diff --git a/README.md b/README.md
index 125561b9d..50e0b55f6 100644
--- a/README.md
+++ b/README.md
@@ -369,7 +369,7 @@ pnpm --filter @edr/passenger-api run prisma:seed
 - 3 User accounts (Admin, Passenger, Agent)
 - Fare rules for ADULT and CHILD passenger categories
 - Currency exchange rates (ETB, DJF, USD)
-- Baggage allowance rules
+- Luggage allowance rules
 - Notification templates
 - Promotions and FAQ content
 - Menu items and station crowd signals
diff --git a/apps/edr-freight-api/src/migrations/2000000000000-CreateCompanyChangeRequest.ts b/apps/edr-freight-api/src/migrations/2000000000000-CreateCompanyChangeRequest.ts
new file mode 100644
index 000000000..9d8d2b5c9
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/2000000000000-CreateCompanyChangeRequest.ts
@@ -0,0 +1,60 @@
+import { MigrationInterface, QueryRunner, Table, TableIndex } from 'typeorm';
+
+/**
+ * Staging table for customer profile edits that require backoffice review. An
+ * already-approved company's settings edits are snapshotted here (Pending)
+ * instead of being written to the live `companies` row; a reviewer approves
+ * (snapshot applied) or rejects with a note (customer amends & resubmits).
+ */
+export class CreateCompanyChangeRequest2000000000000
+  implements MigrationInterface
+{
+  name = 'CreateCompanyChangeRequest2000000000000';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.createTable(
+      new Table({
+        schema: 'freight',
+        name: 'company_change_request',
+        columns: [
+          { name: 'id', type: 'uuid', isPrimary: true, generationStrategy: 'uuid', default: 'gen_random_uuid()' },
+          { name: 'company_id', type: 'uuid' },
+          { name: 'snapshot', type: 'jsonb' },
+          { name: 'documents', type: 'jsonb', isNullable: true },
+          { name: 'status', type: 'varchar', length: '20', default: "'pending'" },
+          { name: 'note', type: 'text', isNullable: true },
+          { name: 'submitted_by', type: 'uuid', isNullable: true },
+          { name: 'submitted_at', type: 'timestamptz', isNullable: true },
+          { name: 'reviewed_by', type: 'uuid', isNullable: true },
+          { name: 'reviewed_at', type: 'timestamptz', isNullable: true },
+          { name: 'created_at', type: 'timestamptz', default: 'now()' },
+          { name: 'updated_at', type: 'timestamptz', default: 'now()' },
+          { name: 'deleted_at', type: 'timestamptz', isNullable: true },
+        ],
+        foreignKeys: [
+          {
+            columnNames: ['company_id'],
+            referencedSchema: 'freight',
+            referencedTableName: 'companies',
+            referencedColumnNames: ['id'],
+            onDelete: 'CASCADE',
+          },
+        ],
+      }),
+      true,
+    );
+
+    await queryRunner.createIndex(
+      'freight.company_change_request',
+      new TableIndex({ name: 'idx_company_change_request_company', columnNames: ['company_id'] }),
+    );
+    await queryRunner.createIndex(
+      'freight.company_change_request',
+      new TableIndex({ name: 'idx_company_change_request_status', columnNames: ['status'] }),
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.dropTable('freight.company_change_request', true);
+  }
+}
diff --git a/apps/edr-freight-api/src/migrations/2000000000001-AddCompanyProfileReview.ts b/apps/edr-freight-api/src/migrations/2000000000001-AddCompanyProfileReview.ts
new file mode 100644
index 000000000..2c2fdf3e1
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/2000000000001-AddCompanyProfileReview.ts
@@ -0,0 +1,28 @@
+import { MigrationInterface, QueryRunner, TableColumn } from 'typeorm';
+
+/**
+ * Adds reviewer note/id/timestamp to company_profiles so a rejected operational
+ * role (new ProfileStatus 'rejected') can carry the reason back to the customer,
+ * who can then amend and reapply.
+ */
+export class AddCompanyProfileReview2000000000001
+  implements MigrationInterface
+{
+  name = 'AddCompanyProfileReview2000000000001';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.addColumns('freight.company_profiles', [
+      new TableColumn({ name: 'review_note', type: 'text', isNullable: true }),
+      new TableColumn({ name: 'reviewed_by', type: 'uuid', isNullable: true }),
+      new TableColumn({ name: 'reviewed_at', type: 'timestamptz', isNullable: true }),
+    ]);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.dropColumns('freight.company_profiles', [
+      'review_note',
+      'reviewed_by',
+      'reviewed_at',
+    ]);
+  }
+}
diff --git a/apps/edr-freight-api/src/migrations/2020000000000-WarehouseCapacityKgToTons.ts b/apps/edr-freight-api/src/migrations/2020000000000-WarehouseCapacityKgToTons.ts
new file mode 100644
index 000000000..333a0f541
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/2020000000000-WarehouseCapacityKgToTons.ts
@@ -0,0 +1,35 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+/**
+ * Weights are tonnes everywhere. Warehouse / yard / zone capacity was stored in
+ * kg (e.g. 25000, 5000, 2500) — convert existing rows to tonnes (÷1000). Cargo
+ * weight (warehouse_inventory.weight ← cargo_total_weight_vgm) is already tonnes
+ * and is NOT touched; truck gross weight has no data yet. Runs exactly once
+ * (tracked by TypeORM) — re-running would divide again.
+ */
+export class WarehouseCapacityKgToTons2020000000000 implements MigrationInterface {
+  name = 'WarehouseCapacityKgToTons2020000000000';
+
+  private readonly tables = ['warehouses', 'warehouse_yards', 'warehouse_zones'];
+  private readonly columns = ['capacity_weight', 'current_weight', 'max_weight'];
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    for (const table of this.tables) {
+      for (const column of this.columns) {
+        await queryRunner.query(
+          `UPDATE freight.${table} SET ${column} = ${column} / 1000.0 WHERE ${column} IS NOT NULL`,
+        );
+      }
+    }
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    for (const table of this.tables) {
+      for (const column of this.columns) {
+        await queryRunner.query(
+          `UPDATE freight.${table} SET ${column} = ${column} * 1000.0 WHERE ${column} IS NOT NULL`,
+        );
+      }
+    }
+  }
+}
diff --git a/apps/edr-freight-api/src/migrations/2040000000000-MigrateLicenseFilesToFileRecords.ts b/apps/edr-freight-api/src/migrations/2040000000000-MigrateLicenseFilesToFileRecords.ts
new file mode 100644
index 000000000..d3720de33
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/2040000000000-MigrateLicenseFilesToFileRecords.ts
@@ -0,0 +1,59 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+/**
+ * Business-license files used to live inline as a jsonb array on
+ * `company_profiles.business_license_files`. They now belong to the FileRecord
+ * model (`freight.files`, resource `company_profiles`, code `business_license`)
+ * so they get stable ids and stream through `GET /api/files/:id` — the same
+ * proxy path regular documents use — instead of broken direct-MinIO URLs.
+ *
+ * This copies each existing inline entry into `freight.files` by reference
+ * (keeping the stored object URL — no bytes are re-uploaded). The original jsonb
+ * column is left intact for rollback safety.
+ */
+export class MigrateLicenseFilesToFileRecords2040000000000
+  implements MigrationInterface
+{
+  name = "MigrateLicenseFilesToFileRecords2040000000000";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      INSERT INTO freight.files
+        (id, resource_id, resource, code, name, url, size, mime_type, created_at, updated_at)
+      SELECT
+        gen_random_uuid(),
+        cp.id,
+        'company_profiles',
+        'business_license',
+        COALESCE(elem->>'name', 'license'),
+        elem->>'url',
+        COALESCE(NULLIF(elem->>'size', '')::int, 0),
+        COALESCE(NULLIF(elem->>'mimeType', ''), 'application/octet-stream'),
+        now(),
+        now()
+      FROM freight.company_profiles cp
+      CROSS JOIN LATERAL jsonb_array_elements(cp.business_license_files) AS elem
+      WHERE cp.business_license_files IS NOT NULL
+        AND jsonb_typeof(cp.business_license_files) = 'array'
+        AND elem->>'url' IS NOT NULL
+        AND NOT EXISTS (
+          SELECT 1 FROM freight.files f
+          WHERE f.resource_id = cp.id
+            AND f.resource = 'company_profiles'
+            AND f.code = 'business_license'
+            AND f.url = elem->>'url'
+            AND f.deleted_at IS NULL
+        );
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    // Reverse the model migration by dropping the license FileRecords. The
+    // original jsonb column was never cleared, so the data still exists there.
+    await queryRunner.query(`
+      DELETE FROM freight.files
+      WHERE resource = 'company_profiles'
+        AND code = 'business_license';
+    `);
+  }
+}
diff --git a/apps/edr-freight-api/src/migrations/2050000000000-AddCustomerTruckContainerLoadedAt.ts b/apps/edr-freight-api/src/migrations/2050000000000-AddCustomerTruckContainerLoadedAt.ts
new file mode 100644
index 000000000..332df2423
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/2050000000000-AddCustomerTruckContainerLoadedAt.ts
@@ -0,0 +1,35 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+/**
+ * Adds customer_truck_containers.loaded_at so an assignment (customer planning
+ * which containers ride which truck) is distinct from the container actually
+ * being loaded. Stage LOADED now requires loaded_at; customer assignment alone
+ * keeps the container at its prior stage (RECEIVED/GRN) with its planned truck
+ * shown. Backfills containers on already-departed trucks (they left loaded).
+ */
+export class AddCustomerTruckContainerLoadedAt2050000000000
+  implements MigrationInterface
+{
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      ALTER TABLE freight.customer_truck_containers
+        ADD COLUMN IF NOT EXISTS loaded_at TIMESTAMPTZ;
+    `);
+
+    await queryRunner.query(`
+      UPDATE freight.customer_truck_containers ctc
+      SET loaded_at = a.departed_at
+      FROM freight.customer_truck_assignments a
+      WHERE a.id = ctc.assignment_id
+        AND a.departed_at IS NOT NULL
+        AND ctc.deleted_at IS NULL
+        AND ctc.loaded_at IS NULL;
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      ALTER TABLE freight.customer_truck_containers DROP COLUMN IF EXISTS loaded_at;
+    `);
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/bookings/bookings.controller.ts b/apps/edr-freight-api/src/modules/bookings/bookings.controller.ts
index 444ac578a..f556751fb 100644
--- a/apps/edr-freight-api/src/modules/bookings/bookings.controller.ts
+++ b/apps/edr-freight-api/src/modules/bookings/bookings.controller.ts
@@ -68,6 +68,8 @@ import { AddCustomerTruckDto } from './dto/add-customer-truck.dto';
 import { DepartCustomerTruckDto } from './dto/depart-customer-truck.dto';
 import { LoadCustomerTruckDto } from './dto/load-customer-truck.dto';
 import { CustomerTruckService } from './customer-truck.service';
+import { FirstMileService } from '../first-mile/first-mile.service';
+import { LastMileService } from '../last-mile/last-mile.service';
 import { GenerateGrnDto } from './dto/generate-grn.dto';
 import { ContainerReceiptService } from './container-receipt.service';
 import { SignContractDto } from './dto/sign-contract.dto';
@@ -81,6 +83,60 @@ import {
   hasFreightPermission,
 } from "../../common/freight-permission.util";
 
+interface MileVehicleSummary {
+  plate: string | null;
+  code: string | null;
+  driverName: string | null;
+  containerNumber: string | null;
+  distanceKm: number | null;
+}
+
+interface MileLegSummary {
+  status: string;
+  exactKm: number | null;
+  remainingPayment: number | null;
+  currency: string;
+  invoiced: boolean;
+  vehicles: MileVehicleSummary[];
+}
+
+/** Trim a first/last-mile record down to a customer-safe operational summary. */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function summarizeMileLeg(rec?: Record<string, any>): MileLegSummary | null {
+  if (!rec) return null;
+  const num = (v: unknown) => (v == null ? null : Number(v));
+  const assignments: Array<Record<string, any>> = rec.vehicleAssignments ?? []; // eslint-disable-line @typescript-eslint/no-explicit-any
+  const currency =
+    rec.vehicle?.currency ??
+    assignments[0]?.vehicle?.currency ??
+    rec.booking?.paymentCurrency ??
+    'ETB';
+  const vehicles: MileVehicleSummary[] = assignments.map((a) => ({
+    plate: a.vehicle?.plateNumber ?? null,
+    code: a.vehicle?.code ?? null,
+    driverName: a.vehicle?.assignedDriverName ?? null,
+    containerNumber: a.containerNumber ?? null,
+    distanceKm: num(a.distanceKm),
+  }));
+  if (!vehicles.length && rec.vehicle) {
+    vehicles.push({
+      plate: rec.vehicle.plateNumber ?? null,
+      code: rec.vehicle.code ?? null,
+      driverName: rec.vehicle.assignedDriverName ?? null,
+      containerNumber: null,
+      distanceKm: num(rec.exactKm),
+    });
+  }
+  return {
+    status: rec.status ?? '',
+    exactKm: num(rec.exactKm),
+    remainingPayment: num(rec.remainingPayment),
+    currency,
+    invoiced: Boolean(rec.invoice),
+    vehicles,
+  };
+}
+
 @ApiTags("bookings")
 @Controller("bookings")
 @ApiBearerAuth()
@@ -94,6 +150,8 @@ export class BookingsController {
     private readonly bookingClearanceService: BookingClearanceService,
     private readonly customerTruckService: CustomerTruckService,
     private readonly containerReceiptService: ContainerReceiptService,
+    private readonly firstMileService: FirstMileService,
+    private readonly lastMileService: LastMileService,
   ) {}
 
   @Post()
@@ -290,6 +348,33 @@ export class BookingsController {
     return this.transitionService.enrichBookingResponse(booking);
   }
 
+  @Get(':id/mile-summary')
+  @ApiOperation({
+    summary: 'First/last-mile operational summary for a booking (customer-safe)',
+  })
+  async mileSummary(
+    @Param('id', ParseUUIDPipe) id: string,
+    @CurrentUser() user: TCurrentUser,
+  ) {
+    // Customers may only see their own booking's mile summary.
+    const booking = await this.bookingsService.findById(id);
+    if (
+      !hasFreightPermission(user, FREIGHT_PERMS.bookings.view) &&
+      !hasFreightPermission(user, FREIGHT_PERMS.bookings.clearanceView)
+    ) {
+      await this.bookingsService.assertCustomerCanAccessBooking(user?.id, booking);
+    }
+
+    const [first, last] = await Promise.all([
+      this.firstMileService.findAll({ bookingId: id, pageSize: 1 }),
+      this.lastMileService.findAll({ bookingId: id, pageSize: 1 }),
+    ]);
+    return {
+      firstMile: summarizeMileLeg(first.data[0]),
+      lastMile: summarizeMileLeg(last.data[0]),
+    };
+  }
+
   @Post(':id/customer-truck-assignment')
   @ApiOperation({ summary: 'Customer assigns external truck and driver for terminal pickup' })
   async assignCustomerTruck(
@@ -350,6 +435,21 @@ export class BookingsController {
     return this.customerTruckService.addTruck(id, dto);
   }
 
+  @Patch(':id/customer-trucks/:assignmentId')
+  @ApiOperation({ summary: 'Edit a not-yet-arrived customer truck (plate/driver/type + containers)' })
+  async updateCustomerTruck(
+    @Param('id', ParseUUIDPipe) id: string,
+    @Param('assignmentId', ParseUUIDPipe) assignmentId: string,
+    @Body() dto: AddCustomerTruckDto,
+    @CurrentUser() user: TCurrentUser,
+  ) {
+    const booking = await this.bookingsService.findById(id);
+    if (!hasFreightPermission(user, FREIGHT_PERMS.bookings.view)) {
+      await this.bookingsService.assertCustomerCanAccessBooking(user?.id, booking);
+    }
+    return this.customerTruckService.updateTruck(id, assignmentId, dto);
+  }
+
   @Delete(':id/customer-trucks/:assignmentId')
   @ApiOperation({ summary: 'Remove a not-yet-arrived customer truck from a booking' })
   async removeCustomerTruck(
diff --git a/apps/edr-freight-api/src/modules/bookings/bookings.module.ts b/apps/edr-freight-api/src/modules/bookings/bookings.module.ts
index 48c5b628b..4b3e3bcca 100644
--- a/apps/edr-freight-api/src/modules/bookings/bookings.module.ts
+++ b/apps/edr-freight-api/src/modules/bookings/bookings.module.ts
@@ -12,6 +12,7 @@ import { FileUploadSettingsModule } from '../file-upload-settings/file-upload-se
 import { SignaturesModule } from '../signatures/signatures.module';
 import { BillingModule } from '../billing/billing.module';
 import { FirstMileModule } from '../first-mile/first-mile.module';
+import { LastMileModule } from '../last-mile/last-mile.module';
 import { BookingContractService } from './booking-contract.service';
 import { BookingInvoiceService } from './booking-invoice.service';
 // import { BookingPaymentController } from './booking-payment.controller';
@@ -70,6 +71,7 @@ import { VehiclesModule } from "../vehicles/vehicles.module";
     NotificationsModule,
     NotificationInboxModule,
     forwardRef(() => FirstMileModule),
+    forwardRef(() => LastMileModule),
     forwardRef(() => TrainSchedulingModule),
     forwardRef(() => ContractsModule),
     forwardRef(() => ContractsModule),
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 a5f25ad21..48a29988a 100644
--- a/apps/edr-freight-api/src/modules/bookings/bookings.service.ts
+++ b/apps/edr-freight-api/src/modules/bookings/bookings.service.ts
@@ -1424,6 +1424,20 @@ export class BookingsService {
         schedule?.status ?? null;
     }
 
+    // A generated-but-unsigned SELF_HAUL handover means the customer must approve
+    // delivery from the portal (booking-based, one per booking). EDR last-mile
+    // handovers are per delivering truck and signed by the receiver at the door,
+    // so they never surface the portal "Approve delivery" action.
+    const [pendingHandover] = await this.dataSource.query(
+      `SELECT 1 FROM freight.booking_handovers
+        WHERE booking_id = $1 AND signed_at IS NULL AND deleted_at IS NULL
+          AND mile_type = 'SELF_HAUL'
+        LIMIT 1`,
+      [id],
+    );
+    (booking as Booking & { handoverAwaitingSignature?: boolean }).handoverAwaitingSignature =
+      Boolean(pendingHandover);
+
     return booking;
   }
 
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 6f0ec6f55..4e364a03a 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
@@ -42,21 +42,30 @@ export class CustomerTruckService {
     const booking = await this.loadBookingGuard(bookingId);
     this.assertSelfHaulPaid(booking);
 
-    const isExport = booking.tradeDirection === 'EXPORT';
     const requested = (dto.containerNumbers ?? []).map((n) => n.trim().toUpperCase());
 
-    // EXPORT: the truck delivers 1–2 known containers. IMPORT: containers are
-    // not pre-specified — they are registered + weighed when the truck leaves.
-    if (isExport) {
-      if (requested.length < 1 || requested.length > 2) {
-        throw new BadRequestException('An export truck must carry 1 or 2 of the booking containers');
-      }
-    } else if (requested.length > 2) {
+    // 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) {
+      throw new BadRequestException('Select at least one container for this truck');
+    }
+    if (requested.length > 2) {
       throw new BadRequestException('A truck carries at most 2 containers');
     }
 
     if (requested.length) {
       const bookingNumbers = await this.bookingContainerNumbers(bookingId);
+      // Never assign more trucks than the booking has containers.
+      const existingTrucks = await this.dataSource
+        .getRepository(CustomerTruckAssignment)
+        .count({ where: { bookingId } });
+      if (existingTrucks + 1 > bookingNumbers.length) {
+        throw new BadRequestException(
+          `Cannot assign more trucks than containers — this booking has ${bookingNumbers.length} container(s) and ${existingTrucks} truck(s) already assigned.`,
+        );
+      }
       for (const n of requested) {
         if (!bookingNumbers.includes(n)) {
           throw new BadRequestException(`Container ${n} is not one of this booking's containers`);
@@ -68,6 +77,13 @@ export class CustomerTruckService {
           throw new ConflictException(`Container ${n} is already loaded onto another truck`);
         }
       }
+      // Size cap: a 40ft container fills the truck.
+      const sizes = await this.containerSizes(bookingId, requested);
+      if (sizes.some((s) => s.includes('40')) && requested.length > 1) {
+        throw new BadRequestException(
+          'A 40ft container fills the truck — assign only 1 container to this truck',
+        );
+      }
     }
 
     await this.dataSource.transaction(async (manager) => {
@@ -133,6 +149,76 @@ export class CustomerTruckService {
     return this.listTrucks(bookingId);
   }
 
+  /**
+   * Edit a truck assignment — plate/driver/type and the containers it carries.
+   * Allowed only until the truck has arrived (same guard as removal). Container
+   * rules mirror {@link addTruck}: 1–2 of the booking's containers, none already
+   * on another truck, and a 40ft container fills the truck (max 1).
+   */
+  async updateTruck(
+    bookingId: string,
+    assignmentId: string,
+    dto: AddCustomerTruckDto,
+  ): Promise<CustomerTruckAssignment[]> {
+    const booking = await this.loadBookingGuard(bookingId);
+    this.assertSelfHaulPaid(booking);
+
+    const assignment = await this.assignments.findByIdWithContainers(assignmentId);
+    if (!assignment || assignment.bookingId !== bookingId) {
+      throw new NotFoundException('Truck assignment not found for this booking');
+    }
+    if (assignment.arrivedAt) {
+      throw new ConflictException('Cannot edit a truck that has already arrived');
+    }
+
+    const requested = (dto.containerNumbers ?? []).map((n) => n.trim().toUpperCase());
+    if (requested.length < 1) {
+      throw new BadRequestException('Select at least one container for this truck');
+    }
+    if (requested.length > 2) {
+      throw new BadRequestException('A truck carries at most 2 containers');
+    }
+    const bookingNumbers = await this.bookingContainerNumbers(bookingId);
+    for (const n of requested) {
+      if (!bookingNumbers.includes(n)) {
+        throw new BadRequestException(`Container ${n} is not one of this booking's containers`);
+      }
+    }
+    // Exclude THIS truck's own containers so re-saving the same set is allowed.
+    const assignedElsewhere = await this.assignedContainerNumbersExcept(bookingId, assignmentId);
+    for (const n of requested) {
+      if (assignedElsewhere.includes(n)) {
+        throw new ConflictException(`Container ${n} is already loaded onto another truck`);
+      }
+    }
+    const sizes = await this.containerSizes(bookingId, requested);
+    if (sizes.some((s) => s.includes('40')) && requested.length > 1) {
+      throw new BadRequestException(
+        'A 40ft container fills the truck — assign only 1 container to this truck',
+      );
+    }
+
+    await this.dataSource.transaction(async (manager) => {
+      await manager.getRepository(CustomerTruckAssignment).update(assignmentId, {
+        plateNumber: dto.truckPlateNumber.trim().toUpperCase(),
+        driverName: dto.driverName.trim(),
+        truckType: dto.truckType.trim(),
+      });
+      await manager.getRepository(CustomerTruckContainer).softDelete({ assignmentId });
+      await manager.getRepository(CustomerTruckContainer).save(
+        requested.map((containerNumber) =>
+          manager.getRepository(CustomerTruckContainer).create({
+            assignmentId,
+            bookingId,
+            containerNumber,
+          }),
+        ),
+      );
+    });
+
+    return this.listTrucks(bookingId);
+  }
+
   /**
    * Register an IMPORT self-haul truck leaving the port: the containers it
    * actually loaded (replacing any provisional list) and its weighed gross.
@@ -226,6 +312,13 @@ export class CustomerTruckService {
     if (assignment.departedAt) {
       throw new ConflictException('This truck has already left — its load is locked');
     }
+    // Containers can only be loaded after the truck has physically arrived at the
+    // warehouse (arrival weighing recorded). Assignment alone is just planning.
+    if (!assignment.arrivedAt) {
+      throw new BadRequestException(
+        'Record the truck arrival before loading — containers can only be loaded onto an arrived truck',
+      );
+    }
 
     const requested = (dto.containerNumbers ?? []).map((n) => n.trim().toUpperCase());
     if (!requested.length) {
@@ -244,30 +337,35 @@ export class CustomerTruckService {
       }
     }
 
-    const grossKg = await this.vgmKgForContainers(bookingId, requested);
+    const grossTons = await this.vgmTonsForContainers(bookingId, requested);
     await this.dataSource.transaction(async (manager) => {
       await manager.getRepository(CustomerTruckContainer).softDelete({ assignmentId });
+      // Operator loading the truck: stamp loaded_at so these containers move to
+      // the LOADED stage (customer assignment alone leaves loaded_at null).
+      const loadedAt = new Date();
       await manager.getRepository(CustomerTruckContainer).save(
         requested.map((containerNumber) =>
           manager.getRepository(CustomerTruckContainer).create({
             assignmentId,
             bookingId,
             containerNumber,
+            loadedAt,
           }),
         ),
       );
-      // Provisional gross from the loaded containers' VGM — overridden by the
-      // weighed gross on departure.
+      // Provisional gross (tonnes) from the loaded containers' VGM — overridden
+      // by the weighed gross on departure. (Column is *_kg but holds tonnes.)
       await manager.getRepository(CustomerTruckAssignment).update(assignmentId, {
-        grossWeightKg: grossKg,
+        grossWeightKg: grossTons,
       });
     });
     return this.listTrucks(bookingId);
   }
 
-  private async vgmKgForContainers(bookingId: string, numbers: string[]): Promise<number> {
-    const [row]: Array<{ kg: string }> = await this.dataSource.query(
-      `SELECT COALESCE(SUM(bcu.vgm_tons), 0) * 1000 AS kg
+  /** Summed VGM (tonnes) of the given containers — provisional truck gross. */
+  private async vgmTonsForContainers(bookingId: string, numbers: string[]): Promise<number> {
+    const [row]: Array<{ tons: string }> = await this.dataSource.query(
+      `SELECT COALESCE(SUM(bcu.vgm_tons), 0) AS tons
          FROM freight.booking_container_units bcu
          JOIN freight.booking_container bc
            ON bc.id = bcu.booking_container_id AND bc.deleted_at IS NULL
@@ -276,7 +374,7 @@ export class CustomerTruckService {
           AND bcu.deleted_at IS NULL`,
       [bookingId, numbers],
     );
-    return Number(row?.kg ?? 0);
+    return Number(row?.tons ?? 0);
   }
 
   /**
@@ -399,4 +497,20 @@ export class CustomerTruckService {
     );
     return rows.map((r) => r.containerNumber.trim().toUpperCase());
   }
+
+  /** Contract container sizes (e.g. "20ft" / "40ft") for the given container numbers. */
+  private async containerSizes(bookingId: string, numbers: string[]): Promise<string[]> {
+    if (!numbers.length) return [];
+    const rows: Array<{ size: string | null }> = await this.dataSource.query(
+      `SELECT bc.container_size AS "size"
+         FROM freight.booking_container_units bcu
+         JOIN freight.booking_container bc
+           ON bc.id = bcu.booking_container_id AND bc.deleted_at IS NULL
+        WHERE bc.booking_id = $1
+          AND UPPER(bcu.container_number) = ANY($2)
+          AND bcu.deleted_at IS NULL`,
+      [bookingId, numbers],
+    );
+    return rows.map((r) => (r.size ?? '').trim());
+  }
 }
diff --git a/apps/edr-freight-api/src/modules/bookings/entities/customer-truck-container.entity.ts b/apps/edr-freight-api/src/modules/bookings/entities/customer-truck-container.entity.ts
index 110e31671..8b6ecc8b9 100644
--- a/apps/edr-freight-api/src/modules/bookings/entities/customer-truck-container.entity.ts
+++ b/apps/edr-freight-api/src/modules/bookings/entities/customer-truck-container.entity.ts
@@ -23,4 +23,12 @@ export class CustomerTruckContainer extends BaseEntity {
 
   @Column({ name: 'container_number', type: 'varchar', length: 64 })
   containerNumber!: string;
+
+  /**
+   * When the container was actually loaded onto the truck by the operator.
+   * Null = customer-assigned (planned) but not yet loaded. Stage LOADED requires
+   * this to be set, so customer assignment alone does not mark a container loaded.
+   */
+  @Column({ name: 'loaded_at', type: 'timestamptz', nullable: true })
+  loadedAt?: Date | null;
 }
diff --git a/apps/edr-freight-api/src/modules/companies/companies.controller.ts b/apps/edr-freight-api/src/modules/companies/companies.controller.ts
index b1761b35f..f8fbb26b0 100644
--- a/apps/edr-freight-api/src/modules/companies/companies.controller.ts
+++ b/apps/edr-freight-api/src/modules/companies/companies.controller.ts
@@ -12,6 +12,7 @@ import {
   HttpStatus,
   UseInterceptors,
   UploadedFiles,
+  BadRequestException,
 } from "@nestjs/common";
 import { AnyFilesInterceptor } from "@nestjs/platform-express";
 import { ApiOperation, ApiTags, ApiConsumes } from "@nestjs/swagger";
@@ -33,7 +34,7 @@ import {
   ResponseCompanyDto,
   ResponseCompanyProfileDto,
 } from "./dto/response-company.dto";
-import { BusinessLicenseFile } from "./entities/company-profile.entity";
+import { ProfileLicenseFileView } from "./entities/company-profile.entity";
 import { ResponseExternalProfileDto } from "./dto/response-external-profile.dto";
 import { CompanyInfoResponseDto } from "./dto/company-info-response.dto";
 import { UpdateProfileDto } from "./dto/update-profile.dto";
@@ -43,6 +44,8 @@ import { ListCompaniesQueryDto } from "./dto/list-companies-query.dto";
 import { CompanyStatsResponseDto } from "./dto/company-stats-response.dto";
 import { OnboardingRequirementsResponseDto } from "./dto/onboarding-requirements-response.dto";
 import { UpdateCompanyProfileStatusDto } from "./dto/update-company-profile-status.dto";
+import { RejectChangeRequestDto } from "./dto/reject-change-request.dto";
+import { ChangeRequestResponseDto } from "./dto/change-request-response.dto";
 import { FetchETradeDto } from "./dto/fetch-etrade.dto";
 import { ETradeResponseDto } from "./dto/etrade-response.dto";
 
@@ -61,6 +64,25 @@ export class CompaniesController {
     private readonly filesService: FilesService,
   ) { }
 
+  /**
+   * License files are FileRecord-backed and previewed through `GET /api/files/:id`
+   * (the client builds that URL from the returned `id`). Populate each profile
+   * DTO's `licenseFiles` with its live/pending files in one batched lookup.
+   */
+  private async populateLicenseFiles(
+    companyId: string,
+    profiles: { id: string; licenseFiles: ProfileLicenseFileView[] }[],
+  ): Promise<void> {
+    if (profiles.length === 0) return;
+    const byProfile = await this.companiesService.assembleLicenseFilesByProfile(
+      companyId,
+      profiles.map((p) => p.id),
+    );
+    for (const p of profiles) {
+      p.licenseFiles = byProfile[p.id] ?? [];
+    }
+  }
+
   @Get("getInfo")
   @ApiOperation({ summary: "Get company info for the current user" })
   async getInfo(
@@ -68,7 +90,10 @@ export class CompaniesController {
   ): Promise<CompanyInfoResponseDto> {
     const { profile, company } =
       await this.companiesService.getCompanyInfoByUserId(user.id);
-    return new CompanyInfoResponseDto(profile, company);
+    const review = await this.companiesService.getOpenChangeRequestForCompany(
+      company.id,
+    );
+    return new CompanyInfoResponseDto(profile, company, review);
   }
 
   @Get("profile")
@@ -78,7 +103,42 @@ export class CompaniesController {
   ): Promise<ProfileResponseDto> {
     const { profile, company } =
       await this.companiesService.getCompanyInfoByUserId(user.id);
-    return new ProfileResponseDto(profile, company);
+    const review = await this.companiesService.getOpenChangeRequestForCompany(
+      company.id,
+    );
+    const dto = new ProfileResponseDto(profile, company, review);
+    await this.populateLicenseFiles(company.id, dto.companyProfiles);
+    return dto;
+  }
+
+  @Get("profile/change-request")
+  @ApiOperation({
+    summary: "Current user's open profile change request (pending/rejected)",
+  })
+  async getMyChangeRequest(
+    @CurrentUser() user: CurrentIamUser,
+  ): Promise<ChangeRequestResponseDto | null> {
+    const { company } =
+      await this.companiesService.getCompanyInfoByUserId(user.id);
+    const review = await this.companiesService.getOpenChangeRequestForCompany(
+      company.id,
+    );
+    return review ? new ChangeRequestResponseDto(review) : null;
+  }
+
+  @Post("company-profiles/:profileId/reapply")
+  @ApiOperation({
+    summary: "Resubmit a rejected operational role for approval (→ pending)",
+  })
+  async reapplyCompanyProfile(
+    @CurrentUser() user: CurrentIamUser,
+    @Param("profileId", ParseUUIDPipe) profileId: string,
+  ): Promise<ResponseCompanyProfileDto> {
+    const profile = await this.companiesService.reapplyCompanyProfile(
+      user.id,
+      profileId,
+    );
+    return new ResponseCompanyProfileDto(profile);
   }
 
   @Get("dashboard")
@@ -177,28 +237,72 @@ export class CompaniesController {
   @ApiConsumes("multipart/form-data")
   @ApiOperation({
     summary:
-      "Upload business-license document(s) for one of the current user's company profiles",
+      "Add business-license document(s) to a profile. For an approved company " +
+      "the upload is staged for backoffice review; during onboarding it goes live.",
   })
   async uploadProfileLicense(
     @CurrentUser() user: CurrentIamUser,
     @Param("profileId", ParseUUIDPipe) profileId: string,
     @UploadedFiles() files: Array<Express.Multer.File>,
-  ): Promise<BusinessLicenseFile[]> {
-    return this.companiesService.uploadProfileLicenseFiles(
+  ): Promise<ProfileLicenseFileView[]> {
+    return this.companiesService.addProfileLicenseFiles(
       user.id,
       profileId,
       files,
     );
   }
 
+  @Post("company-profiles/:profileId/license/:fileId/replace")
+  @UseInterceptors(AnyFilesInterceptor())
+  @ApiConsumes("multipart/form-data")
+  @ApiOperation({
+    summary:
+      "Replace a business-license file with a newly uploaded one (staged for " +
+      "review on an approved company).",
+  })
+  async replaceProfileLicense(
+    @CurrentUser() user: CurrentIamUser,
+    @Param("profileId", ParseUUIDPipe) profileId: string,
+    @Param("fileId", ParseUUIDPipe) fileId: string,
+    @UploadedFiles() files: Array<Express.Multer.File>,
+  ): Promise<ProfileLicenseFileView[]> {
+    const file = files?.[0];
+    if (!file) {
+      throw new BadRequestException("A replacement file is required");
+    }
+    return this.companiesService.replaceProfileLicenseFile(
+      user.id,
+      profileId,
+      fileId,
+      file,
+    );
+  }
+
+  @Delete("company-profiles/:profileId/license/:fileId")
+  @ApiOperation({
+    summary:
+      "Remove a business-license file (staged for review on an approved company).",
+  })
+  async removeProfileLicense(
+    @CurrentUser() user: CurrentIamUser,
+    @Param("profileId", ParseUUIDPipe) profileId: string,
+    @Param("fileId", ParseUUIDPipe) fileId: string,
+  ): Promise<ProfileLicenseFileView[]> {
+    return this.companiesService.removeProfileLicenseFile(
+      user.id,
+      profileId,
+      fileId,
+    );
+  }
+
   @Get("company-profiles/:profileId/license")
   @ApiOperation({
-    summary: "List business-license documents for a company profile",
+    summary: "List business-license documents (with review state) for a profile",
   })
   async listProfileLicense(
     @CurrentUser() user: CurrentIamUser,
     @Param("profileId", ParseUUIDPipe) profileId: string,
-  ): Promise<BusinessLicenseFile[]> {
+  ): Promise<ProfileLicenseFileView[]> {
     return this.companiesService.listProfileLicenseFiles(user.id, profileId);
   }
 
@@ -306,7 +410,9 @@ export class CompaniesController {
     @Param("id", ParseUUIDPipe) id: string,
   ): Promise<ResponseCompanyDto> {
     const company = await this.companiesService.findCompanyById(id);
-    return new ResponseCompanyDto(company);
+    const dto = new ResponseCompanyDto(company);
+    await this.populateLicenseFiles(company.id, dto.companyProfiles ?? []);
+    return dto;
   }
 
   @Patch(":id")
@@ -354,26 +460,76 @@ export class CompaniesController {
   @ApiConsumes("multipart/form-data")
   @ApiOperation({ summary: "Upload documents for a company (onboarding)" })
   async uploadDocuments(
+    @CurrentUser() user: CurrentIamUser,
     @Param("companyId", ParseUUIDPipe) companyId: string,
     @UploadedFiles() files: Array<Express.Multer.File>,
   ) {
-    return this.filesService.uploadMany(companyId, "companies", files);
+    // Routed through the service so an approved company's uploads are staged for
+    // review (and lock the customer), while onboarding uploads pass straight through.
+    return this.companiesService.uploadCompanyDocuments(companyId, files, user.id);
   }
 
   @Patch("company-profiles/:profileId/status")
   @FreightAdmin()
   @ApiOperation({ summary: "Update a company profile's approval status" })
   async updateCompanyProfileStatus(
+    @CurrentUser() user: CurrentIamUser,
     @Param("profileId", ParseUUIDPipe) profileId: string,
     @Body() dto: UpdateCompanyProfileStatusDto,
   ): Promise<ResponseCompanyProfileDto> {
     const profile = await this.companiesService.setCompanyProfileStatus(
       profileId,
       dto.status,
+      dto.note,
+      user.id,
     );
     return new ResponseCompanyProfileDto(profile);
   }
 
+  @Get(":companyId/change-requests")
+  @FreightAdmin()
+  @ApiOperation({ summary: "List a company's profile change requests" })
+  async listChangeRequests(
+    @Param("companyId", ParseUUIDPipe) companyId: string,
+  ): Promise<ChangeRequestResponseDto[]> {
+    const requests = await this.companiesService.listChangeRequests(companyId);
+    return requests.map((r) => new ChangeRequestResponseDto(r));
+  }
+
+  @Post("change-requests/:id/approve")
+  @FreightAdmin()
+  @ApiOperation({
+    summary: "Approve a pending profile change request (applies the changes)",
+  })
+  async approveChangeRequest(
+    @CurrentUser() user: CurrentIamUser,
+    @Param("id", ParseUUIDPipe) id: string,
+  ): Promise<ChangeRequestResponseDto> {
+    const request = await this.companiesService.approveChangeRequest(
+      id,
+      user.id,
+    );
+    return new ChangeRequestResponseDto(request);
+  }
+
+  @Post("change-requests/:id/reject")
+  @FreightAdmin()
+  @ApiOperation({
+    summary: "Reject a pending profile change request with a note",
+  })
+  async rejectChangeRequest(
+    @CurrentUser() user: CurrentIamUser,
+    @Param("id", ParseUUIDPipe) id: string,
+    @Body() dto: RejectChangeRequestDto,
+  ): Promise<ChangeRequestResponseDto> {
+    const request = await this.companiesService.rejectChangeRequest(
+      id,
+      dto.note,
+      user.id,
+    );
+    return new ChangeRequestResponseDto(request);
+  }
+
   @Post(":companyId/profiles")
   @FreightAdmin()
   @ApiOperation({ summary: "Add a profile (employee) to a company" })
diff --git a/apps/edr-freight-api/src/modules/companies/companies.module.ts b/apps/edr-freight-api/src/modules/companies/companies.module.ts
index 42186dd8e..646d01d47 100644
--- a/apps/edr-freight-api/src/modules/companies/companies.module.ts
+++ b/apps/edr-freight-api/src/modules/companies/companies.module.ts
@@ -12,13 +12,21 @@ import { CompanyDashboardRepository } from "./company-dashboard.repository";
 import { Company } from "./entities/company.entity";
 import { ExternalProfile } from "./entities/external-profile.entity";
 import { CompanyProfile } from "./entities/company-profile.entity";
+import { CompanyChangeRequest } from "./entities/company-change-request.entity";
 import { Booking } from "../bookings/entities/booking.entity";
 import { CompanyProfileRepository } from "./company-profile.repository";
+import { CompanyChangeRequestRepository } from "./company-change-request.repository";
 import { ETradeService } from "./services/etrade.service";
 
 @Module({
   imports: [
-    TypeOrmModule.forFeature([Company, ExternalProfile, CompanyProfile, Booking]),
+    TypeOrmModule.forFeature([
+      Company,
+      ExternalProfile,
+      CompanyProfile,
+      CompanyChangeRequest,
+      Booking,
+    ]),
     HttpModule,
     FilesModule,
     FileUploadSettingsModule,
@@ -30,6 +38,7 @@ import { ETradeService } from "./services/etrade.service";
     CompaniesRepository,
     ExternalProfileRepository,
     CompanyProfileRepository,
+    CompanyChangeRequestRepository,
     CompanyDashboardRepository,
     ETradeService,
   ],
diff --git a/apps/edr-freight-api/src/modules/companies/companies.service.ts b/apps/edr-freight-api/src/modules/companies/companies.service.ts
index fe679627b..e31851aef 100644
--- a/apps/edr-freight-api/src/modules/companies/companies.service.ts
+++ b/apps/edr-freight-api/src/modules/companies/companies.service.ts
@@ -7,13 +7,14 @@ import {
 } from "@nestjs/common";
 import { CompaniesRepository } from "./companies.repository";
 import { CompanyProfileRepository } from "./company-profile.repository";
+import { CompanyChangeRequestRepository } from "./company-change-request.repository";
 import { ExternalProfileRepository } from "./external-profile.repository";
 import {
   CompanyDashboardRepository,
   DashboardScope,
 } from "./company-dashboard.repository";
-import { MinioService } from "../minio/minio.service";
 import { FilesService } from "../files/files.service";
+import { FileRecord } from "../files/entities/file.entity";
 import { FileUploadSettingsService } from "../file-upload-settings/file-upload-settings.service";
 import { ETradeService } from "./services/etrade.service";
 import { OnboardingRequirementsResponseDto } from "./dto/onboarding-requirements-response.dto";
@@ -37,9 +38,21 @@ import { ExternalProfile } from "./entities/external-profile.entity";
 import {
   BusinessLicenseFile,
   CompanyProfile,
+  ProfileLicenseFileView,
   ProfileType,
   ProfileStatus,
 } from "./entities/company-profile.entity";
+import {
+  ChangeRequestStatus,
+  CompanyChangeRequest,
+  LicenseChangeIntent,
+} from "./entities/company-change-request.entity";
+
+/** FileRecord `resource` + `code` slots for business-license documents. */
+const LICENSE_RESOURCE = "company_profiles";
+const LICENSE_CODE = "business_license";
+/** Code for a license file staged in an open change request (not yet live). */
+const LICENSE_PENDING_CODE = "business_license_pending";
 
 export interface UserIdentity {
   userId: string;
@@ -54,9 +67,9 @@ export class CompaniesService {
   constructor(
     private readonly companiesRepo: CompaniesRepository,
     private readonly companyProfilesRepo: CompanyProfileRepository,
+    private readonly changeRequestRepo: CompanyChangeRequestRepository,
     private readonly profilesRepo: ExternalProfileRepository,
     private readonly dashboardRepo: CompanyDashboardRepository,
-    private readonly minioService: MinioService,
     private readonly filesService: FilesService,
     private readonly fileUploadSettingsService: FileUploadSettingsService,
     private readonly etradeService: ETradeService,
@@ -334,28 +347,9 @@ export class CompaniesService {
     const company = await this.companiesRepo.findById(id);
     if (!company) throw new NotFoundException(`Company ${id} not found`);
     company.companyProfiles = await this.companyProfilesRepo.findByCompanyId(id);
-    for (const profile of company.companyProfiles) {
-      profile.businessLicenseFiles = await this.signLicenseFiles(
-        profile.businessLicenseFiles,
-      );
-    }
     return company;
   }
 
-  /**
-   * Business-license files are stored as raw, unsigned MinIO URLs (see
-   * `BusinessLicenseFile` on `CompanyProfile`) — a browser can't fetch them
-   * directly. Sign each one with a short-lived URL before it reaches a response.
-   */
-  private async signLicenseFiles(
-    files?: BusinessLicenseFile[] | null,
-  ): Promise<BusinessLicenseFile[]> {
-    if (!files?.length) return [];
-    return Promise.all(
-      files.map(async (f) => ({ ...f, url: await this.filesService.signUrl(f.url) })),
-    );
-  }
-
   /**
    * Validate an explicitly-chosen company profile for a booking: it must belong
    * to the booking's company and be Active. Used for government bookings (staff
@@ -574,12 +568,24 @@ export class CompaniesService {
     return updated;
   }
 
-  async updateProfile(
-    userId: string,
-    dto: UpdateProfileDto,
-  ): Promise<ProfileResponseDto> {
-    const { profile, company } = await this.getCompanyInfoByUserId(userId);
+  /** Keep only the keys that were actually provided (drop `undefined`). */
+  private pickDefined(dto: Record<string, any>): Record<string, any> {
+    const out: Record<string, any> = {};
+    for (const [k, v] of Object.entries(dto)) {
+      if (v !== undefined) out[k] = v;
+    }
+    return out;
+  }
 
+  /**
+   * Translate an UpdateProfileDto (or a staged change-request snapshot) into a
+   * `Company` patch: scalar columns plus a merged `attributes` blob (contact/GM/
+   * PoA live there). Pure — the caller runs the async TIN-uniqueness check.
+   */
+  private mapProfileDtoToCompanyUpdates(
+    company: Company,
+    dto: Partial<UpdateProfileDto>,
+  ): Record<string, any> {
     const companyUpdates: Record<string, any> = {};
     const attrUpdates: Record<string, any> = { ...(company.attributes ?? {}) };
 
@@ -593,21 +599,10 @@ export class CompaniesService {
       companyUpdates.country = dto.companyLocation;
     if (dto.companyAddress !== undefined)
       companyUpdates.address = dto.companyAddress;
-    if (dto.tin !== undefined && dto.tin !== company.tin) {
-      // Reject a TIN already taken by a different company (the user's own draft
-      // placeholder is fine to overwrite).
-      const owner = await this.companiesRepo.findByTin(dto.tin);
-      if (owner && owner.id !== company.id) {
-        throw new ConflictException(
-          `This TIN (${dto.tin}) is already registered to another company. Please check the number and try again.`,
-        );
-      }
+    if (dto.tin !== undefined && dto.tin !== company.tin)
       companyUpdates.tin = dto.tin;
-    }
     if (dto.vatNumber !== undefined) companyUpdates.vatNumber = dto.vatNumber;
-    if (dto.fanNumber !== undefined) {
-      companyUpdates.fanNumber = dto.fanNumber;
-    }
+    if (dto.fanNumber !== undefined) companyUpdates.fanNumber = dto.fanNumber;
 
     if (dto.contactPersonName !== undefined)
       attrUpdates.contactPersonName = dto.contactPersonName;
@@ -629,8 +624,7 @@ export class CompaniesService {
     if (dto.poaPhone !== undefined)
       attrUpdates.poaPhone = normalizeE164(dto.poaPhone);
     if (dto.poaEmail !== undefined) attrUpdates.poaEmail = dto.poaEmail;
-    if (dto.poaLocation !== undefined)
-      attrUpdates.poaLocation = dto.poaLocation;
+    if (dto.poaLocation !== undefined) attrUpdates.poaLocation = dto.poaLocation;
     if (dto.poaAddress !== undefined) attrUpdates.poaAddress = dto.poaAddress;
 
     if (dto.licenceNumber !== undefined)
@@ -653,11 +647,219 @@ export class CompaniesService {
       companyUpdates.etradePhone = normalizeE164(dto.etradePhone);
 
     companyUpdates.attributes = attrUpdates;
+    return companyUpdates;
+  }
 
-    const updated = await this.companiesRepo.update(company.id, companyUpdates);
-    if (!updated)
-      throw new NotFoundException(`Company ${company.id} not found`);
-    return new ProfileResponseDto(profile, updated);
+  /** Reject a TIN already registered to a *different* company. */
+  private async assertTinAvailable(
+    company: Company,
+    tin: string | undefined,
+  ): Promise<void> {
+    if (tin === undefined || tin === company.tin) return;
+    const owner = await this.companiesRepo.findByTin(tin);
+    if (owner && owner.id !== company.id) {
+      throw new ConflictException(
+        `This TIN (${tin}) is already registered to another company. Please check the number and try again.`,
+      );
+    }
+  }
+
+  /** The company's open (pending or last-rejected) profile change request. */
+  async getOpenChangeRequestForCompany(
+    companyId: string,
+  ): Promise<CompanyChangeRequest | null> {
+    return this.changeRequestRepo.findLatestOpenByCompanyId(companyId);
+  }
+
+  /**
+   * Update the current user's profile.
+   *
+   * - Company not yet approved (onboarding) → write straight to the Company row,
+   *   as before. The company/role pending→approve gate already covers first-run.
+   * - Company already `active` → do NOT touch the live Company. Stage the edit in
+   *   a pending change request (merging into any open one) so a backoffice
+   *   reviewer can approve (apply) or reject (with a note). This locks the
+   *   customer until the review resolves.
+   */
+  async updateProfile(
+    userId: string,
+    dto: UpdateProfileDto,
+  ): Promise<ProfileResponseDto> {
+    const { profile, company } = await this.getCompanyInfoByUserId(userId);
+
+    if (company.status !== CompanyStatus.Active) {
+      await this.assertTinAvailable(company, dto.tin);
+      const companyUpdates = this.mapProfileDtoToCompanyUpdates(company, dto);
+      const updated = await this.companiesRepo.update(
+        company.id,
+        companyUpdates,
+      );
+      if (!updated)
+        throw new NotFoundException(`Company ${company.id} not found`);
+      return new ProfileResponseDto(profile, updated);
+    }
+
+    // Approved company: stage the change for review, leaving the live row intact.
+    await this.assertTinAvailable(company, dto.tin);
+    const fields = this.pickDefined(dto);
+
+    const existing = await this.changeRequestRepo.findPendingByCompanyId(
+      company.id,
+    );
+    const now = new Date();
+    let request: CompanyChangeRequest;
+    if (existing) {
+      request =
+        (await this.changeRequestRepo.update(existing.id, {
+          snapshot: { ...(existing.snapshot ?? {}), ...fields },
+          submittedBy: userId,
+          submittedAt: now,
+          note: null,
+        })) ?? existing;
+    } else {
+      request = await this.changeRequestRepo.create({
+        companyId: company.id,
+        snapshot: fields,
+        status: ChangeRequestStatus.Pending,
+        submittedBy: userId,
+        submittedAt: now,
+      });
+    }
+
+    // Live company is unchanged; surface the pending state for the settings page.
+    return new ProfileResponseDto(profile, company, request);
+  }
+
+  /** List a company's change requests, newest first (backoffice review). */
+  async listChangeRequests(
+    companyId: string,
+  ): Promise<CompanyChangeRequest[]> {
+    await this.findCompanyById(companyId);
+    return this.changeRequestRepo.findByCompanyId(companyId);
+  }
+
+  /**
+   * Approve a pending change request: apply its snapshot to the live Company and
+   * mark the request approved. Any staged documents are already attached to the
+   * company, so nothing else needs promoting.
+   */
+  async approveChangeRequest(
+    id: string,
+    reviewerId?: string,
+  ): Promise<CompanyChangeRequest> {
+    const request = await this.changeRequestRepo.findById(id);
+    if (!request)
+      throw new NotFoundException(`Change request ${id} not found`);
+    if (request.status !== ChangeRequestStatus.Pending) {
+      throw new BadRequestException(
+        `Change request ${id} is already ${request.status}`,
+      );
+    }
+
+    const company = await this.companiesRepo.findById(request.companyId);
+    if (!company)
+      throw new NotFoundException(`Company ${request.companyId} not found`);
+
+    const snapshot = (request.snapshot ?? {}) as Partial<UpdateProfileDto>;
+    await this.assertTinAvailable(company, snapshot.tin);
+    const companyUpdates = this.mapProfileDtoToCompanyUpdates(company, snapshot);
+    await this.companiesRepo.update(company.id, companyUpdates);
+    await this.applyLicenseChanges(request);
+
+    return (
+      (await this.changeRequestRepo.update(id, {
+        status: ChangeRequestStatus.Approved,
+        reviewedBy: reviewerId ?? null,
+        reviewedAt: new Date(),
+        note: null,
+      })) ?? request
+    );
+  }
+
+  /**
+   * Upload company documents. For an approved company this also opens/updates a
+   * pending change request (recording the uploaded file ids) so the upload is
+   * reviewed and the customer is locked until it clears — consistent with the
+   * field-edit review. During onboarding (company not yet active) it's a plain
+   * upload with no review.
+   */
+  async uploadCompanyDocuments(
+    companyId: string,
+    files: Express.Multer.File[],
+    submittedBy?: string,
+  ): Promise<FileRecord[]> {
+    const company = await this.findCompanyById(companyId);
+    const uploaded = await this.filesService.uploadMany(
+      companyId,
+      "companies",
+      files,
+    );
+    if (company.status === CompanyStatus.Active) {
+      await this.stageDocumentChange(
+        company.id,
+        uploaded.map((f) => f.id),
+        submittedBy,
+      );
+    }
+    return uploaded;
+  }
+
+  /** Open or append a pending change request recording staged document uploads. */
+  private async stageDocumentChange(
+    companyId: string,
+    fileIds: string[],
+    submittedBy?: string,
+  ): Promise<void> {
+    if (fileIds.length === 0) return;
+    const now = new Date();
+    const existing =
+      await this.changeRequestRepo.findPendingByCompanyId(companyId);
+    if (existing) {
+      const prev = existing.documents?.documentFileIds ?? [];
+      await this.changeRequestRepo.update(existing.id, {
+        documents: { documentFileIds: [...prev, ...fileIds] },
+        submittedBy: submittedBy ?? existing.submittedBy ?? null,
+        submittedAt: now,
+        note: null,
+      });
+    } else {
+      await this.changeRequestRepo.create({
+        companyId,
+        snapshot: {},
+        documents: { documentFileIds: fileIds },
+        status: ChangeRequestStatus.Pending,
+        submittedBy: submittedBy ?? null,
+        submittedAt: now,
+      });
+    }
+  }
+
+  /** Reject a pending change request with a note (customer amends & resubmits). */
+  async rejectChangeRequest(
+    id: string,
+    note: string,
+    reviewerId?: string,
+  ): Promise<CompanyChangeRequest> {
+    const request = await this.changeRequestRepo.findById(id);
+    if (!request)
+      throw new NotFoundException(`Change request ${id} not found`);
+    if (request.status !== ChangeRequestStatus.Pending) {
+      throw new BadRequestException(
+        `Change request ${id} is already ${request.status}`,
+      );
+    }
+    await this.discardLicenseChanges(request);
+    return (
+      (await this.changeRequestRepo.update(id, {
+        status: ChangeRequestStatus.Rejected,
+        // Staged license uploads were just discarded; drop their intents so an
+        // amended resubmit never re-references deleted files.
+        documents: { ...request.documents, licenseChanges: [] },
+        note,
+        reviewedBy: reviewerId ?? null,
+        reviewedAt: new Date(),
+      })) ?? request
+    );
   }
 
   async deleteCompany(id: string): Promise<void> {
@@ -713,6 +915,8 @@ export class CompaniesService {
   async setCompanyProfileStatus(
     profileId: string,
     status: ProfileStatus,
+    note?: string,
+    reviewerId?: string,
   ): Promise<CompanyProfile> {
     const existing = await this.companyProfilesRepo.findById(profileId);
     if (!existing)
@@ -727,6 +931,18 @@ export class CompaniesService {
       );
     }
 
+    // Track the review outcome. Rejection keeps the note so the customer knows
+    // why; approval clears it. Any decision stamps the reviewer + time.
+    if (status === ProfileStatus.Rejected) {
+      patch.reviewNote = note ?? null;
+    } else if (status === ProfileStatus.Active) {
+      patch.reviewNote = null;
+    }
+    if (status !== ProfileStatus.Pending) {
+      patch.reviewedBy = reviewerId ?? null;
+      patch.reviewedAt = new Date();
+    }
+
     const updated = await this.companyProfilesRepo.update(profileId, patch);
     if (!updated)
       throw new NotFoundException(`Company profile ${profileId} not found`);
@@ -744,6 +960,41 @@ export class CompaniesService {
     return updated;
   }
 
+  /**
+   * Customer reapplies for a rejected operational role (after fixing whatever the
+   * reviewer flagged, e.g. re-uploading a license): flip it back to Pending and
+   * clear the rejection note so it re-enters the approval queue.
+   */
+  async reapplyCompanyProfile(
+    userId: string,
+    profileId: string,
+  ): Promise<CompanyProfile> {
+    const profile = await this.profilesRepo.findByUserId(userId);
+    if (!profile)
+      throw new NotFoundException(`Profile for user ${userId} not found`);
+    const companyId = profile.company?.id ?? profile.companyId;
+
+    const target = await this.companyProfilesRepo.findById(profileId);
+    if (!target || target.companyId !== companyId) {
+      throw new NotFoundException(`Company profile ${profileId} not found`);
+    }
+    if (target.status !== ProfileStatus.Rejected) {
+      throw new BadRequestException(
+        "Only a rejected role can be resubmitted for approval",
+      );
+    }
+
+    const updated = await this.companyProfilesRepo.update(profileId, {
+      status: ProfileStatus.Pending,
+      reviewNote: null,
+      reviewedBy: null,
+      reviewedAt: null,
+    });
+    if (!updated)
+      throw new NotFoundException(`Company profile ${profileId} not found`);
+    return updated;
+  }
+
   async createCompanyProfile(
     companyId: string,
     profileType?: ProfileType,
@@ -833,12 +1084,12 @@ export class CompaniesService {
       );
       if (existing) continue;
 
-      const reference = await this.companyProfilesRepo.generateReference(type);
+      // Self-service role adds start Pending and carry no reference — a reference
+      // is minted only when a backoffice reviewer approves the role.
       await this.companyProfilesRepo.create({
         companyId,
         type,
-        reference,
-        status: ProfileStatus.Active,
+        status: ProfileStatus.Pending,
       });
     }
 
@@ -870,13 +1121,14 @@ export class CompaniesService {
 
     let created = await this.companyProfilesRepo.findByType(companyId, type);
     if (!created) {
-      const reference = await this.companyProfilesRepo.generateReference(type);
+      // New self-service roles start Pending (awaiting backoffice approval) and
+      // carry no reference until approved. The customer can select this mode but
+      // can't book under it until it's cleared.
       created = await this.companyProfilesRepo.create({
         companyId,
         type,
-        reference,
         businessLicense: businessLicense ?? null,
-        status: ProfileStatus.Active,
+        status: ProfileStatus.Pending,
       });
     }
 
@@ -971,13 +1223,21 @@ export class CompaniesService {
       }));
     const missingDocs = documents.filter((d) => d.isRequired && !d.uploaded);
 
-    // 3. Per-operational-profile business licenses.
-    const licenseProfiles = (company.companyProfiles ?? []).map((p) => ({
-      profileId: p.id,
-      type: p.type,
-      reference: p.reference ?? "",
-      uploaded: (p.businessLicenseFiles?.length ?? 0) > 0,
-    }));
+    // 3. Per-operational-profile business licenses (FileRecord-backed).
+    const licenseProfiles = await Promise.all(
+      (company.companyProfiles ?? []).map(async (p) => {
+        const records = await this.filesService.findByResource(
+          p.id,
+          LICENSE_RESOURCE,
+        );
+        return {
+          profileId: p.id,
+          type: p.type,
+          reference: p.reference ?? "",
+          uploaded: records.some((r) => r.code === LICENSE_CODE),
+        };
+      }),
+    );
     const missingLicenses = licenseProfiles.filter((p) => !p.uploaded);
 
     const outstanding = [
@@ -1094,61 +1354,321 @@ export class CompaniesService {
     return owned;
   }
 
+  // ─── Business-license files ────────────────────────────────────────────────
+  //
+  // License documents live in the FileRecord model (`freight.files`) with
+  // `resource = "company_profiles"`, `resourceId = <profileId>`. Live files use
+  // code `LICENSE_CODE`; files staged inside an open change request (add /
+  // replacement) use `LICENSE_PENDING_CODE` and only become live on approval.
+  // Preview streams through `GET /api/files/:id` (server-side proxy) — the same
+  // path regular documents use — so it never hits MinIO directly from the
+  // browser (which fails on the internal bucket endpoint).
+
   /**
-   * Upload business-license document(s) and store them directly on the company
-   * profile (multi-file). Bytes go to object storage; only metadata/URLs are
-   * persisted on the profile — intentionally not via the FileRecord file model.
-   * New files are appended to any already present. Returns the full list.
+   * Upload business-license file(s) for one of the user's profiles. During
+   * onboarding (company not yet Active) they go live immediately; for an Active
+   * company they're staged under the pending code and recorded as `add` intents
+   * on a pending change request for backoffice review. Returns the updated view.
    */
-  async uploadProfileLicenseFiles(
+  async addProfileLicenseFiles(
     userId: string,
     profileId: string,
     files: Express.Multer.File[],
-  ): Promise<BusinessLicenseFile[]> {
+  ): Promise<ProfileLicenseFileView[]> {
     const profile = await this.resolveOwnedProfile(userId, profileId);
+    const company = await this.findCompanyById(profile.companyId);
+    const gated = company.status === CompanyStatus.Active;
+    const code = gated ? LICENSE_PENDING_CODE : LICENSE_CODE;
 
-    const uploaded: BusinessLicenseFile[] = [];
-    for (const file of files) {
-      const objectName = `company_profiles/${profileId}/${Date.now()}_${file.originalname}`;
-      const url = await this.minioService.uploadFile(
-        objectName,
-        file.buffer,
-        file.mimetype,
+    const uploaded = await Promise.all(
+      files.map((file) =>
+        this.filesService.upload({
+          resourceId: profileId,
+          resource: LICENSE_RESOURCE,
+          code,
+          file,
+        }),
+      ),
+    );
+
+    if (gated) {
+      await this.stageLicenseChange(
+        company.id,
+        uploaded.map((r) => ({
+          profileId,
+          op: "add" as const,
+          fileId: r.id,
+          fileName: r.name,
+        })),
+        userId,
       );
-      uploaded.push({
-        name: file.originalname,
-        url,
-        size: file.size,
-        mimeType: file.mimetype,
-      });
     }
 
-    const next = [...(profile.businessLicenseFiles ?? []), ...uploaded];
-    await this.companyProfilesRepo.update(profileId, {
-      businessLicenseFiles: next,
-    });
-    return next;
-  }
-
-  /** The business-license files stored on a single company profile. */
-  async listProfileLicenseFiles(
-    userId: string,
-    profileId: string,
-  ): Promise<BusinessLicenseFile[]> {
-    const profile = await this.resolveOwnedProfile(userId, profileId);
-    return profile.businessLicenseFiles ?? [];
+    return this.getProfileLicenseView(profileId, company.id);
   }
 
   /**
-   * Onboarding documents stored on a company profile, fetched by profile id.
-   * Internal helper (no ownership check) used when a booking reuses the active
-   * profile's onboarding documents. Returns [] when the profile is unknown.
+   * Remove a license file. A staged (pending) file is withdrawn outright
+   * (soft-deleted, its `add` intent dropped). A live file on an Active company
+   * is kept and recorded as a `remove` intent for review; during onboarding it
+   * is deleted immediately.
+   */
+  async removeProfileLicenseFile(
+    userId: string,
+    profileId: string,
+    fileId: string,
+  ): Promise<ProfileLicenseFileView[]> {
+    const profile = await this.resolveOwnedProfile(userId, profileId);
+    const record = await this.filesService.findById(fileId);
+    if (
+      record.resource !== LICENSE_RESOURCE ||
+      record.resourceId !== profileId
+    ) {
+      throw new NotFoundException(`License file ${fileId} not found`);
+    }
+    const company = await this.findCompanyById(profile.companyId);
+    const gated = company.status === CompanyStatus.Active;
+
+    if (record.code === LICENSE_PENDING_CODE) {
+      // Withdraw a not-yet-approved upload: delete it and drop its add intent.
+      await this.filesService.remove(fileId);
+      await this.withdrawLicenseIntent(company.id, fileId);
+    } else if (gated) {
+      await this.stageLicenseChange(
+        company.id,
+        [{ profileId, op: "remove", fileId, fileName: record.name }],
+        userId,
+      );
+    } else {
+      await this.filesService.remove(fileId);
+    }
+
+    return this.getProfileLicenseView(profileId, company.id);
+  }
+
+  /**
+   * Replace a live license file with a freshly uploaded one — recorded as a
+   * `remove` of the old file plus an `add` of the new, so approval swaps them
+   * atomically. During onboarding the swap is applied immediately.
+   */
+  async replaceProfileLicenseFile(
+    userId: string,
+    profileId: string,
+    fileId: string,
+    file: Express.Multer.File,
+  ): Promise<ProfileLicenseFileView[]> {
+    const profile = await this.resolveOwnedProfile(userId, profileId);
+    const old = await this.filesService.findById(fileId);
+    if (old.resource !== LICENSE_RESOURCE || old.resourceId !== profileId) {
+      throw new NotFoundException(`License file ${fileId} not found`);
+    }
+    const company = await this.findCompanyById(profile.companyId);
+    const gated = company.status === CompanyStatus.Active;
+
+    const created = await this.filesService.upload({
+      resourceId: profileId,
+      resource: LICENSE_RESOURCE,
+      code: gated ? LICENSE_PENDING_CODE : LICENSE_CODE,
+      file,
+    });
+
+    if (gated) {
+      await this.stageLicenseChange(
+        company.id,
+        [
+          { profileId, op: "remove", fileId, fileName: old.name },
+          { profileId, op: "add", fileId: created.id, fileName: created.name },
+        ],
+        userId,
+      );
+    } else {
+      await this.filesService.remove(fileId);
+    }
+
+    return this.getProfileLicenseView(profileId, company.id);
+  }
+
+  /** License files for one profile, with each file's review status resolved. */
+  async listProfileLicenseFiles(
+    userId: string,
+    profileId: string,
+  ): Promise<ProfileLicenseFileView[]> {
+    const profile = await this.resolveOwnedProfile(userId, profileId);
+    return this.getProfileLicenseView(profileId, profile.companyId);
+  }
+
+  /**
+   * Live license files for a profile, shaped for by-reference reuse (bookings /
+   * contracts snapshot these). No ownership check — internal callers only.
+   * Returns the raw stored URLs; pending (unapproved) files are excluded.
    */
   async getProfileOnboardingFiles(
     profileId: string,
   ): Promise<BusinessLicenseFile[]> {
-    const profile = await this.companyProfilesRepo.findById(profileId);
-    return profile?.businessLicenseFiles ?? [];
+    const records = await this.filesService.findByResource(
+      profileId,
+      LICENSE_RESOURCE,
+    );
+    return records
+      .filter((r) => r.code === LICENSE_CODE)
+      .map((r) => ({
+        name: r.name,
+        url: r.url,
+        size: r.size,
+        mimeType: r.mimeType,
+      }));
+  }
+
+  /**
+   * Assemble the review-aware license view for a set of profiles in one pass
+   * (single change-request lookup). Used to enrich company/profile responses.
+   */
+  async assembleLicenseFilesByProfile(
+    companyId: string,
+    profileIds: string[],
+  ): Promise<Record<string, ProfileLicenseFileView[]>> {
+    const pending =
+      await this.changeRequestRepo.findPendingByCompanyId(companyId);
+    const removeIds = new Set(
+      (pending?.documents?.licenseChanges ?? [])
+        .filter((c) => c.op === "remove")
+        .map((c) => c.fileId),
+    );
+    const result: Record<string, ProfileLicenseFileView[]> = {};
+    await Promise.all(
+      profileIds.map(async (pid) => {
+        result[pid] = await this.mapLicenseRecords(pid, removeIds);
+      }),
+    );
+    return result;
+  }
+
+  /** Single-profile license view (fetches the company's pending request once). */
+  private async getProfileLicenseView(
+    profileId: string,
+    companyId: string,
+  ): Promise<ProfileLicenseFileView[]> {
+    const pending =
+      await this.changeRequestRepo.findPendingByCompanyId(companyId);
+    const removeIds = new Set(
+      (pending?.documents?.licenseChanges ?? [])
+        .filter((c) => c.op === "remove")
+        .map((c) => c.fileId),
+    );
+    return this.mapLicenseRecords(profileId, removeIds);
+  }
+
+  private async mapLicenseRecords(
+    profileId: string,
+    pendingRemoveIds: Set<string>,
+  ): Promise<ProfileLicenseFileView[]> {
+    const records = await this.filesService.findByResource(
+      profileId,
+      LICENSE_RESOURCE,
+    );
+    return records
+      .filter(
+        (r) => r.code === LICENSE_CODE || r.code === LICENSE_PENDING_CODE,
+      )
+      .map((r) => ({
+        id: r.id,
+        name: r.name,
+        size: r.size,
+        mimeType: r.mimeType,
+        status:
+          r.code === LICENSE_PENDING_CODE
+            ? ("pending_add" as const)
+            : pendingRemoveIds.has(r.id)
+              ? ("pending_remove" as const)
+              : ("live" as const),
+      }));
+  }
+
+  /** Open or append a pending change request recording license add/remove intents. */
+  private async stageLicenseChange(
+    companyId: string,
+    changes: LicenseChangeIntent[],
+    submittedBy?: string,
+  ): Promise<void> {
+    if (changes.length === 0) return;
+    const now = new Date();
+    const existing =
+      await this.changeRequestRepo.findPendingByCompanyId(companyId);
+    if (existing) {
+      const prev = existing.documents?.licenseChanges ?? [];
+      await this.changeRequestRepo.update(existing.id, {
+        documents: {
+          ...existing.documents,
+          licenseChanges: [...prev, ...changes],
+        },
+        submittedBy: submittedBy ?? existing.submittedBy ?? null,
+        submittedAt: now,
+        note: null,
+      });
+    } else {
+      await this.changeRequestRepo.create({
+        companyId,
+        snapshot: {},
+        documents: { licenseChanges: changes },
+        status: ChangeRequestStatus.Pending,
+        submittedBy: submittedBy ?? null,
+        submittedAt: now,
+      });
+    }
+  }
+
+  /**
+   * Drop a staged license intent (add or remove) referencing `fileId` from the
+   * company's open request. If that empties the request entirely, delete it so
+   * the customer's settings page unlocks.
+   */
+  private async withdrawLicenseIntent(
+    companyId: string,
+    fileId: string,
+  ): Promise<void> {
+    const existing =
+      await this.changeRequestRepo.findPendingByCompanyId(companyId);
+    if (!existing) return;
+    const remaining = (existing.documents?.licenseChanges ?? []).filter(
+      (c) => c.fileId !== fileId,
+    );
+    const docs = existing.documents ?? {};
+    const stillHasWork =
+      remaining.length > 0 ||
+      (docs.documentFileIds?.length ?? 0) > 0 ||
+      Object.keys(existing.snapshot ?? {}).length > 0;
+
+    if (stillHasWork) {
+      await this.changeRequestRepo.update(existing.id, {
+        documents: { ...docs, licenseChanges: remaining },
+      });
+    } else {
+      await this.changeRequestRepo.softDelete(existing.id);
+    }
+  }
+
+  /** Apply a request's staged license changes: promote adds, delete removes. */
+  private async applyLicenseChanges(
+    request: CompanyChangeRequest,
+  ): Promise<void> {
+    for (const change of request.documents?.licenseChanges ?? []) {
+      if (change.op === "add") {
+        await this.filesService.setCode(change.fileId, LICENSE_CODE);
+      } else {
+        await this.filesService.remove(change.fileId);
+      }
+    }
+  }
+
+  /** Discard a rejected request's staged license uploads (adds only). */
+  private async discardLicenseChanges(
+    request: CompanyChangeRequest,
+  ): Promise<void> {
+    for (const change of request.documents?.licenseChanges ?? []) {
+      if (change.op === "add") {
+        await this.filesService.remove(change.fileId);
+      }
+    }
   }
 
   /**
diff --git a/apps/edr-freight-api/src/modules/companies/company-change-request.repository.ts b/apps/edr-freight-api/src/modules/companies/company-change-request.repository.ts
new file mode 100644
index 000000000..24d988452
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/companies/company-change-request.repository.ts
@@ -0,0 +1,55 @@
+import { Injectable } from "@nestjs/common";
+import { InjectRepository } from "@nestjs/typeorm";
+import { Repository } from "typeorm";
+import { BaseRepository } from "@edr/api-common";
+import {
+  ChangeRequestStatus,
+  CompanyChangeRequest,
+} from "./entities/company-change-request.entity";
+
+@Injectable()
+export class CompanyChangeRequestRepository extends BaseRepository<CompanyChangeRequest> {
+  constructor(
+    @InjectRepository(CompanyChangeRequest)
+    repo: Repository<CompanyChangeRequest>,
+  ) {
+    super(repo);
+  }
+
+  /** The company's current pending request, if any. */
+  async findPendingByCompanyId(
+    companyId: string,
+  ): Promise<CompanyChangeRequest | null> {
+    return this.repository.findOne({
+      where: { companyId, status: ChangeRequestStatus.Pending },
+      order: { createdAt: "DESC" },
+    });
+  }
+
+  /**
+   * The company's latest "open" request — pending (locks the customer) or the
+   * most recent rejected one (drives the reapply banner + prefill). Approved
+   * requests are terminal and ignored here.
+   */
+  async findLatestOpenByCompanyId(
+    companyId: string,
+  ): Promise<CompanyChangeRequest | null> {
+    const pending = await this.findPendingByCompanyId(companyId);
+    if (pending) return pending;
+    return this.repository.findOne({
+      where: { companyId, status: ChangeRequestStatus.Rejected },
+      order: { createdAt: "DESC" },
+    });
+  }
+
+  async findById(id: string): Promise<CompanyChangeRequest | null> {
+    return this.repository.findOne({ where: { id } });
+  }
+
+  async findByCompanyId(companyId: string): Promise<CompanyChangeRequest[]> {
+    return this.repository.find({
+      where: { companyId },
+      order: { createdAt: "DESC" },
+    });
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/companies/dto/change-request-response.dto.ts b/apps/edr-freight-api/src/modules/companies/dto/change-request-response.dto.ts
new file mode 100644
index 000000000..579ac6ddd
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/companies/dto/change-request-response.dto.ts
@@ -0,0 +1,44 @@
+import {
+  ChangeRequestStatus,
+  CompanyChangeRequest,
+  LicenseChangeIntent,
+} from "../entities/company-change-request.entity";
+
+/**
+ * A staged profile change request. Used both by the portal (to lock the settings
+ * page, show the reviewer note, and prefill the proposed values) and by the
+ * backoffice review screen (to render the proposed-vs-current diff).
+ */
+export class ChangeRequestResponseDto {
+  id: string;
+  companyId: string;
+  status: ChangeRequestStatus;
+  /** Proposed field values (Partial<UpdateProfileDto>) — the diff payload. */
+  snapshot: Record<string, any>;
+  documentFileIds: string[];
+  /** Staged business-license add/remove intents attached to this request. */
+  licenseChanges: LicenseChangeIntent[];
+  note: string | null;
+  submittedBy: string | null;
+  submittedAt: Date | null;
+  reviewedBy: string | null;
+  reviewedAt: Date | null;
+  createdAt: Date;
+  updatedAt: Date;
+
+  constructor(req: CompanyChangeRequest) {
+    this.id = req.id;
+    this.companyId = req.companyId;
+    this.status = req.status;
+    this.snapshot = req.snapshot ?? {};
+    this.documentFileIds = req.documents?.documentFileIds ?? [];
+    this.licenseChanges = req.documents?.licenseChanges ?? [];
+    this.note = req.note ?? null;
+    this.submittedBy = req.submittedBy ?? null;
+    this.submittedAt = req.submittedAt ?? null;
+    this.reviewedBy = req.reviewedBy ?? null;
+    this.reviewedAt = req.reviewedAt ?? null;
+    this.createdAt = req.createdAt;
+    this.updatedAt = req.updatedAt;
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/companies/dto/company-info-response.dto.ts b/apps/edr-freight-api/src/modules/companies/dto/company-info-response.dto.ts
index 04fd42816..9a4fb330a 100644
--- a/apps/edr-freight-api/src/modules/companies/dto/company-info-response.dto.ts
+++ b/apps/edr-freight-api/src/modules/companies/dto/company-info-response.dto.ts
@@ -1,14 +1,43 @@
 import { Company } from '../entities/company.entity';
 import { ExternalProfile } from '../entities/external-profile.entity';
+import {
+  ChangeRequestStatus,
+  CompanyChangeRequest,
+} from '../entities/company-change-request.entity';
 import { ResponseCompanyDto } from './response-company.dto';
 import { ResponseExternalProfileDto } from './response-external-profile.dto';
 
 export class CompanyInfoResponseDto {
   profile: ResponseExternalProfileDto;
   company: ResponseCompanyDto;
+  /**
+   * Open profile-edit review, if any. Drives the portal-wide lock (pending →
+   * settings + new-contract/booking creation disabled) and the reapply banner.
+   */
+  review: {
+    status: 'pending' | 'rejected';
+    note: string | null;
+  } | null;
 
-  constructor(profile: ExternalProfile, company: Company) {
+  constructor(
+    profile: ExternalProfile,
+    company: Company,
+    changeRequest?: CompanyChangeRequest | null,
+  ) {
     this.profile = new ResponseExternalProfileDto(profile, company);
     this.company = new ResponseCompanyDto(company);
+
+    const open =
+      changeRequest &&
+      (changeRequest.status === ChangeRequestStatus.Pending ||
+        changeRequest.status === ChangeRequestStatus.Rejected)
+        ? changeRequest
+        : null;
+    this.review = open
+      ? {
+          status: open.status as 'pending' | 'rejected',
+          note: open.note ?? null,
+        }
+      : null;
   }
 }
diff --git a/apps/edr-freight-api/src/modules/companies/dto/profile-response.dto.ts b/apps/edr-freight-api/src/modules/companies/dto/profile-response.dto.ts
index 89a52b5e6..89ab954e7 100644
--- a/apps/edr-freight-api/src/modules/companies/dto/profile-response.dto.ts
+++ b/apps/edr-freight-api/src/modules/companies/dto/profile-response.dto.ts
@@ -1,5 +1,9 @@
 import { Company } from '../entities/company.entity';
 import { ExternalProfile } from '../entities/external-profile.entity';
+import {
+  ChangeRequestStatus,
+  CompanyChangeRequest,
+} from '../entities/company-change-request.entity';
 import { ResponseCompanyProfileDto } from './response-company.dto';
 
 export class ProfileResponseDto {
@@ -48,7 +52,20 @@ export class ProfileResponseDto {
 
   profileId: string;
 
-  constructor(profile: ExternalProfile, company: Company) {
+  /**
+   * Open profile-edit review, if any. `reviewStatus === "pending"` locks the
+   * settings page; `"rejected"` surfaces the note and prefills the (declined)
+   * proposed values from `pendingChanges` so the customer can amend & resubmit.
+   */
+  reviewStatus: "pending" | "rejected" | null;
+  reviewNote: string | null;
+  pendingChanges: Record<string, any> | null;
+
+  constructor(
+    profile: ExternalProfile,
+    company: Company,
+    changeRequest?: CompanyChangeRequest | null,
+  ) {
     this.companyId = company.id;
     this.companyName = company.name;
     this.companyType = company.type;
@@ -92,5 +109,20 @@ export class ProfileResponseDto {
     this.poaEmail = attrs.poaEmail ?? null;
     this.poaLocation = attrs.poaLocation ?? null;
     this.poaAddress = attrs.poaAddress ?? null;
+
+    const openReview =
+      changeRequest &&
+      (changeRequest.status === ChangeRequestStatus.Pending ||
+        changeRequest.status === ChangeRequestStatus.Rejected)
+        ? changeRequest
+        : null;
+    this.reviewStatus =
+      openReview?.status === ChangeRequestStatus.Pending
+        ? "pending"
+        : openReview?.status === ChangeRequestStatus.Rejected
+          ? "rejected"
+          : null;
+    this.reviewNote = openReview?.note ?? null;
+    this.pendingChanges = openReview?.snapshot ?? null;
   }
 }
diff --git a/apps/edr-freight-api/src/modules/companies/dto/reject-change-request.dto.ts b/apps/edr-freight-api/src/modules/companies/dto/reject-change-request.dto.ts
new file mode 100644
index 000000000..c32b44a79
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/companies/dto/reject-change-request.dto.ts
@@ -0,0 +1,11 @@
+import { ApiProperty } from "@nestjs/swagger";
+import { IsString, MaxLength, MinLength } from "class-validator";
+
+export class RejectChangeRequestDto {
+  /** Why the proposed changes were declined — shown to the customer so they can fix and resubmit. */
+  @ApiProperty()
+  @IsString()
+  @MinLength(1)
+  @MaxLength(2000)
+  note!: string;
+}
diff --git a/apps/edr-freight-api/src/modules/companies/dto/response-company.dto.ts b/apps/edr-freight-api/src/modules/companies/dto/response-company.dto.ts
index 5d90d8d60..0c783cbcf 100644
--- a/apps/edr-freight-api/src/modules/companies/dto/response-company.dto.ts
+++ b/apps/edr-freight-api/src/modules/companies/dto/response-company.dto.ts
@@ -5,8 +5,8 @@ import {
   CompanyNationality,
 } from '../entities/company.entity';
 import {
-  BusinessLicenseFile,
   CompanyProfile,
+  ProfileLicenseFileView,
 } from '../entities/company-profile.entity';
 import { ResponseExternalProfileDto } from './response-external-profile.dto';
 
@@ -18,9 +18,15 @@ export class ResponseCompanyProfileDto {
   status: string;
   /** @deprecated Superseded by licenseFiles. Kept for back-compat. */
   businessLicense?: string | null;
-  /** Business-license documents stored on the profile (multi-file). */
-  licenseFiles: BusinessLicenseFile[];
+  /**
+   * Business-license documents (FileRecord-backed) with review state. Left empty
+   * by the constructor and populated asynchronously by the controller, since the
+   * files and their pending-change status require DB lookups.
+   */
+  licenseFiles: ProfileLicenseFileView[];
   attributes?: Record<string, any> | null;
+  /** Reviewer note when the role is rejected (drives the reapply prompt). */
+  reviewNote?: string | null;
   createdAt: Date;
   updatedAt: Date;
 
@@ -31,8 +37,9 @@ export class ResponseCompanyProfileDto {
     this.reference = profile.reference ?? '';
     this.status = profile.status;
     this.businessLicense = profile.businessLicense;
-    this.licenseFiles = profile.businessLicenseFiles ?? [];
+    this.licenseFiles = [];
     this.attributes = profile.attributes;
+    this.reviewNote = profile.reviewNote ?? null;
     this.createdAt = profile.createdAt;
     this.updatedAt = profile.updatedAt;
   }
diff --git a/apps/edr-freight-api/src/modules/companies/dto/update-company-profile-status.dto.ts b/apps/edr-freight-api/src/modules/companies/dto/update-company-profile-status.dto.ts
index 96c02d846..83beb441f 100644
--- a/apps/edr-freight-api/src/modules/companies/dto/update-company-profile-status.dto.ts
+++ b/apps/edr-freight-api/src/modules/companies/dto/update-company-profile-status.dto.ts
@@ -1,9 +1,16 @@
-import { ApiProperty } from "@nestjs/swagger";
-import { IsIn } from "class-validator";
+import { ApiProperty, ApiPropertyOptional } from "@nestjs/swagger";
+import { IsIn, IsOptional, IsString, MaxLength } from "class-validator";
 import { ProfileStatus } from "../entities/company-profile.entity";
 
 export class UpdateCompanyProfileStatusDto {
   @ApiProperty({ enum: ProfileStatus })
   @IsIn(Object.values(ProfileStatus))
   status!: ProfileStatus;
+
+  /** Reviewer note — required in practice when rejecting so the customer knows why. */
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsString()
+  @MaxLength(2000)
+  note?: string;
 }
diff --git a/apps/edr-freight-api/src/modules/companies/entities/company-change-request.entity.ts b/apps/edr-freight-api/src/modules/companies/entities/company-change-request.entity.ts
new file mode 100644
index 000000000..cec670787
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/companies/entities/company-change-request.entity.ts
@@ -0,0 +1,87 @@
+import { BaseEntity } from "@edr/api-common";
+import { Column, Entity, Index, JoinColumn, ManyToOne } from "typeorm";
+import { Company } from "./company.entity";
+
+/**
+ * Lifecycle of a customer's proposed profile change. Edits made on the portal
+ * settings page by an already-approved company are staged here (not written to
+ * the live Company row) until a backoffice reviewer approves — at which point
+ * the snapshot is applied — or rejects with a note, after which the customer can
+ * amend and resubmit.
+ */
+export enum ChangeRequestStatus {
+  Pending = "pending",
+  Approved = "approved",
+  Rejected = "rejected",
+}
+
+/**
+ * A single staged business-license change on one company profile, awaiting
+ * review. `add` → a new file was uploaded under the pending code and becomes
+ * live on approval; `remove` → an existing live file is deleted on approval.
+ * A "replace" is recorded as a `remove` of the old file plus an `add` of the
+ * new one. `fileId` is the FileRecord id the op targets.
+ */
+export interface LicenseChangeIntent {
+  profileId: string;
+  op: "add" | "remove";
+  fileId: string;
+  /** File name, snapshotted for the backoffice review screen. */
+  fileName?: string;
+}
+
+/** File references staged alongside a change request (documents/licenses). */
+export interface ChangeRequestDocuments {
+  /** FileRecord ids uploaded against the company while this request was open. */
+  documentFileIds?: string[];
+  /** Staged per-profile business-license add/remove intents. */
+  licenseChanges?: LicenseChangeIntent[];
+}
+
+@Entity({ schema: "freight", name: "company_change_request" })
+@Index(["companyId"])
+@Index(["status"])
+export class CompanyChangeRequest extends BaseEntity {
+  @Column({ name: "company_id", type: "uuid" })
+  companyId!: string;
+
+  @ManyToOne(() => Company, { onDelete: "CASCADE" })
+  @JoinColumn({ name: "company_id" })
+  company?: Company;
+
+  /**
+   * Proposed profile field values, shaped as `Partial<UpdateProfileDto>`. Covers
+   * the Company / Contact / General Manager / Power-of-Attorney tabs (contact/GM/
+   * PoA fields land in `Company.attributes` on approval).
+   */
+  @Column({ name: "snapshot", type: "jsonb" })
+  snapshot!: Record<string, any>;
+
+  /** Staged document/license file references (see {@link ChangeRequestDocuments}). */
+  @Column({ name: "documents", type: "jsonb", nullable: true })
+  documents?: ChangeRequestDocuments | null;
+
+  @Column({
+    name: "status",
+    type: "varchar",
+    length: 20,
+    default: ChangeRequestStatus.Pending,
+  })
+  status!: ChangeRequestStatus;
+
+  /** Backoffice reviewer's rejection note. */
+  @Column({ name: "note", type: "text", nullable: true })
+  note?: string | null;
+
+  @Column({ name: "submitted_by", type: "uuid", nullable: true })
+  submittedBy?: string | null;
+
+  @Column({ name: "submitted_at", type: "timestamptz", nullable: true })
+  submittedAt?: Date | null;
+
+  @Column({ name: "reviewed_by", type: "uuid", nullable: true })
+  reviewedBy?: string | null;
+
+  @Column({ name: "reviewed_at", type: "timestamptz", nullable: true })
+  reviewedAt?: Date | null;
+}
diff --git a/apps/edr-freight-api/src/modules/companies/entities/company-profile.entity.ts b/apps/edr-freight-api/src/modules/companies/entities/company-profile.entity.ts
index e61668a07..72696766f 100644
--- a/apps/edr-freight-api/src/modules/companies/entities/company-profile.entity.ts
+++ b/apps/edr-freight-api/src/modules/companies/entities/company-profile.entity.ts
@@ -13,11 +13,17 @@ export enum ProfileType {
 export enum ProfileStatus {
   Active = "active",
   Pending = "pending",
+  /** Reviewer declined the role; carries a note. Customer can reapply → Pending. */
+  Rejected = "rejected",
   Suspended = "suspended",
   Blacklisted = "blacklisted",
 }
 
-/** A business-license document stored directly on the company profile. */
+/**
+ * @deprecated Legacy inline shape. Business-license files now live in the
+ * FileRecord model (`freight.files`, resource `company_profiles`). Kept only for
+ * the by-reference reuse shape consumed by bookings/contracts snapshots.
+ */
 export interface BusinessLicenseFile {
   name: string;
   url: string;
@@ -25,6 +31,19 @@ export interface BusinessLicenseFile {
   mimeType?: string;
 }
 
+/** A business-license file plus its change-review state, surfaced to clients. */
+export interface ProfileLicenseFileView {
+  id: string;
+  name: string;
+  size: number;
+  mimeType: string;
+  /**
+   * `live` — approved & in effect; `pending_add` — uploaded, awaiting approval;
+   * `pending_remove` — live but flagged for deletion on approval.
+   */
+  status: "live" | "pending_add" | "pending_remove";
+}
+
 @Entity({ schema: "freight", name: "company_profiles" })
 @Index(["reference"], { unique: true })
 @Index(["type"])
@@ -80,4 +99,14 @@ export class CompanyProfile extends BaseEntity {
 
   @Column({ name: "attributes", type: "jsonb", nullable: true })
   attributes?: Record<string, any> | null;
+
+  /** Reviewer's note when the role is Rejected (cleared on reapply). */
+  @Column({ name: "review_note", type: "text", nullable: true })
+  reviewNote?: string | null;
+
+  @Column({ name: "reviewed_by", type: "uuid", nullable: true })
+  reviewedBy?: string | null;
+
+  @Column({ name: "reviewed_at", type: "timestamptz", nullable: true })
+  reviewedAt?: Date | null;
 }
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 aaf064bff..095857959 100644
--- a/apps/edr-freight-api/src/modules/contracts/contracts.service.ts
+++ b/apps/edr-freight-api/src/modules/contracts/contracts.service.ts
@@ -12,7 +12,7 @@ import { YardCountry } from '@edr/types';
 
 import { deriveTradeDirection } from '../../common/derive-trade-direction.util';
 import { CompaniesService } from '../companies/companies.service';
-import { CompanyProfile, ProfileType } from '../companies/entities/company-profile.entity';
+import { ProfileType } from '../companies/entities/company-profile.entity';
 import { CompanyStatus } from '../companies/entities/company.entity';
 import { ServiceType } from '../rule-engine/entities/service-type.entity';
 import { Yard } from '../rule-engine/entities/yard.entity';
@@ -326,10 +326,20 @@ export class ContractsService {
     companyProfileId: string | null,
   ): Promise<void> {
     if (!companyProfileId) return;
-    const profile = await this.dataSource
-      .getRepository(CompanyProfile)
-      .findOne({ where: { id: companyProfileId } });
-    const docs = profile?.businessLicenseFiles ?? [];
+    // Business-license files are FileRecords (resource "company_profiles"); carry
+    // the live ones by reference. Staged/pending uploads are excluded by code.
+    const records = await this.filesService.findByResource(
+      companyProfileId,
+      'company_profiles',
+    );
+    const docs = records
+      .filter((r) => r.code === 'business_license')
+      .map((r) => ({
+        name: r.name,
+        url: r.url,
+        size: r.size,
+        mimeType: r.mimeType,
+      }));
     if (docs.length === 0) return;
 
     const slug = (name: string) =>
diff --git a/apps/edr-freight-api/src/modules/contracts/dto/create-booking-under-contract.dto.ts b/apps/edr-freight-api/src/modules/contracts/dto/create-booking-under-contract.dto.ts
index e3130da95..f220cae0d 100644
--- a/apps/edr-freight-api/src/modules/contracts/dto/create-booking-under-contract.dto.ts
+++ b/apps/edr-freight-api/src/modules/contracts/dto/create-booking-under-contract.dto.ts
@@ -9,14 +9,19 @@ import {
   IsOptional,
   IsString,
   IsUUID,
+  Matches,
   Min,
   ValidateNested,
 } from 'class-validator';
 
 /** One physical container under a booking line — entered at booking time. */
 export class CreateContainerUnitDto {
-  @ApiProperty()
+  @ApiProperty({ description: 'ISO 6346 container number, e.g. ABCD1234567' })
   @IsString()
+  @Transform(({ value }) => (typeof value === 'string' ? value.trim().toUpperCase() : value))
+  @Matches(/^[A-Z]{4}\d{7}$/, {
+    message: 'containerNumber must match ISO container format, e.g. ABCD1234567',
+  })
   containerNumber!: string;
 
   @ApiPropertyOptional()
diff --git a/apps/edr-freight-api/src/modules/files/files.service.ts b/apps/edr-freight-api/src/modules/files/files.service.ts
index 4966d7ff9..3fd0752f7 100644
--- a/apps/edr-freight-api/src/modules/files/files.service.ts
+++ b/apps/edr-freight-api/src/modules/files/files.service.ts
@@ -124,6 +124,15 @@ export class FilesService {
     await this.filesRepository.softDelete(id);
   }
 
+  /**
+   * Re-slot a stored file under a new `code` (e.g. promote a staged
+   * `business_license_pending` file to the live `business_license` code once a
+   * change request is approved). Bytes and URL are untouched.
+   */
+  async setCode(id: string, code: string): Promise<void> {
+    await this.filesRepository.update(id, { code });
+  }
+
   findByResource(resourceId: string, resource: string): Promise<FileRecord[]> {
     return this.filesRepository.findByResource(resourceId, resource);
   }
diff --git a/apps/edr-freight-api/src/modules/gps-tracking/gps-tracking.controller.ts b/apps/edr-freight-api/src/modules/gps-tracking/gps-tracking.controller.ts
index e380e541e..8bd4a31d8 100644
--- a/apps/edr-freight-api/src/modules/gps-tracking/gps-tracking.controller.ts
+++ b/apps/edr-freight-api/src/modules/gps-tracking/gps-tracking.controller.ts
@@ -11,14 +11,15 @@ import {
 } from '@nestjs/common';
 import { ApiBearerAuth, ApiOperation, ApiTags } from '@nestjs/swagger';
 
-import { FleetManage, FleetView } from '../../common/booking-guards';
+import { BookingStaff } from '../../common/booking-guards';
+import { FREIGHT_PERMS } from '../../seed/freight-permissions.registry';
 import { GpsTrackingService } from './gps-tracking.service';
 import { RegisterDeviceDto, UpdateDeviceDto } from './dto/gps-device.dto';
 
 @ApiTags('gps-tracking')
 @ApiBearerAuth()
 @Controller('gps')
-@FleetView()
+@BookingStaff(FREIGHT_PERMS.tracking.view)
 export class GpsTrackingController {
   constructor(private readonly gps: GpsTrackingService) {}
 
@@ -44,21 +45,21 @@ export class GpsTrackingController {
   }
 
   @Post('devices')
-  @FleetManage()
+  @BookingStaff(FREIGHT_PERMS.tracking.manage)
   @ApiOperation({ summary: 'Register a GPS tracker' })
   register(@Body() dto: RegisterDeviceDto) {
     return this.gps.registerDevice(dto);
   }
 
   @Patch('devices/:id')
-  @FleetManage()
+  @BookingStaff(FREIGHT_PERMS.tracking.manage)
   @ApiOperation({ summary: 'Update a GPS tracker (name / assigned vehicle)' })
   update(@Param('id', ParseUUIDPipe) id: string, @Body() dto: UpdateDeviceDto) {
     return this.gps.updateDevice(id, dto);
   }
 
   @Delete('devices/:id')
-  @FleetManage()
+  @BookingStaff(FREIGHT_PERMS.tracking.manage)
   @ApiOperation({ summary: 'Delete a GPS tracker' })
   remove(@Param('id', ParseUUIDPipe) id: string) {
     return this.gps.removeDevice(id);
diff --git a/apps/edr-freight-api/src/modules/notifications/notify-company.util.ts b/apps/edr-freight-api/src/modules/notifications/notify-company.util.ts
new file mode 100644
index 000000000..9d7f32c3d
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/notifications/notify-company.util.ts
@@ -0,0 +1,37 @@
+import { DataSource } from 'typeorm';
+
+import { NotificationsService } from './notifications.service';
+
+/**
+ * Best-effort SMS + email fan-out to a company's contacts. Looks up the
+ * company's phone/email and sends the message over both channels, swallowing
+ * per-channel failures so a missing provider never breaks the caller's flow.
+ */
+export async function sendCompanyChannels(
+  dataSource: DataSource,
+  notifications: NotificationsService,
+  companyId: string,
+  message: string,
+): Promise<void> {
+  const [contact]: Array<{ phone: string | null; email: string | null }> =
+    await dataSource.query(
+      `SELECT COALESCE(phone, etrade_phone) AS phone, email
+         FROM freight.companies
+        WHERE id = $1 AND deleted_at IS NULL`,
+      [companyId],
+    );
+  if (contact?.phone) {
+    try {
+      await notifications.directSend('sms', contact.phone, message);
+    } catch {
+      /* best-effort: SMS provider unavailable */
+    }
+  }
+  if (contact?.email) {
+    try {
+      await notifications.directSend('email', contact.email, message);
+    } catch {
+      /* best-effort: email provider unavailable */
+    }
+  }
+}
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 f1f63802e..48985bdf0 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
@@ -71,6 +71,24 @@ export class BookingNotifierService {
     });
   }
 
+  /** Train carrying the booking departed — dispatched origin → destination. */
+  dispatched(b: Booking, origin: string | null, destination: string | null): void {
+    const msg =
+      `Your booking ${b.reference ?? b.id} has been dispatched` +
+      `${origin || destination ? ` from ${origin ?? '?'} to ${destination ?? '?'}` : ''}.`;
+    void this.notifyContact(b, msg, 'DISPATCHED');
+    this.inApp(b, 'Shipment dispatched', msg);
+  }
+
+  /** Train carrying the booking arrived at destination. */
+  arrived(b: Booking, origin: string | null, destination: string | null): void {
+    const msg =
+      `Your booking ${b.reference ?? b.id} has arrived` +
+      `${destination ? ` at ${destination}` : ''}${origin ? ` (from ${origin})` : ''}.`;
+    void this.notifyContact(b, msg, 'ARRIVED');
+    this.inApp(b, 'Shipment arrived', msg);
+  }
+
   async payNow(b: Booking, deadline: Date): Promise<void> {
     const payMinutes = Math.max(1, Math.round((deadline.getTime() - Date.now()) / 60_000));
     const eat = deadline.toLocaleString('en-GB', { timeZone: 'Africa/Addis_Ababa' });
diff --git a/apps/edr-freight-api/src/modules/train-scheduling/train-scheduling.service.spec.ts b/apps/edr-freight-api/src/modules/train-scheduling/train-scheduling.service.spec.ts
index 7efbceca4..b7938857f 100644
--- a/apps/edr-freight-api/src/modules/train-scheduling/train-scheduling.service.spec.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/train-scheduling.service.spec.ts
@@ -156,6 +156,7 @@ describe('TrainSchedulingService', () => {
       {
         autoArriveAtFinalYard: jest.fn().mockResolvedValue([]),
       } as never, // bookingJourneyService
+      { dispatched: jest.fn(), arrived: jest.fn() } as never, // bookingNotifier
     );
 
     const defaultFleetWagons = [
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 3c75204a6..f858c6c14 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
@@ -72,6 +72,7 @@ import { UpdateScheduleWindowRuleDto } from './dto/update-schedule-window-rule.d
 import { UpdateScheduleDateDto } from './dto/update-schedule-date.dto';
 import { type BookingWindowConfig } from './booking-window.config';
 import { BookingWindowGateway } from './booking-window.gateway';
+import { BookingNotifierService } from './booking-notifier.service';
 import {
   buildCappedWagonPlan,
   computeFleetAvailability,
@@ -281,10 +282,38 @@ export class TrainSchedulingService {
     private readonly pdfDocuments: WarehouseReleaseDocumentService,
     private readonly bookingWindowGateway: BookingWindowGateway,
     private readonly bookingJourneyService: BookingJourneyService,
+    private readonly bookingNotifier: BookingNotifierService,
     @Optional() private readonly milestoneService?: ClearanceMilestoneService,
     private readonly configService?: ConfigService,
   ) {}
 
+  /**
+   * Notify each booking's customer that their shipment was dispatched / arrived,
+   * with a deep-link to the booking. Fire-and-forget — never blocks the action.
+   */
+  private async notifyScheduleBookings(
+    schedule: TrainSchedule,
+    event: 'dispatched' | 'arrived',
+  ): Promise<void> {
+    try {
+      const ids = (schedule.scheduleBookings ?? []).map((sb) => sb.bookingId).filter(Boolean);
+      if (!ids.length) return;
+      const origin = schedule.originStation?.label ?? schedule.originStation?.code ?? null;
+      const destination =
+        schedule.destinationStation?.label ?? schedule.destinationStation?.code ?? null;
+      const bookings = await this.dataSource.getRepository(Booking).find({
+        where: { id: In(ids) },
+        relations: { company: true },
+      });
+      for (const b of bookings) {
+        if (event === 'dispatched') this.bookingNotifier.dispatched(b, origin, destination);
+        else this.bookingNotifier.arrived(b, origin, destination);
+      }
+    } catch (err) {
+      this.logger.warn(`Failed to notify schedule bookings (${event}): ${(err as Error).message}`);
+    }
+  }
+
   /**
    * Complete customer-tracking clearance milestones for every booking on a
    * schedule when a physical lifecycle event fires (dispatch, arrive, load,
@@ -1551,6 +1580,7 @@ export class TrainSchedulingService {
         { originYardId: schedule.originStationId },
       );
     }
+    void this.notifyScheduleBookings(schedule, 'dispatched');
     return this.getTrainScheduleById(scheduleId);
   }
 
@@ -2556,6 +2586,7 @@ export class TrainSchedulingService {
         { destinationYardId: schedule.destinationStationId },
       );
     }
+    void this.notifyScheduleBookings(schedule, 'arrived');
 
     const detail = await this.getTrainScheduleById(scheduleId);
     const warehouseAutomation = await this.runWarehouseArrivalAutomation(scheduleId);
diff --git a/apps/edr-freight-api/src/modules/warehouses/dto/create-warehouse-yard.dto.ts b/apps/edr-freight-api/src/modules/warehouses/dto/create-warehouse-yard.dto.ts
index ccdda90d8..56b9d0810 100644
--- a/apps/edr-freight-api/src/modules/warehouses/dto/create-warehouse-yard.dto.ts
+++ b/apps/edr-freight-api/src/modules/warehouses/dto/create-warehouse-yard.dto.ts
@@ -35,7 +35,7 @@ export class CreateWarehouseYardDto {
   @Min(0)
   capacityContainers?: number;
 
-  @ApiPropertyOptional({ description: 'Max weight capacity (kg). Defaults to capacityWeight.' })
+  @ApiPropertyOptional({ description: 'Max weight capacity (t). Defaults to capacityWeight.' })
   @IsOptional()
   @IsNumber()
   @Min(0)
diff --git a/apps/edr-freight-api/src/modules/warehouses/dto/create-warehouse-zone.dto.ts b/apps/edr-freight-api/src/modules/warehouses/dto/create-warehouse-zone.dto.ts
index fbb057fd5..eb29f751f 100644
--- a/apps/edr-freight-api/src/modules/warehouses/dto/create-warehouse-zone.dto.ts
+++ b/apps/edr-freight-api/src/modules/warehouses/dto/create-warehouse-zone.dto.ts
@@ -35,7 +35,7 @@ export class CreateWarehouseZoneDto {
   @Min(0)
   capacityContainers?: number;
 
-  @ApiPropertyOptional({ description: 'Max weight capacity (kg). Defaults to capacityWeight.' })
+  @ApiPropertyOptional({ description: 'Max weight capacity (t). Defaults to capacityWeight.' })
   @IsOptional()
   @IsNumber()
   @Min(0)
diff --git a/apps/edr-freight-api/src/modules/warehouses/dto/create-warehouse.dto.ts b/apps/edr-freight-api/src/modules/warehouses/dto/create-warehouse.dto.ts
index 5a8025948..a99ca4f46 100644
--- a/apps/edr-freight-api/src/modules/warehouses/dto/create-warehouse.dto.ts
+++ b/apps/edr-freight-api/src/modules/warehouses/dto/create-warehouse.dto.ts
@@ -1,7 +1,7 @@
 import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
 import { IsEnum, IsNumber, IsOptional, IsString, IsUUID, Matches, MaxLength, Min } from 'class-validator';
 
-import { WAREHOUSE_TYPES, WarehouseType } from '../entities/warehouse.entity';
+import { WAREHOUSE_STATUSES, WAREHOUSE_TYPES, WarehouseStatus, WarehouseType } from '../entities/warehouse.entity';
 
 export class CreateWarehouseDto {
   @ApiProperty()
@@ -47,7 +47,7 @@ export class CreateWarehouseDto {
   @Min(0)
   capacityContainers?: number;
 
-  @ApiPropertyOptional({ description: 'Max weight capacity (kg). Defaults to capacityWeight.' })
+  @ApiPropertyOptional({ description: 'Max weight capacity (t). Defaults to capacityWeight.' })
   @IsOptional()
   @IsNumber()
   @Min(0)
@@ -58,4 +58,9 @@ export class CreateWarehouseDto {
   @IsNumber()
   @Min(0)
   maxVolume?: number;
+
+  @ApiPropertyOptional({ enum: WAREHOUSE_STATUSES, default: 'ACTIVE' })
+  @IsOptional()
+  @IsEnum(WAREHOUSE_STATUSES)
+  status?: WarehouseStatus;
 }
diff --git a/apps/edr-freight-api/src/modules/warehouses/dto/load-inventory.dto.ts b/apps/edr-freight-api/src/modules/warehouses/dto/load-inventory.dto.ts
index 063bb7d1d..c81550cd0 100644
--- a/apps/edr-freight-api/src/modules/warehouses/dto/load-inventory.dto.ts
+++ b/apps/edr-freight-api/src/modules/warehouses/dto/load-inventory.dto.ts
@@ -6,7 +6,7 @@ export class LoadInventoryDto {
   @IsUUID()
   wagonId!: string;
 
-  @ApiPropertyOptional({ description: 'Weight loaded onto the wagon (kg)' })
+  @ApiPropertyOptional({ description: 'Weight loaded onto the wagon (t)' })
   @IsOptional()
   @IsNumber()
   @Min(0)
diff --git a/apps/edr-freight-api/src/modules/warehouses/dto/store-inventory.dto.ts b/apps/edr-freight-api/src/modules/warehouses/dto/store-inventory.dto.ts
new file mode 100644
index 000000000..08b15d536
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/warehouses/dto/store-inventory.dto.ts
@@ -0,0 +1,29 @@
+import { ApiPropertyOptional } from '@nestjs/swagger';
+import { IsOptional, IsString, IsUUID } from 'class-validator';
+
+/**
+ * Optional explicit storage location. When warehouse/yard/zone are all provided,
+ * the item is stored there directly; otherwise store() falls back to the
+ * allocation-rule / capacity-balanced auto pick.
+ */
+export class StoreInventoryDto {
+  @ApiPropertyOptional({ format: 'uuid' })
+  @IsOptional()
+  @IsUUID()
+  warehouseId?: string;
+
+  @ApiPropertyOptional({ format: 'uuid' })
+  @IsOptional()
+  @IsUUID()
+  yardId?: string;
+
+  @ApiPropertyOptional({ format: 'uuid' })
+  @IsOptional()
+  @IsUUID()
+  zoneId?: string;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsString()
+  performedBy?: string;
+}
diff --git a/apps/edr-freight-api/src/modules/warehouses/entities/warehouse-inventory.entity.ts b/apps/edr-freight-api/src/modules/warehouses/entities/warehouse-inventory.entity.ts
index 290b6f0c2..a54f40973 100644
--- a/apps/edr-freight-api/src/modules/warehouses/entities/warehouse-inventory.entity.ts
+++ b/apps/edr-freight-api/src/modules/warehouses/entities/warehouse-inventory.entity.ts
@@ -34,7 +34,9 @@ export const WAREHOUSE_INVENTORY_TRANSITIONS: Record<WarehouseInventoryStatus, W
   UNLOADED: ['STORED', 'READY_FOR_PICKUP'],
   UNLOADED_AT_DJIBOUTI_PORT: [],
   RECEIVED: ['STORED', 'READY_FOR_PICKUP'],
-  STORED: ['RESERVED'],
+  // Reserve is retired from the operator flow — a stored export item advances
+  // straight to loading prep. RESERVED kept for any in-flight/legacy items.
+  STORED: ['RESERVED', 'READY_FOR_LOADING'],
   RESERVED: ['READY_FOR_LOADING'],
   READY_FOR_LOADING: ['LOADED'],
   LOADED: ['DISPATCHED'],
diff --git a/apps/edr-freight-api/src/modules/warehouses/handover.service.ts b/apps/edr-freight-api/src/modules/warehouses/handover.service.ts
index 52bd318e1..5df15910e 100644
--- a/apps/edr-freight-api/src/modules/warehouses/handover.service.ts
+++ b/apps/edr-freight-api/src/modules/warehouses/handover.service.ts
@@ -1,7 +1,11 @@
 import { Injectable, Logger } from '@nestjs/common';
+import { NotificationAudience, NotificationType } from '@edr/types';
 import { DataSource, EntityManager, IsNull } from 'typeorm';
 
 import { BookingHandover } from './entities/booking-handover.entity';
+import { NotificationInboxService } from '../notification-inbox/notification-inbox.service';
+import { NotificationsService } from '../notifications/notifications.service';
+import { sendCompanyChannels } from '../notifications/notify-company.util';
 
 /**
  * Import handover records. A booking has one handover per truck (single truck ⇒
@@ -13,7 +17,35 @@ import { BookingHandover } from './entities/booking-handover.entity';
 export class HandoverService {
   private readonly logger = new Logger(HandoverService.name);
 
-  constructor(private readonly dataSource: DataSource) {}
+  constructor(
+    private readonly dataSource: DataSource,
+    private readonly inbox: NotificationInboxService,
+    private readonly notifications: NotificationsService,
+  ) {}
+
+  /** Tell the customer a handover is ready and needs their signature. */
+  private async notifySignNeeded(bookingId: string, reference: string): Promise<void> {
+    try {
+      const [b]: Array<{ companyId: string | null; reference: string }> = await this.dataSource.query(
+        `SELECT company_id AS "companyId", reference FROM freight.bookings WHERE id = $1 AND deleted_at IS NULL`,
+        [bookingId],
+      );
+      if (!b?.companyId) return;
+      const body = `Your import handover ${reference} for booking ${b.reference} is ready. Please review and sign it from the portal before the truck leaves.`;
+      await this.inbox.notify({
+        recipients: { companyId: b.companyId },
+        audience: NotificationAudience.PORTAL,
+        type: NotificationType.DOCUMENT_ACTION,
+        title: 'Handover — signature needed',
+        body,
+        link: `/bookings/${bookingId}`,
+        data: { bookingId, reference },
+      });
+      await sendCompanyChannels(this.dataSource, this.notifications, b.companyId, body);
+    } catch (err) {
+      this.logger.warn(`Failed to notify handover sign for ${bookingId}: ${(err as Error).message}`);
+    }
+  }
 
   list(bookingId: string): Promise<BookingHandover[]> {
     return this.dataSource.getRepository(BookingHandover).find({
@@ -22,6 +54,32 @@ export class HandoverService {
     });
   }
 
+  /**
+   * Ask the customer to sign the booking's handover. Ensures a handover exists
+   * (creates a booking-level self-haul one if none yet), then fires the
+   * sign-needed notification (in-app + SMS + email). Idempotent to re-send.
+   */
+  async requestSignature(
+    bookingId: string,
+  ): Promise<{ notified: boolean; reference: string | null; alreadySigned: boolean }> {
+    const repo = this.dataSource.getRepository(BookingHandover);
+    const existing = await repo.find({ where: { bookingId }, order: { generatedAt: 'ASC' } });
+
+    if (existing.length === 0) {
+      // No handover yet (truck not arrived): create a booking-level one so the
+      // customer has something to sign. ensureForArrivedTruck notifies on create.
+      const created = await this.ensureForArrivedTruck(bookingId, {});
+      return { notified: true, reference: created.reference, alreadySigned: false };
+    }
+
+    const unsigned = existing.find((h) => !h.signedAt);
+    if (!unsigned) {
+      return { notified: false, reference: existing[0].reference, alreadySigned: true };
+    }
+    await this.notifySignNeeded(bookingId, unsigned.reference);
+    return { notified: true, reference: unsigned.reference, alreadySigned: false };
+  }
+
   /**
    * Self-haul: ensure a handover exists for a customer truck that just arrived.
    * Idempotent — one per (booking, truck). Runs inside the caller's transaction
@@ -54,6 +112,7 @@ export class HandoverService {
       }),
     );
     this.logger.log(`Handover ${reference} generated on arrival for booking ${bookingId}`);
+    void this.notifySignNeeded(bookingId, reference);
     return saved;
   }
 
diff --git a/apps/edr-freight-api/src/modules/warehouses/warehouse-inspection.service.ts b/apps/edr-freight-api/src/modules/warehouses/warehouse-inspection.service.ts
index ff25258d3..b5894c21b 100644
--- a/apps/edr-freight-api/src/modules/warehouses/warehouse-inspection.service.ts
+++ b/apps/edr-freight-api/src/modules/warehouses/warehouse-inspection.service.ts
@@ -1,8 +1,13 @@
-import { Injectable, NotFoundException } from '@nestjs/common';
+import { Injectable, Logger, NotFoundException } from '@nestjs/common';
 import { DataSource } from 'typeorm';
 
+import { NotificationAudience, NotificationType } from '@edr/types';
+
 import { FilesService } from '../files/files.service';
 import { LastMileService } from '../last-mile/last-mile.service';
+import { NotificationInboxService } from '../notification-inbox/notification-inbox.service';
+import { NotificationsService } from '../notifications/notifications.service';
+import { sendCompanyChannels } from '../notifications/notify-company.util';
 import { CreateInspectionReportDto } from './dto/create-inspection-report.dto';
 import { UpdateInspectionReportDto } from './dto/update-inspection-report.dto';
 import { WarehouseInspectionReport } from './entities/warehouse-inspection-report.entity';
@@ -13,11 +18,15 @@ const INSPECTION_RESOURCE = 'warehouse-inspection-report';
 
 @Injectable()
 export class WarehouseInspectionService {
+  private readonly logger = new Logger(WarehouseInspectionService.name);
+
   constructor(
     private readonly dataSource: DataSource,
     private readonly inspectionRepository: WarehouseInspectionRepository,
     private readonly filesService: FilesService,
     private readonly lastMileService: LastMileService,
+    private readonly inbox: NotificationInboxService,
+    private readonly notifications: NotificationsService,
   ) {}
 
   /** Create or update the inspection report for an inventory item and sync its inspectionStatus. */
@@ -44,7 +53,7 @@ export class WarehouseInspectionService {
       expectedWeight: expected,
       actualWeight: actual,
       weightLoss,
-      weightLossUnit: weightLoss !== null ? 'kg' : null,
+      weightLossUnit: weightLoss !== null ? 't' : null,
       hasMissingItems: dto.hasMissingItems ?? false,
       missingItemsDescription: dto.missingItemsDescription ?? null,
       remarks: dto.remarks ?? null,
@@ -83,8 +92,10 @@ export class WarehouseInspectionService {
     const [row] = await this.dataSource.query(
       `SELECT inv.booking_id AS "bookingId",
               b.reference AS "bookingReference",
+              b.company_id AS "companyId",
               b.trade_direction AS "tradeDirection",
               b.last_mile_delivery_address AS "lastMileDeliveryAddress",
+              b.customer_truck_assigned_at AS "customerTruckAssignedAt",
               COALESCE(st.includes_last_mile, false) AS "serviceIncludesLastMile"
          FROM freight.warehouse_inventory inv
          LEFT JOIN freight.bookings b ON b.id = inv.booking_id
@@ -105,6 +116,36 @@ export class WarehouseInspectionService {
 
     if (row.bookingReference && hasLastMile) {
       await this.lastMileService.acceptBooking(row.bookingReference);
+    } else if (!hasLastMile && !row.customerTruckAssignedAt) {
+      // Self-haul import: goods are pickup-ready but no collection truck is
+      // assigned yet — nudge the customer to assign one from the portal.
+      void this.notifyTruckAssignmentNeeded(row);
+    }
+  }
+
+  /** Portal nudge: import goods are ready for pickup but no customer truck is assigned. */
+  private async notifyTruckAssignmentNeeded(row: {
+    bookingId?: string | null;
+    bookingReference?: string | null;
+    companyId?: string | null;
+  }): Promise<void> {
+    if (!row.companyId || !row.bookingId) return;
+    const body = `Booking ${row.bookingReference ?? row.bookingId} has passed inspection and is ready for pickup. Please assign your collection truck(s) from the portal to proceed.`;
+    try {
+      await this.inbox.notify({
+        recipients: { companyId: row.companyId },
+        audience: NotificationAudience.PORTAL,
+        type: NotificationType.BOOKING_STATUS,
+        title: 'Assign a truck for pickup',
+        body,
+        link: `/bookings/${row.bookingId}`,
+        data: { bookingId: row.bookingId, action: 'ASSIGN_TRUCK' },
+      });
+      await sendCompanyChannels(this.dataSource, this.notifications, row.companyId, body);
+    } catch (err) {
+      this.logger.warn(
+        `Truck-assignment notify failed for ${row.bookingId}: ${(err as Error).message}`,
+      );
     }
   }
 
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 84baaf4da..242cecc76 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
@@ -9,6 +9,7 @@ import { FilterWarehouseInventoryDto } from './dto/filter-inventory.dto';
 import { InquiryWarehouseInventoryDto } from './dto/inquiry-inventory.dto';
 import { LoadInventoryDto } from './dto/load-inventory.dto';
 import { MoveInventoryDto } from './dto/move-inventory.dto';
+import { StoreInventoryDto } from './dto/store-inventory.dto';
 import { ReceiveWarehouseInventoryDto } from './dto/receive-inventory.dto';
 import { ReleaseOrderDto } from './dto/release-order.dto';
 import { ReserveInventoryDto } from './dto/reserve-inventory.dto';
@@ -267,9 +268,9 @@ export class WarehouseInventoryController {
   }
 
   @Post(':id/store')
-  @ApiOperation({ summary: 'Mark received inventory as STORED' })
-  store(@Param('id', ParseUUIDPipe) id: string, @Body('performedBy') performedBy?: string) {
-    return this.inventoryService.store(id, performedBy);
+  @ApiOperation({ summary: 'Mark received inventory as STORED (optional explicit warehouse/yard/zone)' })
+  store(@Param('id', ParseUUIDPipe) id: string, @Body() dto: StoreInventoryDto) {
+    return this.inventoryService.store(id, dto.performedBy, dto);
   }
 
   @Post(':id/ready-for-loading')
@@ -354,12 +355,34 @@ export class WarehouseInventoryController {
     return this.handoverService.list(bookingId);
   }
 
+  @Post('bookings/:bookingId/request-handover-signature')
+  @ApiOperation({ summary: 'Ask the customer to sign the handover (creates one if none, then notifies)' })
+  requestHandoverSignature(@Param('bookingId', ParseUUIDPipe) bookingId: string) {
+    return this.handoverService.requestSignature(bookingId);
+  }
+
+  @Get('bookings/:bookingId/handover-document')
+  @ApiOperation({ summary: 'View import goods handover document PDF (resolved by booking)' })
+  async bookingHandoverDocument(@Param('bookingId', ParseUUIDPipe) bookingId: string, @Res() res: Response) {
+    const { filename, buffer } = await this.inventoryService.handoverDocumentForBooking(bookingId);
+    res.setHeader('Content-Type', 'application/pdf');
+    res.setHeader('Content-Disposition', `inline; filename="${filename}"`);
+    res.setHeader('Content-Length', buffer.length);
+    return res.send(buffer);
+  }
+
   @Get('bookings/:bookingId/container-items')
   @ApiOperation({ summary: 'Per-container/bulk items of a booking with lifecycle stage + refs' })
   containerItems(@Param('bookingId', ParseUUIDPipe) bookingId: string) {
     return this.inventoryService.containerItems(bookingId);
   }
 
+  @Get('bookings/:bookingId/container-weights')
+  @ApiOperation({ summary: "A booking's containers + VGM cargo weight (tonnes) for exit weighing" })
+  containerWeights(@Param('bookingId', ParseUUIDPipe) bookingId: string) {
+    return this.inventoryService.bookingContainerWeights(bookingId);
+  }
+
   @Post(':id/deliver')
   @ApiOperation({ summary: 'Deliver import goods to the customer + capture proof of delivery' })
   deliver(@Param('id', ParseUUIDPipe) id: string, @Body() dto: DeliverInventoryDto) {
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 d2562fe93..9b2f53a99 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
@@ -7,6 +7,7 @@ import { InterchangeDocumentsService } from '../interchange-documents/interchang
 import type { InterchangeDocument } from '../interchange-documents/entities/interchange-document.entity';
 import { LastMileService } from '../last-mile/last-mile.service';
 import { NotificationsService } from '../notifications/notifications.service';
+import { sendCompanyChannels } from '../notifications/notify-company.util';
 import { SignaturesService } from '../signatures/signatures.service';
 import { BulkInspectDto } from './dto/bulk-inspect.dto';
 import { BulkReceiveDto, TruckEntranceDto } from './dto/bulk-receive.dto';
@@ -39,6 +40,8 @@ import { WarehouseInventoryRepository } from './warehouse-inventory.repository';
 import { WarehouseLoadingRepository } from './warehouse-loading.repository';
 import { WarehouseReleaseDocumentService } from './warehouse-release-document.service';
 import { HandoverService } from './handover.service';
+import { NotificationAudience, NotificationType } from '@edr/types';
+import { NotificationInboxService } from '../notification-inbox/notification-inbox.service';
 
 /** Wagon states that may receive a load (besides being part of an existing schedule). */
 const LOADABLE_WAGON_STATUSES = ['AVAILABLE', 'IMPORT_READY', 'EXPORT_READY', 'ASSIGNED'];
@@ -356,12 +359,14 @@ export interface ImportUnloadedRow {
   customerTruckType: string | null;
   customerTruckContainerNumber: string | null;
   customerTruckAssignedAt: string | null;
+  hasAssignedTruck: boolean;
   currentStatus: string;
   releaseDate: string | null;
   releaseOrderReference: string | null;
   handoverDocumentReference: string | null;
   handoverDocumentDate: string | null;
   deliveredAt: string | null;
+  notes: string | null;
 }
 
 @Injectable()
@@ -383,8 +388,41 @@ export class WarehouseInventoryService {
     private readonly notifications: NotificationsService,
     private readonly signatures: SignaturesService,
     private readonly handover: HandoverService,
+    private readonly inbox: NotificationInboxService,
   ) {}
 
+  /**
+   * When a self-haul booking (no EDR first/last mile) is received to the warehouse
+   * 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.
+   */
+  private async notifyTruckAssignmentNeeded(booking: {
+    companyId?: string | null;
+    reference?: string | null;
+    hasFirstMile?: boolean;
+    hasLastMile?: boolean;
+    customerTruckAssignedAt?: string | null;
+  }, bookingId: string): Promise<void> {
+    if (!booking.companyId) return;
+    if (booking.hasFirstMile || booking.hasLastMile) return; // EDR mile — no customer truck
+    if (booking.customerTruckAssignedAt) return; // already assigned
+    const body = `Booking ${booking.reference ?? bookingId} has been received at the warehouse. Please assign your collection truck(s) from the portal to proceed.`;
+    try {
+      await this.inbox.notify({
+        recipients: { companyId: booking.companyId },
+        audience: NotificationAudience.PORTAL,
+        type: NotificationType.BOOKING_STATUS,
+        title: 'Assign a truck for pickup',
+        body,
+        link: `/bookings/${bookingId}`,
+        data: { bookingId, action: 'ASSIGN_TRUCK' },
+      });
+      await sendCompanyChannels(this.dataSource, this.notifications, booking.companyId, body);
+    } catch (err) {
+      this.logger.warn(`Truck-assignment notify failed for ${bookingId}: ${(err as Error).message}`);
+    }
+  }
+
   /**
    * Batch 6 — final terminal release / gate clearance.
    * Blocked while an unpaid demurrage/storage invoice exists. Does NOT touch
@@ -866,7 +904,10 @@ export class WarehouseInventoryService {
                   b.customer_truck_driver_name AS "customerTruckDriverName",
                   b.customer_truck_type AS "customerTruckType",
                   b.customer_truck_container_number AS "customerTruckContainerNumber",
-                  b.customer_truck_assigned_at AS "customerTruckAssignedAt"
+                  b.customer_truck_assigned_at AS "customerTruckAssignedAt",
+                  b.company_id AS "companyId",
+                  (NULLIF(TRIM(COALESCE(b.last_mile_delivery_address, '')), '') IS NOT NULL
+                    OR COALESCE(st.includes_last_mile, false)) AS "hasLastMile"
              FROM freight.bookings b
              LEFT JOIN freight.companies company ON company.id = b.company_id
              LEFT JOIN freight.yards oy ON oy.id = b.origin_yard_id
@@ -1002,6 +1043,7 @@ export class WarehouseInventoryService {
 
         result.receivedCount += 1;
         result.results.push({ bookingId, status: 'RECEIVED', inventoryId: saved.id, grnNumber });
+        void this.notifyTruckAssignmentNeeded(booking, bookingId);
       }
     });
 
@@ -1301,12 +1343,18 @@ export class WarehouseInventoryService {
               b.customer_truck_type AS "customerTruckType",
               b.customer_truck_container_number AS "customerTruckContainerNumber",
               b.customer_truck_assigned_at AS "customerTruckAssignedAt",
+              (b.customer_truck_assigned_at IS NOT NULL
+                OR EXISTS (SELECT 1 FROM freight.last_mile lm
+                            WHERE lm.booking_id = b.id
+                              AND lm.vehicle_id IS NOT NULL
+                              AND lm.deleted_at IS NULL)) AS "hasAssignedTruck",
               inv.status               AS "currentStatus",
               inv.release_date         AS "releaseDate",
               inv.release_order_reference AS "releaseOrderReference",
               substring(inv.notes FROM 'Handover Reference: ([^\\n\\r]+)') AS "handoverDocumentReference",
               substring(inv.notes FROM 'Generated At: ([^\\n\\r]+)') AS "handoverDocumentDate",
               inv.delivered_at         AS "deliveredAt",
+              inv.notes                AS "notes",
               oy.country               AS "originCountry",
               dy.country               AS "destinationCountry"
          FROM freight.warehouse_inventory inv
@@ -2020,7 +2068,7 @@ export class WarehouseInventoryService {
             activityType: 'INVENTORY_RECEIVED',
             inventoryId: saved.id,
             warehouseId: dto.warehouseId,
-            description: `GRN ${grnNumber}: received ${weight}kg via truck ${truckEntrance.truckPlateNumber}`,
+            description: `GRN ${grnNumber}: received ${weight}t via truck ${truckEntrance.truckPlateNumber}`,
             performedBy: dto.performedBy,
           },
           manager,
@@ -2104,13 +2152,30 @@ export class WarehouseInventoryService {
 
   // ── Lifecycle transitions ────────────────────────────────────────────────
 
-  async store(id: string, performedBy?: string): Promise<WarehouseInventory> {
+  async store(
+    id: string,
+    performedBy?: string,
+    chosen?: { warehouseId?: string; yardId?: string; zoneId?: string },
+  ): Promise<WarehouseInventory> {
     const item = await this.findById(id);
     this.assertTransition(item.status, 'STORED');
 
+    // Explicit location wins when the operator picked warehouse + yard + zone;
+    // otherwise fall back to the allocation-rule / capacity-balanced auto pick.
+    const manualLocation =
+      chosen?.warehouseId && chosen?.yardId && chosen?.zoneId
+        ? {
+            warehouseId: chosen.warehouseId,
+            yardId: chosen.yardId,
+            zoneId: chosen.zoneId,
+            path: undefined as string | undefined,
+          }
+        : null;
+
     const criteria = await this.getInventoryAllocationCriteria(item);
-    const ruleLocation = await this.allocation.resolveLocation(criteria);
-    const location = ruleLocation ?? (await this.pickCapacityBalancedStorageLocation(item, criteria));
+    const ruleLocation = manualLocation ? null : await this.allocation.resolveLocation(criteria);
+    const location =
+      manualLocation ?? ruleLocation ?? (await this.pickCapacityBalancedStorageLocation(item, criteria));
 
     if (!location) {
       throw new BadRequestException('No active warehouse yard/zone is available for this inventory item');
@@ -2154,18 +2219,19 @@ export class WarehouseInventoryService {
         await this.applyCapacityDelta(manager, location, weight, volume, containerCount);
       }
 
+      const storedReason = manualLocation
+        ? `Stored at operator-selected location -> ${location.path ?? 'chosen yard/zone'}`
+        : ruleLocation?.rule
+          ? `Stored by allocation rule "${ruleLocation.rule.name}" -> ${ruleLocation.path}`
+          : `Stored by capacity-balanced allocation -> ${location.path ?? 'assigned yard/zone'}`;
+
       await manager.getRepository(WarehouseInventory).update(id, {
         status: 'STORED',
         storedAt: new Date(),
         warehouseId: location.warehouseId,
         yardId: location.yardId,
         zoneId: location.zoneId,
-        notes: this.appendNote(
-          locked.notes,
-          ruleLocation?.rule
-            ? `Stored by allocation rule "${ruleLocation.rule.name}" -> ${ruleLocation.path}`
-            : `Stored by capacity-balanced allocation -> ${location.path ?? 'assigned yard/zone'}`,
-        ),
+        notes: this.appendNote(locked.notes, storedReason),
       });
 
       await this.activityLog.record(
@@ -2173,9 +2239,7 @@ export class WarehouseInventoryService {
           activityType: 'INVENTORY_STORED',
           inventoryId: id,
           warehouseId: location.warehouseId,
-          description: ruleLocation?.rule
-            ? `Inventory stored by rule "${ruleLocation.rule.name}" at ${ruleLocation.path}`
-            : `Inventory stored at ${location.path ?? 'assigned yard/zone'}`,
+          description: storedReason.replace(/^Stored/, 'Inventory stored'),
           performedBy,
         },
         manager,
@@ -2294,6 +2358,26 @@ export class WarehouseInventoryService {
             'Customer must sign the handover before the exit paper can be generated',
           );
         }
+
+        // Authoritative weight match: the truck's net (gross − tare) must equal the
+        // total VGM cargo weight of the containers selected as loaded on it.
+        if (dto.containerNumber && dto.grossWeight != null && dto.tareWeight != null) {
+          const selected = dto.containerNumber
+            .split(/[,;\n]+/)
+            .map((n) => n.trim())
+            .filter(Boolean);
+          if (selected.length) {
+            const weights = await this.bookingContainerWeights(item.bookingId);
+            const byNumber = new Map(weights.map((w) => [w.containerNumber.toUpperCase(), w.weightTons]));
+            const expected = selected.reduce((sum, n) => sum + (byNumber.get(n.toUpperCase()) ?? 0), 0);
+            const computedNet = Number((dto.grossWeight - dto.tareWeight).toFixed(3));
+            if (expected > 0 && Math.abs(computedNet - expected) > 0.001) {
+              throw new BadRequestException(
+                `Weight mismatch: gross − tare (${computedNet} t) must equal the selected containers' cargo weight (${expected} t).`,
+              );
+            }
+          }
+        }
       }
     }
     const releaseDate = isTruckLeaving
@@ -2519,15 +2603,17 @@ export class WarehouseInventoryService {
     Array<{
       containerNumber: string;
       goods: string | null;
-      stage: 'PENDING' | 'RECEIVED' | 'GRN' | 'LOADED' | 'LEFT' | 'DELIVERED';
+      stage: 'PENDING' | 'RECEIVED' | 'GRN' | 'ASSIGNED' | 'LOADED' | 'LEFT' | 'DELIVERED';
       grnNumber: string | null;
       truckAssignmentId: string | null;
       truckPlate: string | null;
       truckArrived: boolean;
       truckLeft: boolean;
+      loaded: boolean;
       bookingReference: string | null;
       contractId: string | null;
       hasLastMile: boolean;
+      handoverSigned: boolean;
     }>
   > {
     const rows: Array<{
@@ -2539,6 +2625,7 @@ export class WarehouseInventoryService {
       truckPlate: string | null;
       truckArrived: boolean;
       truckLeft: boolean;
+      loaded: boolean;
       bookingReference: string | null;
       contractId: string | null;
       hasLastMile: boolean;
@@ -2552,6 +2639,7 @@ export class WarehouseInventoryService {
               a.plate_number AS "truckPlate",
               (a.arrived_at IS NOT NULL) AS "truckArrived",
               (a.departed_at IS NOT NULL) AS "truckLeft",
+              (ctc.loaded_at IS NOT NULL) AS loaded,
               b.reference AS "bookingReference",
               b.contract_id AS "contractId",
               (b.last_mile_delivery_address IS NOT NULL) AS "hasLastMile",
@@ -2574,28 +2662,64 @@ export class WarehouseInventoryService {
       [bookingId],
     );
 
+    // Booking-level gate: the per-truck exit paper is blocked until the handover
+    // is fully signed, so the UI can disable "Exit Paper" with a clear reason.
+    const handoverSigned = await this.handover.isFullySigned(bookingId);
+
     return rows.map((r) => ({
       containerNumber: r.containerNumber,
       goods: r.goods,
+      // A container the customer assigned to a truck is ASSIGNED (planned); it
+      // only becomes LOADED once the operator loads it (loaded_at) on truck
+      // leaving. Departed → LEFT, delivered → DELIVERED.
       stage: r.delivered
         ? 'DELIVERED'
         : r.truckLeft
           ? 'LEFT'
-          : r.truckAssignmentId
+          : r.loaded
             ? 'LOADED'
-            : r.grnNumber
-              ? 'GRN'
-              : r.received
-                ? 'RECEIVED'
-                : 'PENDING',
+            : r.truckAssignmentId
+              ? 'ASSIGNED'
+              : r.grnNumber
+                ? 'GRN'
+                : r.received
+                  ? 'RECEIVED'
+                  : 'PENDING',
       grnNumber: r.grnNumber,
       truckAssignmentId: r.truckAssignmentId,
       truckPlate: r.truckPlate,
       truckArrived: r.truckArrived,
       truckLeft: r.truckLeft,
+      loaded: r.loaded,
       bookingReference: r.bookingReference,
       contractId: r.contractId,
       hasLastMile: r.hasLastMile,
+      handoverSigned,
+    }));
+  }
+
+  /**
+   * The booking's containers with their VGM cargo weight (tonnes), keyed by
+   * container number. Drives the truck-leaving exit weighing: the selected
+   * containers' total cargo weight must match (gross − tare).
+   */
+  async bookingContainerWeights(
+    bookingId: string,
+  ): Promise<Array<{ containerNumber: string; weightTons: number }>> {
+    const rows: Array<{ containerNumber: string; weightTons: string }> =
+      await this.dataSource.query(
+        `SELECT bcu.container_number AS "containerNumber",
+                COALESCE(bcu.vgm_tons, 0) AS "weightTons"
+           FROM freight.booking_container_units bcu
+           JOIN freight.booking_container bc
+             ON bc.id = bcu.booking_container_id AND bc.deleted_at IS NULL
+          WHERE bc.booking_id = $1 AND bcu.deleted_at IS NULL
+          ORDER BY bcu.container_number`,
+        [bookingId],
+      );
+    return rows.map((r) => ({
+      containerNumber: r.containerNumber,
+      weightTons: Number(r.weightTons) || 0,
     }));
   }
 
@@ -2677,7 +2801,7 @@ export class WarehouseInventoryService {
       ['Pickup Truck Plate', data.plateNumber],
       ['Driver', data.driverName],
       ['Truck Type', data.truckType],
-      ['Gross Weight (Loaded on Truck)', `${data.grossWeightKg.toLocaleString()} kg`],
+      ['Gross Weight (Loaded on Truck)', `${data.grossWeightKg.toLocaleString()} t`],
       ['Gate-Out Time', gateOut],
       ['Clearance Status', 'CLEARED FOR WAREHOUSE EXIT'],
     ];
@@ -2901,6 +3025,21 @@ export class WarehouseInventoryService {
     };
   }
 
+  /** Handover PDF resolved by booking (for the portal, which only has bookingId). */
+  async handoverDocumentForBooking(bookingId: string): Promise<{ filename: string; buffer: Buffer }> {
+    const [inv]: Array<{ id: string }> = await this.dataSource.query(
+      `SELECT id FROM freight.warehouse_inventory
+        WHERE booking_id = $1 AND deleted_at IS NULL
+        ORDER BY updated_at DESC NULLS LAST, created_at DESC
+        LIMIT 1`,
+      [bookingId],
+    );
+    if (!inv) {
+      throw new NotFoundException(`No warehouse inventory found for booking ${bookingId}`);
+    }
+    return this.handoverDocument(inv.id);
+  }
+
   async handoverDocument(id: string): Promise<{ filename: string; buffer: Buffer }> {
     const [row] = await this.dataSource.query(
       `SELECT inv.id,
@@ -3127,7 +3266,22 @@ export class WarehouseInventoryService {
             [item.bookingId],
           );
         } else {
-          await this.handover.ensureAtDelivery(item.bookingId, {}, manager);
+          // EDR last-mile: the handover is per delivering truck. Resolve the
+          // vehicle that carried this item's container so each truck gets its own
+          // handover (falls back to a booking-level one when unresolvable).
+          let truckPlate: string | null = null;
+          if (item.containerId) {
+            const [veh]: Array<{ plate: string | null }> = await manager.query(
+              `SELECT COALESCE(v.power_plate_no, v.plate_number) AS plate
+                 FROM freight.last_mile_container_allocations lca
+                 JOIN freight.vehicles v ON v.id = lca.vehicle_id
+                WHERE lca.container_id = $1 AND lca.vehicle_id IS NOT NULL
+                LIMIT 1`,
+              [item.containerId],
+            );
+            truckPlate = veh?.plate ?? null;
+          }
+          await this.handover.ensureAtDelivery(item.bookingId, { truckPlate }, manager);
         }
       }
     });
@@ -3608,8 +3762,8 @@ export class WarehouseInventoryService {
       ['Booking Containers', data.bookingContainerSummary],
       ['Cargo / Goods Description', data.cargoDescription],
       ['Quantity', data.quantity],
-      ['Received Weight', `${data.weight.toLocaleString()} kg`],
-      ['Booking Declared Weight', data.bookingDeclaredWeight ? `${data.bookingDeclaredWeight.toLocaleString()} kg` : null],
+      ['Received Weight', `${data.weight.toLocaleString()} t`],
+      ['Booking Declared Weight', data.bookingDeclaredWeight ? `${data.bookingDeclaredWeight.toLocaleString()} t` : null],
       ['Volume', data.volume == null ? null : data.volume.toLocaleString()],
       ['Warehouse', data.warehouse],
       ['Yard', data.yard],
@@ -3731,7 +3885,7 @@ export class WarehouseInventoryService {
         `${(data.truckPlateNumber && data.truckWeightKg
           ? data.truckWeightKg
           : data.weight
-        ).toLocaleString()} kg`,
+        ).toLocaleString()} t`,
       ],
       ['Warehouse', data.warehouse],
       ['Yard', data.yard],
@@ -3894,8 +4048,8 @@ export class WarehouseInventoryService {
       ['Booking Containers', data.bookingContainerSummary],
       ['Cargo / Goods Description', data.cargoDescription],
       ['Quantity', data.quantity],
-      ['Inventory Weight', `${data.weight.toLocaleString()} kg`],
-      ['Booking Declared Weight', data.bookingDeclaredWeight ? `${data.bookingDeclaredWeight.toLocaleString()} kg` : null],
+      ['Inventory Weight', `${data.weight.toLocaleString()} t`],
+      ['Booking Declared Weight', data.bookingDeclaredWeight ? `${data.bookingDeclaredWeight.toLocaleString()} t` : null],
       ['Warehouse', data.warehouse],
       ['Yard', data.yard],
       ['Zone', data.zone],
@@ -3968,8 +4122,8 @@ export class WarehouseInventoryService {
       <tr><th>1. Goods</th><td>${esc(data.cargoDescription || data.containerNumber || data.bookingReference)}</td></tr>
       <tr><th>Container</th><td>${esc(data.containerNumber)}</td></tr>
       <tr><th>Booking Containers</th><td>${esc(data.bookingContainerSummary)}</td></tr>
-      <tr><th>Inventory Weight</th><td>${esc(`${data.weight.toLocaleString()} kg`)}</td></tr>
-      <tr><th>Booking Declared Weight</th><td>${esc(data.bookingDeclaredWeight ? `${data.bookingDeclaredWeight.toLocaleString()} kg` : null)}</td></tr>
+      <tr><th>Inventory Weight</th><td>${esc(`${data.weight.toLocaleString()} t`)}</td></tr>
+      <tr><th>Booking Declared Weight</th><td>${esc(data.bookingDeclaredWeight ? `${data.bookingDeclaredWeight.toLocaleString()} t` : null)}</td></tr>
     </tbody>
   </table>
   <div class="section-title">Handover Clause</div>
@@ -4303,9 +4457,9 @@ export class WarehouseInventoryService {
       dto.truckType?.trim() ? `Truck Type: ${dto.truckType.trim()}` : null,
       dto.containerNumber?.trim() ? `Container Number: ${dto.containerNumber.trim()}` : null,
       dto.gateInTime ? `Gate In Time: ${dto.gateInTime}` : null,
-      `Tare Weight: ${tareWeight} kg`,
-      grossWeight == null ? null : `Gross Weight: ${grossWeight} kg`,
-      computedNetWeight == null ? null : `Net Weight: ${computedNetWeight} kg`,
+      `Tare Weight: ${tareWeight} t`,
+      grossWeight == null ? null : `Gross Weight: ${grossWeight} t`,
+      computedNetWeight == null ? null : `Net Weight: ${computedNetWeight} t`,
       dto.gateOutTime ? `Gate Out Time: ${dto.gateOutTime}` : null,
     ];
 
@@ -4357,7 +4511,7 @@ export class WarehouseInventoryService {
   }
 
   private extractExitInspectionNumber(note: string | null | undefined, label: string): number | undefined {
-    const value = this.extractExitInspectionLine(note, label)?.replace(/\s*kg$/i, '');
+    const value = this.extractExitInspectionLine(note, label)?.replace(/\s*(kg|t)$/i, '');
     if (!value) return undefined;
     const parsed = Number(value);
     return Number.isFinite(parsed) ? parsed : undefined;
@@ -4420,9 +4574,9 @@ export class WarehouseInventoryService {
       truck?.driverName ? `Driver: ${truck.driverName}` : null,
       truck?.driverPhone ? `Driver Phone: ${truck.driverPhone}` : null,
       truck?.driverLicenseNumber ? `Driver License: ${truck.driverLicenseNumber}` : null,
-      truck?.entranceTareWeightKg !== undefined ? `Entrance Tare Weight: ${Number(truck.entranceTareWeightKg)} kg` : null,
+      truck?.entranceTareWeightKg !== undefined ? `Entrance Tare Weight: ${Number(truck.entranceTareWeightKg)} t` : null,
       truck?.weighingRequired !== undefined ? `Weighing Required: ${truck.weighingRequired ? 'Yes' : 'No'}` : null,
-      truck?.exitTareWeightKg !== undefined ? `Exit Tare Weight: ${Number(truck.exitTareWeightKg)} kg` : null,
+      truck?.exitTareWeightKg !== undefined ? `Exit Tare Weight: ${Number(truck.exitTareWeightKg)} t` : null,
       truck?.declarationNumber ? `Declaration / Bill of Entry: ${truck.declarationNumber}` : null,
       truck?.incoterms ? `Incoterms: ${truck.incoterms}` : null,
       truck?.hsCodes ? `HS Codes: ${truck.hsCodes}` : null,
@@ -4430,8 +4584,8 @@ export class WarehouseInventoryService {
       truck?.itemDescription ? `Item Description: ${truck.itemDescription}` : null,
       truck?.packagingType ? `Packaging Type: ${truck.packagingType}` : null,
       truck?.unitCount !== undefined ? `Unit Count: ${Number(truck.unitCount)}` : null,
-      truck?.grossWeightKg !== undefined ? `Gross Weight: ${Number(truck.grossWeightKg)} kg` : null,
-      truck?.netWeightKg !== undefined ? `Net Weight: ${Number(truck.netWeightKg)} kg` : null,
+      truck?.grossWeightKg !== undefined ? `Gross Weight: ${Number(truck.grossWeightKg)} t` : null,
+      truck?.netWeightKg !== undefined ? `Net Weight: ${Number(truck.netWeightKg)} t` : null,
       truck?.volumeDimensions ? `Volume / Dimensions: ${truck.volumeDimensions}` : null,
       truck?.conditionAtReceipt ? `Condition at Receipt: ${truck.conditionAtReceipt}` : null,
       truck?.damagedRejectedQuantity !== undefined ? `Damaged / Rejected Quantity: ${Number(truck.damagedRejectedQuantity)}` : null,
diff --git a/apps/edr-freight-api/src/modules/warehouses/warehouse-invoice.service.ts b/apps/edr-freight-api/src/modules/warehouses/warehouse-invoice.service.ts
index 9ee1dc398..2508e373a 100644
--- a/apps/edr-freight-api/src/modules/warehouses/warehouse-invoice.service.ts
+++ b/apps/edr-freight-api/src/modules/warehouses/warehouse-invoice.service.ts
@@ -6,9 +6,11 @@ import {
   NotFoundException,
 } from "@nestjs/common";
 import { OnEvent } from "@nestjs/event-emitter";
-import { Freight } from "@edr/types";
+import { Freight, NotificationAudience, NotificationType } from "@edr/types";
 import { DataSource } from "typeorm";
 
+import { NotificationInboxService } from "../notification-inbox/notification-inbox.service";
+
 import {
   BillingService,
   InvoiceEventPayload,
@@ -135,6 +137,7 @@ export class WarehouseInvoiceService {
     private readonly invoiceDocuments: InvoiceDocumentService,
     private readonly feeService: WarehouseFeeService,
     private readonly notifications: NotificationsService,
+    private readonly inbox: NotificationInboxService,
   ) { }
 
   // ── Generation ───────────────────────────────────────────────────────────
@@ -968,6 +971,25 @@ export class WarehouseInvoiceService {
       message,
       `warehouse fee invoice ${invoice.invoiceNumber}`,
     );
+
+    // In-app deep-link to pay the fee from the booking.
+    if (invoice.customerId && invoice.bookingId) {
+      try {
+        await this.inbox.notify({
+          recipients: { companyId: invoice.customerId },
+          audience: NotificationAudience.PORTAL,
+          type: NotificationType.INVOICE_ISSUED,
+          title: "Warehouse fee due",
+          body:
+            `Warehouse ${invoice.invoiceType.replace(/_/g, " ").toLowerCase()} fee ${invoice.invoiceNumber} is due — ` +
+            `${Number(invoice.totalAmount).toLocaleString()} ${invoice.currency}. Pay from the portal before cargo pickup.`,
+          link: `/bookings/${invoice.bookingId}`,
+          data: { bookingId: invoice.bookingId, invoiceNumber: invoice.invoiceNumber },
+        });
+      } catch (err) {
+        this.logger.warn(`In-app warehouse fee notify failed: ${(err as Error).message}`);
+      }
+    }
   }
 
   private async notifyWarehouseFeePayment(
diff --git a/apps/edr-freight-api/src/modules/warehouses/warehouses.module.ts b/apps/edr-freight-api/src/modules/warehouses/warehouses.module.ts
index 5f0ce5749..4011bc14f 100644
--- a/apps/edr-freight-api/src/modules/warehouses/warehouses.module.ts
+++ b/apps/edr-freight-api/src/modules/warehouses/warehouses.module.ts
@@ -9,6 +9,7 @@ import { FilesModule } from '../files/files.module';
 import { InterchangeDocumentsModule } from '../interchange-documents/interchange-documents.module';
 import { LastMileModule } from '../last-mile/last-mile.module';
 import { NotificationsModule } from '../notifications/notifications.module';
+import { NotificationInboxModule } from '../notification-inbox/notification-inbox.module';
 import { SignaturesModule } from '../signatures/signatures.module';
 import { WarehouseActivityLog } from './entities/warehouse-activity-log.entity';
 import { WarehouseAllocationRule } from './entities/warehouse-allocation-rule.entity';
@@ -75,6 +76,7 @@ import { WarehousesService } from './warehouses.service';
     InterchangeDocumentsModule,
     forwardRef(() => LastMileModule),
     NotificationsModule,
+    NotificationInboxModule,
     SignaturesModule,
     ExchangeModule.forRootAsync({
       inject: [ConfigService],
diff --git a/apps/edr-freight-api/src/modules/warehouses/warehouses.service.ts b/apps/edr-freight-api/src/modules/warehouses/warehouses.service.ts
index f92401dfc..140d9f6b4 100644
--- a/apps/edr-freight-api/src/modules/warehouses/warehouses.service.ts
+++ b/apps/edr-freight-api/src/modules/warehouses/warehouses.service.ts
@@ -64,8 +64,8 @@ export class WarehousesService {
         currentWeight: 0,
         currentContainers: 0,
         currentVolume: 0,
-        status: 'ACTIVE',
-        isActive: true,
+        status: dto.status ?? 'ACTIVE',
+        isActive: (dto.status ?? 'ACTIVE') === 'ACTIVE',
       });
     } catch (error) {
       this.mapDbError(error);
diff --git a/apps/edr-freight-api/src/seed/freight-permissions.registry.ts b/apps/edr-freight-api/src/seed/freight-permissions.registry.ts
index d4d85e84c..8d70bc61c 100644
--- a/apps/edr-freight-api/src/seed/freight-permissions.registry.ts
+++ b/apps/edr-freight-api/src/seed/freight-permissions.registry.ts
@@ -204,6 +204,7 @@ export const FLEET_ROAD_PERMISSIONS: FreightPermissionSeed[] = [
   perm('e2b00001-0001-4000-8000-000000000003', 'edr_freight_app:drivers:update', 'Update driver'),
   perm('e2b00001-0001-4000-8000-000000000004', 'edr_freight_app:drivers:delete', 'Delete driver'),
   perm('e2c00001-0001-4000-8000-000000000001', 'edr_freight_app:tracking:view', 'Track vehicles'),
+  perm('e2c00001-0001-4000-8000-000000000002', 'edr_freight_app:tracking:manage', 'Manage GPS trackers'),
   perm('e2d00001-0001-4000-8000-000000000001', 'edr_freight_app:fuel:view', 'View fuel purchases'),
   perm('e2d00001-0001-4000-8000-000000000002', 'edr_freight_app:fuel:create', 'Create fuel purchase'),
   perm('e2d00001-0001-4000-8000-000000000003', 'edr_freight_app:fuel:update', 'Update fuel purchase'),
@@ -477,6 +478,7 @@ export const FREIGHT_PERMS = {
   },
   tracking: {
     view: 'edr_freight_app:tracking:view',
+    manage: 'edr_freight_app:tracking:manage',
   },
   fuel: {
     view: 'edr_freight_app:fuel:view',
diff --git a/apps/edr-freight-web/backoffice/.env.example b/apps/edr-freight-web/backoffice/.env.example
index cbbdd289f..a5e34a35d 100644
--- a/apps/edr-freight-web/backoffice/.env.example
+++ b/apps/edr-freight-web/backoffice/.env.example
@@ -1,2 +1,6 @@
 VITE_API_URL=http://localhost:3001
 VITE_BASE_API_URL=http://localhost:3001
+
+# Proactive token refresh cadence (minutes). Must stay well under the 60-min
+# server session window. Default: 10.
+VITE_TOKEN_REFRESH_INTERVAL_MINUTES=10
diff --git a/apps/edr-freight-web/backoffice/src/auth/AuthProvider.tsx b/apps/edr-freight-web/backoffice/src/auth/AuthProvider.tsx
index 66834c9f5..8266d96d7 100644
--- a/apps/edr-freight-web/backoffice/src/auth/AuthProvider.tsx
+++ b/apps/edr-freight-web/backoffice/src/auth/AuthProvider.tsx
@@ -16,6 +16,10 @@ import {
   setCookie,
 } from "./cookies";
 import { applyTokens } from "./http";
+import {
+  startTokenRefreshScheduler,
+  stopTokenRefreshScheduler,
+} from "./refreshScheduler";
 import type { AuthTokens, AuthUser } from "./types";
 
 interface LoginPayload {
@@ -99,6 +103,18 @@ export const AuthProvider = ({ children }: { children: ReactNode }) => {
     void bootstrap();
   }, []);
 
+  // Keep the server session alive while a user is logged in. Runs after
+  // login, MFA verification, and page-reload bootstrap alike.
+  useEffect(() => {
+    if (!user) {
+      stopTokenRefreshScheduler();
+      return;
+    }
+
+    startTokenRefreshScheduler();
+    return stopTokenRefreshScheduler;
+  }, [user]);
+
   const value = useMemo<AuthContextValue>(
     () => ({
       user,
diff --git a/apps/edr-freight-web/backoffice/src/auth/http.ts b/apps/edr-freight-web/backoffice/src/auth/http.ts
index 5aa78e2d3..2b0cf1021 100644
--- a/apps/edr-freight-web/backoffice/src/auth/http.ts
+++ b/apps/edr-freight-web/backoffice/src/auth/http.ts
@@ -28,6 +28,30 @@ const applyTokens = ({ token, refreshToken }: AuthTokens) => {
   setCookie(REFRESH_TOKEN_COOKIE, refreshToken);
 };
 
+/**
+ * Single-flight token refresh: concurrent callers (the 401 interceptor and
+ * the proactive scheduler) share one in-flight request so the refresh token
+ * is only rotated once. Throws if no refresh token is stored or the server
+ * rejects it — callers decide how to end the session.
+ */
+const refreshSessionTokens = async (): Promise<AuthTokens> => {
+  const refreshToken = getCookie(REFRESH_TOKEN_COOKIE);
+  if (!refreshToken) {
+    throw new Error("missing refresh token");
+  }
+
+  refreshPromise ??= api
+    .post<AuthTokens>("/auth/refresh-token", { refreshToken })
+    .then((response) => response.data)
+    .finally(() => {
+      refreshPromise = null;
+    });
+
+  const tokens = await refreshPromise;
+  applyTokens(tokens);
+  return tokens;
+};
+
 api.interceptors.request.use((config) => {
   const token = getCookie(AUTH_TOKEN_COOKIE);
 
@@ -65,8 +89,7 @@ api.interceptors.response.use(
       return Promise.reject(error);
     }
 
-    const refreshToken = getCookie(REFRESH_TOKEN_COOKIE);
-    if (!refreshToken) {
+    if (!getCookie(REFRESH_TOKEN_COOKIE)) {
       clearSessionCookies();
       return Promise.reject(error);
     }
@@ -74,15 +97,7 @@ api.interceptors.response.use(
     originalRequest._retry = true;
 
     try {
-      refreshPromise ??= api
-        .post<AuthTokens>("/auth/refresh-token", { refreshToken })
-        .then((response) => response.data)
-        .finally(() => {
-          refreshPromise = null;
-        });
-
-      const tokens = await refreshPromise;
-      applyTokens(tokens);
+      const tokens = await refreshSessionTokens();
       originalRequest.headers = {
         ...originalRequest.headers,
         Authorization: `Bearer ${tokens.token}`,
@@ -97,4 +112,4 @@ api.interceptors.response.use(
   },
 );
 
-export { api, applyTokens };
+export { api, applyTokens, refreshSessionTokens };
diff --git a/apps/edr-freight-web/backoffice/src/auth/refreshScheduler.ts b/apps/edr-freight-web/backoffice/src/auth/refreshScheduler.ts
new file mode 100644
index 000000000..1d2c14db2
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/auth/refreshScheduler.ts
@@ -0,0 +1,82 @@
+import { isAxiosError } from "axios";
+
+import {
+  REFRESH_TOKEN_COOKIE,
+  clearSessionCookies,
+  getCookie,
+} from "./cookies";
+import { refreshSessionTokens } from "./http";
+
+/**
+ * Proactively refreshes the token pair on a fixed cadence so the server-side
+ * session (a sliding 1-hour window, extended only by /auth/refresh-token) is
+ * kept alive while the app is open. The 401 interceptor in http.ts remains
+ * the reactive fallback; both share the same single-flight refresh call.
+ *
+ * The interval MUST stay well under the server session window (60 min).
+ */
+const DEFAULT_INTERVAL_MINUTES = 10;
+
+const getIntervalMs = () => {
+  const minutes = Number(import.meta.env.VITE_TOKEN_REFRESH_INTERVAL_MINUTES);
+  return (
+    (Number.isFinite(minutes) && minutes > 0
+      ? minutes
+      : DEFAULT_INTERVAL_MINUTES) * 60_000
+  );
+};
+
+let timerId: number | null = null;
+let lastRefreshAt = 0;
+
+const refreshNow = async () => {
+  if (!getCookie(REFRESH_TOKEN_COOKIE)) {
+    // Logged out elsewhere; nothing to keep alive.
+    stopTokenRefreshScheduler();
+    return;
+  }
+
+  try {
+    await refreshSessionTokens();
+    lastRefreshAt = Date.now();
+  } catch (error) {
+    // Network hiccups are retried on the next tick; only an explicit server
+    // rejection means the session is dead.
+    if (isAxiosError(error) && error.response) {
+      stopTokenRefreshScheduler();
+      clearSessionCookies();
+      window.location.replace("/auth");
+    }
+  }
+};
+
+/**
+ * Browsers freeze timers in background tabs — a tab waking up past its
+ * refresh deadline refreshes immediately instead of waiting a full interval.
+ */
+const onVisibilityChange = () => {
+  if (document.visibilityState !== "visible") return;
+  if (Date.now() - lastRefreshAt >= getIntervalMs()) {
+    void refreshNow();
+  }
+};
+
+export const startTokenRefreshScheduler = () => {
+  stopTokenRefreshScheduler();
+
+  // Token age is unknown here (fresh login vs. hours-old page reload), so
+  // refresh right away to extend the session window from "now".
+  lastRefreshAt = 0;
+  void refreshNow();
+
+  timerId = window.setInterval(() => void refreshNow(), getIntervalMs());
+  document.addEventListener("visibilitychange", onVisibilityChange);
+};
+
+export const stopTokenRefreshScheduler = () => {
+  if (timerId !== null) {
+    window.clearInterval(timerId);
+    timerId = null;
+  }
+  document.removeEventListener("visibilitychange", onVisibilityChange);
+};
diff --git a/apps/edr-freight-web/backoffice/src/components/customers/ChangeRequestReview.tsx b/apps/edr-freight-web/backoffice/src/components/customers/ChangeRequestReview.tsx
new file mode 100644
index 000000000..924d62436
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/components/customers/ChangeRequestReview.tsx
@@ -0,0 +1,379 @@
+import {
+  Alert,
+  Anchor,
+  Badge,
+  Box,
+  Button,
+  Card,
+  Group,
+  Modal,
+  SimpleGrid,
+  Stack,
+  Text,
+  Textarea,
+} from "@mantine/core";
+import { useQuery, useMutation } from "@tanstack/react-query";
+import {
+  AlertTriangle,
+  ClipboardCheck,
+  Clock,
+  FilePlus2,
+  FileX2,
+} from "lucide-react";
+import { useState } from "react";
+import { useFileViewer } from "@edr/ui-common";
+
+import { fileViewUrl } from "@/constants/apiConfig";
+import { api } from "@/services/api";
+import type { Company, CompanyChangeRequest } from "@/types/customer";
+import { formatDate, humanize } from "./format";
+
+/** Friendly labels for the proposed-change snapshot keys (UpdateProfileDto). */
+const FIELD_LABELS: Record<string, string> = {
+  companyName: "Company name",
+  companyEmail: "Company email",
+  companyPhone: "Company phone",
+  companyLocation: "Location",
+  companyAddress: "Address",
+  tin: "TIN",
+  vatNumber: "VAT number",
+  fanNumber: "FAN number",
+  nationality: "Nationality",
+  licenceNumber: "Licence number",
+  contactPersonName: "Contact person",
+  contactPersonPosition: "Contact position",
+  contactPersonEmail: "Contact email",
+  contactPersonPhone: "Contact phone",
+  generalManagerName: "General manager",
+  generalManagerEmail: "GM email",
+  generalManagerPhone: "GM phone",
+  poaName: "PoA name",
+  poaPhone: "PoA phone",
+  poaEmail: "PoA email",
+  poaLocation: "PoA location",
+  poaAddress: "PoA address",
+  region: "Region",
+  zone: "Zone",
+  woreda: "Woreda",
+  kebele: "Kebele",
+  houseNo: "House no.",
+};
+
+/** Best-effort current value on the live company for a proposed field key. */
+function currentValue(company: Company, key: string): string {
+  const c = company as unknown as Record<string, unknown>;
+  const attrs = (company.attributes ?? {}) as Record<string, unknown>;
+  const map: Record<string, unknown> = {
+    companyName: c.name,
+    companyEmail: c.email,
+    companyPhone: c.phone,
+    companyLocation: c.country,
+    companyAddress: c.address,
+    tin: c.tin,
+    vatNumber: c.vatNumber,
+    fanNumber: c.fanNumber,
+    nationality: c.nationality,
+    contactPersonName: c.contactPersonName ?? attrs.contactPersonName,
+    contactPersonPhone: c.contactPersonPhone ?? attrs.contactPersonPhone,
+    generalManagerName: c.generalManagerName ?? attrs.generalManagerName,
+    generalManagerEmail: c.generalManagerEmail ?? attrs.generalManagerEmail,
+    generalManagerPhone: c.generalManagerPhone ?? attrs.generalManagerPhone,
+  };
+  const v = key in map ? map[key] : (c[key] ?? attrs[key]);
+  return v === null || v === undefined || v === "" ? "—" : String(v);
+}
+
+function DiffRow({
+  label,
+  from,
+  to,
+}: {
+  label: string;
+  from: string;
+  to: string;
+}) {
+  const changed = from !== to;
+  return (
+    <Stack gap={2}>
+      <Text size="xs" fw={600} c="edr-muted" tt="uppercase">
+        {label}
+      </Text>
+      <Group gap={8} wrap="nowrap" align="center">
+        <Text
+          size="sm"
+          c="dimmed"
+          td={changed ? "line-through" : undefined}
+          style={{ wordBreak: "break-word" }}
+        >
+          {from}
+        </Text>
+        {changed && (
+          <>
+            <Text size="sm" c="edr-muted">
+              →
+            </Text>
+            <Text size="sm" fw={600} c="edr-text">
+              {to}
+            </Text>
+          </>
+        )}
+      </Group>
+    </Stack>
+  );
+}
+
+/**
+ * Backoffice review surface for a customer's staged profile edits. Shows the
+ * pending change request as a proposed-vs-current diff with Approve / Reject
+ * (with note) actions, plus a short history of past decisions.
+ */
+export function ChangeRequestReview({ company }: { company: Company }) {
+  const query = useQuery(
+    api.customers.changeRequests.queryOptions({ input: { id: company.id } }),
+  );
+  const approve = useMutation(
+    api.customers.approveChangeRequest.mutationOptions(),
+  );
+  const reject = useMutation(
+    api.customers.rejectChangeRequest.mutationOptions(),
+  );
+
+  const { view, viewer } = useFileViewer();
+  const [rejectId, setRejectId] = useState<string | null>(null);
+  const [note, setNote] = useState("");
+
+  const requests = query.data ?? [];
+  const pending = requests.find((r) => r.status === "pending");
+  const history = requests.filter((r) => r.status !== "pending").slice(0, 5);
+
+  if (!pending && history.length === 0) return null;
+
+  const proposedKeys = pending
+    ? Object.keys(pending.snapshot ?? {})
+    : ([] as string[]);
+  const docCount = pending?.documentFileIds?.length ?? 0;
+  const licenseChanges = pending?.licenseChanges ?? [];
+
+  const confirmReject = () => {
+    if (!rejectId) return;
+    reject.mutate(
+      { id: rejectId, note: note.trim() },
+      {
+        onSuccess: () => {
+          setRejectId(null);
+          setNote("");
+        },
+      },
+    );
+  };
+
+  return (
+    <>
+      {pending && (
+        <Card withBorder>
+          <Stack gap="md">
+            <Group justify="space-between">
+              <Group gap="sm">
+                <ClipboardCheck size={18} className="text-edr-muted" />
+                <Text fw={600} c="edr-text">
+                  Profile changes awaiting review
+                </Text>
+                <Badge color="yellow" variant="light" radius="md">
+                  Pending
+                </Badge>
+              </Group>
+              <Text size="xs" c="dimmed">
+                Submitted {formatDate(pending.submittedAt ?? pending.createdAt)}
+              </Text>
+            </Group>
+
+            {proposedKeys.length > 0 ? (
+              <SimpleGrid cols={{ base: 1, sm: 2, lg: 3 }} spacing="lg">
+                {proposedKeys.map((key) => (
+                  <DiffRow
+                    key={key}
+                    label={FIELD_LABELS[key] ?? humanize(key)}
+                    from={currentValue(company, key)}
+                    to={
+                      pending.snapshot[key] === null ||
+                      pending.snapshot[key] === undefined ||
+                      pending.snapshot[key] === ""
+                        ? "—"
+                        : String(pending.snapshot[key])
+                    }
+                  />
+                ))}
+              </SimpleGrid>
+            ) : (
+              <Text size="sm" c="dimmed">
+                No field changes — document uploads only.
+              </Text>
+            )}
+
+            {docCount > 0 && (
+              <Text size="sm" c="dimmed">
+                {docCount} document{docCount === 1 ? "" : "s"} uploaded with this
+                request — review them in the Documents tab.
+              </Text>
+            )}
+
+            {licenseChanges.length > 0 && (
+              <Stack gap={8}>
+                <Text size="sm" fw={600} c="edr-text">
+                  Business license changes
+                </Text>
+                {licenseChanges.map((c, i) => (
+                  <Group key={`${c.fileId}-${i}`} gap={8} wrap="nowrap">
+                    {c.op === "add" ? (
+                      <FilePlus2 size={15} className="text-edr-muted" />
+                    ) : (
+                      <FileX2 size={15} className="text-edr-muted" />
+                    )}
+                    <Badge
+                      size="sm"
+                      radius="sm"
+                      variant="light"
+                      color={c.op === "add" ? "green" : "red"}
+                    >
+                      {c.op === "add" ? "Add" : "Remove"}
+                    </Badge>
+                    <Anchor
+                      component="button"
+                      type="button"
+                      size="sm"
+                      onClick={() =>
+                        view({
+                          name: c.fileName ?? "License document",
+                          url: fileViewUrl(c.fileId),
+                        })
+                      }
+                      style={{
+                        textDecoration:
+                          c.op === "remove" ? "line-through" : undefined,
+                      }}
+                    >
+                      {c.fileName ?? "License document"}
+                    </Anchor>
+                  </Group>
+                ))}
+              </Stack>
+            )}
+
+            <Group justify="flex-end" gap="sm">
+              <Button
+                variant="light"
+                color="red"
+                onClick={() => {
+                  setRejectId(pending.id);
+                  setNote("");
+                }}
+              >
+                Reject
+              </Button>
+              <Button
+                color="edr-green"
+                loading={approve.isPending}
+                onClick={() => approve.mutate({ id: pending.id })}
+              >
+                Approve changes
+              </Button>
+            </Group>
+          </Stack>
+        </Card>
+      )}
+
+      {history.length > 0 && (
+        <Card withBorder>
+          <Stack gap="sm">
+            <Text fw={600} c="edr-text">
+              Review history
+            </Text>
+            {history.map((r: CompanyChangeRequest) => (
+              <Group key={r.id} gap="sm" wrap="nowrap" align="flex-start">
+                <Badge
+                  color={r.status === "approved" ? "edr-green" : "red"}
+                  variant="light"
+                  radius="md"
+                  tt="capitalize"
+                >
+                  {r.status}
+                </Badge>
+                <Box style={{ flex: 1 }}>
+                  <Text size="sm" c="edr-text">
+                    {formatDate(r.reviewedAt ?? r.updatedAt)}
+                  </Text>
+                  {r.note && (
+                    <Text size="xs" c="dimmed">
+                      Note: {r.note}
+                    </Text>
+                  )}
+                </Box>
+              </Group>
+            ))}
+          </Stack>
+        </Card>
+      )}
+
+      <Modal
+        opened={rejectId !== null}
+        onClose={() => setRejectId(null)}
+        title="Reject changes"
+        centered
+        radius="lg"
+      >
+        <Stack gap="md">
+          <Alert color="red" variant="light" icon={<AlertTriangle size={18} />}>
+            The customer will see this note and can amend and resubmit.
+          </Alert>
+          <Textarea
+            label="Reason for rejection"
+            placeholder="e.g. The company address doesn't match the trade license."
+            autosize
+            minRows={3}
+            value={note}
+            onChange={(e) => setNote(e.currentTarget.value)}
+            required
+          />
+          <Group justify="flex-end" gap="sm">
+            <Button
+              variant="default"
+              onClick={() => setRejectId(null)}
+              disabled={reject.isPending}
+            >
+              Cancel
+            </Button>
+            <Button
+              color="red"
+              loading={reject.isPending}
+              disabled={note.trim().length === 0}
+              onClick={confirmReject}
+            >
+              Reject changes
+            </Button>
+          </Group>
+        </Stack>
+      </Modal>
+
+      {viewer}
+    </>
+  );
+}
+
+/** Compact "N changes pending" pill for the customer list/detail header. */
+export function ChangeRequestPendingBadge({ companyId }: { companyId: string }) {
+  const query = useQuery(
+    api.customers.changeRequests.queryOptions({ input: { id: companyId } }),
+  );
+  const pending = (query.data ?? []).some((r) => r.status === "pending");
+  if (!pending) return null;
+  return (
+    <Badge
+      color="yellow"
+      variant="light"
+      radius="md"
+      leftSection={<Clock size={12} />}
+    >
+      Changes pending review
+    </Badge>
+  );
+}
diff --git a/apps/edr-freight-web/backoffice/src/components/customers/badges.tsx b/apps/edr-freight-web/backoffice/src/components/customers/badges.tsx
index 5bd6a7527..76555a014 100644
--- a/apps/edr-freight-web/backoffice/src/components/customers/badges.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/customers/badges.tsx
@@ -1,6 +1,16 @@
 import type { Freight } from "@edr/types";
-import { Badge, Button, Group, Tooltip } from "@mantine/core";
+import {
+  Badge,
+  Button,
+  Group,
+  Modal,
+  Stack,
+  Text,
+  Textarea,
+  Tooltip,
+} from "@mantine/core";
 import { useMutation } from "@tanstack/react-query";
+import { useState } from "react";
 import { api } from "@/services/api";
 
 import type {
@@ -25,6 +35,7 @@ const badgeStyle = {
 const STATUS_COLOR: Record<CompanyStatus | ProfileStatus, string> = {
   active: "edr-green",
   pending: "yellow",
+  rejected: "red",
   suspended: "orange",
   blacklisted: "red",
 };
@@ -266,7 +277,9 @@ export function InvoiceStatusBadge({
 
 /**
  * Inline approval action buttons for a profile row.
- * Transitions: pending → approve/reject | active → suspend | suspended → reactivate/blacklist | blacklisted → reinstate
+ * Transitions: pending → approve / reject-with-note | rejected → approve (override) |
+ * active → suspend | suspended → reactivate/blacklist | blacklisted → reinstate.
+ * Rejecting captures a note the customer sees so they can fix and reapply.
  */
 export function ProfileApprovalActions({
   profileId,
@@ -278,33 +291,102 @@ export function ProfileApprovalActions({
   const { mutate, isPending } = useMutation(
     api.customers.setProfileStatus.mutationOptions(),
   );
+  const [rejectOpen, setRejectOpen] = useState(false);
+  const [note, setNote] = useState("");
 
   const act = (next: ProfileStatus) => mutate({ profileId, status: next });
 
+  const confirmReject = () => {
+    mutate(
+      { profileId, status: "rejected", note: note.trim() },
+      { onSuccess: () => setRejectOpen(false) },
+    );
+  };
+
+  const rejectModal = (
+    <Modal
+      opened={rejectOpen}
+      onClose={() => setRejectOpen(false)}
+      title="Reject profile"
+      centered
+      radius="lg"
+    >
+      <Stack gap="md">
+        <Text size="sm" c="dimmed">
+          Tell the customer what needs fixing. They'll see this note and can
+          amend and resubmit the role for approval.
+        </Text>
+        <Textarea
+          label="Reason for rejection"
+          placeholder="e.g. The uploaded business license is expired."
+          autosize
+          minRows={3}
+          value={note}
+          onChange={(e) => setNote(e.currentTarget.value)}
+          required
+        />
+        <Group justify="flex-end" gap="sm">
+          <Button
+            variant="default"
+            onClick={() => setRejectOpen(false)}
+            disabled={isPending}
+          >
+            Cancel
+          </Button>
+          <Button
+            color="red"
+            loading={isPending}
+            disabled={note.trim().length === 0}
+            onClick={confirmReject}
+          >
+            Reject profile
+          </Button>
+        </Group>
+      </Stack>
+    </Modal>
+  );
+
   if (status === "pending") {
     return (
-      <Group gap={6} wrap="nowrap">
-        <Button
-          size="xs"
-          variant="light"
-          color="edr-green"
-          radius="md"
-          loading={isPending}
-          onClick={() => act("active")}
-        >
-          Approve
-        </Button>
-        <Button
-          size="xs"
-          variant="light"
-          color="red"
-          radius="md"
-          loading={isPending}
-          onClick={() => act("blacklisted")}
-        >
-          Reject
-        </Button>
-      </Group>
+      <>
+        {rejectModal}
+        <Group gap={6} wrap="nowrap">
+          <Button
+            size="xs"
+            variant="light"
+            color="edr-green"
+            radius="md"
+            loading={isPending}
+            onClick={() => act("active")}
+          >
+            Approve
+          </Button>
+          <Button
+            size="xs"
+            variant="light"
+            color="red"
+            radius="md"
+            onClick={() => setRejectOpen(true)}
+          >
+            Reject
+          </Button>
+        </Group>
+      </>
+    );
+  }
+
+  if (status === "rejected") {
+    return (
+      <Button
+        size="xs"
+        variant="light"
+        color="edr-green"
+        radius="md"
+        loading={isPending}
+        onClick={() => act("active")}
+      >
+        Approve
+      </Button>
     );
   }
 
diff --git a/apps/edr-freight-web/backoffice/src/components/customers/index.ts b/apps/edr-freight-web/backoffice/src/components/customers/index.ts
index 620b5ec35..2a87e3b0c 100644
--- a/apps/edr-freight-web/backoffice/src/components/customers/index.ts
+++ b/apps/edr-freight-web/backoffice/src/components/customers/index.ts
@@ -9,5 +9,9 @@ export {
   ProfileStatusBadge,
   ProfileTypeBadge,
 } from "./badges";
+export {
+  ChangeRequestReview,
+  ChangeRequestPendingBadge,
+} from "./ChangeRequestReview";
 export { formatBytes, formatDate, formatMoney, humanize } from "./format";
 export { TableCard, type TableCardProps } from "./TableCard";
diff --git a/apps/edr-freight-web/backoffice/src/components/warehouses/ContainerItemsModal.tsx b/apps/edr-freight-web/backoffice/src/components/warehouses/ContainerItemsModal.tsx
index 168bfd744..57be67d68 100644
--- a/apps/edr-freight-web/backoffice/src/components/warehouses/ContainerItemsModal.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/warehouses/ContainerItemsModal.tsx
@@ -11,6 +11,7 @@ import {
   Table,
   Tabs,
   Text,
+  Tooltip,
 } from '@mantine/core';
 import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
 import { FileText } from 'lucide-react';
@@ -22,7 +23,7 @@ import {
   type ContainerItem,
   type ContainerItemStage,
 } from '@/services/warehouse.service';
-import { extractErrorMessage } from './options';
+import { extractDownloadErrorMessage, extractErrorMessage } from './options';
 import { openPdfBlob } from './pdf';
 
 interface ContainerItemsModalProps {
@@ -36,6 +37,7 @@ const STAGE_TABS: Array<{ value: string; label: string }> = [
   { value: 'ALL', label: 'All' },
   { value: 'RECEIVED', label: 'Received' },
   { value: 'GRN', label: "GRN'd" },
+  { value: 'ASSIGNED', label: 'Assigned' },
   { value: 'LOADED', label: 'Loaded' },
   { value: 'LEFT', label: 'Left' },
   { value: 'DELIVERED', label: 'Delivered' },
@@ -45,13 +47,15 @@ const STAGE_COLOR: Record<ContainerItemStage, string> = {
   PENDING: 'gray',
   RECEIVED: 'blue',
   GRN: 'teal',
+  ASSIGNED: 'indigo',
   LOADED: 'grape',
   LEFT: 'orange',
   DELIVERED: 'green',
 };
 
-/** Loadable = not yet on a truck (before LOADED). */
-const isLoadable = (i: ContainerItem) => i.stage === 'PENDING' || i.stage === 'RECEIVED' || i.stage === 'GRN';
+/** Loadable = not yet loaded (PENDING/RECEIVED/GRN, or customer-ASSIGNED awaiting load). */
+const isLoadable = (i: ContainerItem) =>
+  i.stage === 'PENDING' || i.stage === 'RECEIVED' || i.stage === 'GRN' || i.stage === 'ASSIGNED';
 
 export function ContainerItemsModal({ opened, onClose, bookingId, bookingReference }: ContainerItemsModalProps) {
   const { toast } = useToast();
@@ -76,8 +80,13 @@ export function ContainerItemsModal({ opened, onClose, bookingId, bookingReferen
     () => (tab === 'ALL' ? items : items.filter((i) => i.stage === tab)),
     [items, tab],
   );
+  // Only arrived, not-yet-departed trucks can be loaded.
   const truckOptions = trucks
-    .filter((t) => !(t as { departedAt?: string }).departedAt)
+    .filter(
+      (t) =>
+        Boolean((t as { arrivedAt?: string }).arrivedAt) &&
+        !(t as { departedAt?: string }).departedAt,
+    )
     .map((t) => ({ value: t.id, label: `${t.plateNumber} · ${t.driverName}` }));
 
   const loadMutation = useMutation({
@@ -90,12 +99,29 @@ export function ContainerItemsModal({ opened, onClose, bookingId, bookingReferen
     onError: (e) => toast({ variant: 'destructive', title: 'Load failed', description: extractErrorMessage(e) }),
   });
 
+  const requestSign = async () => {
+    try {
+      const res = await warehouseService.requestHandoverSignature(bookingId as string);
+      queryClient.invalidateQueries({ queryKey: itemsKey });
+      if (res.alreadySigned) {
+        toast({ title: 'Handover already signed', description: 'You can generate the exit paper now.' });
+      } else {
+        toast({
+          title: 'Handover not signed',
+          description: `Signature request sent to the customer${res.reference ? ` (${res.reference})` : ''}.`,
+        });
+      }
+    } catch (e) {
+      toast({ variant: 'destructive', title: 'Could not request signature', description: extractErrorMessage(e) });
+    }
+  };
+
   const openExitPaper = async (assignmentId: string, plate: string) => {
     try {
       const res = await warehouseService.downloadTruckExitPaper(assignmentId);
       openPdfBlob(res.data, `exit-${plate}.pdf`);
     } catch (e) {
-      toast({ variant: 'destructive', title: 'Exit paper not ready', description: extractErrorMessage(e) });
+      toast({ variant: 'destructive', title: 'Exit paper not ready', description: await extractDownloadErrorMessage(e) });
     }
   };
 
@@ -163,16 +189,28 @@ export function ContainerItemsModal({ opened, onClose, bookingId, bookingReferen
                     <Table.Td>{i.contractId ? <Badge variant="outline" color="indigo">Contract</Badge> : '—'}</Table.Td>
                     <Table.Td>{i.hasLastMile ? <Badge variant="light" color="cyan">EDR</Badge> : <Badge variant="light" color="gray">Self-haul</Badge>}</Table.Td>
                     <Table.Td ta="right">
-                      {i.truckAssignmentId && (
-                        <Button
-                          size="compact-xs"
-                          variant="light"
-                          color="orange"
-                          leftSection={<FileText size={13} />}
-                          onClick={() => openExitPaper(i.truckAssignmentId as string, i.truckPlate ?? '')}
+                      {i.loaded && i.truckAssignmentId && (
+                        <Tooltip
+                          label="Sign the handover first — a truck can't get its exit paper until the handover is signed."
+                          disabled={i.handoverSigned}
+                          withArrow
+                          multiline
+                          w={240}
                         >
-                          Exit Paper
-                        </Button>
+                          <Button
+                            size="compact-xs"
+                            variant="light"
+                            color={i.handoverSigned ? 'orange' : 'gray'}
+                            leftSection={<FileText size={13} />}
+                            onClick={() =>
+                              i.handoverSigned
+                                ? openExitPaper(i.truckAssignmentId as string, i.truckPlate ?? '')
+                                : requestSign()
+                            }
+                          >
+                            Exit Paper
+                          </Button>
+                        </Tooltip>
                       )}
                     </Table.Td>
                   </Table.Tr>
diff --git a/apps/edr-freight-web/backoffice/src/components/warehouses/CreateWarehouseModal.tsx b/apps/edr-freight-web/backoffice/src/components/warehouses/CreateWarehouseModal.tsx
index 6494906b4..8c8560442 100644
--- a/apps/edr-freight-web/backoffice/src/components/warehouses/CreateWarehouseModal.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/warehouses/CreateWarehouseModal.tsx
@@ -102,7 +102,7 @@ export function CreateWarehouseModal({ opened, onClose, warehouse }: CreateWareh
         await updateMutation.mutateAsync({ id: warehouse.id, payload: { ...payload, status: form.status } });
         toast({ title: 'Warehouse updated' });
       } else {
-        await createMutation.mutateAsync(payload);
+        await createMutation.mutateAsync({ ...payload, status: form.status });
         toast({ title: 'Warehouse created' });
       }
       onClose();
@@ -149,15 +149,13 @@ export function CreateWarehouseModal({ opened, onClose, warehouse }: CreateWareh
             onChange={(value) => setForm((f) => ({ ...f, type: (value as WarehouseType) ?? 'OPEN_WAREHOUSE' }))}
             allowDeselect={false}
           />
-          {isEdit && (
-            <Select
-              label="Status"
-              data={statusOptions}
-              value={form.status}
-              onChange={(value) => setForm((f) => ({ ...f, status: (value as 'ACTIVE' | 'INACTIVE') ?? 'ACTIVE' }))}
-              allowDeselect={false}
-            />
-          )}
+          <Select
+            label="Status"
+            data={statusOptions}
+            value={form.status}
+            onChange={(value) => setForm((f) => ({ ...f, status: (value as 'ACTIVE' | 'INACTIVE') ?? 'ACTIVE' }))}
+            allowDeselect={false}
+          />
         </Group>
 
         <TextInput
@@ -169,7 +167,7 @@ export function CreateWarehouseModal({ opened, onClose, warehouse }: CreateWareh
 
         <Group grow>
           <NumberInput
-            label="Capacity weight (kg)"
+            label="Capacity weight (t)"
             placeholder="Optional"
             min={0}
             value={form.capacityWeight}
diff --git a/apps/edr-freight-web/backoffice/src/components/warehouses/CreateYardModal.tsx b/apps/edr-freight-web/backoffice/src/components/warehouses/CreateYardModal.tsx
index a2eb0aa0e..a61871558 100644
--- a/apps/edr-freight-web/backoffice/src/components/warehouses/CreateYardModal.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/warehouses/CreateYardModal.tsx
@@ -132,7 +132,7 @@ export function CreateYardModal({ opened, onClose, warehouseId, yard }: CreateYa
 
         <Group grow>
           <NumberInput
-            label="Capacity weight (kg)"
+            label="Capacity weight (t)"
             placeholder="Optional"
             min={0}
             value={form.capacityWeight}
diff --git a/apps/edr-freight-web/backoffice/src/components/warehouses/CreateZoneModal.tsx b/apps/edr-freight-web/backoffice/src/components/warehouses/CreateZoneModal.tsx
index 05bc1ce96..3dfa3faca 100644
--- a/apps/edr-freight-web/backoffice/src/components/warehouses/CreateZoneModal.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/warehouses/CreateZoneModal.tsx
@@ -132,7 +132,7 @@ export function CreateZoneModal({ opened, onClose, yardId, zone }: CreateZoneMod
 
         <Group grow>
           <NumberInput
-            label="Capacity weight (kg)"
+            label="Capacity weight (t)"
             placeholder="Optional"
             min={0}
             value={form.capacityWeight}
diff --git a/apps/edr-freight-web/backoffice/src/components/warehouses/InspectionReportModal.tsx b/apps/edr-freight-web/backoffice/src/components/warehouses/InspectionReportModal.tsx
index 2c9098ad3..c030a5ed4 100644
--- a/apps/edr-freight-web/backoffice/src/components/warehouses/InspectionReportModal.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/warehouses/InspectionReportModal.tsx
@@ -174,13 +174,13 @@ export function InspectionReportModal({ opened, onClose, inventoryId }: Inspecti
       {hasWeightLoss && (
         <Group grow mt="xs">
           <NumberInput
-            label="Expected weight (kg)"
+            label="Expected weight (t)"
             min={0}
             value={expectedWeight}
             onChange={(v) => setExpectedWeight(v === '' ? '' : Number(v))}
           />
           <NumberInput
-            label="Actual weight (kg)"
+            label="Actual weight (t)"
             min={0}
             value={actualWeight}
             onChange={(v) => setActualWeight(v === '' ? '' : Number(v))}
diff --git a/apps/edr-freight-web/backoffice/src/components/warehouses/InventoryDetailModal.tsx b/apps/edr-freight-web/backoffice/src/components/warehouses/InventoryDetailModal.tsx
index c888253f1..e76baa6f0 100644
--- a/apps/edr-freight-web/backoffice/src/components/warehouses/InventoryDetailModal.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/warehouses/InventoryDetailModal.tsx
@@ -78,7 +78,7 @@ export function InventoryDetailModal({ opened, onClose, item }: InventoryDetailM
             <DetailRow label="Release reference" value={item.releaseOrderReference ?? '-'} />
             <DetailRow label="Handover reference" value={handoverReference || '-'} />
             <DetailRow label="Quantity" value={formatNumber(item.quantity)} />
-            <DetailRow label="Weight" value={`${formatNumber(item.weight)} kg`} />
+            <DetailRow label="Weight" value={`${formatNumber(item.weight)} t`} />
             <DetailRow label="Volume" value={item.volume == null ? '-' : formatNumber(item.volume)} />
           </SimpleGrid>
 
diff --git a/apps/edr-freight-web/backoffice/src/components/warehouses/InventoryInquiryDetailModal.tsx b/apps/edr-freight-web/backoffice/src/components/warehouses/InventoryInquiryDetailModal.tsx
index 479249894..906ba4b47 100644
--- a/apps/edr-freight-web/backoffice/src/components/warehouses/InventoryInquiryDetailModal.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/warehouses/InventoryInquiryDetailModal.tsx
@@ -67,7 +67,7 @@ export function InventoryInquiryDetailModal({ opened, onClose, result }: Invento
           <SimpleGrid cols={{ base: 1, sm: 3 }}>
             <DetailRow label="Item" value={itemLabel(result)} />
             <DetailRow label="Quantity" value={formatNumber(result.quantity)} />
-            <DetailRow label="Weight" value={`${formatNumber(result.weight)} kg`} />
+            <DetailRow label="Weight" value={`${formatNumber(result.weight)} t`} />
           </SimpleGrid>
 
           <Divider label="Location" labelPosition="left" />
diff --git a/apps/edr-freight-web/backoffice/src/components/warehouses/InventoryWorkbench.tsx b/apps/edr-freight-web/backoffice/src/components/warehouses/InventoryWorkbench.tsx
index f37db855d..b8bb43086 100644
--- a/apps/edr-freight-web/backoffice/src/components/warehouses/InventoryWorkbench.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/warehouses/InventoryWorkbench.tsx
@@ -17,7 +17,6 @@ import { InventoryHistoryModal } from './InventoryHistoryModal';
 import { LoadInventoryModal } from './LoadInventoryModal';
 import { MoveInventoryModal } from './MoveInventoryModal';
 import { ReleaseOrderModal } from './ReleaseOrderModal';
-import { ReserveInventoryModal } from './ReserveInventoryModal';
 import { WarehouseInventoryTable } from './WarehouseInventoryTable';
 import { extractErrorMessage } from './options';
 import { openPdfBlob } from './pdf';
@@ -29,12 +28,11 @@ interface InventoryWorkbenchProps {
   onLastMile?: (item: WarehouseInventoryItem) => void;
 }
 
-/** Inventory table + all lifecycle actions (advance / move / reserve / history). */
+/** Inventory table + all lifecycle actions (advance / move / history). */
 export function InventoryWorkbench({ items, isLoading, onLastMile }: InventoryWorkbenchProps) {
   const { toast } = useToast();
   const [busyId, setBusyId] = useState<string | null>(null);
   const [moveItem, setMoveItem] = useState<WarehouseInventoryItem | null>(null);
-  const [reserveItem, setReserveItem] = useState<WarehouseInventoryItem | null>(null);
   const [loadItem, setLoadItem] = useState<WarehouseInventoryItem | null>(null);
   const [historyItem, setHistoryItem] = useState<WarehouseInventoryItem | null>(null);
   const [viewItem, setViewItem] = useState<WarehouseInventoryItem | null>(null);
@@ -171,7 +169,7 @@ export function InventoryWorkbench({ items, isLoading, onLastMile }: InventoryWo
   const storeInventory = async (item: WarehouseInventoryItem) => {
     setBusyId(item.id);
     try {
-      const stored = await storeMutation.mutateAsync(item.id);
+      const stored = await storeMutation.mutateAsync({ id: item.id });
       toast({
         title: 'Inventory stored',
         description: [stored.warehouse?.code, stored.yard?.code, stored.zone?.code].filter(Boolean).join(' / '),
@@ -187,9 +185,6 @@ export function InventoryWorkbench({ items, isLoading, onLastMile }: InventoryWo
     switch (action) {
       case 'store':
         return storeInventory(item);
-      case 'reserve':
-        setReserveItem(item);
-        return;
       case 'ready-for-loading':
         return runDirect(item, () => readyMutation.mutateAsync(item.id), 'Ready for loading');
       case 'load':
@@ -258,11 +253,6 @@ export function InventoryWorkbench({ items, isLoading, onLastMile }: InventoryWo
       </Stack>
 
       <MoveInventoryModal opened={Boolean(moveItem)} onClose={() => setMoveItem(null)} item={moveItem} />
-      <ReserveInventoryModal
-        opened={Boolean(reserveItem)}
-        onClose={() => setReserveItem(null)}
-        item={reserveItem}
-      />
       <LoadInventoryModal opened={Boolean(loadItem)} onClose={() => setLoadItem(null)} item={loadItem} />
       <InventoryHistoryModal
         opened={Boolean(historyItem)}
diff --git a/apps/edr-freight-web/backoffice/src/components/warehouses/LoadInventoryModal.tsx b/apps/edr-freight-web/backoffice/src/components/warehouses/LoadInventoryModal.tsx
index 7fc43c0d5..f0166714c 100644
--- a/apps/edr-freight-web/backoffice/src/components/warehouses/LoadInventoryModal.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/warehouses/LoadInventoryModal.tsx
@@ -67,7 +67,7 @@ export function LoadInventoryModal({ opened, onClose, item }: LoadInventoryModal
         <WagonSelect label="Wagon" required value={wagonId} onChange={setWagonId} />
 
         <NumberInput
-          label="Loaded weight (kg)"
+          label="Loaded weight (t)"
           placeholder="Defaults to item weight"
           min={0}
           value={loadedWeight}
diff --git a/apps/edr-freight-web/backoffice/src/components/warehouses/LoadToTrainPanel.tsx b/apps/edr-freight-web/backoffice/src/components/warehouses/LoadToTrainPanel.tsx
index e16a29122..828f4ab44 100644
--- a/apps/edr-freight-web/backoffice/src/components/warehouses/LoadToTrainPanel.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/warehouses/LoadToTrainPanel.tsx
@@ -31,7 +31,7 @@ const STAGE_COLOR: Record<string, string> = {
   LOADED: 'green',
 };
 
-const weight = (w: number | null) => (w == null ? '—' : `${Number(w).toLocaleString()} kg`);
+const weight = (w: number | null) => (w == null ? '—' : `${Number(w).toLocaleString()} t`);
 
 interface BookingGroup {
   bookingId: string | null;
diff --git a/apps/edr-freight-web/backoffice/src/components/warehouses/ReceiveInventoryModal.tsx b/apps/edr-freight-web/backoffice/src/components/warehouses/ReceiveInventoryModal.tsx
index 3e3877236..3b4be03db 100644
--- a/apps/edr-freight-web/backoffice/src/components/warehouses/ReceiveInventoryModal.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/warehouses/ReceiveInventoryModal.tsx
@@ -7,6 +7,7 @@ import {
   Checkbox,
   Group,
   Loader,
+  Menu,
   Modal,
   NumberInput,
   ScrollArea,
@@ -20,6 +21,7 @@ import {
   Tooltip,
 } from '@mantine/core';
 import {
+  ArrowRightLeft,
   ChevronDown,
   ChevronRight,
   ClipboardCheck,
@@ -27,6 +29,8 @@ import {
   FileText,
   History,
   Info,
+  MapPin,
+  MoreHorizontal,
   PackageCheck,
   PackageOpen,
   PackageSearch,
@@ -61,7 +65,6 @@ import type {
 } from '@/types/warehouse';
 import { BookingSelect } from './BookingSelect';
 import { DeliverInventoryModal } from './DeliverInventoryModal';
-import { TruckDispatchModal } from './TruckDispatchModal';
 import { ContainerItemsModal } from './ContainerItemsModal';
 import { FeePreviewModal } from './FeePreviewModal';
 import { InspectionReportModal } from './InspectionReportModal';
@@ -69,7 +72,9 @@ import { InventoryDetailModal } from './InventoryDetailModal';
 import { InventoryHistoryModal } from './InventoryHistoryModal';
 import { InventoryWorkbench } from './InventoryWorkbench';
 import { InventoryInquiryDetailModal } from './InventoryInquiryDetailModal';
+import { MoveInventoryModal } from './MoveInventoryModal';
 import { ReleaseOrderModal } from './ReleaseOrderModal';
+import { StoreInventoryModal } from './StoreInventoryModal';
 import { WarehouseInquiryTable } from './WarehouseInquiryTable';
 import { extractErrorMessage, formatDate, formatNumber, inventoryStatusOptions } from './options';
 import { openPdfBlob } from './pdf';
@@ -520,14 +525,14 @@ function TruckEntranceFields({
           {value.weighingRequired && (
             <Group grow>
               <NumberInput
-                label="Gross weight (kg)"
+                label="Gross weight (t)"
                 required
                 min={0}
                 value={value.grossWeightKg}
                 onChange={(v) => onChange({ ...value, grossWeightKg: v === '' ? '' : Number(v) })}
               />
               <NumberInput
-                label="Exit tare weight (kg)"
+                label="Exit tare weight (t)"
                 required
                 min={0}
                 value={value.exitTareWeightKg}
@@ -596,7 +601,7 @@ function TruckEntranceFields({
         />
       </Group>
       <NumberInput
-        label="Net weight (kg)"
+        label="Net weight (t)"
         min={0}
         value={value.netWeightKg}
         onChange={(v) => onChange({ ...value, netWeightKg: v === '' ? '' : Number(v) })}
@@ -2182,7 +2187,6 @@ function ImportUnloadedQueueTab({ enabled }: { enabled: boolean }) {
   const inspectMutation = useMutation(
     api.warehouses.bulkMarkInspected.mutationOptions(),
   );
-  const storeMutation = useMutation(api.warehouses.store.mutationOptions());
   const readyMutation = useMutation(api.warehouses.markReadyForPickup.mutationOptions());
   const [selected, setSelected] = useState<Set<string>>(new Set());
   const [inspectId, setInspectId] = useState<string | null>(null);
@@ -2192,8 +2196,9 @@ function ImportUnloadedQueueTab({ enabled }: { enabled: boolean }) {
   const [feeItem, setFeeItem] = useState<WarehouseInventoryItem | null>(null);
   const [releaseItem, setReleaseItem] = useState<WarehouseInventoryItem | null>(null);
   const [deliverItem, setDeliverItem] = useState<WarehouseInventoryItem | null>(null);
-  const [loadTruckItem, setLoadTruckItem] = useState<WarehouseInventoryItem | null>(null);
   const [containerItemsItem, setContainerItemsItem] = useState<WarehouseInventoryItem | null>(null);
+  const [storeItem, setStoreItem] = useState<WarehouseInventoryItem | null>(null);
+  const [moveItem, setMoveItem] = useState<WarehouseInventoryItem | null>(null);
 
   const allSelected = rows.length > 0 && selected.size === rows.length;
   const someSelected = selected.size > 0 && !allSelected;
@@ -2413,49 +2418,16 @@ function ImportUnloadedQueueTab({ enabled }: { enabled: boolean }) {
                           <Eye size={16} />
                         </ActionIcon>
                       </Tooltip>
-                      {r.currentStatus === 'UNLOADED' && (
+                      {/* Primary stage action stays visible; the rest live under the kebab. */}
+                      {r.currentStatus === 'READY_FOR_PICKUP' && !r.releaseDate && r.hasAssignedTruck && (
                         <Button
                           size="compact-xs"
                           variant="light"
-                          color="blue"
-                          loading={busyId === r.id}
-                          onClick={() => runRowAction(r, 'Inventory stored', () => storeMutation.mutateAsync(r.id))}
+                          color="yellow"
+                          leftSection={<Truck size={14} />}
+                          onClick={() => setReleaseItem(toInventoryItem(r))}
                         >
-                          Store
-                        </Button>
-                      )}
-                      {['UNLOADED', 'STORED'].includes(r.currentStatus) && r.inspectionStatus === 'PASSED' && (
-                        <Button
-                          size="compact-xs"
-                          variant="light"
-                          color="orange"
-                          loading={busyId === r.id}
-                          onClick={() => runRowAction(r, 'Ready for pickup', () => readyMutation.mutateAsync(r.id))}
-                        >
-                          Ready Pickup
-                        </Button>
-                      )}
-                      {r.currentStatus === 'READY_FOR_PICKUP' && !r.releaseDate && (
-                        <>
-                          <Button
-                            size="compact-xs"
-                            variant="light"
-                            color="yellow"
-                            onClick={() => setReleaseItem(toInventoryItem(r))}
-                          >
-                            {r.releaseOrderReference ? 'Truck Leaving' : 'Truck Arrival'}
-                          </Button>
-                        </>
-                      )}
-                      {r.currentStatus === 'READY_FOR_PICKUP' && (
-                        <Button
-                          size="compact-xs"
-                          variant="light"
-                          color="green"
-                          loading={busyId === r.id}
-                          onClick={() => setLoadTruckItem(toInventoryItem(r))}
-                        >
-                          Truck_dispatch
+                          {r.releaseOrderReference ? 'Truck Leaving' : 'Truck Arrival'}
                         </Button>
                       )}
                       {r.currentStatus === 'READY_FOR_PICKUP' && r.releaseDate && (
@@ -2470,40 +2442,64 @@ function ImportUnloadedQueueTab({ enabled }: { enabled: boolean }) {
                           Exit Paper
                         </Button>
                       )}
-                      {r.currentStatus === 'READY_FOR_PICKUP' && r.releaseDate && (
-                        <Button
-                          size="compact-xs"
-                          variant="light"
-                          color="green"
-                          onClick={() => setDeliverItem(toInventoryItem(r))}
-                        >
-                          Deliver
-                        </Button>
-                      )}
-                      {r.inspectionStatus === 'PASSED' && (
-                        <Button
-                          size="compact-xs"
-                          variant="light"
-                          color="teal"
-                          leftSection={<FileText size={14} />}
-                          onClick={() => openHandoverDocument(r)}
-                        >
-                          {r.handoverDocumentReference ? 'View Handover' : 'Handover'}
-                        </Button>
-                      )}
-                      <Button size="compact-xs" variant="light" color="orange" onClick={() => setInspectId(r.id)}>
-                        Inspect / Report
-                      </Button>
-                      <Tooltip label="Storage / fee preview" withArrow>
-                        <ActionIcon variant="subtle" color="teal" onClick={() => setFeeItem(toInventoryItem(r))}>
-                          <PackageCheck size={16} />
-                        </ActionIcon>
-                      </Tooltip>
-                      <Tooltip label="History" withArrow>
-                        <ActionIcon variant="subtle" color="gray" onClick={() => setHistoryItem(toInventoryItem(r))}>
-                          <History size={16} />
-                        </ActionIcon>
-                      </Tooltip>
+                      <Menu shadow="md" width={240} position="bottom-end" withinPortal>
+                        <Menu.Target>
+                          <ActionIcon variant="subtle" color="gray" aria-label="More actions" loading={busyId === r.id}>
+                            <MoreHorizontal size={16} />
+                          </ActionIcon>
+                        </Menu.Target>
+                        <Menu.Dropdown>
+                          {r.currentStatus === 'UNLOADED' && (
+                            <Menu.Item leftSection={<MapPin size={14} />} onClick={() => setStoreItem(toInventoryItem(r))}>
+                              Store…
+                            </Menu.Item>
+                          )}
+                          {r.currentStatus !== 'UNLOADED' && (
+                            <Menu.Item leftSection={<ArrowRightLeft size={14} />} onClick={() => setMoveItem(toInventoryItem(r))}>
+                              Move…
+                            </Menu.Item>
+                          )}
+                          {['UNLOADED', 'STORED'].includes(r.currentStatus) && r.inspectionStatus === 'PASSED' && (
+                            <Menu.Item onClick={() => runRowAction(r, 'Ready for pickup', () => readyMutation.mutateAsync(r.id))}>
+                              Ready for pickup
+                            </Menu.Item>
+                          )}
+                          {r.currentStatus === 'READY_FOR_PICKUP' && !r.releaseDate && (
+                            <Menu.Item
+                              leftSection={<Truck size={14} />}
+                              disabled={!r.hasAssignedTruck}
+                              onClick={() => setReleaseItem(toInventoryItem(r))}
+                            >
+                              {r.hasAssignedTruck
+                                ? r.releaseOrderReference
+                                  ? 'Truck leaving'
+                                  : 'Truck arrival'
+                                : 'Truck arrival — assign a truck first'}
+                            </Menu.Item>
+                          )}
+                          {r.currentStatus === 'READY_FOR_PICKUP' && r.releaseDate && (
+                            <Menu.Item leftSection={<FileText size={14} />} onClick={() => openReleaseDocument(r)}>
+                              Exit paper
+                            </Menu.Item>
+                          )}
+                          {r.currentStatus === 'READY_FOR_PICKUP' && r.releaseDate && (
+                            <Menu.Item onClick={() => setDeliverItem(toInventoryItem(r))}>Deliver</Menu.Item>
+                          )}
+                          {r.inspectionStatus === 'PASSED' && (
+                            <Menu.Item leftSection={<FileText size={14} />} onClick={() => openHandoverDocument(r)}>
+                              {r.handoverDocumentReference ? 'View handover' : 'Handover'}
+                            </Menu.Item>
+                          )}
+                          <Menu.Item onClick={() => setInspectId(r.id)}>Inspect / report</Menu.Item>
+                          <Menu.Divider />
+                          <Menu.Item leftSection={<PackageCheck size={14} />} onClick={() => setFeeItem(toInventoryItem(r))}>
+                            Storage / fee preview
+                          </Menu.Item>
+                          <Menu.Item leftSection={<History size={14} />} onClick={() => setHistoryItem(toInventoryItem(r))}>
+                            History
+                          </Menu.Item>
+                        </Menu.Dropdown>
+                      </Menu>
                     </Group>
                   </Table.Td>
                 </Table.Tr>
@@ -2526,13 +2522,9 @@ function ImportUnloadedQueueTab({ enabled }: { enabled: boolean }) {
         inventoryId={feeItem?.id ?? null}
       />
       <ReleaseOrderModal opened={Boolean(releaseItem)} onClose={() => setReleaseItem(null)} item={releaseItem} />
+      <StoreInventoryModal opened={Boolean(storeItem)} onClose={() => setStoreItem(null)} item={storeItem} />
+      <MoveInventoryModal opened={Boolean(moveItem)} onClose={() => setMoveItem(null)} item={moveItem} />
       <DeliverInventoryModal opened={Boolean(deliverItem)} onClose={() => setDeliverItem(null)} item={deliverItem} />
-      <TruckDispatchModal
-        opened={Boolean(loadTruckItem)}
-        onClose={() => setLoadTruckItem(null)}
-        bookingId={loadTruckItem?.booking?.id ?? null}
-        bookingReference={loadTruckItem?.booking?.reference ?? null}
-      />
       <ContainerItemsModal
         opened={Boolean(containerItemsItem)}
         onClose={() => setContainerItemsItem(null)}
diff --git a/apps/edr-freight-web/backoffice/src/components/warehouses/ReleaseOrderModal.tsx b/apps/edr-freight-web/backoffice/src/components/warehouses/ReleaseOrderModal.tsx
index 0471d51c6..5cca0d3b2 100644
--- a/apps/edr-freight-web/backoffice/src/components/warehouses/ReleaseOrderModal.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/warehouses/ReleaseOrderModal.tsx
@@ -1,5 +1,5 @@
 import { useEffect, useState } from 'react';
-import { Alert, Button, Group, Modal, NumberInput, Select, SimpleGrid, Stack, Text, TextInput } from '@mantine/core';
+import { Alert, Button, Group, Modal, MultiSelect, NumberInput, Select, SimpleGrid, Stack, Text, TextInput } from '@mantine/core';
 import { Info, Scale } from 'lucide-react';
 
 import { useMutation, useQuery } from '@tanstack/react-query';
@@ -28,29 +28,6 @@ export interface ReleaseOrderTruckPrefill {
   containerNumber?: string | null;
 }
 
-const REGISTERED_FIRST_LAST_MILE_TRUCKS = [
-  ['03-ET A45843', '43495'], ['03-ET A45866', '43470'], ['03-ET A45853', '43508'], ['03-ET A45849', '43414'],
-  ['03-ET A45845', '43492'], ['03-ET A45820', '43487'], ['03-ET A45842', '43478'], ['03-ET A45841', '43515'],
-  ['03-ET A45832', '43504'], ['03-ET A45856', '43510'], ['03-ET A45865', '43490'], ['03-ET A45855', '43485'],
-  ['03-ET A45840', '43499'], ['03-ET A45867', '43493'], ['03-ET A45833', '43466'], ['03-ET A45858', '43496'],
-  ['03-ET A45819', '43474'], ['03-ET A45834', '43502'], ['03-ET A45868', '43469'], ['03-ET A45831', '43488'],
-  ['03-ET A45828', '43479'], ['03-ET A45850', '43505'], ['03-ET A45823', '43480'], ['03-ET A45838', '43472'],
-  ['03-ET A45854', '43500'], ['03-ET A45839', '43486'], ['03-ET A45861', '43513'], ['03-ET A45830', '43501'],
-  ['03-ET A45826', '43498'], ['03-ET A45836', '43467'], ['03-ET A45822', '43512'], ['03-ET A45821', '43210'],
-  ['03-ET A45837', '43475'], ['03-ET A45860', '43497'], ['03-ET A45863', '43477'], ['03-ET A45825', '43483'],
-  ['03-ET A45829', '43473'], ['03-ET A45824', '43491'], ['03-ET A45857', '43481'], ['03-ET A45851', '43509'],
-  ['03-ET A45827', '43468'], ['03-ET A45859', '43887'], ['03-ET A45846', '43471'], ['03-ET A45847', '43511'],
-  ['03-ET A45852', '43484'], ['03-ET A45844', '43476'], ['03-ET A45835', '43482'], ['03-ET A45864', '43503'],
-  ['03-ET A45848', '43494'], ['03-ET A45862', '43465'], ['03-ET A39105', '41218'], ['03-ET A39098', '41220'],
-  ['03-ET A29900', '41865'], ['03-ET A39097', '41226'], ['03-ET A39104', '41225'], ['03-ET A39103', '41223'],
-  ['03-ET A39106', '41221'], ['03-ET A39107', '41215'], ['03-ET A39094', '41222'], ['03-ET A39099', '41216'],
-  ['03-ET A39092', '41224'], ['03-ET A31801', '41214'],
-].map(([powerPlate, trailerPlate], index) => ({
-  value: powerPlate,
-  label: `${index + 1}. ${powerPlate} / ${trailerPlate}`,
-  trailerPlate,
-}));
-
 const toIsoDateTime = (value: string) => {
   if (!value) return undefined;
   const date = new Date(value);
@@ -78,7 +55,7 @@ const lineValue = (notes: string | null | undefined, label: string) => {
 };
 
 const lineNumber = (notes: string | null | undefined, label: string): number | '' => {
-  const value = lineValue(notes, label).replace(/\s*kg$/i, '');
+  const value = lineValue(notes, label).replace(/\s*(kg|t)$/i, '');
   if (!value) return '';
   const parsed = Number(value);
   return Number.isFinite(parsed) ? parsed : '';
@@ -141,6 +118,13 @@ export function ReleaseOrderModal({ opened, onClose, item, truckPrefill }: Relea
     queryFn: () => warehouseService.getCustomerTrucks(bookingId as string),
     enabled: opened && Boolean(bookingId),
   });
+  // Per-container cargo weights — the truck's net (gross − tare) must equal the
+  // total cargo weight of the containers selected as loaded on it.
+  const { data: containerWeights = [] } = useQuery({
+    queryKey: ['release-container-weights', bookingId],
+    queryFn: () => warehouseService.getContainerWeights(bookingId as string),
+    enabled: opened && Boolean(bookingId),
+  });
   const [reference, setReference] = useState('');
   const [truckPlateNumber, setTruckPlateNumber] = useState('');
   const [trailerPlateNumber, setTrailerPlateNumber] = useState('');
@@ -210,22 +194,39 @@ export function ReleaseOrderModal({ opened, onClose, item, truckPrefill }: Relea
       truckType: t.truckType,
     })),
   ];
-  const truckSelectOptions = [
-    ...assignedTruckOptions,
-    ...REGISTERED_FIRST_LAST_MILE_TRUCKS.map((t) => ({
-      value: t.value,
-      label: t.label,
-      trailerPlate: t.trailerPlate,
-      driverName: '',
-      driverPhone: '',
-      truckType: '',
-    })),
-  ];
+  // Only trucks actually assigned to THIS booking (last-mile prefill or customer
+  // portal) are selectable. No global fleet list — if nothing is assigned, the
+  // operator types the plate manually in the field below.
+  const truckSelectOptions = assignedTruckOptions;
   // Neither a last-mile truck nor a customer truck has been assigned yet.
   const noTruckAssigned = assignedTruckOptions.length === 0 && !isCustomerAssignedTruck;
   const isTruckIdentityLocked = isEntranceLocked || isCustomerAssignedTruck || hasLastMileTruckPrefill;
   const isDriverNameLocked = isEntranceLocked || isCustomerAssignedTruck || Boolean(truckPrefill?.driverName);
-  const systemNetWeight = item?.weight == null ? netWeight : Number(item.weight);
+
+  // Which containers ride this truck, and their combined cargo weight. When the
+  // booking has container weights, that sum is the authoritative net; the
+  // operator selects the containers loaded on the truck at exit.
+  const hasContainerWeights = containerWeights.length > 0;
+  const containerWeightByNumber = new Map(
+    containerWeights.map((c) => [c.containerNumber.toUpperCase(), Number(c.weightTons) || 0]),
+  );
+  const containerSelectData = containerWeights.map((c) => ({
+    value: c.containerNumber,
+    label: `${c.containerNumber} · ${(Number(c.weightTons) || 0).toLocaleString()} t`,
+  }));
+  const selectedContainerNumbers = containerNumbers.map((n) => n.trim()).filter(Boolean);
+  const selectedCargoWeight = Number(
+    selectedContainerNumbers
+      .reduce((sum, n) => sum + (containerWeightByNumber.get(n.toUpperCase()) ?? 0), 0)
+      .toFixed(3),
+  );
+  const useContainerNet = hasContainerWeights && selectedContainerNumbers.length > 0;
+
+  const systemNetWeight = useContainerNet
+    ? selectedCargoWeight
+    : item?.weight == null
+      ? netWeight
+      : Number(item.weight);
   const computedNetWeight =
     tareWeight !== '' && grossWeight !== '' ? Number((Number(grossWeight) - Number(tareWeight)).toFixed(3)) : null;
   const weightMismatch =
@@ -246,6 +247,10 @@ export function ReleaseOrderModal({ opened, onClose, item, truckPrefill }: Relea
       toast({ variant: 'destructive', title: 'Gate out time and gross weight are required' });
       return;
     }
+    if (isExitStep && hasContainerWeights && selectedContainerNumbers.length === 0) {
+      toast({ variant: 'destructive', title: 'Select the containers loaded on this truck' });
+      return;
+    }
     if (isExitStep && systemNetWeight === '') {
       toast({ variant: 'destructive', title: 'System recorded net weight is missing' });
       return;
@@ -336,23 +341,27 @@ export function ReleaseOrderModal({ opened, onClose, item, truckPrefill }: Relea
             Truck is not assigned yet — assign a last-mile or customer truck, or enter the plate manually below.
           </Alert>
         )}
-        <Select
-          label="Registered first / last-mile truck"
-          placeholder="Select truck or type plate manually below"
-          searchable
-          clearable
-          data={truckSelectOptions}
-          disabled={isTruckIdentityLocked}
-          value={truckSelectOptions.some((truck) => truck.value === truckPlateNumber) ? truckPlateNumber : null}
-          onChange={(value) => {
-            const truck = truckSelectOptions.find((row) => row.value === value);
-            setTruckPlateNumber(truck?.value ?? '');
-            setTrailerPlateNumber(truck?.trailerPlate ?? '');
-            if (truck?.driverName) setDriverName(truck.driverName);
-            if (truck?.driverPhone) setDriverPhone(truck.driverPhone);
-            if (truck?.truckType) setTruckType(truck.truckType);
-          }}
-        />
+        {truckSelectOptions.length > 0 && (
+          <Select
+            label="Assigned first / last-mile truck"
+            placeholder="Select the assigned truck"
+            searchable
+            clearable
+            // Enabled at arrival so the operator picks which assigned truck came;
+            // only locked on the exit (leaving) step once identity is captured.
+            disabled={isEntranceLocked}
+            data={truckSelectOptions}
+            value={truckSelectOptions.some((truck) => truck.value === truckPlateNumber) ? truckPlateNumber : null}
+            onChange={(value) => {
+              const truck = truckSelectOptions.find((row) => row.value === value);
+              setTruckPlateNumber(truck?.value ?? '');
+              setTrailerPlateNumber(truck?.trailerPlate ?? '');
+              if (truck?.driverName) setDriverName(truck.driverName);
+              if (truck?.driverPhone) setDriverPhone(truck.driverPhone);
+              if (truck?.truckType) setTruckType(truck.truckType);
+            }}
+          />
+        )}
         <Group grow>
           <TextInput
             label="Truck plate number"
@@ -376,34 +385,55 @@ export function ReleaseOrderModal({ opened, onClose, item, truckPrefill }: Relea
           <TextInput label="Driver phone" value={driverPhone} onChange={(e) => setDriverPhone(e.currentTarget.value)} readOnly={isEntranceLocked} />
           <TextInput label="Truck type" value={truckType} onChange={(e) => setTruckType(e.currentTarget.value)} readOnly={isTruckIdentityLocked} />
         </Group>
-        <Group grow>
-          <Stack gap={6}>
-            <SimpleGrid cols={containerNumbers.length > 1 ? 2 : 1} spacing="sm">
-              {containerNumbers.map((containerNumber, index) => (
-                <TextInput
-                  key={index}
-                  label={containerNumbers.length > 1 ? `Container number ${index + 1}` : 'Container number'}
-                  value={containerNumber}
-                  onChange={(e) =>
-                    setContainerNumbers((numbers) =>
-                      numbers.map((number, numberIndex) => (numberIndex === index ? e.currentTarget.value : number)),
-                    )
-                  }
-                  readOnly={isTruckIdentityLocked}
-                />
-              ))}
-            </SimpleGrid>
-          </Stack>
+        <Group grow align="flex-start">
+          {hasContainerWeights ? (
+            <MultiSelect
+              label="Containers on this truck"
+              description={
+                isExitStep
+                  ? 'Select the containers loaded on this truck — their cargo weight must match gross − tare.'
+                  : 'Containers this truck will carry.'
+              }
+              placeholder="Select containers"
+              searchable
+              data={containerSelectData}
+              value={selectedContainerNumbers}
+              onChange={(values) => setContainerNumbers(values.length ? values : [''])}
+            />
+          ) : (
+            <Stack gap={6}>
+              <SimpleGrid cols={containerNumbers.length > 1 ? 2 : 1} spacing="sm">
+                {containerNumbers.map((containerNumber, index) => (
+                  <TextInput
+                    key={index}
+                    label={containerNumbers.length > 1 ? `Container number ${index + 1}` : 'Container number'}
+                    value={containerNumber}
+                    onChange={(e) =>
+                      setContainerNumbers((numbers) =>
+                        numbers.map((number, numberIndex) => (numberIndex === index ? e.currentTarget.value : number)),
+                      )
+                    }
+                    readOnly={isTruckIdentityLocked}
+                  />
+                ))}
+              </SimpleGrid>
+            </Stack>
+          )}
           <TextInput label="Gate in time" type="datetime-local" value={gateInTime} onChange={(e) => setGateInTime(e.currentTarget.value)} readOnly={isEntranceLocked} />
         </Group>
         <Group grow>
-          <NumberInput label="Tare weight (kg)" required min={0} value={tareWeight} onChange={(v) => setTareWeight(v === '' ? '' : Number(v))} readOnly={isEntranceLocked} />
-          <NumberInput label="Gross weight (kg)" required={isExitStep} min={0} value={grossWeight} onChange={(v) => setGrossWeight(v === '' ? '' : Number(v))} disabled={!isExitStep} />
-          <NumberInput label="Recorded net weight (system kg)" min={0} value={systemNetWeight} readOnly />
+          <NumberInput label="Tare weight (t)" required min={0} value={tareWeight} onChange={(v) => setTareWeight(v === '' ? '' : Number(v))} readOnly={isEntranceLocked} />
+          <NumberInput label="Gross weight (t)" required={isExitStep} min={0} value={grossWeight} onChange={(v) => setGrossWeight(v === '' ? '' : Number(v))} disabled={!isExitStep} />
+          <NumberInput
+            label={useContainerNet ? 'Selected cargo net (t)' : 'Recorded net weight (system t)'}
+            min={0}
+            value={systemNetWeight}
+            readOnly
+          />
         </Group>
         <Group justify="space-between">
           <Text size="sm" c={weightMismatch ? 'red' : 'dimmed'}>
-            Computed net: <b>{computedNetWeight == null ? '-' : `${computedNetWeight.toLocaleString()} kg`}</b>
+            Computed net: <b>{computedNetWeight == null ? '-' : `${computedNetWeight.toLocaleString()} t`}</b>
           </Text>
           <TextInput label="Gate out time" type="datetime-local" value={gateOutTime} onChange={(e) => setGateOutTime(e.currentTarget.value)} disabled={!isExitStep} />
         </Group>
diff --git a/apps/edr-freight-web/backoffice/src/components/warehouses/StoreInventoryModal.tsx b/apps/edr-freight-web/backoffice/src/components/warehouses/StoreInventoryModal.tsx
new file mode 100644
index 000000000..f1a5aa4ad
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/components/warehouses/StoreInventoryModal.tsx
@@ -0,0 +1,143 @@
+import { useEffect, useMemo, useState } from 'react';
+import { Alert, Button, Group, Modal, Select, Stack, Text } from '@mantine/core';
+import { Info } from 'lucide-react';
+
+import { useMutation, useQuery } from '@tanstack/react-query';
+
+import { api } from '@/services/api';
+import { useToast } from '@/hooks/use-toast';
+import type { WarehouseInventoryItem } from '@/types/warehouse';
+import { extractErrorMessage } from './options';
+
+interface StoreInventoryModalProps {
+  opened: boolean;
+  onClose: () => void;
+  item: WarehouseInventoryItem | null;
+}
+
+/**
+ * Store an unloaded import item. The operator may pick warehouse → yard → zone
+ * explicitly; leaving them blank falls back to the backend auto allocation.
+ */
+export function StoreInventoryModal({ opened, onClose, item }: StoreInventoryModalProps) {
+  const { toast } = useToast();
+  const storeMutation = useMutation(api.warehouses.store.mutationOptions());
+  const [warehouseId, setWarehouseId] = useState('');
+  const [yardId, setYardId] = useState('');
+  const [zoneId, setZoneId] = useState('');
+
+  useEffect(() => {
+    if (opened) {
+      setWarehouseId('');
+      setYardId('');
+      setZoneId('');
+    }
+  }, [opened]);
+
+  const warehousesQuery = useQuery(
+    api.warehouses.list.queryOptions({ input: { filter: { status: 'ACTIVE' } } }),
+  );
+  const yardsQuery = useQuery(
+    api.warehouses.listYards.queryOptions({
+      input: { warehouseId },
+      enabled: Boolean(warehouseId),
+    }),
+  );
+  const zonesQuery = useQuery(
+    api.warehouses.listZones.queryOptions({
+      input: { yardId },
+      enabled: Boolean(yardId),
+    }),
+  );
+
+  const warehouseOptions = useMemo(
+    () => (warehousesQuery.data ?? []).map((w) => ({ value: w.id, label: `${w.name} (${w.code})` })),
+    [warehousesQuery.data],
+  );
+  const yardOptions = useMemo(
+    () => (yardsQuery.data ?? []).filter((y) => y.status === 'ACTIVE').map((y) => ({ value: y.id, label: `${y.name} (${y.code})` })),
+    [yardsQuery.data],
+  );
+  const zoneOptions = useMemo(
+    () => (zonesQuery.data ?? []).filter((z) => z.status === 'ACTIVE').map((z) => ({ value: z.id, label: `${z.name} (${z.code})` })),
+    [zonesQuery.data],
+  );
+
+  const isManual = Boolean(warehouseId || yardId || zoneId);
+  const manualComplete = Boolean(warehouseId && yardId && zoneId);
+
+  const handleSubmit = async () => {
+    if (!item) return;
+    if (isManual && !manualComplete) {
+      toast({ variant: 'destructive', title: 'Pick warehouse, yard and zone — or clear all to auto-allocate' });
+      return;
+    }
+    try {
+      await storeMutation.mutateAsync({
+        id: item.id,
+        payload: manualComplete ? { warehouseId, yardId, zoneId } : undefined,
+      });
+      toast({ title: manualComplete ? 'Inventory stored at selected location' : 'Inventory stored (auto-allocated)' });
+      onClose();
+    } catch (error) {
+      toast({ variant: 'destructive', title: 'Store failed', description: extractErrorMessage(error) });
+    }
+  };
+
+  return (
+    <Modal opened={opened} onClose={onClose} title="Store inventory" centered size="lg">
+      <Stack gap="md">
+        <Alert icon={<Info size={16} />} color="blue" variant="light">
+          <Text size="sm">
+            Choose a warehouse, yard and zone to store this item at a specific location, or leave them
+            blank to let the system auto-allocate by rule / available capacity.
+          </Text>
+        </Alert>
+        <Select
+          label="Warehouse"
+          placeholder="Auto-allocate"
+          searchable
+          clearable
+          data={warehouseOptions}
+          value={warehouseId || null}
+          onChange={(v) => {
+            setWarehouseId(v ?? '');
+            setYardId('');
+            setZoneId('');
+          }}
+        />
+        <Select
+          label="Yard"
+          placeholder={!warehouseId ? 'Select a warehouse first' : 'Select yard'}
+          searchable
+          clearable
+          disabled={!warehouseId}
+          data={yardOptions}
+          value={yardId || null}
+          onChange={(v) => {
+            setYardId(v ?? '');
+            setZoneId('');
+          }}
+        />
+        <Select
+          label="Zone"
+          placeholder={!yardId ? 'Select a yard first' : 'Select zone'}
+          searchable
+          clearable
+          disabled={!yardId}
+          data={zoneOptions}
+          value={zoneId || null}
+          onChange={(v) => setZoneId(v ?? '')}
+        />
+        <Group justify="flex-end" mt="sm">
+          <Button variant="default" onClick={onClose} disabled={storeMutation.isPending}>
+            Cancel
+          </Button>
+          <Button onClick={handleSubmit} loading={storeMutation.isPending}>
+            {manualComplete ? 'Store here' : 'Store (auto)'}
+          </Button>
+        </Group>
+      </Stack>
+    </Modal>
+  );
+}
diff --git a/apps/edr-freight-web/backoffice/src/components/warehouses/WarehouseInventoryTable.tsx b/apps/edr-freight-web/backoffice/src/components/warehouses/WarehouseInventoryTable.tsx
index b1670fa56..871780bbf 100644
--- a/apps/edr-freight-web/backoffice/src/components/warehouses/WarehouseInventoryTable.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/warehouses/WarehouseInventoryTable.tsx
@@ -41,7 +41,6 @@ const itemKind = (item: WarehouseInventoryItem) => {
 
 const actionColor: Record<InventoryAction, string> = {
   store: 'blue',
-  reserve: 'grape',
   'ready-for-loading': 'cyan',
   load: 'teal',
   dispatch: 'edr-green',
diff --git a/apps/edr-freight-web/backoffice/src/components/warehouses/options.ts b/apps/edr-freight-web/backoffice/src/components/warehouses/options.ts
index 42663877d..3a71ea2a5 100644
--- a/apps/edr-freight-web/backoffice/src/components/warehouses/options.ts
+++ b/apps/edr-freight-web/backoffice/src/components/warehouses/options.ts
@@ -57,3 +57,24 @@ export const extractErrorMessage = (error: unknown, fallback = 'Something went w
   const rawMessage = data?.message ?? data?.error ?? (error as Error)?.message;
   return Array.isArray(rawMessage) ? rawMessage.join(', ') : rawMessage ? String(rawMessage) : fallback;
 };
+
+/**
+ * Error extractor for blob-download requests. When `responseType: 'blob'`, axios
+ * delivers the JSON error body as a Blob, so `extractErrorMessage` can't read
+ * `.message`. Decode the Blob to text, parse it, then fall back to the sync path.
+ */
+export const extractDownloadErrorMessage = async (error: unknown, fallback = 'Something went wrong') => {
+  const responseData = (error as { response?: { data?: unknown } })?.response?.data;
+  if (responseData instanceof Blob) {
+    try {
+      const text = await responseData.text();
+      const parsed = JSON.parse(text) as Record<string, unknown>;
+      const raw = parsed?.message ?? parsed?.error;
+      if (Array.isArray(raw)) return raw.join(', ');
+      if (raw) return String(raw);
+    } catch {
+      /* not JSON — fall through */
+    }
+  }
+  return extractErrorMessage(error, fallback);
+};
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 bd1c51e47..2ceaae870 100644
--- a/apps/edr-freight-web/backoffice/src/constants/QUERY_KEYS.ts
+++ b/apps/edr-freight-web/backoffice/src/constants/QUERY_KEYS.ts
@@ -38,6 +38,8 @@ export const QUERY_KEYS = {
     documents: (id: string) =>
       ["customers", "detail", id, "documents"] as const,
     payments: (id: string) => ["customers", "detail", id, "payments"] as const,
+    changeRequests: (id: string) =>
+      ["customers", "detail", id, "change-requests"] as const,
   },
 
   INVOICES: {
diff --git a/apps/edr-freight-web/backoffice/src/constants/URLS.ts b/apps/edr-freight-web/backoffice/src/constants/URLS.ts
index 05bb06372..77a3bc95e 100644
--- a/apps/edr-freight-web/backoffice/src/constants/URLS.ts
+++ b/apps/edr-freight-web/backoffice/src/constants/URLS.ts
@@ -76,6 +76,12 @@ export const URL_CONSTANTS = {
     DOCUMENTS: (id: string) => `/companies/${id}/documents`,
     PROFILE_STATUS: (profileId: string) =>
       `/companies/company-profiles/${profileId}/status`,
+    CHANGE_REQUESTS: (companyId: string) =>
+      `/companies/${companyId}/change-requests`,
+    CHANGE_REQUEST_APPROVE: (id: string) =>
+      `/companies/change-requests/${id}/approve`,
+    CHANGE_REQUEST_REJECT: (id: string) =>
+      `/companies/change-requests/${id}/reject`,
     BOOKINGS_CUSTOMER_VIEW: (id: string) =>
       `/bookings/by-company/${id}/customer-view`,
     PAYMENTS_CUSTOMER_VIEW: (id: string) =>
diff --git a/apps/edr-freight-web/backoffice/src/lib/permissions.ts b/apps/edr-freight-web/backoffice/src/lib/permissions.ts
index c8bfa7c84..e0c5c3d08 100644
--- a/apps/edr-freight-web/backoffice/src/lib/permissions.ts
+++ b/apps/edr-freight-web/backoffice/src/lib/permissions.ts
@@ -145,6 +145,7 @@ export const FREIGHT_PERMS = {
   },
   tracking: {
     view: "edr_freight_app:tracking:view",
+    manage: "edr_freight_app:tracking:manage",
   },
   fuel: {
     view: "edr_freight_app:fuel:view",
diff --git a/apps/edr-freight-web/backoffice/src/pages/customers/CustomerDetailPage.tsx b/apps/edr-freight-web/backoffice/src/pages/customers/CustomerDetailPage.tsx
index ad888b1f6..c68a4ca25 100644
--- a/apps/edr-freight-web/backoffice/src/pages/customers/CustomerDetailPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/customers/CustomerDetailPage.tsx
@@ -1,6 +1,7 @@
 import {
   ActionIcon,
   Anchor,
+  Badge,
   Box,
   Button,
   Card,
@@ -32,6 +33,8 @@ import { useNavigate, useParams } from "react-router-dom";
 
 import {
   BookingStatusBadge,
+  ChangeRequestPendingBadge,
+  ChangeRequestReview,
   CompanyStatusBadge,
   CompanyTypeBadge,
   InvoiceStatusBadge,
@@ -161,25 +164,85 @@ export default function CustomerDetailPage() {
       {
         id: "type",
         header: "Role",
-        cell: ({ row }) => <ProfileTypeBadge type={row.original.type} />,
-      },
-      {
-        id: "reference",
-        header: "Reference",
         cell: ({ row }) => (
-          <Text size="sm" fw={600} c="edr-text">
-            {row.original.reference}
-          </Text>
+          <div className="space-y-2">
+            <ProfileTypeBadge type={row.original.type} />
+
+            <Text size="sm" fw={600} c="edr-text">
+              {row.original.reference}
+            </Text>
+          </div>
         ),
       },
       {
-        id: "businessLicense",
-        header: "Business license",
-        cell: ({ row }) => (
-          <Text size="sm" c="dimmed">
-            {row.original.businessLicense || "—"}
-          </Text>
-        ),
+        id: "licenseFiles",
+        header: "License documents",
+        cell: ({ row }) => {
+          const files = row.original.licenseFiles ?? [];
+          if (files.length === 0) {
+            return (
+              <Text size="sm" c="dimmed">
+                —
+              </Text>
+            );
+          }
+          return (
+            <Stack gap={4}>
+              {files.map((f) => (
+                <Group key={f.id} gap={6} wrap="nowrap">
+                  <ActionIcon
+                    size="sm"
+                    variant="subtle"
+                    color="gray"
+                    aria-label={`View ${f.name}`}
+                    onClick={() =>
+                      view({
+                        name: f.name,
+                        url: fileViewUrl(f.id),
+                        mimeType: f.mimeType,
+                      })
+                    }
+                  >
+                    <Eye size={14} />
+                  </ActionIcon>
+                  <Anchor
+                    component="button"
+                    type="button"
+                    size="xs"
+                    lineClamp={1}
+                    onClick={() =>
+                      view({
+                        name: f.name,
+                        url: fileViewUrl(f.id),
+                        mimeType: f.mimeType,
+                      })
+                    }
+                    style={{
+                      maxWidth: 170,
+                      textAlign: "left",
+                      textDecoration:
+                        f.status === "pending_remove"
+                          ? "line-through"
+                          : undefined,
+                    }}
+                  >
+                    {f.name}
+                  </Anchor>
+                  {f.status === "pending_add" && (
+                    <Badge size="xs" color="yellow" variant="light">
+                      Pending
+                    </Badge>
+                  )}
+                  {f.status === "pending_remove" && (
+                    <Badge size="xs" color="red" variant="light">
+                      Removing
+                    </Badge>
+                  )}
+                </Group>
+              ))}
+            </Stack>
+          );
+        },
       },
       {
         id: "status",
@@ -207,7 +270,7 @@ export default function CustomerDetailPage() {
         ),
       },
     ],
-    [],
+    [view],
   );
 
   const bookingColumns: ColumnDef<CustomerBooking>[] = useMemo(
@@ -501,13 +564,13 @@ export default function CustomerDetailPage() {
         ]}
         backTo="/dashboard/customers"
         title={company.name}
-        subtitle={`TIN ${company.tin}${
-          company.country ? ` · ${company.country}` : ""
-        }`}
+        subtitle={`TIN ${company.tin}${company.country ? ` · ${company.country}` : ""
+          }`}
         meta={
           <Group gap="xs" wrap="nowrap">
             <CompanyTypeBadge type={company.type} />
             <CompanyStatusBadge status={company.status} />
+            <ChangeRequestPendingBadge companyId={company.id} />
           </Group>
         }
       />
@@ -534,6 +597,8 @@ export default function CustomerDetailPage() {
         {/* OVERVIEW */}
         <Tabs.Panel value="overview" pt="lg">
           <Stack gap="lg">
+            <ChangeRequestReview company={company} />
+
             <KpiStrip
               items={[
                 {
@@ -614,7 +679,7 @@ export default function CustomerDetailPage() {
                   <ProfileChips profiles={company.companyProfiles} />
                 </Group>
                 <Box style={{ overflowX: "auto" }} w="100%">
-                  <Box miw={860}>
+                  <Box miw={1040}>
                     <DataTable
                       columns={profileColumns}
                       data={company.companyProfiles}
@@ -641,9 +706,9 @@ export default function CustomerDetailPage() {
               error={
                 bookingsQuery.isError
                   ? {
-                      message: "Failed to load bookings.",
-                      onRetry: () => void bookingsQuery.refetch(),
-                    }
+                    message: "Failed to load bookings.",
+                    onRetry: () => void bookingsQuery.refetch(),
+                  }
                   : undefined
               }
             />
@@ -663,9 +728,9 @@ export default function CustomerDetailPage() {
                 error={
                   documentsQuery.isError
                     ? {
-                        message: "Failed to load documents.",
-                        onRetry: () => void documentsQuery.refetch(),
-                      }
+                      message: "Failed to load documents.",
+                      onRetry: () => void documentsQuery.refetch(),
+                    }
                     : undefined
                 }
               />
@@ -679,12 +744,12 @@ export default function CustomerDetailPage() {
                   </Text>
                   <Stack gap="md">
                     {licenseProfiles.map((p) => (
-                      <Stack key={p.id} gap={4}>
+                      <Stack key={p.id} gap={6}>
                         <Text size="sm" fw={600} c="edr-text">
                           {humanize(p.type)} · {p.reference}
                         </Text>
                         {(p.licenseFiles ?? []).map((f) => (
-                          <Group key={f.url} gap={6} wrap="nowrap">
+                          <Group key={f.id} gap={8} wrap="nowrap">
                             <Paperclip size={13} className="text-edr-muted" />
                             <Anchor
                               component="button"
@@ -692,16 +757,37 @@ export default function CustomerDetailPage() {
                               onClick={() =>
                                 view({
                                   name: f.name,
-                                  url: f.url,
+                                  url: fileViewUrl(f.id),
                                   mimeType: f.mimeType,
                                 })
                               }
                               size="xs"
+                              style={{
+                                textDecoration:
+                                  f.status === "pending_remove"
+                                    ? "line-through"
+                                    : undefined,
+                              }}
                             >
                               {f.name}
                             </Anchor>
+                            {f.status === "pending_add" && (
+                              <Badge size="xs" color="yellow" variant="light">
+                                Pending approval
+                              </Badge>
+                            )}
+                            {f.status === "pending_remove" && (
+                              <Badge size="xs" color="red" variant="light">
+                                Removal pending
+                              </Badge>
+                            )}
                           </Group>
                         ))}
+                        {(p.licenseFiles ?? []).length === 0 && (
+                          <Text size="xs" c="dimmed">
+                            No license documents.
+                          </Text>
+                        )}
                       </Stack>
                     ))}
                   </Stack>
@@ -723,9 +809,9 @@ export default function CustomerDetailPage() {
               error={
                 paymentsQuery.isError
                   ? {
-                      message: "Failed to load payments.",
-                      onRetry: () => void paymentsQuery.refetch(),
-                    }
+                    message: "Failed to load payments.",
+                    onRetry: () => void paymentsQuery.refetch(),
+                  }
                   : undefined
               }
             />
@@ -746,9 +832,9 @@ export default function CustomerDetailPage() {
                 error={
                   invoicesQuery.isError
                     ? {
-                        message: "Failed to load invoices.",
-                        onRetry: () => void invoicesQuery.refetch(),
-                      }
+                      message: "Failed to load invoices.",
+                      onRetry: () => void invoicesQuery.refetch(),
+                    }
                     : undefined
                 }
                 pagination={{
diff --git a/apps/edr-freight-web/backoffice/src/pages/fleet/TrackingPage.tsx b/apps/edr-freight-web/backoffice/src/pages/fleet/TrackingPage.tsx
index 14bb32d33..958d99775 100644
--- a/apps/edr-freight-web/backoffice/src/pages/fleet/TrackingPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/fleet/TrackingPage.tsx
@@ -27,6 +27,8 @@ import {
 import { Activity, Pencil, Plus, Radio, Trash2 } from "lucide-react";
 import Breadcrumbs from "@/components/ui/Breadcrumbs";
 import { useToast } from "@/hooks/use-toast";
+import { useAuth } from "@/auth/useAuth";
+import { FREIGHT_PERMS, hasPermission } from "@/lib/permissions";
 import { vehiclesService } from "@/services/vehicles.service";
 import { gpsTrackingService, type GpsDevice } from "@/services/gps-tracking.service";
 import { freightBrand } from "@/theme/freight-brand";
@@ -151,6 +153,8 @@ function RouteTrail({ path }: { path: LatLng[] }) {
 export function TrackingPage() {
   const { toast } = useToast();
   const qc = useQueryClient();
+  const { user } = useAuth();
+  const canManage = hasPermission(user, FREIGHT_PERMS.tracking.manage);
   const [selectedId, setSelectedId] = useState<string | null>(null);
   const [hoverId, setHoverId] = useState<string | null>(null);
   const [mapsReady, setMapsReady] = useState(false);
@@ -288,9 +292,11 @@ export function TrackingPage() {
           <Text fw={700} size="xl">Real-Time Vehicle Tracking</Text>
           <Text c="dimmed" size="sm">Live GPS positions from GT06 trackers</Text>
         </div>
-        <Button leftSection={<Plus size={16} />} color="edr-green" onClick={openRegister}>
-          Register tracker
-        </Button>
+        {canManage && (
+          <Button leftSection={<Plus size={16} />} color="edr-green" onClick={openRegister}>
+            Register tracker
+          </Button>
+        )}
       </Group>
 
       <Grid>
@@ -358,9 +364,11 @@ export function TrackingPage() {
                       <Badge color={selected.online ? "edr-green" : "gray"} leftSection={<Activity size={12} />}>
                         {selected.online ? "Live" : "Offline"}
                       </Badge>
-                      <ActionIcon variant="subtle" color="red" aria-label="Remove tracker" onClick={() => deleteMutation.mutate(selected.id)}>
-                        <Trash2 size={16} />
-                      </ActionIcon>
+                      {canManage && (
+                        <ActionIcon variant="subtle" color="red" aria-label="Remove tracker" onClick={() => deleteMutation.mutate(selected.id)}>
+                          <Trash2 size={16} />
+                        </ActionIcon>
+                      )}
                     </Group>
                   </Group>
 
@@ -393,6 +401,7 @@ export function TrackingPage() {
                     data={vehicleOptions}
                     value={selected.vehicleId ?? null}
                     onChange={(v) => assignMutation.mutate({ id: selected.id, vehicleId: v })}
+                    disabled={!canManage}
                     searchable
                     clearable
                   />
@@ -421,14 +430,16 @@ export function TrackingPage() {
                           <Table.Td align="right">
                             <Group gap={6} justify="flex-end" wrap="nowrap">
                               <Badge color={d.online ? "edr-green" : "gray"} size="sm">{d.online ? "Live" : "Offline"}</Badge>
-                              <ActionIcon
-                                variant="subtle"
-                                size="sm"
-                                aria-label="Edit tracker"
-                                onClick={(e) => { e.stopPropagation(); openEdit(d); }}
-                              >
-                                <Pencil size={15} />
-                              </ActionIcon>
+                              {canManage && (
+                                <ActionIcon
+                                  variant="subtle"
+                                  size="sm"
+                                  aria-label="Edit tracker"
+                                  onClick={(e) => { e.stopPropagation(); openEdit(d); }}
+                                >
+                                  <Pencil size={15} />
+                                </ActionIcon>
+                              )}
                             </Group>
                           </Table.Td>
                         </Table.Tr>
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 d57210e1e..f3235e0d1 100644
--- a/apps/edr-freight-web/backoffice/src/pages/operations/LastMilePage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/operations/LastMilePage.tsx
@@ -286,6 +286,9 @@ const toReleaseInventoryItem = (row: ImportUnloadedItem): WarehouseInventoryItem
     handoverDocumentReference: row.handoverDocumentReference,
     handoverDocumentDate: row.handoverDocumentDate,
     deliveredAt: row.deliveredAt,
+    // Carries the saved [Exit Inspection] block so truck-leaving prefills the
+    // details captured at arrival (plate, driver, tare, gate-in).
+    notes: row.notes,
     booking: row.bookingId
       ? {
           id: row.bookingId,
diff --git a/apps/edr-freight-web/backoffice/src/pages/warehouses/LoadedInventoryPage.tsx b/apps/edr-freight-web/backoffice/src/pages/warehouses/LoadedInventoryPage.tsx
index b5deec80e..7dfc1996c 100644
--- a/apps/edr-freight-web/backoffice/src/pages/warehouses/LoadedInventoryPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/warehouses/LoadedInventoryPage.tsx
@@ -38,7 +38,7 @@ const columns: ColumnDef<Loading>[] = [
   },
   {
     id: 'weight',
-    header: 'Loaded Weight (kg)',
+    header: 'Loaded Weight (t)',
     cell: ({ row }) => formatNumber(row.original.loadedWeight),
   },
   {
diff --git a/apps/edr-freight-web/backoffice/src/pages/warehouses/LoadingQueuePage.tsx b/apps/edr-freight-web/backoffice/src/pages/warehouses/LoadingQueuePage.tsx
index 652a26863..e9bb3a162 100644
--- a/apps/edr-freight-web/backoffice/src/pages/warehouses/LoadingQueuePage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/warehouses/LoadingQueuePage.tsx
@@ -203,7 +203,7 @@ function PendingPaymentTable({ items, onNavigate }: PendingPaymentTableProps) {
     },
     { id: 'warehouse', header: 'Warehouse', cell: ({ row }) => row.original.warehouse?.code ?? '—' },
     { id: 'zone', header: 'Zone', cell: ({ row }) => row.original.zone?.code ?? '—' },
-    { id: 'weight', header: 'Weight (kg)', cell: ({ row }) => formatNumber(row.original.weight) },
+    { id: 'weight', header: 'Weight (t)', cell: ({ row }) => formatNumber(row.original.weight) },
     {
       id: 'payment',
       header: 'Payment',
diff --git a/apps/edr-freight-web/backoffice/src/pages/warehouses/WarehouseRulesPage.tsx b/apps/edr-freight-web/backoffice/src/pages/warehouses/WarehouseRulesPage.tsx
index 41a97110f..81633f9f8 100644
--- a/apps/edr-freight-web/backoffice/src/pages/warehouses/WarehouseRulesPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/warehouses/WarehouseRulesPage.tsx
@@ -16,7 +16,7 @@ import {
   Text,
   TextInput,
 } from '@mantine/core';
-import { Info, Plus, Trash2 } from 'lucide-react';
+import { Info, Pencil, Plus, Trash2 } from 'lucide-react';
 
 import { useQuery } from '@tanstack/react-query';
 
@@ -30,6 +30,8 @@ import {
   useDeleteAllocationRule,
   useDeleteFeeRule,
   useFeeRules,
+  useUpdateAllocationRule,
+  useUpdateFeeRule,
 } from '@/hooks/useWarehouses';
 import { api } from '@/services/api';
 import {
@@ -38,6 +40,8 @@ import {
   FEE_RULE_TYPES,
   FEE_RULE_TYPE_LABELS,
   VEHICLE_TYPES,
+  type AllocationRule,
+  type FeeRule,
   type FeeRuleBasis,
   type FeeRuleType,
 } from '@/types/warehouse';
@@ -121,8 +125,10 @@ function AllocationRules() {
   const { data, isLoading } = useAllocationRules();
   const { data: yards = [], isLoading: yardsLoading } = useAllWarehouseYards();
   const create = useCreateAllocationRule();
+  const update = useUpdateAllocationRule();
   const remove = useDeleteAllocationRule();
   const [open, setOpen] = useState(false);
+  const [editingId, setEditingId] = useState<string | null>(null);
   const [form, setForm] = useState({
     name: '',
     priority: 100,
@@ -142,7 +148,8 @@ function AllocationRules() {
       label: `${yard.code} - ${yard.name}${yard.warehouse?.code ? ` (${yard.warehouse.code})` : ''}`,
     }));
 
-  const resetForm = () =>
+  const resetForm = () => {
+    setEditingId(null);
     setForm({
       name: '',
       priority: 100,
@@ -153,6 +160,22 @@ function AllocationRules() {
       targetYardCode: '',
       storageType: '',
     });
+  };
+
+  const startEdit = (rule: AllocationRule) => {
+    setForm({
+      name: rule.name,
+      priority: rule.priority ?? 100,
+      freightType: rule.freightType ?? '',
+      tradeDirection: rule.tradeDirection ?? '',
+      cargoTypeCode: rule.cargoTypeCode ?? '',
+      containerStatus: rule.containerStatus ?? '',
+      targetYardCode: rule.targetYardCode ?? '',
+      storageType: rule.storageType ?? '',
+    });
+    setEditingId(rule.id);
+    setOpen(true);
+  };
 
   const submit = async () => {
     if (!form.name.trim() || !form.targetYardCode.trim()) {
@@ -160,7 +183,7 @@ function AllocationRules() {
       return;
     }
 
-    await create.mutateAsync({
+    const payload = {
       name: form.name.trim(),
       priority: form.priority,
       freightType: clean(form.freightType) ?? null,
@@ -170,10 +193,20 @@ function AllocationRules() {
       targetYardCode: form.targetYardCode.trim(),
       storageType: clean(form.storageType) ?? null,
       isActive: true,
-    } as never);
-    toast({ title: 'Allocation rule created' });
-    setOpen(false);
-    resetForm();
+    };
+    try {
+      if (editingId) {
+        await update.mutateAsync({ id: editingId, payload: payload as never });
+        toast({ title: 'Allocation rule updated' });
+      } else {
+        await create.mutateAsync(payload as never);
+        toast({ title: 'Allocation rule created' });
+      }
+      setOpen(false);
+      resetForm();
+    } catch (error) {
+      toast({ variant: 'destructive', title: editingId ? 'Update failed' : 'Create failed', description: extractErrorMessage(error) });
+    }
   };
 
   return (
@@ -182,7 +215,7 @@ function AllocationRules() {
         <Text c="dimmed" size="sm">
           {rules.length} rule(s) matched by ascending priority
         </Text>
-        <Button leftSection={<Plus size={16} />} onClick={() => setOpen(true)}>
+        <Button leftSection={<Plus size={16} />} onClick={() => { resetForm(); setOpen(true); }}>
           New allocation rule
         </Button>
       </Group>
@@ -229,14 +262,19 @@ function AllocationRules() {
                     </Badge>
                   </Table.Td>
                   <Table.Td ta="right">
-                    <ActionIcon
-                      variant="subtle"
-                      color="red"
-                      onClick={() => remove.mutate(rule.id)}
-                      title="Delete"
-                    >
-                      <Trash2 size={16} />
-                    </ActionIcon>
+                    <Group gap={4} justify="flex-end" wrap="nowrap">
+                      <ActionIcon variant="subtle" color="blue" onClick={() => startEdit(rule)} title="Edit">
+                        <Pencil size={16} />
+                      </ActionIcon>
+                      <ActionIcon
+                        variant="subtle"
+                        color="red"
+                        onClick={() => remove.mutate(rule.id)}
+                        title="Delete"
+                      >
+                        <Trash2 size={16} />
+                      </ActionIcon>
+                    </Group>
                   </Table.Td>
                 </Table.Tr>
               ))}
@@ -245,7 +283,7 @@ function AllocationRules() {
         </Table.ScrollContainer>
       )}
 
-      <Modal opened={open} onClose={() => setOpen(false)} title="New allocation rule" centered size="lg">
+      <Modal opened={open} onClose={() => { setOpen(false); resetForm(); }} title={editingId ? 'Edit allocation rule' : 'New allocation rule'} centered size="lg">
         <Stack gap="md">
           <Card withBorder radius="md" padding="sm" bg="gray.0">
             <Stack gap={4}>
@@ -340,11 +378,11 @@ function AllocationRules() {
             />
           </Group>
           <Group justify="flex-end" mt="sm">
-            <Button variant="default" onClick={() => setOpen(false)}>
+            <Button variant="default" onClick={() => { setOpen(false); resetForm(); }}>
               Cancel
             </Button>
-            <Button loading={create.isPending} onClick={submit}>
-              Create
+            <Button loading={create.isPending || update.isPending} onClick={submit}>
+              {editingId ? 'Save changes' : 'Create'}
             </Button>
           </Group>
         </Stack>
@@ -363,8 +401,10 @@ function FeeRules() {
     api.containerTypes.list.queryOptions({ staleTime: Infinity }),
   );
   const create = useCreateFeeRule();
+  const update = useUpdateFeeRule();
   const remove = useDeleteFeeRule();
   const [open, setOpen] = useState(false);
+  const [editingId, setEditingId] = useState<string | null>(null);
   const [form, setForm] = useState({
     name: '',
     ruleType: 'DEMURRAGE_FEE' as FeeRuleType,
@@ -394,7 +434,8 @@ function FeeRules() {
   // Double handling + truck detention apply to IMPORT only — trade direction is locked.
   const isImportOnly = isDoubleHandling || isTruckDetention;
 
-  const resetForm = () =>
+  const resetForm = () => {
+    setEditingId(null);
     setForm({
       name: '',
       ruleType: 'DEMURRAGE_FEE',
@@ -410,6 +451,27 @@ function FeeRules() {
       tiers: [],
       currency: 'USD',
     });
+  };
+
+  const startEdit = (rule: FeeRule) => {
+    setForm({
+      name: rule.name,
+      ruleType: rule.ruleType,
+      basis: (rule.basis as FeeRuleBasis) ?? 'PER_CONTAINER',
+      freightType: rule.freightType ?? '',
+      tradeDirection: rule.tradeDirection ?? '',
+      cargoTypeCode: rule.cargoTypeCode ?? '',
+      containerType: rule.containerType ?? '',
+      vehicleType: rule.vehicleType ?? '',
+      freeDays: rule.freeDays ?? 3,
+      freeHours: rule.freeHours ?? 3,
+      ratePerDay: rule.ratePerDay ?? 0,
+      tiers: (rule.tiers ?? []).map((t) => ({ fromDay: t.fromDay, toDay: t.toDay, ratePerDay: t.ratePerDay })),
+      currency: rule.currency ?? 'USD',
+    });
+    setEditingId(rule.id);
+    setOpen(true);
+  };
 
   const addTier = () =>
     setForm((f) => {
@@ -479,12 +541,17 @@ function FeeRules() {
     };
 
     try {
-      await create.mutateAsync(payload as never);
-      toast({ title: 'Fee rule created' });
+      if (editingId) {
+        await update.mutateAsync({ id: editingId, payload: payload as never });
+        toast({ title: 'Fee rule updated' });
+      } else {
+        await create.mutateAsync(payload as never);
+        toast({ title: 'Fee rule created' });
+      }
       setOpen(false);
       resetForm();
     } catch (error) {
-      if (tiers.length && isUnknownTiersError(error)) {
+      if (!editingId && tiers.length && isUnknownTiersError(error)) {
         const legacyPayload: Omit<typeof payload, 'tiers'> = {
           name: payload.name,
           ruleType: payload.ruleType,
@@ -505,7 +572,7 @@ function FeeRules() {
         resetForm();
         return;
       }
-      toast({ variant: 'destructive', title: 'Create failed', description: extractErrorMessage(error) });
+      toast({ variant: 'destructive', title: editingId ? 'Update failed' : 'Create failed', description: extractErrorMessage(error) });
     }
   };
 
@@ -515,7 +582,7 @@ function FeeRules() {
         <Text c="dimmed" size="sm">
           {rules.length} rule(s) - most specific match applies
         </Text>
-        <Button leftSection={<Plus size={16} />} onClick={() => setOpen(true)}>
+        <Button leftSection={<Plus size={16} />} onClick={() => { resetForm(); setOpen(true); }}>
           New fee rule
         </Button>
       </Group>
@@ -577,14 +644,19 @@ function FeeRules() {
                     </Badge>
                   </Table.Td>
                   <Table.Td ta="right">
-                    <ActionIcon
-                      variant="subtle"
-                      color="red"
-                      onClick={() => remove.mutate(rule.id)}
-                      title="Delete"
-                    >
-                      <Trash2 size={16} />
-                    </ActionIcon>
+                    <Group gap={4} justify="flex-end" wrap="nowrap">
+                      <ActionIcon variant="subtle" color="blue" onClick={() => startEdit(rule)} title="Edit">
+                        <Pencil size={16} />
+                      </ActionIcon>
+                      <ActionIcon
+                        variant="subtle"
+                        color="red"
+                        onClick={() => remove.mutate(rule.id)}
+                        title="Delete"
+                      >
+                        <Trash2 size={16} />
+                      </ActionIcon>
+                    </Group>
                   </Table.Td>
                 </Table.Tr>
               ))}
@@ -593,7 +665,7 @@ function FeeRules() {
         </Table.ScrollContainer>
       )}
 
-      <Modal opened={open} onClose={() => setOpen(false)} title="New fee rule" centered size="lg">
+      <Modal opened={open} onClose={() => { setOpen(false); resetForm(); }} title={editingId ? 'Edit fee rule' : 'New fee rule'} centered size="lg">
         <Stack gap="sm">
           <Group grow>
             <TextInput
@@ -775,11 +847,11 @@ function FeeRules() {
           </Stack>
           )}
           <Group justify="flex-end" mt="sm">
-            <Button variant="default" onClick={() => setOpen(false)}>
+            <Button variant="default" onClick={() => { setOpen(false); resetForm(); }}>
               Cancel
             </Button>
-            <Button loading={create.isPending} onClick={submit}>
-              Create
+            <Button loading={create.isPending || update.isPending} onClick={submit}>
+              {editingId ? 'Save changes' : 'Create'}
             </Button>
           </Group>
         </Stack>
diff --git a/apps/edr-freight-web/backoffice/src/services/api.ts b/apps/edr-freight-web/backoffice/src/services/api.ts
index c991c54f6..c04c67169 100644
--- a/apps/edr-freight-web/backoffice/src/services/api.ts
+++ b/apps/edr-freight-web/backoffice/src/services/api.ts
@@ -3,6 +3,7 @@ import type { FleetResourceSlug } from "@/pages/fleet/config/resources";
 import type { BookingDetail } from "@/types/booking";
 import type {
   Company,
+  CompanyChangeRequest,
   CompanyListFilter,
   CompanyProfile,
   CompanyStats,
@@ -99,6 +100,7 @@ import type {
   LoadInventoryPayload,
   LoadPassedExportResult,
   MoveInventoryPayload,
+  StoreInventoryPayload,
   PayInvoicePayload,
   ReadyToLoadRow,
   ReceiveInventoryPayload,
@@ -1051,10 +1053,13 @@ export const api = {
       () => [["warehouse-inventory"], ["warehouses"]],
     ),
 
-    store: endpoint<string, WarehouseInventoryItem>(
+    store: endpoint<
+      { id: string; payload?: StoreInventoryPayload },
+      WarehouseInventoryItem
+    >(
       "warehouse-inventory",
       "store",
-      (id) => warehouseService.store(id).then((r) => r.data),
+      ({ id, payload }) => warehouseService.store(id, payload).then((r) => r.data),
       undefined,
       () => INVENTORY_INVALIDATIONS,
     ),
@@ -2261,13 +2266,13 @@ export const api = {
     ),
 
     setProfileStatus: endpoint<
-      { profileId: string; status: ProfileStatus },
+      { profileId: string; status: ProfileStatus; note?: string },
       CompanyProfile
     >(
       "customers",
       "setProfileStatus",
-      ({ profileId, status }) =>
-        customersService.setProfileStatus(profileId, status),
+      ({ profileId, status, note }) =>
+        customersService.setProfileStatus(profileId, status, note),
       undefined,
       (_input, data) => [
         QUERY_KEYS.CUSTOMERS.byId(data.companyId),
@@ -2275,6 +2280,37 @@ export const api = {
       ],
     ),
 
+    changeRequests: endpoint<{ id: string }, CompanyChangeRequest[]>(
+      "customers",
+      "changeRequests",
+      ({ id }) => customersService.changeRequests(id),
+      ({ id }) => QUERY_KEYS.CUSTOMERS.changeRequests(id),
+    ),
+
+    approveChangeRequest: endpoint<{ id: string }, CompanyChangeRequest>(
+      "customers",
+      "approveChangeRequest",
+      ({ id }) => customersService.approveChangeRequest(id),
+      undefined,
+      (_input, data) => [
+        QUERY_KEYS.CUSTOMERS.changeRequests(data.companyId),
+        QUERY_KEYS.CUSTOMERS.byId(data.companyId),
+        QUERY_KEYS.CUSTOMERS.ROOT,
+      ],
+    ),
+
+    rejectChangeRequest: endpoint<{ id: string; note: string }, CompanyChangeRequest>(
+      "customers",
+      "rejectChangeRequest",
+      ({ id, note }) => customersService.rejectChangeRequest(id, note),
+      undefined,
+      (_input, data) => [
+        QUERY_KEYS.CUSTOMERS.changeRequests(data.companyId),
+        QUERY_KEYS.CUSTOMERS.byId(data.companyId),
+        QUERY_KEYS.CUSTOMERS.ROOT,
+      ],
+    ),
+
     setCompanyStatus: endpoint<{ companyId: string; status: string }, unknown>(
       "customers",
       "setCompanyStatus",
diff --git a/apps/edr-freight-web/backoffice/src/services/customers.service.ts b/apps/edr-freight-web/backoffice/src/services/customers.service.ts
index 9ac20093c..cafe0aece 100644
--- a/apps/edr-freight-web/backoffice/src/services/customers.service.ts
+++ b/apps/edr-freight-web/backoffice/src/services/customers.service.ts
@@ -2,6 +2,7 @@ import { api as apiClient } from "@/auth/http";
 import { URL_CONSTANTS } from "@/constants/URLS";
 import type {
   Company,
+  CompanyChangeRequest,
   CompanyListFilter,
   CompanyProfile,
   CompanyStats,
@@ -80,11 +81,15 @@ export const customersService = {
       .then((r) => r.data);
   },
 
-  setProfileStatus(profileId: string, status: ProfileStatus): Promise<CompanyProfile> {
+  setProfileStatus(
+    profileId: string,
+    status: ProfileStatus,
+    note?: string,
+  ): Promise<CompanyProfile> {
     return apiClient
       .patch<CompanyProfile>(
         URL_CONSTANTS.COMPANIES.PROFILE_STATUS(profileId),
-        { status },
+        { status, note },
       )
       .then((r) => r.data);
   },
@@ -95,4 +100,32 @@ export const customersService = {
       .patch(URL_CONSTANTS.COMPANIES.BY_ID(companyId), { status })
       .then((r) => r.data);
   },
+
+  /** List a company's profile-edit change requests (newest first). */
+  changeRequests(companyId: string): Promise<CompanyChangeRequest[]> {
+    return apiClient
+      .get<CompanyChangeRequest[]>(
+        URL_CONSTANTS.COMPANIES.CHANGE_REQUESTS(companyId),
+      )
+      .then((r) => r.data);
+  },
+
+  /** Approve a pending change request — applies the proposed changes. */
+  approveChangeRequest(id: string): Promise<CompanyChangeRequest> {
+    return apiClient
+      .post<CompanyChangeRequest>(
+        URL_CONSTANTS.COMPANIES.CHANGE_REQUEST_APPROVE(id),
+      )
+      .then((r) => r.data);
+  },
+
+  /** Reject a pending change request with a note. */
+  rejectChangeRequest(id: string, note: string): Promise<CompanyChangeRequest> {
+    return apiClient
+      .post<CompanyChangeRequest>(
+        URL_CONSTANTS.COMPANIES.CHANGE_REQUEST_REJECT(id),
+        { note },
+      )
+      .then((r) => r.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 16037b199..366d8b9f3 100644
--- a/apps/edr-freight-web/backoffice/src/services/warehouse.service.ts
+++ b/apps/edr-freight-web/backoffice/src/services/warehouse.service.ts
@@ -30,6 +30,7 @@ import type {
   LoadableWagon,
   LoadInventoryPayload,
   MoveInventoryPayload,
+  StoreInventoryPayload,
   ReceiveInventoryPayload,
   ReleaseOrderPayload,
   DeliverInventoryPayload,
@@ -63,7 +64,7 @@ import type {
   WarehouseZone,
 } from '@/types/warehouse';
 
-export type ContainerItemStage = 'PENDING' | 'RECEIVED' | 'GRN' | 'LOADED' | 'LEFT' | 'DELIVERED';
+export type ContainerItemStage = 'PENDING' | 'RECEIVED' | 'GRN' | 'ASSIGNED' | 'LOADED' | 'LEFT' | 'DELIVERED';
 
 export interface ContainerItem {
   containerNumber: string;
@@ -74,9 +75,12 @@ export interface ContainerItem {
   truckPlate: string | null;
   truckArrived: boolean;
   truckLeft: boolean;
+  /** Operator has loaded this container onto the truck (customer assignment alone is not "loaded"). */
+  loaded: boolean;
   bookingReference: string | null;
   contractId: string | null;
   hasLastMile: boolean;
+  handoverSigned: boolean;
 }
 
 /** A pre-dispatch EXPORT train that has inventory waiting to be loaded. */
@@ -135,6 +139,26 @@ export const warehouseService = {
     return data?.data ?? data ?? [];
   },
 
+  /** Ask the customer to sign the booking's handover (creates one if none, then notifies). */
+  requestHandoverSignature: async (
+    bookingId: string,
+  ): Promise<{ notified: boolean; reference: string | null; alreadySigned: boolean }> => {
+    const { data } = await apiClient.post(
+      `/warehouse-inventory/bookings/${bookingId}/request-handover-signature`,
+    );
+    return data?.data ?? data;
+  },
+
+  /** A booking's containers with VGM cargo weight (tonnes) for exit weighing. */
+  getContainerWeights: async (
+    bookingId: string,
+  ): Promise<Array<{ containerNumber: string; weightTons: number }>> => {
+    const { data } = await apiClient.get(
+      `/warehouse-inventory/bookings/${bookingId}/container-weights`,
+    );
+    return data?.data ?? data ?? [];
+  },
+
   /** Booking container numbers not yet loaded onto any truck. */
   getLoadableContainers: async (bookingId: string): Promise<string[]> => {
     const { data } = await apiClient.get(
@@ -235,8 +259,8 @@ export const warehouseService = {
     }),
 
   // ── Lifecycle (Batch 2) ──────────────────────────────────────────────────
-  store: (id: string) =>
-    apiClient.post<WarehouseInventoryItem>(URL_CONSTANTS.WAREHOUSE_INVENTORY.STORE(id)),
+  store: (id: string, payload?: StoreInventoryPayload) =>
+    apiClient.post<WarehouseInventoryItem>(URL_CONSTANTS.WAREHOUSE_INVENTORY.STORE(id), payload),
   reserve: (payload: ReserveInventoryPayload) =>
     apiClient.post<WarehouseInventoryItem>(URL_CONSTANTS.WAREHOUSE_INVENTORY.RESERVE, payload),
   markReadyForLoading: (id: string) =>
diff --git a/apps/edr-freight-web/backoffice/src/types/customer.ts b/apps/edr-freight-web/backoffice/src/types/customer.ts
index e92d75c89..8d76571d4 100644
--- a/apps/edr-freight-web/backoffice/src/types/customer.ts
+++ b/apps/edr-freight-web/backoffice/src/types/customer.ts
@@ -30,14 +30,24 @@ export type ProfileType =
   | "transporter";
 
 /** Mirrors backend `ProfileStatus`. */
-export type ProfileStatus = "active" | "pending" | "suspended" | "blacklisted";
+export type ProfileStatus =
+  | "active"
+  | "pending"
+  | "rejected"
+  | "suspended"
+  | "blacklisted";
 
-/** A business-license document uploaded for a company profile. */
+/** Review state of a business-license file (mirrors API ProfileLicenseFileView). */
+export type LicenseFileStatus = "live" | "pending_add" | "pending_remove";
+
+/** A business-license document uploaded for a company profile (FileRecord-backed). */
 export interface LicenseFile {
+  id: string;
   name: string;
-  url: string;
   size: number;
-  mimeType?: string;
+  mimeType: string;
+  /** `live` = approved; `pending_add`/`pending_remove` = awaiting review. */
+  status: LicenseFileStatus;
 }
 
 /** A single role a company is registered for, with its reference code. */
@@ -52,6 +62,39 @@ export interface CompanyProfile {
   /** Business-license documents uploaded for this profile. */
   licenseFiles?: LicenseFile[];
   attributes?: Record<string, unknown> | null;
+  /** Reviewer note when the role is rejected. */
+  reviewNote?: string | null;
+  createdAt: string;
+  updatedAt: string;
+}
+
+/** Lifecycle of a staged customer profile-edit review. */
+export type ChangeRequestStatus = "pending" | "approved" | "rejected";
+
+/** A staged business-license add/remove on one profile, awaiting review. */
+export interface LicenseChangeIntent {
+  profileId: string;
+  op: "add" | "remove";
+  fileId: string;
+  fileName?: string;
+}
+
+/**
+ * A staged profile-edit change request. The customer's settings edits land here
+ * (pending) until a reviewer approves (applies them) or rejects (with a note).
+ */
+export interface CompanyChangeRequest {
+  id: string;
+  companyId: string;
+  status: ChangeRequestStatus;
+  /** Proposed field values (the diff payload vs. the live company). */
+  snapshot: Record<string, unknown>;
+  documentFileIds: string[];
+  /** Staged business-license add/remove intents attached to this request. */
+  licenseChanges: LicenseChangeIntent[];
+  note: string | null;
+  submittedAt: string | null;
+  reviewedAt: string | null;
   createdAt: string;
   updatedAt: string;
 }
diff --git a/apps/edr-freight-web/backoffice/src/types/warehouse.ts b/apps/edr-freight-web/backoffice/src/types/warehouse.ts
index 48ec6f7b3..e16271880 100644
--- a/apps/edr-freight-web/backoffice/src/types/warehouse.ts
+++ b/apps/edr-freight-web/backoffice/src/types/warehouse.ts
@@ -41,7 +41,6 @@ export type InventoryStatus = (typeof INVENTORY_STATUSES)[number];
 
 export type InventoryAction =
   | 'store'
-  | 'reserve'
   | 'ready-for-loading'
   | 'load'
   | 'dispatch'
@@ -59,7 +58,7 @@ export const INVENTORY_NEXT_ACTION: Record<InventoryStatus, InventoryAction | nu
   UNLOADED: 'store',
   UNLOADED_AT_DJIBOUTI_PORT: null,
   RECEIVED: 'store',
-  STORED: 'reserve',
+  STORED: 'ready-for-loading',
   RESERVED: 'ready-for-loading',
   ARRIVED_AT_WAREHOUSE: null,
   UNDER_INSPECTION: null,
@@ -85,6 +84,11 @@ export function getNextInventoryAction(item: WarehouseInventoryItem): InventoryA
       // Import goods skip storage; they need inspection before pickup.
       if (isImport) return inspected ? 'ready-for-pickup' : null;
       return 'store';
+    case 'STORED':
+      // Reserve is retired: a stored export item goes straight to loading prep
+      // once inspection passes. Import STORED is handled via the import queue.
+      if (isImport) return null;
+      return inspected ? 'ready-for-loading' : null;
     case 'RESERVED':
       // Export loading is gated on a passed inspection.
       return inspected ? 'ready-for-loading' : null;
@@ -589,12 +593,21 @@ export interface ImportUnloadedItem {
   customerTruckType: string | null;
   customerTruckContainerNumber: string | null;
   customerTruckAssignedAt: string | null;
+  hasAssignedTruck: boolean;
   currentStatus: string;
   releaseDate: string | null;
   releaseOrderReference: string | null;
   handoverDocumentReference: string | null;
   handoverDocumentDate: string | null;
   deliveredAt: string | null;
+  notes: string | null;
+}
+
+/** Optional explicit storage location; blank → backend auto-allocates. */
+export interface StoreInventoryPayload {
+  warehouseId?: string;
+  yardId?: string;
+  zoneId?: string;
 }
 
 export interface ImportTrainItem {
diff --git a/apps/edr-freight-web/backoffice/src/utils/result.ts b/apps/edr-freight-web/backoffice/src/utils/result.ts
index 3e9627445..54104442c 100644
--- a/apps/edr-freight-web/backoffice/src/utils/result.ts
+++ b/apps/edr-freight-web/backoffice/src/utils/result.ts
@@ -8,6 +8,32 @@ export type ApiError = {
   statusCode?: number;
 };
 
+/**
+ * Backend errors arrive as snake_case i18n-style codes (e.g.
+ * "unable_to_log_in"). Map the known ones to friendly copy and prettify
+ * anything else so raw codes never reach the UI. `code` stays raw for
+ * programmatic checks.
+ */
+const API_ERROR_MESSAGES: Record<string, string> = {
+  unable_to_log_in: "Incorrect email or password.",
+  invalid_refresh_token: "Your session has expired. Please sign in again.",
+  session_expired: "Your session has expired. Please sign in again.",
+  session_not_found: "Your session has expired. Please sign in again.",
+  user_not_found: "No account found for these credentials.",
+};
+
+const SNAKE_CASE_CODE = /^[a-z0-9]+(?:_[a-z0-9]+)+$/;
+
+function humanizeApiMessage(raw: string): string {
+  const known = API_ERROR_MESSAGES[raw];
+  if (known) return known;
+  if (SNAKE_CASE_CODE.test(raw)) {
+    const text = raw.replaceAll("_", " ");
+    return `${text.charAt(0).toUpperCase()}${text.slice(1)}.`;
+  }
+  return raw;
+}
+
 export function extractApiError(err: unknown): ApiError {
   if (err && typeof err === "object") {
     const obj = err as Record<string, unknown>;
@@ -16,8 +42,12 @@ export function extractApiError(err: unknown): ApiError {
       const statusCode = response.status as number | undefined;
       const data = response.data as Record<string, unknown> | undefined;
       return {
-        code: (data?.error as string) || (data?.message as string) || "api_error",
-        message: (data?.message as string) || (data?.error as string) || "An unexpected error occurred",
+        code: (data?.message as string) || (data?.error as string) || "api_error",
+        message: humanizeApiMessage(
+          (data?.message as string) ||
+            (data?.error as string) ||
+            "An unexpected error occurred",
+        ),
         statusCode,
       };
     }
diff --git a/apps/edr-freight-web/portal/src/App.tsx b/apps/edr-freight-web/portal/src/App.tsx
index 7567c485d..697c2f89c 100644
--- a/apps/edr-freight-web/portal/src/App.tsx
+++ b/apps/edr-freight-web/portal/src/App.tsx
@@ -24,6 +24,10 @@ import OnboardingResumeBanner, {
 } from "./components/onboarding/OnboardingResumeBanner";
 import OnboardingWizardDialog from "./components/onboarding/OnboardingWizardDialog";
 import useAuth from "./hooks/useAuth";
+import {
+  startTokenRefreshScheduler,
+  stopTokenRefreshScheduler,
+} from "./utils/refreshScheduler";
 import EDRFreightLandingPage from "./pages/EDRFreightLandingPage";
 import MyPortalPage from "./pages/MyPortalPage";
 import MySignaturePage from "./pages/MySignaturePage";
@@ -212,7 +216,20 @@ const sidebarItems: SidebarItem[] = [
 const App = () => {
   const navigate = useNavigate();
   const location = useLocation();
-  const { user, company, companyType, createProfileAndSwitch } = useAuth();
+  const { user, company, companyType, createProfileAndSwitch, isAuthenticated } =
+    useAuth();
+
+  // Keep the server session alive while a user is logged in. Runs after
+  // login, signup, and page-reload bootstrap alike.
+  useEffect(() => {
+    if (!isAuthenticated) {
+      stopTokenRefreshScheduler();
+      return;
+    }
+
+    startTokenRefreshScheduler();
+    return stopTokenRefreshScheduler;
+  }, [isAuthenticated]);
 
   const displayName = user?.name?.en || user?.username || user?.email || "User";
   const userEmail = user?.email;
diff --git a/apps/edr-freight-web/portal/src/components/onboarding/OnboardingResumeBanner.tsx b/apps/edr-freight-web/portal/src/components/onboarding/OnboardingResumeBanner.tsx
index d0024c6f6..21d4d0746 100644
--- a/apps/edr-freight-web/portal/src/components/onboarding/OnboardingResumeBanner.tsx
+++ b/apps/edr-freight-web/portal/src/components/onboarding/OnboardingResumeBanner.tsx
@@ -1,5 +1,6 @@
 import { useQuery } from "@tanstack/react-query";
-import { ArrowRight, Clock } from "lucide-react";
+import { Link } from "react-router-dom";
+import { AlertTriangle, ArrowRight, Clock } from "lucide-react";
 import { api } from "@/services/api";
 import useAuth from "@/hooks/useAuth";
 import type { OnboardingRequirements } from "@/services/companies.service";
@@ -148,16 +149,74 @@ export default function OnboardingResumeBanner({
 }
 
 /**
- * Shown once onboarding is submitted but the company's operational profiles are
- * still being reviewed. Communicates that approval is per-profile and that
- * bookings unlock as each profile is cleared. Self-hides when nothing is pending.
+ * Post-onboarding review banner. Surfaces (in priority order):
+ *  1. A pending profile-edit review — the whole account is locked until an admin
+ *     approves the submitted changes.
+ *  2. A rejected profile-edit review — links to Settings to amend & resubmit.
+ *  3. Per-operational-profile approval — bookings unlock as each role clears.
+ * Self-hides when there's nothing outstanding.
  */
 export function AccountReviewBanner() {
-  const { company } = useAuth();
+  const { company, reviewStatus, reviewNote } = useAuth();
   const profiles = company?.company?.companyProfiles ?? [];
   const pending = profiles.filter((p) => p.status === "pending");
   const approved = profiles.filter((p) => p.status === "active");
 
+  // 1. Profile-edit review pending — the account-wide lock.
+  if (reviewStatus === "pending") {
+    return (
+      <div className="border-b border-amber-200 bg-amber-50 px-6 py-3">
+        <div className="mx-auto flex max-w-6xl items-center gap-3">
+          <span className="flex h-9 w-9 shrink-0 items-center justify-center rounded-full bg-amber-100 text-amber-700">
+            <Clock size={18} />
+          </span>
+          <span className="flex flex-col gap-0.5">
+            <span className="text-sm font-semibold text-amber-900">
+              Your profile changes are under review
+            </span>
+            <span className="text-xs text-amber-800">
+              Editing and creating new contracts or bookings is paused until an
+              administrator approves your submitted changes.
+            </span>
+          </span>
+        </div>
+      </div>
+    );
+  }
+
+  // 2. Profile-edit review rejected — prompt to fix & resubmit.
+  if (reviewStatus === "rejected") {
+    return (
+      <div className="border-b border-red-200 bg-red-50 px-6 py-3">
+        <div className="mx-auto flex max-w-6xl flex-wrap items-center justify-between gap-3">
+          <div className="flex items-center gap-3">
+            <span className="flex h-9 w-9 shrink-0 items-center justify-center rounded-full bg-red-100 text-red-700">
+              <AlertTriangle size={18} />
+            </span>
+            <span className="flex flex-col gap-0.5">
+              <span className="text-sm font-semibold text-red-900">
+                Your recent changes were not approved
+              </span>
+              <span className="text-xs text-red-800">
+                {reviewNote
+                  ? `Reviewer note: ${reviewNote}`
+                  : "Please update your details and resubmit for review."}
+              </span>
+            </span>
+          </div>
+          <Link
+            to="/settings"
+            className="inline-flex items-center gap-2 rounded-lg bg-red-600 px-4 py-2 text-sm font-semibold text-white shadow-sm transition-transform hover:scale-[1.02]"
+          >
+            Review &amp; resubmit
+            <ArrowRight size={16} />
+          </Link>
+        </div>
+      </div>
+    );
+  }
+
+  // 3. Per-operational-profile approval (existing behaviour).
   if (profiles.length === 0 || pending.length === 0) return null;
 
   const pendingLabel = pending
diff --git a/apps/edr-freight-web/portal/src/components/onboarding/RoleLicenseStep.tsx b/apps/edr-freight-web/portal/src/components/onboarding/RoleLicenseStep.tsx
index fa1061622..28829c193 100644
--- a/apps/edr-freight-web/portal/src/components/onboarding/RoleLicenseStep.tsx
+++ b/apps/edr-freight-web/portal/src/components/onboarding/RoleLicenseStep.tsx
@@ -4,6 +4,7 @@ import { Paperclip } from "lucide-react";
 import { SmartFileInput } from "@edr/ui-common";
 import type { IFileUploadSetting } from "@edr/types/freight";
 
+import { fileViewUrl } from "@/constants/apiConfig";
 import type { LicenseFile } from "@/services/companies.service";
 
 const ROLE_LABELS: Record<string, string> = {
@@ -107,10 +108,10 @@ export default function RoleLicenseStep({
             {hasExisting && (
               <Stack gap={4} mb="sm">
                 {profile.existingFiles.map((f) => (
-                  <Group key={f.url} gap={6} wrap="nowrap">
+                  <Group key={f.id} gap={6} wrap="nowrap">
                     <Paperclip size={13} className="text-edr-muted" />
                     <Anchor
-                      href={f.url}
+                      href={fileViewUrl(f.id)}
                       target="_blank"
                       rel="noopener noreferrer"
                       size="xs"
diff --git a/apps/edr-freight-web/portal/src/constants/URLS.ts b/apps/edr-freight-web/portal/src/constants/URLS.ts
index ac00e71a0..89a3d57e7 100644
--- a/apps/edr-freight-web/portal/src/constants/URLS.ts
+++ b/apps/edr-freight-web/portal/src/constants/URLS.ts
@@ -96,6 +96,13 @@ export const URL_CONSTANTS = {
     DOCUMENTS: (id: string) => `/api/companies/${id}/documents`,
     PROFILE_LICENSE: (profileId: string) =>
       `/api/companies/company-profiles/${profileId}/license`,
+    PROFILE_LICENSE_FILE: (profileId: string, fileId: string) =>
+      `/api/companies/company-profiles/${profileId}/license/${fileId}`,
+    PROFILE_LICENSE_REPLACE: (profileId: string, fileId: string) =>
+      `/api/companies/company-profiles/${profileId}/license/${fileId}/replace`,
+    PROFILE_CHANGE_REQUEST: "/api/companies/profile/change-request",
+    PROFILE_REAPPLY: (profileId: string) =>
+      `/api/companies/company-profiles/${profileId}/reapply`,
   },
 
   BOOKINGS: {
diff --git a/apps/edr-freight-web/portal/src/hooks/useAuth.ts b/apps/edr-freight-web/portal/src/hooks/useAuth.ts
index 9d17b1fed..0f6e98377 100644
--- a/apps/edr-freight-web/portal/src/hooks/useAuth.ts
+++ b/apps/edr-freight-web/portal/src/hooks/useAuth.ts
@@ -44,7 +44,21 @@ const useAuth = () => {
     api.companies.getInfo.queryOptions({
       enabled: !!authQuery.data?.id,
       retry: false,
-      staleTime: 10 * 60 * 1000,
+
+      staleTime(query) {
+        // Fast-poll while anything is awaiting a backoffice decision: an
+        // unapproved role, or a pending profile-edit review. This surfaces
+        // approvals/rejections to the portal within a minute.
+        if (
+          query.state.data?.review?.status === "pending" ||
+          query.state.data?.company?.companyProfiles?.find(
+            (p) => p.status !== "active",
+          )
+        )
+          return 60;
+
+        return 10 * 60 * 1000;
+      },
       refetchOnWindowFocus: false,
     }),
   );
@@ -166,6 +180,14 @@ const useAuth = () => {
   const activeProfileStatus = activeProfile?.status ?? null;
   const canBook = activeProfileStatus === "active";
 
+  // Profile-edit review: while a change request is pending the customer is
+  // locked out of editing and of creating new contracts/bookings; a rejected
+  // request surfaces the reviewer note so they can amend and resubmit.
+  const review = companyInfo?.review ?? null;
+  const reviewStatus = review?.status ?? null;
+  const reviewNote = review?.note ?? null;
+  const isUnderReview = reviewStatus === "pending";
+
   /** Refetch everything scoped to the active operational profile. */
   const invalidateScopedData = async () => {
     await Promise.all([
@@ -179,9 +201,7 @@ const useAuth = () => {
     ]);
   };
 
-  const switchMode = async (
-    type: ProfileTypeValue,
-  ): Promise<Result<void>> => {
+  const switchMode = async (type: ProfileTypeValue): Promise<Result<void>> => {
     try {
       await api.companies.setActiveMode.call({ type });
       await invalidateScopedData();
@@ -207,6 +227,19 @@ const useAuth = () => {
     }
   };
 
+  /** Resubmit a rejected operational role for approval, then refresh. */
+  const reapplyProfile = async (
+    profileId: string,
+  ): Promise<Result<void>> => {
+    try {
+      await api.companies.reapplyProfile.call({ profileId });
+      await invalidateScopedData();
+      return { success: true, data: undefined };
+    } catch (err) {
+      return { success: false, error: extractApiError(err) };
+    }
+  };
+
   const logout = async () => {
     try {
       await api.auth.logout.call();
@@ -239,10 +272,14 @@ const useAuth = () => {
     companyType,
     companyStatus,
     isCompanyApproved,
+    reviewStatus,
+    reviewNote,
+    isUnderReview,
     onboardingCompleted,
     onboardingStep,
     switchMode,
     createProfileAndSwitch,
+    reapplyProfile,
     login,
     signup,
     setPassword,
diff --git a/apps/edr-freight-web/portal/src/pages/SettingsPage.tsx b/apps/edr-freight-web/portal/src/pages/SettingsPage.tsx
index 8c3204123..2a8443812 100644
--- a/apps/edr-freight-web/portal/src/pages/SettingsPage.tsx
+++ b/apps/edr-freight-web/portal/src/pages/SettingsPage.tsx
@@ -1,11 +1,13 @@
 import { api } from "@/services/api";
 import type { ProfileResponse } from "@/types/profile";
 import {
+  Alert,
   Badge,
   Box,
   Card,
   Center,
   Container,
+  Fieldset,
   Group,
   Loader,
   Stack,
@@ -17,9 +19,11 @@ import {
 import { useQuery, useQueryClient } from "@tanstack/react-query";
 import {
   AlertCircle,
+  AlertTriangle,
   BadgeCheck,
   Briefcase,
   Building2,
+  Clock,
   FileCheck,
   Globe,
   ShieldCheck,
@@ -225,6 +229,9 @@ export default function SettingsPage() {
     );
   }
 
+  const reviewStatus = profile.reviewStatus ?? null;
+  const locked = reviewStatus === "pending";
+
   return (
     <Container size="xl" px="lg" py="xl">
       <Stack gap="xl">
@@ -239,6 +246,39 @@ export default function SettingsPage() {
           </Text>
         </div>
 
+        {reviewStatus === "pending" && (
+          <Alert
+            color="yellow"
+            variant="light"
+            icon={<Clock size={18} />}
+            title="Changes submitted for review"
+          >
+            Your recent changes are awaiting administrator approval. Editing is
+            disabled until the review is complete — you'll be notified once it's
+            approved or if any changes are requested.
+          </Alert>
+        )}
+        {reviewStatus === "rejected" && (
+          <Alert
+            color="red"
+            variant="light"
+            icon={<AlertTriangle size={18} />}
+            title="Changes were not approved"
+          >
+            <Stack gap={4}>
+              {profile.reviewNote && (
+                <Text size="sm">
+                  <strong>Reviewer note:</strong> {profile.reviewNote}
+                </Text>
+              )}
+              <Text size="sm">
+                Please update the details below and save again to resubmit for
+                review.
+              </Text>
+            </Stack>
+          </Alert>
+        )}
+
         <Tabs
           value={tab}
           onChange={(value) => value && setTab(value as SettingsTab)}
@@ -269,20 +309,33 @@ export default function SettingsPage() {
             ))}
           </Tabs.List>
 
+          {/* While a change request is pending, every panel's inputs + submit
+              buttons are disabled via the native fieldset; tab switching stays
+              enabled so the customer can still review what they submitted. */}
           <Tabs.Panel value="company">
-            <TabCompanyProfile mode="edit" profile={profile} />
+            <Fieldset disabled={locked} variant="unstyled" p={0}>
+              <TabCompanyProfile mode="edit" profile={profile} />
+            </Fieldset>
           </Tabs.Panel>
           <Tabs.Panel value="contact">
-            <TabContactPerson profile={profile} mode="edit" />
+            <Fieldset disabled={locked} variant="unstyled" p={0}>
+              <TabContactPerson profile={profile} mode="edit" />
+            </Fieldset>
           </Tabs.Panel>
           <Tabs.Panel value="gm">
-            <TabGeneralManager profile={profile} mode="edit" />
+            <Fieldset disabled={locked} variant="unstyled" p={0}>
+              <TabGeneralManager profile={profile} mode="edit" />
+            </Fieldset>
           </Tabs.Panel>
           <Tabs.Panel value="poa">
-            <TabPowerOfAttorney profile={profile} mode="edit" />
+            <Fieldset disabled={locked} variant="unstyled" p={0}>
+              <TabPowerOfAttorney profile={profile} mode="edit" />
+            </Fieldset>
           </Tabs.Panel>
           <Tabs.Panel value="documents">
-            <TabDocuments profile={profile} mode="edit" />
+            <Fieldset disabled={locked} variant="unstyled" p={0}>
+              <TabDocuments profile={profile} mode="edit" />
+            </Fieldset>
           </Tabs.Panel>
         </Tabs>
       </Stack>
diff --git a/apps/edr-freight-web/portal/src/pages/accounts/SignupPage.tsx b/apps/edr-freight-web/portal/src/pages/accounts/SignupPage.tsx
index 1b13f7cfc..5746eefd5 100644
--- a/apps/edr-freight-web/portal/src/pages/accounts/SignupPage.tsx
+++ b/apps/edr-freight-web/portal/src/pages/accounts/SignupPage.tsx
@@ -242,270 +242,259 @@ export default function SignupPage() {
 
   return (
     <AuthShell
-      tagline= "Smart Freight Operations"
-  taglineBody = "Join EDR Freight to manage shipments, track consignments, and streamline logistics workflows across Ethiopia and Djibouti."
+      tagline="Smart Freight Operations"
+      taglineBody="Join EDR Freight to manage shipments, track consignments, and streamline logistics workflows across Ethiopia and Djibouti."
     >
-    <div className="flex w-full flex-col" >
-      { stage === "form" ? (
-        <form
-            onSubmit= { handleSubmit(requestOtp) }
-            className = "flex w-full flex-col"
-    >
-    <div className="mb-4 space-y-1.5 text-center sm:mb-5" >
-      <h1 className="text-xl font-bold tracking-tight text-gray-900 sm:text-2xl" >
-        Create account
-          </h1>
-          < p className = "text-sm leading-relaxed text-gray-500" >
-            Register to access EDR Freight services.
+      <div className="flex w-full flex-col">
+        {stage === "form" ? (
+          <form
+            onSubmit={handleSubmit(requestOtp)}
+            className="flex w-full flex-col"
+          >
+            <div className="mb-4 space-y-1.5 text-center sm:mb-5">
+              <h1 className="text-xl font-bold tracking-tight text-gray-900 sm:text-2xl">
+                Create account
+              </h1>
+              <p className="text-sm leading-relaxed text-gray-500">
+                Register to access EDR Freight services.
               </p>
-              </div>
+            </div>
 
-              < Stack gap = "sm" >
-                <SimpleGrid cols={ { base: 1, sm: 2 } } spacing = "md" >
-                  <TextInput
+            <Stack gap="sm">
+              <SimpleGrid cols={{ base: 1, sm: 2 }} spacing="md">
+                <TextInput
                   label="First name"
-  placeholder = "John"
-  required
-  disabled = { sending }
-  error = { errors.firstName?.en?.message }
-  {...register("firstName.en") }
+                  placeholder="John"
+                  required
+                  disabled={sending}
+                  error={errors.firstName?.en?.message}
+                  {...register("firstName.en")}
                 />
-    < TextInput
-  label = "Last name"
-  placeholder = "Doe"
-  required
-  disabled = { sending }
-  error = { errors.lastName?.en?.message }
-  {...register("lastName.en") }
+                <TextInput
+                  label="Last name"
+                  placeholder="Doe"
+                  required
+                  disabled={sending}
+                  error={errors.lastName?.en?.message}
+                  {...register("lastName.en")}
                 />
-    </SimpleGrid>
+              </SimpleGrid>
 
-    < TextInput
-  label = "Email"
-  type = "email"
-  placeholder = "john@example.com"
-  required
-  disabled = { sending }
-  error = { errors.email?.message }
-  {...register("email") }
+              <TextInput
+                label="Email"
+                type="email"
+                placeholder="john@example.com"
+                required
+                disabled={sending}
+                error={errors.email?.message}
+                {...register("email")}
               />
 
-    < ControlledPhoneField
-  control = { control }
-  name = "phone"
-  label = "Phone"
-  required
-  disabled = { sending }
-    />
+              <ControlledPhoneField
+                control={control}
+                name="phone"
+                label="Phone"
+                required
+                disabled={sending}
+              />
 
-    <div className="space-y-1.5" >
-      <Text size="sm" fw = { 500} c = "edr-text" >
-        Send verification code via
-          </Text>
-          < SegmentedControl
-  fullWidth
-  disabled = { sending }
-  value = { channel }
-  onChange = {(v) => setChannel(v as OtpChannel)
-}
-data = {
-  [
-  {
-    value: "phone",
-    label: (
-      <span className= "flex items-center justify-center gap-1.5" >
-      <Smartphone size={ 14} /> Phone
-  </span>
+              <div className="space-y-1.5">
+                <Text size="sm" fw={500} c="edr-text">
+                  Send verification code via
+                </Text>
+                <SegmentedControl
+                  fullWidth
+                  disabled={sending}
+                  value={channel}
+                  onChange={(v) => setChannel(v as OtpChannel)}
+                  data={[
+                    {
+                      value: "phone",
+                      label: (
+                        <span className="flex items-center justify-center gap-1.5">
+                          <Smartphone size={14} /> Phone
+                        </span>
                       ),
-},
-{
-  value: "email",
-  label: (
-    <span className= "flex items-center justify-center gap-1.5" >
-    <Mail size={ 14 } /> Email
-      </span>
+                    },
+                    {
+                      value: "email",
+                      label: (
+                        <span className="flex items-center justify-center gap-1.5">
+                          <Mail size={14} /> Email
+                        </span>
                       ),
                     },
                   ]}
                 />
-  </div>
+              </div>
 
-  < div >
-  <PasswordInput
+              <div>
+                <PasswordInput
                   label="Password"
-placeholder = "Create a strong password"
-required
-disabled = { sending }
-error = { errors.password?.message }
-{...register("password") }
+                  placeholder="Create a strong password"
+                  required
+                  disabled={sending}
+                  error={errors.password?.message}
+                  {...register("password")}
                 />
-{
-  passwordValue.length > 0 ? (
-    <div className= "mt-2 space-y-1" >
-    {
-      passwordRequirements.map((req) => {
-        const met = req.test(passwordValue);
-        return (
-          <div
-                          key= { req.label }
-        className = "flex items-center gap-2"
-          >
-          <span
-                            className={
-          `flex h-4 w-4 shrink-0 items-center justify-center rounded-full ${met
-            ? "bg-primary text-primary-foreground"
-            : "bg-gray-200 text-gray-500"
-          }`
-        }
+                {passwordValue.length > 0 ? (
+                  <div className="mt-2 space-y-1">
+                    {passwordRequirements.map((req) => {
+                      const met = req.test(passwordValue);
+                      return (
+                        <div
+                          key={req.label}
+                          className="flex items-center gap-2"
+                        >
+                          <span
+                            className={`flex h-4 w-4 shrink-0 items-center justify-center rounded-full ${met
+                                ? "bg-primary text-primary-foreground"
+                                : "bg-gray-200 text-gray-500"
+                              }`}
                           >
-          {
-            met?(
-                              <Check className = "h-2.5 w-2.5" />
-                            ): (
-                <X className = "h-2.5 w-2.5" />
-                            )
-    }
-    </span>
-    < span
-                            className = {`text-xs ${met ? "text-primary" : "text-gray-500"}`
-}
+                            {met ? (
+                              <Check className="h-2.5 w-2.5" />
+                            ) : (
+                              <X className="h-2.5 w-2.5" />
+                            )}
+                          </span>
+                          <span
+                            className={`text-xs ${met ? "text-primary" : "text-gray-500"}`}
                           >
-  { req.label }
-  </span>
-  </div>
+                            {req.label}
+                          </span>
+                        </div>
                       );
                     })}
-</div>
+                  </div>
                 ) : null}
-</div>
+              </div>
 
-  < PasswordInput
-label = "Confirm password"
-placeholder = "Re-enter your password"
-required
-disabled = { sending }
-error = { errors.confirmPassword?.message }
-{...register("confirmPassword") }
+              <PasswordInput
+                label="Confirm password"
+                placeholder="Re-enter your password"
+                required
+                disabled={sending}
+                error={errors.confirmPassword?.message}
+                {...register("confirmPassword")}
               />
 
-{
-  error ? (
-    <Alert
-                  color= "red"
-                  variant = "light"
-  icon = {< AlertCircle size = { 18} />}
+              {error ? (
+                <Alert
+                  color="red"
+                  variant="light"
+                  icon={<AlertCircle size={18} />}
                 >
-  { error }
-  </Alert>
+                  {error}
+                </Alert>
               ) : null}
 
-<Button
+              <Button
                 type="submit"
-color = "edr-green"
-fullWidth
-loading = { sending }
-rightSection = {!sending ? <ArrowRight size={ 16 } /> : undefined}
+                color="edr-green"
+                fullWidth
+                loading={sending}
+                rightSection={!sending ? <ArrowRight size={16} /> : undefined}
               >
-  Continue
-  </Button>
+                Continue
+              </Button>
 
-  < p className = "text-center text-sm text-gray-500" >
-    Already have an account ? { " "}
-      < button
-                  type = "button"
-onClick = {() => navigate("/login")}
-className = "font-semibold text-primary hover:underline"
-  >
-  Sign In
-    </button>
-    </p>
-    </Stack>
-    </form>
-        ) : (
-  <Stack gap= "md" >
-  <div className="mb-1 flex justify-center" >
-    <span className="flex h-12 w-12 items-center justify-center rounded-full bg-primary/10 text-primary" >
-      <ShieldCheck size={ 22 } />
-        </span>
-        </div>
-        < div className = "space-y-1.5 text-center" >
-          <h1 className="text-xl font-bold tracking-tight text-gray-900 sm:text-2xl" >
-            Verify your { otpChannel === "email" ? "email" : "phone" }
-</h1>
-  < p className = "text-sm leading-relaxed text-gray-500" >
-    We sent a 6 - digit code to{ " " }
-<span className="font-medium text-gray-700" >
-  { otpChannel === "email"
-  ? maskEmail(pendingData?.email ?? "")
-  : maskPhone(pendingData?.phone ?? "")}
-</span>
-  .Enter it to finish creating your account.
+              <p className="text-center text-sm text-gray-500">
+                Already have an account ?{" "}
+                <button
+                  type="button"
+                  onClick={() => navigate("/login")}
+                  className="font-semibold text-primary hover:underline"
+                >
+                  Sign In
+                </button>
               </p>
-    </div>
+            </Stack>
+          </form>
+        ) : (
+          <Stack gap="md">
+            <div className="mb-1 flex justify-center">
+              <span className="flex h-12 w-12 items-center justify-center rounded-full bg-primary/10 text-primary">
+                <ShieldCheck size={22} />
+              </span>
+            </div>
+            <div className="space-y-1.5 text-center">
+              <h1 className="text-xl font-bold tracking-tight text-gray-900 sm:text-2xl">
+                Verify your {otpChannel === "email" ? "email" : "phone"}
+              </h1>
+              <p className="text-sm leading-relaxed text-gray-500">
+                We sent a 6 - digit code to{" "}
+                <span className="font-medium text-gray-700">
+                  {otpChannel === "email"
+                    ? maskEmail(pendingData?.email ?? "")
+                    : maskPhone(pendingData?.phone ?? "")}
+                </span>
+                .Enter it to finish creating your account.
+              </p>
+            </div>
 
-{
-  otpError ? (
-    <Alert
-                color= "red"
-                variant = "light"
-  icon = {< AlertCircle size = { 18} />}
+            {otpError ? (
+              <Alert
+                color="red"
+                variant="light"
+                icon={<AlertCircle size={18} />}
               >
-  { otpError }
-  </Alert>
+                {otpError}
+              </Alert>
             ) : null}
 
-<Stack gap={ 6 } align = "center" >
-  <Text size="sm" fw = { 500} c = "edr-text" >
-    Verification code
-      </Text>
-      < PinInput
-length = { 6}
-type = "number"
-oneTimeCode
-value = { otpCode }
-placeholder = "0"
-disabled = { verifying }
-styles = {{ input: { textAlign: "center" } }}
-onChange = { setOtpCode }
-  />
-  </Stack>
+            <Stack gap={6} align="center">
+              <Text size="sm" fw={500} c="edr-text">
+                Verification code
+              </Text>
+              <PinInput
+                length={6}
+                type="number"
+                oneTimeCode
+                value={otpCode}
+                placeholder="0"
+                disabled={verifying}
+                styles={{ input: { textAlign: "center" } }}
+                onChange={setOtpCode}
+              />
+            </Stack>
 
-  < Button
-color = "edr-green"
-fullWidth
-loading = { verifying }
-disabled = { verifying || otpCode.trim().length !== 6}
-onClick = { confirmOtp }
-  >
-  Verify & amp; create account
-    </Button>
+            <Button
+              color="edr-green"
+              fullWidth
+              loading={verifying}
+              disabled={verifying || otpCode.trim().length !== 6}
+              onClick={confirmOtp}
+            >
+              Verify & create account
+            </Button>
 
-    < div className = "flex items-center justify-between" >
-      <Button
+            <div className="flex items-center justify-between">
+              <Button
                 variant="subtle"
-color = "gray"
-leftSection = {< ArrowLeft size = { 14} />}
-disabled = { sending || verifying}
-onClick = {() => {
-  setStage("form");
-  setOtpError(null);
-}}
+                color="gray"
+                leftSection={<ArrowLeft size={14} />}
+                disabled={sending || verifying}
+                onClick={() => {
+                  setStage("form");
+                  setOtpError(null);
+                }}
               >
-  Back
-  </Button>
-  < Button
-variant = "subtle"
-color = "edr-green"
-leftSection = {< RotateCw size = { 14} />}
-disabled = { resendIn > 0 || sending || verifying}
-onClick = { resendOtp }
-  >
-  { resendIn > 0 ? `Resend in ${resendIn}s` : "Resend code"}
-</Button>
-  </div>
-  </Stack>
+                Back
+              </Button>
+              <Button
+                variant="subtle"
+                color="edr-green"
+                leftSection={<RotateCw size={14} />}
+                disabled={resendIn > 0 || sending || verifying}
+                onClick={resendOtp}
+              >
+                {resendIn > 0 ? `Resend in ${resendIn}s` : "Resend code"}
+              </Button>
+            </div>
+          </Stack>
         )}
-</div>
-  </AuthShell>
+      </div>
+    </AuthShell>
   );
 }
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 40994d589..7384bbc4d 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
@@ -18,6 +18,7 @@ import { ContainersCard } from "./components/ContainersCard";
 import { ContractCard } from "./components/ContractCard";
 import { CustomerTruckAssignmentCard } from "./components/CustomerTruckAssignmentCard";
 import { KeyFactsStrip } from "./components/KeyFactsStrip";
+import { MileSummaryCard } from "./components/MileSummaryCard";
 import { BodyGrid, PageShell } from "./components/layout";
 import {
   CancelledBanner,
@@ -108,6 +109,7 @@ export function ReadonlyBookingView({
       : status === "SELECTED_FOR_BATCH");
   const canApproveDelivery =
     status === "COMPLETED" ||
+    Boolean(booking.handoverAwaitingSignature) ||
     (status === "TRUCK_ASSIGNED" && Boolean(booking.customerTruckArrivedAt));
   const usesCustomerTruck =
     booking.tradeDirection === "IMPORT"
@@ -219,6 +221,8 @@ export function ReadonlyBookingView({
             <WarehousePaymentsSection bookingId={booking.id} />
 
             <ActivityCard booking={booking} />
+
+            <MileSummaryCard booking={booking} />
           </>
         }
         right={
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 65af584d3..a8cee69eb 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
@@ -15,7 +15,7 @@ import {
 } from "@mantine/core";
 import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
 import type { Freight } from "@edr/types";
-import { CheckCircle2, Clock, Download, Plus, Trash2, Truck } from "lucide-react";
+import { CheckCircle2, Clock, Download, Pencil, Plus, Trash2, Truck } from "lucide-react";
 import { useState } from "react";
 import toast from "react-hot-toast";
 
@@ -63,44 +63,59 @@ export function CustomerTruckAssignmentCard({
   const [driverName, setDriverName] = useState("");
   const [truckType, setTruckType] = useState("");
   const [containers, setContainers] = useState<string[]>([]);
+  const [editingId, setEditingId] = useState<string | null>(null);
   const [error, setError] = useState<string | null>(null);
 
   // Container numbers on the booking that aren't already loaded onto a truck.
   const assignedNumbers = new Set(
     trucks.flatMap((t) => (t.containers ?? []).map((c) => c.containerNumber)),
   );
+  // When editing a truck, its own containers stay selectable.
+  const editingOwn = new Set(
+    (trucks.find((t) => t.id === editingId)?.containers ?? []).map((c) => c.containerNumber),
+  );
   const availableContainers = (booking.containerNumbers ?? []).filter(
-    (n) => !assignedNumbers.has(n),
+    (n) => !assignedNumbers.has(n) || editingOwn.has(n),
   );
 
-  // EXPORT trucks deliver known containers (pre-selected). IMPORT trucks don't —
-  // staff register + weigh what was loaded when the truck leaves.
-  const isExport = booking.tradeDirection === "EXPORT";
-
+  // Both import and export specify the containers each truck carries.
   const resetForm = () => {
     setPlateNumber("");
     setDriverName("");
     setTruckType("");
     setContainers([]);
+    setEditingId(null);
+    setError(null);
+  };
+
+  const startEdit = (t: Freight.ICustomerTruck) => {
+    setPlateNumber(t.plateNumber ?? "");
+    setDriverName(t.driverName ?? "");
+    setTruckType(t.truckType ?? "");
+    setContainers((t.containers ?? []).map((c) => c.containerNumber));
+    setEditingId(t.id);
     setError(null);
   };
 
   const addMutation = useMutation({
-    mutationFn: () =>
-      customerTrucksService.add(booking.id, {
+    mutationFn: () => {
+      const payload = {
         truckPlateNumber: plateNumber.trim().toUpperCase(),
         driverName: driverName.trim(),
         truckType: truckType.trim(),
-        // Import: containers are registered + weighed on departure, not here.
-        containerNumbers: isExport ? containers : [],
-      }),
+        containerNumbers: containers,
+      };
+      return editingId
+        ? customerTrucksService.update(booking.id, editingId, payload)
+        : customerTrucksService.add(booking.id, payload);
+    },
     onSuccess: (list) => {
       queryClient.setQueryData(trucksKey, list);
+      toast.success(editingId ? "Truck updated" : "Truck added");
       resetForm();
       onAssigned();
-      toast.success("Truck added");
     },
-    onError: (e) => setError(errorMessage(e, "Could not add truck")),
+    onError: (e) => setError(errorMessage(e, editingId ? "Could not update truck" : "Could not add truck")),
   });
 
   const removeMutation = useMutation({
@@ -123,7 +138,7 @@ export function CustomerTruckAssignmentCard({
       setError("Plate number, driver name and truck type are required.");
       return;
     }
-    if (isExport && (containers.length < 1 || containers.length > 2)) {
+    if (containers.length < 1 || containers.length > 2) {
       setError("Select 1 or 2 container numbers for this truck.");
       return;
     }
@@ -187,15 +202,25 @@ export function CustomerTruckAssignmentCard({
                 </Group>
               </Stack>
               {!t.arrivedAt && (
-                <ActionIcon
-                  variant="subtle"
-                  color="red"
-                  aria-label="Remove truck"
-                  onClick={() => removeMutation.mutate(t.id)}
-                  loading={removeMutation.isPending}
-                >
-                  <Trash2 size={16} />
-                </ActionIcon>
+                <Group gap={4} wrap="nowrap">
+                  <ActionIcon
+                    variant="subtle"
+                    color="blue"
+                    aria-label="Edit truck"
+                    onClick={() => startEdit(t)}
+                  >
+                    <Pencil size={16} />
+                  </ActionIcon>
+                  <ActionIcon
+                    variant="subtle"
+                    color="red"
+                    aria-label="Remove truck"
+                    onClick={() => removeMutation.mutate(t.id)}
+                    loading={removeMutation.isPending}
+                  >
+                    <Trash2 size={16} />
+                  </ActionIcon>
+                </Group>
               )}
             </Group>
           ))
@@ -207,10 +232,10 @@ export function CustomerTruckAssignmentCard({
           </Alert>
         )}
 
-        {/* Add-truck form. Export needs unassigned containers; import always allows another truck. */}
-        {(isExport ? availableContainers.length > 0 : true) ? (
+        {/* Add-truck form — both directions assign the containers each truck carries. */}
+        {availableContainers.length > 0 ? (
           <>
-            <Divider label="Add a truck" labelPosition="center" />
+            <Divider label={editingId ? "Edit truck" : "Add a truck"} labelPosition="center" />
             <SimpleGrid cols={{ base: 1, sm: 2 }} spacing="sm">
               <TextInput
                 label="Truck Plate Number"
@@ -231,28 +256,32 @@ export function CustomerTruckAssignmentCard({
                 value={truckType || null}
                 onChange={(value) => setTruckType(value ?? "")}
               />
-              {isExport && (
-                <MultiSelect
-                  label="Containers to load (1–2)"
-                  required
-                  placeholder="Select container numbers"
-                  data={availableContainers}
-                  value={containers}
-                  onChange={setContainers}
-                  maxValues={2}
-                  searchable
-                  nothingFoundMessage="No unassigned containers"
-                />
-              )}
+              <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 && (
+                <Button variant="default" onClick={resetForm} disabled={addMutation.isPending}>
+                  Cancel
+                </Button>
+              )}
               <Button
-                leftSection={<Plus size={16} />}
+                leftSection={editingId ? <Pencil size={16} /> : <Plus size={16} />}
                 color="edr-green"
                 onClick={submitAdd}
                 loading={addMutation.isPending}
               >
-                Add truck
+                {editingId ? "Save changes" : "Add truck"}
               </Button>
             </Group>
           </>
diff --git a/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/components/MileSummaryCard.tsx b/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/components/MileSummaryCard.tsx
new file mode 100644
index 000000000..bfb57529f
--- /dev/null
+++ b/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/components/MileSummaryCard.tsx
@@ -0,0 +1,214 @@
+import { Box, Group, Stack, Text } from "@mantine/core";
+import { useQuery } from "@tanstack/react-query";
+
+import type { Freight } from "@edr/types";
+
+import { bookingsService } from "@/services/bookings.service";
+import type {
+  MileLegSummary,
+  MileVehicleSummary,
+} from "@/services/bookings.service";
+
+import { CardTitle, SectionCard } from "./layout";
+
+function StatusPill({ status }: { status: string }) {
+  const s = status.toUpperCase();
+  const done = s.includes("DELIVER") || s.includes("COMPLET") || s.includes("PAID");
+  const active = s.includes("TRANSIT") || s.includes("PROGRESS") || s.includes("ASSIGN");
+  const dot = done ? "#0EA371" : active ? "#2563EB" : "#94A3B8";
+  const color = done ? "#0A6F4D" : active ? "#1E40AF" : "#475569";
+  const bg = done ? "#ECF6F1" : active ? "#EAF1FE" : "#F1F4F7";
+  const border = done ? "#CDEBDD" : active ? "#CFDDFB" : "#E1E7EE";
+  const label = status
+    .replace(/_/g, " ")
+    .toLowerCase()
+    .replace(/\b\w/g, (m) => m.toUpperCase());
+
+  return (
+    <Group
+      component="span"
+      gap={6}
+      align="center"
+      wrap="nowrap"
+      style={{
+        display: "inline-flex",
+        borderRadius: 999,
+        backgroundColor: bg,
+        border: `1px solid ${border}`,
+        padding: "4px 10px",
+        fontSize: 11.5,
+        fontWeight: 700,
+        color,
+      }}
+    >
+      <Box
+        component="span"
+        style={{ width: 6, height: 6, borderRadius: 999, backgroundColor: dot }}
+      />
+      {label}
+    </Group>
+  );
+}
+
+function VehicleRow({ v }: { v: MileVehicleSummary }) {
+  const parts: string[] = [];
+  if (v.driverName) parts.push(v.driverName);
+  if (v.containerNumber) parts.push(`Container ${v.containerNumber}`);
+  if (v.distanceKm != null) parts.push(`${v.distanceKm} km`);
+
+  return (
+    <Group
+      justify="space-between"
+      align="flex-start"
+      wrap="nowrap"
+      py={8}
+      style={{ borderTop: "1px solid #F2F5F8" }}
+    >
+      <Stack gap={2} style={{ minWidth: 0 }}>
+        <Text fz="13px" fw={700} c="#10202F">
+          {v.plate || v.code || "Vehicle"}
+        </Text>
+        {parts.length > 0 && (
+          <Text fz="12px" c="#6B7C8E">
+            {parts.join("  ·  ")}
+          </Text>
+        )}
+      </Stack>
+      {v.code && v.plate && (
+        <Text fz="12px" c="#9AA8B5" style={{ whiteSpace: "nowrap" }}>
+          {v.code}
+        </Text>
+      )}
+    </Group>
+  );
+}
+
+function LegBlock({
+  title,
+  leg,
+  address,
+}: {
+  title: string;
+  leg: MileLegSummary | null;
+  address?: string | null;
+}) {
+  const fmtMoney = (n: number | null, currency: string) =>
+    n == null
+      ? null
+      : `${currency} ${Number(n).toLocaleString(undefined, {
+          minimumFractionDigits: 2,
+          maximumFractionDigits: 2,
+        })}`;
+
+  return (
+    <Box>
+      <Group justify="space-between" align="center" pb={8}>
+        <Text fz="13px" fw={700} c="#10202F">
+          {title}
+        </Text>
+        {leg ? (
+          <StatusPill status={leg.status} />
+        ) : (
+          <StatusPill status="AWAITING_ASSIGNMENT" />
+        )}
+      </Group>
+
+      {address && (
+        <Text fz="12px" c="#6B7C8E" pb={4}>
+          {title.startsWith("First") ? "Pickup" : "Delivery"}:{" "}
+          <b style={{ color: "#10202F" }}>{address}</b>
+        </Text>
+      )}
+
+      {!leg ? (
+        <Text fz="12px" c="#9AA8B5" fs="italic" py={6}>
+          Requested — a vehicle and driver will be assigned soon.
+        </Text>
+      ) : leg.vehicles.length > 0 ? (
+        <Box>
+          {leg.vehicles.map((v, i) => (
+            <VehicleRow key={`${v.plate ?? v.code ?? "v"}-${i}`} v={v} />
+          ))}
+        </Box>
+      ) : (
+        <Text fz="12px" c="#9AA8B5" fs="italic" py={6}>
+          No vehicle assigned yet.
+        </Text>
+      )}
+
+      {leg && (
+        <Group
+          justify="space-between"
+          align="center"
+          pt={8}
+          mt={4}
+          style={{ borderTop: "1px solid #F2F5F8" }}
+        >
+          <Group gap={16}>
+            {leg.exactKm != null && (
+              <Text fz="12px" c="#6B7C8E">
+                Total distance{" "}
+                <b style={{ color: "#10202F" }}>{leg.exactKm} km</b>
+              </Text>
+            )}
+            {leg.remainingPayment != null && leg.remainingPayment > 0 && (
+              <Text fz="12px" c="#6B7C8E">
+                Balance{" "}
+                <b style={{ color: "#10202F" }}>
+                  {fmtMoney(leg.remainingPayment, leg.currency)}
+                </b>
+              </Text>
+            )}
+          </Group>
+          {leg.invoiced && (
+            <Text fz="11px" fw={700} c="#0A6F4D">
+              Invoiced
+            </Text>
+          )}
+        </Group>
+      )}
+    </Box>
+  );
+}
+
+export function MileSummaryCard({ booking }: { booking: Freight.IBooking }) {
+  const { data } = useQuery({
+    queryKey: ["booking-mile-summary", booking.id],
+    queryFn: () => bookingsService.mileSummary(booking.id),
+  });
+
+  const firstLeg = data?.firstMile ?? null;
+  const lastLeg = data?.lastMile ?? null;
+
+  // The backend doesn't persist an "enabled" flag — the presence of a
+  // pickup/delivery address is the request signal. Also show a leg once its
+  // record exists, regardless of address.
+  const showFirst = !!booking.firstMilePickupAddress || !!firstLeg;
+  const showLast = !!booking.lastMileDeliveryAddress || !!lastLeg;
+
+  if (!showFirst && !showLast) return null;
+
+  return (
+    <SectionCard p={22}>
+      <Box pb={12}>
+        <CardTitle>First & Last Mile</CardTitle>
+      </Box>
+      <Stack gap={20}>
+        {showFirst && (
+          <LegBlock
+            title="First mile"
+            leg={firstLeg}
+            address={booking.firstMilePickupAddress}
+          />
+        )}
+        {showLast && (
+          <LegBlock
+            title="Last mile"
+            leg={lastLeg}
+            address={booking.lastMileDeliveryAddress}
+          />
+        )}
+      </Stack>
+    </SectionCard>
+  );
+}
diff --git a/apps/edr-freight-web/portal/src/pages/bookings/delivery/ApproveDeliveryButton.tsx b/apps/edr-freight-web/portal/src/pages/bookings/delivery/ApproveDeliveryButton.tsx
index e9ee31722..c3a0a8ccd 100644
--- a/apps/edr-freight-web/portal/src/pages/bookings/delivery/ApproveDeliveryButton.tsx
+++ b/apps/edr-freight-web/portal/src/pages/bookings/delivery/ApproveDeliveryButton.tsx
@@ -1,11 +1,8 @@
 import { Button, type ButtonProps } from "@mantine/core";
-import { useMutation, useQueryClient } from "@tanstack/react-query";
 import { CheckCircle2 } from "lucide-react";
-import type { MouseEvent } from "react";
-import toast from "react-hot-toast";
-import { useNavigate } from "react-router-dom";
+import { type MouseEvent, useState } from "react";
 
-import { api } from "@/services/api";
+import { ApproveDeliveryModal } from "./ApproveDeliveryModal";
 
 type ApproveDeliveryButtonProps = ButtonProps & {
   bookingId: string;
@@ -13,25 +10,6 @@ type ApproveDeliveryButtonProps = ButtonProps & {
   onApproved?: () => void;
 };
 
-const errorMessage = (error: unknown) => {
-  const data = (error as { response?: { data?: { message?: string | string[] } } })
-    ?.response?.data;
-  if (Array.isArray(data?.message)) return data.message.join(", ");
-  if (data?.message) return data.message;
-  return error instanceof Error ? error.message : "Could not approve delivery";
-};
-
-const downloadBlob = (blob: Blob, filename: string) => {
-  const url = URL.createObjectURL(blob);
-  const link = document.createElement("a");
-  link.href = url;
-  link.download = filename;
-  document.body.appendChild(link);
-  link.click();
-  link.remove();
-  URL.revokeObjectURL(url);
-};
-
 export function ApproveDeliveryButton({
   bookingId,
   stopPropagation,
@@ -40,56 +18,31 @@ export function ApproveDeliveryButton({
   variant = "filled",
   ...props
 }: ApproveDeliveryButtonProps) {
-  const navigate = useNavigate();
-  const queryClient = useQueryClient();
-
-  const handoverMutation = useMutation(api.bookings.downloadHandoverDocument.mutationOptions());
-
-  const mutation = useMutation({
-    ...api.bookings.approveDelivery.mutationOptions(),
-    onSuccess: async (result) => {
-      try {
-        const blob = await handoverMutation.mutateAsync({ inventoryId: result.inventoryId });
-        downloadBlob(blob, `handover-${bookingId}.pdf`);
-        toast.success("Delivery approved and signed handover downloaded");
-      } catch {
-        toast.success("Delivery approved and handover signed");
-        toast.error("Signed handover document could not be downloaded");
-      }
-      await Promise.all([
-        queryClient.invalidateQueries({ queryKey: api.bookings.get.queryKey({ id: bookingId }) }),
-        queryClient.invalidateQueries({ queryKey: api.bookings.list.queryKey() }),
-        queryClient.invalidateQueries({ queryKey: ["companies", "getDashboard"] }),
-      ]);
-      onApproved?.();
-    },
-    onError: (error) => {
-      const message = errorMessage(error);
-      toast.error(message);
-      if (message.toLowerCase().includes("save your signature")) {
-        navigate("/signature");
-      } else if (/demurrage|storage|warehouse invoice|fully paid/i.test(message)) {
-        navigate("/billing");
-      }
-    },
-  });
+  const [opened, setOpened] = useState(false);
 
   const handleClick = (event: MouseEvent<HTMLButtonElement>) => {
     if (stopPropagation) event.stopPropagation();
-    mutation.mutate({ id: bookingId });
+    setOpened(true);
   };
 
   return (
-    <Button
-      {...props}
-      size={size}
-      variant={variant}
-      color="edr-green"
-      leftSection={<CheckCircle2 size={16} />}
-      loading={mutation.isPending || handoverMutation.isPending}
-      onClick={handleClick}
-    >
-      Approve delivery
-    </Button>
+    <>
+      <Button
+        {...props}
+        size={size}
+        variant={variant}
+        color="edr-green"
+        leftSection={<CheckCircle2 size={16} />}
+        onClick={handleClick}
+      >
+        Approve delivery
+      </Button>
+      <ApproveDeliveryModal
+        bookingId={bookingId}
+        opened={opened}
+        onClose={() => setOpened(false)}
+        onApproved={onApproved}
+      />
+    </>
   );
 }
diff --git a/apps/edr-freight-web/portal/src/pages/bookings/delivery/ApproveDeliveryModal.tsx b/apps/edr-freight-web/portal/src/pages/bookings/delivery/ApproveDeliveryModal.tsx
new file mode 100644
index 000000000..a3723b650
--- /dev/null
+++ b/apps/edr-freight-web/portal/src/pages/bookings/delivery/ApproveDeliveryModal.tsx
@@ -0,0 +1,171 @@
+import { Alert, Button, Group, Loader, Modal, Stack, Text } from "@mantine/core";
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import { CheckCircle2, Info } from "lucide-react";
+import { useEffect, useState } from "react";
+import toast from "react-hot-toast";
+import { useNavigate } from "react-router-dom";
+
+import { api } from "@/services/api";
+import { bookingsService } from "@/services/bookings.service";
+
+type ApproveDeliveryModalProps = {
+  bookingId: string;
+  opened: boolean;
+  onClose: () => void;
+  onApproved?: () => void;
+};
+
+const errorMessage = (error: unknown) => {
+  const data = (error as { response?: { data?: { message?: string | string[] } } })
+    ?.response?.data;
+  if (Array.isArray(data?.message)) return data.message.join(", ");
+  if (data?.message) return data.message;
+  return error instanceof Error ? error.message : "Could not approve delivery";
+};
+
+const downloadBlob = (blob: Blob, filename: string) => {
+  const url = URL.createObjectURL(blob);
+  const link = document.createElement("a");
+  link.href = url;
+  link.download = filename;
+  document.body.appendChild(link);
+  link.click();
+  link.remove();
+  URL.revokeObjectURL(url);
+};
+
+/**
+ * Approve-delivery flow: open the handover document for the customer to review,
+ * then apply their saved signature (approve) and hand back the signed PDF.
+ */
+export function ApproveDeliveryModal({
+  bookingId,
+  opened,
+  onClose,
+  onApproved,
+}: ApproveDeliveryModalProps) {
+  const navigate = useNavigate();
+  const queryClient = useQueryClient();
+  const [pdfUrl, setPdfUrl] = useState<string | null>(null);
+
+  const {
+    data: docBlob,
+    isLoading,
+    isError,
+  } = useQuery({
+    queryKey: ["booking-handover-doc", bookingId],
+    queryFn: () => bookingsService.downloadBookingHandoverDocument(bookingId),
+    enabled: opened && Boolean(bookingId),
+    staleTime: 0,
+  });
+
+  useEffect(() => {
+    if (!docBlob) {
+      setPdfUrl(null);
+      return;
+    }
+    const url = URL.createObjectURL(docBlob);
+    setPdfUrl(url);
+    return () => URL.revokeObjectURL(url);
+  }, [docBlob]);
+
+  const handoverMutation = useMutation(
+    api.bookings.downloadHandoverDocument.mutationOptions(),
+  );
+
+  const approve = useMutation({
+    ...api.bookings.approveDelivery.mutationOptions(),
+    onSuccess: async (result) => {
+      try {
+        const signed = await handoverMutation.mutateAsync({
+          inventoryId: result.inventoryId,
+        });
+        downloadBlob(signed, `handover-${bookingId}.pdf`);
+        toast.success("Delivery approved and signed handover downloaded");
+      } catch {
+        toast.success("Delivery approved and handover signed");
+        toast.error("Signed handover document could not be downloaded");
+      }
+      await Promise.all([
+        queryClient.invalidateQueries({
+          queryKey: api.bookings.get.queryKey({ id: bookingId }),
+        }),
+        queryClient.invalidateQueries({ queryKey: api.bookings.list.queryKey() }),
+        queryClient.invalidateQueries({ queryKey: ["companies", "getDashboard"] }),
+      ]);
+      onApproved?.();
+      onClose();
+    },
+    onError: (error) => {
+      const message = errorMessage(error);
+      toast.error(message);
+      if (message.toLowerCase().includes("save your signature")) {
+        onClose();
+        navigate("/signature");
+      } else if (/demurrage|storage|warehouse invoice|fully paid/i.test(message)) {
+        onClose();
+        navigate("/billing");
+      }
+    },
+  });
+
+  const busy = approve.isPending || handoverMutation.isPending;
+
+  return (
+    <Modal
+      opened={opened}
+      onClose={onClose}
+      title="Approve delivery — review & sign the handover"
+      size="xl"
+      centered
+    >
+      <Stack gap="md">
+        <Alert color="blue" variant="light" icon={<Info size={16} />}>
+          <Text size="sm">
+            Review the handover document below. Approving applies your saved signature
+            and confirms you received the goods.
+          </Text>
+        </Alert>
+
+        {isLoading ? (
+          <Group justify="center" py="xl">
+            <Loader size="sm" />
+            <Text size="sm" c="dimmed">
+              Loading handover document…
+            </Text>
+          </Group>
+        ) : isError || !pdfUrl ? (
+          <Text size="sm" c="red">
+            Could not load the handover document. It may not be generated yet.
+          </Text>
+        ) : (
+          <iframe
+            title="Handover document"
+            src={pdfUrl}
+            style={{
+              width: "100%",
+              height: "60vh",
+              border: "1px solid var(--mantine-color-gray-3)",
+              borderRadius: 8,
+            }}
+          />
+        )}
+
+        <Group justify="flex-end">
+          <Button variant="default" onClick={onClose} disabled={busy}>
+            Cancel
+          </Button>
+          <Button
+            color="edr-green"
+            leftSection={<CheckCircle2 size={16} />}
+            loading={busy}
+            disabled={isLoading || isError}
+            onClick={() => approve.mutate({ id: bookingId })}
+          >
+            Approve &amp; sign delivery
+          </Button>
+        </Group>
+      </Stack>
+    </Modal>
+  );
+}
diff --git a/apps/edr-freight-web/portal/src/pages/bookings/new-booking-form/step-documents.tsx b/apps/edr-freight-web/portal/src/pages/bookings/new-booking-form/step-documents.tsx
index e0ae67384..880efb846 100644
--- a/apps/edr-freight-web/portal/src/pages/bookings/new-booking-form/step-documents.tsx
+++ b/apps/edr-freight-web/portal/src/pages/bookings/new-booking-form/step-documents.tsx
@@ -87,7 +87,7 @@ export function StepDocuments({ form }: { form: BookingForm }) {
           </Text>
           {onboardingDocs.map((doc, i) => (
             <Group
-              key={`${doc.url}-${i}`}
+              key={`${doc.id}-${i}`}
               gap={12}
               align="center"
               wrap="nowrap"
diff --git a/apps/edr-freight-web/portal/src/pages/contracts/NewContractPage.tsx b/apps/edr-freight-web/portal/src/pages/contracts/NewContractPage.tsx
index c443bf3b9..9b24d3b8b 100644
--- a/apps/edr-freight-web/portal/src/pages/contracts/NewContractPage.tsx
+++ b/apps/edr-freight-web/portal/src/pages/contracts/NewContractPage.tsx
@@ -144,6 +144,18 @@ export default function NewContractPage({
     );
   }
 
+  // Profile changes pending review lock out new contract creation too.
+  if (!auth.isPending && auth.isUnderReview) {
+    return (
+      <GateNotice
+        title="Profile Changes Under Review"
+        body="Your recent profile changes are awaiting administrator approval. Creating contracts is paused until the review is complete."
+        actionLabel="Back to Contracts"
+        onAction={() => navigate("/contracts")}
+      />
+    );
+  }
+
   const [pricingData, setPricingData] =
     useState<GenerateContractPriceResponse | null>(null);
   // In edit mode the contract already exists, so seed its id — this makes
@@ -191,14 +203,18 @@ export default function NewContractPage({
         contractId = contract.id;
       }
 
-      const pricing = await api.contracts.generatePrice.call({ id: contractId });
+      const pricing = await api.contracts.generatePrice.call({
+        id: contractId,
+      });
       return { contractId, pricing, mode };
     },
     onSuccess: ({ contractId, pricing, mode }) => {
       setPriceContractId(contractId);
       setPricingData(pricing);
       setPriceModalMode(mode);
-      queryClient.invalidateQueries({ queryKey: api.contracts.list.queryKey() });
+      queryClient.invalidateQueries({
+        queryKey: api.contracts.list.queryKey(),
+      });
     },
   });
 
@@ -214,7 +230,9 @@ export default function NewContractPage({
       }
       clearContractDraft();
       setPriceModalMode(null);
-      queryClient.invalidateQueries({ queryKey: api.contracts.list.queryKey() });
+      queryClient.invalidateQueries({
+        queryKey: api.contracts.list.queryKey(),
+      });
       navigate("/contracts");
     },
   });
@@ -228,7 +246,9 @@ export default function NewContractPage({
       clearContractDraft();
       setPriceChangeResult(null);
       setPriceModalMode(null);
-      queryClient.invalidateQueries({ queryKey: api.contracts.list.queryKey() });
+      queryClient.invalidateQueries({
+        queryKey: api.contracts.list.queryKey(),
+      });
       navigate("/contracts");
     },
   });
@@ -242,7 +262,9 @@ export default function NewContractPage({
       clearContractDraft();
       setPriceModalMode(null);
       setPriceContractId(null);
-      queryClient.invalidateQueries({ queryKey: api.contracts.list.queryKey() });
+      queryClient.invalidateQueries({
+        queryKey: api.contracts.list.queryKey(),
+      });
       navigate("/contracts");
     },
   });
@@ -325,6 +347,17 @@ export default function NewContractPage({
       m.set(p.type, p.status);
     return m;
   }, [auth.company]);
+  // Full profile per type, so the awaiting/rejected modal can show the reviewer
+  // note and offer a reapply for a rejected role.
+  const profileByType = useMemo(() => {
+    const m = new Map<
+      string,
+      { id: string; status: string; reviewNote?: string | null }
+    >();
+    for (const p of auth.company?.company?.companyProfiles ?? [])
+      m.set(p.type, { id: p.id, status: p.status, reviewNote: p.reviewNote });
+    return m;
+  }, [auth.company]);
   const profileTypes = useMemo(
     () => [...profileStatusByType.keys()],
     [profileStatusByType],
@@ -343,12 +376,14 @@ export default function NewContractPage({
   // badges. Intercity rides any customer profile, so always "approved".
   const operationStatus = useMemo(
     () =>
-      (op: OperationType): "approved" | "pending" | "missing" => {
+      (op: OperationType): "approved" | "pending" | "rejected" | "missing" => {
         if (op === "intercity") return "approved";
         const target = operationToProfileType(op, profileTypes);
         const status = profileStatusByType.get(target);
         if (!status) return "missing";
-        return status === "active" ? "approved" : "pending";
+        if (status === "active") return "approved";
+        if (status === "rejected") return "rejected";
+        return "pending";
       },
     [profileStatusByType, profileTypes],
   );
@@ -398,6 +433,17 @@ export default function NewContractPage({
     },
   });
 
+  // Resubmit a rejected operational role for approval (from the block modal).
+  const reapplyMutation = useMutation({
+    mutationFn: async (profileId: string) => {
+      const res = await auth.reapplyProfile(profileId);
+      if (!res.success) {
+        throw new Error(res.error?.message ?? "Failed to resubmit for approval");
+      }
+    },
+    onSuccess: () => setPendingApprovalProfile(null),
+  });
+
   const handleOperationSelect = (op: OperationType) => {
     // Intercity (domestic) runs on any existing customer profile — no switch.
     if (op === "intercity") return;
@@ -551,23 +597,23 @@ export default function NewContractPage({
         : {}),
       ...(serviceType?.includesFirstMile && data.firstMile.enabled
         ? {
-            firstMilePickupAddress: data.firstMile.pickUpAddress,
-            firstMilePickupLat: data.firstMile.lat ?? undefined,
-            firstMilePickupLng: data.firstMile.lng ?? undefined,
-          }
+          firstMilePickupAddress: data.firstMile.pickUpAddress,
+          firstMilePickupLat: data.firstMile.lat ?? undefined,
+          firstMilePickupLng: data.firstMile.lng ?? undefined,
+        }
         : {}),
       ...(serviceType?.includesLastMile && data.lastMile.enabled
         ? {
-            lastMileDeliveryAddress: data.lastMile.deliveryAddress,
-            lastMileDeliveryLat: data.lastMile.lat ?? undefined,
-            lastMileDeliveryLng: data.lastMile.lng ?? undefined,
-          }
+          lastMileDeliveryAddress: data.lastMile.deliveryAddress,
+          lastMileDeliveryLat: data.lastMile.lat ?? undefined,
+          lastMileDeliveryLng: data.lastMile.lng ?? undefined,
+        }
         : {}),
       ...(serviceType?.includesCustoms && data.customsClearingEnabled
         ? {
-            customsClearingEnabled: true,
-            customsClearingAgent: data.customsClearingAgent || undefined,
-          }
+          customsClearingEnabled: true,
+          customsClearingAgent: data.customsClearingAgent || undefined,
+        }
         : { customsClearingEnabled: false }),
       cargoScope,
       routes,
@@ -652,7 +698,12 @@ export default function NewContractPage({
         mb="lg"
       >
         <Box>
-          <Title order={1} fw={800} fz={26} style={{ letterSpacing: "-0.01em" }}>
+          <Title
+            order={1}
+            fw={800}
+            fz={26}
+            style={{ letterSpacing: "-0.01em" }}
+          >
             {isEdit ? "Edit Contract" : "New Contract"}
           </Title>
           <Text size="sm" c="edr-muted" mt={4}>
@@ -791,12 +842,12 @@ export default function NewContractPage({
                 errors={
                   showDocErrors
                     ? Object.fromEntries(
-                        missingRequiredDocKeys(
-                          editDocSettingQuery.data,
-                          editContract,
-                          editDocuments,
-                        ).map((k) => [k, "Required"]),
-                      )
+                      missingRequiredDocKeys(
+                        editDocSettingQuery.data,
+                        editContract,
+                        editDocuments,
+                      ).map((k) => [k, "Required"]),
+                    )
                     : {}
                 }
               />
@@ -814,9 +865,9 @@ export default function NewContractPage({
               pricing={
                 pricingData
                   ? {
-                      currency: pricingData.currency,
-                      lineItems: pricingData.lineItems,
-                    }
+                    currency: pricingData.currency,
+                    lineItems: pricingData.lineItems,
+                  }
                   : null
               }
               onSaveDraft={handleSaveDraft}
@@ -926,8 +977,8 @@ export default function NewContractPage({
                 Pricing schedule
               </Text>
               <Text size="xs" c="dimmed" mb="md">
-                Final amount is calculated at booking — quantities are unknown at
-                the contract stage.
+                Final amount is calculated at booking — quantities are unknown
+                at the contract stage.
               </Text>
               <Stack gap={10}>
                 {pricingData.lineItems.map((item) => (
@@ -1087,7 +1138,7 @@ export default function NewContractPage({
                 loading={confirmSubmitMutation.isPending}
                 onClick={() => confirmSubmitMutation.mutate()}
               >
-                Confirm &amp; submit
+                Confirm {"&"} submit
               </Button>
             </Group>
           </Stack>
@@ -1131,9 +1182,9 @@ export default function NewContractPage({
                 <Check size={18} />
               </Box>
               <Text size="sm" c="dimmed">
-                License submitted. Your {createTargetLabel.toLowerCase()} profile
-                is now awaiting staff approval. We'll notify you once it's
-                approved — then you can create this contract as{" "}
+                License submitted. Your {createTargetLabel.toLowerCase()}{" "}
+                profile is now awaiting staff approval. We'll notify you once
+                it's approved — then you can create this contract as{" "}
                 {createTargetLabel.toLowerCase()}.
               </Text>
             </Group>
@@ -1146,9 +1197,9 @@ export default function NewContractPage({
         ) : (
           <Stack gap="md">
             <Text size="sm" c="dimmed">
-              You don't have a {createTargetLabel.toLowerCase()} profile yet. Add
-              your business license to create one. It goes to staff for approval
-              before you can use it.
+              You don't have a {createTargetLabel.toLowerCase()} profile yet.
+              Add your business license to create one. It goes to staff for
+              approval before you can use it.
             </Text>
             <FileInput
               label="Business license"
@@ -1181,35 +1232,78 @@ export default function NewContractPage({
         )}
       </Modal>
 
-      {/* Awaiting-approval modal — the chosen operation maps to a profile that
-          exists but isn't approved yet. The select was already reverted. */}
-      <Modal
-        opened={pendingApprovalProfile !== null}
-        onClose={() => setPendingApprovalProfile(null)}
-        title="Awaiting approval"
-        centered
-        radius="lg"
-      >
-        <Stack gap="md">
-          <Text size="sm" c="dimmed">
-            Your{" "}
-            {pendingApprovalProfile
-              ? (PROFILE_TYPE_LABELS[pendingApprovalProfile] ??
-                pendingApprovalProfile)
-              : ""}{" "}
-            profile was submitted and is under staff review. You can start a
-            contract under it once it's approved.
-          </Text>
-          <Group justify="flex-end" gap="sm">
-            <Button
-              color="edr-green"
-              onClick={() => setPendingApprovalProfile(null)}
-            >
-              OK
-            </Button>
-          </Group>
-        </Stack>
-      </Modal>
+      {/* Awaiting-approval / rejected modal — the chosen operation maps to a
+          profile that exists but isn't active. The select was already reverted. */}
+      {(() => {
+        const target = pendingApprovalProfile
+          ? profileByType.get(pendingApprovalProfile)
+          : undefined;
+        const isRejected = target?.status === "rejected";
+        const label = pendingApprovalProfile
+          ? (PROFILE_TYPE_LABELS[pendingApprovalProfile] ??
+            pendingApprovalProfile)
+          : "";
+        return (
+          <Modal
+            opened={pendingApprovalProfile !== null}
+            onClose={() => setPendingApprovalProfile(null)}
+            title={isRejected ? "Profile not approved" : "Awaiting approval"}
+            centered
+            radius="lg"
+          >
+            <Stack gap="md">
+              {isRejected ? (
+                <>
+                  <Text size="sm" c="dimmed">
+                    Your {label} profile was not approved. Fix the issue below
+                    and resubmit it for review.
+                  </Text>
+                  {target?.reviewNote && (
+                    <Alert color="red" variant="light" radius="md">
+                      <Text size="sm">
+                        <strong>Reviewer note:</strong> {target.reviewNote}
+                      </Text>
+                    </Alert>
+                  )}
+                  <Group justify="flex-end" gap="sm">
+                    <Button
+                      variant="default"
+                      onClick={() => setPendingApprovalProfile(null)}
+                      disabled={reapplyMutation.isPending}
+                    >
+                      Close
+                    </Button>
+                    <Button
+                      color="edr-green"
+                      loading={reapplyMutation.isPending}
+                      onClick={() =>
+                        target && reapplyMutation.mutate(target.id)
+                      }
+                    >
+                      Resubmit for approval
+                    </Button>
+                  </Group>
+                </>
+              ) : (
+                <>
+                  <Text size="sm" c="dimmed">
+                    Your {label} profile was submitted and is under staff
+                    review. You can start a contract under it once it's approved.
+                  </Text>
+                  <Group justify="flex-end" gap="sm">
+                    <Button
+                      color="edr-green"
+                      onClick={() => setPendingApprovalProfile(null)}
+                    >
+                      OK
+                    </Button>
+                  </Group>
+                </>
+              )}
+            </Stack>
+          </Modal>
+        );
+      })()}
     </Box>
   );
 }
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 77086103b..2f0681590 100644
--- a/apps/edr-freight-web/portal/src/pages/contracts/NewShipmentPage.tsx
+++ b/apps/edr-freight-web/portal/src/pages/contracts/NewShipmentPage.tsx
@@ -1151,9 +1151,14 @@ function ContainerLineEditor({
               render={({ field, fieldState }) => (
                 <TextInput
                   {...field}
+<<<<<<< HEAD
                   onChange={(e) =>
                     field.onChange(e.currentTarget.value.toUpperCase())
                   }
+=======
+                  onChange={(e) => field.onChange(e.currentTarget.value.toUpperCase())}
+                  maxLength={11}
+>>>>>>> 1b9ac42ed3fc9bd6b8dea8d08b5c4c066d083feb
                   label={u === 0 ? "Container number *" : undefined}
                   placeholder="e.g. MSCU1234567"
                   error={fieldState.error?.message}
diff --git a/apps/edr-freight-web/portal/src/pages/contracts/new-contract-form/step-documents.tsx b/apps/edr-freight-web/portal/src/pages/contracts/new-contract-form/step-documents.tsx
index 34f8d92ea..86b6f61a2 100644
--- a/apps/edr-freight-web/portal/src/pages/contracts/new-contract-form/step-documents.tsx
+++ b/apps/edr-freight-web/portal/src/pages/contracts/new-contract-form/step-documents.tsx
@@ -156,7 +156,7 @@ export function StepDocuments({
           </Text>
           {onboardingDocs.map((doc, i) => (
             <Group
-              key={`${doc.url}-${i}`}
+              key={`${doc.id}-${i}`}
               gap={12}
               align="center"
               wrap="nowrap"
diff --git a/apps/edr-freight-web/portal/src/pages/contracts/new-contract-form/step1-contract-type.tsx b/apps/edr-freight-web/portal/src/pages/contracts/new-contract-form/step1-contract-type.tsx
index e37daea6c..19a441045 100644
--- a/apps/edr-freight-web/portal/src/pages/contracts/new-contract-form/step1-contract-type.tsx
+++ b/apps/edr-freight-web/portal/src/pages/contracts/new-contract-form/step1-contract-type.tsx
@@ -43,7 +43,9 @@ export function Step1ContractType({
   allowedOperations: OperationType[];
   onOperationSelect?: (op: OperationType) => void;
   /** Approval state of the profile each operation maps to (for the badges). */
-  operationStatus?: (op: OperationType) => "approved" | "pending" | "missing";
+  operationStatus?: (
+    op: OperationType,
+  ) => "approved" | "pending" | "rejected" | "missing";
 }) {
   const contractType = form.watch("contractType");
 
@@ -221,6 +223,11 @@ export function Step1ContractType({
                         Pending
                       </Badge>
                     )}
+                    {status === "rejected" && (
+                      <Badge size="xs" color="red" variant="light" radius="sm">
+                        Rejected
+                      </Badge>
+                    )}
                     {status === "missing" && (
                       <Badge size="xs" color="gray" variant="light" radius="sm">
                         Add license
diff --git a/apps/edr-freight-web/portal/src/pages/contracts/new-shipment-form/schema.ts b/apps/edr-freight-web/portal/src/pages/contracts/new-shipment-form/schema.ts
index a21a69a76..245f10475 100644
--- a/apps/edr-freight-web/portal/src/pages/contracts/new-shipment-form/schema.ts
+++ b/apps/edr-freight-web/portal/src/pages/contracts/new-shipment-form/schema.ts
@@ -26,16 +26,31 @@ export interface ShipmentValidationContext {
   requiresDate?: boolean;
 }
 
+<<<<<<< HEAD
 // ISO 6346: 3-letter owner code + category id (U/J/Z) + 6-digit serial + check digit.
 const ISO_CONTAINER_NUMBER_REGEX = /^[A-Z]{4}\d{7}$/;
+=======
+// ISO 6346: 4 letters (owner + category) + 6 serial digits + 1 check digit.
+// Enforced at booking input so the number stays a clean reference in the warehouse.
+const ISO_CONTAINER_RE = /^[A-Z]{4}\d{7}$/;
+>>>>>>> 1b9ac42ed3fc9bd6b8dea8d08b5c4c066d083feb
 
 const containerUnitSchema = z.object({
   containerNumber: z
     .string()
+<<<<<<< HEAD
     .min(1, "Container number is required.")
     .refine(
       (v) => ISO_CONTAINER_NUMBER_REGEX.test(v.trim().toUpperCase()),
       "Enter a valid ISO container number (e.g. ABCD1234567).",
+=======
+    .transform((v) => v.trim().toUpperCase())
+    .pipe(
+      z
+        .string()
+        .min(1, "Container number is required.")
+        .regex(ISO_CONTAINER_RE, "Use ISO format: 4 letters + 7 digits, e.g. ABCU1234567."),
+>>>>>>> 1b9ac42ed3fc9bd6b8dea8d08b5c4c066d083feb
     ),
   sealNumber: z.string().default(""),
   vgmTons: z
diff --git a/apps/edr-freight-web/portal/src/pages/settings/TabCompanyProfile.tsx b/apps/edr-freight-web/portal/src/pages/settings/TabCompanyProfile.tsx
index 995acc104..27011a9d7 100644
--- a/apps/edr-freight-web/portal/src/pages/settings/TabCompanyProfile.tsx
+++ b/apps/edr-freight-web/portal/src/pages/settings/TabCompanyProfile.tsx
@@ -34,6 +34,12 @@ export const COMPANY_PROFILE_SCHEMA = z.object({
   companyAddress: z.string().min(1, "Address is required"),
   tinNumber: z.string().length(10, "TIN must be exactly 10 digits"),
   fanNumber: z.string().length(16, "FAN must be exactly 16 digits"),
+  vatNumber: z
+    .string()
+    .trim()
+    .max(20, "VAT number is too long")
+    .optional()
+    .or(z.literal("")),
 });
 
 export type CompanyProfileFormData = z.infer<typeof COMPANY_PROFILE_SCHEMA>;
@@ -63,6 +69,7 @@ export default function TabCompanyProfile({
         companyAddress: profile.companyAddress ?? "",
         tinNumber: profile.tinNumber,
         fanNumber: profile.fanNumber ?? "",
+        vatNumber: profile.vatNumber ?? "",
       };
     }
     return {
@@ -73,6 +80,7 @@ export default function TabCompanyProfile({
       companyAddress: "",
       tinNumber: "",
       fanNumber: "",
+      vatNumber: "",
     };
   }, [profile]);
 
@@ -97,6 +105,7 @@ export default function TabCompanyProfile({
         companyAddress: data.companyAddress,
         tin: data.tinNumber,
         fanNumber: data.fanNumber,
+        vatNumber: data.vatNumber ?? "",
       };
 
       if (isCreate) {
@@ -223,6 +232,18 @@ export default function TabCompanyProfile({
               />
             </Grid.Col>
           </Grid>
+
+          <Grid>
+            <Grid.Col span={6}>
+              <TextInput
+                label="VAT Number (optional)"
+                placeholder="e.g. 0012345678"
+                maxLength={20}
+                error={errors.vatNumber?.message}
+                {...register("vatNumber")}
+              />
+            </Grid.Col>
+          </Grid>
         </Stack>
 
         <Group
diff --git a/apps/edr-freight-web/portal/src/pages/settings/TabDocuments.tsx b/apps/edr-freight-web/portal/src/pages/settings/TabDocuments.tsx
index 2b31559ce..9bd8d7ba9 100644
--- a/apps/edr-freight-web/portal/src/pages/settings/TabDocuments.tsx
+++ b/apps/edr-freight-web/portal/src/pages/settings/TabDocuments.tsx
@@ -1,11 +1,21 @@
 import { fileViewUrl } from "@/constants/apiConfig";
 import { api } from "@/services/api";
-import { companiesService } from "@/services/companies.service";
+import {
+  companiesService,
+  type CompanyProfileResponse,
+  type LicenseFileStatus,
+} from "@/services/companies.service";
 import { getMinFiles } from "@/types/fileUploadSettings";
 import type { ProfileResponse } from "@/types/profile";
-import { SmartFileInput, useFileViewer } from "@edr/ui-common";
 import {
-  // Anchor,
+  SmartFileInput,
+  useFileViewer,
+  type ViewableFile,
+} from "@edr/ui-common";
+import {
+  ActionIcon,
+  Anchor,
+  Badge,
   Button,
   Card,
   Center,
@@ -13,18 +23,23 @@ import {
   Stack,
   Text,
   Title,
+  Tooltip,
 } from "@mantine/core";
 import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
 import {
   ArrowRight,
   CheckCircle2,
+  Clock,
   FileCheck,
+  FileText,
   Loader2,
   Paperclip,
+  RefreshCw,
+  Trash2,
   UploadCloud,
   XCircle,
 } from "lucide-react";
-import { useMemo, useState } from "react";
+import { useMemo, useRef, useState } from "react";
 
 const ROLE_LABELS: Record<string, string> = {
   importer: "Importer",
@@ -137,9 +152,7 @@ export default function TabDocuments({
     return errs;
   };
 
-  const licenseProfiles = profile.companyProfiles.filter(
-    (p) => p.licenseFiles && p.licenseFiles.length > 0,
-  );
+  const licenseProfiles = profile.companyProfiles;
 
   return (
     <>
@@ -246,24 +259,19 @@ export default function TabDocuments({
             <Title order={3}>Business licenses</Title>
           </Group>
           <Text c="edr-muted" size="sm" mb="lg">
-            License documents uploaded per operational profile
+            Add, replace or remove the license documents for each operational
+            profile. Changes are submitted to EDR for review before they take
+            effect.
           </Text>
 
-          <Stack gap="md">
+          <Stack gap="xl">
             {licenseProfiles.map((p) => (
-              <Stack key={p.id} gap={4}>
-                <Text size="sm" fw={600} c="edr-text">
-                  {ROLE_LABELS[p.type] ?? p.type} · {p.reference}
-                </Text>
-                {p.licenseFiles.map((f) => (
-                  <Group key={f.url} gap={6} wrap="nowrap">
-                    <Paperclip size={13} className="text-edr-muted" />
-                    <Text component="button" type="button" size="xs">
-                      {f.name}
-                    </Text>
-                  </Group>
-                ))}
-              </Stack>
+              <ProfileLicenseRow
+                key={p.id}
+                profile={p}
+                onViewFile={view}
+                reviewPending={profile.reviewStatus === "pending"}
+              />
             ))}
           </Stack>
         </Card>
@@ -273,3 +281,263 @@ export default function TabDocuments({
     </>
   );
 }
+
+const LICENSE_ACCEPT = ".pdf,.png,.jpg,.jpeg";
+
+function formatBytes(bytes: number): string {
+  if (!bytes) return "";
+  const units = ["B", "KB", "MB", "GB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(1024));
+  return `${parseFloat((bytes / Math.pow(1024, i)).toFixed(1))} ${units[i]}`;
+}
+
+const STATUS_BADGE: Record<
+  LicenseFileStatus,
+  { label: string; color: string; bg: string; fg: string } | null
+> = {
+  live: null,
+  pending_add: {
+    label: "Pending approval",
+    color: "edr-amber",
+    bg: "var(--mantine-color-edr-amber-soft-0)",
+    fg: "var(--mantine-color-edr-amber-text-0)",
+  },
+  pending_remove: {
+    label: "Removal pending",
+    color: "edr-red",
+    bg: "var(--mantine-color-edr-red-soft-0)",
+    fg: "var(--mantine-color-edr-red-0)",
+  },
+};
+
+/**
+ * One operational profile's business-license documents. Lists each file (click
+ * to preview via the file proxy) with its review state, and lets the customer
+ * add / replace / remove files. Every mutation opens a change request the
+ * backoffice must approve; while one is open the parent locks this whole tab.
+ */
+function ProfileLicenseRow({
+  profile,
+  onViewFile,
+  reviewPending,
+}: {
+  profile: CompanyProfileResponse;
+  onViewFile: (file: ViewableFile) => void;
+  reviewPending: boolean;
+}) {
+  const queryClient = useQueryClient();
+  const addInputRef = useRef<HTMLInputElement>(null);
+  const replaceInputRef = useRef<HTMLInputElement>(null);
+  const replaceTargetId = useRef<string | null>(null);
+  const [error, setError] = useState<string | null>(null);
+
+  const invalidate = () => {
+    setError(null);
+    queryClient.invalidateQueries({
+      queryKey: api.companies.getProfile.queryKey(),
+    });
+  };
+
+  const addMutation = useMutation({
+    mutationFn: (files: File[]) =>
+      companiesService.uploadProfileLicense(profile.id, files),
+    onSuccess: invalidate,
+    onError: () => setError("Upload failed. Please try again."),
+  });
+  const replaceMutation = useMutation({
+    mutationFn: ({ fileId, file }: { fileId: string; file: File }) =>
+      companiesService.replaceProfileLicense(profile.id, fileId, file),
+    onSuccess: invalidate,
+    onError: () => setError("Replace failed. Please try again."),
+  });
+  const removeMutation = useMutation({
+    mutationFn: (fileId: string) =>
+      companiesService.removeProfileLicense(profile.id, fileId),
+    onSuccess: invalidate,
+    onError: () => setError("Remove failed. Please try again."),
+  });
+
+  const busy =
+    addMutation.isPending ||
+    replaceMutation.isPending ||
+    removeMutation.isPending;
+  const files = profile.licenseFiles ?? [];
+
+  return (
+    <Stack gap="sm">
+      <Group justify="space-between" align="center">
+        <Text size="sm" fw={700} c="edr-text">
+          {ROLE_LABELS[profile.type] ?? profile.type} · {profile.reference}
+        </Text>
+        <Button
+          variant="light"
+          size="xs"
+          leftSection={<UploadCloud size={14} />}
+          loading={addMutation.isPending}
+          disabled={busy}
+          onClick={() => addInputRef.current?.click()}
+        >
+          Add document
+        </Button>
+      </Group>
+
+      {files.length === 0 ? (
+        <Card
+          padding="md"
+          radius="md"
+          style={{
+            borderStyle: "dashed",
+            backgroundColor: "var(--mantine-color-edr-bg-0)",
+          }}
+        >
+          <Text size="sm" c="edr-muted" ta="center">
+            No license documents yet.
+          </Text>
+        </Card>
+      ) : (
+        <Stack gap="xs">
+          {files.map((f) => {
+            const badge = STATUS_BADGE[f.status];
+            const isPending = f.status !== "live";
+            return (
+              <Card
+                key={f.id}
+                padding="sm"
+                radius="md"
+                withBorder
+                style={{ backgroundColor: "var(--mantine-color-edr-card-0)" }}
+              >
+                <Group gap="sm" wrap="nowrap">
+                  <FileText
+                    size={18}
+                    className="text-edr-muted"
+                    style={{ flexShrink: 0 }}
+                  />
+                  <Stack gap={0} style={{ minWidth: 0, flex: 1 }}>
+                    <Anchor
+                      component="button"
+                      type="button"
+                      size="sm"
+                      fw={600}
+                      onClick={() =>
+                        onViewFile({
+                          name: f.name,
+                          url: fileViewUrl(f.id),
+                          mimeType: f.mimeType,
+                        })
+                      }
+                      style={{
+                        textAlign: "left",
+                        textDecoration:
+                          f.status === "pending_remove"
+                            ? "line-through"
+                            : undefined,
+                      }}
+                      lineClamp={1}
+                    >
+                      {f.name}
+                    </Anchor>
+                    {f.size > 0 && (
+                      <Text size="xs" c="edr-muted">
+                        {formatBytes(f.size)}
+                      </Text>
+                    )}
+                  </Stack>
+
+                  {badge && (
+                    <Badge
+                      size="sm"
+                      radius="sm"
+                      variant="light"
+                      leftSection={<Clock size={11} />}
+                      style={{
+                        backgroundColor: badge.bg,
+                        color: badge.fg,
+                        flexShrink: 0,
+                      }}
+                    >
+                      {badge.label}
+                    </Badge>
+                  )}
+
+                  <Tooltip label="Replace" withArrow>
+                    <ActionIcon
+                      variant="subtle"
+                      color="gray"
+                      aria-label={`Replace ${f.name}`}
+                      disabled={busy || isPending}
+                      onClick={() => {
+                        replaceTargetId.current = f.id;
+                        replaceInputRef.current?.click();
+                      }}
+                    >
+                      <RefreshCw size={15} />
+                    </ActionIcon>
+                  </Tooltip>
+                  <Tooltip label="Remove" withArrow>
+                    <ActionIcon
+                      variant="subtle"
+                      color="red"
+                      aria-label={`Remove ${f.name}`}
+                      disabled={busy || isPending}
+                      loading={
+                        removeMutation.isPending &&
+                        removeMutation.variables === f.id
+                      }
+                      onClick={() => removeMutation.mutate(f.id)}
+                    >
+                      <Trash2 size={15} />
+                    </ActionIcon>
+                  </Tooltip>
+                </Group>
+              </Card>
+            );
+          })}
+        </Stack>
+      )}
+
+      {reviewPending && (
+        <Group gap={6} c="edr-amber-text">
+          <Clock size={13} />
+          <Text size="xs" fw={500}>
+            Awaiting EDR review — further changes are disabled until it clears.
+          </Text>
+        </Group>
+      )}
+      {error && (
+        <Group gap={6} c="red">
+          <XCircle size={13} />
+          <Text size="xs" fw={500}>
+            {error}
+          </Text>
+        </Group>
+      )}
+
+      <input
+        ref={addInputRef}
+        type="file"
+        multiple
+        accept={LICENSE_ACCEPT}
+        style={{ display: "none" }}
+        onChange={(e) => {
+          const picked = e.target.files ? Array.from(e.target.files) : [];
+          if (picked.length > 0) addMutation.mutate(picked);
+          e.target.value = "";
+        }}
+      />
+      <input
+        ref={replaceInputRef}
+        type="file"
+        accept={LICENSE_ACCEPT}
+        style={{ display: "none" }}
+        onChange={(e) => {
+          const file = e.target.files?.[0];
+          const fileId = replaceTargetId.current;
+          if (file && fileId) replaceMutation.mutate({ fileId, file });
+          replaceTargetId.current = null;
+          e.target.value = "";
+        }}
+      />
+    </Stack>
+  );
+}
diff --git a/apps/edr-freight-web/portal/src/services/api.ts b/apps/edr-freight-web/portal/src/services/api.ts
index 932f6fc46..bad712689 100644
--- a/apps/edr-freight-web/portal/src/services/api.ts
+++ b/apps/edr-freight-web/portal/src/services/api.ts
@@ -54,6 +54,7 @@ import {
   UpdateDropdownSettingDto,
 } from "@/types/dropdownSettings";
 import type {
+  ChangeRequestResponse,
   CompanyDocument,
   CompanyInfoResponse,
   CompanyNationality,
@@ -211,6 +212,18 @@ export const api = {
       "documents",
       ({ companyId }) => companiesService.getDocuments(companyId),
     ),
+
+    changeRequest: endpoint<void, ChangeRequestResponse | null>(
+      "companies",
+      "changeRequest",
+      companiesService.getChangeRequest,
+    ),
+
+    reapplyProfile: endpoint<{ profileId: string }, CompanyProfileResponse>(
+      "companies",
+      "reapplyProfile",
+      ({ profileId }) => companiesService.reapplyProfile(profileId),
+    ),
   },
 
   bookings: {
@@ -251,6 +264,13 @@ export const api = {
         bookingsService.downloadHandoverDocument(inventoryId),
     ),
 
+    downloadBookingHandoverDocument: endpoint<{ bookingId: string }, Blob>(
+      "bookings",
+      "downloadBookingHandoverDocument",
+      ({ bookingId }) =>
+        bookingsService.downloadBookingHandoverDocument(bookingId),
+    ),
+
     create: endpoint<
       { payload: CreateBookingPayload; documents?: BookingDocuments },
       Freight.IBooking
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 c2729bebb..852452099 100644
--- a/apps/edr-freight-web/portal/src/services/bookings.service.ts
+++ b/apps/edr-freight-web/portal/src/services/bookings.service.ts
@@ -7,6 +7,26 @@ import { client } from "../utils/api";
 
 const B = URL_CONSTANTS.BOOKINGS;
 
+export interface MileVehicleSummary {
+  plate: string | null;
+  code: string | null;
+  driverName: string | null;
+  containerNumber: string | null;
+  distanceKm: number | null;
+}
+export interface MileLegSummary {
+  status: string;
+  exactKm: number | null;
+  remainingPayment: number | null;
+  currency: string;
+  invoiced: boolean;
+  vehicles: MileVehicleSummary[];
+}
+export interface MileSummaryResponse {
+  firstMile: MileLegSummary | null;
+  lastMile: MileLegSummary | null;
+}
+
 export type CreateBookingPayload = Freight.CreateBookingDto;
 
 export interface ContractView {
@@ -150,6 +170,10 @@ export const bookingsService = {
     const { data } = await client.get(`/api/bookings/${id}`);
     return data.data;
   },
+  mileSummary: async (id: string): Promise<MileSummaryResponse> => {
+    const { data } = await client.get(`/api/bookings/${id}/mile-summary`);
+    return data.data;
+  },
   assignCustomerTruck: async (
     id: string,
     payload: CustomerTruckAssignmentPayload,
@@ -174,6 +198,13 @@ export const bookingsService = {
     );
     return data;
   },
+  downloadBookingHandoverDocument: async (bookingId: string): Promise<Blob> => {
+    const { data } = await client.get(
+      `/api/warehouse-inventory/bookings/${bookingId}/handover-document`,
+      { responseType: "blob" },
+    );
+    return data;
+  },
   tracking: async (id: string): Promise<Freight.IBookingTracking> => {
     const { data } = await client.get(`/api/bookings/${id}/tracking`);
     return data.data;
diff --git a/apps/edr-freight-web/portal/src/services/companies.service.ts b/apps/edr-freight-web/portal/src/services/companies.service.ts
index d3f584170..ad93e03a8 100644
--- a/apps/edr-freight-web/portal/src/services/companies.service.ts
+++ b/apps/edr-freight-web/portal/src/services/companies.service.ts
@@ -14,11 +14,16 @@ export type ProfileTypeValue =
 
 export type CompanyNationality = "ethiopian" | "foreign";
 
+/** Review state of a business-license file (mirrors the API's ProfileLicenseFileView). */
+export type LicenseFileStatus = "live" | "pending_add" | "pending_remove";
+
 export interface LicenseFile {
+  id: string;
   name: string;
-  url: string;
   size: number;
-  mimeType?: string;
+  mimeType: string;
+  /** `live` = approved; `pending_add`/`pending_remove` = awaiting backoffice review. */
+  status: LicenseFileStatus;
 }
 
 export interface ExternalProfileResponse {
@@ -73,6 +78,8 @@ export interface CompanyProfileResponse {
   /** Business-license documents uploaded for this profile. */
   licenseFiles: LicenseFile[];
   attributes: Record<string, any> | null;
+  /** Reviewer note when the role is rejected (drives the reapply prompt). */
+  reviewNote?: string | null;
   createdAt: string;
   updatedAt: string;
 }
@@ -80,6 +87,28 @@ export interface CompanyProfileResponse {
 export interface CompanyInfoResponse {
   profile: ExternalProfileResponse;
   company: CompanyResponse;
+  /**
+   * Open profile-edit review, if any. `pending` locks the settings page + new
+   * contract/booking creation; `rejected` surfaces the note for reapply.
+   */
+  review?: {
+    status: "pending" | "rejected";
+    note: string | null;
+  } | null;
+}
+
+/** A staged profile-edit review request (portal view). */
+export interface ChangeRequestResponse {
+  id: string;
+  companyId: string;
+  status: "pending" | "approved" | "rejected";
+  snapshot: Record<string, any>;
+  documentFileIds: string[];
+  note: string | null;
+  submittedAt: string | null;
+  reviewedAt: string | null;
+  createdAt: string;
+  updatedAt: string;
 }
 
 /** A single company-level document uploaded against a `file_upload_settings` field. */
@@ -328,7 +357,11 @@ export const companiesService = {
     return unwrap(response.data);
   },
 
-  /** Upload business-license document(s) for a company profile (multi-file). */
+  /**
+   * Add business-license document(s) to a company profile. For an approved
+   * company the upload is staged for backoffice review; during onboarding it
+   * goes live immediately. Returns the profile's full license list with state.
+   */
   uploadProfileLicense: async (
     profileId: string,
     files: File[],
@@ -343,7 +376,33 @@ export const companiesService = {
     return unwrap(response.data);
   },
 
-  /** List business-license document(s) already uploaded for a company profile. */
+  /** Replace a license file with a newly uploaded one (staged for review). */
+  replaceProfileLicense: async (
+    profileId: string,
+    fileId: string,
+    file: File,
+  ): Promise<LicenseFile[]> => {
+    const formData = new FormData();
+    formData.append("business_license", file);
+    const response = await client.post<ApiResponse<LicenseFile[]>>(
+      URL_CONSTANTS.COMPANIES_API.PROFILE_LICENSE_REPLACE(profileId, fileId),
+      formData,
+    );
+    return unwrap(response.data);
+  },
+
+  /** Remove a license file (staged for review on an approved company). */
+  removeProfileLicense: async (
+    profileId: string,
+    fileId: string,
+  ): Promise<LicenseFile[]> => {
+    const response = await client.delete<ApiResponse<LicenseFile[]>>(
+      URL_CONSTANTS.COMPANIES_API.PROFILE_LICENSE_FILE(profileId, fileId),
+    );
+    return unwrap(response.data);
+  },
+
+  /** List business-license document(s) (with review state) for a company profile. */
   getProfileLicense: async (profileId: string): Promise<LicenseFile[]> => {
     const response = await client.get<ApiResponse<LicenseFile[]>>(
       URL_CONSTANTS.COMPANIES_API.PROFILE_LICENSE(profileId),
@@ -351,6 +410,24 @@ export const companiesService = {
     return unwrap(response.data);
   },
 
+  /** The current company's open profile change request (pending/rejected), or null. */
+  getChangeRequest: async (): Promise<ChangeRequestResponse | null> => {
+    const response = await client.get<ApiResponse<ChangeRequestResponse | null>>(
+      URL_CONSTANTS.COMPANIES_API.PROFILE_CHANGE_REQUEST,
+    );
+    return unwrap(response.data);
+  },
+
+  /** Resubmit a rejected operational role for approval (→ pending). */
+  reapplyProfile: async (
+    profileId: string,
+  ): Promise<CompanyProfileResponse> => {
+    const response = await client.post<ApiResponse<CompanyProfileResponse>>(
+      URL_CONSTANTS.COMPANIES_API.PROFILE_REAPPLY(profileId),
+    );
+    return unwrap(response.data);
+  },
+
   /** Fetch company registration data from eTrade by TIN. */
   fetchETradeInfo: async (payload: { tin: string }): Promise<any> => {
     const response = await client.post<ApiResponse<any>>(
diff --git a/apps/edr-freight-web/portal/src/services/customer-trucks.service.ts b/apps/edr-freight-web/portal/src/services/customer-trucks.service.ts
index ee317e204..2663d43ec 100644
--- a/apps/edr-freight-web/portal/src/services/customer-trucks.service.ts
+++ b/apps/edr-freight-web/portal/src/services/customer-trucks.service.ts
@@ -23,6 +23,15 @@ export const customerTrucksService = {
     return data.data ?? data;
   },
 
+  update: async (
+    bookingId: string,
+    assignmentId: string,
+    payload: Freight.AddCustomerTruckPayload,
+  ): Promise<Freight.ICustomerTruck[]> => {
+    const { data } = await client.patch(B.CUSTOMER_TRUCK(bookingId, assignmentId), payload);
+    return data.data ?? data;
+  },
+
   remove: async (
     bookingId: string,
     assignmentId: string,
diff --git a/apps/edr-freight-web/portal/src/types/profile.ts b/apps/edr-freight-web/portal/src/types/profile.ts
index 3d3f2bad6..1e267fa66 100644
--- a/apps/edr-freight-web/portal/src/types/profile.ts
+++ b/apps/edr-freight-web/portal/src/types/profile.ts
@@ -40,6 +40,14 @@ export interface ProfileResponse {
   poaLocation: string | null;
   poaAddress: string | null;
   profileId: string;
+  /**
+   * Open profile-edit review. `pending` → the settings page is read-only until an
+   * admin decides; `rejected` → the note explains why and the forms prefill the
+   * declined values so the customer can amend & resubmit.
+   */
+  reviewStatus?: "pending" | "rejected" | null;
+  reviewNote?: string | null;
+  pendingChanges?: Record<string, any> | null;
 }
 
 export interface UpdateProfilePayload {
diff --git a/apps/edr-freight-web/portal/src/utils/api.ts b/apps/edr-freight-web/portal/src/utils/api.ts
index 289709906..6cc569477 100644
--- a/apps/edr-freight-web/portal/src/utils/api.ts
+++ b/apps/edr-freight-web/portal/src/utils/api.ts
@@ -42,21 +42,41 @@ client.interceptors.request.use((config) => {
 });
 
 // Token refresh state
-let isRefreshing = false;
-let failedQueue: {
-  resolve: (token: string) => void;
-  reject: (error: unknown) => void;
-}[] = [];
+let refreshPromise: Promise<string> | null = null;
 
-function processQueue(error: unknown, token?: string) {
-  failedQueue.forEach(({ resolve, reject }) => {
-    if (error) {
-      reject(error);
-    } else {
-      resolve(token!);
+/**
+ * Single-flight token refresh: concurrent callers (the 401 interceptor and
+ * the proactive scheduler) share one in-flight request so the refresh token
+ * is only rotated once. Throws if no refresh token is stored or the server
+ * rejects it — callers decide how to end the session.
+ */
+async function refreshSessionTokens(): Promise<string> {
+  refreshPromise ??= (async () => {
+    const refreshToken = getCookie("refresh-token");
+    if (!refreshToken) {
+      throw new Error("missing refresh token");
     }
+
+    type TokenPair = { token: string; refreshToken: string };
+    const { data } = await client.post<Partial<TokenPair> & { data?: TokenPair }>(
+      URL_CONSTANTS.AUTH.REFRESH_TOKEN,
+      { refreshToken },
+    );
+    // The API returns the pair flat ({ success, token, refreshToken }); accept
+    // a { data: { ... } }-wrapped shape too so a transform change can't
+    // silently break refresh again.
+    const payload = data.data ?? data;
+    if (!payload.token || !payload.refreshToken) {
+      throw new Error("malformed refresh-token response");
+    }
+    setCookie("auth-token", payload.token, 7);
+    setCookie("refresh-token", payload.refreshToken, 7);
+    return payload.token;
+  })().finally(() => {
+    refreshPromise = null;
   });
-  failedQueue = [];
+
+  return refreshPromise;
 }
 
 // Handle auth errors globally with token refresh
@@ -72,54 +92,41 @@ client.interceptors.response.use(
     // - status is not 401
     // - already retried
     // - it's the refresh endpoint itself
+    // - it's a credential endpoint (401 there = wrong credentials, not an
+    //   expired session — refreshing would mask the real error)
     if (
       !error.response ||
       error.response.status !== 401 ||
       originalRequest._retry ||
-      originalRequest.url === URL_CONSTANTS.AUTH.REFRESH_TOKEN
+      originalRequest.url === URL_CONSTANTS.AUTH.REFRESH_TOKEN ||
+      originalRequest.url === URL_CONSTANTS.AUTH.LOGIN ||
+      originalRequest.url === URL_CONSTANTS.USERS.SIGN_UP
     ) {
       return Promise.reject(error);
     }
 
-    if (isRefreshing) {
-      return new Promise<string>((resolve, reject) => {
-        failedQueue.push({ resolve, reject });
-      }).then((token) => {
-        originalRequest.headers.Authorization = `Bearer ${token}`;
-        return client(originalRequest);
-      });
-    }
-
-    originalRequest._retry = true;
-    isRefreshing = true;
-
-    const refreshToken = getCookie("refresh-token");
-
-    if (!refreshToken) {
-      isRefreshing = false;
-      clearAuthCookies();
+    // Nothing to refresh with (e.g. not logged in yet) — surface the
+    // original error instead of a confusing refresh failure.
+    if (!getCookie("refresh-token")) {
+      if (getCookie("auth-token")) {
+        // Half-broken cookie state; reset it.
+        clearAuthCookies();
+      }
       return Promise.reject(error);
     }
 
+    originalRequest._retry = true;
+
     try {
-      const { data } = await client.post<{
-        data: { token: string; refreshToken: string };
-      }>(URL_CONSTANTS.AUTH.REFRESH_TOKEN, { refreshToken });
-      const { token, refreshToken: newRefreshToken } = data.data;
-      setCookie("auth-token", token, 7);
-      setCookie("refresh-token", newRefreshToken, 7);
+      const token = await refreshSessionTokens();
       originalRequest.headers.Authorization = `Bearer ${token}`;
-      processQueue(null, token);
       return client(originalRequest);
     } catch (refreshError) {
-      processQueue(refreshError, undefined);
       clearAuthCookies();
       return Promise.reject(refreshError);
-    } finally {
-      isRefreshing = false;
     }
   },
 );
 
-export { client };
+export { client, clearAuthCookies, getCookie, refreshSessionTokens };
 export type { UseQueryOptions, QueryObserverOptions };
diff --git a/apps/edr-freight-web/portal/src/utils/refreshScheduler.ts b/apps/edr-freight-web/portal/src/utils/refreshScheduler.ts
new file mode 100644
index 000000000..dceca856e
--- /dev/null
+++ b/apps/edr-freight-web/portal/src/utils/refreshScheduler.ts
@@ -0,0 +1,81 @@
+import { isAxiosError } from "axios";
+
+import {
+  clearAuthCookies,
+  getCookie,
+  refreshSessionTokens,
+} from "./api";
+
+/**
+ * Proactively refreshes the token pair on a fixed cadence so the server-side
+ * session (a sliding 1-hour window, extended only by /auth/refresh-token) is
+ * kept alive while the app is open. The 401 interceptor in api.ts remains
+ * the reactive fallback; both share the same single-flight refresh call.
+ *
+ * The interval MUST stay well under the server session window (60 min).
+ */
+const DEFAULT_INTERVAL_MINUTES = 10;
+
+const getIntervalMs = () => {
+  const minutes = Number(import.meta.env.VITE_TOKEN_REFRESH_INTERVAL_MINUTES);
+  return (
+    (Number.isFinite(minutes) && minutes > 0
+      ? minutes
+      : DEFAULT_INTERVAL_MINUTES) * 60_000
+  );
+};
+
+let timerId: number | null = null;
+let lastRefreshAt = 0;
+
+const refreshNow = async () => {
+  if (!getCookie("refresh-token")) {
+    // Logged out elsewhere; nothing to keep alive.
+    stopTokenRefreshScheduler();
+    return;
+  }
+
+  try {
+    await refreshSessionTokens();
+    lastRefreshAt = Date.now();
+  } catch (error) {
+    // Network hiccups are retried on the next tick; only an explicit server
+    // rejection means the session is dead.
+    if (isAxiosError(error) && error.response) {
+      stopTokenRefreshScheduler();
+      clearAuthCookies();
+      window.location.replace("/login");
+    }
+  }
+};
+
+/**
+ * Browsers freeze timers in background tabs — a tab waking up past its
+ * refresh deadline refreshes immediately instead of waiting a full interval.
+ */
+const onVisibilityChange = () => {
+  if (document.visibilityState !== "visible") return;
+  if (Date.now() - lastRefreshAt >= getIntervalMs()) {
+    void refreshNow();
+  }
+};
+
+export const startTokenRefreshScheduler = () => {
+  stopTokenRefreshScheduler();
+
+  // Token age is unknown here (fresh login vs. hours-old page reload), so
+  // refresh right away to extend the session window from "now".
+  lastRefreshAt = 0;
+  void refreshNow();
+
+  timerId = window.setInterval(() => void refreshNow(), getIntervalMs());
+  document.addEventListener("visibilitychange", onVisibilityChange);
+};
+
+export const stopTokenRefreshScheduler = () => {
+  if (timerId !== null) {
+    window.clearInterval(timerId);
+    timerId = null;
+  }
+  document.removeEventListener("visibilitychange", onVisibilityChange);
+};
diff --git a/apps/edr-freight-web/portal/src/utils/result.ts b/apps/edr-freight-web/portal/src/utils/result.ts
index 3e9627445..54104442c 100644
--- a/apps/edr-freight-web/portal/src/utils/result.ts
+++ b/apps/edr-freight-web/portal/src/utils/result.ts
@@ -8,6 +8,32 @@ export type ApiError = {
   statusCode?: number;
 };
 
+/**
+ * Backend errors arrive as snake_case i18n-style codes (e.g.
+ * "unable_to_log_in"). Map the known ones to friendly copy and prettify
+ * anything else so raw codes never reach the UI. `code` stays raw for
+ * programmatic checks.
+ */
+const API_ERROR_MESSAGES: Record<string, string> = {
+  unable_to_log_in: "Incorrect email or password.",
+  invalid_refresh_token: "Your session has expired. Please sign in again.",
+  session_expired: "Your session has expired. Please sign in again.",
+  session_not_found: "Your session has expired. Please sign in again.",
+  user_not_found: "No account found for these credentials.",
+};
+
+const SNAKE_CASE_CODE = /^[a-z0-9]+(?:_[a-z0-9]+)+$/;
+
+function humanizeApiMessage(raw: string): string {
+  const known = API_ERROR_MESSAGES[raw];
+  if (known) return known;
+  if (SNAKE_CASE_CODE.test(raw)) {
+    const text = raw.replaceAll("_", " ");
+    return `${text.charAt(0).toUpperCase()}${text.slice(1)}.`;
+  }
+  return raw;
+}
+
 export function extractApiError(err: unknown): ApiError {
   if (err && typeof err === "object") {
     const obj = err as Record<string, unknown>;
@@ -16,8 +42,12 @@ export function extractApiError(err: unknown): ApiError {
       const statusCode = response.status as number | undefined;
       const data = response.data as Record<string, unknown> | undefined;
       return {
-        code: (data?.error as string) || (data?.message as string) || "api_error",
-        message: (data?.message as string) || (data?.error as string) || "An unexpected error occurred",
+        code: (data?.message as string) || (data?.error as string) || "api_error",
+        message: humanizeApiMessage(
+          (data?.message as string) ||
+            (data?.error as string) ||
+            "An unexpected error occurred",
+        ),
         statusCode,
       };
     }
diff --git a/apps/edr-passenger-api/src/app.module.ts b/apps/edr-passenger-api/src/app.module.ts
index 1e41076e7..59d73c55f 100644
--- a/apps/edr-passenger-api/src/app.module.ts
+++ b/apps/edr-passenger-api/src/app.module.ts
@@ -65,6 +65,8 @@ 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([
@@ -97,6 +99,16 @@ import { SegmentFareSeeder } from './seed/segment-fare.seeder';
     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.`,
+        [EOtpType.VERIFY_PHONE_NUMBER]: ({ otp }) =>
+            `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}`,
+        [EOtpType.SET_PASSWORD]: ({ route }) =>
+            `Set your EDR Passenger password using this link: ${route}`,
+      },
     }),
     SharedAuthModule,
     PrismaModule,
diff --git a/apps/edr-passenger-api/src/main.ts b/apps/edr-passenger-api/src/main.ts
index cbdae37e3..26f57e506 100644
--- a/apps/edr-passenger-api/src/main.ts
+++ b/apps/edr-passenger-api/src/main.ts
@@ -60,7 +60,7 @@ async function bootstrap() {
 Enterprise-grade REST API for the Ethio-Djibouti Railway passenger booking and management platform. Built with NestJS, TypeScript, PostgreSQL, and Prisma ORM.
 
 ## Latest Updates
-- **Enhanced Module Coverage:** Complete API coverage with 25+ core modules including System Config, Excess Baggage, Packages, and comprehensive CRUD operations across all entities.
+- **Enhanced Module Coverage:** Complete API coverage with 25+ core modules including System Config, Excess Luggage, Packages, and comprehensive CRUD operations across all entities.
 - **Health Check Endpoints:** Three public probes added under \`/health\`. Liveness (\`GET /health\`), readiness with live DB ping (\`GET /health/ready\`), and app info (\`GET /health/info\`). All are exempt from rate limiting.
 - **Rate Limiting:** Global throttle enforced via ThrottlerGuard with three named tiers: auth (5 req/min on \`/auth\` and \`/fayda/verification\`), strict (20 req/min on \`/bookings\`, \`/passengers\`, \`/payments\`, \`/wallet\`), default (100 req/min everywhere else). Health probes, webhook handlers, and internal service endpoints are exempt.
 - **Boarding Pass on Gate Validation:** Every successful gate validation at \`POST /tickets/:ref/validate\` now automatically delivers a boarding pass to the passenger via email (full HTML with QR code, route, seat table) and SMS (compact text with ref, route, seats, barcode). The leg label (OUTBOUND, RETURN, LEG1, etc.) is included so passengers know which boarding it covers.
@@ -328,7 +328,7 @@ Payment providers send notifications to:
       "JWT-auth",
     )
     .addTag("Agents", "Counter booking, shift management, commission tracking, and reconciliation")
-    .addTag("Excess Baggage", "IAM-protected agent/supervisor endpoints to log excess baggage charges, waive fees, resend payment links, and manage allowance rules per seat class. Public token-based endpoints let passengers self-pay outstanding charges.")
+    .addTag("Excess Luggage", "IAM-protected agent/supervisor endpoints to log excess baggage charges, waive fees, resend payment links, and manage allowance rules per seat class. Public token-based endpoints let passengers self-pay outstanding charges.")
     .addTag("Packages", "Bundled travel packages with tiered pricing. Public endpoints for browsing and booking; JWT-authenticated endpoints for purchase history; IAM-protected endpoints for admin CRUD and tier management.")
     .addTag("Config", "System-wide configuration management including feature flags, maintenance modes, and operational parameters. IAM-protected endpoints for administrative control.")
     .addTag("Audit", "User activity logging, system changes, compliance tracking, and audit trails")
diff --git a/apps/edr-passenger-api/src/modules/bookings/bookings.dto.ts b/apps/edr-passenger-api/src/modules/bookings/bookings.dto.ts
index 345cfc357..d50f48592 100644
--- a/apps/edr-passenger-api/src/modules/bookings/bookings.dto.ts
+++ b/apps/edr-passenger-api/src/modules/bookings/bookings.dto.ts
@@ -21,6 +21,8 @@ export class PassengerInputDto {
   @ApiPropertyOptional({ example: 'P1234567', description: 'Passport number for non-Ethiopian passengers (no verification)' }) @IsOptional() @IsString() passportNumber?: string;
   @ApiPropertyOptional({ example: 'Djibouti', description: 'Passport issuing country for non-Ethiopians' }) @IsOptional() @IsString() passportCountry?: string;
   @ApiPropertyOptional({ example: 'Ethiopian', description: 'Ethiopian (Verifayda + Telebirr/CBE/eBirr), Djiboutian (Passport + Waafi), Other (Passport + Card)' }) @IsOptional() @IsString() nationality?: string;
+  @ApiPropertyOptional({ example: 35000, description: 'Actual fare for this passenger in minor units (ETB). When provided, overrides the fare engine calculation — use for berth-specific pricing (Upper/Middle/Lower).' }) @IsOptional() @IsInt() seatFareMinor?: number;
+  @ApiPropertyOptional({ example: 35000, description: 'Return leg fare for this passenger in minor units (ETB). Used for ROUND_TRIP berth-specific pricing.' }) @IsOptional() @IsInt() returnSeatFareMinor?: number;
 }
 
 export class RoundTripPassengerDto {
@@ -143,6 +145,9 @@ export class CreateBookingDto {
   @ApiPropertyOptional({ description: 'Package price tier ID — required when packageId is provided' })
   @IsOptional() @IsString() priceTierId?: string;
 
+  @ApiPropertyOptional({ description: 'Total amount in minor units (ETB) as computed and displayed on the review page. When provided, this overrides the fare engine total — use to pass the exact berth-specific amount the user saw.' })
+  @IsOptional() @IsInt() reviewedTotalMinor?: number;
+
   @ApiPropertyOptional({ description: 'Promo code for discount (applies to combined fare for round-trip)' }) 
   @IsOptional() @IsString() promoCode?: string;
   
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 a2ea23e09..b784ea111 100644
--- a/apps/edr-passenger-api/src/modules/bookings/bookings.service.ts
+++ b/apps/edr-passenger-api/src/modules/bookings/bookings.service.ts
@@ -1,4 +1,4 @@
-import { Injectable, NotFoundException, BadRequestException } from '@nestjs/common';
+import { Injectable, NotFoundException, BadRequestException, Logger } from '@nestjs/common';
 import { InjectDataSource } from '@nestjs/typeorm';
 import { DataSource } from 'typeorm';
 import { PrismaService } from '../../common/prisma.service';
@@ -17,6 +17,7 @@ function generateRef(): string {
   return Array.from({ length: 6 }, () => chars[Math.floor(Math.random() * chars.length)]).join('');
 }
 
+
 /**
  * For package round-trip bookings, totalMinor in the DB may have been stored as a
  * single-leg amount before the server fix. Recompute from the tier price when needed.
@@ -59,6 +60,8 @@ interface BookingFilters {
 
 @Injectable()
 export class BookingsService {
+  private readonly logger = new Logger(BookingsService.name);
+
   constructor(
     private readonly prisma: PrismaService,
     @InjectDataSource() private readonly dataSource: DataSource,
@@ -545,30 +548,42 @@ export class BookingsService {
       : await this.calculateFare(dto.scheduleId, dto.seatClassId, originStop, destStop, passengersData[0]?.nationality, adultCount, childCount, dto.promoCode, dto.loyaltyRedemptionPoints);
     
     const displayCurrency = dto.displayCurrency || Currency.ETB;
-    let displayTotalMinor = fareCalculation.totalMinor;
-    if (displayCurrency !== Currency.ETB) {
-      displayTotalMinor = await this.currencyService.convertAmount(fareCalculation.totalMinor, Currency.ETB, displayCurrency);
-    }
 
-    // Track per-seat fare. For package bookings children pay 10% of adult fare;
-    // for regular bookings the first child is free.
+    // Track per-seat fare. Use the client-supplied seatFareMinor when present (berth-specific
+    // pricing for Upper/Middle/Lower beds). Fall back to the fare engine's baseFareMinor.
     let freeChildUsed = false;
+    let pkgChildIdx = 0;
     const passengersWithFares = passengersData.map(p => {
       let fareMinor: number;
       if (p.category === PassengerCategory.ADULT) {
-        fareMinor = fareCalculation.baseFareMinor;
+        fareMinor = p.seatFareMinor ?? fareCalculation.baseFareMinor;
       } else if (dto.packageId) {
-        // Free children (first per adult) get fareMinor=0; paid children pay full adult fare.
-        // passengersWithFares is built in adult-first order so we track paid children by count.
-        const childIdx = passengersWithFares.filter(x => x.category !== PassengerCategory.ADULT).length;
-        fareMinor = childIdx < adultCount ? 0 : fareCalculation.baseFareMinor;
+        fareMinor = pkgChildIdx < adultCount ? 0 : (p.seatFareMinor ?? fareCalculation.baseFareMinor);
+        pkgChildIdx++;
       } else {
         if (!freeChildUsed) { fareMinor = 0; freeChildUsed = true; }
-        else fareMinor = fareCalculation.baseFareMinor;
+        else fareMinor = p.seatFareMinor ?? fareCalculation.baseFareMinor;
       }
       return { ...p, fareMinor };
     });
 
+    // Use the sum of per-seat fares as the authoritative total when the client supplied
+    // seatFareMinor for every seat-holding passenger — this captures berth-specific pricing
+    // (Upper/Middle/Lower) that the fare engine cannot resolve from seatClassId alone.
+    // Free children have no seatId and no seatFareMinor — exclude them from the check.
+    const seatedPassengers = passengersData.filter(p => p.seatId);
+    const allFaresProvided = seatedPassengers.length > 0 && seatedPassengers.every(p => p.seatFareMinor != null);
+    const resolvedTotalMinor = dto.reviewedTotalMinor ??
+      (allFaresProvided
+        ? passengersWithFares.reduce((sum, p) => sum + p.fareMinor, 0)
+        : fareCalculation.totalMinor);
+    this.logger.log(`createOneWayBooking: resolvedTotalMinor=${resolvedTotalMinor} (reviewedTotalMinor=${dto.reviewedTotalMinor} allFaresProvided=${allFaresProvided} fareEngine=${fareCalculation.totalMinor})`);
+
+    let displayTotalMinor = resolvedTotalMinor;
+    if (displayCurrency !== Currency.ETB) {
+      displayTotalMinor = await this.currencyService.convertAmount(resolvedTotalMinor, Currency.ETB, displayCurrency);
+    }
+
     const booking = await this.prisma.booking.create({
       data: {
         bookingRef: generateRef(),
@@ -576,7 +591,7 @@ export class BookingsService {
         scheduleId: dto.scheduleId,
         status: 'PENDING_PAYMENT',
         bookingType: 'ONE_WAY',
-        totalMinor: fareCalculation.totalMinor,
+        totalMinor: resolvedTotalMinor / 100,
         adultCount,
         childCount,
         displayCurrency,
@@ -696,8 +711,8 @@ export class BookingsService {
       displayTotalMinor = await this.currencyService.convertAmount(totalMinor, Currency.ETB, displayCurrency);
     }
 
-    // Track per-seat fare. For package bookings children pay 10% of adult fare;
-    // for regular bookings the first child is free per leg.
+    // Track per-seat fare. Use client-supplied seatFareMinor/returnSeatFareMinor when
+    // present (berth-specific pricing). Fall back to fare engine values.
     let outboundFreeChildUsed = false;
     let returnFreeChildUsed = false;
     const passengersWithFares = passengersData.map(p => {
@@ -705,24 +720,40 @@ export class BookingsService {
       let returnFareMinor: number;
 
       if (p.category === PassengerCategory.ADULT) {
-        outboundFareMinor = outboundFare.baseFareMinor;
-        returnFareMinor = returnFare.baseFareMinor;
+        outboundFareMinor = p.seatFareMinor ?? outboundFare.baseFareMinor;
+        returnFareMinor   = p.returnSeatFareMinor ?? returnFare.baseFareMinor;
       } else if (dto.packageId) {
-        // Free children (first per adult) get fareMinor=0; paid children pay full adult fare.
-        const childIdx = passengersWithFares.filter(x => x.category !== PassengerCategory.ADULT).length;
-        const isFreeChild = childIdx < adultCount;
-        outboundFareMinor = isFreeChild ? 0 : outboundFare.baseFareMinor;
-        returnFareMinor   = isFreeChild ? 0 : returnFare.baseFareMinor;
+        outboundFareMinor = 0;
+        returnFareMinor   = 0;
       } else {
         if (!outboundFreeChildUsed) { outboundFareMinor = 0; outboundFreeChildUsed = true; }
-        else outboundFareMinor = outboundFare.baseFareMinor;
+        else outboundFareMinor = p.seatFareMinor ?? outboundFare.baseFareMinor;
         if (!returnFreeChildUsed)   { returnFareMinor   = 0; returnFreeChildUsed   = true; }
-        else returnFareMinor   = returnFare.baseFareMinor;
+        else returnFareMinor   = p.returnSeatFareMinor ?? returnFare.baseFareMinor;
       }
 
       return { ...p, outboundFareMinor, returnFareMinor };
     });
 
+    // Override totalMinor with the sum of actual per-seat fares when all seated passengers
+    // supplied their fares — free children (no seatId) are excluded from the check.
+    const rtSeatedPassengers = passengersData.filter(p => p.outboundSeatId);
+    const allRTFaresProvided = rtSeatedPassengers.length > 0 &&
+      rtSeatedPassengers.every(p => p.seatFareMinor != null && p.returnSeatFareMinor != null);
+    if (dto.reviewedTotalMinor) {
+      totalMinor = dto.reviewedTotalMinor;
+      displayTotalMinor = displayCurrency !== Currency.ETB
+        ? await this.currencyService.convertAmount(totalMinor, Currency.ETB, displayCurrency)
+        : totalMinor;
+    } else if (allRTFaresProvided && !dto.packageId) {
+      totalMinor = passengersWithFares.reduce((sum, p) => sum + p.outboundFareMinor + p.returnFareMinor, 0);
+      if (displayCurrency !== Currency.ETB) {
+        displayTotalMinor = await this.currencyService.convertAmount(totalMinor, Currency.ETB, displayCurrency);
+      } else {
+        displayTotalMinor = totalMinor;
+      }
+    }
+
     const booking = await this.prisma.booking.create({
       data: {
         bookingRef: generateRef(),
diff --git a/apps/edr-passenger-api/src/modules/bookings/guest-booking.dto.ts b/apps/edr-passenger-api/src/modules/bookings/guest-booking.dto.ts
index c2acaeece..f5a5559bb 100644
--- a/apps/edr-passenger-api/src/modules/bookings/guest-booking.dto.ts
+++ b/apps/edr-passenger-api/src/modules/bookings/guest-booking.dto.ts
@@ -1,4 +1,4 @@
-import { IsString, IsArray, ValidateNested, IsOptional, IsEnum, IsDateString, IsBoolean } from 'class-validator';
+import { IsString, IsArray, ValidateNested, IsOptional, IsEnum, IsDateString, IsBoolean, IsInt } from 'class-validator';
 import { Type } from 'class-transformer';
 import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
 import { Currency, IdDocumentType } from '@prisma/client';
@@ -42,6 +42,12 @@ export class GuestPassengerDto {
 
   @ApiPropertyOptional({ example: 'abebe@email.com', description: 'Contact email' }) 
   @IsOptional() @IsString() email?: string;
+
+  @ApiPropertyOptional({ example: 35000, description: 'Actual fare for this passenger in minor units (ETB). Overrides fare engine — use for berth-specific pricing (Upper/Middle/Lower).' })
+  @IsOptional() @IsInt() seatFareMinor?: number;
+
+  @ApiPropertyOptional({ example: 35000, description: 'Return leg fare for this passenger in minor units (ETB). Used for ROUND_TRIP berth-specific pricing.' })
+  @IsOptional() @IsInt() returnSeatFareMinor?: number;
 }
 
 export class CreateGuestBookingDto {
@@ -150,6 +156,9 @@ export class CreateGuestBookingDto {
 
   @ApiPropertyOptional({ description: 'Package price tier ID — required when packageId is provided' })
   @IsOptional() @IsString() priceTierId?: string;
+
+  @ApiPropertyOptional({ description: 'Total amount in minor units (ETB) as computed and displayed on the review page. When provided, overrides the fare engine total — use to pass the exact berth-specific amount the user saw.' })
+  @IsOptional() @IsInt() reviewedTotalMinor?: number;
 }
 
 export class SavedPassengerProfileDto {
diff --git a/apps/edr-passenger-api/src/modules/bookings/guest-booking.service.ts b/apps/edr-passenger-api/src/modules/bookings/guest-booking.service.ts
index 1025a42b3..fb218e052 100644
--- a/apps/edr-passenger-api/src/modules/bookings/guest-booking.service.ts
+++ b/apps/edr-passenger-api/src/modules/bookings/guest-booking.service.ts
@@ -14,7 +14,7 @@ const BOOKING_CUTOFF_MS = 30 * 60 * 1000;
 
 function generateRef(): string {
   const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
-  return 'EDR-' + Array.from({ length: 6 }, () => chars[Math.floor(Math.random() * chars.length)]).join('');
+  return Array.from({ length: 6 }, () => chars[Math.floor(Math.random() * chars.length)]).join('');
 }
 
 // Ethiopian mobile prefixes: Ethio Telecom (09xx) and Safaricom ET (07xx)
@@ -185,12 +185,38 @@ export class GuestBookingService {
     }
 
     const taxesMinor = 0;
-    const totalMinor = Math.max(0, totalBaseFareMinor - discountMinor);
+
+    // Per-seat fare: use client-supplied seatFareMinor when present (berth-specific pricing).
+    // Free children (first child, non-package) get fareMinor=0.
+    let freeChildUsed = false;
+    let pkgChildIdx = 0;
+    const passengersWithFares = passengersData.map(p => {
+      let fareMinor: number;
+      if (p.category === PassengerCategory.ADULT) {
+        fareMinor = p.seatFareMinor ?? baseFareMinor;
+      } else if (isPackageOneway) {
+        fareMinor = pkgChildIdx < adultCount ? 0 : (p.seatFareMinor ?? childUnitFare);
+        pkgChildIdx++;
+      } else {
+        if (!freeChildUsed) { fareMinor = 0; freeChildUsed = true; }
+        else fareMinor = p.seatFareMinor ?? childUnitFare;
+      }
+      return { ...p, fareMinor };
+    });
+
+    // Use reviewedTotalMinor from frontend as authoritative total when provided.
+    // Fall back to per-seat sum when all seated passengers supplied seatFareMinor.
+    const seatedPassengers = passengersData.filter(p => p.seatId);
+    const allFaresProvided = seatedPassengers.length > 0 && seatedPassengers.every(p => p.seatFareMinor != null);
+    const resolvedTotalMinor = dto.reviewedTotalMinor ??
+      (allFaresProvided
+        ? passengersWithFares.reduce((sum, p) => sum + p.fareMinor, 0)
+        : Math.max(0, totalBaseFareMinor - discountMinor));
 
     const displayCurrency = dto.displayCurrency || Currency.ETB;
-    let displayTotalMinor = totalMinor;
+    let displayTotalMinor = resolvedTotalMinor;
     if (displayCurrency !== Currency.ETB) {
-      displayTotalMinor = await this.currencyService.convertAmount(totalMinor, Currency.ETB, displayCurrency);
+      displayTotalMinor = await this.currencyService.convertAmount(resolvedTotalMinor, Currency.ETB, displayCurrency);
     }
 
     // Resolve or create the guest Passenger record
@@ -224,7 +250,7 @@ export class GuestBookingService {
         passengerId: guestPassengerId,
         scheduleId: dto.scheduleId,
         status: 'PENDING_PAYMENT',
-        totalMinor,
+        totalMinor: resolvedTotalMinor,
         adultCount,
         childCount,
         displayCurrency,
@@ -235,7 +261,7 @@ export class GuestBookingService {
         contactEmail: firstPassenger.email || null,
         contactPhone: firstPassenger.phone || null,
         seats: {
-          create: passengersData.map((p) => ({
+          create: passengersWithFares.map((p) => ({
             seat: { connect: { id: p.seatId } },
             passengerName: p.passengerName,
             dateOfBirth: p.dateOfBirth,
@@ -245,7 +271,7 @@ export class GuestBookingService {
             passportCountry: p.passportCountry,
             verifaydaVerified: p.verifaydaVerified,
             verifaydaData: p.verifaydaData || undefined,
-            fareMinor: p.category === PassengerCategory.ADULT ? baseFareMinor : childUnitFare,
+            fareMinor: p.fareMinor,
             displayCurrency,
           })),
         },
@@ -278,7 +304,7 @@ export class GuestBookingService {
         totalBaseFareMinor,
         discountMinor,
         taxesFeesMinor: taxesMinor,
-        totalMinor,
+        totalMinor: resolvedTotalMinor,
         currency: 'ETB',
         displayCurrency,
         displayTotalMinor,
@@ -423,13 +449,51 @@ export class GuestBookingService {
     }
 
     const taxesMinor = 0;
-    const totalMinor = Math.max(0, combinedBaseFareMinor - discountMinor);
+    let totalMinor = Math.max(0, combinedBaseFareMinor - discountMinor);
 
     const displayCurrency = dto.displayCurrency || Currency.ETB;
-    const displayTotalMinor = displayCurrency !== Currency.ETB
+    let displayTotalMinor = displayCurrency !== Currency.ETB
       ? await this.currencyService.convertAmount(totalMinor, Currency.ETB, displayCurrency)
       : totalMinor;
 
+    // Per-seat fares: use client-supplied seatFareMinor/returnSeatFareMinor when present.
+    let outboundFreeChildUsed = false;
+    let returnFreeChildUsed = false;
+    const passengersWithFares = passengersData.map(p => {
+      let outboundFareMinor: number;
+      let returnFareMinor: number;
+      if (p.category === PassengerCategory.ADULT) {
+        outboundFareMinor = p.seatFareMinor       ?? outboundBaseFare;
+        returnFareMinor   = p.returnSeatFareMinor ?? returnBaseFare;
+      } else if (isPackageRoundTrip) {
+        outboundFareMinor = 0;
+        returnFareMinor   = 0;
+      } else {
+        if (!outboundFreeChildUsed) { outboundFareMinor = 0; outboundFreeChildUsed = true; }
+        else outboundFareMinor = p.seatFareMinor ?? outboundChildUnitFare;
+        if (!returnFreeChildUsed)   { returnFareMinor   = 0; returnFreeChildUsed   = true; }
+        else returnFareMinor   = p.returnSeatFareMinor ?? returnChildUnitFare;
+      }
+      return { ...p, outboundFareMinor, returnFareMinor };
+    });
+
+    // Override totalMinor with reviewedTotalMinor when provided, or sum of per-seat fares
+    // when all seated passengers supplied their fares.
+    const rtSeatedPassengers = passengersData.filter(p => p.seatId);
+    const allRTFaresProvided = rtSeatedPassengers.length > 0 &&
+      rtSeatedPassengers.every(p => p.seatFareMinor != null && p.returnSeatFareMinor != null);
+    if (dto.reviewedTotalMinor) {
+      totalMinor = dto.reviewedTotalMinor;
+      displayTotalMinor = displayCurrency !== Currency.ETB
+        ? await this.currencyService.convertAmount(totalMinor, Currency.ETB, displayCurrency)
+        : totalMinor;
+    } else if (allRTFaresProvided && !isPackageRoundTrip) {
+      totalMinor = passengersWithFares.reduce((sum, p) => sum + p.outboundFareMinor + p.returnFareMinor, 0);
+      displayTotalMinor = displayCurrency !== Currency.ETB
+        ? await this.currencyService.convertAmount(totalMinor, Currency.ETB, displayCurrency)
+        : totalMinor;
+    }
+
     // Create or resolve guest passenger (same as one-way)
     const { guestPassengerId, iamUserId, createdAccount } = await this.resolveGuestPassenger(dto, passengersData[0], req);
 
@@ -461,7 +525,7 @@ export class GuestBookingService {
         contactPhone:                passengersData[0]?.phone || null,
         seats: {
           create: [
-            ...passengersData.map((p) => ({
+            ...passengersWithFares.map((p) => ({
               seat:              { connect: { id: p.seatId } },
               leg:               1,
               scheduleId:        dto.scheduleId,
@@ -473,10 +537,10 @@ export class GuestBookingService {
               passportCountry:   p.passportCountry,
               verifaydaVerified: p.verifaydaVerified,
               verifaydaData:     p.verifaydaData || undefined,
-              fareMinor:         p.category === PassengerCategory.ADULT ? outboundBaseFare : outboundChildUnitFare,
+              fareMinor:         p.outboundFareMinor,
               displayCurrency,
             })),
-            ...passengersData.map((p) => ({
+            ...passengersWithFares.map((p) => ({
               seat:              { connect: { id: p.returnSeatId } },
               leg:               2,
               scheduleId:        dto.returnScheduleId,
@@ -488,7 +552,7 @@ export class GuestBookingService {
               passportCountry:   p.passportCountry,
               verifaydaVerified: p.verifaydaVerified,
               verifaydaData:     p.verifaydaData || undefined,
-              fareMinor:         p.category === PassengerCategory.ADULT ? returnBaseFare : returnChildUnitFare,
+              fareMinor:         p.returnFareMinor,
               displayCurrency,
             })),
           ],
diff --git a/apps/edr-passenger-api/src/modules/currency/currency.service.ts b/apps/edr-passenger-api/src/modules/currency/currency.service.ts
index 4666d4aaa..304add11c 100644
--- a/apps/edr-passenger-api/src/modules/currency/currency.service.ts
+++ b/apps/edr-passenger-api/src/modules/currency/currency.service.ts
@@ -30,23 +30,59 @@ export class CurrencyService {
     private readonly configService: ConfigService,
   ) {}
 
+  /**
+   * Converts a stored display-currency minor amount to the charge major amount
+   * sent to the payment provider, without hitting the DB for an exchange rate.
+   * Use this when the payment method's settlement currency matches the booking's
+   * displayCurrency — the rate is already baked into displayTotalMinor.
+   */
+  displayMinorToChargeMajor(displayMinor: number, currency: string): number {
+    const decimals = CHARGE_CURRENCY_DECIMALS[currency.toUpperCase()];
+    if (decimals === undefined) {
+      throw new BadRequestException(`Unsupported charge currency: ${currency}`);
+    }
+    return this.roundTo(displayMinor / 100, decimals);
+  }
+
+  async convertEtbMinorToChargeMinor(
+    amountMinorEtb: number,
+    targetCurrency: string,
+  ): Promise<number> {
+    const target = targetCurrency.toUpperCase();
+    if (CHARGE_CURRENCY_DECIMALS[target] === undefined) {
+      throw new BadRequestException(`Unsupported charge currency: ${targetCurrency}`);
+    }
+
+    if (target === Currency.ETB) {
+      return amountMinorEtb;
+    }
+
+    // Convert ETB minor → target minor: apply exchange rate, keep as minor units.
+    const rate = await this.getRateOrThrow(Currency.ETB, target as Currency);
+    return Math.round(amountMinorEtb * rate);
+  }
+
+  /**
+   * Converts an ETB minor-unit amount to the charge major-unit amount sent to the
+   * payment provider. Applies the exchange rate for foreign currencies then divides
+   * by 100 to yield major units (e.g. 300000 ETB minor → 3000.00 ETB major).
+   */
   async convertEtbMinorToChargeMajor(
     amountMinorEtb: number,
     targetCurrency: string,
   ): Promise<number> {
     const target = targetCurrency.toUpperCase();
-    const decimals = CHARGE_CURRENCY_DECIMALS[target];
-    if (decimals === undefined) {
+    if (CHARGE_CURRENCY_DECIMALS[target] === undefined) {
       throw new BadRequestException(`Unsupported charge currency: ${targetCurrency}`);
     }
+    const decimals = CHARGE_CURRENCY_DECIMALS[target];
 
-    const sourceMajor = amountMinorEtb / 100;
     if (target === Currency.ETB) {
-      return this.roundTo(sourceMajor, decimals);
+      return this.roundTo(amountMinorEtb / 100, decimals);
     }
 
     const rate = await this.getRateOrThrow(Currency.ETB, target as Currency);
-    return this.roundTo(sourceMajor * rate, decimals);
+    return this.roundTo((amountMinorEtb * rate) / 100, decimals);
   }
 
   async getRateOrThrow(
diff --git a/apps/edr-passenger-api/src/modules/excess-baggage/excess-baggage.controller.ts b/apps/edr-passenger-api/src/modules/excess-baggage/excess-baggage.controller.ts
index e65a6be68..8d01e7113 100644
--- a/apps/edr-passenger-api/src/modules/excess-baggage/excess-baggage.controller.ts
+++ b/apps/edr-passenger-api/src/modules/excess-baggage/excess-baggage.controller.ts
@@ -17,7 +17,7 @@ class UpsertBaggageAllowanceDto {
 }
 
 // ── IAM-protected agent/supervisor routes ────────────────────────────────────
-@ApiTags('Excess Baggage')
+@ApiTags('Excess Luggage')
 @Controller('agents/excess-baggage')
 @UseGuards(IamJwtGuard)
 @ApiBearerAuth('IAM-auth')
@@ -100,7 +100,7 @@ export class ExcessBaggageAgentController {
 }
 
 // ── Public pay-by-token routes (passenger self-service) ──────────────────────
-@ApiTags('Excess Baggage')
+@ApiTags('Excess Luggage')
 @Controller('excess-baggage')
 export class ExcessBaggagePublicController {
   constructor(private service: ExcessBaggageService) {}
diff --git a/apps/edr-passenger-api/src/modules/fare-engine/fare-engine.service.ts b/apps/edr-passenger-api/src/modules/fare-engine/fare-engine.service.ts
index 70f18564d..dd4e15b9c 100644
--- a/apps/edr-passenger-api/src/modules/fare-engine/fare-engine.service.ts
+++ b/apps/edr-passenger-api/src/modules/fare-engine/fare-engine.service.ts
@@ -30,13 +30,10 @@ export class FareEngineService {
     if (!seatClass) throw new NotFoundException('Seat class not found');
     if (!seatClass.isActive) throw new BadRequestException('Seat class is not active');
 
-    // Resolve nationality type: Ethiopian and Djiboutian are LOCAL, everyone else INTERNATIONAL
     const nationalityUpper = (dto.nationality ?? '').toUpperCase();
     const nationalityType = (nationalityUpper === 'ETHIOPIAN' || nationalityUpper === 'DJIBOUTIAN')
       ? 'LOCAL' : 'INTERNATIONAL';
 
-    // Find the nationality-specific seat class for the same coach type and bed position.
-    // Falls back to the requested seatClass if no nationality-specific one exists.
     const nationalitySeatClass = await this.prisma.seatClass.findFirst({
       where: {
         coachTypeId: seatClass.coachTypeId,
@@ -46,13 +43,10 @@ export class FareEngineService {
       },
     }) ?? seatClass;
 
-    // Calculate distance: distanceKm represents cumulative distance from route origin
-    // For a segment, distance = destination.distanceKm - origin.distanceKm
     const totalDistanceKm = destStop.distanceKm! - originStop.distanceKm!;
     if (totalDistanceKm < 0 || isNaN(totalDistanceKm))
       throw new BadRequestException('Invalid distance calculation - check route stop distances');
 
-    // Resolve fare: FareRule (schedule-scoped → route-scoped) takes precedence over distance×rate
     const now = new Date();
     const [originStation, destStation] = await Promise.all([
       this.prisma.station.findUnique({ where: { id: dto.originStationId } }),
@@ -81,8 +75,12 @@ export class FareEngineService {
     let baseFarePerPassengerMinor: number;
     let ratePerKmMinor: number;
     let fareSource: string;
+    let insuranceFactor = 1;
+    let usdToEtbRate = 1;
+    // When insuranceFeeMinor is used as a multiplier in the formula it must not
+    // be added again as a flat fee. This flag tracks that.
+    let insuranceAlreadyInBase = false;
 
-    // 1. Segment override: exact origin→destination stop pair on this route
     const segmentOverride = await this.prisma.segmentFareRule.findFirst({
       where: {
         routeId: route.id,
@@ -106,39 +104,52 @@ export class FareEngineService {
     });
 
     if (segmentOverride) {
-      // Flat override for this exact segment — baseFareMinor is the total base, not a per-km rate
       baseFarePerPassengerMinor = segmentOverride.baseFareMinor;
+      if (nationalityType === 'INTERNATIONAL' && !segmentOverride.nationality) {
+        baseFarePerPassengerMinor *= 2;
+      }
       ratePerKmMinor = totalDistanceKm > 0 ? Math.round(baseFarePerPassengerMinor / totalDistanceKm) : 0;
       fareSource = 'SEGMENT_FARE_RULE';
     } else if (fareRule?.tripId) {
-      // Schedule-scoped flat override
       baseFarePerPassengerMinor = fareRule.baseFareMinor;
+      if (nationalityType === 'INTERNATIONAL' && !fareRule.nationality) {
+        baseFarePerPassengerMinor *= 2;
+      }
       ratePerKmMinor = totalDistanceKm > 0 ? Math.round(baseFarePerPassengerMinor / totalDistanceKm) : 0;
       fareSource = 'SCHEDULE_FARE_RULE';
     } else {
-      // Default: distance-based using tariff formula: km × rate × 1.02
-      // baseFareMinor stores the per-km rate (tariff decimal × 100000)
+      // Distance-based formula:
+      //   baseFare (minor) = distanceKm × (baseFareMinor / 100) × insuranceFactor × usdToEtbRate
+      // baseFareMinor stored as integer (e.g. 300 = 3.00 ETB/km), divided by 100 to get ETB/km.
+      // insuranceFeeMinor stored as integer (e.g. 102 = 1.02 multiplier), divided by 100; defaults to 1 if unset.
+      // usdToEtbRate fetched live from CurrencyExchangeRate table.
+      // Insurance is already baked into baseFarePerPassengerMinor — do NOT add it again as a flat fee.
+      const ratePerKmEtb = nationalitySeatClass.baseFareMinor / 100;
+      insuranceFactor = nationalitySeatClass.insuranceFeeMinor > 0
+        ? nationalitySeatClass.insuranceFeeMinor / 100
+        : 1;
+      usdToEtbRate = await this.currencyService.getExchangeRate(Currency.USD, Currency.ETB);
       ratePerKmMinor = nationalitySeatClass.baseFareMinor;
-      baseFarePerPassengerMinor = Math.round(ratePerKmMinor * totalDistanceKm * 1.02);
+      baseFarePerPassengerMinor = Math.round(
+        totalDistanceKm * ratePerKmEtb * insuranceFactor * usdToEtbRate,
+      );
       fareSource = 'SEAT_CLASS_BASE_FARE';
+      insuranceAlreadyInBase = true;
     }
 
-    // Premium and insurance fees applied per passenger
-    const premiumPerPassenger = seatClass.premiumMinor ?? 0;
-    const insurancePerPassenger = seatClass.insuranceFeeMinor ?? 0;
-    const farePerPassengerMinor = baseFarePerPassengerMinor + premiumPerPassenger + insurancePerPassenger;
+    const premiumPerPassenger    = seatClass.premiumMinor ?? 0;
+    const insurancePerPassenger  = insuranceAlreadyInBase ? 0 : (seatClass.insuranceFeeMinor ?? 0);
+    const farePerPassengerMinor  = baseFarePerPassengerMinor + premiumPerPassenger + insurancePerPassenger;
 
     const adultCount        = dto.adultCount ?? 1;
     const childCount        = dto.childCount ?? 0;
     const freeChildrenCount = Math.min(childCount, adultCount);
     const paidChildrenCount = Math.max(0, childCount - freeChildrenCount);
 
-    // Subtotal includes: (distance-based fare + premium + insurance) × passengers
-    // First child is free, but pays premium and insurance
-    const adultSubtotal = farePerPassengerMinor * adultCount;
+    const adultSubtotal     = farePerPassengerMinor * adultCount;
     const freeChildSubtotal = (premiumPerPassenger + insurancePerPassenger) * freeChildrenCount;
     const paidChildSubtotal = farePerPassengerMinor * paidChildrenCount;
-    const subtotalMinor = adultSubtotal + freeChildSubtotal + paidChildSubtotal;
+    const subtotalMinor     = adultSubtotal + freeChildSubtotal + paidChildSubtotal;
 
     let discountMinor = 0;
     let promoLabel = 'none';
@@ -152,8 +163,7 @@ export class FareEngineService {
       }
     }
 
-    const afterDiscountMinor = subtotalMinor - discountMinor;
-    const totalEtbMinor = afterDiscountMinor;
+    const totalEtbMinor = subtotalMinor - discountMinor;
 
     const billingCurrency = resolveCurrencyFromNationality(dto.nationality);
     const exchangeRate    = await this.currencyService.getExchangeRate(Currency.ETB, billingCurrency);
@@ -161,9 +171,11 @@ export class FareEngineService {
 
     const calculation = [
       `Distance:       ${totalDistanceKm} km (${originStation?.name} → ${destStation?.name})`,
-      `Nationality:    ${dto.nationality ?? 'unspecified'} → ${nationalityType} → ${nationalitySeatClass.name}`,
-      `Rate per km:    ${ratePerKmMinor} ETB minor (${nationalitySeatClass.name})`,
-      `Base fare/pax:  ${totalDistanceKm} km × ${ratePerKmMinor} × 1.02 = ${baseFarePerPassengerMinor} ETB minor`,
+      `Nationality:    ${dto.nationality ?? 'unspecified'} → ${nationalityType}${nationalityType === 'INTERNATIONAL' ? ' (2× surcharge applied)' : ''} → ${nationalitySeatClass.name}`,
+      `Rate per km:    ${nationalitySeatClass.baseFareMinor} minor → ${nationalitySeatClass.baseFareMinor / 100} ETB/km`,
+      `Insurance:      ${nationalitySeatClass.insuranceFeeMinor} minor → factor ${insuranceFactor}${insuranceAlreadyInBase ? ' (baked into base fare)' : ''}`,
+      `USD→ETB rate:   ${usdToEtbRate}`,
+      `Base fare/pax:  ${totalDistanceKm} km × (${nationalitySeatClass.baseFareMinor} / 100) × ${insuranceFactor} × ${usdToEtbRate} = ${baseFarePerPassengerMinor} ETB minor`,
       `Premium/pax:    ${premiumPerPassenger} ETB minor`,
       `Insurance/pax:  ${insurancePerPassenger} ETB minor`,
       `Total fare/pax: ${farePerPassengerMinor} ETB minor`,
@@ -191,6 +203,8 @@ export class FareEngineService {
       seatClassName: nationalitySeatClass.name,
       totalDistanceKm,
       ratePerKmMinor,
+      insuranceFactor,
+      usdToEtbRate,
       baseFarePerPassengerMinor,
       premiumPerPassenger,
       insurancePerPassenger,
@@ -323,19 +337,16 @@ export class FareEngineService {
     if (fareRules.length > 0) {
       const billingCurrency = resolveCurrencyFromNationality(nationality);
       const exchangeRate = await this.currencyService.getExchangeRate(Currency.ETB, billingCurrency);
-      return fareRules.map(rule => {
-        const seatClassId = rule.seatClassId;
-        return {
-          seatClassId,
-          seatClassName: 'Unknown',
-          baseFareMinor: rule.baseFareMinor,
-          totalMinor: rule.baseFareMinor,
-          billingCurrency,
-          totalInBillingCurrency: Math.round(rule.baseFareMinor * exchangeRate),
-          exchangeRate,
-          source: 'FARE_RULE',
-        };
-      });
+      return fareRules.map(rule => ({
+        seatClassId: rule.seatClassId,
+        seatClassName: 'Unknown',
+        baseFareMinor: rule.baseFareMinor,
+        totalMinor: rule.baseFareMinor,
+        billingCurrency,
+        totalInBillingCurrency: Math.round(rule.baseFareMinor * exchangeRate),
+        exchangeRate,
+        source: 'FARE_RULE',
+      }));
     }
 
     throw new BadRequestException(
diff --git a/apps/edr-passenger-api/src/modules/notifications/notifications.controller.ts b/apps/edr-passenger-api/src/modules/notifications/notifications.controller.ts
index f27bd8ecd..99ce32b08 100644
--- a/apps/edr-passenger-api/src/modules/notifications/notifications.controller.ts
+++ b/apps/edr-passenger-api/src/modules/notifications/notifications.controller.ts
@@ -4,7 +4,7 @@ import { NotificationsService } from './notifications.service';
 import { JwtGuard } from '../../common/jwt.guard';
 import { PassengerStaff } from '../../common/passenger-guards';
 import { PASSENGER_PERMS } from '../../seed/passenger-permissions.registry';
-import { TestNotificationDto } from './notifications.dto';
+import { TestNotificationDto, CreateTemplateDto, UpdateTemplateDto } from './notifications.dto';
 import { EmailClientService } from './email-client.service';
 import { SmsClientService } from './sms-client.service';
 import { SendEmail } from './dtos/email.dto';
@@ -21,6 +21,39 @@ export class NotificationsController {
     private smsClient: SmsClientService,
   ) {}
 
+  // --- Template management (declared before the ':passengerId' catch-all so the
+  // static 'templates' segment isn't captured as a passenger id) ---
+
+  @Get('templates')
+  @PassengerStaff([PASSENGER_PERMS.notifications.send, PASSENGER_PERMS.admin])
+  @ApiOperation({ summary: 'List notification templates' })
+  listTemplates() {
+    return this.service.listTemplates();
+  }
+
+  @Get('templates/:id')
+  @PassengerStaff([PASSENGER_PERMS.notifications.send, PASSENGER_PERMS.admin])
+  @ApiOperation({ summary: 'Get a notification template' })
+  getTemplate(@Param('id') id: string) {
+    return this.service.getTemplate(id);
+  }
+
+  @Post('templates')
+  @PassengerStaff([PASSENGER_PERMS.notifications.send, PASSENGER_PERMS.admin])
+  @ApiOperation({ summary: 'Create a notification template' })
+  @ApiBody({ type: CreateTemplateDto })
+  createTemplate(@Body() dto: CreateTemplateDto) {
+    return this.service.createTemplate(dto);
+  }
+
+  @Patch('templates/:id')
+  @PassengerStaff([PASSENGER_PERMS.notifications.send, PASSENGER_PERMS.admin])
+  @ApiOperation({ summary: 'Update a notification template (code is immutable)' })
+  @ApiBody({ type: UpdateTemplateDto })
+  updateTemplate(@Param('id') id: string, @Body() dto: UpdateTemplateDto) {
+    return this.service.updateTemplate(id, dto);
+  }
+
   @Get(':passengerId')
   @ApiOperation({ summary: 'Get notifications for passenger' })
   getForPassenger(@Param('passengerId') id: string) {
diff --git a/apps/edr-passenger-api/src/modules/notifications/notifications.dto.ts b/apps/edr-passenger-api/src/modules/notifications/notifications.dto.ts
index e55535a2a..4b2050de1 100644
--- a/apps/edr-passenger-api/src/modules/notifications/notifications.dto.ts
+++ b/apps/edr-passenger-api/src/modules/notifications/notifications.dto.ts
@@ -1,6 +1,10 @@
-import { IsString, IsEnum, IsOptional, IsArray } from 'class-validator';
+import { IsString, IsEnum, IsOptional, IsArray, IsBoolean, Matches } from 'class-validator';
 import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
 
+/** A single channel, or a comma-separated list of them (e.g. "SMS,EMAIL"). */
+const CHANNEL_LIST_RE = /^(EMAIL|SMS|PUSH|IN_APP)(,(EMAIL|SMS|PUSH|IN_APP))*$/;
+const CHANNEL_MSG = 'channel must be a comma-separated list of EMAIL, SMS, PUSH, IN_APP';
+
 export enum NotificationCategoryEnum {
   BOOKING = 'BOOKING',
   PAYMENT = 'PAYMENT',
@@ -18,6 +22,55 @@ export class SendNotificationDto {
   @ApiPropertyOptional() @IsOptional() metadata?: Record<string, any>;
 }
 
+export class CreateTemplateDto {
+  @ApiProperty({ example: 'booking.created', description: 'Unique template code / event key' })
+  @IsString()
+  code: string;
+
+  @ApiProperty({ example: 'SMS,EMAIL', description: 'Comma-separated channels: EMAIL, SMS, PUSH, IN_APP' })
+  @IsString()
+  @Matches(CHANNEL_LIST_RE, { message: CHANNEL_MSG })
+  channel: string;
+
+  @ApiPropertyOptional({ example: 'Your train ticket is booked' })
+  @IsOptional()
+  @IsString()
+  subject?: string;
+
+  @ApiProperty({ example: 'Dear {{passengerName}}, your booking {{bookingRef}} is booked.' })
+  @IsString()
+  bodyTemplate: string;
+
+  @ApiPropertyOptional({ example: true, description: 'Defaults to true' })
+  @IsOptional()
+  @IsBoolean()
+  active?: boolean;
+}
+
+// `code` is intentionally omitted — it is the immutable event key and cannot be changed.
+export class UpdateTemplateDto {
+  @ApiPropertyOptional({ example: 'SMS,EMAIL' })
+  @IsOptional()
+  @IsString()
+  @Matches(CHANNEL_LIST_RE, { message: CHANNEL_MSG })
+  channel?: string;
+
+  @ApiPropertyOptional({ example: 'Your train ticket is booked' })
+  @IsOptional()
+  @IsString()
+  subject?: string;
+
+  @ApiPropertyOptional({ example: 'Dear {{passengerName}}, ...' })
+  @IsOptional()
+  @IsString()
+  bodyTemplate?: string;
+
+  @ApiPropertyOptional({ example: true })
+  @IsOptional()
+  @IsBoolean()
+  active?: boolean;
+}
+
 export class TestNotificationDto {
   @ApiProperty({ example: 'booking.created' })
   @IsString()
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 43d1e4d46..fc8bffa27 100644
--- a/apps/edr-passenger-api/src/modules/notifications/notifications.service.ts
+++ b/apps/edr-passenger-api/src/modules/notifications/notifications.service.ts
@@ -1,4 +1,4 @@
-import { Injectable, Logger } from '@nestjs/common';
+import { Injectable, Logger, NotFoundException, ConflictException } from '@nestjs/common';
 import { OnEvent } from '@nestjs/event-emitter';
 import { InjectDataSource } from '@nestjs/typeorm';
 import { DataSource } from 'typeorm';
@@ -6,6 +6,7 @@ import { PrismaService } from '../../common/prisma.service';
 import { PushAdapter, NotificationChannel } from './notification.adapters';
 import { EmailClientService } from './email-client.service';
 import { SmsClientService } from './sms-client.service';
+import { CreateTemplateDto, UpdateTemplateDto } from './notifications.dto';
 
 export type NotificationChannelType = 'EMAIL' | 'SMS' | 'PUSH' | 'IN_APP';
 
@@ -245,22 +246,151 @@ export class NotificationsService {
     return { updated: true };
   }
 
+  // ---------------------------------------------------------------------------
+  // Template management (backoffice). Templates are keyed by `code`; event
+  // handlers look them up by that code (e.g. 'booking.created'), so `code` is
+  // immutable once created — only channel/subject/body/active are editable.
+  // ---------------------------------------------------------------------------
+
+  listTemplates() {
+    return this.prisma.notificationTemplate.findMany({ orderBy: { code: 'asc' } });
+  }
+
+  async getTemplate(id: string) {
+    const template = await this.prisma.notificationTemplate.findUnique({ where: { id } });
+    if (!template) throw new NotFoundException(`Notification template ${id} not found`);
+    return template;
+  }
+
+  async createTemplate(dto: CreateTemplateDto) {
+    const existing = await this.prisma.notificationTemplate.findUnique({ where: { code: dto.code } });
+    if (existing) throw new ConflictException(`Template with code "${dto.code}" already exists`);
+    return this.prisma.notificationTemplate.create({
+      data: {
+        code: dto.code,
+        channel: dto.channel,
+        subject: dto.subject ?? null,
+        bodyTemplate: dto.bodyTemplate,
+        active: dto.active ?? true,
+      },
+    });
+  }
+
+  async updateTemplate(id: string, dto: UpdateTemplateDto) {
+    await this.getTemplate(id); // 404 if missing
+    return this.prisma.notificationTemplate.update({
+      where: { id },
+      data: {
+        ...(dto.channel !== undefined ? { channel: dto.channel } : {}),
+        ...(dto.subject !== undefined ? { subject: dto.subject } : {}),
+        ...(dto.bodyTemplate !== undefined ? { bodyTemplate: dto.bodyTemplate } : {}),
+        ...(dto.active !== undefined ? { active: dto.active } : {}),
+      },
+    });
+  }
+
+  /**
+   * Booking created (awaiting payment) → the rich "your ticket is booked, here is the pay link"
+   * message. Mirrors the operator's legacy SMS: greeting, route, train/seat line(s), travel
+   * times, pay link, and the 2-hour pay-window warning (enforced by tasks.service — see
+   * MAX_PAYMENT_HOURS). The body comes from the editable `booking.created` template; the shallow
+   * event payload is re-fetched with schedule + seats to fill it.
+   */
   @OnEvent('booking.created')
   async onBookingCreated(payload: any) {
-    const booking = payload.booking;
-    await this.send(
-      'booking.created',
-      booking.passengerId,
-      {
-        bookingRef: booking.bookingRef,
-        amount: this.formatAmount(booking),
-        currency: booking.displayCurrency ?? 'ETB',
-        category: 'BOOKING',
-        deepLink: `edr://bookings/${booking.bookingRef}`,
+    const bookingId = payload.booking.id;
+
+    const booking = await this.prisma.booking.findUnique({
+      where: { id: bookingId },
+      include: {
+        schedule: { include: { originStation: true, destinationStation: true, train: true } },
+        seats: { include: { seat: { include: { coach: { include: { coachType: true } } } } } },
       },
-      // For now, always notify the travelling passenger on every channel.
-      ['IN_APP', 'EMAIL', 'SMS'],
-    );
+    });
+
+    const ref = booking?.bookingRef ?? payload.booking.bookingRef;
+    const passengerId = booking?.passengerId ?? payload.booking.passengerId;
+
+    const template = await this.prisma.notificationTemplate.findUnique({
+      where: { code: 'booking.created' },
+    });
+    if (!template || !template.active) {
+      this.logger.warn('booking.created template not found or inactive');
+      return;
+    }
+
+    const { subject, body } = this.interpolate(template, this.buildBookingCreatedContext(booking, ref));
+
+    // IN_APP — always created.
+    await this.createInAppNotification(passengerId, subject, body, {
+      category: 'BOOKING',
+      deepLink: `edr://bookings/${ref}`,
+    });
+
+    // SMS — the primary channel for this message. Prefer the IAM user's number, fall back to
+    // the phone entered on the booking form (guest bookings have no IAM user).
+    const contactPhone: string | null =
+      (booking as any)?.contactPhone ?? (payload.booking as any)?.contactPhone ?? null;
+    const iamPhone = passengerId ? await this.getRecipientAddress(passengerId, 'SMS').catch(() => null) : null;
+    const smsPhone = iamPhone ?? contactPhone;
+    if (smsPhone) {
+      await this.smsClient
+        .sendSms({ to: smsPhone, message: body })
+        .catch((e) => this.logger.error(`booking.created SMS failed for ${ref}: ${e?.message}`));
+    } else {
+      this.logger.warn(`No SMS phone for booking ${ref}`);
+    }
+
+    // EMAIL — same text, with the same contact fallback.
+    const contactEmail: string | null =
+      (booking as any)?.contactEmail ?? (payload.booking as any)?.contactEmail ?? null;
+    const iamEmail = passengerId ? await this.getRecipientAddress(passengerId, 'EMAIL').catch(() => null) : null;
+    const emailTo = iamEmail ?? contactEmail;
+    if (emailTo) {
+      await this.emailClient
+        .sendEmail({ to: emailTo, subject, text: body })
+        .catch((e) => this.logger.error(`booking.created email failed for ${ref}: ${e?.message}`));
+    }
+  }
+
+  /**
+   * 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
+   * several lines).
+   */
+  private buildBookingCreatedContext(booking: any, ref: string): Record<string, unknown> {
+    const s = booking?.schedule ?? {};
+    const trainName = s.train?.name ?? s.train?.number ?? '';
+    const fmtDate = (d: any) =>
+      d ? new Date(d).toLocaleDateString('en-US', { month: 'short', day: '2-digit', year: 'numeric' }) : 'TBD';
+    const fmtTime = (d: any) =>
+      d ? new Date(d).toLocaleTimeString('en-US', { hour: '2-digit', minute: '2-digit', hour12: true }) : 'TBD';
+
+    const seats = booking?.seats ?? [];
+    const trainSeatLines = seats
+      .map((bs: any) => {
+        const coach = bs.seat?.coach?.number ?? '-';
+        const cls = bs.seat?.coach?.coachType?.name ?? '';
+        const seatNo = bs.seat?.seatNumber ?? '-';
+        return `Train/Seat: Train ${trainName}, ${coach} ${cls}, seat no. ${seatNo}`.replace(/ +/g, ' ').trim();
+      })
+      .join('\n');
+
+    // 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}`;
+
+    return {
+      passengerName,
+      bookingRef: ref,
+      origin: s.originStation?.name ?? '',
+      destination: s.destinationStation?.name ?? '',
+      trainSeatLines,
+      travelDate: fmtDate(s.departureAt),
+      departureTime: fmtTime(s.departureAt),
+      arrivalTime: fmtTime(s.arrivalAt),
+      payLink,
+    };
   }
 
   /**
diff --git a/apps/edr-passenger-api/src/modules/payments/payments.service.spec.ts b/apps/edr-passenger-api/src/modules/payments/payments.service.spec.ts
index 112cc5096..bc5faee95 100644
--- a/apps/edr-passenger-api/src/modules/payments/payments.service.spec.ts
+++ b/apps/edr-passenger-api/src/modules/payments/payments.service.spec.ts
@@ -76,7 +76,7 @@ describe("PaymentsService", () => {
   // Mirrors the real ETB→major conversion: minor units → major price (TELEBIRR settles in ETB).
   const mockCurrencyService = {
     convertEtbMinorToChargeMajor: jest.fn((minor: number) =>
-      Promise.resolve(minor / 100),
+      Promise.resolve(minor),
     ),
     getRateOrThrow: jest.fn(),
   };
diff --git a/apps/edr-passenger-api/src/modules/payments/payments.service.ts b/apps/edr-passenger-api/src/modules/payments/payments.service.ts
index 9e43139c4..5e44038c4 100644
--- a/apps/edr-passenger-api/src/modules/payments/payments.service.ts
+++ b/apps/edr-passenger-api/src/modules/payments/payments.service.ts
@@ -338,7 +338,14 @@ export class PaymentsService {
     };
     return this.prisma.paymentIntent.upsert({
       where: { bookingId },
-      update: data,
+      // amountMinor/currency are refreshed on update too: a cross-currency method switch
+      // (e.g. Waafi/USD → Telebirr/ETB) re-initiates over the same row, and the projection
+      // must reflect the currency the new provider actually charges — not the first one's.
+      update: {
+        ...data,
+        amountMinor: snapshot.amountMinor,
+        currency: snapshot.currency,
+      },
       create: {
         bookingId,
         amountMinor: snapshot.amountMinor,
@@ -550,7 +557,6 @@ export class PaymentsService {
   getSupportedPaymentMethods(region?: PaymentRegionEnum) {
     return this.prisma.paymentMethod.findMany({
       where: {
-        enabled: true,
         ...(region
           ? {
               region: {
diff --git a/apps/edr-passenger-api/src/modules/search/search.module.ts b/apps/edr-passenger-api/src/modules/search/search.module.ts
index baadcf90c..b7788c2fe 100644
--- a/apps/edr-passenger-api/src/modules/search/search.module.ts
+++ b/apps/edr-passenger-api/src/modules/search/search.module.ts
@@ -4,9 +4,10 @@ import { SearchService } from './search.service';
 import { CurrencyModule } from '../currency/currency.module';
 import { FareEngineModule } from '../fare-engine/fare-engine.module';
 import { SegmentsModule } from '../segments/segments.module';
+import { SystemConfigModule } from '../system-config/system-config.module';
 
 @Module({
-  imports: [CurrencyModule, FareEngineModule, SegmentsModule],
+  imports: [CurrencyModule, FareEngineModule, SegmentsModule, SystemConfigModule],
   controllers: [SearchController],
   providers: [SearchService],
   exports: [SearchService],
diff --git a/apps/edr-passenger-api/src/modules/search/search.service.ts b/apps/edr-passenger-api/src/modules/search/search.service.ts
index 355446544..4de0f0d21 100644
--- a/apps/edr-passenger-api/src/modules/search/search.service.ts
+++ b/apps/edr-passenger-api/src/modules/search/search.service.ts
@@ -6,6 +6,7 @@ import { FareEngineService } from '../fare-engine/fare-engine.service';
 import { SegmentsService } from '../segments/segments.service';
 import { resolveCurrencyFromNationality } from '../fare-engine/fare-engine.dto';
 import { Currency } from '@prisma/client';
+import { SystemConfigService, CONFIG_KEYS } from '../system-config/system-config.service';
 
 const POINTS_TO_MINOR = 10;
 
@@ -40,8 +41,13 @@ export class SearchService {
     private currencyService: CurrencyService,
     private fareEngine: FareEngineService,
     private segmentsService: SegmentsService,
+    private systemConfig: SystemConfigService,
   ) {}
 
+  private async getCutoffHours(): Promise<number> {
+    return this.systemConfig.getNumber(CONFIG_KEYS.HOLD_CUTOFF_HOURS_BEFORE_DEPARTURE);
+  }
+
   async searchTrips(dto: SearchTripsDto) {
     const [direct, transit] = await Promise.all([
       this.searchSchedules(
@@ -166,13 +172,14 @@ export class SearchService {
 
     const schedules = await this.prisma.trainSchedule.findMany({
       where: {
-        status: { in: ['SCHEDULED', 'BOARDING'] },
+        status: 'SCHEDULED',
         isPackageOnly: false,
         OR: [
           { departureAt: { gte: windowStart, lt: requestedDate } },
           { departureAt: { gte: requestedNextDay < now ? now : requestedNextDay, lt: windowEnd } },
         ],
         stopTimes: { some: { stationId: originStationId } },
+        coachAssignments: { some: {} },
       },
       include: SCHEDULE_INCLUDE,
       orderBy: { departureAt: 'asc' },
@@ -183,7 +190,7 @@ export class SearchService {
         this.buildScheduleResult(schedule as any, originStationId, destinationStationId, totalPassengers, nationality)
       )
     );
-    return results.filter(Boolean);
+    return results.filter((r): r is NonNullable<typeof r> => !!r && r.hasAvailability);
   }
 
   private async searchSchedules(
@@ -200,12 +207,18 @@ export class SearchService {
     const now = new Date();
     const totalPassengers = adultCount + (childCount ?? 0);
 
+    const cutoffHours = await this.getCutoffHours();
+    const cutoffThreshold = new Date(now.getTime() + cutoffHours * 60 * 60 * 1000);
+    const isToday = now.getFullYear() === y && now.getMonth() === m - 1 && now.getDate() === d;
+    const earliest = isToday ? cutoffThreshold : date;
+
     const schedules = await this.prisma.trainSchedule.findMany({
       where: {
-        status: { in: ['SCHEDULED', 'BOARDING'] },
+        status: 'SCHEDULED',
         isPackageOnly: false,
-        departureAt: { gte: date < now ? now : date, lt: nextDay },
+        departureAt: { gte: earliest, lt: nextDay },
         stopTimes: { some: { stationId: originStationId } },
+        coachAssignments: { some: {} },
       },
       include: SCHEDULE_INCLUDE,
     });
@@ -215,7 +228,7 @@ export class SearchService {
         this.buildScheduleResult(schedule as any, originStationId, destinationStationId, totalPassengers, nationality)
       )
     );
-    return results.filter(Boolean);
+    return results.filter((r): r is NonNullable<typeof r> => !!r && r.hasAvailability);
   }
 
   // ── Transit search ─────────────────────────────────────────────────────────
@@ -241,26 +254,31 @@ export class SearchService {
     const [leg1Schedules, allCandidates] = await Promise.all([
       this.prisma.trainSchedule.findMany({
         where: {
-          status: { in: ['SCHEDULED', 'BOARDING'] },
+          status: 'SCHEDULED',
           isPackageOnly: false,
           departureAt: { gte: dayStart, lt: dayEnd },
           stopTimes: { some: { stationId: originStationId } },
+          coachAssignments: { some: {} },
         },
         include: SCHEDULE_INCLUDE,
       }),
       this.prisma.trainSchedule.findMany({
         where: {
-          status: { in: ['SCHEDULED', 'BOARDING'] },
+          status: 'SCHEDULED',
           isPackageOnly: false,
           departureAt: { gte: dayStart, lt: leg2WindowEnd },
+          coachAssignments: { some: {} },
         },
         include: SCHEDULE_INCLUDE,
       }),
     ]);
 
+    const cutoffHours = await this.getCutoffHours();
+    const cutoffThreshold = new Date(Date.now() + cutoffHours * 60 * 60 * 1000);
+
     const results: any[] = [];
 
-    for (const leg1 of leg1Schedules as ScheduleWithIncludes[]) {
+    for (const leg1 of (leg1Schedules as ScheduleWithIncludes[]).filter(s => new Date(s.departureAt) > cutoffThreshold)) {
       const originStop = leg1.stopTimes.find(s => s.stationId === originStationId);
       if (!originStop) continue;
 
@@ -354,6 +372,9 @@ export class SearchService {
         .map((s: any) => s.id as string)
     );
 
+    // Exclude schedules with no seats at all
+    if (allValidSeatIds.length === 0) return null;
+
     // Run availability batch and fare calculation in parallel
     const [freeSeats, faresByClass] = await Promise.all([
       this.segmentsService.getFreeSeatIds(
diff --git a/apps/edr-passenger-api/src/modules/seat-classes/seat-classes.dto.ts b/apps/edr-passenger-api/src/modules/seat-classes/seat-classes.dto.ts
index d12fe0fb6..1f061bf53 100644
--- a/apps/edr-passenger-api/src/modules/seat-classes/seat-classes.dto.ts
+++ b/apps/edr-passenger-api/src/modules/seat-classes/seat-classes.dto.ts
@@ -1,17 +1,31 @@
-import { IsString, IsInt, IsBoolean, IsOptional } from 'class-validator';
+import { IsString, IsInt, IsBoolean, IsOptional, IsIn } from 'class-validator';
 import { ApiProperty, ApiPropertyOptional, PartialType } from '@nestjs/swagger';
 
 export class CreateSeatClassDto {
+  @ApiProperty()
+  @IsString()
+  coachTypeId: string;
+
   @ApiProperty({ example: 'Economy Seat' })
   @IsString()
   name: string;
 
-  @ApiPropertyOptional({ example: 'Standard economy seating' })
+  @ApiPropertyOptional()
   @IsOptional()
   @IsString()
   description?: string;
 
-  @ApiProperty({ example: 45000, description: 'Base price in minor currency units' })
+  @ApiPropertyOptional({ enum: ['LOCAL', 'INTERNATIONAL'] })
+  @IsOptional()
+  @IsIn(['LOCAL', 'INTERNATIONAL'])
+  nationalityType?: string;
+
+  @ApiPropertyOptional({ enum: ['UPPER', 'MIDDLE', 'LOWER'] })
+  @IsOptional()
+  @IsString()
+  bedPosition?: string;
+
+  @ApiProperty({ example: 3000, description: 'Per-km rate in minor units (tariff decimal × 100000)' })
   @IsInt()
   basePrice: number;
 
diff --git a/apps/edr-passenger-api/src/modules/support/support.controller.ts b/apps/edr-passenger-api/src/modules/support/support.controller.ts
index 63adefe5a..4404c3ea8 100644
--- a/apps/edr-passenger-api/src/modules/support/support.controller.ts
+++ b/apps/edr-passenger-api/src/modules/support/support.controller.ts
@@ -17,6 +17,8 @@ import { JwtGuard } from '../../common/jwt.guard';
 import {
   CreateConversationDto,
   CreateGuestConversationDto,
+  DeviceIdBodyDto,
+  DeviceSendMessageDto,
   GuestIdBodyDto,
   GuestSendMessageDto,
   ListConversationsQueryDto,
@@ -103,7 +105,39 @@ export class SupportController {
     return this.service.unreadCount('USER', { iamUserId: userId(req) });
   }
 
-  // ---- customer: guest (unauthenticated) --------------------------------
+  // ---- customer: device-scoped single thread (portal) -------------------
+  // No auth, no forms. One conversation per device id (localStorage). Anyone
+  // with the device id can see that thread — accepted MVP trade-off.
+
+  @Get('device/thread')
+  @IsPublic()
+  @ApiOperation({ summary: "Get the device's support thread + messages" })
+  deviceThread(@Query('deviceId') deviceId: string) {
+    return this.service.getDeviceThread(deviceId);
+  }
+
+  @Post('device/messages')
+  @IsPublic()
+  @ApiOperation({ summary: 'Send a message (creates the thread on first send)' })
+  deviceSend(@Body() body: DeviceSendMessageDto) {
+    return this.service.sendDeviceMessage(body.deviceId, body.text);
+  }
+
+  @Post('device/read')
+  @IsPublic()
+  @ApiOperation({ summary: 'Mark the device thread read' })
+  deviceRead(@Body() body: DeviceIdBodyDto) {
+    return this.service.markDeviceRead(body.deviceId);
+  }
+
+  @Get('device/unread-count')
+  @IsPublic()
+  @ApiOperation({ summary: "Count the device thread's unread messages" })
+  deviceUnread(@Query('deviceId') deviceId: string) {
+    return this.service.unreadCount('USER', { guestId: deviceId });
+  }
+
+  // ---- customer: guest (unauthenticated, multi-ticket) ------------------
   // No JwtGuard. Access is scoped by a client-generated `guestId` (the bearer
   // of access — anyone with it sees that thread; accepted MVP trade-off).
 
diff --git a/apps/edr-passenger-api/src/modules/support/support.dto.ts b/apps/edr-passenger-api/src/modules/support/support.dto.ts
index 77a3ee3ed..a60ac607e 100644
--- a/apps/edr-passenger-api/src/modules/support/support.dto.ts
+++ b/apps/edr-passenger-api/src/modules/support/support.dto.ts
@@ -93,6 +93,26 @@ export class GuestIdBodyDto {
   guestId!: string;
 }
 
+export class DeviceSendMessageDto {
+  @ApiProperty({ description: 'Client device id (localStorage).' })
+  @IsString()
+  @Length(8, 120)
+  deviceId!: string;
+
+  @ApiProperty({ description: 'Message text.' })
+  @IsString()
+  @MinLength(1)
+  @MaxLength(4000)
+  text!: string;
+}
+
+export class DeviceIdBodyDto {
+  @ApiProperty()
+  @IsString()
+  @Length(8, 120)
+  deviceId!: string;
+}
+
 export class UpdateStatusDto {
   @ApiProperty({ enum: SupportStatusDto })
   @IsEnum(SupportStatusDto)
diff --git a/apps/edr-passenger-api/src/modules/support/support.gateway.ts b/apps/edr-passenger-api/src/modules/support/support.gateway.ts
index 203c39035..c5b65497b 100644
--- a/apps/edr-passenger-api/src/modules/support/support.gateway.ts
+++ b/apps/edr-passenger-api/src/modules/support/support.gateway.ts
@@ -7,7 +7,6 @@ import {
 import { Server, Socket } from 'socket.io';
 import { Passenger as PassengerTypes } from '@edr/types';
 
-import { PrismaService } from '../../common/prisma.service';
 import { WsAuthService } from './ws-auth.service';
 
 /**
@@ -34,27 +33,24 @@ export class SupportGateway implements OnGatewayConnection {
   @WebSocketServer()
   private readonly server!: Server;
 
-  constructor(
-    private readonly wsAuth: WsAuthService,
-    private readonly prisma: PrismaService,
-  ) {}
+  constructor(private readonly wsAuth: WsAuthService) {}
 
   async handleConnection(socket: Socket): Promise<void> {
     const userId = await this.wsAuth.resolveUserId(this.extractToken(socket));
 
-    // Authenticated: passenger (own room) or backoffice staff (shared room).
+    // A valid token means a backoffice agent: the portal connects only with a
+    // device/guest id (never a token), so every token-authed socket is staff.
+    // Join the shared backoffice room — no passenger-row heuristic needed.
     if (userId) {
       socket.data.userId = userId;
-      const passenger = await this.prisma.passenger.findUnique({
-        where: { iamUserId: userId },
+      socket.data.side = 'AGENT';
+      await socket.join(SupportGateway.BACKOFFICE_ROOM);
+      socket.emit('support:hello', {
+        side: 'AGENT',
+        room: SupportGateway.BACKOFFICE_ROOM,
+        userId,
       });
-      if (passenger) {
-        await socket.join(`user:${userId}`);
-        socket.data.side = 'USER';
-      } else {
-        await socket.join(SupportGateway.BACKOFFICE_ROOM);
-        socket.data.side = 'AGENT';
-      }
+      this.logger.debug(`support socket ${socket.id} → AGENT (backoffice)`);
       return;
     }
 
diff --git a/apps/edr-passenger-api/src/modules/support/support.service.ts b/apps/edr-passenger-api/src/modules/support/support.service.ts
index dfbbb3b12..77f701bf2 100644
--- a/apps/edr-passenger-api/src/modules/support/support.service.ts
+++ b/apps/edr-passenger-api/src/modules/support/support.service.ts
@@ -113,6 +113,61 @@ export class SupportService {
     return this.firstMessage(conversation, input.initialMessage);
   }
 
+  // ---- customer: device-scoped single thread (portal) -------------------
+
+  /** The device's single conversation + its messages ({conversation:null} if none). */
+  async getDeviceThread(deviceId: string): Promise<T.PassengerSupportThreadDto> {
+    if (!deviceId) return { conversation: null, messages: [] };
+    const c = (await this.prisma.supportConversation.findFirst({
+      where: { guestId: deviceId },
+      orderBy: { createdAt: 'asc' },
+    })) as ConversationRow | null;
+    if (!c) return { conversation: null, messages: [] };
+    const rows = await this.prisma.supportMessage.findMany({
+      where: { conversationId: c.id },
+      orderBy: { createdAt: 'asc' },
+    });
+    const unread = await this.computeUnread([c], 'USER');
+    return {
+      conversation: this.toConversationDto(c, unread.get(c.id) ?? 0),
+      messages: rows.map((m) => this.toMessageDto(m)),
+    };
+  }
+
+  /** Append a message to the device's thread, creating it on first message. */
+  async sendDeviceMessage(
+    deviceId: string,
+    text: string,
+  ): Promise<T.PassengerSupportMessageDto> {
+    let c = (await this.prisma.supportConversation.findFirst({
+      where: { guestId: deviceId },
+      orderBy: { createdAt: 'asc' },
+    })) as ConversationRow | null;
+    if (!c) {
+      c = (await this.prisma.supportConversation.create({
+        data: { guestId: deviceId, subject: 'Support chat', status: 'OPEN' },
+      })) as ConversationRow;
+    }
+    const updated = await this.appendMessage(c, 'USER', text);
+    const last = updated.messages[updated.messages.length - 1];
+    return this.toMessageDto(last);
+  }
+
+  /** Mark the device's thread read (customer side). */
+  async markDeviceRead(deviceId: string): Promise<{ unreadCount: number }> {
+    const c = await this.prisma.supportConversation.findFirst({
+      where: { guestId: deviceId },
+      orderBy: { createdAt: 'asc' },
+    });
+    if (c) {
+      await this.prisma.supportConversation.update({
+        where: { id: c.id },
+        data: { userLastReadAt: new Date() },
+      });
+    }
+    return this.unreadCount('USER', { guestId: deviceId });
+  }
+
   async listForCustomer(
     owner: CustomerOwner,
     query: ListQuery,
diff --git a/apps/edr-passenger-api/src/modules/tickets/tickets.service.spec.ts b/apps/edr-passenger-api/src/modules/tickets/tickets.service.spec.ts
index 7f6ad7f52..96b3e2ef8 100644
--- a/apps/edr-passenger-api/src/modules/tickets/tickets.service.spec.ts
+++ b/apps/edr-passenger-api/src/modules/tickets/tickets.service.spec.ts
@@ -72,9 +72,8 @@ describe('TicketsService - Offline Validation', () => {
 
       const result = await service.validateOfflineBatch(validations);
 
-      expect(result.success).toBe(1);
+      expect(result.successful).toBe(1);
       expect(result.failed).toBe(0);
-      expect(result.duplicate).toBe(0);
     });
 
     it('should detect duplicate validations', async () => {
@@ -98,8 +97,8 @@ describe('TicketsService - Offline Validation', () => {
 
       const result = await service.validateOfflineBatch(validations);
 
-      expect(result.success).toBe(1);
-      expect(result.duplicate).toBe(1);
+      expect(result.successful).toBe(1);
+      expect(result.failed).toBe(1);
     });
 
     it('should handle already validated tickets', async () => {
@@ -119,8 +118,8 @@ describe('TicketsService - Offline Validation', () => {
 
       const result = await service.validateOfflineBatch(validations);
 
-      expect(result.duplicate).toBe(1);
-      expect(result.success).toBe(0);
+      expect(result.successful).toBe(0);
+      expect(result.failed).toBe(1);
     });
   });
 });
diff --git a/apps/edr-passenger-web/backoffice/public/docs.md b/apps/edr-passenger-web/backoffice/public/docs.md
index 0a4922fa9..428c365ae 100644
--- a/apps/edr-passenger-web/backoffice/public/docs.md
+++ b/apps/edr-passenger-web/backoffice/public/docs.md
@@ -34,7 +34,7 @@ The Passenger Backoffice Application is a comprehensive management system for th
 - **Live Tracking**: Monitor trip status and real-time updates
 - **Security Monitoring**: Fraud detection and audit logging
 - **Comprehensive Analytics**: Revenue, occupancy, and performance reports
-- **🆕 Excess Baggage Management**: Handle boarding baggage charges with agent tools
+- **🆕 Excess Luggage Management**: Handle boarding baggage charges with agent tools
 - **🆕 Travel Packages**: Manage pilgrimage and group travel packages with tiered pricing
 - **🆕 System Health Monitoring**: Real-time API health checks and system status
 - **🆕 Advanced Fare Configuration**: Dynamic pricing with segment-based rules
@@ -94,7 +94,7 @@ The application is organized into 8 main sections:
     ├── System Config
     └── Settings
 └── Enhanced Features
-    ├── Excess Baggage
+    ├── Excess Luggage
     ├── Travel Packages
     ├── Package Inquiries
     ├── Health Monitoring
@@ -2862,7 +2862,7 @@ Action: Block user
 
 ### Version 1.0.0 (January 15, 2026)
 - **Complete Platform Release** - Full-featured passenger management system
-- **Excess Baggage Management** - Complete boarding baggage handling with agent tools and passenger self-pay options
+- **Excess Luggage Management** - Complete boarding baggage handling with agent tools and passenger self-pay options
 - **Travel Packages** - Pilgrimage and group travel packages with tiered pricing, capacity management, and inquiry handling
 - **System Health Monitoring** - Real-time API health checks with liveness, readiness, and performance metrics
 - **System Configuration** - Centralized config management with feature flags, rate limiting, and operational controls
@@ -2920,7 +2920,7 @@ Action: Block user
 
 ## Enhanced Features
 
-### Excess Baggage
+### Excess Luggage
 
 **Purpose**: Manage excess baggage charges at boarding with agent tools and passenger self-pay  
 **Access Level**: Agent, Supervisor, Admin  
@@ -2941,7 +2941,7 @@ Action: Block user
 └──────────────────────────────┘
 ```
 
-#### Excess Baggage Process
+#### Excess Luggage Process
 
 1. **At Boarding**: Agent weighs passenger baggage
 2. **If Excess**: Agent creates charge in system
@@ -2962,8 +2962,8 @@ Action: Block user
 
 ##### READ (List Charges)
 
-1. **Access Excess Baggage Page**:
-   - Click **Excess Baggage** in Enhanced Features section
+1. **Access Excess Luggage Page**:
+   - Click **Excess Luggage** in Enhanced Features section
    - Shows all baggage charges
 
 2. **Search & Filter**:
@@ -3000,7 +3000,7 @@ Action: Block user
 
 #### Agent Workflow
 
-1. **Weigh Baggage**: Use station scales
+1. **Weigh Luggage**: Use station scales
 2. **Check Allowance**: Compare to passenger's seat class allowance
 3. **Create Charge**: If excess weight found
 4. **Offer Payment Options**:
diff --git a/apps/edr-passenger-web/backoffice/src/app/classes/page.tsx b/apps/edr-passenger-web/backoffice/src/app/classes/page.tsx
index 348268ca2..7cc9875dc 100644
--- a/apps/edr-passenger-web/backoffice/src/app/classes/page.tsx
+++ b/apps/edr-passenger-web/backoffice/src/app/classes/page.tsx
@@ -311,42 +311,21 @@ export default function ClassesPage() {
                 <p className="text-xs text-muted-foreground mt-1">Per-km distance-based fare rate</p>
               </div>
 
-              <div className="grid grid-cols-1 md:grid-cols-2 gap-4 mt-4">
-                <div>
-                  <label className="label">Premium Fee (ETB)</label>
-                  <input
-                    type="number"
-                    name="premiumMinor"
-                    className="input"
-                    defaultValue={editingClass?.premiumMinor ? (editingClass.premiumMinor / 100).toFixed(2) : '0.00'}
-                    min="0"
-                    step="0.01"
-                    placeholder="e.g., 50.00"
-                  />
-                  <p className="text-xs text-muted-foreground mt-1">Flat fee per passenger (e.g., lounge access, extra legroom)</p>
-                </div>
-
-                <div>
-                  <label className="label">Insurance Fee (ETB)</label>
-                  <input
-                    type="number"
-                    name="insuranceFeeMinor"
-                    className="input"
-                    defaultValue={editingClass?.insuranceFeeMinor ? (editingClass.insuranceFeeMinor / 100).toFixed(2) : '0.00'}
-                    min="0"
-                    step="0.01"
-                    placeholder="e.g., 25.00"
-                  />
-                  <p className="text-xs text-muted-foreground mt-1">Flat fee per passenger (e.g., travel insurance)</p>
-                </div>
+              <input type="hidden" name="premiumMinor" value="0" />
+              <div className="mt-4">
+                <label className="label">Insurance Fee (ETB)</label>
+                <input
+                  type="number"
+                  name="insuranceFeeMinor"
+                  className="input"
+                  defaultValue={editingClass?.insuranceFeeMinor ? (editingClass.insuranceFeeMinor / 100).toFixed(2) : '0.00'}
+                  min="0"
+                  step="0.01"
+                  placeholder="e.g., 25.00"
+                />
+                <p className="text-xs text-muted-foreground mt-1">Flat fee per passenger (e.g., travel insurance)</p>
               </div>
 
-              <div className="mt-4 p-3 bg-blue-50 dark:bg-blue-900/20 border border-blue-200 dark:border-blue-800 rounded text-sm text-blue-800 dark:text-blue-200">
-                <p className="font-medium mb-1">Total Fare Calculation:</p>
-                <p>Total = (Base Fare × Distance) + Premium + Insurance</p>
-                <p className="mt-2 text-xs">• Premium applies per passenger</p>
-                <p className="text-xs">• Insurance applies per passenger</p>
-              </div>
             </div>
 
             <div>
diff --git a/apps/edr-passenger-web/backoffice/src/app/currencies/page.tsx b/apps/edr-passenger-web/backoffice/src/app/currencies/page.tsx
index 4cf393713..cee6944f6 100644
--- a/apps/edr-passenger-web/backoffice/src/app/currencies/page.tsx
+++ b/apps/edr-passenger-web/backoffice/src/app/currencies/page.tsx
@@ -220,13 +220,6 @@ export default function CurrenciesPage() {
         )}
       </div>
 
-      <div className="card bg-blue-50 dark:bg-blue-900/20 border border-blue-200 dark:border-blue-800 text-sm text-blue-800 dark:text-blue-300 space-y-1">
-        <p className="font-semibold text-blue-900 dark:text-blue-200 mb-2">How it works</p>
-        <p>• ETB is the transaction currency — all fares are stored in ETB minor units (1 ETB = 100 minor)</p>
-        <p>• DJF and USD rates are used to display prices to passengers in their preferred currency</p>
-        <p>• Rates apply globally; changes take effect immediately on the next booking or fare quote</p>
-      </div>
-
       <Modal
         isOpen={showAddModal}
         onClose={() => { setShowAddModal(false); setError(null); }}
diff --git a/apps/edr-passenger-web/backoffice/src/app/docs/sections/OperationsSection.tsx b/apps/edr-passenger-web/backoffice/src/app/docs/sections/OperationsSection.tsx
index 7c14cc357..0f9b9beb5 100644
--- a/apps/edr-passenger-web/backoffice/src/app/docs/sections/OperationsSection.tsx
+++ b/apps/edr-passenger-web/backoffice/src/app/docs/sections/OperationsSection.tsx
@@ -82,7 +82,7 @@ export default function OperationsSection() {
 
       {/* EXCESS BAGGAGE */}
       <div id="excess-baggage" className="border-t pt-8">
-        <h2 className="text-2xl font-bold text-slate-900 dark:text-white mb-2">📦 Luggage (Excess Baggage)</h2>
+        <h2 className="text-2xl font-bold text-slate-900 dark:text-white mb-2">📦 Luggage (Excess Luggage)</h2>
         <p className={li}>Handle excess baggage charges at boarding — passenger self-pay or agent cash collection. Access level: Agent, Supervisor, Admin.</p>
         <div className="mt-3 flex flex-wrap gap-2 text-xs">
           {['PENDING','PAID','CASH_COLLECTED','EXPIRED','WAIVED'].map(s => (
@@ -91,7 +91,7 @@ export default function OperationsSection() {
         </div>
       </div>
       <div id="excess-baggage-how" className="border-t pt-8">
-        <h3 className="text-xl font-bold text-slate-900 dark:text-white mb-4">📦 How-To: Handle Excess Baggage</h3>
+        <h3 className="text-xl font-bold text-slate-900 dark:text-white mb-4">📦 How-To: Handle Excess Luggage</h3>
         <div className="space-y-3">
           <HowToStep number={1} title="Find Charges">
             <ol className={ol}><li>Click <strong>Luggage</strong> in Operations</li><li>Search by booking reference; filter by status or date</li></ol>
diff --git a/apps/edr-passenger-web/backoffice/src/app/notifications/page.tsx b/apps/edr-passenger-web/backoffice/src/app/notifications/page.tsx
index 049a12237..d277eb3de 100644
--- a/apps/edr-passenger-web/backoffice/src/app/notifications/page.tsx
+++ b/apps/edr-passenger-web/backoffice/src/app/notifications/page.tsx
@@ -10,8 +10,12 @@ import ActionButton from '@/components/ui/ActionButton';
 import { notificationsApi } from '@/lib/api';
 import { formatDateTime } from '@/lib/utils';
 
+const CHANNEL_OPTIONS = ['EMAIL', 'SMS', 'PUSH', 'IN_APP'];
+
 export default function NotificationsPage() {
   const [showModal, setShowModal] = useState(false);
+  const [editing, setEditing] = useState<any | null>(null);
+  const [templateError, setTemplateError] = useState<string | null>(null);
   const [activeTab, setActiveTab] = useState<'templates' | 'send' | 'history'>('templates');
   const [sendForm, setSendForm] = useState({ recipientType: 'ALL', channel: 'EMAIL', subject: '', message: '' });
   const [sendError, setSendError] = useState<string | null>(null);
@@ -34,10 +38,54 @@ export default function NotificationsPage() {
     mutationFn: notificationsApi.createTemplate,
     onSuccess: () => {
       queryClient.invalidateQueries({ queryKey: ['notification-templates'] });
-      setShowModal(false);
+      closeTemplateModal();
     },
+    onError: (e: any) => setTemplateError(e?.response?.data?.message || e?.message || 'Failed to create template'),
   });
 
+  const updateTemplateMutation = useMutation({
+    mutationFn: ({ id, data }: { id: string; data: any }) => notificationsApi.updateTemplate(id, data),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ['notification-templates'] });
+      closeTemplateModal();
+    },
+    onError: (e: any) => setTemplateError(e?.response?.data?.message || e?.message || 'Failed to update template'),
+  });
+
+  const openCreateModal = () => {
+    setEditing(null);
+    setTemplateError(null);
+    setShowModal(true);
+  };
+
+  const openEditModal = (template: any) => {
+    setEditing(template);
+    setTemplateError(null);
+    setShowModal(true);
+  };
+
+  const closeTemplateModal = () => {
+    setShowModal(false);
+    setEditing(null);
+    setTemplateError(null);
+  };
+
+  const handleTemplateSubmit = async (e: React.FormEvent<HTMLFormElement>) => {
+    e.preventDefault();
+    setTemplateError(null);
+    const fd = new FormData(e.currentTarget);
+    const channel = fd.get('channel') as string;
+    const subject = (fd.get('subject') as string) || undefined;
+    const bodyTemplate = fd.get('bodyTemplate') as string;
+    const active = fd.get('active') === 'on';
+
+    if (editing) {
+      await updateTemplateMutation.mutateAsync({ id: editing.id, data: { channel, subject, bodyTemplate, active } });
+    } else {
+      await createTemplateMutation.mutateAsync({ code: fd.get('code') as string, channel, subject, bodyTemplate, active });
+    }
+  };
+
   const sendMutation = useMutation({
     mutationFn: notificationsApi.send,
     onSuccess: () => {
@@ -59,23 +107,36 @@ export default function NotificationsPage() {
   const historyArray = Array.isArray(historyData) ? historyData : (historyData as any)?.items || [];
 
   const templateColumns = [
-    { key: 'name', label: 'Template Name', render: (t: any) => <span className="font-medium">{t.name}</span> },
-    { key: 'channel', label: 'Channel', render: (t: any) => <Badge>{t.channel || t.type}</Badge> },
+    { key: 'code', label: 'Code / Event Key', render: (t: any) => <span className="font-mono text-sm font-medium">{t.code}</span> },
+    { key: 'channel', label: 'Channel', render: (t: any) => <Badge>{t.channel}</Badge> },
     {
       key: 'subject',
       label: 'Subject / Body',
-      render: (t: any) => <span className="text-sm text-muted-foreground truncate max-w-xs block">{t.subject || t.body || t.content || '—'}</span>,
+      render: (t: any) => (
+        <span className="text-sm text-muted-foreground truncate max-w-xs block">
+          {t.subject ? `${t.subject} — ` : ''}{(t.bodyTemplate || '').replace(/\n/g, ' ') || '—'}
+        </span>
+      ),
     },
     {
       key: 'active',
       label: 'Status',
       render: (t: any) => (
-        <Badge variant="status" status={t.isActive !== false ? 'CONFIRMED' : 'CANCELLED'}>
-          {t.isActive !== false ? 'Active' : 'Inactive'}
+        <Badge variant="status" status={t.active !== false ? 'CONFIRMED' : 'CANCELLED'}>
+          {t.active !== false ? 'Active' : 'Inactive'}
         </Badge>
       ),
     },
     { key: 'createdAt', label: 'Created', render: (t: any) => <span className="text-sm text-muted-foreground">{formatDateTime(t.createdAt)}</span> },
+    {
+      key: 'actions',
+      label: '',
+      render: (t: any) => (
+        <button onClick={() => openEditModal(t)} className="text-sm font-medium text-primary hover:underline">
+          Edit
+        </button>
+      ),
+    },
   ];
 
   const historyColumns = [
@@ -106,7 +167,7 @@ export default function NotificationsPage() {
           <p className="text-muted-foreground">Manage notification templates and send messages</p>
         </div>
         {activeTab === 'templates' && (
-          <ActionButton icon={Plus} onClick={() => setShowModal(true)}>New Template</ActionButton>
+          <ActionButton icon={Plus} onClick={openCreateModal}>New Template</ActionButton>
         )}
       </div>
 
@@ -184,43 +245,68 @@ export default function NotificationsPage() {
         </div>
       )}
 
-      <Modal isOpen={showModal} onClose={() => setShowModal(false)} title="Create Notification Template">
-        <form
-          onSubmit={async (e) => {
-            e.preventDefault();
-            const fd = new FormData(e.currentTarget);
-            await createTemplateMutation.mutateAsync({
-              name: fd.get('name') as string,
-              channel: fd.get('channel') as string,
-              subject: fd.get('subject') as string,
-              body: fd.get('body') as string,
-            });
-          }}
-          className="space-y-4"
-        >
+      <Modal
+        isOpen={showModal}
+        onClose={closeTemplateModal}
+        title={editing ? `Edit Template — ${editing.code}` : 'Create Notification Template'}
+      >
+        <form onSubmit={handleTemplateSubmit} className="space-y-4">
           <div>
-            <label className="label">Template Name *</label>
-            <input type="text" name="name" className="input" placeholder="e.g., Booking Confirmation" required />
+            <label className="label">Code / Event Key {editing ? '' : '*'}</label>
+            <input
+              type="text"
+              name="code"
+              className="input font-mono"
+              placeholder="e.g., booking.created"
+              defaultValue={editing?.code ?? ''}
+              required={!editing}
+              disabled={!!editing}
+            />
+            {editing && (
+              <p className="mt-1 text-xs text-muted-foreground">Code is the event key and cannot be changed.</p>
+            )}
           </div>
           <div>
-            <label className="label">Channel</label>
-            <select name="channel" className="input">
-              <option value="EMAIL">Email</option>
-              <option value="SMS">SMS</option>
-              <option value="PUSH">Push Notification</option>
+            <label className="label">Channel *</label>
+            <select name="channel" className="input" defaultValue={editing?.channel ?? 'EMAIL'} required>
+              {CHANNEL_OPTIONS.map((c) => (
+                <option key={c} value={c}>{c}</option>
+              ))}
+              <option value="SMS,EMAIL">SMS,EMAIL</option>
+              <option value="SMS,EMAIL,IN_APP">SMS,EMAIL,IN_APP</option>
             </select>
+            <p className="mt-1 text-xs text-muted-foreground">
+              One channel, or a comma-separated list (EMAIL, SMS, PUSH, IN_APP).
+            </p>
           </div>
           <div>
             <label className="label">Subject</label>
-            <input type="text" name="subject" className="input" placeholder="Enter subject" />
+            <input type="text" name="subject" className="input" placeholder="Enter subject" defaultValue={editing?.subject ?? ''} />
           </div>
           <div>
             <label className="label">Body *</label>
-            <textarea name="body" className="input" rows={4} placeholder="Enter template body" required />
+            <textarea
+              name="bodyTemplate"
+              className="input font-mono text-sm"
+              rows={8}
+              placeholder="Enter template body"
+              defaultValue={editing?.bodyTemplate ?? ''}
+              required
+            />
+            <p className="mt-1 text-xs text-muted-foreground">
+              Use <code>{'{{variable}}'}</code> placeholders (e.g. <code>{'{{passengerName}}'}</code>, <code>{'{{bookingRef}}'}</code>) — they are filled in when the notification is sent.
+            </p>
           </div>
+          <div className="flex items-center gap-2">
+            <input type="checkbox" name="active" id="template-active" defaultChecked={editing ? editing.active !== false : true} />
+            <label htmlFor="template-active" className="text-sm">Active</label>
+          </div>
+          {templateError && <p className="text-sm text-red-600 dark:text-red-400">{templateError}</p>}
           <div className="flex justify-end gap-2">
-            <ActionButton type="button" variant="secondary" onClick={() => setShowModal(false)}>Cancel</ActionButton>
-            <ActionButton type="submit" loading={createTemplateMutation.isPending}>Create Template</ActionButton>
+            <ActionButton type="button" variant="secondary" onClick={closeTemplateModal}>Cancel</ActionButton>
+            <ActionButton type="submit" loading={createTemplateMutation.isPending || updateTemplateMutation.isPending}>
+              {editing ? 'Save Changes' : 'Create Template'}
+            </ActionButton>
           </div>
         </form>
       </Modal>
diff --git a/apps/edr-passenger-web/backoffice/src/app/pricing/page.tsx b/apps/edr-passenger-web/backoffice/src/app/pricing/page.tsx
index 3e221839b..73ce87383 100644
--- a/apps/edr-passenger-web/backoffice/src/app/pricing/page.tsx
+++ b/apps/edr-passenger-web/backoffice/src/app/pricing/page.tsx
@@ -609,7 +609,7 @@ export default function PricingPage() {
             className={`px-4 py-2 font-medium border-b-2 transition-colors ${tab === 'baggage' ? 'border-primary text-primary' : 'border-transparent text-muted-foreground'
               }`}
           >
-            Excess Baggage Rates
+            Excess Luggage Rates
           </button>
         </div>
 
@@ -765,24 +765,6 @@ export default function PricingPage() {
         </div>
       </div>
 
-      <div className="card bg-blue-50 dark:bg-blue-900/20 border border-blue-200 dark:border-blue-800">
-        <h3 className="font-semibold text-blue-900 dark:text-blue-200 mb-3">Pricing Structure</h3>
-        <ul className="text-sm text-blue-800 dark:text-blue-300 space-y-2">
-          <li>
-            • <strong>Segment Fares:</strong> Set fares for specific stop-to-stop segments (e.g., Addis → Dire Dawa)
-          </li>
-          <li>
-            • <strong>Schedule Fares:</strong> Set custom pricing for each schedule by seat class and passenger type
-          </li>
-          <li>
-            • <strong>Passenger Type:</strong> ADULT (5+ years) or CHILD (&lt;5) — first child travels free, subsequent children pay full fare
-          </li>
-          <li>
-            • <strong>Nationality-based:</strong> Override fares for specific nationalities (Ethiopian, Djiboutian, Other)
-          </li>
-        </ul>
-      </div>
-
       {/* Delete Confirmation */}
       <ConfirmDialog
         isOpen={deleteConfirm.isOpen}
@@ -1113,7 +1095,7 @@ export default function PricingPage() {
           </div>
         </div>
       </Modal>
-      {/* Baggage Allowance Modal */}
+      {/* Luggage Allowance Modal */}
       <Modal isOpen={baggageModal} onClose={() => { setBaggageModal(false); setEditingAllowance(null); setBaggageError(null); }} title={editingAllowance ? 'Edit Allowance Rule' : 'Add Allowance Rule'} size="md">
         <div className="space-y-4">
           {baggageError && <div className="bg-red-50 dark:bg-red-900/20 border border-red-200 dark:border-red-800 p-3 rounded-lg text-sm text-red-800 dark:text-red-200">{baggageError}</div>}
diff --git a/apps/edr-passenger-web/backoffice/src/app/seats/page.tsx b/apps/edr-passenger-web/backoffice/src/app/seats/page.tsx
index a5ed35666..413383b7a 100644
--- a/apps/edr-passenger-web/backoffice/src/app/seats/page.tsx
+++ b/apps/edr-passenger-web/backoffice/src/app/seats/page.tsx
@@ -52,15 +52,28 @@ export default function SeatsPage() {
     queryFn: async () => {
       if (!selectedRoute) return null;
       const template: any[] = await routeCoachTemplatesApi.get(selectedRoute);
-      if (!template?.length) return [];
-      const fullCoaches = await Promise.all(
-        template.map((entry: any) => fleetApi.getCoach(entry.coachId ?? entry.coach?.id))
-      );
-      return fullCoaches.map((coach: any, i: number) => ({
+      if (template?.length) {
+        const fullCoaches = await Promise.all(
+          template.map((entry: any) => fleetApi.getCoach(entry.coachId ?? entry.coach?.id))
+        );
+        return fullCoaches.map((coach: any, i: number) => ({
+          ...coach,
+          coachNumber: coach.number,
+          positionNumber: template[i].positionNumber,
+          seatArrangement: coach.arrangement,
+        }));
+      }
+      // No template — fetch coaches from the most recent schedule for this route
+      const schedules: any = await schedulesApi.getAll({ routeId: selectedRoute });
+      const scheduleList: any[] = schedules?.items || schedules?.data || (Array.isArray(schedules) ? schedules : []);
+      if (!scheduleList.length) return [];
+      const latestSchedule = scheduleList[scheduleList.length - 1];
+      const seatMap: any = await seatsApi.getSeatMap(latestSchedule.id);
+      return (seatMap?.coaches || []).map((coach: any, i: number) => ({
         ...coach,
-        coachNumber: coach.number,
-        positionNumber: template[i].positionNumber,
-        seatArrangement: coach.arrangement,
+        coachNumber: coach.number ?? coach.coachNumber,
+        positionNumber: coach.positionNumber ?? i + 1,
+        seatArrangement: coach.arrangement ?? coach.seatArrangement,
       }));
     },
     enabled: !!selectedRoute,
diff --git a/apps/edr-passenger-web/backoffice/src/app/support/page.tsx b/apps/edr-passenger-web/backoffice/src/app/support/page.tsx
index 8102cc556..246a6f4f9 100644
--- a/apps/edr-passenger-web/backoffice/src/app/support/page.tsx
+++ b/apps/edr-passenger-web/backoffice/src/app/support/page.tsx
@@ -42,7 +42,7 @@ export default function SupportPage() {
   const { data, isLoading } = useConversations(
     status === 'ALL' ? { search } : { status, search },
   );
-  const items = data?.items ?? [];
+  const items = useMemo(() => data?.items ?? [], [data?.items]);
 
   useSupportSocket(true);
 
diff --git a/apps/edr-passenger-web/backoffice/src/app/tariff-rates/page.tsx b/apps/edr-passenger-web/backoffice/src/app/tariff-rates/page.tsx
index bc8f31eaf..653ffddc3 100644
--- a/apps/edr-passenger-web/backoffice/src/app/tariff-rates/page.tsx
+++ b/apps/edr-passenger-web/backoffice/src/app/tariff-rates/page.tsx
@@ -10,7 +10,6 @@ import Modal from '@/components/ui/Modal';
 import ConfirmDialog from '@/components/ui/ConfirmDialog';
 import { apiClient } from '@/lib/api-client';
 
-const NATIONALITY_TYPES = ['LOCAL', 'INTERNATIONAL'] as const;
 const BED_POSITIONS = ['UPPER', 'MIDDLE', 'LOWER'] as const;
 const COACH_TYPE_LABELS: Record<string, string> = {
   HSC: 'Regular Seat (Hard Seat)',
@@ -18,7 +17,6 @@ const COACH_TYPE_LABELS: Record<string, string> = {
   SBC: 'VIP Bed (Soft Berth)',
 };
 
-// Tariff reference rates per the official policy document
 const TARIFF_REFERENCE: Record<string, Record<string, number>> = {
   LOCAL: {
     'HSC-null': 0.03,
@@ -109,7 +107,7 @@ export default function TariffRatesPage() {
       name: fd.get('name') as string,
       nationalityType: selectedNationalityType,
       bedPosition: selectedBedPosition || null,
-      baseFareMinor: parseInt(fd.get('baseFareMinor') as string),
+      basePrice: Math.round(Number(fd.get('baseFareMinor') as string) * 100) || 0,
       isActive: fd.get('isActive') === 'true',
     };
     if (editingClass) {
@@ -127,7 +125,6 @@ export default function TariffRatesPage() {
     ? classesData
     : (classesData as any)?.items || (classesData as any)?.data || [];
 
-  // Only show classes that have nationalityType set (tariff-managed rows)
   const tariffClasses = allClasses.filter((c: any) => c.nationalityType);
 
   const displayed = tariffClasses.filter((c: any) => {
@@ -141,7 +138,6 @@ export default function TariffRatesPage() {
     );
   });
 
-  // Auto-suggest name from selections
   const suggestName = () => {
     const ct = coachTypesArray.find((c: any) => c.id === selectedCoachTypeId);
     if (!ct) return '';
@@ -151,13 +147,12 @@ export default function TariffRatesPage() {
     return `${label}${pos} (${nat})`;
   };
 
-  // Auto-suggest baseFareMinor from tariff reference
+  // Returns the human-readable rate (e.g. 0.03); stored value = this × 100
   const suggestRate = () => {
     const ct = coachTypesArray.find((c: any) => c.id === selectedCoachTypeId);
     if (!ct) return '';
     const ref = getTariffRef(selectedNationalityType, ct.code, selectedBedPosition || null);
-    // baseFareMinor = tariff_decimal × 100000
-    return ref ? Math.round(ref * 100000).toString() : '';
+    return ref ? String(ref) : '';
   };
 
   const columns = [
@@ -184,18 +179,18 @@ export default function TariffRatesPage() {
       render: (c: any) => <span className="font-medium">{c.name}</span>,
     },
     {
-      key: 'baseFareMinor', label: 'Rate per km (minor)',
+      key: 'baseFareMinor', label: 'Rate per km',
       render: (c: any) => {
         const ct = coachTypesArray.find((t: any) => t.id === c.coachTypeId);
         const ref = ct ? getTariffRef(c.nationalityType, ct.code, c.bedPosition) : undefined;
-        const tariffMinor = ref ? Math.round(ref * 100000) : undefined;
+        const tariffMinor = ref ? Math.round(ref * 100) : undefined;
         const matches = tariffMinor === c.baseFareMinor;
         return (
           <div className="flex items-center gap-2">
-            <span className="font-mono font-medium">{c.baseFareMinor}</span>
+            <span className="font-mono font-medium">{c.baseFareMinor / 100}</span>
             {tariffMinor !== undefined && (
               <span className={`text-xs px-1.5 py-0.5 rounded ${matches ? 'bg-green-100 text-green-700 dark:bg-green-900/30 dark:text-green-400' : 'bg-yellow-100 text-yellow-700 dark:bg-yellow-900/30 dark:text-yellow-400'}`}>
-                {matches ? '✓ tariff' : `tariff: ${tariffMinor}`}
+                {matches ? '✓ tariff' : `tariff: ${tariffMinor / 100}`}
               </span>
             )}
           </div>
@@ -237,17 +232,6 @@ export default function TariffRatesPage() {
         </ActionButton>
       </div>
 
-      {/* Tariff reference card */}
-      <div className="card bg-blue-50 dark:bg-blue-900/20 border border-blue-200 dark:border-blue-800">
-        <h3 className="font-semibold text-blue-900 dark:text-blue-200 mb-2">Official Tariff Formula</h3>
-        <p className="text-sm text-blue-800 dark:text-blue-300 font-mono">
-          Fare = KM × rate × 1.02 × ExchangeRate
-        </p>
-        <p className="text-xs text-blue-700 dark:text-blue-400 mt-1">
-          Rate is stored as <strong>baseFareMinor = tariff_decimal × 100,000</strong> (e.g. 0.03 → 3000). The ×1.02 insurance coefficient is applied automatically by the fare engine.
-        </p>
-      </div>
-
       <div className="card">
         <div className="relative mb-4">
           <Search className="absolute left-3 top-1/2 -translate-y-1/2 h-4 w-4 text-muted-foreground" />
@@ -377,15 +361,16 @@ export default function TariffRatesPage() {
             </div>
 
             <div>
-              <label className="label">Base Fare Minor (per km) *</label>
+              <label className="label">Rate per km *</label>
               <input
                 type="number"
                 name="baseFareMinor"
                 className="input"
-                defaultValue={editingClass?.baseFareMinor ?? ''}
+                defaultValue={editingClass ? editingClass.baseFareMinor / 100 : ''}
                 key={editingClass?.id ?? `rate-${selectedCoachTypeId}-${selectedBedPosition}-${selectedNationalityType}`}
-                placeholder={suggestRate() || 'e.g. 3000'}
+                placeholder={suggestRate() || 'e.g. 6'}
                 min="0"
+                step="any"
                 required
               />
               {suggestRate() && (
@@ -401,7 +386,7 @@ export default function TariffRatesPage() {
                   >
                     {suggestRate()}
                   </button>
-                  {' '}(= {(parseInt(suggestRate()) / 100000).toFixed(3)} ETB/km)
+                  {' '}(stored as {Math.round(Number(suggestRate()) * 100)})
                 </p>
               )}
             </div>
diff --git a/apps/edr-passenger-web/backoffice/src/app/tickets/page.tsx b/apps/edr-passenger-web/backoffice/src/app/tickets/page.tsx
index 53ae0584a..275291415 100644
--- a/apps/edr-passenger-web/backoffice/src/app/tickets/page.tsx
+++ b/apps/edr-passenger-web/backoffice/src/app/tickets/page.tsx
@@ -884,11 +884,11 @@ export default function TicketsPage() {
         })()}
       </Modal>
 
-      {/* Excess Baggage Modal */}
+      {/* Excess Luggage Modal */}
       <Modal
         isOpen={excessModalOpen}
         onClose={() => { setExcessModalOpen(false); setExcessTicket(null); setExcessResult(null); }}
-        title="Log Excess Baggage"
+        title="Log Excess Luggage"
         size="sm"
       >
         {excessResult ? (
diff --git a/apps/edr-passenger-web/backoffice/src/features/support/useSupportSocket.ts b/apps/edr-passenger-web/backoffice/src/features/support/useSupportSocket.ts
index c4014f8d2..aabeb0ce4 100644
--- a/apps/edr-passenger-web/backoffice/src/features/support/useSupportSocket.ts
+++ b/apps/edr-passenger-web/backoffice/src/features/support/useSupportSocket.ts
@@ -37,11 +37,27 @@ export function useSupportSocket(
       `${SOCKET_ORIGIN}/${Passenger.PASSENGER_SUPPORT_WS_NAMESPACE}`,
       {
         auth: { token },
-        transports: ['websocket'],
+        // Prefer WebSocket, fall back to HTTP long-polling if the proxy blocks
+        // the upgrade (polling rides normal HTTPS, already CSP-allowed).
+        transports: ['websocket', 'polling'],
         withCredentials: true,
       },
     );
 
+    // Temporary diagnostics — remove once live delivery is confirmed.
+    socket.on('connect', () =>
+      console.warn('[support] agent socket connected', socket.id),
+    );
+    socket.on('connect_error', (err) =>
+      console.warn('[support] agent socket connect_error:', err.message),
+    );
+    socket.on('disconnect', (reason) =>
+      console.warn('[support] agent socket disconnected:', reason),
+    );
+    socket.on('support:hello', (info) =>
+      console.warn('[support] server assigned:', info),
+    );
+
     socket.on(
       Passenger.PASSENGER_SUPPORT_WS_EVENTS.MESSAGE_NEW,
       (event: Passenger.PassengerSupportMessageEvent) => {
diff --git a/apps/edr-passenger-web/backoffice/src/lib/api/index.ts b/apps/edr-passenger-web/backoffice/src/lib/api/index.ts
index 9f3764227..7824cef07 100644
--- a/apps/edr-passenger-web/backoffice/src/lib/api/index.ts
+++ b/apps/edr-passenger-web/backoffice/src/lib/api/index.ts
@@ -444,7 +444,7 @@ export const packageInquiriesApi = {
   remove: (id: string) => apiClient.delete(`/packages/inquiries/${id}`),
 };
 
-// Excess Baggage API
+// Excess Luggage API
 export const excessBaggageApi = {
   logCharge: (data: any) => apiClient.post<any>('/agents/excess-baggage', data),
   getCharge: (id: string) => apiClient.get<any>(`/agents/excess-baggage/${id}`),
diff --git a/apps/edr-passenger-web/backoffice/src/middleware.ts b/apps/edr-passenger-web/backoffice/src/middleware.ts
index db7af8568..5ad4e3407 100644
--- a/apps/edr-passenger-web/backoffice/src/middleware.ts
+++ b/apps/edr-passenger-web/backoffice/src/middleware.ts
@@ -35,8 +35,12 @@ function buildCsp(nonce: string): string {
     ? `'self' 'nonce-${nonce}' 'strict-dynamic'`
     : `'self' 'unsafe-inline' 'unsafe-eval'`;
 
+  // The Socket.IO WebSocket upgrade connects to wss://<api-host>; under CSP a
+  // `https://host` source does NOT cover `wss://host`, so add it explicitly.
+  const wsOrigin = apiOrigin.replace(/^http/, 'ws'); // https→wss, http→ws
+
   const connectSrc = isProd
-    ? `'self' ${apiOrigin}`.trim()
+    ? `'self' ${apiOrigin} ${wsOrigin}`.trim()
     : `'self' ${apiOrigin} ws: wss:`.trim();
 
   const directives = [
diff --git a/apps/edr-passenger-web/portal/src/app/booking/confirmation/page.tsx b/apps/edr-passenger-web/portal/src/app/booking/confirmation/page.tsx
index 220ecb1b3..515eb4449 100644
--- a/apps/edr-passenger-web/portal/src/app/booking/confirmation/page.tsx
+++ b/apps/edr-passenger-web/portal/src/app/booking/confirmation/page.tsx
@@ -8,7 +8,7 @@ import { usePaymentStore } from '@/lib/payment-store';
 import { useQuery } from '@tanstack/react-query';
 import { apiClient } from '@/lib/api-client';
 import { useEffect, useState, useRef } from 'react';
-import { CheckCircle, Copy, Train, FileText } from 'lucide-react';
+import { CheckCircle, Clock, Copy, Train, FileText } from 'lucide-react';
 import { format } from 'date-fns';
 import { isChild, isFirstChild } from '@/utils/fare-utils';
 
@@ -45,7 +45,7 @@ export default function ConfirmationPage() {
         return {
           id: bookingId || '',
           pnr: pnr || undefined,
-          status: 'CONFIRMED',
+          status: 'PENDING_PAYMENT',
           totalMinor: passengers.reduce((sum) => sum + (selectedSchedule?.baseFareAdult || 0), 0),
         };
       }
@@ -53,6 +53,10 @@ export default function ConfirmationPage() {
     enabled: !!bookingId,
   });
 
+  // Only trust an actually-confirmed booking to show ticket numbers / a "CONFIRMED" badge —
+  // a gateway redirect back here does not mean payment succeeded (see payment return pages).
+  const isConfirmed = _booking?.status === 'CONFIRMED';
+
   useEffect(() => {
     if (bookingId && !confirmAttempted.current) {
       confirmAttempted.current = true;
@@ -190,14 +194,33 @@ export default function ConfirmationPage() {
           {/* Success Header */}
           <div className="text-center mb-8">
             <div className="flex justify-center mb-4">
-              <div className="w-20 h-20 bg-green-100 dark:bg-green-900/30 rounded-full flex items-center justify-center animate-bounce">
-                <CheckCircle className="w-12 h-12 text-green-600 dark:text-green-400" />
-              </div>
+              {isConfirmed ? (
+                <div className="w-20 h-20 bg-green-100 dark:bg-green-900/30 rounded-full flex items-center justify-center animate-bounce">
+                  <CheckCircle className="w-12 h-12 text-green-600 dark:text-green-400" />
+                </div>
+              ) : (
+                <div className="w-20 h-20 bg-amber-100 dark:bg-amber-900/30 rounded-full flex items-center justify-center">
+                  <Clock className="w-12 h-12 text-amber-600 dark:text-amber-400" />
+                </div>
+              )}
             </div>
-            <h1 className="text-4xl font-bold text-green-600 dark:text-green-400 mb-2">
-              {packageName ? `${packageName} booking confirmed!` : 'Booking confirmed!'}
-            </h1>
-            <p className="text-gray-600 dark:text-gray-400 text-lg">Your train tickets are ready</p>
+            {isConfirmed ? (
+              <>
+                <h1 className="text-4xl font-bold text-green-600 dark:text-green-400 mb-2">
+                  {packageName ? `${packageName} booking confirmed!` : 'Booking confirmed!'}
+                </h1>
+                <p className="text-gray-600 dark:text-gray-400 text-lg">Your train tickets are ready</p>
+              </>
+            ) : (
+              <>
+                <h1 className="text-4xl font-bold text-amber-600 dark:text-amber-400 mb-2">
+                  Booking received — payment pending
+                </h1>
+                <p className="text-gray-600 dark:text-gray-400 text-lg">
+                  We haven&apos;t confirmed your payment yet. Your tickets will be issued once payment is completed.
+                </p>
+              </>
+            )}
           </div>
 
           {/* PNR Card */}
@@ -340,7 +363,9 @@ export default function ConfirmationPage() {
               </div>
               <div>
                 <p className="text-sm text-gray-600 dark:text-gray-400">Status</p>
-                <p className="font-semibold text-green-600 dark:text-green-400">{_booking?.status || 'CONFIRMED'}</p>
+                <p className={`font-semibold ${isConfirmed ? 'text-green-600 dark:text-green-400' : 'text-amber-600 dark:text-amber-400'}`}>
+                  {_booking?.status || 'PENDING_PAYMENT'}
+                </p>
               </div>
               <div>
                 <p className="text-sm text-gray-600 dark:text-gray-400">Passengers</p>
@@ -366,7 +391,9 @@ export default function ConfirmationPage() {
             <div className="space-y-4">
               {passengers.map((passenger, index) => {
                 const backendTicket = _booking?.ticket || null;
-                const ticketNumber = backendTicket?.barcodePayload || `TKT-${bookingId?.slice(0, 8).toUpperCase()}-${(index + 1).toString().padStart(2, '0')}`;
+                const ticketNumber = isConfirmed
+                  ? backendTicket?.barcodePayload || `TKT-${bookingId?.slice(0, 8).toUpperCase()}-${(index + 1).toString().padStart(2, '0')}`
+                  : null;
 
                 return (
                   <div key={index} className="card hover:shadow-lg transition-shadow">
@@ -377,13 +404,17 @@ export default function ConfirmationPage() {
                           <h3 className="text-xl font-bold text-gray-900 dark:text-gray-100">{passenger.name}</h3>
                           <p className="text-sm text-gray-600 dark:text-gray-400">Passenger {index + 1}</p>
                         </div>
-                        <span className="badge badge-success">CONFIRMED</span>
+                        {isConfirmed ? (
+                          <span className="badge badge-success">CONFIRMED</span>
+                        ) : (
+                          <span className="badge badge-warning">AWAITING PAYMENT</span>
+                        )}
                       </div>
-                      
+
                       <div className="grid grid-cols-2 gap-4 text-sm">
                         <div>
                           <p className="text-gray-600 dark:text-gray-400">Ticket Number</p>
-                          <p className="font-semibold text-gray-900 dark:text-gray-100">{ticketNumber}</p>
+                          <p className="font-semibold text-gray-900 dark:text-gray-100">{ticketNumber || 'Pending payment'}</p>
                         </div>
                         <div>
                           <p className="text-gray-600 dark:text-gray-400">Date of Birth</p>
diff --git a/apps/edr-passenger-web/portal/src/app/booking/payment/dmoney/failure/page.tsx b/apps/edr-passenger-web/portal/src/app/booking/payment/dmoney/failure/page.tsx
new file mode 100644
index 000000000..bb66105f3
--- /dev/null
+++ b/apps/edr-passenger-web/portal/src/app/booking/payment/dmoney/failure/page.tsx
@@ -0,0 +1,60 @@
+'use client';
+
+import { useSearchParams, useRouter } from 'next/navigation';
+import { usePaymentStore } from '@/lib/payment-store';
+import { consumeManageBookingPaymentReturn } from '@/utils/manage-booking-return';
+import { useEffect, useState, Suspense } from 'react';
+import { XCircle, Loader2, ChevronLeft } from 'lucide-react';
+
+function DmoneyFailureContent() {
+  const router = useRouter();
+  const searchParams = useSearchParams();
+  const { updateStatus } = usePaymentStore();
+  // A Manage Booking payment (paying for an already-existing booking) has no in-progress
+  // booking-store session to go "back to review" from — send it back to that booking's
+  // detail view instead, where the user can pick a different payment method.
+  const [backTarget, setBackTarget] = useState('/booking/review');
+
+  // D-Money callback query params (mirrors Telebirr)
+  const merchantOrderId = searchParams.get('merchantOrderId') || '';
+  const trxRef     = searchParams.get('trxRef')     || searchParams.get('outTradeNo') || '';
+  const resultCode = searchParams.get('resultCode') || searchParams.get('code')       || '';
+  const resultMsg  = searchParams.get('resultMsg')  || searchParams.get('message')    || 'Payment was not completed.';
+
+  useEffect(() => {
+    const manageBookingRef = consumeManageBookingPaymentReturn();
+    if (manageBookingRef) {
+      setBackTarget(`/booking/detail?ref=${encodeURIComponent(manageBookingRef)}`);
+    }
+    updateStatus('FAILED');
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+
+  return (
+    <div className="min-h-screen bg-gray-50 dark:bg-gray-900 flex items-center justify-center px-4">
+      <div className="bg-white dark:bg-gray-800 rounded-2xl shadow-xl p-8 max-w-md w-full text-center">
+        <XCircle className="w-14 h-14 text-red-500 mx-auto mb-4" />
+        <h1 className="text-xl font-bold text-gray-900 dark:text-white mb-2">Payment Failed</h1>
+        <p className="text-sm text-gray-500 dark:text-gray-400 mb-1">{resultMsg}</p>
+        {resultCode && <p className="text-xs text-gray-400 mb-1">Code: {resultCode}</p>}
+        {merchantOrderId && <p className="text-xs text-gray-400 mb-1">Order ID: {merchantOrderId}</p>}
+        {trxRef && <p className="text-xs text-gray-400 mb-4">Ref: {trxRef}</p>}
+        <div className="flex flex-col gap-3 mt-4">
+          <button onClick={() => router.push(backTarget)}
+            className="btn-secondary w-full flex items-center justify-center gap-2">
+            <ChevronLeft className="w-4 h-4" />
+            Back
+          </button>
+        </div>
+      </div>
+    </div>
+  );
+}
+
+export default function DmoneyFailurePage() {
+  return (
+    <Suspense fallback={<div className="min-h-screen flex items-center justify-center"><Loader2 className="w-10 h-10 animate-spin text-primary" /></div>}>
+      <DmoneyFailureContent />
+    </Suspense>
+  );
+}
diff --git a/apps/edr-passenger-web/portal/src/app/booking/payment/dmoney/success/page.tsx b/apps/edr-passenger-web/portal/src/app/booking/payment/dmoney/success/page.tsx
index 33d6a20f6..cf132bc7f 100644
--- a/apps/edr-passenger-web/portal/src/app/booking/payment/dmoney/success/page.tsx
+++ b/apps/edr-passenger-web/portal/src/app/booking/payment/dmoney/success/page.tsx
@@ -3,15 +3,42 @@
 import { useEffect, useState } from 'react';
 import { useRouter, useSearchParams } from 'next/navigation';
 import { usePaymentStore } from '@/lib/payment-store';
+import { useBookingStore } from '@/lib/booking-store';
 import { consumeManageBookingPaymentReturn } from '@/utils/manage-booking-return';
-import { CheckCircle, Loader2 } from 'lucide-react';
+import { apiClient } from '@/lib/api-client';
+import { CheckCircle, XCircle, Loader2, ChevronLeft } from 'lucide-react';
 import { Suspense } from 'react';
 
+type IntentStatus = 'PENDING' | 'PROCESSING' | 'REQUIRES_ACTION' | 'SUCCEEDED' | 'FAILED';
+type ViewState = 'checking' | 'succeeded' | 'failed' | 'unknown';
+
+// D-Money redirects the browser to this ONE url regardless of outcome — a hit here is not
+// proof of payment. Poll the backend (which reconciles with the provider) before showing
+// "Payment Successful". Real confirmation still happens via the webhook; this only decides
+// what the browser shows.
+async function verifyBookingPaid(bookingId: string): Promise<'SUCCEEDED' | 'FAILED' | 'UNKNOWN'> {
+  const maxAttempts = 5;
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    try {
+      const intent = await apiClient.get<{ status: IntentStatus }>(`/payments/intents/${bookingId}`);
+      if (intent?.status === 'SUCCEEDED') return 'SUCCEEDED';
+      if (intent?.status === 'FAILED') return 'FAILED';
+    } catch {
+      // transient lookup failure — keep retrying until attempts are exhausted
+    }
+    if (attempt < maxAttempts - 1) {
+      await new Promise((resolve) => setTimeout(resolve, 1500));
+    }
+  }
+  return 'UNKNOWN';
+}
+
 function DmoneySuccessContent() {
   const router = useRouter();
   const searchParams = useSearchParams();
   const { updateStatus } = usePaymentStore();
-  const [status, setStatus] = useState<'processing' | 'done' | 'error'>('processing');
+  const { bookingId } = useBookingStore();
+  const [view, setView] = useState<ViewState>('checking');
   const [returnTarget, setReturnTarget] = useState('/booking/confirmation');
 
   // D-Money callback query params (mirrors Telebirr)
@@ -19,30 +46,56 @@ function DmoneySuccessContent() {
   const trxRef  = searchParams.get('trxRef')  || searchParams.get('outTradeNo') || '';
 
   useEffect(() => {
-    // Actual booking confirmation happens server-side via the provider webhook — this page
-    // only reflects that back to the user. A Manage Booking payment (paying for an
-    // already-existing booking) has no in-progress booking-store session to show a
-    // confirmation from, so it goes back to that booking's detail view instead.
+    let cancelled = false;
+
     const manageBookingRef = consumeManageBookingPaymentReturn();
     const target = manageBookingRef ? `/booking/detail?ref=${encodeURIComponent(manageBookingRef)}` : '/booking/confirmation';
     setReturnTarget(target);
-    updateStatus('SUCCEEDED');
-    setStatus('done');
-    setTimeout(() => router.push(target), 1500);
+
+    // Manage Booking sessions don't carry a bookingId in the client store — the detail page
+    // it lands on re-fetches the booking's real status itself, so there's nothing to verify
+    // client-side here; just hand off without claiming an outcome we can't confirm.
+    if (!bookingId) {
+      if (!cancelled) {
+        router.push(target);
+      }
+      return;
+    }
+
+    verifyBookingPaid(bookingId).then((result) => {
+      if (cancelled) return;
+      if (result === 'SUCCEEDED') {
+        updateStatus('SUCCEEDED');
+        setView('succeeded');
+        setTimeout(() => router.push(target), 1500);
+      } else if (result === 'FAILED') {
+        updateStatus('FAILED');
+        setView('failed');
+      } else {
+        // Still not confirmed after polling — don't claim success or failure. Hand off to
+        // /booking/confirmation, which now reflects the booking's real (pending) status.
+        setView('unknown');
+        setTimeout(() => router.push(target), 1500);
+      }
+    });
+
+    return () => {
+      cancelled = true;
+    };
   // eslint-disable-next-line react-hooks/exhaustive-deps
   }, []);
 
   return (
     <div className="min-h-screen bg-gray-50 dark:bg-gray-900 flex items-center justify-center px-4">
       <div className="bg-white dark:bg-gray-800 rounded-2xl shadow-xl p-8 max-w-md w-full text-center">
-        {status === 'processing' && (
+        {view === 'checking' && (
           <>
             <Loader2 className="w-14 h-14 text-primary animate-spin mx-auto mb-4" />
             <h1 className="text-xl font-bold text-gray-900 dark:text-white mb-2">Confirming payment…</h1>
             <p className="text-sm text-gray-500 dark:text-gray-400">Please wait while we confirm your D-Money payment.</p>
           </>
         )}
-        {status === 'done' && (
+        {view === 'succeeded' && (
           <>
             <CheckCircle className="w-14 h-14 text-green-500 mx-auto mb-4" />
             <h1 className="text-xl font-bold text-gray-900 dark:text-white mb-2">Payment Successful!</h1>
@@ -52,15 +105,25 @@ function DmoneySuccessContent() {
             <p className="text-xs text-gray-400 mt-3">Redirecting…</p>
           </>
         )}
-        {status === 'error' && (
+        {view === 'failed' && (
           <>
-            <div className="w-14 h-14 rounded-full bg-red-100 flex items-center justify-center mx-auto mb-4">
-              <span className="text-3xl">⚠️</span>
-            </div>
-            <h1 className="text-xl font-bold text-gray-900 dark:text-white mb-2">Something went wrong</h1>
-            <p className="text-sm text-red-500 mb-4">Unable to confirm payment</p>
+            <XCircle className="w-14 h-14 text-red-500 mx-auto mb-4" />
+            <h1 className="text-xl font-bold text-gray-900 dark:text-white mb-2">Payment Failed</h1>
+            <p className="text-sm text-gray-500 dark:text-gray-400 mb-4">Your D-Money payment was not completed.</p>
             <button onClick={() => router.push(returnTarget)}
-              className="btn-primary w-full">Continue</button>
+              className="btn-secondary w-full flex items-center justify-center gap-2">
+              <ChevronLeft className="w-4 h-4" />
+              Back
+            </button>
+          </>
+        )}
+        {view === 'unknown' && (
+          <>
+            <Loader2 className="w-14 h-14 text-amber-500 animate-spin mx-auto mb-4" />
+            <h1 className="text-xl font-bold text-gray-900 dark:text-white mb-2">Still confirming…</h1>
+            <p className="text-sm text-gray-500 dark:text-gray-400">
+              We haven&apos;t received final confirmation from D-Money yet. Taking you to your booking status.
+            </p>
           </>
         )}
       </div>
diff --git a/apps/edr-passenger-web/portal/src/app/booking/payment/page.tsx b/apps/edr-passenger-web/portal/src/app/booking/payment/page.tsx
index a95179762..ceb54acd9 100644
--- a/apps/edr-passenger-web/portal/src/app/booking/payment/page.tsx
+++ b/apps/edr-passenger-web/portal/src/app/booking/payment/page.tsx
@@ -436,7 +436,7 @@ export default function PaymentPage() {
                   </div>
                 ) : (
                   <div className="space-y-3">
-                    {paymentMethods.map((method) => {
+                    {paymentMethods.filter(m => m.enabled).map((method) => {
                       const Icon = getIconForMethod(method.type);
                       const isSelected = selectedMethod === method.type;
                       return (
diff --git a/apps/edr-passenger-web/portal/src/app/booking/payment/telebirr/success/page.tsx b/apps/edr-passenger-web/portal/src/app/booking/payment/telebirr/success/page.tsx
index 1a830cee3..a47fdd07c 100644
--- a/apps/edr-passenger-web/portal/src/app/booking/payment/telebirr/success/page.tsx
+++ b/apps/edr-passenger-web/portal/src/app/booking/payment/telebirr/success/page.tsx
@@ -3,15 +3,42 @@
 import { useEffect, useState } from 'react';
 import { useRouter, useSearchParams } from 'next/navigation';
 import { usePaymentStore } from '@/lib/payment-store';
+import { useBookingStore } from '@/lib/booking-store';
 import { consumeManageBookingPaymentReturn } from '@/utils/manage-booking-return';
-import { CheckCircle, Loader2 } from 'lucide-react';
+import { apiClient } from '@/lib/api-client';
+import { CheckCircle, XCircle, Loader2, ChevronLeft } from 'lucide-react';
 import { Suspense } from 'react';
 
+type IntentStatus = 'PENDING' | 'PROCESSING' | 'REQUIRES_ACTION' | 'SUCCEEDED' | 'FAILED';
+type ViewState = 'checking' | 'succeeded' | 'failed' | 'unknown';
+
+// Telebirr redirects the browser to this ONE url regardless of outcome — a hit here is not
+// proof of payment. Poll the backend (which reconciles with the provider) before showing
+// "Payment Successful". Real confirmation still happens via the webhook; this only decides
+// what the browser shows.
+async function verifyBookingPaid(bookingId: string): Promise<'SUCCEEDED' | 'FAILED' | 'UNKNOWN'> {
+  const maxAttempts = 5;
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    try {
+      const intent = await apiClient.get<{ status: IntentStatus }>(`/payments/intents/${bookingId}`);
+      if (intent?.status === 'SUCCEEDED') return 'SUCCEEDED';
+      if (intent?.status === 'FAILED') return 'FAILED';
+    } catch {
+      // transient lookup failure — keep retrying until attempts are exhausted
+    }
+    if (attempt < maxAttempts - 1) {
+      await new Promise((resolve) => setTimeout(resolve, 1500));
+    }
+  }
+  return 'UNKNOWN';
+}
+
 function TelebirrSuccessContent() {
   const router = useRouter();
   const searchParams = useSearchParams();
   const { updateStatus } = usePaymentStore();
-  const [status, setStatus] = useState<'processing' | 'done' | 'error'>('processing');
+  const { bookingId } = useBookingStore();
+  const [view, setView] = useState<ViewState>('checking');
   const [returnTarget, setReturnTarget] = useState('/booking/confirmation');
 
   // Telebirr callback query params
@@ -19,30 +46,56 @@ function TelebirrSuccessContent() {
   const trxRef  = searchParams.get('trxRef')  || searchParams.get('outTradeNo') || '';
 
   useEffect(() => {
-    // Actual booking confirmation happens server-side via the provider webhook — this page
-    // only reflects that back to the user. A Manage Booking payment (paying for an
-    // already-existing booking) has no in-progress booking-store session to show a
-    // confirmation from, so it goes back to that booking's detail view instead.
+    let cancelled = false;
+
     const manageBookingRef = consumeManageBookingPaymentReturn();
     const target = manageBookingRef ? `/booking/detail?ref=${encodeURIComponent(manageBookingRef)}` : '/booking/confirmation';
     setReturnTarget(target);
-    updateStatus('SUCCEEDED');
-    setStatus('done');
-    setTimeout(() => router.push(target), 1500);
+
+    // Manage Booking sessions don't carry a bookingId in the client store — the detail page
+    // it lands on re-fetches the booking's real status itself, so there's nothing to verify
+    // client-side here; just hand off without claiming an outcome we can't confirm.
+    if (!bookingId) {
+      if (!cancelled) {
+        router.push(target);
+      }
+      return;
+    }
+
+    verifyBookingPaid(bookingId).then((result) => {
+      if (cancelled) return;
+      if (result === 'SUCCEEDED') {
+        updateStatus('SUCCEEDED');
+        setView('succeeded');
+        setTimeout(() => router.push(target), 1500);
+      } else if (result === 'FAILED') {
+        updateStatus('FAILED');
+        setView('failed');
+      } else {
+        // Still not confirmed after polling — don't claim success or failure. Hand off to
+        // /booking/confirmation, which now reflects the booking's real (pending) status.
+        setView('unknown');
+        setTimeout(() => router.push(target), 1500);
+      }
+    });
+
+    return () => {
+      cancelled = true;
+    };
   // eslint-disable-next-line react-hooks/exhaustive-deps
   }, []);
 
   return (
     <div className="min-h-screen bg-gray-50 dark:bg-gray-900 flex items-center justify-center px-4">
       <div className="bg-white dark:bg-gray-800 rounded-2xl shadow-xl p-8 max-w-md w-full text-center">
-        {status === 'processing' && (
+        {view === 'checking' && (
           <>
             <Loader2 className="w-14 h-14 text-primary animate-spin mx-auto mb-4" />
             <h1 className="text-xl font-bold text-gray-900 dark:text-white mb-2">Confirming payment…</h1>
             <p className="text-sm text-gray-500 dark:text-gray-400">Please wait while we confirm your Telebirr payment.</p>
           </>
         )}
-        {status === 'done' && (
+        {view === 'succeeded' && (
           <>
             <CheckCircle className="w-14 h-14 text-green-500 mx-auto mb-4" />
             <h1 className="text-xl font-bold text-gray-900 dark:text-white mb-2">Payment Successful!</h1>
@@ -52,15 +105,25 @@ function TelebirrSuccessContent() {
             <p className="text-xs text-gray-400 mt-3">Redirecting…</p>
           </>
         )}
-        {status === 'error' && (
+        {view === 'failed' && (
           <>
-            <div className="w-14 h-14 rounded-full bg-red-100 flex items-center justify-center mx-auto mb-4">
-              <span className="text-3xl">⚠️</span>
-            </div>
-            <h1 className="text-xl font-bold text-gray-900 dark:text-white mb-2">Something went wrong</h1>
-            <p className="text-sm text-red-500 mb-4">Unable to confirm payment</p>
+            <XCircle className="w-14 h-14 text-red-500 mx-auto mb-4" />
+            <h1 className="text-xl font-bold text-gray-900 dark:text-white mb-2">Payment Failed</h1>
+            <p className="text-sm text-gray-500 dark:text-gray-400 mb-4">Your Telebirr payment was not completed.</p>
             <button onClick={() => router.push(returnTarget)}
-              className="btn-primary w-full">Continue</button>
+              className="btn-secondary w-full flex items-center justify-center gap-2">
+              <ChevronLeft className="w-4 h-4" />
+              Back
+            </button>
+          </>
+        )}
+        {view === 'unknown' && (
+          <>
+            <Loader2 className="w-14 h-14 text-amber-500 animate-spin mx-auto mb-4" />
+            <h1 className="text-xl font-bold text-gray-900 dark:text-white mb-2">Still confirming…</h1>
+            <p className="text-sm text-gray-500 dark:text-gray-400">
+              We haven&apos;t received final confirmation from Telebirr yet. Taking you to your booking status.
+            </p>
           </>
         )}
       </div>
diff --git a/apps/edr-passenger-web/portal/src/app/booking/payment/waafi/success/page.tsx b/apps/edr-passenger-web/portal/src/app/booking/payment/waafi/success/page.tsx
index c75a0c390..89a8b3098 100644
--- a/apps/edr-passenger-web/portal/src/app/booking/payment/waafi/success/page.tsx
+++ b/apps/edr-passenger-web/portal/src/app/booking/payment/waafi/success/page.tsx
@@ -3,14 +3,41 @@
 import { useEffect, useState, Suspense } from 'react';
 import { useRouter, useSearchParams } from 'next/navigation';
 import { usePaymentStore } from '@/lib/payment-store';
+import { useBookingStore } from '@/lib/booking-store';
 import { consumeManageBookingPaymentReturn } from '@/utils/manage-booking-return';
-import { CheckCircle, Loader2 } from 'lucide-react';
+import { apiClient } from '@/lib/api-client';
+import { CheckCircle, XCircle, Loader2, ChevronLeft } from 'lucide-react';
+
+type IntentStatus = 'PENDING' | 'PROCESSING' | 'REQUIRES_ACTION' | 'SUCCEEDED' | 'FAILED';
+type ViewState = 'checking' | 'succeeded' | 'failed' | 'unknown';
+
+// Waafi registers a dedicated success URL, but a hit here still isn't proof of payment on
+// its own (gateway redirect vs. real settlement can disagree). Poll the backend (which
+// reconciles with the provider) before showing "Payment Successful".
+async function verifyBookingPaid(bookingId: string): Promise<'SUCCEEDED' | 'FAILED' | 'UNKNOWN'> {
+  const maxAttempts = 5;
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    try {
+      const intent = await apiClient.get<{ status: IntentStatus }>(`/payments/intents/${bookingId}`);
+      if (intent?.status === 'SUCCEEDED') return 'SUCCEEDED';
+      if (intent?.status === 'FAILED') return 'FAILED';
+    } catch {
+      // transient lookup failure — keep retrying until attempts are exhausted
+    }
+    if (attempt < maxAttempts - 1) {
+      await new Promise((resolve) => setTimeout(resolve, 1500));
+    }
+  }
+  return 'UNKNOWN';
+}
 
 function WaafiSuccessContent() {
   const router = useRouter();
   const searchParams = useSearchParams();
   const { updateStatus } = usePaymentStore();
-  const [status, setStatus] = useState<'processing' | 'done' | 'error'>('processing');
+  const { bookingId } = useBookingStore();
+  const [view, setView] = useState<ViewState>('checking');
+  const [returnTarget, setReturnTarget] = useState('/booking/confirmation');
 
   // Waafi callback query params
   const referenceId   = searchParams.get('referenceId')   || '';
@@ -19,29 +46,56 @@ function WaafiSuccessContent() {
   const currency      = searchParams.get('currency')       || '';
 
   useEffect(() => {
-    // Actual booking confirmation happens server-side via the provider webhook — this page
-    // only reflects that back to the user. A Manage Booking payment (paying for an
-    // already-existing booking) has no in-progress booking-store session to show a
-    // confirmation from, so it goes back to that booking's detail view instead.
+    let cancelled = false;
+
     const manageBookingRef = consumeManageBookingPaymentReturn();
     const target = manageBookingRef ? `/booking/detail?ref=${encodeURIComponent(manageBookingRef)}` : '/booking/confirmation';
-    updateStatus('SUCCEEDED');
-    setStatus('done');
-    setTimeout(() => router.push(target), 1500);
+    setReturnTarget(target);
+
+    // Manage Booking sessions don't carry a bookingId in the client store — the detail page
+    // it lands on re-fetches the booking's real status itself, so there's nothing to verify
+    // client-side here; just hand off without claiming an outcome we can't confirm.
+    if (!bookingId) {
+      if (!cancelled) {
+        router.push(target);
+      }
+      return;
+    }
+
+    verifyBookingPaid(bookingId).then((result) => {
+      if (cancelled) return;
+      if (result === 'SUCCEEDED') {
+        updateStatus('SUCCEEDED');
+        setView('succeeded');
+        setTimeout(() => router.push(target), 1500);
+      } else if (result === 'FAILED') {
+        updateStatus('FAILED');
+        setView('failed');
+      } else {
+        // Still not confirmed after polling — don't claim success or failure. Hand off to
+        // /booking/confirmation, which now reflects the booking's real (pending) status.
+        setView('unknown');
+        setTimeout(() => router.push(target), 1500);
+      }
+    });
+
+    return () => {
+      cancelled = true;
+    };
   // eslint-disable-next-line react-hooks/exhaustive-deps
   }, []);
 
   return (
     <div className="min-h-screen bg-gray-50 dark:bg-gray-900 flex items-center justify-center px-4">
       <div className="bg-white dark:bg-gray-800 rounded-2xl shadow-xl p-8 max-w-md w-full text-center">
-        {status === 'processing' && (
+        {view === 'checking' && (
           <>
             <Loader2 className="w-14 h-14 text-primary animate-spin mx-auto mb-4" />
             <h1 className="text-xl font-bold text-gray-900 dark:text-white mb-2">Confirming payment…</h1>
             <p className="text-sm text-gray-500 dark:text-gray-400">Please wait while we confirm your Waafi payment.</p>
           </>
         )}
-        {status === 'done' && (
+        {view === 'succeeded' && (
           <>
             <CheckCircle className="w-14 h-14 text-green-500 mx-auto mb-4" />
             <h1 className="text-xl font-bold text-gray-900 dark:text-white mb-2">Payment Successful!</h1>
@@ -54,6 +108,27 @@ function WaafiSuccessContent() {
             <p className="text-xs text-gray-400 mt-3">Redirecting…</p>
           </>
         )}
+        {view === 'failed' && (
+          <>
+            <XCircle className="w-14 h-14 text-red-500 mx-auto mb-4" />
+            <h1 className="text-xl font-bold text-gray-900 dark:text-white mb-2">Payment Failed</h1>
+            <p className="text-sm text-gray-500 dark:text-gray-400 mb-4">Your Waafi payment was not completed.</p>
+            <button onClick={() => router.push(returnTarget)}
+              className="btn-secondary w-full flex items-center justify-center gap-2">
+              <ChevronLeft className="w-4 h-4" />
+              Back
+            </button>
+          </>
+        )}
+        {view === 'unknown' && (
+          <>
+            <Loader2 className="w-14 h-14 text-amber-500 animate-spin mx-auto mb-4" />
+            <h1 className="text-xl font-bold text-gray-900 dark:text-white mb-2">Still confirming…</h1>
+            <p className="text-sm text-gray-500 dark:text-gray-400">
+              We haven&apos;t received final confirmation from Waafi yet. Taking you to your booking status.
+            </p>
+          </>
+        )}
       </div>
     </div>
   );
diff --git a/apps/edr-passenger-web/portal/src/app/booking/results/page.tsx b/apps/edr-passenger-web/portal/src/app/booking/results/page.tsx
index 77a18380f..0f8ac2004 100644
--- a/apps/edr-passenger-web/portal/src/app/booking/results/page.tsx
+++ b/apps/edr-passenger-web/portal/src/app/booking/results/page.tsx
@@ -1,57 +1,106 @@
-'use client';
+"use client";
 
-import { useSearchParams, useRouter } from 'next/navigation';
-import { useQuery } from '@tanstack/react-query';
-import { apiClient } from '@/lib/api-client';
-import { useBookingStore } from '@/lib/booking-store';
-import { Schedule } from '@/types';
-import { ArrowRight, Clock, Calendar, Users, ChevronLeft, Check, X, MapPin, Gift, Train, Bed, Armchair, Star } from 'lucide-react';
-import { format } from 'date-fns';
-import { formatTime, getTimePeriod } from '@/utils/format';
-import { useState, useEffect } from 'react';
+import { useSearchParams, useRouter } from "next/navigation";
+import { useQuery } from "@tanstack/react-query";
+import { apiClient } from "@/lib/api-client";
+import { useBookingStore } from "@/lib/booking-store";
+import { Schedule } from "@/types";
+import {
+  ArrowRight,
+  Clock,
+  Calendar,
+  Users,
+  ChevronLeft,
+  Check,
+  X,
+  MapPin,
+  Gift,
+  Train,
+  Bed,
+  Armchair,
+  Star,
+} from "lucide-react";
+import { format } from "date-fns";
+import { formatTime, getTimePeriod } from "@/utils/format";
+import { useState, useEffect } from "react";
 
 export default function ResultsPage() {
   const router = useRouter();
   const searchParams = useSearchParams();
-  const { setSelectedSchedule, setOutboundSchedule, setInboundSchedule } = useBookingStore();
-  const [selectedCoachTypes, setSelectedCoachTypes] = useState<Record<string, { id: string; code: string; name: string }>>({});
+  const { setSelectedSchedule, setOutboundSchedule, setInboundSchedule } =
+    useBookingStore();
+  const [selectedCoachTypes, setSelectedCoachTypes] = useState<
+    Record<string, { id: string; code: string; name: string }>
+  >({});
   const [outboundScheduleData, setOutboundScheduleData] = useState<any>(
     () => useBookingStore.getState().outboundSchedule,
   );
   const [classModal, setClassModal] = useState<Schedule | null>(null);
-  const [promoData, setPromoData] = useState<{ code: string; discount: string; message: string } | null>(null);
-  const [roundTripStep, setRoundTripStep] = useState<'outbound' | 'inbound'>(() => {
-    const { outboundSchedule, searchCriteria: sc } = useBookingStore.getState();
-    return outboundSchedule && sc?.tripType === 'ROUND_TRIP' ? 'inbound' : 'outbound';
-  });
+  const [promoData, setPromoData] = useState<{
+    code: string;
+    discount: string;
+    message: string;
+  } | null>(null);
+  const [roundTripStep, setRoundTripStep] = useState<"outbound" | "inbound">(
+    () => {
+      const { outboundSchedule, searchCriteria: sc } =
+        useBookingStore.getState();
+      return outboundSchedule && sc?.tripType === "ROUND_TRIP"
+        ? "inbound"
+        : "outbound";
+    },
+  );
 
   const searchCriteria = useBookingStore((s) => s.searchCriteria);
   const setSearchCriteria = useBookingStore((s) => s.setSearchCriteria);
 
   const searchData = {
-    originStationId: searchParams.get('origin') || searchCriteria?.originStationId || '',
-    destinationStationId: searchParams.get('destination') || searchCriteria?.destinationStationId || '',
-    date: searchParams.get('date') || searchCriteria?.departureDate || '',
-    returnDate: searchParams.get('returnDate') || searchCriteria?.returnDate,
-    journeyType: (searchParams.get('tripType') ?? searchCriteria?.tripType ?? 'ONE_WAY') === 'ROUND_TRIP' ? 'ROUND_TRIP' : 'ONE_WAY',
-    adultCount: parseInt(searchParams.get('adults') || '') || searchCriteria?.adultCount || 1,
-    childCount: parseInt(searchParams.get('children') || '') || searchCriteria?.childCount || 0,
-    nationality: searchParams.get('nationality') || searchCriteria?.nationality || 'ETHIOPIAN',
-    promoCode: searchParams.get('promoCode') || searchCriteria?.promoCode || '',
+    originStationId:
+      searchParams.get("origin") || searchCriteria?.originStationId || "",
+    destinationStationId:
+      searchParams.get("destination") ||
+      searchCriteria?.destinationStationId ||
+      "",
+    date: searchParams.get("date") || searchCriteria?.departureDate || "",
+    returnDate: searchParams.get("returnDate") || searchCriteria?.returnDate,
+    journeyType:
+      (searchParams.get("tripType") ??
+        searchCriteria?.tripType ??
+        "ONE_WAY") === "ROUND_TRIP"
+        ? "ROUND_TRIP"
+        : "ONE_WAY",
+    adultCount:
+      parseInt(searchParams.get("adults") || "") ||
+      searchCriteria?.adultCount ||
+      1,
+    childCount:
+      parseInt(searchParams.get("children") || "") ||
+      searchCriteria?.childCount ||
+      0,
+    nationality:
+      searchParams.get("nationality") ||
+      searchCriteria?.nationality ||
+      "ETHIOPIAN",
+    promoCode: searchParams.get("promoCode") || searchCriteria?.promoCode || "",
   };
 
   useEffect(() => {
-    if (searchParams.get('origin')) {
+    if (searchParams.get("origin")) {
       setSearchCriteria({
-        tripType: (searchParams.get('tripType') || 'ONE_WAY') as 'ONE_WAY' | 'ROUND_TRIP',
-        originStationId: searchParams.get('origin')!,
-        destinationStationId: searchParams.get('destination')!,
-        departureDate: searchParams.get('date')!,
-        returnDate: searchParams.get('returnDate') || undefined,
-        adultCount: parseInt(searchParams.get('adults') || '1'),
-        childCount: parseInt(searchParams.get('children') || '0'),
-        nationality: (searchParams.get('nationality') || 'ETHIOPIAN') as 'ETHIOPIAN' | 'DJIBOUTIAN' | 'OTHER',
-        promoCode: searchParams.get('promoCode') || '',
+        tripType: (searchParams.get("tripType") || "ONE_WAY") as
+          | "ONE_WAY"
+          | "ROUND_TRIP",
+        originStationId: searchParams.get("origin")!,
+        destinationStationId: searchParams.get("destination")!,
+        departureDate: searchParams.get("date")!,
+        returnDate: searchParams.get("returnDate") || undefined,
+        adultCount: parseInt(searchParams.get("adults") || "1"),
+        childCount: parseInt(searchParams.get("children") || "0"),
+        nationality: (searchParams.get("nationality") || "ETHIOPIAN") as
+          | "ETHIOPIAN"
+          | "DJIBOUTIAN"
+          | "OTHER",
+        promoCode: searchParams.get("promoCode") || "",
       });
     }
   }, [searchParams, setSearchCriteria]);
@@ -59,13 +108,13 @@ export default function ResultsPage() {
   useEffect(() => {
     if (searchData.promoCode) {
       apiClient
-        .post('/promos/validate', { code: searchData.promoCode })
+        .post("/promos/validate", { code: searchData.promoCode })
         .then((response: any) => {
           if (response.applicable || response.valid) {
             setPromoData({
               code: searchData.promoCode,
-              discount: response.message || 'Discount applied',
-              message: response.message || 'Promo code applied successfully!',
+              discount: response.message || "Discount applied",
+              message: response.message || "Promo code applied successfully!",
             });
           }
         })
@@ -90,8 +139,12 @@ export default function ResultsPage() {
     return `/booking/search?${params}`;
   };
 
-  const { data: results, isLoading, error } = useQuery<any>({
-    queryKey: ['search', searchData],
+  const {
+    data: results,
+    isLoading,
+    error,
+  } = useQuery<any>({
+    queryKey: ["search", searchData],
     queryFn: async (): Promise<any> => {
       const payload: any = {
         originStationId: searchData.originStationId,
@@ -102,15 +155,13 @@ export default function ResultsPage() {
         nationality: searchData.nationality,
         journeyType: searchData.journeyType,
       };
-      
-      if (searchData.journeyType === 'ROUND_TRIP' && searchData.returnDate) {
+
+      if (searchData.journeyType === "ROUND_TRIP" && searchData.returnDate) {
         payload.returnDate = searchData.returnDate;
       }
-      
-      
-      const response = await apiClient.post('/search', payload) as any;
-      
-      
+
+      const response = (await apiClient.post("/search", payload)) as any;
+
       return response;
     },
     enabled: !!searchData.originStationId && !!searchData.destinationStationId,
@@ -118,20 +169,20 @@ export default function ResultsPage() {
     gcTime: 0,
   });
 
-  const isRoundTrip = searchData.journeyType === 'ROUND_TRIP';
-  
+  const isRoundTrip = searchData.journeyType === "ROUND_TRIP";
+
   // Handle both response formats:
   // 1. One-way: response can be array of schedules OR object with journeyType and outbound
   // 2. Round-trip: response has journeyType, outbound, inbound properties
   let outboundSchedules: Schedule[] = [];
   let inboundSchedules: Schedule[] = [];
-  
+
   if (results) {
-    if (results.journeyType === 'ROUND_TRIP') {
+    if (results.journeyType === "ROUND_TRIP") {
       // Round trip response format
       outboundSchedules = results.outbound || [];
       inboundSchedules = results.inbound || [];
-    } else if (results.journeyType === 'ONE_WAY' && results.outbound) {
+    } else if (results.journeyType === "ONE_WAY" && results.outbound) {
       // One-way response format with outbound array
       outboundSchedules = results.outbound || [];
     } else if (Array.isArray(results)) {
@@ -142,40 +193,68 @@ export default function ResultsPage() {
       outboundSchedules = results.data;
     }
   }
-  
-  // Alternatives are surfaced whenever a leg returns no exact-date results.
-  const alternativeOutbound: Schedule[] = (!!results && outboundSchedules.length === 0) ? (results?.alternativeOutbound || []) : [];
-  const alternativeInbound: Schedule[] = (isRoundTrip && !!results && inboundSchedules.length === 0) ? (results?.alternativeInbound || []) : [];
-  const requestedDate: string = (results && results.requestedDate) || searchData.date;
-  const requestedReturnDate: string = (results && results.requestedReturnDate) || searchData.returnDate || '';
 
-  const isOneWayNoOutbound = !isRoundTrip && !!results && outboundSchedules.length === 0;
+  // Alternatives are surfaced whenever a leg returns no exact-date results.
+  const alternativeOutbound: Schedule[] =
+    !!results && outboundSchedules.length === 0
+      ? results?.alternativeOutbound || []
+      : [];
+  const alternativeInbound: Schedule[] =
+    isRoundTrip && !!results && inboundSchedules.length === 0
+      ? results?.alternativeInbound || []
+      : [];
+  const requestedDate: string =
+    (results && results.requestedDate) || searchData.date;
+  const requestedReturnDate: string =
+    (results && results.requestedReturnDate) || searchData.returnDate || "";
+
+  const isOneWayNoOutbound =
+    !isRoundTrip && !!results && outboundSchedules.length === 0;
   // Round-trip: show results view if either leg has exact results OR alternatives.
   // One-way: need at least one outbound result.
   const hasResults = isRoundTrip
-    ? (outboundSchedules.length > 0 || alternativeOutbound.length > 0) || (inboundSchedules.length > 0 || alternativeInbound.length > 0)
+    ? outboundSchedules.length > 0 ||
+      alternativeOutbound.length > 0 ||
+      inboundSchedules.length > 0 ||
+      alternativeInbound.length > 0
     : outboundSchedules.length > 0;
 
-  const handleSelectCoachType = (scheduleId: string, coachTypeId: string, coachTypeCode: string, coachTypeName: string, seatClassName: string) => {
-    setSelectedCoachTypes(prev => ({ ...prev, [scheduleId]: { id: coachTypeId, code: coachTypeCode, name: coachTypeName, seatClassName } }));
+  const handleSelectCoachType = (
+    scheduleId: string,
+    coachTypeId: string,
+    coachTypeCode: string,
+    coachTypeName: string,
+    seatClassName: string,
+  ) => {
+    setSelectedCoachTypes((prev) => ({
+      ...prev,
+      [scheduleId]: {
+        id: coachTypeId,
+        code: coachTypeCode,
+        name: coachTypeName,
+        seatClassName,
+      },
+    }));
   };
 
   const handleSelect = (schedule: Schedule, isOutbound: boolean = false) => {
-    const scheduleId = schedule.scheduleId || schedule.id || '';
+    const scheduleId = schedule.scheduleId || schedule.id || "";
     const selectedCoachType = selectedCoachTypes[scheduleId];
-    
+
     if (!selectedCoachType) {
-      alert('Please select a coach type before continuing');
+      alert("Please select a coach type before continuing");
       return;
     }
 
     // Find the coach type to get pricing info
-    const coachType = schedule.coachTypes?.find(ct => ct.coachTypeCode === selectedCoachType.code);
+    const coachType = schedule.coachTypes?.find(
+      (ct) => ct.coachTypeCode === selectedCoachType.code,
+    );
     // Use displayAmountMinor (passenger's currency) so stored fare matches what the card showed.
     const minFare = coachType?.classes.length
-      ? Math.min(...coachType.classes.map(c => c.baseFareMinor))
+      ? Math.min(...coachType.classes.map((c) => c.baseFareMinor))
       : 0;
-    const fareCurrency = 'ETB';
+    const fareCurrency = "ETB";
 
     const hours = Math.floor((schedule.durationMinutes || 0) / 60);
     const minutes = (schedule.durationMinutes || 0) % 60;
@@ -184,12 +263,13 @@ export default function ResultsPage() {
     const scheduleData = {
       id: scheduleId,
       trainNumber: schedule.trainNumber,
-      origin: schedule.origin?.name || 'Origin',
-      destination: schedule.destination?.name || 'Destination',
-      originStationId: schedule.origin?.id || schedule.originStationId || '',
-      destinationStationId: schedule.destination?.id || schedule.destinationStationId || '',
-      departureTime: schedule.departureAt || schedule.departureTime || '',
-      arrivalTime: schedule.arrivalAt || schedule.arrivalTime || '',
+      origin: schedule.origin?.name || "Origin",
+      destination: schedule.destination?.name || "Destination",
+      originStationId: schedule.origin?.id || schedule.originStationId || "",
+      destinationStationId:
+        schedule.destination?.id || schedule.destinationStationId || "",
+      departureTime: schedule.departureAt || schedule.departureTime || "",
+      arrivalTime: schedule.arrivalAt || schedule.arrivalTime || "",
       duration: durationStr,
       baseFareAdult: minFare,
       baseFareChild: minFare,
@@ -199,7 +279,8 @@ export default function ResultsPage() {
       selectedCoachTypeId: selectedCoachType.id,
       selectedCoachTypeCode: selectedCoachType.code,
       selectedCoachTypeName: selectedCoachType.name,
-      seatClassName: (selectedCoachType as any).seatClassName || selectedCoachType.name,
+      seatClassName:
+        (selectedCoachType as any).seatClassName || selectedCoachType.name,
       // Retained so the seat map's coach preview can price a switch to a different
       // coach type without needing a fresh API call.
       coachTypes: schedule.coachTypes || [],
@@ -210,8 +291,8 @@ export default function ResultsPage() {
       setOutboundScheduleData(scheduleData);
       setOutboundSchedule(scheduleData);
       setClassModal(null);
-      setRoundTripStep('inbound');
-      window.scrollTo({ top: 0, behavior: 'smooth' });
+      setRoundTripStep("inbound");
+      window.scrollTo({ top: 0, behavior: "smooth" });
       return;
     }
 
@@ -223,8 +304,8 @@ export default function ResultsPage() {
       // For one-way
       setSelectedSchedule(scheduleData);
     }
-    
-    router.push('/booking/auth-check');
+
+    router.push("/booking/auth-check");
   };
 
   // Shared "Choose Your Coach" drawer — used by both the normal results view and the
@@ -233,121 +314,181 @@ export default function ResultsPage() {
   const renderClassModal = () => {
     if (!classModal) return null;
 
-    const scheduleId = classModal.scheduleId || classModal.id || '';
+    const scheduleId = classModal.scheduleId || classModal.id || "";
     const selectedCoachType = selectedCoachTypes[scheduleId];
     const isOutbound = (classModal as any).isOutbound;
     // Dining coaches aren't bookable seat/bed classes — exclude them from selection.
-    const coachTypes = (classModal.coachTypes || []).filter((ct: any) => ct.coachTypeCode !== 'DPC');
+    const coachTypes = (classModal.coachTypes || []).filter(
+      (ct: any) => ct.coachTypeCode !== "DPC",
+    );
 
     const getCoachIcon = (typeName: string) => {
       const lower = typeName.toLowerCase();
-      if (lower.includes('soft') || lower.includes('vip')) return Star;
-      if (lower.includes('bed')) return Bed;
+      if (lower.includes("soft") || lower.includes("vip")) return Star;
+      if (lower.includes("bed")) return Bed;
       return Armchair;
     };
 
     return (
       <>
-        <div className="fixed inset-0 z-[99] bg-black/50 backdrop-blur-sm" onClick={() => setClassModal(null)} />
-        <div className="fixed inset-y-0 right-0 z-[100] w-full sm:w-[680px] lg:w-[95vw] xl:w-[90vw] 2xl:w-[85vw] max-w-[1400px] bg-white dark:bg-gray-900 shadow-2xl flex flex-col"
-          style={{ animation: 'drawer-slide-in 0.3s cubic-bezier(0.22,1,0.36,1)' }}
+        <div
+          className="fixed inset-0 z-[99] bg-black/50 backdrop-blur-sm"
+          onClick={() => setClassModal(null)}
+        />
+        <div
+          className="fixed inset-y-0 right-0 z-[100] w-full sm:w-[680px] lg:w-[95vw] xl:w-[90vw] 2xl:w-[85vw] max-w-[1400px] bg-white dark:bg-gray-900 shadow-2xl flex flex-col"
+          style={{
+            animation: "drawer-slide-in 0.3s cubic-bezier(0.22,1,0.36,1)",
+          }}
         >
-            <div className="flex items-center justify-between px-6 py-5 border-b border-gray-100 dark:border-gray-800 flex-shrink-0">
-              <div>
-                <h2 className="text-lg font-bold text-gray-900 dark:text-white">Choose Your Coach</h2>
-                <p className="text-xs text-gray-500 dark:text-gray-400 mt-1 flex items-center gap-1.5">
-                  <Train className="w-3.5 h-3.5" />
-                  <span className="font-medium">{classModal.trainNumber}</span>
-                  <span className="text-gray-400">·</span>
-                  <span>{classModal.origin?.name} → {classModal.destination?.name}</span>
-                </p>
-              </div>
-              <button
-                type="button"
-                onClick={() => setClassModal(null)}
-                className="w-10 h-10 flex items-center justify-center rounded-full hover:bg-gray-100 dark:hover:bg-gray-800 transition-all"
-                aria-label="Close"
-              >
-                <X className="w-5 h-5 text-gray-500" />
-              </button>
+          <div className="flex items-center justify-between px-6 py-5 border-b border-gray-100 dark:border-gray-800 flex-shrink-0">
+            <div>
+              <h2 className="text-lg font-bold text-gray-900 dark:text-white">
+                Choose Your Coach
+              </h2>
+              <p className="text-xs text-gray-500 dark:text-gray-400 mt-1 flex items-center gap-1.5">
+                <Train className="w-3.5 h-3.5" />
+                <span className="font-medium">{classModal.trainNumber}</span>
+                <span className="text-gray-400">·</span>
+                <span>
+                  {classModal.origin?.name} → {classModal.destination?.name}
+                </span>
+              </p>
             </div>
+            <button
+              type="button"
+              onClick={() => setClassModal(null)}
+              className="w-10 h-10 flex items-center justify-center rounded-full hover:bg-gray-100 dark:hover:bg-gray-800 transition-all"
+              aria-label="Close"
+            >
+              <X className="w-5 h-5 text-gray-500" />
+            </button>
+          </div>
 
-            <div className="flex-1 overflow-y-auto px-6 py-4">
-              {coachTypes.length > 0 ? (
-                <div className="grid grid-cols-1 lg:grid-cols-2 xl:grid-cols-3 gap-4 pt-2">
-                  {coachTypes.map((coachType: any, index: number) => {
-                    const isSelected = selectedCoachType?.id === coachType.coachTypeId;
-                    const minPrice = coachType.classes.length ? Math.min(...coachType.classes.map((c: any) => c.baseFareMinor)) : 0;
-                    const coachCurrency = 'ETB';
-                    const CoachIcon = getCoachIcon(coachType.coachTypeName);
+          <div className="flex-1 overflow-y-auto px-6 py-4">
+            {coachTypes.length > 0 ? (
+              <div className="grid grid-cols-1 lg:grid-cols-2 xl:grid-cols-3 gap-4 pt-2">
+                {coachTypes.map((coachType: any, index: number) => {
+                  const isSelected =
+                    selectedCoachType?.id === coachType.coachTypeId;
+                  const minPrice = coachType.classes.length
+                    ? Math.min(
+                        ...coachType.classes.map((c: any) => c.baseFareMinor),
+                      )
+                    : 0;
+                  const coachCurrency = "ETB";
+                  const CoachIcon = getCoachIcon(coachType.coachTypeName);
 
-                    return (
-                      <button
-                        key={coachType.coachId}
-                        onClick={() => handleSelectCoachType(scheduleId, coachType.coachTypeId, coachType.coachTypeCode, coachType.coachTypeName, coachType.classes?.[0]?.name || coachType.coachTypeName)}
-                        className={`group relative w-full p-5 rounded-2xl border-2 text-left transition-all duration-200 ${
+                  const selectThisCoach = () =>
+                    handleSelectCoachType(
+                      scheduleId,
+                      coachType.coachTypeId,
+                      coachType.coachTypeCode,
+                      coachType.coachTypeName,
+                      coachType.classes?.[0]?.name ||
+                        coachType.coachTypeName,
+                    );
+
+                  return (
+                    <div
+                      key={coachType.coachId}
+                      role="button"
+                      tabIndex={0}
+                      onClick={selectThisCoach}
+                      onKeyDown={(e) => {
+                        if (e.key === "Enter" || e.key === " ") {
+                          e.preventDefault();
+                          selectThisCoach();
+                        }
+                      }}
+                      className={`group relative w-full p-5 rounded-2xl border-2 text-left transition-all duration-200 cursor-pointer ${
+                        isSelected
+                          ? "border-primary bg-gradient-to-br from-primary/8 to-primary/3 dark:from-primary/15 dark:to-primary/5 shadow-lg shadow-primary/20 scale-[1.02]"
+                          : "border-gray-200 dark:border-gray-700 shadow-sm hover:border-primary/40 hover:shadow-md hover:scale-[1.01] bg-white dark:bg-gray-800/50"
+                      }`}
+                      style={{
+                        animation: `fade-in-up 0.3s ease-out ${index * 0.1}s both`,
+                      }}
+                    >
+                      {/* Radio indicator — top-right, persistent (not hover-only) so the
+                          card's selection state is clear on touch too. */}
+                      <span
+                        className={`absolute top-4 right-4 w-5 h-5 rounded-full border-2 flex items-center justify-center flex-shrink-0 transition-all ${
                           isSelected
-                            ? 'border-primary bg-gradient-to-br from-primary/8 to-primary/3 dark:from-primary/15 dark:to-primary/5 shadow-lg shadow-primary/20 scale-[1.02]'
-                            : 'border-gray-200 dark:border-gray-700 hover:border-primary/40 hover:shadow-md hover:scale-[1.01] bg-white dark:bg-gray-800/50'
+                            ? "border-primary"
+                            : "border-gray-300 dark:border-gray-600 group-hover:border-primary/50"
                         }`}
-                        style={{ animation: `fade-in-up 0.3s ease-out ${index * 0.1}s both` }}
                       >
                         {isSelected && (
-                          <div className="absolute top-4 right-4 w-7 h-7 bg-primary rounded-full flex items-center justify-center shadow-lg animate-scale-in">
-                            <Check className="w-4 h-4 text-white" strokeWidth={3} />
-                          </div>
+                          <span className="w-2.5 h-2.5 rounded-full bg-primary animate-scale-in" />
                         )}
+                      </span>
 
-                        <div className="flex flex-col">
-                          <div className="flex items-start gap-4 pr-2">
-                            <div className={`w-12 h-12 rounded-xl flex items-center justify-center flex-shrink-0 transition-all ${
+                      <div className="flex flex-col">
+                        <div className="flex items-start gap-4 pr-2">
+                          <div
+                            className={`w-12 h-12 rounded-xl flex items-center justify-center flex-shrink-0 transition-all ${
                               isSelected
-                                ? 'bg-primary/15 dark:bg-primary/25 shadow-inner'
-                                : 'bg-gray-100 dark:bg-gray-700 group-hover:bg-primary/10'
-                            }`}>
-                              <CoachIcon className={`w-6 h-6 transition-colors ${
-                                isSelected ? 'text-primary' : 'text-gray-600 dark:text-gray-400 group-hover:text-primary'
-                              }`} />
-                            </div>
-
-                            <div className="flex-1 min-w-0">
-                              <div className="flex items-start justify-between gap-2 mb-2">
-                                <div>
-                                  <h3 className="font-bold text-base text-gray-900 dark:text-white leading-tight">
-                                    {coachType.coachTypeName}
-                                  </h3>
-                                </div>
-                              </div>
-
-                              <div className="mt-3">
-                                <div className="flex items-baseline gap-1">
-                                  <span className="text-xs text-gray-500 dark:text-gray-400 font-medium">From</span>
-                                  <span className={`text-2xl font-bold tracking-tight ${
-                                    isSelected ? 'text-primary' : 'text-gray-900 dark:text-white'
-                                  }`}>
-                                    {(minPrice / 100).toFixed(2)}
-                                  </span>
-                                  <span className="text-sm font-semibold text-gray-600 dark:text-gray-400">{coachCurrency}</span>
-                                </div>
-                              </div>
-                            </div>
+                                ? "bg-primary/15 dark:bg-primary/25 shadow-inner"
+                                : "bg-gray-100 dark:bg-gray-700 group-hover:bg-primary/10"
+                            }`}
+                          >
+                            <CoachIcon
+                              className={`w-6 h-6 transition-colors ${
+                                isSelected
+                                  ? "text-primary"
+                                  : "text-gray-600 dark:text-gray-400 group-hover:text-primary"
+                              }`}
+                            />
                           </div>
 
-                          {coachType.classes.length > 0 && (
-                            <div className="mt-4 pt-4 border-t border-gray-200/60 dark:border-gray-700/60">
-                              <div className="flex items-center justify-between mb-3">
-                                <p className="text-xs font-bold text-gray-700 dark:text-gray-300 uppercase tracking-wider">
-                                  Class Options
-                                </p>
+                          <div className="flex-1 min-w-0">
+                            <div className="flex items-start justify-between gap-2 mb-2">
+                              <div>
+                                <h3 className="font-bold text-base text-gray-900 dark:text-white leading-tight">
+                                  {coachType.coachTypeName}
+                                </h3>
+                              </div>
+                            </div>
+
+                            <div className="mt-3">
+                              <div className="flex items-baseline gap-1">
                                 <span className="text-xs text-gray-500 dark:text-gray-400 font-medium">
-                                  {coachType.classes.length} available
+                                  From
+                                </span>
+                                <span
+                                  className={`text-2xl font-bold tracking-tight ${
+                                    isSelected
+                                      ? "text-primary"
+                                      : "text-gray-900 dark:text-white"
+                                  }`}
+                                >
+                                  {(minPrice / 100).toFixed(2)}
+                                </span>
+                                <span className="text-sm font-semibold text-gray-600 dark:text-gray-400">
+                                  {coachCurrency}
                                 </span>
                               </div>
-                              <div className="space-y-2.5">
-                                {coachType.classes.map((cls: any, idx: number) => (
+                            </div>
+                          </div>
+                        </div>
+
+                        {coachType.classes.length > 0 && (
+                          <div className="mt-4 pt-4 border-t border-gray-200/60 dark:border-gray-700/60">
+                            <div className="flex items-center justify-between mb-3">
+                              <p className="text-xs font-bold text-gray-700 dark:text-gray-300 uppercase tracking-wider">
+                                Class Options
+                              </p>
+                              <span className="text-xs text-gray-500 dark:text-gray-400 font-medium">
+                                {coachType.classes.length} available
+                              </span>
+                            </div>
+                            <div className="space-y-2.5">
+                              {coachType.classes.map(
+                                (cls: any, idx: number) => (
                                   <div
                                     key={idx}
-                                    className="flex items-center justify-between py-2 px-3 rounded-lg bg-gray-50/80 dark:bg-gray-800/40 hover:bg-gray-100/80 dark:hover:bg-gray-800/60 transition-colors"
+                                    className="flex items-center justify-between py-2 px-3 rounded-lg bg-gray-50/80 dark:bg-gray-800/40"
                                   >
                                     <div className="flex items-center gap-2.5">
                                       <CoachIcon className="w-3.5 h-3.5 text-gray-500 dark:text-gray-400" />
@@ -364,43 +505,56 @@ export default function ResultsPage() {
                                       </span>
                                     </div>
                                   </div>
-                                ))}
-                              </div>
+                                ),
+                              )}
                             </div>
-                          )}
-                        </div>
-                      </button>
-                    );
-                  })}
-                </div>
-              ) : (
-                <div className="flex flex-col items-center justify-center py-16 text-center">
-                  <div className="w-16 h-16 bg-gray-100 dark:bg-gray-800 rounded-full flex items-center justify-center mb-4">
-                    <Train className="w-8 h-8 text-gray-400" />
-                  </div>
-                  <p className="text-gray-500 dark:text-gray-400 text-sm">No coach types available for this journey</p>
-                </div>
-              )}
-            </div>
+                          </div>
+                        )}
 
-            <div className="px-6 py-5 border-t border-gray-100 dark:border-gray-800 flex-shrink-0 bg-gray-50/50 dark:bg-gray-800/30 flex justify-center">
-              <div className="w-full max-w-md">
-                <button
-                  onClick={() => { if (selectedCoachType) { handleSelect(classModal, isOutbound); } }}
-                  disabled={!selectedCoachType}
-                  className="w-full flex items-center justify-center gap-2.5 px-6 py-3.5 bg-gradient-to-r from-[rgb(20,113,76)] to-[rgb(16,95,65)] hover:from-[rgb(16,89,60)] hover:to-[rgb(12,75,50)] text-white font-bold text-sm rounded-xl transition-all disabled:opacity-50 disabled:cursor-not-allowed shadow-lg shadow-primary/30 disabled:shadow-none hover:shadow-xl hover:scale-[1.02] active:scale-[0.98]"
-                >
-                  <span>{isRoundTrip && isOutbound ? 'Continue to Return Journey' : 'Continue to Passenger Details'}</span>
-                  <ArrowRight className="w-4 h-4" />
-                </button>
-                {!selectedCoachType && (
-                  <p className="text-center text-xs text-gray-500 dark:text-gray-400 mt-3 flex items-center justify-center gap-1">
-                    <span className="w-1.5 h-1.5 rounded-full bg-gray-400 animate-pulse" />
-                    Select a coach type to continue
-                  </p>
-                )}
+                        {/* Note — only shown while unselected; once picked, the Continue
+                            button below takes its place. */}
+                        {!isSelected && (
+                          <p className="mt-4 pt-3 border-t border-gray-200/60 dark:border-gray-700/60 text-xs text-gray-400 dark:text-gray-500 italic text-center">
+                            Click to select this coach
+                          </p>
+                        )}
+
+                        {/* Continue only appears on the card the user has actually picked —
+                            a real nested button (the outer card is a div, not a button, so
+                            this doesn't create invalid/ambiguous nested-button behavior). */}
+                        {isSelected && (
+                          <button
+                            type="button"
+                            onClick={(e) => {
+                              e.stopPropagation();
+                              handleSelect(classModal, isOutbound);
+                            }}
+                            className="mt-3 w-full flex items-center justify-center gap-2 px-4 py-2.5 bg-gradient-to-r from-[rgb(20,113,76)] to-[rgb(16,95,65)] hover:from-[rgb(16,89,60)] hover:to-[rgb(12,75,50)] text-white font-bold text-sm rounded-xl transition-all shadow-md shadow-primary/30 hover:shadow-lg active:scale-[0.98]"
+                          >
+                            <span>
+                              {isRoundTrip && isOutbound
+                                ? "Continue to Return Journey"
+                                : "Continue to Passenger Details"}
+                            </span>
+                            <ArrowRight className="w-4 h-4" />
+                          </button>
+                        )}
+                      </div>
+                    </div>
+                  );
+                })}
               </div>
-            </div>
+            ) : (
+              <div className="flex flex-col items-center justify-center py-16 text-center">
+                <div className="w-16 h-16 bg-gray-100 dark:bg-gray-800 rounded-full flex items-center justify-center mb-4">
+                  <Train className="w-8 h-8 text-gray-400" />
+                </div>
+                <p className="text-gray-500 dark:text-gray-400 text-sm">
+                  No coach types available for this journey
+                </p>
+              </div>
+            )}
+          </div>
         </div>
         <style>{`
           @keyframes drawer-slide-in{from{transform:translateX(100%)}to{transform:translateX(0)}}
@@ -411,44 +565,69 @@ export default function ResultsPage() {
     );
   };
 
-  const renderScheduleCard = (schedule: Schedule, isOutbound: boolean = false, isAlternative: boolean = false) => {
-    const scheduleId = schedule.scheduleId || schedule.id || '';
+  const renderScheduleCard = (
+    schedule: Schedule,
+    isOutbound: boolean = false,
+    isAlternative: boolean = false,
+  ) => {
+    const scheduleId = schedule.scheduleId || schedule.id || "";
     const selectedCoachType = selectedCoachTypes[scheduleId];
-    
+
     // Calculate lowest fare and display currency from coach types / faresByClass.
     // Prefer displayAmountMinor (passenger's own currency) over baseFareMinor (ETB internal).
     let lowestFare = null;
-    const displayCurrency = 'ETB';
+    const displayCurrency = "ETB";
     if (schedule.coachTypes?.length) {
-      const allClasses = schedule.coachTypes.flatMap(ct => ct.classes);
-      const allFares = allClasses.map(c => c.baseFareMinor).filter(f => f > 0);
+      const allClasses = schedule.coachTypes.flatMap((ct) => ct.classes);
+      const allFares = allClasses
+        .map((c) => c.baseFareMinor)
+        .filter((f) => f > 0);
       lowestFare = allFares.length ? Math.min(...allFares) : null;
     } else if (schedule.faresByClass?.length) {
-      lowestFare = Math.min(...schedule.faresByClass.map(f => f.baseFareMinor).filter(f => f > 0));
+      lowestFare = Math.min(
+        ...schedule.faresByClass
+          .map((f) => f.baseFareMinor)
+          .filter((f) => f > 0),
+      );
     } else if (schedule.combinedMinFareDisplay) {
       lowestFare = schedule.combinedMinFareDisplay;
     }
     const hours = Math.floor((schedule.durationMinutes || 0) / 60);
     const minutes = (schedule.durationMinutes || 0) % 60;
     const durationStr = `${hours}h ${minutes}m`;
-    const departureDate = schedule.departureAt ? new Date(schedule.departureAt) : null;
-    const arrivalDate   = schedule.arrivalAt   ? new Date(schedule.arrivalAt)   : null;
-    const isNextDay = departureDate && arrivalDate && departureDate.toDateString() !== arrivalDate.toDateString();
+    const departureDate = schedule.departureAt
+      ? new Date(schedule.departureAt)
+      : null;
+    const arrivalDate = schedule.arrivalAt
+      ? new Date(schedule.arrivalAt)
+      : null;
+    const isNextDay =
+      departureDate &&
+      arrivalDate &&
+      departureDate.toDateString() !== arrivalDate.toDateString();
 
     return (
-      <div key={scheduleId} className={`card ${isAlternative ? 'border-2 border-amber-200 dark:border-amber-800/60' : ''}`}>
+      <div
+        key={scheduleId}
+        className={`card ${isAlternative ? "border-2 border-amber-200 dark:border-amber-800/60" : ""}`}
+      >
         {isAlternative && (
           <div className="flex flex-wrap items-center gap-2 mb-4">
             <span className="inline-flex items-center gap-1.5 text-xs font-semibold px-2.5 py-1 rounded-full bg-amber-100 dark:bg-amber-900/30 text-amber-700 dark:text-amber-300">
               <Calendar className="w-3.5 h-3.5" />
-              Different date — {schedule.departureAt ? format(new Date(schedule.departureAt), 'EEEE, MMMM d, yyyy') : 'N/A'}
+              Different date —{" "}
+              {schedule.departureAt
+                ? format(new Date(schedule.departureAt), "EEEE, MMMM d, yyyy")
+                : "N/A"}
             </span>
-            <span className={`inline-flex items-center gap-1.5 text-xs font-semibold px-2.5 py-1 rounded-full ${
-              schedule.hasAvailability
-                ? 'bg-green-100 dark:bg-green-900/30 text-green-700 dark:text-green-300'
-                : 'bg-red-100 dark:bg-red-900/30 text-red-700 dark:text-red-300'
-            }`}>
-              {schedule.hasAvailability ? 'Seats available' : 'Fully booked'}
+            <span
+              className={`inline-flex items-center gap-1.5 text-xs font-semibold px-2.5 py-1 rounded-full ${
+                schedule.hasAvailability
+                  ? "bg-green-100 dark:bg-green-900/30 text-green-700 dark:text-green-300"
+                  : "bg-red-100 dark:bg-red-900/30 text-red-700 dark:text-red-300"
+              }`}
+            >
+              {schedule.hasAvailability ? "Seats available" : "Fully booked"}
             </span>
           </div>
         )}
@@ -459,20 +638,30 @@ export default function ResultsPage() {
                 <Clock className="w-5 h-5 text-primary" />
               </div>
               <div>
-                <div className="font-bold text-lg text-gray-900 dark:text-gray-100">{schedule.trainNumber}</div>
-                <div className="text-sm text-gray-600 dark:text-gray-400">{schedule.trainName || 'Express Service'}</div>
+                <div className="font-bold text-lg text-gray-900 dark:text-gray-100">
+                  {schedule.trainNumber}
+                </div>
+                <div className="text-sm text-gray-600 dark:text-gray-400">
+                  {schedule.trainName || "Express Service"}
+                </div>
               </div>
             </div>
 
             <div className="flex items-center gap-4">
               <div className="text-center">
                 <div className="text-3xl font-bold text-gray-900 dark:text-gray-100">
-                  {schedule.departureAt ? formatTime(schedule.departureAt) : '--:--'}
+                  {schedule.departureAt
+                    ? formatTime(schedule.departureAt)
+                    : "--:--"}
                 </div>
                 <div className="text-xs text-gray-500 dark:text-gray-400 mt-0.5">
-                  {schedule.departureAt ? `${format(new Date(schedule.departureAt), 'MMM d')} · ${getTimePeriod(schedule.departureAt)}` : ''}
+                  {schedule.departureAt
+                    ? `${format(new Date(schedule.departureAt), "MMM d")} · ${getTimePeriod(schedule.departureAt)}`
+                    : ""}
+                </div>
+                <div className="text-sm text-gray-600 dark:text-gray-400 mt-1">
+                  {schedule.origin?.name || "Origin"}
                 </div>
-                <div className="text-sm text-gray-600 dark:text-gray-400 mt-1">{schedule.origin?.name || 'Origin'}</div>
               </div>
 
               <div className="flex-1 flex flex-col items-center">
@@ -494,35 +683,57 @@ export default function ResultsPage() {
 
               <div className="text-center">
                 <div className="text-3xl font-bold text-gray-900 dark:text-gray-100">
-                  {schedule.arrivalAt ? formatTime(schedule.arrivalAt) : '--:--'}
+                  {schedule.arrivalAt
+                    ? formatTime(schedule.arrivalAt)
+                    : "--:--"}
                 </div>
                 <div className="text-xs text-gray-500 dark:text-gray-400 mt-0.5 flex items-center justify-center gap-1">
-                  <span>{schedule.arrivalAt ? `${format(new Date(schedule.arrivalAt), 'MMM d')} · ${getTimePeriod(schedule.arrivalAt)}` : ''}</span>
-                  {isNextDay && <span className="text-orange-500 font-medium">(+1)</span>}
+                  <span>
+                    {schedule.arrivalAt
+                      ? `${format(new Date(schedule.arrivalAt), "MMM d")} · ${getTimePeriod(schedule.arrivalAt)}`
+                      : ""}
+                  </span>
+                  {isNextDay && (
+                    <span className="text-orange-500 font-medium">(+1)</span>
+                  )}
+                </div>
+                <div className="text-sm text-gray-600 dark:text-gray-400 mt-1">
+                  {schedule.destination?.name || "Destination"}
                 </div>
-                <div className="text-sm text-gray-600 dark:text-gray-400 mt-1">{schedule.destination?.name || 'Destination'}</div>
               </div>
             </div>
           </div>
 
           <div className="lg:border-l dark:border-gray-700 lg:pl-6 lg:min-w-[220px]">
             <div className="text-center lg:text-right">
-              <div className="text-sm text-gray-600 dark:text-gray-400 mb-1">Starting from</div>
-              <div className="text-3xl font-bold text-primary">
-                {lowestFare ? `${displayCurrency} ${(lowestFare / 100).toFixed(2)}` : 'N/A'}
+              <div className="text-sm text-gray-600 dark:text-gray-400 mb-1">
+                Starting from
+              </div>
+              <div className="text-3xl font-bold text-primary">
+                {lowestFare
+                  ? `${displayCurrency} ${(lowestFare / 100).toFixed(2)}`
+                  : "N/A"}
+              </div>
+              <div className="text-xs text-gray-500 dark:text-gray-400 mt-1 mb-4">
+                per adult
               </div>
-              <div className="text-xs text-gray-500 dark:text-gray-400 mt-1 mb-4">per adult</div>
               {selectedCoachType && (
                 <p className="text-xs text-primary font-semibold mb-2">
                   {selectedCoachType.name} selected
                 </p>
               )}
               <button
-                onClick={() => setClassModal({ ...schedule, isOutbound } as any)}
+                onClick={() =>
+                  setClassModal({ ...schedule, isOutbound } as any)
+                }
                 disabled={isAlternative && schedule.hasAvailability === false}
                 className="btn-secondary w-full flex items-center justify-center gap-2 disabled:opacity-50 disabled:cursor-not-allowed"
               >
-                {isAlternative && schedule.hasAvailability === false ? 'Unavailable' : selectedCoachType ? 'Change' : 'Select'}
+                {isAlternative && schedule.hasAvailability === false
+                  ? "Unavailable"
+                  : selectedCoachType
+                    ? "Change"
+                    : "Select"}
               </button>
             </div>
           </div>
@@ -554,10 +765,10 @@ export default function ResultsPage() {
                 </div>
                 {/* Progress bar */}
                 <div className="mt-4 h-2 bg-gray-200 dark:bg-gray-700 rounded-full overflow-hidden">
-                  <div 
+                  <div
                     className="h-full bg-primary rounded-full"
                     style={{
-                      animation: 'progressBar 2s ease-in-out infinite',
+                      animation: "progressBar 2s ease-in-out infinite",
                     }}
                   />
                 </div>
@@ -572,18 +783,24 @@ export default function ResultsPage() {
                     <div className="flex-1">
                       {/* Train info skeleton */}
                       <div className="flex items-center gap-3 mb-4">
-                        <div 
+                        <div
                           className="w-10 h-10 bg-gray-200 dark:bg-gray-700 rounded-lg"
-                          style={{ animation: 'shimmer 1.5s ease-in-out infinite' }}
+                          style={{
+                            animation: "shimmer 1.5s ease-in-out infinite",
+                          }}
                         />
                         <div className="flex-1 space-y-2">
-                          <div 
+                          <div
                             className="h-5 bg-gray-200 dark:bg-gray-700 rounded w-24"
-                            style={{ animation: 'shimmer 1.5s ease-in-out infinite' }}
+                            style={{
+                              animation: "shimmer 1.5s ease-in-out infinite",
+                            }}
                           />
-                          <div 
+                          <div
                             className="h-4 bg-gray-200 dark:bg-gray-700 rounded w-32"
-                            style={{ animation: 'shimmer 1.5s ease-in-out infinite' }}
+                            style={{
+                              animation: "shimmer 1.5s ease-in-out infinite",
+                            }}
                           />
                         </div>
                       </div>
@@ -591,50 +808,68 @@ export default function ResultsPage() {
                       {/* Time and route skeleton */}
                       <div className="flex items-center gap-4">
                         <div className="text-center space-y-2">
-                          <div 
+                          <div
                             className="h-8 bg-gray-200 dark:bg-gray-700 rounded w-16"
-                            style={{ animation: 'shimmer 1.5s ease-in-out infinite' }}
+                            style={{
+                              animation: "shimmer 1.5s ease-in-out infinite",
+                            }}
                           />
-                          <div 
+                          <div
                             className="h-3 bg-gray-200 dark:bg-gray-700 rounded w-12"
-                            style={{ animation: 'shimmer 1.5s ease-in-out infinite' }}
+                            style={{
+                              animation: "shimmer 1.5s ease-in-out infinite",
+                            }}
                           />
-                          <div 
+                          <div
                             className="h-4 bg-gray-200 dark:bg-gray-700 rounded w-20"
-                            style={{ animation: 'shimmer 1.5s ease-in-out infinite' }}
+                            style={{
+                              animation: "shimmer 1.5s ease-in-out infinite",
+                            }}
                           />
                         </div>
 
                         <div className="flex-1 flex flex-col items-center">
-                          <div 
+                          <div
                             className="h-4 bg-gray-200 dark:bg-gray-700 rounded w-16 mb-2"
-                            style={{ animation: 'shimmer 1.5s ease-in-out infinite' }}
+                            style={{
+                              animation: "shimmer 1.5s ease-in-out infinite",
+                            }}
                           />
-                          <div 
+                          <div
                             className="w-full h-0.5 bg-gray-200 dark:bg-gray-700 relative"
-                            style={{ animation: 'shimmer 1.5s ease-in-out infinite' }}
+                            style={{
+                              animation: "shimmer 1.5s ease-in-out infinite",
+                            }}
                           >
                             <div className="absolute left-0 top-1/2 -translate-y-1/2 w-2 h-2 bg-gray-300 dark:bg-gray-600 rounded-full" />
                             <div className="absolute right-0 top-1/2 -translate-y-1/2 w-2 h-2 bg-gray-300 dark:bg-gray-600 rounded-full" />
                           </div>
-                          <div 
+                          <div
                             className="h-4 bg-gray-200 dark:bg-gray-700 rounded w-12 mt-2"
-                            style={{ animation: 'shimmer 1.5s ease-in-out infinite' }}
+                            style={{
+                              animation: "shimmer 1.5s ease-in-out infinite",
+                            }}
                           />
                         </div>
 
                         <div className="text-center space-y-2">
-                          <div 
+                          <div
                             className="h-8 bg-gray-200 dark:bg-gray-700 rounded w-16"
-                            style={{ animation: 'shimmer 1.5s ease-in-out infinite' }}
+                            style={{
+                              animation: "shimmer 1.5s ease-in-out infinite",
+                            }}
                           />
-                          <div 
+                          <div
                             className="h-3 bg-gray-200 dark:bg-gray-700 rounded w-12"
-                            style={{ animation: 'shimmer 1.5s ease-in-out infinite' }}
+                            style={{
+                              animation: "shimmer 1.5s ease-in-out infinite",
+                            }}
                           />
-                          <div 
+                          <div
                             className="h-4 bg-gray-200 dark:bg-gray-700 rounded w-20"
-                            style={{ animation: 'shimmer 1.5s ease-in-out infinite' }}
+                            style={{
+                              animation: "shimmer 1.5s ease-in-out infinite",
+                            }}
                           />
                         </div>
                       </div>
@@ -642,21 +877,29 @@ export default function ResultsPage() {
 
                     <div className="lg:border-l dark:border-gray-700 lg:pl-6 lg:min-w-[220px]">
                       <div className="text-center lg:text-right space-y-3">
-                        <div 
+                        <div
                           className="h-4 bg-gray-200 dark:bg-gray-700 rounded w-24 mx-auto lg:ml-auto"
-                          style={{ animation: 'shimmer 1.5s ease-in-out infinite' }}
+                          style={{
+                            animation: "shimmer 1.5s ease-in-out infinite",
+                          }}
                         />
-                        <div 
+                        <div
                           className="h-10 bg-gray-200 dark:bg-gray-700 rounded w-32 mx-auto lg:ml-auto"
-                          style={{ animation: 'shimmer 1.5s ease-in-out infinite' }}
+                          style={{
+                            animation: "shimmer 1.5s ease-in-out infinite",
+                          }}
                         />
-                        <div 
+                        <div
                           className="h-3 bg-gray-200 dark:bg-gray-700 rounded w-16 mx-auto lg:ml-auto"
-                          style={{ animation: 'shimmer 1.5s ease-in-out infinite' }}
+                          style={{
+                            animation: "shimmer 1.5s ease-in-out infinite",
+                          }}
                         />
-                        <div 
+                        <div
                           className="h-10 bg-gray-200 dark:bg-gray-700 rounded w-full"
-                          style={{ animation: 'shimmer 1.5s ease-in-out infinite' }}
+                          style={{
+                            animation: "shimmer 1.5s ease-in-out infinite",
+                          }}
                         />
                       </div>
                     </div>
@@ -677,9 +920,16 @@ export default function ResultsPage() {
           <div className="w-16 h-16 bg-red-100 dark:bg-red-900/30 rounded-full flex items-center justify-center mx-auto mb-4">
             <span className="text-3xl">⚠️</span>
           </div>
-          <h2 className="text-xl font-bold mb-2 text-gray-900 dark:text-gray-100">Search Error</h2>
-          <p className="text-gray-600 dark:text-gray-400 mb-6">Unable to load results. Please try again.</p>
-          <button onClick={() => router.push(buildSearchUrl())} className="btn-primary">
+          <h2 className="text-xl font-bold mb-2 text-gray-900 dark:text-gray-100">
+            Search Error
+          </h2>
+          <p className="text-gray-600 dark:text-gray-400 mb-6">
+            Unable to load results. Please try again.
+          </p>
+          <button
+            onClick={() => router.push(buildSearchUrl())}
+            className="btn-primary"
+          >
             Back to Search
           </button>
         </div>
@@ -688,21 +938,35 @@ export default function ResultsPage() {
   }
 
   if (!hasResults) {
-    const isRoundTripNoResults = isRoundTrip && !!results && outboundSchedules.length === 0 && inboundSchedules.length === 0 && alternativeOutbound.length === 0 && alternativeInbound.length === 0;
+    const isRoundTripNoResults =
+      isRoundTrip &&
+      !!results &&
+      outboundSchedules.length === 0 &&
+      inboundSchedules.length === 0 &&
+      alternativeOutbound.length === 0 &&
+      alternativeInbound.length === 0;
     if (isRoundTripNoResults) {
       return (
         <div className="min-h-screen bg-gray-50 dark:bg-gray-900 py-12">
           <div className="container mx-auto px-4">
             <div className="max-w-2xl mx-auto">
               <div className="card text-center">
-                <div className="w-20 h-20 bg-gray-100 dark:bg-gray-800 rounded-full flex items-center justify-center mx-auto mb-6">
+                <div className="hidden sm:flex w-20 h-20 bg-gray-100 dark:bg-gray-800 rounded-full items-center justify-center mx-auto mb-6">
                   <Calendar className="w-10 h-10 text-gray-400 dark:text-gray-500" />
                 </div>
-                <h2 className="text-2xl font-bold mb-3 text-gray-900 dark:text-gray-100">No trains found</h2>
+                <h2 className="text-2xl font-bold mb-3 text-gray-900 dark:text-gray-100">
+                  No trains found
+                </h2>
                 <p className="text-gray-600 dark:text-gray-400 mb-8">
-                  We couldn&apos;t find any trains for your round trip. Try adjusting your dates or route.
+                  We couldn&apos;t find any trains for your trip. Try adjusting
+                  your dates or route.
                 </p>
-                <button onClick={() => router.push(buildSearchUrl())} className="btn-primary">Modify search</button>
+                <button
+                  onClick={() => router.push(buildSearchUrl())}
+                  className="btn-primary"
+                >
+                  Modify search
+                </button>
               </div>
             </div>
           </div>
@@ -712,8 +976,8 @@ export default function ResultsPage() {
 
     if (isOneWayNoOutbound) {
       const requestedDateLabel = requestedDate
-        ? format(new Date(`${requestedDate}T00:00:00`), 'EEEE, MMMM d, yyyy')
-        : 'your selected date';
+        ? format(new Date(`${requestedDate}T00:00:00`), "EEEE, MMMM d, yyyy")
+        : "your selected date";
       const hasAlternatives = alternativeOutbound.length > 0;
 
       return (
@@ -722,17 +986,22 @@ export default function ResultsPage() {
           <div className="container mx-auto px-4">
             <div className="max-w-6xl mx-auto">
               <div className="card text-center mb-8 max-w-3xl mx-auto">
-                <div className="w-20 h-20 bg-amber-100 dark:bg-amber-900/30 rounded-full flex items-center justify-center mx-auto mb-6">
+                <div className="hidden sm:flex w-20 h-20 bg-amber-100 dark:bg-amber-900/30 rounded-full items-center justify-center mx-auto mb-6">
                   <Calendar className="w-10 h-10 text-amber-500" />
                 </div>
-                <h2 className="text-2xl font-bold mb-3 text-gray-900 dark:text-gray-100">No trains available</h2>
+                <h2 className="text-2xl font-bold mb-3 text-gray-900 dark:text-gray-100">
+                  No trains available
+                </h2>
                 <p className="text-gray-600 dark:text-gray-400 mb-8">
-                  No trains are available on <span className="font-semibold text-gray-900 dark:text-gray-100">{requestedDateLabel}</span>. This
-                  may be due to no scheduled service or full capacity. {hasAlternatives
-                    ? 'Please check the alternative options below or try a different date.'
-                    : 'Please try a different date.'}
+                  No trains are available on{" "}
+                  <span className="font-semibold text-gray-900 dark:text-gray-100">
+                    {requestedDateLabel}
+                  </span>
                 </p>
-                <button onClick={() => router.push(buildSearchUrl())} className="btn-primary">
+                <button
+                  onClick={() => router.push(buildSearchUrl())}
+                  className="btn-primary"
+                >
                   Change travel date
                 </button>
               </div>
@@ -740,13 +1009,18 @@ export default function ResultsPage() {
               {hasAlternatives && (
                 <div>
                   <div className="mb-4">
-                    <h3 className="text-lg font-bold text-gray-900 dark:text-white">Alternative Travel Options</h3>
+                    <h3 className="text-lg font-bold text-gray-900 dark:text-white">
+                      Alternative Travel Options
+                    </h3>
                     <p className="text-sm text-amber-600 dark:text-amber-400 mt-1">
-                      These trains run on different dates than requested — adjust your travel date to book one of them.
+                      These trains run on different dates than requested —
+                      adjust your travel date to book one of them.
                     </p>
                   </div>
                   <div className="space-y-4">
-                    {alternativeOutbound.map((schedule) => renderScheduleCard(schedule, true, true))}
+                    {alternativeOutbound.map((schedule) =>
+                      renderScheduleCard(schedule, true, true),
+                    )}
                   </div>
                 </div>
               )}
@@ -761,14 +1035,20 @@ export default function ResultsPage() {
         <div className="container mx-auto px-4">
           <div className="max-w-2xl mx-auto">
             <div className="card text-center">
-              <div className="w-20 h-20 bg-gray-100 dark:bg-gray-800 rounded-full flex items-center justify-center mx-auto mb-6">
+              <div className="hidden sm:flex w-20 h-20 bg-gray-100 dark:bg-gray-800 rounded-full items-center justify-center mx-auto mb-6">
                 <Calendar className="w-10 h-10 text-gray-400 dark:text-gray-500" />
               </div>
-              <h2 className="text-2xl font-bold mb-3 text-gray-900 dark:text-gray-100">No trains found</h2>
+              <h2 className="text-2xl font-bold mb-3 text-gray-900 dark:text-gray-100">
+                No trains found
+              </h2>
               <p className="text-gray-600 dark:text-gray-400 mb-8">
-                We couldn&apos;t find any trains matching your search criteria. <br /> Try adjusting your dates or route.
+                We couldn&apos;t find any trains matching your search criteria.{" "}
+                <br /> Try adjusting your dates or route.
               </p>
-              <button onClick={() => router.push(buildSearchUrl())} className="btn-primary">
+              <button
+                onClick={() => router.push(buildSearchUrl())}
+                className="btn-primary"
+              >
                 Modify search
               </button>
             </div>
@@ -782,37 +1062,46 @@ export default function ResultsPage() {
     <div className="min-h-screen bg-gray-50 dark:bg-gray-900 py-4 md:py-6">
       <div className="container mx-auto px-4">
         <div className="max-w-6xl mx-auto">
-
           {renderClassModal()}
 
           {promoData && (
             <div className="mb-6 bg-green-50 dark:bg-green-900/20 border border-green-200 dark:border-green-800 rounded-lg p-4 flex items-start gap-3">
               <Check className="w-5 h-5 text-green-600 dark:text-green-400 flex-shrink-0 mt-0.5" />
               <div className="flex-1">
-                <h3 className="font-semibold text-green-900 dark:text-green-200">Promo code applied!</h3>
+                <h3 className="font-semibold text-green-900 dark:text-green-200">
+                  Promo code applied!
+                </h3>
                 <p className="text-sm text-green-800 dark:text-green-300 mt-1">
-                  <span className="font-mono font-bold">{promoData.code}</span> — {promoData.message}
+                  <span className="font-mono font-bold">{promoData.code}</span>{" "}
+                  — {promoData.message}
                 </p>
               </div>
             </div>
           )}
 
           <div className="mb-8">
-            <button onClick={() => router.push(buildSearchUrl())} className="btn-ghost px-0 py-4 flex items-center gap-2">
+            <button
+              onClick={() => router.push(buildSearchUrl())}
+              className="btn-ghost px-0 py-4 flex items-center gap-2"
+            >
               <ChevronLeft className="w-4 h-4" />
               Modify search
             </button>
             <h1 className="section-title">Available schedules</h1>
             {isRoundTrip && (
               <div className="flex items-center gap-3 mt-4">
-                <div className={`flex items-center gap-2 px-4 py-2 rounded-full text-sm font-semibold transition-all ${
-                  roundTripStep === 'inbound'
-                    ? 'bg-green-100 dark:bg-green-900/30 text-green-700 dark:text-green-300'
-                    : 'bg-primary text-white shadow-md shadow-primary/30'
-                }`}>
-                  {roundTripStep === 'inbound'
-                    ? <Check className="w-3.5 h-3.5" />
-                    : <span className="text-xs leading-none">1</span>}
+                <div
+                  className={`flex items-center gap-2 px-4 py-2 rounded-full text-sm font-semibold transition-all ${
+                    roundTripStep === "inbound"
+                      ? "bg-green-100 dark:bg-green-900/30 text-green-700 dark:text-green-300"
+                      : "bg-primary text-white shadow-md shadow-primary/30"
+                  }`}
+                >
+                  {roundTripStep === "inbound" ? (
+                    <Check className="w-3.5 h-3.5" />
+                  ) : (
+                    <span className="text-xs leading-none">1</span>
+                  )}
                   <span>Outbound</span>
                 </div>
                 <div className="flex items-center gap-1">
@@ -820,11 +1109,13 @@ export default function ResultsPage() {
                   <ArrowRight className="w-3 h-3 text-gray-400" />
                   <div className="w-4 h-0.5 bg-gray-300 dark:bg-gray-600" />
                 </div>
-                <div className={`flex items-center gap-2 px-4 py-2 rounded-full text-sm font-semibold transition-all ${
-                  roundTripStep === 'inbound'
-                    ? 'bg-primary text-white shadow-md shadow-primary/30'
-                    : 'bg-gray-100 dark:bg-gray-800 text-gray-400 dark:text-gray-500'
-                }`}>
+                <div
+                  className={`flex items-center gap-2 px-4 py-2 rounded-full text-sm font-semibold transition-all ${
+                    roundTripStep === "inbound"
+                      ? "bg-primary text-white shadow-md shadow-primary/30"
+                      : "bg-gray-100 dark:bg-gray-800 text-gray-400 dark:text-gray-500"
+                  }`}
+                >
                   <span className="text-xs leading-none">2</span>
                   <span>Return</span>
                 </div>
@@ -833,11 +1124,18 @@ export default function ResultsPage() {
             <div className="hidden sm:flex flex-wrap items-center gap-4 text-gray-600 dark:text-gray-400 mt-3">
               <div className="flex items-center gap-2">
                 <Calendar className="w-4 h-4" />
-                <span>{searchData.date ? format(new Date(searchData.date), 'EEEE, MMMM d, yyyy') : 'Date not specified'}</span>
+                <span>
+                  {searchData.date
+                    ? format(new Date(searchData.date), "EEEE, MMMM d, yyyy")
+                    : "Date not specified"}
+                </span>
               </div>
               <div className="flex items-center gap-2">
                 <Users className="w-4 h-4" />
-                <span>{searchData.adultCount} adult(s), {searchData.childCount} child(ren)</span>
+                <span>
+                  {searchData.adultCount} adult(s), {searchData.childCount}{" "}
+                  child(ren)
+                </span>
               </div>
               {searchData.promoCode && (
                 <div className="flex items-center gap-2 bg-green-50 dark:bg-green-900/30 text-green-700 dark:text-green-300 px-3 py-1 rounded-full text-sm">
@@ -850,7 +1148,7 @@ export default function ResultsPage() {
 
           <div className="space-y-8">
             {isRoundTrip ? (
-              roundTripStep === 'outbound' ? (
+              roundTripStep === "outbound" ? (
                 <div>
                   <div className="mb-4">
                     <h2 className="text-xl font-bold text-gray-900 dark:text-white flex items-center gap-2">
@@ -858,32 +1156,59 @@ export default function ResultsPage() {
                       Select Outbound Journey
                     </h2>
                     <p className="text-sm text-gray-500 dark:text-gray-400 mt-1">
-                      {searchData.date ? format(new Date(searchData.date), 'EEEE, MMMM d, yyyy') : ''}
+                      {searchData.date
+                        ? format(
+                            new Date(searchData.date),
+                            "EEEE, MMMM d, yyyy",
+                          )
+                        : ""}
                     </p>
                   </div>
                   <div className="space-y-4">
-                    {outboundSchedules.map((schedule: Schedule) => renderScheduleCard(schedule, true))}
+                    {outboundSchedules.map((schedule: Schedule) =>
+                      renderScheduleCard(schedule, true),
+                    )}
                   </div>
-                  {outboundSchedules.length === 0 && alternativeOutbound.length > 0 && (
-                    <div className="mt-6">
-                      <div className="card text-center mb-6 max-w-3xl mx-auto">
-                        <div className="w-16 h-16 bg-amber-100 dark:bg-amber-900/30 rounded-full flex items-center justify-center mx-auto mb-4">
-                          <Calendar className="w-8 h-8 text-amber-500" />
+                  {outboundSchedules.length === 0 &&
+                    alternativeOutbound.length > 0 && (
+                      <div className="mt-6">
+                        <div className="card text-center mb-6 max-w-3xl mx-auto">
+                          <div className="hidden sm:flex w-16 h-16 bg-amber-100 dark:bg-amber-900/30 rounded-full items-center justify-center mx-auto mb-4">
+                            <Calendar className="w-8 h-8 text-amber-500" />
+                          </div>
+                          <h2 className="text-xl font-bold mb-2 text-gray-900 dark:text-gray-100">
+                            No trains available
+                          </h2>
+                          <p className="text-gray-600 dark:text-gray-400 mb-6">
+                            No trains are available on{" "}
+                            <span className="font-semibold text-gray-900 dark:text-gray-100">
+                              {requestedDate
+                                ? format(
+                                    new Date(`${requestedDate}T00:00:00`),
+                                    "EEEE, MMMM d, yyyy",
+                                  )
+                                : "your selected date"}
+                            </span>
+                          </p>
+                          <button
+                            onClick={() => router.push(buildSearchUrl())}
+                            className="btn-primary"
+                          >
+                            Change travel dates
+                          </button>
+                        </div>
+                        <div className="mb-3">
+                          <h3 className="text-base font-bold text-gray-900 dark:text-white">
+                            Alternative Outbound Options
+                          </h3>
+                        </div>
+                        <div className="space-y-4">
+                          {alternativeOutbound.map((schedule: Schedule) =>
+                            renderScheduleCard(schedule, true, true),
+                          )}
                         </div>
-                        <h2 className="text-xl font-bold mb-2 text-gray-900 dark:text-gray-100">No trains available</h2>
-                        <p className="text-gray-600 dark:text-gray-400 mb-6">
-                          No trains are available on <span className="font-semibold text-gray-900 dark:text-gray-100">{requestedDate ? format(new Date(`${requestedDate}T00:00:00`), 'EEEE, MMMM d, yyyy') : 'your selected date'}</span>. This may be due to no scheduled service or full capacity. Please check the alternative options below or try a different date.
-                        </p>
-                        <button onClick={() => router.push(buildSearchUrl())} className="btn-primary">Change travel dates</button>
                       </div>
-                      <div className="mb-3">
-                        <h3 className="text-base font-bold text-gray-900 dark:text-white">Alternative Outbound Options</h3>
-                      </div>
-                      <div className="space-y-4">
-                        {alternativeOutbound.map((schedule: Schedule) => renderScheduleCard(schedule, true, true))}
-                      </div>
-                    </div>
-                  )}
+                    )}
                 </div>
               ) : (
                 <div>
@@ -894,20 +1219,25 @@ export default function ResultsPage() {
                           <Check className="w-4 h-4 text-green-600 dark:text-green-400" />
                         </div>
                         <div>
-                          <p className="text-sm font-semibold text-green-900 dark:text-green-200">Outbound journey selected</p>
+                          <p className="text-sm font-semibold text-green-900 dark:text-green-200">
+                            Outbound journey selected
+                          </p>
                           <p className="text-xs text-green-700 dark:text-green-400 mt-0.5">
-                            {outboundScheduleData.origin} → {outboundScheduleData.destination}
-                            {outboundScheduleData.selectedSeatClassName ? ` · ${outboundScheduleData.selectedSeatClassName}` : ''}
+                            {outboundScheduleData.origin} →{" "}
+                            {outboundScheduleData.destination}
+                            {outboundScheduleData.selectedSeatClassName
+                              ? ` · ${outboundScheduleData.selectedSeatClassName}`
+                              : ""}
                           </p>
                         </div>
                       </div>
                       <button
                         onClick={() => {
-                          setRoundTripStep('outbound');
+                          setRoundTripStep("outbound");
                           const prevId = outboundScheduleData?.id;
                           setOutboundScheduleData(null);
                           if (prevId) {
-                            setSelectedCoachTypes(prev => {
+                            setSelectedCoachTypes((prev) => {
                               const next = { ...prev };
                               delete next[prevId];
                               return next;
@@ -926,37 +1256,66 @@ export default function ResultsPage() {
                       Select Return Journey
                     </h2>
                     <p className="text-sm text-gray-500 dark:text-gray-400 mt-1">
-                      {searchData.returnDate ? format(new Date(searchData.returnDate), 'EEEE, MMMM d, yyyy') : ''}
+                      {searchData.returnDate
+                        ? format(
+                            new Date(searchData.returnDate),
+                            "EEEE, MMMM d, yyyy",
+                          )
+                        : ""}
                     </p>
                   </div>
                   <div className="space-y-4" id="inbound-section">
-                    {inboundSchedules.map((schedule: Schedule) => renderScheduleCard(schedule, false))}
+                    {inboundSchedules.map((schedule: Schedule) =>
+                      renderScheduleCard(schedule, false),
+                    )}
                   </div>
-                  {inboundSchedules.length === 0 && alternativeInbound.length > 0 && (
-                    <div className="mt-6">
-                      <div className="card text-center mb-6 max-w-3xl mx-auto">
-                        <div className="w-16 h-16 bg-amber-100 dark:bg-amber-900/30 rounded-full flex items-center justify-center mx-auto mb-4">
-                          <Calendar className="w-8 h-8 text-amber-500" />
+                  {inboundSchedules.length === 0 &&
+                    alternativeInbound.length > 0 && (
+                      <div className="mt-6">
+                        <div className="card text-center mb-6 max-w-3xl mx-auto">
+                          <div className="hidden sm:flex w-16 h-16 bg-amber-100 dark:bg-amber-900/30 rounded-full items-center justify-center mx-auto mb-4">
+                            <Calendar className="w-8 h-8 text-amber-500" />
+                          </div>
+                          <h2 className="text-xl font-bold mb-2 text-gray-900 dark:text-gray-100">
+                            No trains available
+                          </h2>
+                          <p className="text-gray-600 dark:text-gray-400 mb-6">
+                            No trains are available on{" "}
+                            <span className="font-semibold text-gray-900 dark:text-gray-100">
+                              {requestedReturnDate
+                                ? format(
+                                    new Date(`${requestedReturnDate}T00:00:00`),
+                                    "EEEE, MMMM d, yyyy",
+                                  )
+                                : "your selected return date"}
+                            </span>
+                          </p>
+                          <button
+                            onClick={() => router.push(buildSearchUrl())}
+                            className="btn-primary"
+                          >
+                            Change travel dates
+                          </button>
+                        </div>
+                        <div className="mb-3">
+                          <h3 className="text-base font-bold text-gray-900 dark:text-white">
+                            Alternative Return Options
+                          </h3>
+                        </div>
+                        <div className="space-y-4">
+                          {alternativeInbound.map((schedule: Schedule) =>
+                            renderScheduleCard(schedule, false, true),
+                          )}
                         </div>
-                        <h2 className="text-xl font-bold mb-2 text-gray-900 dark:text-gray-100">No trains available</h2>
-                        <p className="text-gray-600 dark:text-gray-400 mb-6">
-                          No trains are available on <span className="font-semibold text-gray-900 dark:text-gray-100">{requestedReturnDate ? format(new Date(`${requestedReturnDate}T00:00:00`), 'EEEE, MMMM d, yyyy') : 'your selected return date'}</span>. This may be due to no scheduled service or full capacity. Please check the alternative options below or try a different date.
-                        </p>
-                        <button onClick={() => router.push(buildSearchUrl())} className="btn-primary">Change travel dates</button>
                       </div>
-                      <div className="mb-3">
-                        <h3 className="text-base font-bold text-gray-900 dark:text-white">Alternative Return Options</h3>
-                      </div>
-                      <div className="space-y-4">
-                        {alternativeInbound.map((schedule: Schedule) => renderScheduleCard(schedule, false, true))}
-                      </div>
-                    </div>
-                  )}
+                    )}
                 </div>
               )
             ) : (
               <div className="space-y-4">
-                {outboundSchedules.map((schedule: Schedule) => renderScheduleCard(schedule, true))}
+                {outboundSchedules.map((schedule: Schedule) =>
+                  renderScheduleCard(schedule, true),
+                )}
               </div>
             )}
           </div>
diff --git a/apps/edr-passenger-web/portal/src/app/booking/review/page.tsx b/apps/edr-passenger-web/portal/src/app/booking/review/page.tsx
index c5d897a13..cf14cc87c 100644
--- a/apps/edr-passenger-web/portal/src/app/booking/review/page.tsx
+++ b/apps/edr-passenger-web/portal/src/app/booking/review/page.tsx
@@ -343,6 +343,9 @@ export default function ReviewPage() {
               passportNumber: !isEthiopian ? (p.passportNumber || '') : '',
               passportCountry: !isEthiopian ? (p.passportCountry || '') : '',
               nationality: p.nationality,
+              ...(isRoundTrip
+                ? { seatFareMinor: (p as any).outboundSeatFareMinor ?? undefined, returnSeatFareMinor: (p as any).inboundSeatFareMinor ?? undefined }
+                : { seatFareMinor: p.seatFareMinor ?? undefined }),
             };
           }),
         };
@@ -397,8 +400,9 @@ export default function ReviewPage() {
               passportNumber: !isEthiopian ? (p.passportNumber || '') : '',
               passportCountry: !isEthiopian ? (p.passportCountry || '') : '',
               nationality: p.nationality,
-              phone: p.phone || '',
-              email: p.email || '',
+              ...(isRoundTrip
+                ? { seatFareMinor: (p as any).outboundSeatFareMinor ?? undefined, returnSeatFareMinor: (p as any).inboundSeatFareMinor ?? undefined }
+                : { seatFareMinor: p.seatFareMinor ?? undefined }),
             };
           }),
           createAccount: createAccount || false,
@@ -444,6 +448,11 @@ export default function ReviewPage() {
         return { fareMinor, isFree: isFreeChild };
       });
       setReviewedTotal(computedTotal, passengerFares);
+
+      // Pass the exact total shown on this page to the backend so it stores the
+      // correct berth-specific amount regardless of what the fare engine calculates.
+      bookingData.reviewedTotalMinor = computedTotal;
+
       await createBookingMutation.mutateAsync(bookingData);
     } catch (error) {
       alert(error instanceof Error ? error.message : 'An unexpected error occurred. Please try again.');
diff --git a/apps/edr-passenger-web/portal/src/app/booking/search/page.tsx b/apps/edr-passenger-web/portal/src/app/booking/search/page.tsx
index 92e0ced68..574b08487 100644
--- a/apps/edr-passenger-web/portal/src/app/booking/search/page.tsx
+++ b/apps/edr-passenger-web/portal/src/app/booking/search/page.tsx
@@ -26,6 +26,20 @@ import {
 import { useEffect, useRef, useState, useCallback } from "react";
 import ModernDatePicker from "@/components/ModernDatePicker";
 
+function useDarkMode() {
+  const [dark, setDark] = useState(() =>
+    typeof window !== 'undefined' && document.documentElement.classList.contains('dark')
+  );
+  useEffect(() => {
+    const obs = new MutationObserver(() =>
+      setDark(document.documentElement.classList.contains('dark'))
+    );
+    obs.observe(document.documentElement, { attributeFilter: ['class'] });
+    return () => obs.disconnect();
+  }, []);
+  return dark;
+}
+
 const searchSchema = z
   .object({
     tripType: z.enum(["ONE_WAY", "ROUND_TRIP"]),
@@ -37,7 +51,9 @@ const searchSchema = z
     returnDate: z.string().optional(),
     adultCount: z.number().min(1).max(9),
     childCount: z.number().min(0).max(9),
-    nationality: z.enum(["ETHIOPIAN", "DJIBOUTIAN", "OTHER"]),
+    nationality: z.enum(["ETHIOPIAN", "DJIBOUTIAN", "OTHER"], {
+      errorMap: () => ({ message: "Please select your nationality" }),
+    }),
     promoCode: z.string().optional(),
   })
   .refine(
@@ -226,6 +242,7 @@ function PassengerModal({
   onChangeChild,
   onChangeNationality,
   onClose,
+  nationalityError,
 }: {
   adultCount: number;
   childCount: number;
@@ -234,6 +251,7 @@ function PassengerModal({
   onChangeChild: (n: number) => void;
   onChangeNationality: (v: string) => void;
   onClose: () => void;
+  nationalityError?: string;
 }) {
   const rows = [
     {
@@ -323,10 +341,13 @@ function PassengerModal({
             </div>
           ))}
           <div className="border-t border-gray-100 dark:border-gray-800 -mx-5 pt-5 px-5">
-            <p className="text-sm font-semibold text-gray-900 dark:text-white mb-3">
+            <p className="text-sm font-semibold text-gray-900 dark:text-white mb-1">
               Nationality
             </p>
-            <div className="grid grid-cols-3 gap-2">
+            {nationalityError && (
+              <p className="text-xs text-red-500 mb-2">{nationalityError}</p>
+            )}
+            <div className={`grid grid-cols-3 gap-2 ${nationalityError ? "mt-1" : "mt-2"}`}>
               {natOptions.map((opt) => (
                 <button
                   key={opt.value}
@@ -335,7 +356,9 @@ function PassengerModal({
                   className={`py-2.5 px-2 rounded-xl border-2 text-xs font-semibold transition-all ${
                     nationality === opt.value
                       ? "border-primary bg-primary/5 text-primary"
-                      : "border-gray-200 dark:border-gray-700 text-gray-600 dark:text-gray-400 hover:border-gray-300"
+                      : nationalityError
+                        ? "border-red-300 dark:border-red-800 text-gray-600 dark:text-gray-400 hover:border-gray-300"
+                        : "border-gray-200 dark:border-gray-700 text-gray-600 dark:text-gray-400 hover:border-gray-300"
                   }`}
                 >
                   {opt.label}
@@ -406,7 +429,7 @@ function StationDropdown({
           (s.name.toLowerCase().includes(query.toLowerCase()) ||
             s.code?.toLowerCase().includes(query.toLowerCase())),
       )
-    : stations.filter((s) => s.id !== excludeId).slice(0, 8);
+    : stations.filter((s) => s.id !== excludeId).slice(0, 20);
 
   const displayValue = open ? query : (selectedStation?.name ?? "");
 
@@ -452,7 +475,7 @@ function StationDropdown({
       </div>
 
       {open && (
-        <div className="absolute top-full left-0 right-0 mt-2 bg-white dark:bg-gray-800 border border-gray-200 dark:border-gray-700 rounded-xl shadow-xl z-[200] max-h-56 overflow-y-auto overflow-x-hidden scrollbar-hide">
+        <div className="absolute top-full left-0 right-0 mt-2 bg-white dark:bg-gray-800 border border-gray-200 dark:border-gray-700 rounded-xl shadow-xl z-[200] max-h-96 overflow-y-auto overflow-x-hidden scrollbar-hide">
           {!query && recentIds.length > 0 && (
             <div className="px-3 pt-2 pb-1">
               <p className="text-[10px] font-semibold text-gray-400 uppercase tracking-wide mb-1">
@@ -526,6 +549,7 @@ export default function SearchPage() {
   const queryClient = useQueryClient();
   const { user, isAuthenticated } = useAuthStore();
 
+  const dark = useDarkMode();
   const [passengerModalOpen, setPassengerModalOpen] = useState(false);
   const [promoVisible, setPromoVisible] = useState(false);
   const [promoCode, setPromoCode] = useState("");
@@ -586,7 +610,10 @@ export default function SearchPage() {
       tripType: "ONE_WAY",
       adultCount: 1,
       childCount: 0,
-      nationality: "ETHIOPIAN",
+      // No default nationality — the user must explicitly pick one. Left blank (not a valid
+      // enum member) so the zod schema's errorMap flags it if they try to search without
+      // selecting it.
+      nationality: "" as any,
       departureDate: "",
       promoCode: "",
     },
@@ -716,10 +743,34 @@ export default function SearchPage() {
     router.push(`/booking/results?${params}`);
   };
 
+  // Validate the rest of the form first — only once every other field is already valid do
+  // we surface the nationality error (opening the modal directly rather than leaving an
+  // inline error to hunt for). Otherwise nationality's error would show at the same time as
+  // origin/destination/date errors, which is noisier than fixing things one step at a time.
+  const onInvalid = (formErrors: typeof errors) => {
+    setHasInteracted(true);
+    const hasOtherErrors = Object.keys(formErrors).some((k) => k !== "nationality");
+    if (formErrors.nationality && !hasOtherErrors) {
+      setPassengerModalOpen(true);
+    }
+  };
+
   const getStationById = (id: string) => stations.find((s) => s.id === id);
   const originStation = getStationById(originId);
   const destStation = getStationById(destId);
 
+  // Mirrors onInvalid's ordering: don't flag nationality (border/message/modal) while other
+  // fields still have errors of their own to fix first.
+  const showNationalityError =
+    hasInteracted &&
+    !!errors.nationality &&
+    !Object.keys(errors).some((k) => k !== "nationality");
+
+  // No default nationality anymore — only render a flag once one is actually picked, rather
+  // than falling through to the "Other" 🌍 flag and implying a selection that hasn't happened.
+  const nationalityFlag = (nat?: string) =>
+    nat === "ETHIOPIAN" ? "🇪🇹" : nat === "DJIBOUTIAN" ? "🇩🇯" : nat === "OTHER" ? "🌍" : null;
+
   return (
     <div className="bg-gray-50 dark:bg-gray-950">
       {/* Passenger modal (mobile) */}
@@ -730,8 +781,12 @@ export default function SearchPage() {
           nationality={watch("nationality")}
           onChangeAdult={(n) => setValue("adultCount", n)}
           onChangeChild={(n) => setValue("childCount", n)}
-          onChangeNationality={(v) => setValue("nationality", v as any)}
+          onChangeNationality={(v) => {
+            setValue("nationality", v as any);
+            clearErrors("nationality");
+          }}
           onClose={() => setPassengerModalOpen(false)}
+          nationalityError={showNationalityError ? errors.nationality?.message : undefined}
         />
       )}
 
@@ -818,7 +873,7 @@ export default function SearchPage() {
           ref={widgetRef}
         >
           <div className="max-w-6xl mx-auto">
-            <form onSubmit={handleSubmit(onSubmit)}>
+            <form onSubmit={handleSubmit(onSubmit, onInvalid)}>
               <div className="bg-white dark:bg-gray-900 rounded-2xl shadow-2xl border border-white/20 overflow-visible">
                 {error && (
                   <div className="flex items-center gap-2 px-5 py-3 bg-red-50 text-red-600 text-sm border-b border-red-100 rounded-t-2xl">
@@ -882,12 +937,14 @@ export default function SearchPage() {
                               ? "border-red-400"
                               : originId
                                 ? "border-primary bg-primary/5"
-                                : "border-gray-200"
+                                : "border-gray-200 dark:border-gray-700"
                           }`}
+                          style={{ backgroundColor: originId ? undefined : undefined }}
                         >
                           <MapPin className="w-4 h-4 text-primary flex-shrink-0" />
                           <span
-                            className={`text-sm ${originStation ? "font-semibold text-gray-900" : "text-gray-400"}`}
+                            style={{ color: originStation ? (dark ? '#ffffff' : '#111827') : (dark ? '#6b7280' : '#9ca3af') }}
+                            className={`text-sm ${originStation ? 'font-semibold' : ''}`}
                           >
                             {originStation?.name ?? "Select departure"}
                           </span>
@@ -929,12 +986,13 @@ export default function SearchPage() {
                               ? "border-red-400"
                               : destId
                                 ? "border-primary bg-primary/5"
-                                : "border-gray-200"
+                                : "border-gray-200 dark:border-gray-700"
                           }`}
                         >
                           <MapPin className="w-4 h-4 text-primary flex-shrink-0" />
                           <span
-                            className={`text-sm ${destStation ? "font-semibold text-gray-900" : "text-gray-400"}`}
+                            style={{ color: destStation ? (dark ? '#ffffff' : '#111827') : (dark ? '#6b7280' : '#9ca3af') }}
+                            className={`text-sm ${destStation ? 'font-semibold' : ''}`}
                           >
                             {destStation?.name ?? "Select destination"}
                           </span>
@@ -1002,19 +1060,22 @@ export default function SearchPage() {
                     <button
                       type="button"
                       onClick={() => setPassengerModalOpen(true)}
-                      className="w-full flex items-center justify-between px-3.5 py-3 border-2 border-gray-200 rounded-xl bg-white"
+                      className={`w-full flex items-center justify-between px-3.5 py-3 border-2 rounded-xl bg-white dark:bg-gray-800 ${
+                        showNationalityError ? "border-red-400" : "border-gray-200 dark:border-gray-700"
+                      }`}
                     >
-                      <span className="flex items-center gap-2 text-sm font-medium text-gray-900">
+                      <span className="flex items-center gap-2 text-sm font-medium" style={{ color: dark ? '#ffffff' : '#111827' }}>
                         <Users className="w-4 h-4 text-primary" />
-                        {totalPassengers} Pax ·{" "}
-                        {watch("nationality") === "ETHIOPIAN"
-                          ? "🇪🇹"
-                          : watch("nationality") === "DJIBOUTIAN"
-                            ? "🇩🇯"
-                            : "🌍"}
+                        {totalPassengers} Pax
+                        {nationalityFlag(watch("nationality"))
+                          ? ` · ${nationalityFlag(watch("nationality"))}`
+                          : " · Select nationality"}
                       </span>
                       <ChevronDown className="w-4 h-4 text-primary" />
                     </button>
+                    {showNationalityError && (
+                      <p className="text-xs text-red-500">{errors.nationality?.message}</p>
+                    )}
                     <button
                       type="submit"
                       disabled={isLoading}
@@ -1100,8 +1161,6 @@ export default function SearchPage() {
                             </p>
                           )}
                         </div>
-                        {/* Divider */}
-                        <div className="w-px h-10 bg-gray-200 mb-0.5 flex-shrink-0" />
                         {/* Date */}
                         <div className="w-44 flex-shrink-0 space-y-1">
                           <label className="text-xs font-semibold text-gray-500 uppercase tracking-wide">
@@ -1131,8 +1190,6 @@ export default function SearchPage() {
                             </p>
                           )}
                         </div>
-                        {/* Divider */}
-                        <div className="w-px h-10 bg-gray-200 mb-0.5 flex-shrink-0" />
                         {/* Pax + Nationality */}
                         <div className="w-44 flex-shrink-0 space-y-1">
                           <label className="text-xs font-semibold text-gray-500 uppercase tracking-wide">
@@ -1141,19 +1198,22 @@ export default function SearchPage() {
                           <button
                             type="button"
                             onClick={() => setPassengerModalOpen(true)}
-                            className="w-full flex items-center justify-between px-3 py-3.5 border-2 border-gray-200 rounded-xl bg-white hover:border-gray-300 transition-all"
+                            className={`w-full flex items-center justify-between px-3 py-3.5 border-2 rounded-xl bg-white dark:bg-gray-800 hover:border-gray-300 dark:hover:border-gray-600 transition-all ${
+                              showNationalityError ? "border-red-400" : "border-gray-200 dark:border-gray-700"
+                            }`}
                           >
-                            <span className="flex items-center gap-1.5 text-sm font-medium text-gray-900 truncate">
+                            <span className="flex items-center gap-1.5 text-sm font-medium text-gray-900 dark:text-white truncate">
                               <Users className="w-4 h-4 text-primary flex-shrink-0" />
-                              {totalPassengers} Pax ·{" "}
-                              {watch("nationality") === "ETHIOPIAN"
-                                ? "🇪🇹"
-                                : watch("nationality") === "DJIBOUTIAN"
-                                  ? "🇩🇯"
-                                  : "🌍"}
+                              {totalPassengers} Pax
+                              {nationalityFlag(watch("nationality"))
+                                ? ` · ${nationalityFlag(watch("nationality"))}`
+                                : " · Select nationality"}
                             </span>
                             <ChevronDown className="w-4 h-4 text-primary flex-shrink-0" />
                           </button>
+                          {showNationalityError && (
+                            <p className="text-xs text-red-500">{errors.nationality?.message}</p>
+                          )}
                         </div>
                         {/* Search */}
                         <button
@@ -1395,19 +1455,24 @@ export default function SearchPage() {
                             <button
                               type="button"
                               onClick={() => setPassengerModalOpen(true)}
-                              className="w-full flex items-center justify-between px-3 py-3.5 border-2 border-gray-200 dark:border-gray-700 rounded-xl bg-white dark:bg-gray-800 hover:border-gray-300 dark:hover:border-gray-600 transition-all"
+                              className={`w-full flex items-center justify-between px-3 py-3.5 border-2 rounded-xl bg-white dark:bg-gray-800 hover:border-gray-300 dark:hover:border-gray-600 transition-all ${
+                                showNationalityError
+                                  ? "border-red-400"
+                                  : "border-gray-200 dark:border-gray-700"
+                              }`}
                             >
                               <span className="flex items-center gap-1.5 text-sm font-medium text-gray-900 dark:text-white truncate">
                                 <Users className="w-4 h-4 text-primary flex-shrink-0" />
-                                {totalPassengers} Pax ·{" "}
-                                {watch("nationality") === "ETHIOPIAN"
-                                  ? "🇪🇹"
-                                  : watch("nationality") === "DJIBOUTIAN"
-                                    ? "🇩🇯"
-                                    : "🌍"}
+                                {totalPassengers} Pax
+                                {nationalityFlag(watch("nationality"))
+                                  ? ` · ${nationalityFlag(watch("nationality"))}`
+                                  : " · Select nationality"}
                               </span>
                               <ChevronDown className="w-4 h-4 text-primary flex-shrink-0" />
                             </button>
+                            {showNationalityError && (
+                              <p className="text-xs text-red-500">{errors.nationality?.message}</p>
+                            )}
                           </div>
                           {/* Search Button */}
                           <div className="flex-shrink-0 space-y-1">
diff --git a/apps/edr-passenger-web/portal/src/app/booking/seats/page.tsx b/apps/edr-passenger-web/portal/src/app/booking/seats/page.tsx
index 9ae90c08b..f8fd23609 100644
--- a/apps/edr-passenger-web/portal/src/app/booking/seats/page.tsx
+++ b/apps/edr-passenger-web/portal/src/app/booking/seats/page.tsx
@@ -315,6 +315,11 @@ export default function SeatsPage() {
   // first real pick (no fare-change modal) even though the map already has an entry for
   // them — only a click AFTER that (replacing their own real pick) is an actual change.
   const restoredIndicesRef = useRef<Set<number>>(new Set());
+  // Set by handleAutoAssign right before it updates passengerSeatMap, so the effect below
+  // can proceed straight to Continue once that state update actually lands — calling
+  // handleContinue() synchronously in the same tick would still see the pre-update
+  // passengerSeatMap/allSeatsAssigned from this render's closure.
+  const autoContinueAfterAssignRef = useRef(false);
   useEffect(() => {
     const legKey = `${currentSchedule?.id || ''}-${currentJourneyType}`;
     if (restoredLegRef.current === legKey) return;
@@ -689,10 +694,6 @@ export default function SeatsPage() {
     () => filteredCoaches.find((c: any) => c.id === selectedCoach),
     [filteredCoaches, selectedCoach],
   );
-  const allSeats = useMemo(
-    () => selectedCoachData?.seats || [],
-    [selectedCoachData],
-  );
 
   const getBedPosition = (selectedClass: string): string | null => {
     const lowerClass = selectedClass.toLowerCase();
@@ -702,59 +703,87 @@ export default function SeatsPage() {
     return null;
   };
 
-  const validSeats = useMemo(() => {
-    // If coach has rooms, extract all beds from rooms
-    if (selectedCoachData?.rooms?.length > 0) {
-      const allBeds: any[] = [];
-      selectedCoachData.rooms.forEach((room: any) => {
-        if (room.beds) {
-          allBeds.push(...room.beds);
-        }
-      });
+  // Extracted so it can be applied to ANY coach, not just the one currently expanded —
+  // Auto Assign needs to look across every coach of this type, not just selectedCoachData.
+  const getValidSeatsForCoach = useCallback(
+    (coachData: any): any[] => {
+      if (!coachData) return [];
 
-      let beds = allBeds.filter((s: any) => {
+      // If coach has rooms, extract all beds from rooms
+      if (coachData.rooms?.length > 0) {
+        const allBeds: any[] = [];
+        coachData.rooms.forEach((room: any) => {
+          if (room.beds) {
+            allBeds.push(...room.beds);
+          }
+        });
+
+        let beds = allBeds.filter((s: any) => {
+          const seatLabel = s.label || s.number || s.seatNumber || "";
+          return seatLabel && !seatLabel.startsWith("-");
+        });
+
+        const isBedCoach =
+          coachData.seatClass?.toLowerCase().includes("bed") ||
+          coachData.mode?.toLowerCase().includes("bed");
+
+        if (isBedCoach && currentSchedule?.selectedSeatClass) {
+          const selectedBedPosition = getBedPosition(
+            currentSchedule.selectedSeatClass,
+          );
+          if (selectedBedPosition) {
+            beds = beds.filter((s: any) => s.bedPosition === selectedBedPosition);
+          }
+        }
+
+        return beds;
+      }
+
+      // Fallback to old seat structure
+      let seats = (coachData.seats || []).filter((s: any) => {
         const seatLabel = s.label || s.number || s.seatNumber || "";
         return seatLabel && !seatLabel.startsWith("-");
       });
-
       const isBedCoach =
-        selectedCoachData?.seatClass?.toLowerCase().includes("bed") ||
-        selectedCoachData?.mode?.toLowerCase().includes("bed");
+        coachData.isBedCoach === true ||
+        seats.some((s: any) => s.bedPosition) ||
+        coachData.seatClass?.toLowerCase().includes("bed") ||
+        coachData.mode?.toLowerCase().includes("bed");
 
       if (isBedCoach && currentSchedule?.selectedSeatClass) {
         const selectedBedPosition = getBedPosition(
           currentSchedule.selectedSeatClass,
         );
         if (selectedBedPosition) {
-          beds = beds.filter((s: any) => s.bedPosition === selectedBedPosition);
+          seats = seats.filter((s: any) => s.bedPosition === selectedBedPosition);
         }
       }
 
-      return beds;
-    }
+      return seats;
+    },
+    [currentSchedule?.selectedSeatClass],
+  );
 
-    // Fallback to old seat structure
-    let seats = allSeats.filter((s: any) => {
-      const seatLabel = s.label || s.number || s.seatNumber || "";
-      return seatLabel && !seatLabel.startsWith("-");
-    });
-    const isBedCoach =
-      selectedCoachData?.isBedCoach === true ||
-      seats.some((s: any) => s.bedPosition) ||
-      selectedCoachData?.seatClass?.toLowerCase().includes("bed") ||
-      selectedCoachData?.mode?.toLowerCase().includes("bed");
+  const validSeats = useMemo(
+    () => getValidSeatsForCoach(selectedCoachData),
+    [getValidSeatsForCoach, selectedCoachData],
+  );
 
-    if (isBedCoach && currentSchedule?.selectedSeatClass) {
-      const selectedBedPosition = getBedPosition(
-        currentSchedule.selectedSeatClass,
-      );
-      if (selectedBedPosition) {
-        seats = seats.filter((s: any) => s.bedPosition === selectedBedPosition);
-      }
-    }
-
-    return seats;
-  }, [allSeats, selectedCoachData, currentSchedule?.selectedSeatClass]);
+  // Every valid seat across every coach of the current type, tagged with which coach it
+  // belongs to — lets Auto Assign search the whole train (not just the one expanded coach)
+  // and lets handleContinue resolve a passenger's coach label even when their seat came
+  // from a coach they never manually expanded.
+  const allCoachSeats = useMemo(
+    () =>
+      filteredCoaches.flatMap((c: any) =>
+        getValidSeatsForCoach(c).map((s: any) => ({
+          ...s,
+          _coachId: c.id,
+          _coachLabel: c.label || c.name || c.coachNumber || c.number || "",
+        })),
+      ),
+    [filteredCoaches, getValidSeatsForCoach],
+  );
 
   // Seats already claimed by any passenger in this journey leg, plus outbound
   const assignedSeatIds = useMemo(
@@ -989,12 +1018,15 @@ export default function SeatsPage() {
       try {
         await ensureLegHold(seatIdsForHold);
         const updatedPassengers = passengers.map((p, i) => {
-          const seatData = validSeats?.find((s: any) => s.id === seatIds[i]);
+          // Look up from allCoachSeats (every coach of this type), not just the currently
+          // expanded one — Auto Assign can place passengers in a coach that was never
+          // manually expanded.
+          const seatData = allCoachSeats?.find((s: any) => s.id === seatIds[i]);
           return {
             ...p,
             outboundSeatId: seatIds[i],
             outboundSeatNumber: seatData ? buildSeatLabel(seatData) : '',
-            outboundCoachNumber: selectedCoachData?.label || selectedCoachData?.name || selectedCoachData?.number || '',
+            outboundCoachNumber: seatData?._coachLabel || selectedCoachData?.label || selectedCoachData?.name || selectedCoachData?.number || '',
             outboundSeatFareMinor: seatData ? (getSeatFare(seatData) ?? undefined) : undefined,
             outboundBedPosition: seatData?.bedPosition || undefined,
           };
@@ -1170,13 +1202,16 @@ export default function SeatsPage() {
     try {
       await ensureLegHold(seatIdsForHold);
       const updatedPassengers = passengers.map((p, i) => {
-        const seatData = validSeats?.find((s: any) => s.id === seatIds[i]);
+        // See the outbound branch above — resolve from allCoachSeats so a passenger whose
+        // seat came from a coach Auto Assign picked (but was never manually expanded)
+        // still gets the right coach label.
+        const seatData = allCoachSeats?.find((s: any) => s.id === seatIds[i]);
         if (isRoundTrip && currentJourneyType === "inbound") {
           return {
             ...p,
             inboundSeatId: seatIds[i],
             inboundSeatNumber: seatData ? buildSeatLabel(seatData) : '',
-            inboundCoachNumber: selectedCoachData?.label || selectedCoachData?.name || selectedCoachData?.number || '',
+            inboundCoachNumber: seatData?._coachLabel || selectedCoachData?.label || selectedCoachData?.name || selectedCoachData?.number || '',
             inboundSeatFareMinor: seatData ? (getSeatFare(seatData) ?? undefined) : undefined,
             inboundBedPosition: seatData?.bedPosition || undefined,
           };
@@ -1185,7 +1220,7 @@ export default function SeatsPage() {
           ...p,
           seatId: seatIds[i],
           seatNumber: seatData ? buildSeatLabel(seatData) : '',
-          coachNumber: selectedCoachData?.label || selectedCoachData?.name || selectedCoachData?.number || '',
+          coachNumber: seatData?._coachLabel || selectedCoachData?.label || selectedCoachData?.name || selectedCoachData?.number || '',
           seatFareMinor: seatData ? (getSeatFare(seatData) ?? undefined) : undefined,
           bedPosition: seatData?.bedPosition || undefined,
         };
@@ -1197,7 +1232,7 @@ export default function SeatsPage() {
       if (!isRoundTrip && isPackageBooking && packageId) {
         const firstEligibleIdx = seatEligibleIndices[0];
         const firstSeatData = firstEligibleIdx != null
-          ? validSeats?.find((s: any) => s.id === seatIds[firstEligibleIdx])
+          ? allCoachSeats?.find((s: any) => s.id === seatIds[firstEligibleIdx])
           : null;
         const berthFare = firstSeatData ? getSeatFare(firstSeatData) : null;
         if (berthFare != null) {
@@ -1228,20 +1263,38 @@ export default function SeatsPage() {
     router.push("/booking/review");
   };
 
+  // Fires once the passengerSeatMap update from handleAutoAssign has actually landed (and
+  // every eligible passenger now has a seat) — proceeds straight to Continue so the user
+  // doesn't have to click it separately after auto-assigning.
+  useEffect(() => {
+    if (autoContinueAfterAssignRef.current && allSeatsAssigned) {
+      autoContinueAfterAssignRef.current = false;
+      handleContinue();
+    }
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [passengerSeatMap, allSeatsAssigned]);
+
   const handleAutoAssign = () => {
     const unassignedIndices = seatEligibleIndices.filter((i) => !passengerSeatMap[i]);
 
     if (unassignedIndices.length === 0) return;
 
-    const availableSeats = (
-      validSeats?.filter((s: any) => s.status === "AVAILABLE") || []
-    ).filter((s: any) => !assignedSeatIds.has(s.id));
+    // Search the whole train (every coach of this type), not just whichever one happens to
+    // be expanded — fill the currently-expanded coach first so the result stays visible
+    // without switching coaches, then spill over into other coaches only if needed.
+    const availableAcrossTrain = allCoachSeats
+      .filter((s: any) => s.status === "AVAILABLE" && !assignedSeatIds.has(s.id))
+      .sort((a: any, b: any) => {
+        const aCurrent = a._coachId === selectedCoach ? 0 : 1;
+        const bCurrent = b._coachId === selectedCoach ? 0 : 1;
+        return aCurrent - bCurrent;
+      });
 
-    if (availableSeats.length < unassignedIndices.length) {
+    if (availableAcrossTrain.length < unassignedIndices.length) {
       setModalState({
         isOpen: true,
         title: "Not Enough Seats",
-        message: `Only ${availableSeats.length} seat(s) available in this coach, but you need ${unassignedIndices.length} more seat(s). Please select another coach.`,
+        message: `Only ${availableAcrossTrain.length} seat(s) available across this coach type, but you need ${unassignedIndices.length} more seat(s). Please select another coach type.`,
         type: "warning",
         onConfirm: undefined,
         showCancel: false,
@@ -1251,11 +1304,21 @@ export default function SeatsPage() {
     }
 
     const next = { ...passengerSeatMap };
+    let lastAssignedCoachId: string | null = null;
     unassignedIndices.forEach((passengerIndex, offset) => {
-      next[passengerIndex] = availableSeats[offset].id;
+      const seat = availableAcrossTrain[offset];
+      next[passengerIndex] = seat.id;
+      lastAssignedCoachId = seat._coachId;
     });
+    // Proceed straight to Continue once this update lands — no separate click needed.
+    autoContinueAfterAssignRef.current = true;
     setPassengerSeatMap(next);
     setActivePassengerIndex(seatEligibleIndices[seatEligibleIndices.length - 1] ?? 0);
+    // Bring whichever coach the last passenger landed in into view, since seats may now
+    // span coaches beyond the one that was expanded when Auto Assign was clicked.
+    if (lastAssignedCoachId && lastAssignedCoachId !== selectedCoach) {
+      setSelectedCoach(lastAssignedCoachId);
+    }
   };
 
   const handleBackToPassengers = () => {
@@ -1857,8 +1920,10 @@ export default function SeatsPage() {
           }
 
           const assignedSeatId = passengerSeatMap[i];
+          // allCoachSeats (not validSeats) so a seat Auto Assign placed in a coach the user
+          // never manually expanded still shows correctly here.
           const assignedSeat = assignedSeatId
-            ? validSeats?.find((s: any) => s.id === assignedSeatId)
+            ? allCoachSeats?.find((s: any) => s.id === assignedSeatId)
             : null;
           const seatLabel = assignedSeat ? buildSeatLabel(assignedSeat) : "";
           const seatFare = assignedSeat
diff --git a/apps/edr-passenger-web/portal/src/app/help/page.tsx b/apps/edr-passenger-web/portal/src/app/help/page.tsx
index be49c34f3..eb8a6a150 100644
--- a/apps/edr-passenger-web/portal/src/app/help/page.tsx
+++ b/apps/edr-passenger-web/portal/src/app/help/page.tsx
@@ -1,9 +1,18 @@
 'use client';
 
-import { useEffect, useState } from 'react';
-import { getTranslation, Language, useLanguage } from '@/lib/i18n';
+import { useState } from 'react';
 import Link from 'next/link';
-import { ChevronDown, Search, MessageCircle } from 'lucide-react';
+import {
+  ChevronDown,
+  Search,
+  MessageCircle,
+  Ticket,
+  CreditCard,
+  Users,
+  MapPin,
+  Wallet,
+  ShieldCheck,
+} from 'lucide-react';
 
 interface FAQItem {
   question: string;
@@ -11,414 +20,389 @@ interface FAQItem {
 }
 
 interface FAQCategory {
+  icon: React.ReactNode;
   title: string;
   items: FAQItem[];
 }
 
-const styles = `
-  .help-hero {
-    padding: 60px 20px;
-    background: linear-gradient(to bottom right, rgb(20, 113, 76), transparent);
-    text-align: center;
-    color: #111827;
-  }
-  
-  .dark .help-hero {
-    color: #f3f4f6;
-  }
-  
-  .help-hero h1 {
-    font-size: 2.5rem;
-    font-weight: 700;
-    margin-bottom: 16px;
-    color: #111827;
-  }
-  
-  .dark .help-hero h1 {
-    color: #f3f4f6;
-  }
-  
-  .help-hero p {
-    font-size: 1.125rem;
-    color: #6b7280;
-  }
-  
-  .dark .help-hero p {
-    color: #9ca3af;
-  }
-  
-  .search-section {
-    padding: 30px 20px;
-    background-color: white;
-    border-bottom: 1px solid #e5e7eb;
-  }
-  
-  .dark .search-section {
-    background-color: #111827;
-    border-bottom-color: #374151;
-  }
-  
-  .search-box {
-    max-width: 42rem;
-    margin: 0 auto;
-    position: relative;
-  }
-  
-  .search-box input {
-    width: 100%;
-    padding: 12px 40px 12px 12px;
-    border: 2px solid #e5e7eb;
-    border-radius: 12px;
-    font-size: 1rem;
-    transition: all 0.2s;
-    box-sizing: border-box;
-    background: white;
-    color: #111827;
-  }
-  
-  .dark .search-box input {
-    background: #1f2937;
-    color: #f3f4f6;
-    border-color: #374151;
-  }
-  
-  .search-box input:focus {
-    outline: none;
-    border-color: rgb(20, 113, 76);
-    box-shadow: 0 0 0 3px rgba(20, 113, 76, 0.1);
-  }
-  
-  .search-icon {
-    position: absolute;
-    right: 12px;
-    top: 50%;
-    transform: translateY(-50%);
-    color: #9ca3af;
-    pointer-events: none;
-  }
-  
-  .faq-section {
-    padding: 60px 20px;
-    background-color: white;
-  }
-  
-  .dark .faq-section {
-    background-color: #111827;
-  }
-  
-  .faq-container {
-    max-width: 48rem;
-    margin: 0 auto;
-  }
-  
-  .faq-category {
-    margin-bottom: 40px;
-  }
-  
-  .faq-category h2 {
-    font-size: 1.5rem;
-    font-weight: 700;
-    margin-bottom: 24px;
-    color: #111827;
-  }
-  
-  .dark .faq-category h2 {
-    color: #f3f4f6;
-  }
-  
-  .faq-item {
-    border: 2px solid #e5e7eb;
-    border-radius: 8px;
-    margin-bottom: 16px;
-    overflow: hidden;
-    transition: all 0.2s;
-  }
-  
-  .dark .faq-item {
-    border-color: #374151;
-  }
-  
-  .faq-item:hover {
-    border-color: rgb(20, 113, 76);
-  }
-  
-  .faq-question {
-    display: flex;
-    align-items: center;
-    justify-content: space-between;
-    padding: 16px;
-    background-color: white;
-    cursor: pointer;
-    transition: all 0.2s;
-    border: none;
-    width: 100%;
-    text-align: left;
-    font-weight: 600;
-    color: #111827;
-  }
-  
-  .dark .faq-question {
-    background-color: #1f2937;
-    color: #f3f4f6;
-  }
-  
-  .faq-question:hover {
-    background-color: #f9fafb;
-  }
-  
-  .dark .faq-question:hover {
-    background-color: #374151;
-  }
-  
-  .faq-chevron {
-    transition: transform 0.3s;
-    flex-shrink: 0;
-    margin-left: 12px;
-  }
-  
-  .faq-chevron.open {
-    transform: rotate(180deg);
-  }
-  
-  .faq-answer {
-    padding: 16px;
-    background-color: #f9fafb;
-    border-top: 1px solid #e5e7eb;
-    color: #6b7280;
-    font-size: 0.875rem;
-    line-height: 1.6;
-  }
-  
-  .dark .faq-answer {
-    background-color: #0f1117;
-    border-top-color: #374151;
-    color: #9ca3af;
-  }
-  
-  .help-section {
-    padding: 60px 20px;
-    background-color: #f9fafb;
-  }
-  
-  .dark .help-section {
-    background-color: #0f1117;
-  }
-  
-  .help-card {
-    max-width: 42rem;
-    margin: 0 auto;
-    background: white;
-    border-radius: 18px;
-    padding: 32px;
-    border: 1px solid #e5e7eb;
-    text-align: center;
-  }
-  
-  .dark .help-card {
-    background: #1f2937;
-    border-color: #374151;
-  }
-  
-  .help-icon {
-    width: 64px;
-    height: 64px;
-    background: rgb(20, 113, 76);
-    border-radius: 8px;
-    display: flex;
-    align-items: center;
-    justify-content: center;
-    margin: 0 auto 16px;
-  }
-  
-  .help-card h2 {
-    font-size: 1.5rem;
-    font-weight: 700;
-    margin-bottom: 12px;
-    color: #111827;
-  }
-  
-  .dark .help-card h2 {
-    color: #f3f4f6;
-  }
-  
-  .help-card p {
-    color: #6b7280;
-    margin-bottom: 24px;
-  }
-  
-  .dark .help-card p {
-    color: #9ca3af;
-  }
-  
-  .button-primary {
-    display: inline-block;
-    padding: 12px 32px;
-    background-color: rgb(20, 113, 76);
-    color: white;
-    font-weight: 700;
-    border-radius: 12px;
-    text-decoration: none;
-    transition: all 0.2s;
-  }
-  
-  .button-primary:hover {
-    background-color: rgb(16, 89, 60);
-    transform: scale(1.05);
-  }
-  
-  .no-results {
-    text-align: center;
-    padding: 40px 20px;
-    color: #6b7280;
-  }
-  
-  .dark .no-results {
-    color: #9ca3af;
-  }
-  
-  @media (max-width: 768px) {
-    .help-hero h1 {
-      font-size: 1.875rem;
-    }
-  }
-`;
+const FAQ_CATEGORIES: FAQCategory[] = [
+  {
+    icon: <Ticket className="w-5 h-5" />,
+    title: 'Booking',
+    items: [
+      {
+        question: 'How do I book a ticket?',
+        answer:
+          'Go to the search page, enter your departure and destination stations, select a date, choose the number of passengers and your nationality, then tap Search. Pick a trip from the results, select your seats, fill in passenger details, and complete payment.',
+      },
+      {
+        question: 'Can I book without creating an account?',
+        answer:
+          'Yes. Guest booking is fully supported — no account required. You can optionally create an account at the end of the booking flow to save your details for future trips.',
+      },
+      {
+        question: 'What is the booking reference format?',
+        answer:
+          'Your booking reference is a 6-character alphanumeric code (e.g. A3F9KZ). It is shown on your confirmation screen and sent to your email or phone. Use it to look up your booking at any time via the Booking Lookup page.',
+      },
+      {
+        question: 'Can I book a round trip?',
+        answer:
+          'Yes. Select "Round Trip" on the search form, choose both a departure and return date, and complete both legs in a single flow.',
+      },
+      {
+        question: 'How far in advance can I book?',
+        answer:
+          'Tickets are available for booking up to the hold cutoff time before departure (typically 2 hours). Schedules are published in advance so you can plan ahead.',
+      },
+      {
+        question: 'Can I save passenger details for future bookings?',
+        answer:
+          'Yes. When booking as a logged-in user you can save passenger profiles. On subsequent bookings you can select a saved passenger instead of re-entering their details.',
+      },
+      {
+        question: 'How do I modify my booking?',
+        answer:
+          'Log in and go to your profile, find the booking, and select Modify. Changes are allowed up to 24 hours before departure. Fare differences may apply.',
+      },
+      {
+        question: 'What is the cancellation policy?',
+        answer:
+          'Cancellations made at least 48 hours before departure receive a full refund. Cancellations within 48 hours may be subject to a fee. Refunds are returned to your original payment method or wallet.',
+      },
+    ],
+  },
+  {
+    icon: <Users className="w-5 h-5" />,
+    title: 'Passengers & Age-Based Pricing',
+    items: [
+      {
+        question: 'How is the fare calculated?',
+        answer:
+          'The fare is calculated as: Base Fare × Distance + Insurance. The base fare depends on the seat class (Economy Regular, Economy Bed, or VIP Bed). Age-based rules then apply on top of this.',
+      },
+      {
+        question: 'What are the passenger age categories?',
+        answer:
+          'Adults are passengers aged 5 years and above and pay 100% of the fare. Children are passengers under 5 years old — the first child in a booking travels free, and any additional children pay the full fare.',
+      },
+      {
+        question: 'How is a child\'s age determined?',
+        answer:
+          'Age is calculated automatically from the date of birth you enter for each passenger. Make sure to enter the correct date of birth so the right fare is applied.',
+      },
+      {
+        question: 'Example: how much does a family of 2 adults + 3 children pay?',
+        answer:
+          'The first child is free, so you pay for 2 adults + 2 children = 4× the base fare for that seat class and distance.',
+      },
+      {
+        question: 'What seat classes are available?',
+        answer:
+          'Three classes are available: Economy Regular (standard seating), Economy Bed (sleeping berth in economy), and VIP Bed (premium sleeping berth). Each has its own base fare.',
+      },
+      {
+        question: 'What is the nationality field for?',
+        answer:
+          'Nationality determines which ID verification path applies. Ethiopian nationals are verified via the Verifayda national ID system. Djiboutian and other international passengers use their passport instead.',
+      },
+    ],
+  },
+  {
+    icon: <ShieldCheck className="w-5 h-5" />,
+    title: 'Identity Verification (Verifayda)',
+    items: [
+      {
+        question: 'What is Verifayda?',
+        answer:
+          'Verifayda is the Ethiopian government\'s national ID verification system. When you book as an Ethiopian national, your national ID is verified in real time to confirm your identity and retrieve your name and date of birth.',
+      },
+      {
+        question: 'Is my national ID stored?',
+        answer:
+          'No. National ID numbers are not stored in our system. Verification happens in real time and only the confirmed passenger data (name, date of birth, nationality) is used for the booking.',
+      },
+      {
+        question: 'What if I am not Ethiopian?',
+        answer:
+          'Non-Ethiopian passengers use their passport number instead. No Verifayda verification is required. Select your nationality on the search form and enter your passport details during the passenger information step.',
+      },
+      {
+        question: 'What happens if verification fails?',
+        answer:
+          'If Verifayda verification is unsuccessful the booking cannot be completed for that passenger. Check that the national ID number is correct and try again. If the problem persists, contact support.',
+      },
+    ],
+  },
+  {
+    icon: <MapPin className="w-5 h-5" />,
+    title: 'Stations & Routes',
+    items: [
+      {
+        question: 'How many stations does EDR serve?',
+        answer:
+          'EDR serves 21 stations along the Ethio-Djibouti Railway corridor, spanning from Addis Ababa in Ethiopia to Djibouti City in Djibouti.',
+      },
+      {
+        question: 'Can I book a partial journey (not the full route)?',
+        answer:
+          'Yes. You can book between any two stations on the route. Fares are calculated based on the distance between your chosen origin and destination.',
+      },
+      {
+        question: 'How do I find my nearest station?',
+        answer:
+          'On the search page, tap the From or To field and browse or search the full list of stations. Each station shows its code and country.',
+      },
+      {
+        question: 'Are prices shown in my local currency?',
+        answer:
+          'All transactions are processed in Ethiopian Birr (ETB). You can view prices in ETB, Djiboutian Franc (DJF), or US Dollar (USD) by selecting your preferred display currency on the fare or booking screen.',
+      },
+    ],
+  },
+  {
+    icon: <CreditCard className="w-5 h-5" />,
+    title: 'Payment',
+    items: [
+      {
+        question: 'What payment methods are accepted?',
+        answer:
+          'We accept Telebirr, CBE Birr, eBirr, credit/debit cards, and EDR Wallet balance. You can choose your preferred method at checkout.',
+      },
+      {
+        question: 'What is the EDR Wallet?',
+        answer:
+          'The EDR Wallet is a stored-value account linked to your profile. You can top it up and use it to pay for tickets instantly. Your wallet balance and transaction history are available in your profile.',
+      },
+      {
+        question: 'When will I receive my refund?',
+        answer:
+          'Refunds are processed within 5–7 business days to your original payment method. If you paid via EDR Wallet, the refund is credited to your wallet immediately.',
+      },
+      {
+        question: 'Is my payment information secure?',
+        answer:
+          'Yes. We do not store card details. All payments are processed through certified payment providers. Transactions are encrypted end-to-end.',
+      },
+    ],
+  },
+  {
+    icon: <Ticket className="w-5 h-5" />,
+    title: 'Tickets & Boarding',
+    items: [
+      {
+        question: 'How do I get my ticket?',
+        answer:
+          'After payment is confirmed, your ticket is generated automatically. You can view and download it as a PDF from your booking detail page. A QR code and barcode are included for gate validation.',
+      },
+      {
+        question: 'Do I need to print my ticket?',
+        answer:
+          'No. You can show your digital ticket (QR code) on your phone at the gate. Printed tickets are also accepted.',
+      },
+      {
+        question: 'What do I need to board?',
+        answer:
+          'Present your ticket QR code and a valid ID (national ID or passport matching the passenger details on the booking) at the gate.',
+      },
+      {
+        question: 'Can I look up a booking without an account?',
+        answer:
+          'Yes. Go to the Booking Lookup page and enter your booking reference and the phone number or email used when booking.',
+      },
+    ],
+  },
+  {
+    icon: <Wallet className="w-5 h-5" />,
+    title: 'Account & Profile',
+    items: [
+      {
+        question: 'How do I create an account?',
+        answer:
+          'Tap Register on the login page and enter your email, phone number, full name, and a password. You will receive an OTP to verify your account.',
+      },
+      {
+        question: 'I forgot my password. What do I do?',
+        answer:
+          'Tap "Forgot password" on the login page, enter your registered email, and follow the reset link sent to your inbox.',
+      },
+      {
+        question: 'How do I set up Verifayda on my account?',
+        answer:
+          'Go to your profile and find the Fayda Setup section. Enter your national ID to link your verified identity to your account. This enables faster booking as your details are pre-filled.',
+      },
+      {
+        question: 'Can I use the app in multiple languages?',
+        answer:
+          'Yes. The app supports English, Amharic (አማርኛ), Afaan Oromoo, and French. Change your language from the navigation bar.',
+      },
+    ],
+  },
+];
 
-export default function Help() {
-  const [lang, setLang] = useState<Language>('en');
-  const [openIndexes, setOpenIndexes] = useState<number[]>([]);
+export default function HelpPage() {
+  const [openKeys, setOpenKeys] = useState<Set<string>>(new Set());
   const [searchTerm, setSearchTerm] = useState('');
-  const { getLang } = useLanguage();
-  const t = (key: string) => getTranslation(lang, key);
 
-  useEffect(() => {
-    setLang(getLang());
-    const handleLanguageChange = (e: any) => setLang(e.detail);
-    window.addEventListener('languageChange', handleLanguageChange);
-    return () => window.removeEventListener('languageChange', handleLanguageChange);
-  }, [getLang]);
-
-  const faqCategories: FAQCategory[] = [
-    {
-      title: t('help.bookingFaq'),
-      items: [
-        { question: t('help.how'), answer: t('help.howAnswer') },
-        { question: t('help.modify'), answer: t('help.modifyAnswer') },
-        { question: t('help.cancel'), answer: t('help.cancelAnswer') },
-      ],
-    },
-    {
-      title: t('help.paymentFaq'),
-      items: [
-        { question: t('help.payMethods'), answer: t('help.payMethodsAnswer') },
-        { question: t('help.refund'), answer: t('help.refundAnswer') },
-      ],
-    },
-    {
-      title: t('help.other'),
-      items: [
-        { question: t('help.docs'), answer: t('help.docsAnswer') },
-      ],
-    },
-  ];
-
-  const toggleFAQ = (index: number) => {
-    if (openIndexes.includes(index)) {
-      setOpenIndexes(openIndexes.filter(i => i !== index));
-    } else {
-      setOpenIndexes([...openIndexes, index]);
-    }
+  const toggle = (key: string) => {
+    setOpenKeys((prev) => {
+      const next = new Set(prev);
+      next.has(key) ? next.delete(key) : next.add(key);
+      return next;
+    });
   };
 
-  let flatFAQs: (FAQItem & { id: number })[] = [];
-  faqCategories.forEach((cat) => {
-    cat.items.forEach((item) => {
-      flatFAQs.push({ ...item, id: flatFAQs.length });
+  const query = searchTerm.trim().toLowerCase();
+  const searchResults: { catTitle: string; item: FAQItem; key: string }[] = [];
+  if (query) {
+    FAQ_CATEGORIES.forEach((cat) => {
+      cat.items.forEach((item, i) => {
+        if (
+          item.question.toLowerCase().includes(query) ||
+          item.answer.toLowerCase().includes(query)
+        ) {
+          searchResults.push({ catTitle: cat.title, item, key: `search-${cat.title}-${i}` });
+        }
+      });
     });
-  });
-
-  const filteredFAQs = flatFAQs.filter(
-    (faq) =>
-      faq.question.toLowerCase().includes(searchTerm.toLowerCase()) ||
-      faq.answer.toLowerCase().includes(searchTerm.toLowerCase())
-  );
+  }
 
   return (
-    <>
-      <style>{styles}</style>
-      <main>
-        <section className="help-hero">
-          <h1>{t('help.title')}</h1>
-          <p>{t('help.subtitle')}</p>
-        </section>
+    <main className="min-h-screen bg-gray-50 dark:bg-gray-950">
+      {/* Hero */}
+      <section className="bg-gradient-to-br from-primary/90 to-primary/60 py-14 px-4 text-center">
+        <h1 className="text-3xl md:text-4xl font-bold text-white mb-3">Help & FAQs</h1>
+        <p className="text-white/80 text-base max-w-xl mx-auto">
+          Find answers about booking, pricing, payments, and more.
+        </p>
+      </section>
 
-        <section className="search-section">
-          <div className="search-box">
-            <input
-              type="text"
-              placeholder="Search FAQs..."
-              value={searchTerm}
-              onChange={(e) => setSearchTerm(e.target.value)}
-            />
-            <Search className="search-icon" size={20} />
-          </div>
-        </section>
+      {/* Search */}
+      <section className="bg-white dark:bg-gray-900 border-b border-gray-200 dark:border-gray-800 px-4 py-5">
+        <div className="max-w-2xl mx-auto relative">
+          <Search className="absolute left-3.5 top-1/2 -translate-y-1/2 w-4 h-4 text-gray-400" />
+          <input
+            type="text"
+            placeholder="Search FAQs…"
+            value={searchTerm}
+            onChange={(e) => setSearchTerm(e.target.value)}
+            className="w-full pl-10 pr-4 py-3 border-2 border-gray-200 dark:border-gray-700 rounded-xl bg-white dark:bg-gray-800 text-gray-900 dark:text-white placeholder-gray-400 focus:outline-none focus:border-primary text-sm"
+          />
+        </div>
+      </section>
 
-        <section className="faq-section">
-          <div className="faq-container">
-            {searchTerm ? (
-              <>
-                {filteredFAQs.length > 0 ? (
-                  filteredFAQs.map((faq) => (
-                    <div key={faq.id} className="faq-item">
-                      <div className="faq-question">
-                        <span>{faq.question}</span>
-                      </div>
-                      <div className="faq-answer">{faq.answer}</div>
-                    </div>
-                  ))
-                ) : (
-                  <div className="no-results">
-                    No FAQs found for &quot;{searchTerm}&quot;
-                  </div>
-                )}
-              </>
-            ) : (
-              faqCategories.map((category, catIdx) => (
-                <div key={catIdx} className="faq-category">
-                  <h2>{category.title}</h2>
-                  {category.items.map((item, itemIdx) => {
-                    const globalIdx = catIdx * 100 + itemIdx;
-                    const isOpen = openIndexes.includes(globalIdx);
+      {/* Content */}
+      <section className="px-4 py-10 max-w-3xl mx-auto">
+        {query ? (
+          searchResults.length > 0 ? (
+            <div className="space-y-3">
+              <p className="text-sm text-gray-500 dark:text-gray-400 mb-4">
+                {searchResults.length} result{searchResults.length !== 1 ? 's' : ''} for &ldquo;{searchTerm}&rdquo;
+              </p>
+              {searchResults.map(({ catTitle, item, key }) => (
+                <FAQRow
+                  key={key}
+                  question={item.question}
+                  answer={item.answer}
+                  badge={catTitle}
+                  isOpen={openKeys.has(key)}
+                  onToggle={() => toggle(key)}
+                />
+              ))}
+            </div>
+          ) : (
+            <div className="text-center py-16 text-gray-400 dark:text-gray-500">
+              <Search className="w-10 h-10 mx-auto mb-3 opacity-40" />
+              <p className="text-sm">No results for &ldquo;{searchTerm}&rdquo;</p>
+            </div>
+          )
+        ) : (
+          <div className="space-y-10">
+            {FAQ_CATEGORIES.map((cat) => (
+              <div key={cat.title}>
+                <div className="flex items-center gap-2 mb-4">
+                  <span className="text-primary">{cat.icon}</span>
+                  <h2 className="text-lg font-bold text-gray-900 dark:text-white">{cat.title}</h2>
+                </div>
+                <div className="space-y-2">
+                  {cat.items.map((item, i) => {
+                    const key = `${cat.title}-${i}`;
                     return (
-                      <div key={itemIdx} className="faq-item">
-                        <button
-                          className="faq-question"
-                          onClick={() => toggleFAQ(globalIdx)}
-                        >
-                          <span>{item.question}</span>
-                          <ChevronDown className={`faq-chevron ${isOpen ? 'open' : ''}`} size={20} color="rgb(20, 113, 76)" />
-                        </button>
-                        {isOpen && <div className="faq-answer">{item.answer}</div>}
-                      </div>
+                      <FAQRow
+                        key={key}
+                        question={item.question}
+                        answer={item.answer}
+                        isOpen={openKeys.has(key)}
+                        onToggle={() => toggle(key)}
+                      />
                     );
                   })}
                 </div>
-              ))
-            )}
+              </div>
+            ))}
           </div>
-        </section>
+        )}
+      </section>
 
-        <section className="help-section">
-          <div className="help-card">
-            <div className="help-icon">
-              <MessageCircle size={32} color="white" />
-            </div>
-            <h2>{t('help.help')}</h2>
-            <p>{t('help.contact')}</p>
-            <Link href="/contact" className="button-primary">Contact Support</Link>
+      {/* Contact CTA */}
+      <section className="px-4 pb-16">
+        <div className="max-w-xl mx-auto bg-white dark:bg-gray-900 border border-gray-200 dark:border-gray-800 rounded-2xl p-8 text-center shadow-sm">
+          <div className="w-14 h-14 bg-primary rounded-xl flex items-center justify-center mx-auto mb-4">
+            <MessageCircle className="w-7 h-7 text-white" />
           </div>
-        </section>
-      </main>
-    </>
+          <h2 className="text-xl font-bold text-gray-900 dark:text-white mb-2">Still need help?</h2>
+          <p className="text-gray-500 dark:text-gray-400 text-sm mb-6">
+            Our support team is available to assist you.
+          </p>
+          <Link
+            href="/contact"
+            className="inline-block px-8 py-3 bg-primary hover:bg-primary/90 text-white font-bold rounded-xl transition-colors text-sm"
+          >
+            Contact Support
+          </Link>
+        </div>
+      </section>
+    </main>
+  );
+}
+
+function FAQRow({
+  question,
+  answer,
+  badge,
+  isOpen,
+  onToggle,
+}: {
+  question: string;
+  answer: string;
+  badge?: string;
+  isOpen: boolean;
+  onToggle: () => void;
+}) {
+  return (
+    <div className="border-2 border-gray-200 dark:border-gray-700 rounded-xl overflow-hidden hover:border-primary/50 transition-colors">
+      <button
+        type="button"
+        onClick={onToggle}
+        className="w-full flex items-start justify-between gap-3 px-4 py-4 bg-white dark:bg-gray-800 text-left"
+      >
+        <div className="flex-1 min-w-0">
+          {badge && (
+            <span className="inline-block text-xs font-semibold text-primary bg-primary/10 rounded-full px-2 py-0.5 mb-1.5">
+              {badge}
+            </span>
+          )}
+          <p className="text-sm font-semibold text-gray-900 dark:text-white">{question}</p>
+        </div>
+        <ChevronDown
+          className={`w-4 h-4 text-primary flex-shrink-0 mt-0.5 transition-transform duration-200 ${isOpen ? 'rotate-180' : ''}`}
+        />
+      </button>
+      {isOpen && (
+        <div className="px-4 py-4 bg-gray-50 dark:bg-gray-900 border-t border-gray-200 dark:border-gray-700 text-sm text-gray-600 dark:text-gray-300 leading-relaxed">
+          {answer}
+        </div>
+      )}
+    </div>
   );
 }
diff --git a/apps/edr-passenger-web/portal/src/components/Footer.tsx b/apps/edr-passenger-web/portal/src/components/Footer.tsx
index 8d1aa1394..8d4e36a3f 100644
--- a/apps/edr-passenger-web/portal/src/components/Footer.tsx
+++ b/apps/edr-passenger-web/portal/src/components/Footer.tsx
@@ -1,7 +1,6 @@
 'use client';
 
 import { Mail, Phone, MapPin } from 'lucide-react';
-import Link from 'next/link';
 import { useLanguage, getTranslation, Language } from '@/lib/i18n';
 import { useEffect, useState } from 'react';
 
@@ -21,83 +20,27 @@ export function Footer() {
     <footer className="bg-[rgb(20_113_76)] dark:bg-gray-900 text-white py-12">
       <div className="container mx-auto px-4">
         <div className="max-w-6xl mx-auto">
-          <div className="grid grid-cols-1 md:grid-cols-4 gap-8 mb-8">
+          <div className="grid grid-cols-1 md:grid-cols-2 gap-8 mb-8">
             {/* Company Info */}
             <div>
-              <h4 className="font-semibold mb-2">
-                Ethio-Djibouti Railway
-              </h4>
-              <p className="text-sm text-gray-100 my-3">Connecting East Africa with train travel.
-              </p>
+              <h4 className="font-semibold mb-2">Ethio-Djibouti Railway</h4>
+              <p className="text-sm text-gray-100 my-3">Connecting East Africa with train travel.</p>
               <div className="space-y-2 text-sm">
                 <div className="flex items-center gap-2 text-gray-100">
-                  <Phone className="w-4 h-4" />
-                  <a href="tel:9546" className="hover:text-gray-200 transition">
-                    9546
-                  </a>
+                  <Phone className="w-4 h-4 flex-shrink-0" />
+                  <a href="tel:9546" className="hover:text-gray-200 transition">9546</a>
                 </div>
                 <div className="flex items-center gap-2 text-gray-100">
-                  <Mail className="w-4 h-4" />
-                  <a href="mailto:edr_@edrsc.com" className="hover:text-gray-200 transition">
-                    edr_@edrsc.com
-                  </a>
+                  <Mail className="w-4 h-4 flex-shrink-0" />
+                  <a href="mailto:edr_@edrsc.com" className="hover:text-gray-200 transition">edr_@edrsc.com</a>
                 </div>
                 <div className="flex items-center gap-2 text-gray-100">
-                  <MapPin className="w-4 h-4" />
+                  <MapPin className="w-4 h-4 flex-shrink-0" />
                   <span>Furi, Sheger City</span>
                 </div>
               </div>
             </div>
 
-            {/* Quick Links */}
-            <div>
-              <h4 className="font-semibold mb-4">{t('nav.home')}</h4>
-              <ul className="space-y-2 text-sm text-gray-100">
-                <li>
-                  <Link href="/" className="hover:text-gray-200 transition">
-                    {t('nav.home')}
-                  </Link>
-                </li>
-                <li>
-                  <Link href="/services" className="hover:text-gray-200 transition">
-                    {t('nav.services')}
-                  </Link>
-                </li>
-                <li>
-                  <Link href="/about" className="hover:text-gray-200 transition">
-                    {t('nav.about')}
-                  </Link>
-                </li>
-                <li>
-                  <Link href="/contact" className="hover:text-gray-200 transition">
-                    {t('nav.contact')}
-                  </Link>
-                </li>
-              </ul>
-            </div>
-
-            {/* Support */}
-            <div>
-              <h4 className="font-semibold mb-4">{t('footer.support')}</h4>
-              <ul className="space-y-2 text-sm text-gray-100">
-                <li>
-                  <Link href="/help" className="hover:text-gray-200 transition">
-                    {t('nav.help')}
-                  </Link>
-                </li>
-                <li>
-                  <a href="#" className="hover:text-gray-200 transition">
-                    {t('footer.privacy')}
-                  </a>
-                </li>
-                <li>
-                  <a href="#" className="hover:text-gray-200 transition">
-                    {t('footer.terms')}
-                  </a>
-                </li>
-              </ul>
-            </div>
-
             {/* Social Media */}
             <div>
               <h4 className="font-semibold mb-4">{t('footer.follow')}</h4>
@@ -118,21 +61,10 @@ export function Footer() {
             </div>
           </div>
 
-          {/* Divider */}
-          <div className="border-t border-white border-opacity-20 dark:border-gray-700 pt-8">
-            <div className="flex flex-col md:flex-row justify-between items-center text-sm text-gray-100">
-              <p>
-                &copy; 2024 Ethio-Djibouti Railway. {t('footer.rights')}
-              </p>
-              <div className="flex gap-6 mt-4 md:mt-0">
-                <a href="#" className="hover:text-gray-200 transition">
-                  {t('footer.privacy')}
-                </a>
-                <a href="#" className="hover:text-gray-200 transition">
-                  {t('footer.terms')}
-                </a>
-              </div>
-            </div>
+          <div className="border-t border-white border-opacity-20 dark:border-gray-700 pt-6">
+            <p className="text-sm text-gray-100 text-center md:text-left">
+              &copy; {new Date().getFullYear()} Ethio-Djibouti Railway. {t('footer.rights')}
+            </p>
           </div>
         </div>
       </div>
diff --git a/apps/edr-passenger-web/portal/src/components/PackagesSection.tsx b/apps/edr-passenger-web/portal/src/components/PackagesSection.tsx
index 5fb5c0b8a..304671050 100644
--- a/apps/edr-passenger-web/portal/src/components/PackagesSection.tsx
+++ b/apps/edr-passenger-web/portal/src/components/PackagesSection.tsx
@@ -277,15 +277,15 @@ function FeaturedCard({ pkg }: { pkg: HolidayPackage }) {
             </div>
 
             {/* Bottom: price + CTA */}
-            <div className="flex items-end justify-between pt-5 border-t border-gray-100 dark:border-gray-800">
+            <div className="flex flex-col sm:flex-row sm:items-end sm:justify-between gap-3 pt-5 border-t border-gray-100 dark:border-gray-800">
               {price ? (
                 <div>
                   <p className="text-[10px] text-gray-400 uppercase tracking-wider font-medium">
                     Starting from
                   </p>
-                  <p className="text-3xl font-extrabold text-primary leading-none mt-1">
+                  <p className="text-2xl font-extrabold text-primary leading-none mt-1">
                     {price.currency}{" "}
-                    <span className="text-2xl">
+                    <span className="text-xl">
                       {price.amount.toLocaleString(undefined, {
                         minimumFractionDigits: 2,
                         maximumFractionDigits: 2,
@@ -300,7 +300,7 @@ function FeaturedCard({ pkg }: { pkg: HolidayPackage }) {
               ) : (
                 <div />
               )}
-              <span className="inline-flex items-center gap-2 bg-[rgb(20,113,76)] group-hover:bg-[rgb(16,89,60)] text-white text-sm font-bold px-6 py-3.5 rounded-xl shadow-lg group-hover:shadow-xl transition-all duration-200 group-hover:gap-3">
+              <span className="inline-flex items-center justify-center gap-2 bg-[rgb(20,113,76)] group-hover:bg-[rgb(16,89,60)] text-white text-sm font-bold px-5 py-3 rounded-xl shadow-lg group-hover:shadow-xl transition-all duration-200 group-hover:gap-3 w-full sm:w-auto">
                 View Package
                 <ArrowRight className="w-4 h-4" />
               </span>
@@ -384,20 +384,20 @@ function PackageCard({ pkg }: { pkg: HolidayPackage }) {
           </div>
 
           {/* Price + CTA */}
-          <div className="mt-auto pt-3.5 border-t border-gray-100 dark:border-gray-800 flex items-center justify-between">
+          <div className="mt-auto pt-3.5 border-t border-gray-100 dark:border-gray-800 flex items-center justify-between gap-2">
             {price ? (
-              <div>
+              <div className="min-w-0">
                 <p className="text-[10px] text-gray-400 uppercase tracking-wide">
                   From
                 </p>
-                <p className="text-base font-extrabold text-primary">
+                <p className="text-sm font-extrabold text-primary truncate">
                   {fmtPrice(price.amount * 100, price.currency)}
                 </p>
               </div>
             ) : (
               <div />
             )}
-            <span className="text-xs text-primary font-bold flex items-center gap-1 group-hover:gap-2 transition-all">
+            <span className="flex-shrink-0 text-xs text-white bg-primary font-bold flex items-center gap-1 group-hover:gap-2 transition-all px-3 py-2 rounded-lg">
               View <ArrowRight className="w-3.5 h-3.5" />
             </span>
           </div>
diff --git a/apps/edr-passenger-web/portal/src/components/SearchWidget.tsx b/apps/edr-passenger-web/portal/src/components/SearchWidget.tsx
index 36bd545e6..eb8a12f86 100644
--- a/apps/edr-passenger-web/portal/src/components/SearchWidget.tsx
+++ b/apps/edr-passenger-web/portal/src/components/SearchWidget.tsx
@@ -8,8 +8,8 @@ import { useQuery } from '@tanstack/react-query';
 import { apiClient } from '@/lib/api-client';
 import { useBookingStore } from '@/lib/booking-store';
 import { Station } from '@/types';
-import { MapPin, Users, Search, Plus, Minus, ChevronDown } from 'lucide-react';
-import { useState } from 'react';
+import { MapPin, Users, Search, Plus, Minus, ChevronDown, Globe } from 'lucide-react';
+import { useState, useRef, useEffect } from 'react';
 import ModernDatePicker from '@/components/ModernDatePicker';
 
 const searchSchema = z.object({
@@ -36,6 +36,89 @@ interface SearchWidgetProps {
   onSearch?: () => void;
 }
 
+const NATIONALITIES = [
+  { value: 'ETHIOPIAN', label: 'Ethiopian' },
+  { value: 'DJIBOUTIAN', label: 'Djiboutian' },
+  { value: 'OTHER', label: 'Other' },
+] as const;
+
+// Reusable custom dropdown
+function CustomSelect({
+  value,
+  onChange,
+  options,
+  placeholder,
+  icon,
+  error,
+  disabled,
+}: {
+  value: string;
+  onChange: (val: string) => void;
+  options: { value: string; label: string; disabled?: boolean }[];
+  placeholder: string;
+  icon?: React.ReactNode;
+  error?: boolean;
+  disabled?: boolean;
+}) {
+  const [open, setOpen] = useState(false);
+  const ref = useRef<HTMLDivElement>(null);
+  const selected = options.find((o) => o.value === value);
+
+  useEffect(() => {
+    const handler = (e: MouseEvent) => {
+      if (ref.current && !ref.current.contains(e.target as Node)) setOpen(false);
+    };
+    document.addEventListener('mousedown', handler);
+    return () => document.removeEventListener('mousedown', handler);
+  }, []);
+
+  return (
+    <div ref={ref} className="relative">
+      <button
+        type="button"
+        disabled={disabled}
+        onClick={() => !disabled && setOpen((o) => !o)}
+        className={[
+          'w-full pr-10 py-3.5 border rounded-lg focus:outline-none focus:ring-2 focus:ring-primary focus:border-transparent text-base text-left flex items-center gap-2 transition-colors',
+          'bg-white dark:bg-gray-800 text-gray-900 dark:text-white',
+          'disabled:opacity-60 disabled:cursor-not-allowed',
+          icon ? 'pl-11' : 'pl-4',
+          error ? 'border-red-500' : 'border-gray-300 dark:border-gray-600',
+        ].join(' ')}
+      >
+        {icon && <span className="absolute left-3 top-1/2 -translate-y-1/2">{icon}</span>}
+        <span className={selected ? 'text-gray-900 dark:text-white' : 'text-gray-400 dark:text-gray-500'}>
+          {selected ? selected.label : placeholder}
+        </span>
+        <ChevronDown className={`absolute right-3 top-1/2 -translate-y-1/2 w-4 h-4 text-gray-400 dark:text-gray-500 transition-transform ${open ? 'rotate-180' : ''}`} />
+      </button>
+
+      {open && (
+        <>
+          <div className="fixed inset-0 z-40" onClick={() => setOpen(false)} />
+          <div className="absolute top-full left-0 right-0 mt-1 bg-white dark:bg-gray-900 border border-gray-200 dark:border-gray-700 rounded-lg shadow-xl z-50 max-h-80 overflow-y-auto text-gray-900 dark:text-white">
+            {options.map((opt) => (
+              <button
+                key={opt.value}
+                type="button"
+                disabled={opt.disabled}
+                onClick={() => { onChange(opt.value); setOpen(false); }}
+                className={[
+                  'w-full text-left px-4 py-3 text-sm transition-colors',
+                  opt.disabled ? 'opacity-40 cursor-not-allowed' : 'hover:bg-gray-50 dark:hover:bg-gray-800 cursor-pointer',
+                  opt.value === value ? 'text-primary font-semibold bg-primary/5 dark:bg-primary/10' : 'text-gray-900 dark:text-white',
+                ].join(' ')}
+              >
+                {opt.label}
+              </button>
+            ))}
+          </div>
+        </>
+      )}
+    </div>
+  );
+}
+
 export function SearchWidget({ fullWidth = false, onSearch }: SearchWidgetProps) {
   const router = useRouter();
   const setSearchCriteria = useBookingStore((s) => s.setSearchCriteria);
@@ -46,8 +129,8 @@ export function SearchWidget({ fullWidth = false, onSearch }: SearchWidgetProps)
     queryFn: async () => await apiClient.get('/stations') as Station[],
   });
 
-  const { register, handleSubmit, watch, setValue, clearErrors, formState: { errors } } = useForm<SearchForm>({
-    // @ts-ignore - ZodEffects type compatibility issue
+  const { handleSubmit, watch, setValue, clearErrors, formState: { errors } } = useForm<SearchForm>({
+    // @ts-ignore
     resolver: zodResolver(searchSchema),
     mode: 'onSubmit',
     reValidateMode: 'onChange',
@@ -63,16 +146,16 @@ export function SearchWidget({ fullWidth = false, onSearch }: SearchWidgetProps)
   });
 
   const originId = watch('originStationId');
+  const destinationId = watch('destinationStationId');
+  const nationality = watch('nationality');
   const adultCount = watch('adultCount');
   const childCount = watch('childCount');
 
+  const stationOptions = (stations ?? []).map((s) => ({ value: s.id, label: s.name }));
+  const destinationOptions = stationOptions.map((s) => ({ ...s, disabled: s.value === originId }));
+
   const onSubmit = (data: SearchForm) => {
-    setSearchCriteria({
-      ...data,
-      adultCount: data.adultCount,
-      childCount: data.childCount,
-      nationality: data.nationality,
-    });
+    setSearchCriteria({ ...data });
     const params = new URLSearchParams({
       origin: data.originStationId,
       destination: data.destinationStationId,
@@ -89,172 +172,113 @@ export function SearchWidget({ fullWidth = false, onSearch }: SearchWidgetProps)
     <div className={fullWidth ? 'w-full' : 'w-full max-w-6xl mx-auto'}>
       <form onSubmit={handleSubmit(onSubmit)} className="bg-white/95 dark:bg-gray-800/95 rounded-2xl shadow-lg border border-gray-200/20 dark:border-gray-700/20 overflow-visible backdrop-blur-sm">
         <div className="p-6 md:p-8 overflow-visible">
+
           {/* Row 1: From, To, Date */}
           <div className="grid grid-cols-1 md:grid-cols-3 gap-4 items-end mb-4">
             {/* From */}
-            <div className="space-y-2 md:col-span-1">
-              <label className="block text-sm font-medium text-gray-700 dark:text-gray-300 text-left">From</label>
-              <div className="relative">
-                <MapPin className="absolute left-3 top-1/2 -translate-y-1/2 w-5 h-5 text-primary" />
-                <select
-                  {...register('originStationId', {
-                    onChange: (e) => {
-                      if (e.target.value) clearErrors('originStationId');
-                    }
-                  })}
-                  className={`w-full pl-11 pr-4 py-3.5 border rounded-lg focus:outline-none focus:ring-2 focus:ring-primary focus:border-transparent disabled:bg-gray-50 dark:disabled:bg-gray-800 disabled:cursor-not-allowed text-base bg-white dark:bg-gray-700 text-gray-900 dark:text-gray-100 ${
-                    errors.originStationId ? 'border-red-500 dark:border-red-500' : 'border-gray-300 dark:border-gray-600'
-                  }`}
-                  disabled={isLoading}
-                >
-                  <option value="">Select departure</option>
-                  {stations?.map((s) => (
-                    <option key={s.id} value={s.id}>{s.name}</option>
-                  ))}
-                </select>
-              </div>
+            <div className="space-y-2">
+              <label className="block text-sm font-medium text-gray-700 dark:text-gray-300">From</label>
+              <CustomSelect
+                value={originId}
+                onChange={(val) => { setValue('originStationId', val); clearErrors('originStationId'); }}
+                options={stationOptions}
+                placeholder="Select departure"
+                icon={<MapPin className="w-5 h-5 text-primary" />}
+                error={!!errors.originStationId}
+                disabled={isLoading}
+              />
               {errors.originStationId && (
-                <p className="text-red-600 dark:text-red-400 text-sm mt-1">{errors.originStationId.message}</p>
+                <p className="text-red-600 dark:text-red-400 text-sm">{errors.originStationId.message}</p>
               )}
             </div>
 
             {/* To */}
-            <div className="space-y-2 md:col-span-1">
-              <label className="block text-sm font-medium text-gray-700 dark:text-gray-300 text-left">To</label>
-              <div className="relative">
-                <MapPin className="absolute left-3 top-1/2 -translate-y-1/2 w-5 h-5 text-primary" />
-                <select
-                  {...register('destinationStationId', {
-                    onChange: (e) => {
-                      if (e.target.value) clearErrors('destinationStationId');
-                    }
-                  })}
-                  className={`w-full pl-11 pr-4 py-3.5 border rounded-lg focus:outline-none focus:ring-2 focus:ring-primary focus:border-transparent disabled:bg-gray-50 dark:disabled:bg-gray-800 disabled:cursor-not-allowed text-base bg-white dark:bg-gray-700 text-gray-900 dark:text-gray-100 ${
-                    errors.destinationStationId ? 'border-red-500 dark:border-red-500' : 'border-gray-300 dark:border-gray-600'
-                  }`}
-                  disabled={isLoading}
-                >
-                  <option value="">Select arrival</option>
-                  {stations?.map((s) => (
-                    <option key={s.id} value={s.id} disabled={s.id === originId}>{s.name}</option>
-                  ))}
-                </select>
-              </div>
+            <div className="space-y-2">
+              <label className="block text-sm font-medium text-gray-700 dark:text-gray-300">To</label>
+              <CustomSelect
+                value={destinationId}
+                onChange={(val) => { setValue('destinationStationId', val); clearErrors('destinationStationId'); }}
+                options={destinationOptions}
+                placeholder="Select arrival"
+                icon={<MapPin className="w-5 h-5 text-primary" />}
+                error={!!errors.destinationStationId}
+                disabled={isLoading}
+              />
               {errors.destinationStationId && (
-                <p className="text-red-600 dark:text-red-400 text-sm mt-1">{errors.destinationStationId.message}</p>
+                <p className="text-red-600 dark:text-red-400 text-sm">{errors.destinationStationId.message}</p>
               )}
             </div>
 
             {/* Date */}
-            <div className="space-y-2 md:col-span-1">
-              <label className="block text-sm font-medium text-gray-700 dark:text-gray-300 text-left">Date</label>
+            <div className="space-y-2">
+              <label className="block text-sm font-medium text-gray-700 dark:text-gray-300">Date</label>
               <ModernDatePicker
                 value={watch('departureDate') ? new Date(watch('departureDate') + 'T00:00:00') : undefined}
                 onChange={(date) => {
-                  const year = date.getFullYear();
-                  const month = String(date.getMonth() + 1).padStart(2, '0');
-                  const day = String(date.getDate()).padStart(2, '0');
-                  setValue('departureDate', `${year}-${month}-${day}`);
+                  const y = date.getFullYear();
+                  const m = String(date.getMonth() + 1).padStart(2, '0');
+                  const d = String(date.getDate()).padStart(2, '0');
+                  setValue('departureDate', `${y}-${m}-${d}`);
                   clearErrors('departureDate');
                 }}
                 minDate={new Date()}
                 placeholder="Select date"
               />
               {errors.departureDate && (
-                <p className="text-red-600 dark:text-red-400 text-sm mt-1">{errors.departureDate.message}</p>
+                <p className="text-red-600 dark:text-red-400 text-sm">{errors.departureDate.message}</p>
               )}
             </div>
           </div>
 
           {/* Row 2: Passengers, Nationality, Promo Code */}
           <div className="grid grid-cols-1 md:grid-cols-3 gap-4 items-end mb-4">
-            {/* Passengers Dropdown */}
+            {/* Passengers */}
             <div className="space-y-2 relative z-20">
-              <label className="block text-sm font-medium text-gray-700 dark:text-gray-300 text-left">Passengers</label>
+              <label className="block text-sm font-medium text-gray-700 dark:text-gray-300">Passengers</label>
               <button
                 type="button"
                 onClick={() => setIsPassengerOpen(!isPassengerOpen)}
-                className="w-full px-4 py-3.5 border border-gray-300 dark:border-gray-600 rounded-lg focus:outline-none focus:ring-2 focus:ring-primary focus:border-transparent text-base bg-white dark:bg-gray-700 text-gray-900 dark:text-gray-100 flex items-center justify-between hover:border-primary transition-colors"
+                className="w-full px-4 py-3.5 border border-gray-300 dark:border-gray-600 rounded-lg focus:outline-none focus:ring-2 focus:ring-primary text-base bg-white dark:bg-gray-800 text-gray-900 dark:text-white flex items-center justify-between hover:border-primary transition-colors dark:[color-scheme:dark]"
               >
                 <span className="flex items-center gap-2">
                   <Users className="w-4 h-4 text-primary" />
                   {(adultCount || 1) + (childCount || 0)} Passenger{((adultCount || 1) + (childCount || 0)) !== 1 ? 's' : ''}
                 </span>
-                <ChevronDown className={`w-4 h-4 transition-transform text-primary ${isPassengerOpen ? 'rotate-180' : ''}`} />
+                <ChevronDown className={`w-4 h-4 text-gray-400 transition-transform ${isPassengerOpen ? 'rotate-180' : ''}`} />
               </button>
 
-              {/* Passenger Dropdown Menu */}
               {isPassengerOpen && (
                 <>
                   <div className="fixed inset-0 z-40" onClick={() => setIsPassengerOpen(false)} />
-                  <div className="absolute top-full left-0 right-0 mt-2 bg-white dark:bg-gray-800 border border-gray-300 dark:border-gray-600 rounded-lg shadow-lg z-50 p-4 space-y-4">
-                    {/* Adults */}
-                    <div>
-                      <div className="flex items-center justify-between mb-2">
-                        <div>
-                          <div className="text-sm font-medium text-gray-900 dark:text-gray-100">Adults</div>
-                          <div className="text-xs text-gray-500 dark:text-gray-400">≥5 years</div>
-                        </div>
-                        <div className="flex items-center gap-2">
-                          <button
-                            type="button"
-                            onClick={() => {
-                              const current = adultCount || 1;
-                              if (current > 1) setValue('adultCount', current - 1);
-                            }}
-                            className="w-7 h-7 rounded-full border border-gray-300 dark:border-gray-600 flex items-center justify-center hover:bg-gray-100 dark:hover:bg-gray-700 disabled:opacity-50"
-                            disabled={(adultCount || 1) <= 1}
-                          >
-                            <Minus className="w-4 h-4 text-primary" />
-                          </button>
-                          <span className="w-6 text-center font-semibold text-gray-900 dark:text-gray-100">{adultCount || 1}</span>
-                          <button
-                            type="button"
-                            onClick={() => {
-                              const current = adultCount || 1;
-                              if (current < 9) setValue('adultCount', current + 1);
-                            }}
-                            className="w-7 h-7 rounded-full border border-gray-300 dark:border-gray-600 flex items-center justify-center hover:bg-gray-100 dark:hover:bg-gray-700 disabled:opacity-50"
-                            disabled={(adultCount || 1) >= 9}
-                          >
-                            <Plus className="w-4 h-4 text-primary" />
-                          </button>
-                        </div>
+                  <div className="absolute top-full left-0 right-0 mt-1 bg-white dark:bg-gray-900 border border-gray-200 dark:border-gray-700 rounded-lg shadow-xl z-50 p-4 space-y-4 text-gray-900 dark:text-white">
+                    <div className="flex items-center justify-between">
+                      <div>
+                        <div className="text-sm font-medium text-gray-900 dark:text-white">Adults</div>
+                        <div className="text-xs text-gray-500 dark:text-gray-400">≥5 years</div>
+                      </div>
+                      <div className="flex items-center gap-3">
+                        <button type="button" onClick={() => { const c = adultCount || 1; if (c > 1) setValue('adultCount', c - 1); }} disabled={(adultCount || 1) <= 1} className="w-7 h-7 rounded-full border border-gray-300 dark:border-gray-600 flex items-center justify-center hover:bg-gray-100 dark:hover:bg-gray-700 disabled:opacity-40">
+                          <Minus className="w-3.5 h-3.5 text-primary" />
+                        </button>
+                        <span className="w-5 text-center font-semibold text-gray-900 dark:text-white">{adultCount || 1}</span>
+                        <button type="button" onClick={() => { const c = adultCount || 1; if (c < 9) setValue('adultCount', c + 1); }} disabled={(adultCount || 1) >= 9} className="w-7 h-7 rounded-full border border-gray-300 dark:border-gray-600 flex items-center justify-center hover:bg-gray-100 dark:hover:bg-gray-700 disabled:opacity-40">
+                          <Plus className="w-3.5 h-3.5 text-primary" />
+                        </button>
                       </div>
                     </div>
-
-                    {/* Children */}
-                    <div className="border-t border-gray-200 dark:border-gray-700 pt-4">
-                      <div className="flex items-center justify-between">
-                        <div>
-                          <div className="text-sm font-medium text-gray-900 dark:text-gray-100">Children</div>
-                          <div className="text-xs text-gray-500 dark:text-gray-400">&lt;5 years • First free</div>
-                        </div>
-                        <div className="flex items-center gap-2">
-                          <button
-                            type="button"
-                            onClick={() => {
-                              const current = childCount || 0;
-                              if (current > 0) setValue('childCount', current - 1);
-                            }}
-                            className="w-7 h-7 rounded-full border border-gray-300 dark:border-gray-600 flex items-center justify-center hover:bg-gray-100 dark:hover:bg-gray-700 disabled:opacity-50"
-                            disabled={(childCount || 0) <= 0}
-                          >
-                            <Minus className="w-4 h-4 text-primary" />
-                          </button>
-                          <span className="w-6 text-center font-semibold text-gray-900 dark:text-gray-100">{childCount || 0}</span>
-                          <button
-                            type="button"
-                            onClick={() => {
-                              const current = childCount || 0;
-                              if (current < 9) setValue('childCount', current + 1);
-                            }}
-                            className="w-7 h-7 rounded-full border border-gray-300 dark:border-gray-600 flex items-center justify-center hover:bg-gray-100 dark:hover:bg-gray-700 disabled:opacity-50"
-                            disabled={(childCount || 0) >= 9}
-                          >
-                            <Plus className="w-4 h-4 text-primary" />
-                          </button>
-                        </div>
+                    <div className="border-t border-gray-100 dark:border-gray-700 pt-4 flex items-center justify-between">
+                      <div>
+                        <div className="text-sm font-medium text-gray-900 dark:text-white">Children</div>
+                        <div className="text-xs text-gray-500 dark:text-gray-400">&lt;5 years · First free</div>
+                      </div>
+                      <div className="flex items-center gap-3">
+                        <button type="button" onClick={() => { const c = childCount || 0; if (c > 0) setValue('childCount', c - 1); }} disabled={(childCount || 0) <= 0} className="w-7 h-7 rounded-full border border-gray-300 dark:border-gray-600 flex items-center justify-center hover:bg-gray-100 dark:hover:bg-gray-700 disabled:opacity-40">
+                          <Minus className="w-3.5 h-3.5 text-primary" />
+                        </button>
+                        <span className="w-5 text-center font-semibold text-gray-900 dark:text-white">{childCount || 0}</span>
+                        <button type="button" onClick={() => { const c = childCount || 0; if (c < 9) setValue('childCount', c + 1); }} disabled={(childCount || 0) >= 9} className="w-7 h-7 rounded-full border border-gray-300 dark:border-gray-600 flex items-center justify-center hover:bg-gray-100 dark:hover:bg-gray-700 disabled:opacity-40">
+                          <Plus className="w-3.5 h-3.5 text-primary" />
+                        </button>
                       </div>
                     </div>
                   </div>
@@ -264,49 +288,35 @@ export function SearchWidget({ fullWidth = false, onSearch }: SearchWidgetProps)
 
             {/* Nationality */}
             <div className="space-y-2">
-              <label className="block text-sm font-medium text-gray-700 dark:text-gray-300 text-left">Nationality</label>
-              <select
-                {...register('nationality')}
-                className="w-full px-4 py-3.5 border border-gray-300 dark:border-gray-600 rounded-lg focus:outline-none focus:ring-2 focus:ring-primary focus:border-transparent text-base bg-white dark:bg-gray-700 text-gray-900 dark:text-gray-100"
-              >
-                <option value="ETHIOPIAN">Ethiopian</option>
-                <option value="DJIBOUTIAN">Djiboutian</option>
-                <option value="OTHER">Other</option>
-              </select>
+              <label className="block text-sm font-medium text-gray-700 dark:text-gray-300">Nationality</label>
+              <CustomSelect
+                value={nationality}
+                onChange={(val) => setValue('nationality', val as SearchForm['nationality'])}
+                options={NATIONALITIES.map((n) => ({ value: n.value, label: n.label }))}
+                placeholder="Select nationality"
+                icon={<Globe className="w-5 h-5 text-primary" />}
+              />
             </div>
 
             {/* Promo Code */}
             <div className="space-y-2">
-              <label className="block text-sm font-medium text-gray-700 dark:text-gray-300 text-left">Promo Code (Optional)</label>
+              <label className="block text-sm font-medium text-gray-700 dark:text-gray-300">Promo Code (Optional)</label>
               <input
                 type="text"
                 placeholder="Enter promo code"
-                className="w-full px-4 py-3.5 border border-gray-300 dark:border-gray-600 rounded-lg focus:outline-none focus:ring-2 focus:ring-primary focus:border-transparent text-base bg-white dark:bg-gray-700 text-gray-900 dark:text-gray-100 placeholder-gray-500 dark:placeholder-gray-400"
+                className="w-full px-4 py-3.5 border border-gray-300 dark:border-gray-600 rounded-lg focus:outline-none focus:ring-2 focus:ring-primary text-base bg-white dark:bg-gray-800 text-gray-900 dark:text-white placeholder-gray-400 dark:placeholder-gray-500"
               />
             </div>
           </div>
 
-          {/* Row 3: Search Button */}
-          <div>
-            {/* Debug info - remove after testing */}
-            {Object.keys(errors).length > 0 && (
-              <div className="mb-3 p-3 bg-red-50 dark:bg-red-900/20 border border-red-200 dark:border-red-800 rounded-lg">
-                <p className="text-sm font-medium text-red-800 dark:text-red-200 mb-1">Validation Errors:</p>
-                <ul className="text-xs text-red-700 dark:text-red-300 list-disc list-inside">
-                  {Object.entries(errors).map(([key, value]) => (
-                    <li key={key}>{key}: {value?.message}</li>
-                  ))}
-                </ul>
-              </div>
-            )}
-            <button
-              type="submit"
-              className="w-full bg-primary hover:bg-primary/90 text-white font-semibold py-3.5 px-6 rounded-lg transition-all duration-200 flex items-center justify-center gap-2 shadow-lg hover:shadow-xl"
-            >
-              <Search className="w-5 h-5 text-white" />
-              <span>Search Train</span>
-            </button>
-          </div>
+          {/* Search Button */}
+          <button
+            type="submit"
+            className="w-full bg-primary hover:bg-primary/90 text-white font-semibold py-3.5 px-6 rounded-lg transition-all duration-200 flex items-center justify-center gap-2 shadow-lg hover:shadow-xl"
+          >
+            <Search className="w-5 h-5" />
+            <span>Search Train</span>
+          </button>
         </div>
       </form>
     </div>
diff --git a/apps/edr-passenger-web/portal/src/features/support/SupportPanel.tsx b/apps/edr-passenger-web/portal/src/features/support/SupportPanel.tsx
index b7d4ad81b..24b6b82fd 100644
--- a/apps/edr-passenger-web/portal/src/features/support/SupportPanel.tsx
+++ b/apps/edr-passenger-web/portal/src/features/support/SupportPanel.tsx
@@ -1,27 +1,14 @@
 'use client';
 
 import { Passenger } from '@edr/types';
-import { ArrowLeft, Headset, Plus, Send, X } from 'lucide-react';
-import { useEffect, useMemo, useRef, useState } from 'react';
+import { Headset, Send, X } from 'lucide-react';
+import { useEffect, useRef, useState } from 'react';
 
-import {
-  useConversations,
-  useCreateConversation,
-  useMarkRead,
-  useMessages,
-  useSendMessage,
-} from './useSupport';
+import { useMarkRead, useSendMessage, useThread } from './useSupport';
 
 const GREEN = 'rgb(20 113 76)';
-type ConversationDto = Passenger.PassengerSupportConversationDto;
 type MessageDto = Passenger.PassengerSupportMessageDto;
 
-const STATUS_CLASS: Record<string, string> = {
-  OPEN: 'bg-emerald-100 text-emerald-700 dark:bg-emerald-900/40 dark:text-emerald-300',
-  RESOLVED: 'bg-blue-100 text-blue-700 dark:bg-blue-900/40 dark:text-blue-300',
-  CLOSED: 'bg-gray-200 text-gray-600 dark:bg-slate-700 dark:text-slate-300',
-};
-
 function formatTime(iso?: string | null): string {
   if (!iso) return '';
   const d = new Date(iso);
@@ -31,330 +18,24 @@ function formatTime(iso?: string | null): string {
     : d.toLocaleDateString([], { month: 'short', day: 'numeric' });
 }
 
-type View = { kind: 'list' } | { kind: 'new' } | { kind: 'thread'; id: string };
-
-export function SupportPanel({
-  onClose,
-  isGuest = false,
-}: {
-  onClose: () => void;
-  isGuest?: boolean;
-}) {
-  const [view, setView] = useState<View>({ kind: 'list' });
-
-  return (
-    <div className="flex h-[560px] max-h-[calc(100vh-120px)] w-[min(384px,calc(100vw-32px))] flex-col overflow-hidden rounded-2xl border border-gray-200 bg-white shadow-2xl dark:border-slate-700 dark:bg-slate-900">
-      {view.kind === 'list' && (
-        <ConversationList
-          onClose={onClose}
-          onNew={() => setView({ kind: 'new' })}
-          onOpen={(id) => setView({ kind: 'thread', id })}
-        />
-      )}
-      {view.kind === 'new' && (
-        <NewConversation
-          isGuest={isGuest}
-          onClose={onClose}
-          onBack={() => setView({ kind: 'list' })}
-          onCreated={(id) => setView({ kind: 'thread', id })}
-        />
-      )}
-      {view.kind === 'thread' && (
-        <Thread
-          conversationId={view.id}
-          onClose={onClose}
-          onBack={() => setView({ kind: 'list' })}
-        />
-      )}
-    </div>
-  );
-}
-
-function Header({
-  title,
-  subtitle,
-  onClose,
-  onBack,
-}: {
-  title: string;
-  subtitle?: string;
-  onClose: () => void;
-  onBack?: () => void;
-}) {
-  return (
-    <div
-      className="flex items-center justify-between gap-2 px-4 py-3 text-white"
-      style={{
-        background: `linear-gradient(135deg, ${GREEN}, rgb(30 140 96))`,
-      }}
-    >
-      <div className="flex min-w-0 items-center gap-2">
-        {onBack ? (
-          <button
-            onClick={onBack}
-            className="rounded-full p-1 hover:bg-white/20"
-            aria-label="Back"
-          >
-            <ArrowLeft size={20} />
-          </button>
-        ) : (
-          <span className="flex h-8 w-8 items-center justify-center rounded-full bg-white/20">
-            <Headset size={18} />
-          </span>
-        )}
-        <div className="min-w-0">
-          <p className="truncate text-sm font-semibold">{title}</p>
-          {subtitle && (
-            <p className="truncate text-xs text-white/80">{subtitle}</p>
-          )}
-        </div>
-      </div>
-      <button
-        onClick={onClose}
-        className="rounded-full p-1 hover:bg-white/20"
-        aria-label="Close"
-      >
-        <X size={20} />
-      </button>
-    </div>
-  );
-}
-
-function ConversationList({
-  onClose,
-  onNew,
-  onOpen,
-}: {
-  onClose: () => void;
-  onNew: () => void;
-  onOpen: (id: string) => void;
-}) {
-  const { data, isLoading } = useConversations();
-  const items = data?.items ?? [];
-
-  return (
-    <>
-      <Header
-        title="Support"
-        subtitle="We usually reply within a few minutes"
-        onClose={onClose}
-      />
-      <div className="flex-1 overflow-y-auto">
-        {isLoading ? (
-          <div className="p-8 text-center text-sm text-gray-400">Loading…</div>
-        ) : items.length === 0 ? (
-          <div className="flex flex-col items-center gap-2 px-6 py-12 text-center text-sm text-gray-500 dark:text-slate-400">
-            <span
-              className="flex h-12 w-12 items-center justify-center rounded-full"
-              style={{ background: 'rgba(20,113,76,0.1)', color: GREEN }}
-            >
-              <Headset size={24} />
-            </span>
-            No conversations yet. Start one and our team will help you out.
-          </div>
-        ) : (
-          items.map((c) => (
-            <ConversationRow key={c.id} c={c} onClick={() => onOpen(c.id)} />
-          ))
-        )}
-      </div>
-      <div className="border-t border-gray-100 p-3 dark:border-slate-700">
-        <button
-          onClick={onNew}
-          className="flex w-full items-center justify-center gap-2 rounded-lg py-2.5 text-sm font-semibold text-white transition hover:opacity-90"
-          style={{ background: GREEN }}
-        >
-          <Plus size={16} /> New request
-        </button>
-      </div>
-    </>
-  );
-}
-
-function ConversationRow({
-  c,
-  onClick,
-}: {
-  c: ConversationDto;
-  onClick: () => void;
-}) {
-  const unread = c.unreadCount > 0;
-  return (
-    <button
-      onClick={onClick}
-      className={`block w-full border-b border-gray-100 px-4 py-3 text-left transition hover:bg-gray-50 dark:border-slate-800 dark:hover:bg-slate-800/60 ${
-        unread ? 'bg-emerald-50/60 dark:bg-emerald-900/10' : ''
-      }`}
-    >
-      <div className="flex items-center justify-between gap-2">
-        <span
-          className={`truncate text-sm ${
-            unread
-              ? 'font-bold text-gray-900 dark:text-white'
-              : 'font-semibold text-gray-800 dark:text-slate-200'
-          }`}
-        >
-          {c.subject || 'Support request'}
-        </span>
-        <span className="shrink-0 text-xs text-gray-400">
-          {formatTime(c.lastMessageAt)}
-        </span>
-      </div>
-      <div className="mt-1 flex items-center justify-between gap-2">
-        <span className="truncate text-xs text-gray-500 dark:text-slate-400">
-          {c.lastMessageSender === 'AGENT' ? 'Support: ' : ''}
-          {c.lastMessagePreview ?? '—'}
-        </span>
-        {unread ? (
-          <span
-            className="flex h-5 min-w-5 items-center justify-center rounded-full px-1.5 text-xs font-semibold text-white"
-            style={{ background: GREEN }}
-          >
-            {c.unreadCount}
-          </span>
-        ) : (
-          <span
-            className={`rounded-full px-2 py-0.5 text-[10px] font-medium capitalize ${
-              STATUS_CLASS[c.status] ?? ''
-            }`}
-          >
-            {c.status.toLowerCase()}
-          </span>
-        )}
-      </div>
-    </button>
-  );
-}
-
-function NewConversation({
-  isGuest,
-  onClose,
-  onBack,
-  onCreated,
-}: {
-  isGuest: boolean;
-  onClose: () => void;
-  onBack: () => void;
-  onCreated: (id: string) => void;
-}) {
-  const [name, setName] = useState('');
-  const [email, setEmail] = useState('');
-  const [subject, setSubject] = useState('');
-  const [message, setMessage] = useState('');
-  const create = useCreateConversation();
-
-  const guestValid =
-    !isGuest || (name.trim().length > 0 && /.+@.+\..+/.test(email.trim()));
-  const valid =
-    subject.trim().length >= 3 && message.trim().length > 0 && guestValid;
-
-  const submit = async () => {
-    if (!valid) return;
-    const conv = await create.mutateAsync({
-      subject: subject.trim(),
-      initialMessage: message.trim(),
-      ...(isGuest ? { name: name.trim(), email: email.trim() } : {}),
-    });
-    onCreated(conv.id);
-  };
-
-  const inputClass =
-    'w-full rounded-lg border border-gray-300 px-3 py-2 text-sm outline-none focus:border-emerald-500 dark:border-slate-600 dark:bg-slate-800 dark:text-white';
-
-  return (
-    <>
-      <Header title="New request" onClose={onClose} onBack={onBack} />
-      <div className="flex flex-1 flex-col gap-4 overflow-y-auto p-4">
-        {isGuest && (
-          <>
-            <div>
-              <label className="mb-1 block text-xs font-medium text-gray-600 dark:text-slate-300">
-                Your name
-              </label>
-              <input
-                value={name}
-                onChange={(e) => setName(e.target.value)}
-                placeholder="Full name"
-                className={inputClass}
-              />
-            </div>
-            <div>
-              <label className="mb-1 block text-xs font-medium text-gray-600 dark:text-slate-300">
-                Email
-              </label>
-              <input
-                type="email"
-                value={email}
-                onChange={(e) => setEmail(e.target.value)}
-                placeholder="you@example.com"
-                className={inputClass}
-              />
-            </div>
-          </>
-        )}
-        <div>
-          <label className="mb-1 block text-xs font-medium text-gray-600 dark:text-slate-300">
-            Subject
-          </label>
-          <input
-            value={subject}
-            onChange={(e) => setSubject(e.target.value)}
-            placeholder="e.g. Refund for booking EDR-1234"
-            className={inputClass}
-          />
-        </div>
-        <div className="flex flex-1 flex-col">
-          <label className="mb-1 block text-xs font-medium text-gray-600 dark:text-slate-300">
-            How can we help?
-          </label>
-          <textarea
-            value={message}
-            onChange={(e) => setMessage(e.target.value)}
-            placeholder="Describe your issue…"
-            className="min-h-[120px] flex-1 resize-none rounded-lg border border-gray-300 px-3 py-2 text-sm outline-none focus:border-emerald-500 dark:border-slate-600 dark:bg-slate-800 dark:text-white"
-          />
-        </div>
-        <button
-          onClick={submit}
-          disabled={!valid || create.isPending}
-          className="flex items-center justify-center gap-2 rounded-lg py-2.5 text-sm font-semibold text-white transition hover:opacity-90 disabled:opacity-50"
-          style={{ background: GREEN }}
-        >
-          <Send size={16} /> {create.isPending ? 'Sending…' : 'Send request'}
-        </button>
-      </div>
-    </>
-  );
-}
-
-function Thread({
-  conversationId,
-  onClose,
-  onBack,
-}: {
-  conversationId: string;
-  onClose: () => void;
-  onBack: () => void;
-}) {
-  const { data: conversations } = useConversations();
-  const conversation = useMemo(
-    () => conversations?.items.find((c) => c.id === conversationId),
-    [conversations, conversationId],
-  );
-  const { data: messages, isLoading } = useMessages(conversationId);
-  const send = useSendMessage(conversationId);
+export function SupportPanel({ onClose }: { onClose: () => void }) {
+  const { data, isLoading } = useThread();
+  const send = useSendMessage();
   const markRead = useMarkRead();
   const [draft, setDraft] = useState('');
   const viewport = useRef<HTMLDivElement>(null);
 
+  const messages = data?.messages ?? [];
+
+  // Mark read on open + whenever new messages arrive.
   useEffect(() => {
-    if (conversationId) markRead.mutate(conversationId);
+    markRead.mutate();
     // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [conversationId, messages?.length]);
+  }, [messages.length]);
 
   useEffect(() => {
     viewport.current?.scrollTo({ top: viewport.current.scrollHeight });
-  }, [messages?.length]);
+  }, [messages.length]);
 
   const submit = async () => {
     const text = draft.trim();
@@ -364,22 +45,51 @@ function Thread({
   };
 
   return (
-    <>
-      <Header
-        title={conversation?.subject || 'Conversation'}
-        subtitle={
-          conversation ? `Status: ${conversation.status.toLowerCase()}` : undefined
-        }
-        onClose={onClose}
-        onBack={onBack}
-      />
+    <div className="flex h-[560px] max-h-[calc(100vh-120px)] w-[min(384px,calc(100vw-32px))] flex-col overflow-hidden rounded-2xl border border-gray-200 bg-white shadow-2xl dark:border-slate-700 dark:bg-slate-900">
+      {/* Header */}
+      <div
+        className="flex items-center justify-between gap-2 px-4 py-3 text-white"
+        style={{ background: `linear-gradient(135deg, ${GREEN}, rgb(30 140 96))` }}
+      >
+        <div className="flex items-center gap-2">
+          <span className="flex h-8 w-8 items-center justify-center rounded-full bg-white/20">
+            <Headset size={18} />
+          </span>
+          <div>
+            <p className="text-sm font-semibold">Support</p>
+            <p className="text-xs text-white/80">We usually reply in a few minutes</p>
+          </div>
+        </div>
+        <button
+          onClick={onClose}
+          className="rounded-full p-1 hover:bg-white/20"
+          aria-label="Close"
+        >
+          <X size={20} />
+        </button>
+      </div>
+
+      {/* Messages */}
       <div ref={viewport} className="flex-1 space-y-3 overflow-y-auto p-4">
         {isLoading ? (
           <div className="p-8 text-center text-sm text-gray-400">Loading…</div>
+        ) : messages.length === 0 ? (
+          <div className="flex flex-col items-center gap-2 px-6 py-10 text-center text-sm text-gray-500 dark:text-slate-400">
+            <span
+              className="flex h-12 w-12 items-center justify-center rounded-full"
+              style={{ background: 'rgba(20,113,76,0.1)', color: GREEN }}
+            >
+              <Headset size={24} />
+            </span>
+            Hi! 👋 How can we help you today? Send us a message and our team will
+            get back to you.
+          </div>
         ) : (
-          (messages ?? []).map((m) => <MessageBubble key={m.id} m={m} />)
+          messages.map((m) => <MessageBubble key={m.id} m={m} />)
         )}
       </div>
+
+      {/* Composer */}
       <div className="border-t border-gray-100 p-3 dark:border-slate-700">
         <div className="flex items-end gap-2">
           <textarea
@@ -406,7 +116,7 @@ function Thread({
           </button>
         </div>
       </div>
-    </>
+    </div>
   );
 }
 
diff --git a/apps/edr-passenger-web/portal/src/features/support/SupportWidget.tsx b/apps/edr-passenger-web/portal/src/features/support/SupportWidget.tsx
index a822c3d7d..2b46a97b6 100644
--- a/apps/edr-passenger-web/portal/src/features/support/SupportWidget.tsx
+++ b/apps/edr-passenger-web/portal/src/features/support/SupportWidget.tsx
@@ -3,8 +3,6 @@
 import { Headset, MessageCircle } from 'lucide-react';
 import { useState } from 'react';
 
-import { useAuthStore } from '@/lib/auth-store';
-
 import { SupportPanel } from './SupportPanel';
 import { useUnreadCount } from './useSupport';
 import { useSupportSocket } from './useSupportSocket';
@@ -12,23 +10,20 @@ import { useSupportSocket } from './useSupportSocket';
 const GREEN = 'rgb(20 113 76)';
 
 /**
- * Floating passenger-support launcher, mounted in the app shell for everyone —
- * authenticated passengers and guests (guests are scoped by a localStorage
- * guestId). Live pushes keep the unread badge fresh.
+ * Floating support launcher for the portal. One device-scoped thread — opens
+ * straight into the conversation, no login or form. Live pushes keep the badge
+ * fresh via a `guest:<deviceId>` socket room.
  */
 export function SupportWidget() {
-  const { isAuthenticated } = useAuthStore();
   const [open, setOpen] = useState(false);
   const { data } = useUnreadCount(true);
   const unread = data?.unreadCount ?? 0;
 
-  // Authenticated users keep a live socket for background pushes; guests connect
-  // once they open the panel (avoids idle sockets for visitors who never chat).
-  useSupportSocket(isAuthenticated || open);
+  useSupportSocket(true);
 
   return (
     <div className="fixed bottom-6 right-6 z-[100] flex flex-col items-end gap-3">
-      {open && <SupportPanel onClose={() => setOpen(false)} isGuest={!isAuthenticated} />}
+      {open && <SupportPanel onClose={() => setOpen(false)} />}
       {!open && (
         <button
           onClick={() => setOpen(true)}
diff --git a/apps/edr-passenger-web/portal/src/features/support/deviceIdentity.ts b/apps/edr-passenger-web/portal/src/features/support/deviceIdentity.ts
new file mode 100644
index 000000000..315bd2b6b
--- /dev/null
+++ b/apps/edr-passenger-web/portal/src/features/support/deviceIdentity.ts
@@ -0,0 +1,21 @@
+'use client';
+
+const DEVICE_KEY = 'support_device_id';
+
+/**
+ * Stable per-device id for the portal's single support thread. Persisted in
+ * localStorage — no login or form required; the visitor is dropped straight
+ * into their one ongoing conversation.
+ */
+export function getDeviceId(): string {
+  if (typeof window === 'undefined') return '';
+  let id = localStorage.getItem(DEVICE_KEY);
+  if (!id) {
+    id =
+      typeof crypto !== 'undefined' && 'randomUUID' in crypto
+        ? crypto.randomUUID()
+        : `device-${Date.now()}-${Math.floor(Math.random() * 1e9)}`;
+    localStorage.setItem(DEVICE_KEY, id);
+  }
+  return id;
+}
diff --git a/apps/edr-passenger-web/portal/src/features/support/guestIdentity.ts b/apps/edr-passenger-web/portal/src/features/support/guestIdentity.ts
deleted file mode 100644
index fe41b59be..000000000
--- a/apps/edr-passenger-web/portal/src/features/support/guestIdentity.ts
+++ /dev/null
@@ -1,24 +0,0 @@
-'use client';
-
-const GUEST_KEY = 'support_guest_id';
-
-/** True when a real passenger auth token is present. */
-export function isAuthed(): boolean {
-  if (typeof window === 'undefined') return false;
-  const t = localStorage.getItem('auth_token');
-  return !!t && t !== 'null' && t !== 'undefined';
-}
-
-/** Stable anonymous id for guest conversations (persisted in localStorage). */
-export function getGuestId(): string {
-  if (typeof window === 'undefined') return '';
-  let id = localStorage.getItem(GUEST_KEY);
-  if (!id) {
-    id =
-      typeof crypto !== 'undefined' && 'randomUUID' in crypto
-        ? crypto.randomUUID()
-        : `guest-${Date.now()}-${Math.floor(Math.random() * 1e9)}`;
-    localStorage.setItem(GUEST_KEY, id);
-  }
-  return id;
-}
diff --git a/apps/edr-passenger-web/portal/src/features/support/supportApi.ts b/apps/edr-passenger-web/portal/src/features/support/supportApi.ts
index 6e619b0aa..c33eef760 100644
--- a/apps/edr-passenger-web/portal/src/features/support/supportApi.ts
+++ b/apps/edr-passenger-web/portal/src/features/support/supportApi.ts
@@ -1,75 +1,29 @@
 import type { Passenger } from '@edr/types';
 
 import { apiClient } from '@/lib/api-client';
-import { getGuestId, isAuthed } from './guestIdentity';
+import { getDeviceId } from './deviceIdentity';
 
-type ConversationDto = Passenger.PassengerSupportConversationDto;
+type ThreadDto = Passenger.PassengerSupportThreadDto;
 type MessageDto = Passenger.PassengerSupportMessageDto;
-type ListResult = Passenger.PassengerSupportConversationListResult;
-
-export interface CreateInput {
-  subject: string;
-  initialMessage: string;
-  // Required only for guests:
-  name?: string;
-  email?: string;
-  phone?: string;
-}
 
 /**
- * Passenger portal support-chat calls. Transparently uses the authenticated
- * (`/support/...`) or guest (`/support/guest/...`) endpoints depending on whether
- * a passenger auth token is present. Guests are scoped by a localStorage guestId.
+ * Passenger portal support-chat calls — a single device-scoped thread. No auth,
+ * no forms; everything is keyed by a localStorage device id.
  */
 export const supportApi = {
-  listConversations: (): Promise<ListResult> =>
-    isAuthed()
-      ? apiClient.get('/support/conversations')
-      : apiClient.get('/support/guest/conversations', {
-          params: { guestId: getGuestId() },
-        }),
-
-  createConversation: (input: CreateInput): Promise<ConversationDto> =>
-    isAuthed()
-      ? apiClient.post('/support/conversations', {
-          subject: input.subject,
-          initialMessage: input.initialMessage,
-        })
-      : apiClient.post('/support/guest/conversations', {
-          guestId: getGuestId(),
-          name: input.name,
-          email: input.email,
-          phone: input.phone,
-          subject: input.subject,
-          initialMessage: input.initialMessage,
-        }),
-
-  listMessages: (id: string): Promise<MessageDto[]> =>
-    isAuthed()
-      ? apiClient.get(`/support/conversations/${id}/messages`)
-      : apiClient.get(`/support/guest/conversations/${id}/messages`, {
-          params: { guestId: getGuestId() },
-        }),
-
-  sendMessage: (id: string, text: string): Promise<MessageDto> =>
-    isAuthed()
-      ? apiClient.post(`/support/conversations/${id}/messages`, { text })
-      : apiClient.post(`/support/guest/conversations/${id}/messages`, {
-          guestId: getGuestId(),
-          text,
-        }),
-
-  markRead: (id: string): Promise<{ unreadCount: number }> =>
-    isAuthed()
-      ? apiClient.post(`/support/conversations/${id}/read`)
-      : apiClient.post(`/support/guest/conversations/${id}/read`, {
-          guestId: getGuestId(),
-        }),
-
+  getThread: (): Promise<ThreadDto> =>
+    apiClient.get('/support/device/thread', {
+      params: { deviceId: getDeviceId() },
+    }),
+  sendMessage: (text: string): Promise<MessageDto> =>
+    apiClient.post('/support/device/messages', {
+      deviceId: getDeviceId(),
+      text,
+    }),
+  markRead: (): Promise<{ unreadCount: number }> =>
+    apiClient.post('/support/device/read', { deviceId: getDeviceId() }),
   unreadCount: (): Promise<{ unreadCount: number }> =>
-    isAuthed()
-      ? apiClient.get('/support/unread-count')
-      : apiClient.get('/support/guest/unread-count', {
-          params: { guestId: getGuestId() },
-        }),
+    apiClient.get('/support/device/unread-count', {
+      params: { deviceId: getDeviceId() },
+    }),
 };
diff --git a/apps/edr-passenger-web/portal/src/features/support/useSupport.ts b/apps/edr-passenger-web/portal/src/features/support/useSupport.ts
index 129d28970..14b8518c8 100644
--- a/apps/edr-passenger-web/portal/src/features/support/useSupport.ts
+++ b/apps/edr-passenger-web/portal/src/features/support/useSupport.ts
@@ -2,28 +2,20 @@
 
 import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
 
-import { supportApi, type CreateInput } from './supportApi';
+import { supportApi } from './supportApi';
 
-export const SUPPORT_CONVERSATIONS_KEY = ['support', 'conversations'];
+export const SUPPORT_THREAD_KEY = ['support', 'thread'];
 export const SUPPORT_UNREAD_KEY = ['support', 'unread'];
-export const supportMessagesKey = (id: string) => ['support', 'messages', id];
 
-export function useConversations(enabled = true) {
+/** The device's single support thread (conversation + messages). */
+export function useThread(enabled = true) {
   return useQuery({
-    queryKey: SUPPORT_CONVERSATIONS_KEY,
-    queryFn: () => supportApi.listConversations(),
+    queryKey: SUPPORT_THREAD_KEY,
+    queryFn: () => supportApi.getThread(),
     enabled,
   });
 }
 
-export function useMessages(conversationId: string | null) {
-  return useQuery({
-    queryKey: supportMessagesKey(conversationId ?? ''),
-    queryFn: () => supportApi.listMessages(conversationId as string),
-    enabled: !!conversationId,
-  });
-}
-
 export function useUnreadCount(enabled = true) {
   return useQuery({
     queryKey: SUPPORT_UNREAD_KEY,
@@ -33,22 +25,13 @@ export function useUnreadCount(enabled = true) {
   });
 }
 
-export function useCreateConversation() {
+export function useSendMessage() {
   const qc = useQueryClient();
   return useMutation({
-    mutationFn: (input: CreateInput) => supportApi.createConversation(input),
-    onSuccess: () =>
-      qc.invalidateQueries({ queryKey: SUPPORT_CONVERSATIONS_KEY }),
-  });
-}
-
-export function useSendMessage(conversationId: string) {
-  const qc = useQueryClient();
-  return useMutation({
-    mutationFn: (text: string) => supportApi.sendMessage(conversationId, text),
+    mutationFn: (text: string) => supportApi.sendMessage(text),
     onSuccess: () => {
-      qc.invalidateQueries({ queryKey: supportMessagesKey(conversationId) });
-      qc.invalidateQueries({ queryKey: SUPPORT_CONVERSATIONS_KEY });
+      qc.invalidateQueries({ queryKey: SUPPORT_THREAD_KEY });
+      qc.invalidateQueries({ queryKey: SUPPORT_UNREAD_KEY });
     },
   });
 }
@@ -56,9 +39,9 @@ export function useSendMessage(conversationId: string) {
 export function useMarkRead() {
   const qc = useQueryClient();
   return useMutation({
-    mutationFn: (id: string) => supportApi.markRead(id),
+    mutationFn: () => supportApi.markRead(),
     onSuccess: () => {
-      qc.invalidateQueries({ queryKey: SUPPORT_CONVERSATIONS_KEY });
+      qc.invalidateQueries({ queryKey: SUPPORT_THREAD_KEY });
       qc.invalidateQueries({ queryKey: SUPPORT_UNREAD_KEY });
     },
   });
diff --git a/apps/edr-passenger-web/portal/src/features/support/useSupportSocket.ts b/apps/edr-passenger-web/portal/src/features/support/useSupportSocket.ts
index 441b77cb8..1bd21b7b8 100644
--- a/apps/edr-passenger-web/portal/src/features/support/useSupportSocket.ts
+++ b/apps/edr-passenger-web/portal/src/features/support/useSupportSocket.ts
@@ -2,66 +2,43 @@
 
 import { Passenger } from '@edr/types';
 import { useQueryClient } from '@tanstack/react-query';
-import { useEffect, useRef } from 'react';
+import { useEffect } from 'react';
 import { io } from 'socket.io-client';
 
-import { getGuestId, isAuthed } from './guestIdentity';
-import {
-  SUPPORT_CONVERSATIONS_KEY,
-  SUPPORT_UNREAD_KEY,
-  supportMessagesKey,
-} from './useSupport';
+import { getDeviceId } from './deviceIdentity';
+import { SUPPORT_THREAD_KEY, SUPPORT_UNREAD_KEY } from './useSupport';
 
 const SOCKET_ORIGIN = String(
   process.env.NEXT_PUBLIC_API_URL || 'http://localhost:4000',
 ).replace(/\/api\/?$/, '');
 
 /**
- * Subscribes the signed-in passenger to live support pushes. New messages
- * refresh the affected thread + list + unread badge, and fire `onMessage`
- * (the widget toasts when closed).
+ * Subscribes the device to live support pushes. The gateway joins a
+ * `guest:<deviceId>` room; any message/status change refreshes the thread and
+ * the unread badge.
  */
-export function useSupportSocket(
-  enabled: boolean,
-  onMessage?: (event: Passenger.PassengerSupportMessageEvent) => void,
-) {
+export function useSupportSocket(enabled: boolean) {
   const qc = useQueryClient();
-  const onMessageRef = useRef(onMessage);
-  onMessageRef.current = onMessage;
 
   useEffect(() => {
     if (!enabled || typeof window === 'undefined') return;
-    // Authenticated passengers connect with their token; guests connect with
-    // their anonymous guestId so the gateway can join their `guest:<id>` room.
-    const auth = isAuthed()
-      ? { token: localStorage.getItem('auth_token') }
-      : { guestId: getGuestId() };
-
     const socket = io(
       `${SOCKET_ORIGIN}/${Passenger.PASSENGER_SUPPORT_WS_NAMESPACE}`,
       {
-        auth,
-        transports: ['websocket'],
+        auth: { guestId: getDeviceId() },
+        // Prefer WebSocket, fall back to HTTP long-polling if the proxy blocks
+        // the upgrade (polling rides normal HTTPS, already CSP-allowed).
+        transports: ['websocket', 'polling'],
         withCredentials: true,
       },
     );
 
-    socket.on(
-      Passenger.PASSENGER_SUPPORT_WS_EVENTS.MESSAGE_NEW,
-      (event: Passenger.PassengerSupportMessageEvent) => {
-        qc.invalidateQueries({
-          queryKey: supportMessagesKey(event.message.conversationId),
-        });
-        qc.invalidateQueries({ queryKey: SUPPORT_CONVERSATIONS_KEY });
-        qc.invalidateQueries({ queryKey: SUPPORT_UNREAD_KEY });
-        onMessageRef.current?.(event);
-      },
-    );
-
-    socket.on(Passenger.PASSENGER_SUPPORT_WS_EVENTS.CONVERSATION_UPDATED, () => {
-      qc.invalidateQueries({ queryKey: SUPPORT_CONVERSATIONS_KEY });
+    const refresh = () => {
+      qc.invalidateQueries({ queryKey: SUPPORT_THREAD_KEY });
       qc.invalidateQueries({ queryKey: SUPPORT_UNREAD_KEY });
-    });
+    };
+    socket.on(Passenger.PASSENGER_SUPPORT_WS_EVENTS.MESSAGE_NEW, refresh);
+    socket.on(Passenger.PASSENGER_SUPPORT_WS_EVENTS.CONVERSATION_UPDATED, refresh);
 
     return () => {
       socket.off();
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 9d15af7d8..6ff31aeaf 100644
--- a/apps/edr-passenger-web/portal/src/lib/generate-voucher.ts
+++ b/apps/edr-passenger-web/portal/src/lib/generate-voucher.ts
@@ -52,11 +52,14 @@ const PAGE_MARGIN = 18;
 // Encodes everything a gate scanner needs to verify this specific ticket without
 // a network round-trip: booking reference, ticket number, passenger, train, seat(s),
 // departure time and fare. Kept as compact JSON so any generic QR reader can parse it.
+// Field names (`ref`/`ticketNumber`) must match what the backoffice boarding scanner and
+// tickets.service.ts's scanAndBoard() read from the QR payload — see apps/edr-passenger-api/
+// src/modules/tickets/tickets.service.ts.
 function buildTicketQrPayload(data: PassengerVoucherData): string {
   return JSON.stringify({
     type: 'EDR_TICKET',
-    pnr: data.bookingRef,
-    ticket: data.ticketNumber,
+    ref: data.bookingRef,
+    ticketNumber: data.ticketNumber,
     passenger: data.passengerName,
     status: data.status,
     train: data.outboundSchedule.trainNumber,
@@ -165,6 +168,10 @@ function drawTicketHero(doc: jsPDF, bookingRef: string, ticketNumber: string, st
   const qrSize = 22;
   const qrPad = 2.5;
   const cardSize = qrSize + qrPad * 2;
+  const qrGap = 3;
+  // The QR box is anchored to the right edge of the card — reserve that space so the
+  // status pill (also right-anchored) never draws underneath/over it.
+  const qrCardX = pageWidth - margin - cardSize - qrGap;
 
   doc.setFillColor(...SURFACE);
   doc.setDrawColor(...HAIRLINE);
@@ -172,7 +179,8 @@ function drawTicketHero(doc: jsPDF, bookingRef: string, ticketNumber: string, st
   doc.roundedRect(margin, y, pageWidth - margin * 2, cardH, 3, 3, 'FD');
 
   const padX = 7;
-  drawStatusPill(doc, status, pageWidth - margin - padX, y + 5.5, 'right');
+  const pillRightX = qrDataUrl ? qrCardX - qrGap : pageWidth - margin - padX;
+  drawStatusPill(doc, status, pillRightX, y + 5.5, 'right');
 
   label(doc, 'Booking reference', margin + padX, y + 12);
   doc.setTextColor(...INK); doc.setFontSize(21); doc.setFont('helvetica', 'bold');
@@ -183,13 +191,12 @@ function drawTicketHero(doc: jsPDF, bookingRef: string, ticketNumber: string, st
   doc.text(ticketNumber, margin + padX + 22, y + 28.7);
 
   if (qrDataUrl) {
-    const cardX = pageWidth - margin - cardSize - 3;
     const cardY = y + (cardH - cardSize) / 2;
     doc.setFillColor(255, 255, 255);
     doc.setDrawColor(...HAIRLINE);
     doc.setLineWidth(0.3);
-    doc.roundedRect(cardX, cardY, cardSize, cardSize, 2, 2, 'FD');
-    doc.addImage(qrDataUrl, 'PNG', cardX + qrPad, cardY + qrPad, qrSize, qrSize);
+    doc.roundedRect(qrCardX, cardY, cardSize, cardSize, 2, 2, 'FD');
+    doc.addImage(qrDataUrl, 'PNG', qrCardX + qrPad, cardY + qrPad, qrSize, qrSize);
   }
 
   return y + cardH + 10;
diff --git a/apps/edr-passenger-web/portal/src/middleware.ts b/apps/edr-passenger-web/portal/src/middleware.ts
index c7960a601..f5759b0bf 100644
--- a/apps/edr-passenger-web/portal/src/middleware.ts
+++ b/apps/edr-passenger-web/portal/src/middleware.ts
@@ -48,8 +48,12 @@ function buildCsp(nonce: string): string {
     ? `'self' 'nonce-${nonce}' 'strict-dynamic'`
     : `'self' 'unsafe-inline' 'unsafe-eval'`;
 
+  // The Socket.IO WebSocket upgrade connects to wss://<api-host>; under CSP a
+  // `https://host` source does NOT cover `wss://host`, so add it explicitly.
+  const wsOrigin = apiOrigin.replace(/^http/, 'ws'); // https→wss, http→ws
+
   const connectSrc = isProd
-    ? `'self' ${apiOrigin}`.trim()
+    ? `'self' ${apiOrigin} ${wsOrigin}`.trim()
     : `'self' ${apiOrigin} ws: wss:`.trim();
 
   const directives = [
diff --git a/apps/edr-payment-api/src/modules/intents/intents.service.ts b/apps/edr-payment-api/src/modules/intents/intents.service.ts
index aebb65ebb..ccd10f508 100644
--- a/apps/edr-payment-api/src/modules/intents/intents.service.ts
+++ b/apps/edr-payment-api/src/modules/intents/intents.service.ts
@@ -77,8 +77,27 @@ export class IntentsService {
       request.referenceId,
     );
     if (existing) {
-      const reusable = await this.reuseOrRetire(existing);
-      if (reusable) return this.toSnapshot(reusable);
+      // Payer switched method (e.g. Waafi → Telebirr) on an uncharged session: retire the
+      // open intent and fall through to open a fresh one for the new provider. Only safe
+      // while REQUIRES_ACTION — PROCESSING/SUCCEEDED intents may have money in flight, so
+      // they keep the reuse path (the switch is silently refused until they resolve).
+      const switchingProvider =
+        existing.provider !== request.provider &&
+        existing.status === ProviderPaymentStatus.REQUIRES_ACTION;
+      if (switchingProvider) {
+        await this.intentsRepository.update(existing.id, {
+          status: ProviderPaymentStatus.CANCELLED,
+          failureCode: "METHOD_CHANGED",
+          failureMessage: `Payer switched from ${existing.provider} to ${request.provider}`,
+        });
+        this.logger.log(
+          `intent ${existing.id} retired (METHOD_CHANGED ${existing.provider} → ${request.provider}) for ` +
+            `${request.service}/${request.referenceType}/${request.referenceId}`,
+        );
+      } else {
+        const reusable = await this.reuseOrRetire(existing);
+        if (reusable) return this.toSnapshot(reusable);
+      }
     }
 
     const provider = this.providers.get(request.provider);
diff --git a/packages/payment-providers/src/providers/cac-bank/cac-bank.provider.ts b/packages/payment-providers/src/providers/cac-bank/cac-bank.provider.ts
index f72f42ba2..8e5a94bbb 100644
--- a/packages/payment-providers/src/providers/cac-bank/cac-bank.provider.ts
+++ b/packages/payment-providers/src/providers/cac-bank/cac-bank.provider.ts
@@ -1,4 +1,4 @@
-import { Injectable, Logger } from "@nestjs/common";
+import { Injectable, Logger, OnModuleInit } from "@nestjs/common";
 import { ConfigService } from "@nestjs/config";
 import { HttpService } from "@nestjs/axios";
 import {
@@ -23,7 +23,7 @@ import type {
 } from "./cac-bank.types";
 
 @Injectable()
-export class CacBankProvider implements PaymentProvider {
+export class CacBankProvider implements PaymentProvider, OnModuleInit {
   readonly method = ProviderMethod.CAC_BANK;
   private readonly logger = new Logger(CacBankProvider.name);
   private auth: CacBankAuth | null = null;
@@ -33,6 +33,29 @@ export class CacBankProvider implements PaymentProvider {
     private readonly http: HttpService,
   ) {}
 
+  /** Log the effective CAC Bank config once at startup (secrets masked) so misconfig is visible. */
+  onModuleInit(): void {
+    this.logger.log(
+      `CAC Bank config resolved: ${JSON.stringify(this.effectiveConfig())}`,
+    );
+  }
+
+  /** Snapshot of every resolved CAC env value; secret fields are masked, not printed raw. */
+  private effectiveConfig(): Record<string, unknown> {
+    return {
+      CAC_BASE_URL: this.baseUrl || "(empty)",
+      CAC_USERNAME: this.username || "(empty)",
+      CAC_PASSWORD: this.password,
+      CAC_APP_KEY: this.appKey,
+      CAC_API_KEY: this.apiKey,
+      CAC_COMPANY_SERVICES_ID: this.companyServicesId,
+      CAC_CURRENCY: this.defaultCurrency,
+      CAC_TOKEN_TTL_MS: this.tokenTtlMs,
+      CAC_OTP_EXPIRY_MS: this.otpExpiryMs,
+    };
+  }
+  
+
   async initiate(
     input: ProviderInitiationInput,
   ): Promise<ProviderInitiationResult> {
@@ -51,12 +74,25 @@ export class CacBankProvider implements PaymentProvider {
       company_services_id: this.companyServicesId,
     };
 
+    this.logger.log(
+      `CAC Bank initiate → ${this.baseUrl}/paymentapi/PaymentInitiateRequest | currency=${requestBody.currency} amount=${requestBody.amount} (amountMinorIn=${input.amountMinor}) mobile=${input.payerAccount} ref=${input.merchantOrderId}`,
+    );
+    this.logger.debug(
+      `CAC Bank initiate request body: ${JSON.stringify(this.sanitizeKeys(requestBody))}`,
+    );
+    this.logger.debug(
+      `CAC Bank effective config: ${JSON.stringify(this.effectiveConfig())}`,
+    );
+
     const response = await this.postJson<CacPaymentInitiateResponse>(
       "/paymentapi/PaymentInitiateRequest",
       requestBody,
     );
 
     if (response.paymentRequestId == null) {
+      this.logger.error(
+        `CAC Bank initiate rejected — sent currency=${requestBody.currency} amount=${requestBody.amount} mobile=${input.payerAccount} | full response: ${JSON.stringify(response)}`,
+      );
       throw new Error(
         `CAC Bank initiate failed: ${JSON.stringify(response)}`,
       );
@@ -92,6 +128,10 @@ export class CacBankProvider implements PaymentProvider {
       otp,
     };
 
+    this.logger.log(
+      `CAC Bank confirm → paymentRequestId=${paymentRequestId} otp=${"*".repeat(otp?.length ?? 0)}`,
+    );
+
     try {
       const response = await this.postJson<CacPaymentConfirmResponse>(
         "/paymentapi/PaymentConfirmationRequest",
@@ -99,6 +139,9 @@ export class CacBankProvider implements PaymentProvider {
       );
 
       if (response.confirmReference == null && !response.reference) {
+        this.logger.warn(
+          `CAC Bank confirm rejected — paymentRequestId=${paymentRequestId} | full response: ${JSON.stringify(response)}`,
+        );
         return {
           status: "FAILED",
           failureCode: "CONFIRM_REJECTED",
diff --git a/packages/payment-providers/src/providers/waafi/waafi.provider.ts b/packages/payment-providers/src/providers/waafi/waafi.provider.ts
index 58331ecbd..5914fcd61 100644
--- a/packages/payment-providers/src/providers/waafi/waafi.provider.ts
+++ b/packages/payment-providers/src/providers/waafi/waafi.provider.ts
@@ -1,4 +1,4 @@
-import { Injectable, Logger } from "@nestjs/common";
+import { Injectable, Logger, OnModuleInit } from "@nestjs/common";
 import { ConfigService } from "@nestjs/config";
 import { HttpService } from "@nestjs/axios";
 import {
@@ -26,7 +26,7 @@ const WAAFI_SUCCESS_CODE = "2001";
 const WAAFI_HPP_SESSION_MS = 5 * 60_000;
 
 @Injectable()
-export class WaafiProvider implements PaymentProvider {
+export class WaafiProvider implements PaymentProvider, OnModuleInit {
   readonly method = ProviderMethod.WAAFI;
   private readonly logger = new Logger(WaafiProvider.name);
   private readonly httpsAgent: https.Agent;
@@ -44,16 +44,59 @@ export class WaafiProvider implements PaymentProvider {
     this.httpsAgent = new https.Agent({ rejectUnauthorized: !insecure });
   }
 
+  /** Log the effective Waafi config once at startup (secrets masked) so misconfig is visible. */
+  onModuleInit(): void {
+    this.logger.log(
+      `Waafi config resolved: ${JSON.stringify(this.effectiveConfig())}`,
+    );
+  }
+
+  /** Snapshot of every resolved Waafi env value; secret fields are masked, not printed raw. */
+  private effectiveConfig(): Record<string, unknown> {
+    return {
+      WAAFI_BASE_URL: this.baseUrl,
+      WAAFI_MERCHANT_UID: this.merchantUid || "(empty)",
+      WAAFI_STORE_ID: this.storeId || "(empty)",
+      WAAFI_HPP_KEY: this.mask(this.hppKey),
+      WAAFI_WEBHOOK_SECRET: this.mask(this.webhookSecret),
+      WAAFI_PAYMENT_METHOD: this.paymentMethod,
+      WAAFI_HPP_SUCCESS_URL: this.successUrl || "(empty)",
+      WAAFI_HPP_FAILURE_URL: this.failureUrl || "(empty)",
+      WAAFI_HPP_RESP_FORMAT: this.respDataFormat,
+      WAAFI_INSECURE_TLS: this.config.get<boolean>("waafi.insecureTls") ?? false,
+    };
+  }
+
+  /** Mask a secret to `set(len=N,…abcd)` / `(empty)` so presence & length are visible but not the value. */
+  private mask(value: string): string {
+    if (!value) return "(empty)";
+    const tail = value.length > 4 ? value.slice(-4) : "";
+    return `set(len=${value.length},…${tail})`;
+  }
+
   async initiate(
     input: ProviderInitiationInput,
   ): Promise<ProviderInitiationResult> {
     const requestBody = this.buildPurchaseRequest(input);
+    const url = `${this.baseUrl}/asm`;
+    this.logger.log(
+      `Waafi HPP_PURCHASE → ${url} | currency=${input.currency} amount=${this.toAmount(input.amountMinor)} (amountMinorIn=${input.amountMinor}) ref=${input.merchantOrderId}`,
+    );
+    this.logger.debug(
+      `Waafi HPP_PURCHASE request body: ${JSON.stringify(this.sanitize(requestBody))}`,
+    );
+    this.logger.debug(
+      `Waafi effective config: ${JSON.stringify(this.effectiveConfig())}`,
+    );
     const response = await this.postJson<WaafiHppPurchaseResponse>(
-      `${this.baseUrl}/asm`,
+      url,
       requestBody,
     );
 
     if (response.responseCode !== WAAFI_SUCCESS_CODE) {
+      this.logger.error(
+        `Waafi HPP_PURCHASE rejected — sent currency=${input.currency} amount=${this.toAmount(input.amountMinor)} paymentMethod=${this.paymentMethod} | full response: ${JSON.stringify(response)}`,
+      );
       throw new Error(
         `Waafi HPP_PURCHASE failed: responseCode=${response.responseCode} errorCode=${response.errorCode} msg=${response.responseMsg}`,
       );
diff --git a/packages/types/src/freight/index.ts b/packages/types/src/freight/index.ts
index 7817e0a31..c5a1a364a 100644
--- a/packages/types/src/freight/index.ts
+++ b/packages/types/src/freight/index.ts
@@ -521,6 +521,8 @@ export interface IBooking extends BaseEntity {
   customerTruckContainerNumber?: string | null;
   customerTruckAssignedAt?: string | null;
   customerTruckArrivedAt?: string | null;
+  /** A handover has been generated for this booking and is awaiting the customer's signature. */
+  handoverAwaitingSignature?: boolean;
 
   customsClearingEnabled?: boolean;
   // (multi-truck self-haul lives in ICustomerTruck[], fetched via the
diff --git a/packages/types/src/passenger/support-chat.ts b/packages/types/src/passenger/support-chat.ts
index a768db122..254b64e55 100644
--- a/packages/types/src/passenger/support-chat.ts
+++ b/packages/types/src/passenger/support-chat.ts
@@ -79,6 +79,12 @@ export interface SendPassengerSupportMessageDto {
   text: string;
 }
 
+/** The single device-scoped thread for the portal: conversation + its messages. */
+export interface PassengerSupportThreadDto {
+  conversation: PassengerSupportConversationDto | null;
+  messages: PassengerSupportMessageDto[];
+}
+
 /** Paginated list envelope for the conversations list endpoints. */
 export interface PassengerSupportConversationListResult {
   items: PassengerSupportConversationDto[];
diff --git a/packages/ui-common/src/components/SmartFileInput/index.tsx b/packages/ui-common/src/components/SmartFileInput/index.tsx
index 1e1eaf223..b078c7c00 100644
--- a/packages/ui-common/src/components/SmartFileInput/index.tsx
+++ b/packages/ui-common/src/components/SmartFileInput/index.tsx
@@ -767,9 +767,9 @@ export function SmartFileInput({
                           )}
                         </div>
 
-                        <span className="hidden shrink-0 items-center gap-1.5 rounded-md border border-border bg-card px-3 py-1.5 text-xs font-medium text-foreground shadow-2xs transition group-hover:border-primary/50 group-hover:text-primary sm:inline-flex">
+                        <span className="inline-flex shrink-0 items-center gap-1.5 rounded-md border border-primary/40 bg-card px-3 py-1.5 text-xs font-semibold text-primary shadow-2xs transition group-hover:border-primary group-hover:bg-primary/5">
                           <UploadCloud className="h-3.5 w-3.5" />
-                          Replace
+                          Replace file
                         </span>
                       </div>
                     ) : (