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/.env.example b/apps/edr-freight-api/.env.example
index 2b3b855cb..6fdaab48b 100644
--- a/apps/edr-freight-api/.env.example
+++ b/apps/edr-freight-api/.env.example
@@ -1,5 +1,7 @@
 # Copy to .env for local/docker compose (not committed).
 PORT=3001
+# GT06 GPS tracker TCP listener port (raw TCP, must be reachable by tracker SIMs). 0 disables.
+GT06_TCP_PORT=5023
 DB_HOST=localhost
 DB_PORT=5433
 DB_USER=postgres
diff --git a/apps/edr-freight-api/Dockerfile b/apps/edr-freight-api/Dockerfile
index f9107ed23..d88029a80 100644
--- a/apps/edr-freight-api/Dockerfile
+++ b/apps/edr-freight-api/Dockerfile
@@ -40,4 +40,6 @@ RUN addgroup --system --gid 1001 nodejs \
 COPY --from=deployer --chown=nestjs:nodejs /deploy .
 USER nestjs
 EXPOSE 3001
+# GT06 GPS tracker TCP listener (raw TCP, not HTTP). Change via GT06_TCP_PORT.
+EXPOSE 5023
 CMD ["node", "dist/main.js"]
diff --git a/apps/edr-freight-api/src/app.module.ts b/apps/edr-freight-api/src/app.module.ts
index d23d5bd2a..9561a7b73 100644
--- a/apps/edr-freight-api/src/app.module.ts
+++ b/apps/edr-freight-api/src/app.module.ts
@@ -8,7 +8,10 @@ import { TypeOrmModule, TypeOrmModuleOptions } from "@nestjs/typeorm";
 import { ScheduleModule } from "@nestjs/schedule";
 import { EventEmitterModule } from "@nestjs/event-emitter";
 import { DataSource, DataSourceOptions } from "typeorm";
-import { ensurePostgresSchemas } from "./config/ensure-postgres-schemas";
+import {
+  ensurePostgresSchemas,
+  APPLICATION_SEARCH_PATH,
+} from "./config/ensure-postgres-schemas";
 import { IamModule, DataSeeder } from "@tria-plc/iamapi-common";
 import { SharedAuthModule } from "@tria-plc/api-common/modules/auth/shared-auth.module";
 
@@ -48,6 +51,7 @@ import {
   EDR_FREIGHT_PERMISSIONS,
 } from "./seed/edr-freight.seed";
 import { EdrOrgSeeder } from "./seed/edr-org.seeder";
+import { FreightPositionsSeeder } from "./seed/freight-positions.seeder";
 import { DemoUsersSeeder } from "./seed/demo-users.seeder";
 import { FreightStaffUsersSeeder } from "./seed/freight-staff-users.seeder";
 import { PaymentModule } from "./modules/payment/payment.module";
@@ -80,6 +84,10 @@ import { VehiclesModule } from "./modules/vehicles/vehicles.module";
 import { DriversModule } from "./modules/drivers/drivers.module";
 import { FuelModule } from "./modules/fuel/fuel.module";
 import { MaintenanceModule } from "./modules/maintenance/maintenance.module";
+import { ComplianceModule } from "./modules/compliance/compliance.module";
+import { IncidentsModule } from "./modules/incidents/incidents.module";
+import { ProcurementModule } from "./modules/procurement/procurement.module";
+import { GpsTrackingModule } from "./modules/gps-tracking/gps-tracking.module";
 import { FirstMileModule } from "./modules/first-mile/first-mile.module";
 import { LastMileModule } from "./modules/last-mile/last-mile.module";
 import { InterchangeDocumentsModule } from "./modules/interchange-documents/interchange-documents.module";
@@ -104,7 +112,27 @@ import { LoggerMiddleware } from "./logger.middleware";
         }
         await ensurePostgresSchemas(options as DataSourceOptions);
         const dataSource = new DataSource(options as DataSourceOptions);
-        return dataSource.initialize();
+        await dataSource.initialize();
+
+        // The remote edr_dev DB sits behind a connection pooler/proxy that rejects
+        // the Postgres `options` startup parameter (08P01). Instead of setting
+        // search_path at connect time, apply it per physical connection: the pg
+        // Pool emits `connect` for every new client (initial fill, pool growth,
+        // reconnect), so every backend session gets the schema search order.
+        const pool = (dataSource.driver as { master?: unknown }).master as
+          | { on?: (event: string, cb: (client: unknown) => void) => void }
+          | undefined;
+        if (pool?.on) {
+          pool.on("connect", (client) => {
+            (client as { query: (sql: string) => Promise<unknown> })
+              .query(`SET search_path TO ${APPLICATION_SEARCH_PATH}`)
+              .catch(() => {
+                /* connection will be validated on first real query */
+              });
+          });
+        }
+
+        return dataSource;
       },
     }),
     SharedAuthModule,
@@ -148,6 +176,10 @@ import { LoggerMiddleware } from "./logger.middleware";
     DriversModule,
     FuelModule,
     MaintenanceModule,
+    ComplianceModule,
+    IncidentsModule,
+    ProcurementModule,
+    GpsTrackingModule,
     FirstMileModule,
     LastMileModule,
     InterchangeDocumentsModule,
@@ -157,6 +189,7 @@ import { LoggerMiddleware } from "./logger.middleware";
   ],
   providers: [
     EdrOrgSeeder,
+    FreightPositionsSeeder,
     DemoUsersSeeder,
     FreightStaffUsersSeeder,
     PricingDataSeeder,
@@ -180,6 +213,7 @@ export class AppModule implements OnApplicationBootstrap {
   constructor(
     private readonly seeder: DataSeeder,
     private readonly edrOrgSeeder: EdrOrgSeeder,
+    private readonly freightPositionsSeeder: FreightPositionsSeeder,
     private readonly demoUsersSeeder: DemoUsersSeeder,
     private readonly freightStaffUsersSeeder: FreightStaffUsersSeeder,
     private readonly pricingDataSeeder: PricingDataSeeder,
@@ -201,6 +235,7 @@ export class AppModule implements OnApplicationBootstrap {
     await this.freightPermissionKeyMigrationSeeder.run();
     await this.seeder.run();
     await this.edrOrgSeeder.run();
+    await this.freightPositionsSeeder.run();
     await this.demoUsersSeeder.run();
     await this.freightStaffUsersSeeder.run();
     await this.pricingDataSeeder.run();
diff --git a/apps/edr-freight-api/src/config/database.config.ts b/apps/edr-freight-api/src/config/database.config.ts
index 9e05eb794..dcf09fbd9 100644
--- a/apps/edr-freight-api/src/config/database.config.ts
+++ b/apps/edr-freight-api/src/config/database.config.ts
@@ -44,7 +44,6 @@ import {
   NotificationTemplate,
 } from "@tria-plc/iamapi-common";
 import { OrganizationSetting } from "@tria-plc/iamapi-common/entities/iam/organization-structure/organization-setting.entity";
-import { APPLICATION_SEARCH_PATH } from "./ensure-postgres-schemas";
 
 const iamEntities = [
   DefaultPosition,
@@ -105,14 +104,12 @@ export default registerAs("database", (): TypeOrmModuleOptions => {
     password: process.env.DB_PASSWORD ?? "",
     database: process.env.DB_NAME ?? "edr_freight",
     schema: "public",
-    // The `-c search_path=...` startup option is rejected by transaction-pooling
-    // poolers (e.g. PgBouncer: "unsupported startup parameter in options"). When
-    // behind such a pooler set DB_PGBOUNCER=true and instead make the search_path
-    // a role default: ALTER ROLE <user> IN DATABASE <db> SET search_path TO
-    // public,iam,freight,audit;
-    ...(process.env.DB_PGBOUNCER === "true"
-      ? {}
-      : { extra: { options: `-c search_path=${APPLICATION_SEARCH_PATH}` } }),
+    // NOTE: do NOT pass `extra.options: '-c search_path=...'`. That sends the
+    // Postgres startup `options` parameter, which connection poolers (PgBouncer /
+    // proxies fronting the remote edr_dev DB) reject with
+    // `08P01 unsupported startup parameter in options: search_path`.
+    // The search_path is instead applied per-connection via a pool `connect`
+    // handler in app.module.ts (see setPoolSearchPath).
     entities: [__dirname + "/../**/*.entity.{ts,js}", ...iamEntities],
     autoLoadEntities: true,
     migrations: [
diff --git a/apps/edr-freight-api/src/migrations/1900000000000-AddEmailToOtpVerifications.ts b/apps/edr-freight-api/src/migrations/1900000000000-AddEmailToOtpVerifications.ts
index 1bd3bbc27..55a6568c3 100644
--- a/apps/edr-freight-api/src/migrations/1900000000000-AddEmailToOtpVerifications.ts
+++ b/apps/edr-freight-api/src/migrations/1900000000000-AddEmailToOtpVerifications.ts
@@ -12,23 +12,28 @@ export class AddEmailToOtpVerifications1900000000000
   name = "AddEmailToOtpVerifications1900000000000";
 
   public async up(queryRunner: QueryRunner): Promise<void> {
+    // The table lives in the `freight` schema (the OtpVerification entity pins
+    // schema: "freight"). An earlier version of this migration targeted
+    // `public.otp_verifications`, which does not exist there — leaving the real
+    // freight table without an `email` column and OTP send failing with
+    // `column OtpVerification.email does not exist`. Target `freight` explicitly.
     await queryRunner.query(`
-      ALTER TABLE public.otp_verifications
+      ALTER TABLE freight.otp_verifications
       ALTER COLUMN phone DROP NOT NULL
     `);
     await queryRunner.query(`
-      ALTER TABLE public.otp_verifications
+      ALTER TABLE freight.otp_verifications
       ADD COLUMN IF NOT EXISTS email varchar UNIQUE
     `);
   }
 
   public async down(queryRunner: QueryRunner): Promise<void> {
     await queryRunner.query(`
-      ALTER TABLE public.otp_verifications
+      ALTER TABLE freight.otp_verifications
       DROP COLUMN IF EXISTS email
     `);
     await queryRunner.query(`
-      ALTER TABLE public.otp_verifications
+      ALTER TABLE freight.otp_verifications
       ALTER COLUMN phone SET NOT NULL
     `);
   }
diff --git a/apps/edr-freight-api/src/migrations/1950000000000-AddVehicleCompliance.ts b/apps/edr-freight-api/src/migrations/1950000000000-AddVehicleCompliance.ts
new file mode 100644
index 000000000..f83f0a236
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/1950000000000-AddVehicleCompliance.ts
@@ -0,0 +1,59 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+/**
+ * Vehicle Compliance & Expiry Alerts.
+ * - Adds expiry-tracking columns to freight.vehicles.
+ * - Creates freight.compliance_records for per-document compliance tracking.
+ */
+export class AddVehicleCompliance1950000000000 implements MigrationInterface {
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    // Vehicle expiry / compliance columns.
+    await queryRunner.query(`
+      ALTER TABLE freight.vehicles
+        ADD COLUMN IF NOT EXISTS vin VARCHAR,
+        ADD COLUMN IF NOT EXISTS ownership VARCHAR,
+        ADD COLUMN IF NOT EXISTS insurance_expiry DATE,
+        ADD COLUMN IF NOT EXISTS registration_expiry DATE,
+        ADD COLUMN IF NOT EXISTS next_inspection_date DATE;
+    `);
+
+    // Compliance records table.
+    await queryRunner.query(`
+      CREATE TABLE IF NOT EXISTS freight.compliance_records (
+        id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+        vehicle_id UUID NOT NULL REFERENCES freight.vehicles(id),
+        type VARCHAR NOT NULL,
+        document_number VARCHAR,
+        issued_date DATE,
+        expiry_date DATE NOT NULL,
+        status VARCHAR NOT NULL DEFAULT 'VALID',
+        notes TEXT,
+        created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+        updated_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+        deleted_at TIMESTAMPTZ
+      );
+    `);
+
+    await queryRunner.query(
+      `CREATE INDEX IF NOT EXISTS idx_compliance_records_vehicle_id ON freight.compliance_records(vehicle_id);`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX IF NOT EXISTS idx_compliance_records_expiry_date ON freight.compliance_records(expiry_date);`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX IF NOT EXISTS idx_compliance_records_type ON freight.compliance_records(type);`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`DROP TABLE IF EXISTS freight.compliance_records CASCADE;`);
+    await queryRunner.query(`
+      ALTER TABLE freight.vehicles
+        DROP COLUMN IF EXISTS vin,
+        DROP COLUMN IF EXISTS ownership,
+        DROP COLUMN IF EXISTS insurance_expiry,
+        DROP COLUMN IF EXISTS registration_expiry,
+        DROP COLUMN IF EXISTS next_inspection_date;
+    `);
+  }
+}
diff --git a/apps/edr-freight-api/src/migrations/1960000000000-AddIncidents.ts b/apps/edr-freight-api/src/migrations/1960000000000-AddIncidents.ts
new file mode 100644
index 000000000..dbb2994c3
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/1960000000000-AddIncidents.ts
@@ -0,0 +1,46 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+/**
+ * Accident & Incident register for the fleet. Tracks accidents, breakdowns,
+ * traffic violations, thefts and other incidents against a vehicle, driver
+ * and/or booking, with severity, damage estimate, insurance claim tracking and
+ * a lifecycle status. Queried by driver_id for per-driver incident history.
+ */
+export class AddIncidents1960000000000 implements MigrationInterface {
+  name = 'AddIncidents1960000000000';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      CREATE TABLE IF NOT EXISTS freight.incidents (
+        id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+        created_at timestamptz NOT NULL DEFAULT now(),
+        updated_at timestamptz NOT NULL DEFAULT now(),
+        deleted_at timestamptz,
+        vehicle_id uuid,
+        driver_id uuid,
+        booking_id uuid,
+        type varchar NOT NULL,
+        severity varchar NOT NULL,
+        occurred_at timestamptz NOT NULL,
+        location varchar,
+        description text NOT NULL,
+        damage_estimate numeric(14,2),
+        status varchar NOT NULL DEFAULT 'REPORTED',
+        insurance_claim_number varchar,
+        reported_by varchar
+      )
+    `);
+    await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS "IDX_INCIDENTS_DRIVER"
+      ON freight.incidents (driver_id, occurred_at)
+    `);
+    await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS "IDX_INCIDENTS_VEHICLE"
+      ON freight.incidents (vehicle_id, occurred_at)
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`DROP TABLE IF EXISTS freight.incidents`);
+  }
+}
diff --git a/apps/edr-freight-api/src/migrations/1970000000000-AddMaintenanceDepth.ts b/apps/edr-freight-api/src/migrations/1970000000000-AddMaintenanceDepth.ts
new file mode 100644
index 000000000..87b52ceff
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/1970000000000-AddMaintenanceDepth.ts
@@ -0,0 +1,93 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class AddMaintenanceDepth1970000000000 implements MigrationInterface {
+  name = 'AddMaintenanceDepth1970000000000';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`CREATE SCHEMA IF NOT EXISTS freight`);
+
+    await queryRunner.query(`
+      CREATE TABLE IF NOT EXISTS freight.work_orders (
+        id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+        vehicle_id UUID NOT NULL,
+        title VARCHAR NOT NULL,
+        description TEXT,
+        status VARCHAR NOT NULL DEFAULT 'OPEN',
+        priority VARCHAR NOT NULL DEFAULT 'MEDIUM',
+        assigned_to VARCHAR,
+        opened_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+        closed_at TIMESTAMPTZ,
+        labor_cost NUMERIC(14, 2),
+        parts_cost NUMERIC(14, 2),
+        created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+        updated_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+        deleted_at TIMESTAMPTZ
+      );
+    `);
+
+    await queryRunner.query(`
+      CREATE TABLE IF NOT EXISTS freight.parts (
+        id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+        name VARCHAR NOT NULL,
+        sku VARCHAR,
+        category VARCHAR,
+        quantity_in_stock INT NOT NULL DEFAULT 0,
+        reorder_level INT NOT NULL DEFAULT 0,
+        unit_cost NUMERIC(14, 2),
+        location VARCHAR,
+        created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+        updated_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+        deleted_at TIMESTAMPTZ
+      );
+    `);
+
+    await queryRunner.query(`
+      CREATE TABLE IF NOT EXISTS freight.warranties (
+        id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+        vehicle_id UUID NOT NULL,
+        component VARCHAR NOT NULL,
+        provider VARCHAR,
+        start_date DATE,
+        expiry_date DATE NOT NULL,
+        coverage_notes TEXT,
+        created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+        updated_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+        deleted_at TIMESTAMPTZ
+      );
+    `);
+
+    await queryRunner.query(
+      `CREATE INDEX IF NOT EXISTS "IDX_work_orders_vehicle_id_status" ON freight.work_orders (vehicle_id, status)`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX IF NOT EXISTS "IDX_parts_category" ON freight.parts (category)`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX IF NOT EXISTS "IDX_warranties_vehicle_id_expiry_date" ON freight.warranties (vehicle_id, expiry_date)`,
+    );
+
+    await queryRunner.query(`
+      DO $$ BEGIN
+        ALTER TABLE freight.work_orders
+          ADD CONSTRAINT "FK_work_orders_vehicle_id"
+          FOREIGN KEY (vehicle_id) REFERENCES freight.vehicles(id) ON DELETE CASCADE;
+      EXCEPTION WHEN duplicate_object THEN NULL;
+      END $$;
+    `);
+
+    await queryRunner.query(`
+      DO $$ BEGIN
+        ALTER TABLE freight.warranties
+          ADD CONSTRAINT "FK_warranties_vehicle_id"
+          FOREIGN KEY (vehicle_id) REFERENCES freight.vehicles(id) ON DELETE CASCADE;
+      EXCEPTION WHEN duplicate_object THEN NULL;
+      END $$;
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`DROP TABLE IF EXISTS freight.warranties CASCADE`);
+    await queryRunner.query(`DROP TABLE IF EXISTS freight.parts CASCADE`);
+    await queryRunner.query(`DROP TABLE IF EXISTS freight.work_orders CASCADE`);
+  }
+}
diff --git a/apps/edr-freight-api/src/migrations/1980000000000-AddProcurement.ts b/apps/edr-freight-api/src/migrations/1980000000000-AddProcurement.ts
new file mode 100644
index 000000000..6d4304aaf
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/1980000000000-AddProcurement.ts
@@ -0,0 +1,73 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class AddProcurement1980000000000 implements MigrationInterface {
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      CREATE TABLE IF NOT EXISTS freight.vendors (
+        id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+        created_at timestamptz NOT NULL DEFAULT now(),
+        updated_at timestamptz NOT NULL DEFAULT now(),
+        deleted_at timestamptz,
+        name varchar NOT NULL,
+        type varchar,
+        contact_person varchar,
+        phone varchar,
+        email varchar,
+        address varchar,
+        is_active boolean NOT NULL DEFAULT true
+      );
+    `);
+
+    await queryRunner.query(`
+      CREATE TABLE IF NOT EXISTS freight.asset_acquisitions (
+        id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+        created_at timestamptz NOT NULL DEFAULT now(),
+        updated_at timestamptz NOT NULL DEFAULT now(),
+        deleted_at timestamptz,
+        vehicle_id uuid,
+        vendor_id uuid,
+        acquisition_type varchar NOT NULL,
+        acquisition_date date NOT NULL,
+        cost numeric(14,2),
+        useful_life_months integer,
+        salvage_value numeric(14,2),
+        lease_start date,
+        lease_end date,
+        monthly_payment numeric(14,2),
+        status varchar NOT NULL DEFAULT 'ACTIVE',
+        notes text
+      );
+    `);
+
+    await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS idx_asset_acquisitions_vehicle_date
+        ON freight.asset_acquisitions(vehicle_id, acquisition_date);
+    `);
+
+    await queryRunner.query(`
+      CREATE TABLE IF NOT EXISTS freight.asset_disposals (
+        id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+        created_at timestamptz NOT NULL DEFAULT now(),
+        updated_at timestamptz NOT NULL DEFAULT now(),
+        deleted_at timestamptz,
+        vehicle_id uuid NOT NULL,
+        disposal_date date NOT NULL,
+        method varchar NOT NULL,
+        sale_price numeric(14,2),
+        buyer varchar,
+        notes text
+      );
+    `);
+
+    await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS idx_asset_disposals_vehicle_date
+        ON freight.asset_disposals(vehicle_id, disposal_date);
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`DROP TABLE IF EXISTS freight.asset_disposals CASCADE;`);
+    await queryRunner.query(`DROP TABLE IF EXISTS freight.asset_acquisitions CASCADE;`);
+    await queryRunner.query(`DROP TABLE IF EXISTS freight.vendors CASCADE;`);
+  }
+}
diff --git a/apps/edr-freight-api/src/migrations/1990000000000-AddVehiclePricePerKm.ts b/apps/edr-freight-api/src/migrations/1990000000000-AddVehiclePricePerKm.ts
new file mode 100644
index 000000000..7767cd796
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/1990000000000-AddVehiclePricePerKm.ts
@@ -0,0 +1,25 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+/**
+ * Per-km haulage rate on a vehicle (mainly trucks) plus the currency it's
+ * quoted in (ETB | USD, default ETB).
+ */
+export class AddVehiclePricePerKm1990000000000 implements MigrationInterface {
+  name = "AddVehiclePricePerKm1990000000000";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      ALTER TABLE freight.vehicles
+      ADD COLUMN IF NOT EXISTS price_per_km numeric(14,2),
+      ADD COLUMN IF NOT EXISTS currency varchar(8) NOT NULL DEFAULT 'ETB'
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      ALTER TABLE freight.vehicles
+      DROP COLUMN IF EXISTS price_per_km,
+      DROP COLUMN IF EXISTS currency
+    `);
+  }
+}
diff --git a/apps/edr-freight-api/src/migrations/1990000000000-SegmentCorridorBookings.ts b/apps/edr-freight-api/src/migrations/1990000000000-SegmentCorridorBookings.ts
new file mode 100644
index 000000000..ca88ef7cd
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/1990000000000-SegmentCorridorBookings.ts
@@ -0,0 +1,75 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+/**
+ * Segment corridor bookings: a booking may ride only part of a train's route
+ * (its own origin→destination leg), so dispatch/arrival become per-booking
+ * facts and wagon capacity is consumed per leg instead of per whole route.
+ *
+ *  - bookings.loaded_at / arrived_at (+ by-user): operator-confirmed load at
+ *    the booking's origin yard and unload at its destination yard. Clearance
+ *    gates read arrived_at, not the train's actual_arrival_at.
+ *  - train_set_wagons.board_yard_id / alight_yard_id: the leg a consist slot
+ *    occupies; NULL/NULL = whole route (legacy). Non-overlapping legs coexist
+ *    without consuming each other's capacity.
+ *  - wagon_movements: auditable ledger of every physical wagon relocation
+ *    (loaded leg / empty reposition / manual correction) with the acting user.
+ */
+export class SegmentCorridorBookings1990000000000 implements MigrationInterface {
+  name = 'SegmentCorridorBookings1990000000000';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      ALTER TABLE freight.bookings
+        ADD COLUMN IF NOT EXISTS loaded_at timestamptz,
+        ADD COLUMN IF NOT EXISTS loaded_by_user_id uuid,
+        ADD COLUMN IF NOT EXISTS arrived_at timestamptz,
+        ADD COLUMN IF NOT EXISTS arrived_by_user_id uuid;
+    `);
+
+    await queryRunner.query(`
+      ALTER TABLE freight.train_set_wagons
+        ADD COLUMN IF NOT EXISTS board_yard_id uuid REFERENCES freight.yards(id) ON DELETE SET NULL,
+        ADD COLUMN IF NOT EXISTS alight_yard_id uuid REFERENCES freight.yards(id) ON DELETE SET NULL;
+    `);
+
+    await queryRunner.query(`
+      CREATE TABLE IF NOT EXISTS freight.wagon_movements (
+        id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+        wagon_id uuid NOT NULL REFERENCES freight.wagons(id) ON DELETE CASCADE,
+        from_yard_id uuid REFERENCES freight.yards(id),
+        to_yard_id uuid NOT NULL REFERENCES freight.yards(id),
+        train_schedule_id uuid REFERENCES freight.train_schedules(id) ON DELETE SET NULL,
+        booking_id uuid REFERENCES freight.bookings(id) ON DELETE SET NULL,
+        kind varchar(30) NOT NULL,
+        moved_by_user_id uuid,
+        occurred_at timestamptz NOT NULL DEFAULT now(),
+        note text,
+        created_at timestamptz NOT NULL DEFAULT now(),
+        updated_at timestamptz NOT NULL DEFAULT now(),
+        deleted_at timestamptz
+      );
+    `);
+    await queryRunner.query(
+      `CREATE INDEX IF NOT EXISTS "IDX_wagon_movements_wagon_occurred" ON freight.wagon_movements (wagon_id, occurred_at);`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX IF NOT EXISTS "IDX_wagon_movements_schedule" ON freight.wagon_movements (train_schedule_id);`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`DROP TABLE IF EXISTS freight.wagon_movements;`);
+    await queryRunner.query(`
+      ALTER TABLE freight.train_set_wagons
+        DROP COLUMN IF EXISTS board_yard_id,
+        DROP COLUMN IF EXISTS alight_yard_id;
+    `);
+    await queryRunner.query(`
+      ALTER TABLE freight.bookings
+        DROP COLUMN IF EXISTS loaded_at,
+        DROP COLUMN IF EXISTS loaded_by_user_id,
+        DROP COLUMN IF EXISTS arrived_at,
+        DROP COLUMN IF EXISTS arrived_by_user_id;
+    `);
+  }
+}
diff --git a/apps/edr-freight-api/src/migrations/2000000000000-AddCustomsPriorityConfig.ts b/apps/edr-freight-api/src/migrations/2000000000000-AddCustomsPriorityConfig.ts
new file mode 100644
index 000000000..c7009c303
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/2000000000000-AddCustomsPriorityConfig.ts
@@ -0,0 +1,83 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+/**
+ * Moves service-level priority off the service_types table and onto the
+ * admin-managed priority_configs table as a new CUSTOMS rule type.
+ *
+ *  - Drops service_types.priority_bonus_points (replaced by CUSTOMS configs).
+ *  - Widens priority_configs.type CHECK to allow 'CUSTOMS' (currency must be
+ *    null, same as WAGON).
+ *  - Seeds the two customs wagon-count tiers: 1–10 → 7 pts, 11–53 → 15 pts.
+ *    CUSTOMS rules apply only when the booking's service type includesCustoms.
+ */
+export class AddCustomsPriorityConfig2000000000000 implements MigrationInterface {
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      ALTER TABLE freight.service_types DROP COLUMN IF EXISTS priority_bonus_points;
+    `);
+
+    await queryRunner.query(`
+      ALTER TABLE freight.priority_configs
+        DROP CONSTRAINT IF EXISTS priority_configs_type_check;
+    `);
+    await queryRunner.query(`
+      ALTER TABLE freight.priority_configs
+        ADD CONSTRAINT priority_configs_type_check
+        CHECK (type IN ('WAGON', 'CURRENCY', 'CUSTOMS'));
+    `);
+
+    await queryRunner.query(`
+      ALTER TABLE freight.priority_configs
+        DROP CONSTRAINT IF EXISTS chk_currency_for_type;
+    `);
+    await queryRunner.query(`
+      ALTER TABLE freight.priority_configs
+        ADD CONSTRAINT chk_currency_for_type CHECK (
+          (type = 'WAGON' AND currency IS NULL) OR
+          (type = 'CURRENCY' AND currency IS NOT NULL) OR
+          (type = 'CUSTOMS' AND currency IS NULL)
+        );
+    `);
+
+    await queryRunner.query(`
+      INSERT INTO freight.priority_configs
+        (type, label, currency, min_wagon_count, max_wagon_count, score_points, is_active, display_order)
+      VALUES
+        ('CUSTOMS', 'With customs 1–10 wagons', NULL, 1, 10, 7, true, 1),
+        ('CUSTOMS', 'With customs 11–53 wagons', NULL, 11, 53, 15, true, 2);
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      DELETE FROM freight.priority_configs WHERE type = 'CUSTOMS';
+    `);
+
+    await queryRunner.query(`
+      ALTER TABLE freight.priority_configs
+        DROP CONSTRAINT IF EXISTS chk_currency_for_type;
+    `);
+    await queryRunner.query(`
+      ALTER TABLE freight.priority_configs
+        ADD CONSTRAINT chk_currency_for_type CHECK (
+          (type = 'WAGON' AND currency IS NULL) OR
+          (type = 'CURRENCY' AND currency IS NOT NULL)
+        );
+    `);
+
+    await queryRunner.query(`
+      ALTER TABLE freight.priority_configs
+        DROP CONSTRAINT IF EXISTS priority_configs_type_check;
+    `);
+    await queryRunner.query(`
+      ALTER TABLE freight.priority_configs
+        ADD CONSTRAINT priority_configs_type_check
+        CHECK (type IN ('WAGON', 'CURRENCY'));
+    `);
+
+    await queryRunner.query(`
+      ALTER TABLE freight.service_types
+        ADD COLUMN IF NOT EXISTS priority_bonus_points INT NOT NULL DEFAULT 0;
+    `);
+  }
+}
diff --git a/apps/edr-freight-api/src/migrations/2000000000000-AddGpsTracking.ts b/apps/edr-freight-api/src/migrations/2000000000000-AddGpsTracking.ts
new file mode 100644
index 000000000..3d440c678
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/2000000000000-AddGpsTracking.ts
@@ -0,0 +1,69 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+/**
+ * GPS tracking: physical trackers (gps_devices, one denormalized latest fix per
+ * device for the live map) + append-only fix history (gps_positions).
+ */
+export class AddGpsTracking2000000000000 implements MigrationInterface {
+  name = "AddGpsTracking2000000000000";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      CREATE TABLE IF NOT EXISTS freight.gps_devices (
+        id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+        imei varchar(20) NOT NULL UNIQUE,
+        name varchar,
+        vehicle_id uuid REFERENCES freight.vehicles(id),
+        status varchar(16) NOT NULL DEFAULT 'REGISTERED',
+        last_seen_at timestamptz,
+        last_lat numeric(10,6),
+        last_lng numeric(10,6),
+        last_speed numeric(6,2),
+        last_course int,
+        last_fix_at timestamptz,
+        voltage_level int,
+        gsm_level int,
+        created_at timestamptz NOT NULL DEFAULT now(),
+        updated_at timestamptz NOT NULL DEFAULT now(),
+        deleted_at timestamptz
+      )
+    `);
+    await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS "IDX_GPS_DEVICES_VEHICLE"
+      ON freight.gps_devices (vehicle_id)
+    `);
+
+    await queryRunner.query(`
+      CREATE TABLE IF NOT EXISTS freight.gps_positions (
+        id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+        device_id uuid NOT NULL,
+        imei varchar(20) NOT NULL,
+        vehicle_id uuid,
+        lat numeric(10,6) NOT NULL,
+        lng numeric(10,6) NOT NULL,
+        speed numeric(6,2) NOT NULL DEFAULT 0,
+        course int NOT NULL DEFAULT 0,
+        satellites int NOT NULL DEFAULT 0,
+        positioned boolean NOT NULL DEFAULT false,
+        gps_time timestamptz NOT NULL,
+        alarm int NOT NULL DEFAULT 0,
+        created_at timestamptz NOT NULL DEFAULT now(),
+        updated_at timestamptz NOT NULL DEFAULT now(),
+        deleted_at timestamptz
+      )
+    `);
+    await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS "IDX_GPS_POSITIONS_DEVICE_TIME"
+      ON freight.gps_positions (device_id, gps_time)
+    `);
+    await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS "IDX_GPS_POSITIONS_VEHICLE_TIME"
+      ON freight.gps_positions (vehicle_id, gps_time)
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`DROP TABLE IF EXISTS freight.gps_positions`);
+    await queryRunner.query(`DROP TABLE IF EXISTS freight.gps_devices`);
+  }
+}
diff --git a/apps/edr-freight-api/src/migrations/2000000000000-AddTruckDetentionTiming.ts b/apps/edr-freight-api/src/migrations/2000000000000-AddTruckDetentionTiming.ts
new file mode 100644
index 000000000..ce7bfd326
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/2000000000000-AddTruckDetentionTiming.ts
@@ -0,0 +1,32 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+/**
+ * Truck detention support.
+ *  - last_mile.arrived_at / delivered_at: the detention window for an EDR
+ *    last-mile vehicle. The clock runs from arrival at destination; the customer
+ *    has a grace period (default 3h) to clear/return, after which detention
+ *    accrues per truck per day until delivered_at (or now, if still out).
+ *  - warehouse_fee_rules.free_hours: configurable grace window (hours) for a
+ *    TRUCK_DETENTION_FEE rule; null/0 falls back to the 3-hour default.
+ */
+export class AddTruckDetentionTiming2000000000000 implements MigrationInterface {
+  name = 'AddTruckDetentionTiming2000000000000';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE freight.last_mile ADD COLUMN IF NOT EXISTS arrived_at timestamptz`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE freight.last_mile ADD COLUMN IF NOT EXISTS delivered_at timestamptz`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE freight.warehouse_fee_rules ADD COLUMN IF NOT EXISTS free_hours int`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`ALTER TABLE freight.warehouse_fee_rules DROP COLUMN IF EXISTS free_hours`);
+    await queryRunner.query(`ALTER TABLE freight.last_mile DROP COLUMN IF EXISTS delivered_at`);
+    await queryRunner.query(`ALTER TABLE freight.last_mile DROP COLUMN IF EXISTS arrived_at`);
+  }
+}
diff --git a/apps/edr-freight-api/src/migrations/2010000000000-AddConsolidationResumeStatus.ts b/apps/edr-freight-api/src/migrations/2010000000000-AddConsolidationResumeStatus.ts
new file mode 100644
index 000000000..cb6f7dc91
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/2010000000000-AddConsolidationResumeStatus.ts
@@ -0,0 +1,29 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+/**
+ * Adds bookings.consolidation_resume_status: the status a booking parked in
+ * PENDING_CONSOLIDATION returns to once it pairs with a wagon partner.
+ *
+ * Direct customer bookings leave it NULL (they resume to SUBMITTED, unchanged).
+ * Contract-drawdown bookings (GL shipments) set it to the status
+ * createUnderContract would otherwise have used (OPERATION_REQUEST_PENDING or
+ * AWAITING_DOCUMENTS), so pairing resumes them into the contract-booking flow
+ * instead of wrongly moving them to SUBMITTED.
+ */
+export class AddConsolidationResumeStatus2010000000000
+  implements MigrationInterface
+{
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      ALTER TABLE freight.bookings
+        ADD COLUMN IF NOT EXISTS consolidation_resume_status VARCHAR(40);
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      ALTER TABLE freight.bookings
+        DROP COLUMN IF EXISTS consolidation_resume_status;
+    `);
+  }
+}
diff --git a/apps/edr-freight-api/src/migrations/2010000000000-AddFeeRuleVehicleType.ts b/apps/edr-freight-api/src/migrations/2010000000000-AddFeeRuleVehicleType.ts
new file mode 100644
index 000000000..a71f3cb5b
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/2010000000000-AddFeeRuleVehicleType.ts
@@ -0,0 +1,20 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+/**
+ * Truck-detention rules can be scoped by vehicle type (TRUCK / VAN / TRAILER /
+ * TANKER / FLATBED / …), so different truck types carry different detention
+ * rates. Null = applies to any truck type.
+ */
+export class AddFeeRuleVehicleType2010000000000 implements MigrationInterface {
+  name = 'AddFeeRuleVehicleType2010000000000';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE freight.warehouse_fee_rules ADD COLUMN IF NOT EXISTS vehicle_type varchar(20)`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`ALTER TABLE freight.warehouse_fee_rules DROP COLUMN IF EXISTS vehicle_type`);
+  }
+}
diff --git a/apps/edr-freight-api/src/migrations/2020000000000-RepairOtpEmailSchema.ts b/apps/edr-freight-api/src/migrations/2020000000000-RepairOtpEmailSchema.ts
new file mode 100644
index 000000000..e11923a4d
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/2020000000000-RepairOtpEmailSchema.ts
@@ -0,0 +1,41 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+/**
+ * Repair: AddEmailToOtpVerifications1900000000000 originally altered
+ * `public.otp_verifications`, but the OtpVerification entity pins
+ * schema: "freight". On any DB where that migration already ran (and is recorded
+ * as executed, so it won't run again), the real `freight.otp_verifications` table
+ * never got the `email` column and `phone` was never made nullable — so OTP send
+ * dies with `column OtpVerification.email does not exist`.
+ *
+ * This migration re-applies the change against the correct schema. Idempotent
+ * (IF NOT EXISTS / no-op DROP NOT NULL), and guarded so it's a no-op when the
+ * freight table is absent.
+ */
+export class RepairOtpEmailSchema2020000000000 implements MigrationInterface {
+  name = "RepairOtpEmailSchema2020000000000";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    const exists = await queryRunner.hasTable("freight.otp_verifications");
+    if (!exists) return;
+
+    await queryRunner.query(`
+      ALTER TABLE freight.otp_verifications
+      ALTER COLUMN phone DROP NOT NULL
+    `);
+    await queryRunner.query(`
+      ALTER TABLE freight.otp_verifications
+      ADD COLUMN IF NOT EXISTS email varchar UNIQUE
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    const exists = await queryRunner.hasTable("freight.otp_verifications");
+    if (!exists) return;
+
+    await queryRunner.query(`
+      ALTER TABLE freight.otp_verifications
+      DROP COLUMN IF EXISTS email
+    `);
+  }
+}
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/2030000000000-AddTrainScheduleReference.ts b/apps/edr-freight-api/src/migrations/2030000000000-AddTrainScheduleReference.ts
new file mode 100644
index 000000000..a05465c53
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/2030000000000-AddTrainScheduleReference.ts
@@ -0,0 +1,58 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+/**
+ * Adds train_schedules.reference: a human-facing unique schedule number
+ * S-YYYY-NNNNN (per-year sequence, like bookings' BK-YYYY-NNNNNN).
+ *
+ *  - Adds the nullable column.
+ *  - Backfills existing rows: within each created-at year, numbers rows by
+ *    created_at ascending (oldest → S-<year>-00001). Deterministic order.
+ *  - Adds a partial unique index (NULLs allowed so a future insert can stage
+ *    the row before the app stamps its reference).
+ */
+export class AddTrainScheduleReference2030000000000
+  implements MigrationInterface
+{
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      ALTER TABLE freight.train_schedules
+        ADD COLUMN IF NOT EXISTS reference VARCHAR(20);
+    `);
+
+    // Backfill per-year, ordered by created_at (oldest = 00001). Uses the row's
+    // own created-at year as the reference year so historical rows keep a
+    // sensible number.
+    await queryRunner.query(`
+      WITH numbered AS (
+        SELECT
+          id,
+          EXTRACT(YEAR FROM created_at)::int AS yr,
+          ROW_NUMBER() OVER (
+            PARTITION BY EXTRACT(YEAR FROM created_at)
+            ORDER BY created_at ASC, id ASC
+          ) AS seq
+        FROM freight.train_schedules
+        WHERE reference IS NULL
+      )
+      UPDATE freight.train_schedules ts
+      SET reference = 'S-' || numbered.yr || '-' || LPAD(numbered.seq::text, 5, '0')
+      FROM numbered
+      WHERE ts.id = numbered.id;
+    `);
+
+    await queryRunner.query(`
+      CREATE UNIQUE INDEX IF NOT EXISTS ux_train_schedules_reference
+        ON freight.train_schedules (reference)
+        WHERE reference IS NOT NULL;
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      DROP INDEX IF EXISTS freight.ux_train_schedules_reference;
+    `);
+    await queryRunner.query(`
+      ALTER TABLE freight.train_schedules DROP COLUMN IF EXISTS reference;
+    `);
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/bookings/booking-list-tabs.config.ts b/apps/edr-freight-api/src/modules/bookings/booking-list-tabs.config.ts
index 2140a7688..9ef951853 100644
--- a/apps/edr-freight-api/src/modules/bookings/booking-list-tabs.config.ts
+++ b/apps/edr-freight-api/src/modules/bookings/booking-list-tabs.config.ts
@@ -28,7 +28,7 @@ export const BOOKING_LIST_TABS: ReadonlyArray<{
   { key: 'payment', statuses: ['FULLY_EXECUTED'] },
   {
     key: 'operations',
-    statuses: ['IN_TRANSIT', 'PAID'],
+    statuses: ['IN_TRANSIT', 'ARRIVED', 'PAID'],
   },
   { key: 'completed', statuses: ['COMPLETED'] },
   { key: 'closed', statuses: ['REJECTED', 'CANCELLED'] },
diff --git a/apps/edr-freight-api/src/modules/bookings/booking-next-step.util.ts b/apps/edr-freight-api/src/modules/bookings/booking-next-step.util.ts
index ac6e35b56..d93b5b7bd 100644
--- a/apps/edr-freight-api/src/modules/bookings/booking-next-step.util.ts
+++ b/apps/edr-freight-api/src/modules/bookings/booking-next-step.util.ts
@@ -102,6 +102,7 @@ export function computeNextStep(
         description: 'Mark shipment as in transit',
       };
     case 'IN_TRANSIT':
+    case 'ARRIVED':
       return {
         action: 'COMPLETE',
         description: 'Mark shipment complete',
diff --git a/apps/edr-freight-api/src/modules/bookings/booking-transition.service.ts b/apps/edr-freight-api/src/modules/bookings/booking-transition.service.ts
index b5c277073..8b6e8a2f8 100644
--- a/apps/edr-freight-api/src/modules/bookings/booking-transition.service.ts
+++ b/apps/edr-freight-api/src/modules/bookings/booking-transition.service.ts
@@ -485,7 +485,7 @@ export class BookingTransitionService {
 
   async complete(bookingId: string): Promise<Booking> {
     const booking = await this.bookingsService.findById(bookingId);
-    assertBookingStatus(booking, ["IN_TRANSIT"]);
+    assertBookingStatus(booking, ["IN_TRANSIT", "ARRIVED"]);
 
     const updated = await this.bookingsRepository.update(bookingId, {
       status: "COMPLETED",
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..79d94f3de 100644
--- a/apps/edr-freight-api/src/modules/bookings/bookings.controller.ts
+++ b/apps/edr-freight-api/src/modules/bookings/bookings.controller.ts
@@ -350,6 +350,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 61dc78e13..48c5b628b 100644
--- a/apps/edr-freight-api/src/modules/bookings/bookings.module.ts
+++ b/apps/edr-freight-api/src/modules/bookings/bookings.module.ts
@@ -114,6 +114,7 @@ import { VehiclesModule } from "../vehicles/vehicles.module";
     BookingPricingService,
     BookingInvoiceService,
     BookingLifecycleNotifierService,
+    ConsolidationService,
     CustomerTruckService,
     ContainerReceiptService,
   ],
diff --git a/apps/edr-freight-api/src/modules/bookings/bookings.repository.ts b/apps/edr-freight-api/src/modules/bookings/bookings.repository.ts
index ccdab3379..fa11fc66c 100644
--- a/apps/edr-freight-api/src/modules/bookings/bookings.repository.ts
+++ b/apps/edr-freight-api/src/modules/bookings/bookings.repository.ts
@@ -272,26 +272,51 @@ export class BookingsRepository extends BaseRepository<Booking> {
   }
 
   /**
-   * Pair two bookings for consolidation. Both return to SUBMITTED so staff can
-   * accept them into the approval chain; the link itself (consolidationPartnerId)
-   * marks them as consolidated in the UI.
+   * Pair two bookings for consolidation. Each returns to its own resume status —
+   * SUBMITTED for a direct customer booking (so staff can accept it into the
+   * approval chain) or the stored consolidationResumeStatus for a contract
+   * drawdown (OPERATION_REQUEST_PENDING / AWAITING_DOCUMENTS). The link itself
+   * (consolidationPartnerId) marks them as consolidated in the UI. The resume
+   * status is cleared once used, so a later un-pair re-parks cleanly.
    */
   async pairConsolidation(bookingId: string, partnerId: string): Promise<void> {
+    const [booking, partner] = await Promise.all([
+      this.repository.findOne({
+        where: { id: bookingId },
+        select: { id: true, consolidationResumeStatus: true },
+      }),
+      this.repository.findOne({
+        where: { id: partnerId },
+        select: { id: true, consolidationResumeStatus: true },
+      }),
+    ]);
+
     await this.repository.update(bookingId, {
       consolidationPartnerId: partnerId,
-      status: 'SUBMITTED',
+      status: booking?.consolidationResumeStatus ?? 'SUBMITTED',
+      consolidationResumeStatus: null,
     } as never);
     await this.repository.update(partnerId, {
       consolidationPartnerId: bookingId,
-      status: 'SUBMITTED',
+      status: partner?.consolidationResumeStatus ?? 'SUBMITTED',
+      consolidationResumeStatus: null,
     } as never);
   }
 
-  /** Park a booking that needs consolidation but has no partner yet. */
-  async parkForConsolidation(bookingId: string): Promise<void> {
+  /**
+   * Park a booking that needs consolidation but has no partner yet. The optional
+   * resumeStatus is where the booking returns once it pairs — pass it for a
+   * contract drawdown so pairing resumes the contract-booking flow rather than
+   * the direct-booking SUBMITTED default.
+   */
+  async parkForConsolidation(
+    bookingId: string,
+    resumeStatus?: string | null,
+  ): Promise<void> {
     await this.repository.update(bookingId, {
       consolidationPartnerId: null,
       status: 'PENDING_CONSOLIDATION',
+      consolidationResumeStatus: resumeStatus ?? null,
     } as never);
   }
 
@@ -1019,6 +1044,81 @@ export class BookingsRepository extends BaseRepository<Booking> {
       .getMany();
   }
 
+  /**
+   * Corridor day pool: ready, not-yet-allocated bookings for one EAT day whose
+   * origin AND destination both lie on the day's corridor stop set — covers
+   * full-route bookings and sub-corridor bookings (Dire→Djibouti on an
+   * Addis→…→Djibouti train). The caller still verifies stop ORDER per train
+   * via the corridor budget; this query only narrows the pool. Same status
+   * rules and ordering as {@link findBatchPool}.
+   */
+  findBatchPoolByCorridorDay(
+    corridorYardIds: string[],
+    day: string,
+  ): Promise<Booking[]> {
+    if (corridorYardIds.length === 0) return Promise.resolve([]);
+    return this.repository
+      .createQueryBuilder('booking')
+      .leftJoinAndSelect('booking.company', 'company')
+      .leftJoinAndSelect('booking.bookingContainers', 'bookingContainer')
+      .leftJoin(TrainScheduleBooking, 'sb', 'sb.booking_id = booking.id')
+      .where('booking.origin_yard_id IN (:...corridorYardIds)', { corridorYardIds })
+      .andWhere('booking.destination_yard_id IN (:...corridorYardIds)', {
+        corridorYardIds,
+      })
+      .andWhere(
+        `DATE(booking.scheduled_date AT TIME ZONE 'Africa/Addis_Ababa') = :day`,
+        { day },
+      )
+      .andWhere('sb.id IS NULL')
+      .andWhere(
+        `((booking.is_government = false AND booking.status = 'FULLY_EXECUTED')
+          OR (booking.is_government = true AND booking.status IN ('APPROVED','PAID')))`,
+      )
+      .orderBy('booking.is_government', 'DESC')
+      .addOrderBy('booking.priority_score', 'DESC')
+      .addOrderBy('booking.fully_executed_at', 'ASC')
+      .addOrderBy('booking.created_at', 'ASC')
+      .getMany();
+  }
+
+  /**
+   * Commercial bookings on the day's corridor whose operation request was NOT
+   * accepted by staff (still pending / changes / price-confirm) and are not yet
+   * linked to a train. These never reached FULLY_EXECUTED, so they never enter the
+   * batch pool; the window's doc-review end sweeps them to EXPIRED. Government
+   * bookings are excluded (they don't go through the customer window).
+   */
+  findUnacceptedForRouteDay(
+    corridorYardIds: string[],
+    day: string,
+  ): Promise<Booking[]> {
+    if (corridorYardIds.length === 0) return Promise.resolve([]);
+    return this.repository
+      .createQueryBuilder('booking')
+      .leftJoinAndSelect('booking.company', 'company')
+      .leftJoin(TrainScheduleBooking, 'sb', 'sb.booking_id = booking.id')
+      .where('booking.origin_yard_id IN (:...corridorYardIds)', { corridorYardIds })
+      .andWhere('booking.destination_yard_id IN (:...corridorYardIds)', {
+        corridorYardIds,
+      })
+      .andWhere(
+        `DATE(booking.scheduled_date AT TIME ZONE 'Africa/Addis_Ababa') = :day`,
+        { day },
+      )
+      .andWhere('sb.id IS NULL')
+      .andWhere('booking.is_government = false')
+      .andWhere(
+        `booking.status IN (
+          'OPERATION_REQUESTED',
+          'OPERATION_REQUEST_PENDING',
+          'OPERATION_CHANGES_REQUESTED',
+          'OPERATION_PRICE_PENDING_CONFIRM'
+        )`,
+      )
+      .getMany();
+  }
+
   /** Every booking that targeted a schedule (any status) — for the batch monitoring board. */
   findAllBySchedule(scheduleId: string): Promise<Booking[]> {
     return this.repository
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 1fb37dc31..a5f25ad21 100644
--- a/apps/edr-freight-api/src/modules/bookings/bookings.service.ts
+++ b/apps/edr-freight-api/src/modules/bookings/bookings.service.ts
@@ -24,6 +24,7 @@ import {
   RuleEngineService,
 } from '../rule-engine/rule-engine.service';
 import { InjectDataSource } from '@nestjs/typeorm';
+import { EventEmitter2 } from '@nestjs/event-emitter';
 import { DataSource, In } from 'typeorm';
 
 import { deriveTradeDirection } from '../../common/derive-trade-direction.util';
@@ -99,6 +100,7 @@ export class BookingsService {
     private readonly consolidationService: ConsolidationService,
     private readonly vehiclesService: VehiclesService,
     private readonly contractPdfService: ContractPdfService,
+    private readonly events: EventEmitter2,
   ) {}
 
   async assignCustomerTruck(
@@ -493,6 +495,14 @@ export class BookingsService {
       messages.push(
         this.consolidationService.describePaired(partner.reference, slots),
       );
+      // Let deferred owners (e.g. contract drawdowns whose invoice/milestones
+      // were held while the booking waited) finalize now that a whole wagon
+      // exists. Fire-and-forget: a listener failure must not undo the pairing.
+      this.events
+        .emitAsync('booking.consolidation.paired', {
+          bookingIds: [booking.id, partner.id],
+        })
+        .catch(() => undefined);
       return { booking: paired, messages };
     }
 
@@ -605,10 +615,15 @@ export class BookingsService {
       if (schedule.bookingWindowStatus !== 'OPEN') {
         throw new BadRequestException('Selected schedule is no longer accepting bookings');
       }
-      if (
-        schedule.originStationId !== dto.originYardId ||
-        schedule.destinationStationId !== dto.destinationYardId
-      ) {
+      // Corridor-aware: the booking's leg must lie on the schedule's route in
+      // stop order — sub-corridor pins (Dire→Djibouti on an Addis→Djibouti
+      // train) are valid.
+      const stops = await this.trainSchedulingService.stopYardsForSchedule(
+        schedule,
+      );
+      const fromIdx = stops.indexOf(dto.originYardId);
+      const toIdx = stops.indexOf(dto.destinationYardId);
+      if (fromIdx < 0 || toIdx < 0 || fromIdx >= toIdx) {
         throw new BadRequestException('Selected schedule is not on the booking route');
       }
     } else if (dto.scheduledDate) {
@@ -1278,6 +1293,14 @@ export class BookingsService {
   ): Promise<Freight.IBookingTracking> {
     const booking = await this.findById(bookingId);
 
+    const journey = {
+      bookingStatus: booking.status ?? null,
+      bookingOriginYardId: booking.originYardId ?? null,
+      bookingDestinationYardId: booking.destinationYardId ?? null,
+      loadedAt: booking.loadedAt ? new Date(booking.loadedAt).toISOString() : null,
+      arrivedAt: booking.arrivedAt ? new Date(booking.arrivedAt).toISOString() : null,
+    };
+
     const empty: Freight.IBookingTracking = {
       bookingId: booking.id,
       bookingReference: booking.reference,
@@ -1295,6 +1318,7 @@ export class BookingsService {
       actualArrivalAt: null,
       scheduledDepartureAt: null,
       scheduledArrivalAt: null,
+      ...journey,
     };
 
     if (!booking.trainScheduleId) {
@@ -1331,6 +1355,7 @@ export class BookingsService {
       actualArrivalAt: track.actualArrivalAt,
       scheduledDepartureAt: track.scheduledDepartureAt,
       scheduledArrivalAt: track.scheduledArrivalAt,
+      ...journey,
     };
   }
 
@@ -1607,7 +1632,7 @@ export class BookingsService {
     if (!booking.isGovernment) {
       throw new BadRequestException('Only government bookings can be expedited');
     }
-    const blocked = ['PAID', 'IN_TRANSIT', 'COMPLETED', 'CANCELLED', 'REJECTED'];
+    const blocked = ['PAID', 'IN_TRANSIT', 'ARRIVED', 'COMPLETED', 'CANCELLED', 'REJECTED'];
     if (blocked.includes(booking.status)) {
       throw new BadRequestException(`Cannot expedite booking in status ${booking.status}`);
     }
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..693b60e09 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,16 +42,16 @@ 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');
     }
 
@@ -68,6 +68,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 +140,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.
@@ -244,7 +321,7 @@ 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 });
       await manager.getRepository(CustomerTruckContainer).save(
@@ -256,18 +333,19 @@ export class CustomerTruckService {
           }),
         ),
       );
-      // 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 +354,7 @@ export class CustomerTruckService {
           AND bcu.deleted_at IS NULL`,
       [bookingId, numbers],
     );
-    return Number(row?.kg ?? 0);
+    return Number(row?.tons ?? 0);
   }
 
   /**
@@ -399,4 +477,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/booking.entity.ts b/apps/edr-freight-api/src/modules/bookings/entities/booking.entity.ts
index cf0ca76f6..398c64809 100644
--- a/apps/edr-freight-api/src/modules/bookings/entities/booking.entity.ts
+++ b/apps/edr-freight-api/src/modules/bookings/entities/booking.entity.ts
@@ -37,6 +37,7 @@ export const BOOKING_STATUSES = [
   'PAYMENT_VERIFICATION_IN_PROGRESS',
   'PAID',
   'IN_TRANSIT',
+  'ARRIVED',
   'COMPLETED',
   'REJECTED',
   'CANCELLED',
@@ -430,6 +431,14 @@ export class Booking extends BaseEntity {
   @JoinColumn({ name: 'consolidation_partner_id' })
   consolidationPartner?: Booking | null;
 
+  // Status a booking parked in PENDING_CONSOLIDATION returns to once it pairs.
+  // Null for direct customer bookings (they resume to SUBMITTED, the historical
+  // default); contract-drawdown bookings set it to the status createUnderContract
+  // would otherwise have used (OPERATION_REQUEST_PENDING / AWAITING_DOCUMENTS), so
+  // pairing resumes them into the right flow instead of the direct-booking one.
+  @Column({ name: 'consolidation_resume_status', type: 'varchar', length: 40, nullable: true })
+  consolidationResumeStatus?: string | null;
+
   @Column({ name: 'wagons_required', type: 'numeric', precision: 6, scale: 2, nullable: true })
   wagonsRequired?: number | null;
 
@@ -458,6 +467,24 @@ export class Booking extends BaseEntity {
   @Column({ name: 'train_schedule_id', type: 'uuid', nullable: true })
   trainScheduleId?: string | null;
 
+  // ── Per-booking journey (segment corridor bookings) ────────────────────────
+  // A booking rides only its own origin→destination leg of the train's route,
+  // so dispatch/arrival are per-booking facts, not train facts. Clearance gates
+  // read arrivedAt (booking arrival), never the schedule's actualArrivalAt.
+  /** Operator confirmed cargo loaded at the booking's origin yard (per-booking dispatch). */
+  @Column({ name: 'loaded_at', type: 'timestamptz', nullable: true })
+  loadedAt?: Date | null;
+
+  @Column({ name: 'loaded_by_user_id', type: 'uuid', nullable: true })
+  loadedByUserId?: string | null;
+
+  /** Operator confirmed cargo unloaded at the booking's destination yard (per-booking arrival). */
+  @Column({ name: 'arrived_at', type: 'timestamptz', nullable: true })
+  arrivedAt?: Date | null;
+
+  @Column({ name: 'arrived_by_user_id', type: 'uuid', nullable: true })
+  arrivedByUserId?: string | null;
+
   /** End of the pay window once the booking is SELECTED_FOR_BATCH. */
   @Column({ name: 'payment_deadline', type: 'timestamptz', nullable: true })
   paymentDeadline?: Date | null;
diff --git a/apps/edr-freight-api/src/modules/companies/company-dashboard.repository.ts b/apps/edr-freight-api/src/modules/companies/company-dashboard.repository.ts
index 842a36616..aa9a31f49 100644
--- a/apps/edr-freight-api/src/modules/companies/company-dashboard.repository.ts
+++ b/apps/edr-freight-api/src/modules/companies/company-dashboard.repository.ts
@@ -21,6 +21,7 @@ const COMMITTED_STATUSES = [
   'PAYMENT_VERIFICATION_IN_PROGRESS',
   'PAID',
   'IN_TRANSIT',
+  'ARRIVED',
   'COMPLETED',
   'DELIVERED',
   'CONSOLIDATED',
diff --git a/apps/edr-freight-api/src/modules/compliance/compliance.controller.ts b/apps/edr-freight-api/src/modules/compliance/compliance.controller.ts
new file mode 100644
index 000000000..2a5715647
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/compliance/compliance.controller.ts
@@ -0,0 +1,53 @@
+import { Controller, Post, Get, Patch, Delete, Body, Param, Query } from '@nestjs/common';
+import { ApiTags, ApiOperation } from '@nestjs/swagger';
+import { ComplianceService } from './compliance.service';
+import {
+  CreateComplianceRecordDto,
+  UpdateComplianceRecordDto,
+} from './dto/create-compliance-record.dto';
+import { ComplianceType } from './entities/compliance-record.entity';
+
+@ApiTags('Vehicle Compliance')
+@Controller('compliance')
+export class ComplianceController {
+  constructor(private readonly complianceService: ComplianceService) {}
+
+  @Post()
+  @ApiOperation({ summary: 'Create a compliance record' })
+  create(@Body() dto: CreateComplianceRecordDto) {
+    return this.complianceService.create(dto);
+  }
+
+  @Get()
+  @ApiOperation({ summary: 'List compliance records' })
+  findAll(
+    @Query('vehicleId') vehicleId?: string,
+    @Query('type') type?: ComplianceType,
+  ) {
+    return this.complianceService.findAll({ vehicleId, type });
+  }
+
+  @Get('alerts')
+  @ApiOperation({ summary: 'List overdue / due-soon compliance & expiry alerts' })
+  getAlerts() {
+    return this.complianceService.getAlerts();
+  }
+
+  @Get(':id')
+  @ApiOperation({ summary: 'Get a compliance record by ID' })
+  findOne(@Param('id') id: string) {
+    return this.complianceService.findById(id);
+  }
+
+  @Patch(':id')
+  @ApiOperation({ summary: 'Update a compliance record' })
+  update(@Param('id') id: string, @Body() dto: UpdateComplianceRecordDto) {
+    return this.complianceService.update(id, dto);
+  }
+
+  @Delete(':id')
+  @ApiOperation({ summary: 'Soft-delete a compliance record' })
+  remove(@Param('id') id: string) {
+    return this.complianceService.remove(id);
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/compliance/compliance.module.ts b/apps/edr-freight-api/src/modules/compliance/compliance.module.ts
new file mode 100644
index 000000000..1477fbc8b
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/compliance/compliance.module.ts
@@ -0,0 +1,16 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { ComplianceRecord } from './entities/compliance-record.entity';
+import { Vehicle } from '../vehicles/entities/vehicle.entity';
+import { Driver } from '../drivers/entities/driver.entity';
+import { ComplianceService } from './compliance.service';
+import { ComplianceRepository } from './compliance.repository';
+import { ComplianceController } from './compliance.controller';
+
+@Module({
+  imports: [TypeOrmModule.forFeature([ComplianceRecord, Vehicle, Driver])],
+  providers: [ComplianceService, ComplianceRepository],
+  controllers: [ComplianceController],
+  exports: [ComplianceService],
+})
+export class ComplianceModule {}
diff --git a/apps/edr-freight-api/src/modules/compliance/compliance.repository.ts b/apps/edr-freight-api/src/modules/compliance/compliance.repository.ts
new file mode 100644
index 000000000..e9764f8a4
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/compliance/compliance.repository.ts
@@ -0,0 +1,26 @@
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { BaseRepository } from '@edr/api-common';
+import { Repository, FindOptionsWhere } from 'typeorm';
+import { ComplianceRecord, ComplianceType } from './entities/compliance-record.entity';
+
+@Injectable()
+export class ComplianceRepository extends BaseRepository<ComplianceRecord> {
+  constructor(
+    @InjectRepository(ComplianceRecord)
+    private readonly complianceRepository: Repository<ComplianceRecord>,
+  ) {
+    super(complianceRepository);
+  }
+
+  async findWithFilters(filter: { vehicleId?: string; type?: ComplianceType } = {}) {
+    const where: FindOptionsWhere<ComplianceRecord> = {};
+    if (filter.vehicleId) where.vehicleId = filter.vehicleId;
+    if (filter.type) where.type = filter.type;
+
+    return this.complianceRepository.find({
+      where,
+      order: { expiryDate: 'ASC' },
+    });
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/compliance/compliance.service.ts b/apps/edr-freight-api/src/modules/compliance/compliance.service.ts
new file mode 100644
index 000000000..ec6e2a803
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/compliance/compliance.service.ts
@@ -0,0 +1,184 @@
+import { Injectable, NotFoundException } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { In, IsNull, Repository } from 'typeorm';
+import { ComplianceRepository } from './compliance.repository';
+import {
+  ComplianceRecord,
+  ComplianceStatus,
+  ComplianceType,
+} from './entities/compliance-record.entity';
+import {
+  CreateComplianceRecordDto,
+  UpdateComplianceRecordDto,
+} from './dto/create-compliance-record.dto';
+import { Vehicle } from '../vehicles/entities/vehicle.entity';
+import { Driver } from '../drivers/entities/driver.entity';
+
+const DUE_SOON_DAYS = 30;
+const MS_PER_DAY = 24 * 60 * 60 * 1000;
+
+export type AlertSeverity = 'OVERDUE' | 'DUE_SOON';
+
+export interface ComplianceAlert {
+  vehicleId: string;
+  vehiclePlate?: string;
+  kind: string;
+  label: string;
+  expiryDate: string;
+  daysUntil: number;
+  severity: AlertSeverity;
+}
+
+@Injectable()
+export class ComplianceService {
+  constructor(
+    private readonly complianceRepository: ComplianceRepository,
+    @InjectRepository(Vehicle)
+    private readonly vehicleRepo: Repository<Vehicle>,
+    @InjectRepository(Driver)
+    private readonly driverRepo: Repository<Driver>,
+  ) {}
+
+  async create(dto: CreateComplianceRecordDto): Promise<ComplianceRecord> {
+    return this.complianceRepository.create({
+      ...dto,
+      status: dto.status ?? this.deriveStatus(dto.expiryDate),
+    });
+  }
+
+  async findAll(filter: { vehicleId?: string; type?: ComplianceType } = {}) {
+    return this.complianceRepository.findWithFilters(filter);
+  }
+
+  async findById(id: string): Promise<ComplianceRecord> {
+    const record = await this.complianceRepository.findById(id);
+    if (!record) {
+      throw new NotFoundException(`Compliance record ${id} not found`);
+    }
+    return record;
+  }
+
+  async update(id: string, dto: UpdateComplianceRecordDto): Promise<ComplianceRecord> {
+    await this.findById(id);
+    const nextExpiry = dto.expiryDate;
+    const updated = await this.complianceRepository.update(id, {
+      ...dto,
+      // Re-derive status when expiry changes and the caller didn't set it explicitly.
+      status: dto.status ?? (nextExpiry ? this.deriveStatus(nextExpiry) : undefined),
+    });
+    return updated!;
+  }
+
+  async remove(id: string): Promise<void> {
+    await this.findById(id);
+    await this.complianceRepository.softDelete(id);
+  }
+
+  /**
+   * Flat list of compliance items that are overdue or due within 30 days.
+   * Combines the compliance_records table with the vehicle expiry columns
+   * (insurance / registration / next inspection) and assigned-driver license
+   * expiry. `new Date()` is fine here — this is the NestJS API runtime.
+   */
+  async getAlerts(): Promise<ComplianceAlert[]> {
+    const now = new Date();
+    const alerts: ComplianceAlert[] = [];
+
+    const vehicles = await this.vehicleRepo.find({ where: { deletedAt: IsNull() } });
+    const vehicleById = new Map(vehicles.map((v) => [v.id, v]));
+    const plateOf = (v?: Vehicle) => v?.plateNumber ?? v?.code ?? undefined;
+
+    // 1. Compliance records
+    const records = await this.complianceRepository.findWithFilters();
+    for (const record of records) {
+      const computed = this.computeSeverity(record.expiryDate, now);
+      if (!computed) continue;
+      const vehicle = vehicleById.get(record.vehicleId);
+      alerts.push({
+        vehicleId: record.vehicleId,
+        vehiclePlate: plateOf(vehicle),
+        kind: record.type,
+        label: record.documentNumber
+          ? `${record.type} · ${record.documentNumber}`
+          : record.type,
+        expiryDate: record.expiryDate,
+        daysUntil: computed.daysUntil,
+        severity: computed.severity,
+      });
+    }
+
+    // 2. Vehicle-level expiry columns
+    const vehicleFields: { field: keyof Vehicle; kind: string; label: string }[] = [
+      { field: 'insuranceExpiry', kind: 'INSURANCE', label: 'Insurance' },
+      { field: 'registrationExpiry', kind: 'REGISTRATION', label: 'Registration' },
+      { field: 'nextInspectionDate', kind: 'INSPECTION', label: 'Inspection' },
+    ];
+    for (const vehicle of vehicles) {
+      for (const { field, kind, label } of vehicleFields) {
+        const value = vehicle[field] as string | undefined;
+        if (!value) continue;
+        const computed = this.computeSeverity(value, now);
+        if (!computed) continue;
+        alerts.push({
+          vehicleId: vehicle.id,
+          vehiclePlate: plateOf(vehicle),
+          kind,
+          label,
+          expiryDate: value,
+          daysUntil: computed.daysUntil,
+          severity: computed.severity,
+        });
+      }
+    }
+
+    // 3. Assigned-driver license expiry
+    const driverIds = [
+      ...new Set(vehicles.map((v) => v.assignedDriverId).filter((id): id is string => !!id)),
+    ];
+    if (driverIds.length > 0) {
+      const drivers = await this.driverRepo.find({ where: { id: In(driverIds) } });
+      const driverById = new Map(drivers.map((d) => [d.id, d]));
+      for (const vehicle of vehicles) {
+        if (!vehicle.assignedDriverId) continue;
+        const driver = driverById.get(vehicle.assignedDriverId);
+        if (!driver?.licenseExpiryDate) continue;
+        const expiry =
+          driver.licenseExpiryDate instanceof Date
+            ? driver.licenseExpiryDate.toISOString().slice(0, 10)
+            : String(driver.licenseExpiryDate);
+        const computed = this.computeSeverity(expiry, now);
+        if (!computed) continue;
+        alerts.push({
+          vehicleId: vehicle.id,
+          vehiclePlate: plateOf(vehicle),
+          kind: 'DRIVER_LICENSE',
+          label: `Driver License · ${driver.firstName ?? ''} ${driver.lastName ?? ''}`.trim(),
+          expiryDate: expiry,
+          daysUntil: computed.daysUntil,
+          severity: computed.severity,
+        });
+      }
+    }
+
+    return alerts.sort((a, b) => a.daysUntil - b.daysUntil);
+  }
+
+  private computeSeverity(
+    expiryDate: string,
+    now: Date,
+  ): { daysUntil: number; severity: AlertSeverity } | null {
+    const daysUntil = Math.ceil((new Date(expiryDate).getTime() - now.getTime()) / MS_PER_DAY);
+    if (daysUntil < 0) return { daysUntil, severity: 'OVERDUE' };
+    if (daysUntil <= DUE_SOON_DAYS) return { daysUntil, severity: 'DUE_SOON' };
+    return null;
+  }
+
+  private deriveStatus(expiryDate: string): ComplianceStatus {
+    const daysUntil = Math.ceil(
+      (new Date(expiryDate).getTime() - Date.now()) / MS_PER_DAY,
+    );
+    if (daysUntil < 0) return ComplianceStatus.EXPIRED;
+    if (daysUntil <= DUE_SOON_DAYS) return ComplianceStatus.EXPIRING;
+    return ComplianceStatus.VALID;
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/compliance/dto/create-compliance-record.dto.ts b/apps/edr-freight-api/src/modules/compliance/dto/create-compliance-record.dto.ts
new file mode 100644
index 000000000..8b716ef15
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/compliance/dto/create-compliance-record.dto.ts
@@ -0,0 +1,55 @@
+import { IsUUID, IsString, IsDateString, IsOptional, IsEnum } from 'class-validator';
+import { ComplianceType, ComplianceStatus } from '../entities/compliance-record.entity';
+
+export class CreateComplianceRecordDto {
+  @IsUUID()
+  vehicleId!: string;
+
+  @IsEnum(ComplianceType)
+  type!: ComplianceType;
+
+  @IsOptional()
+  @IsString()
+  documentNumber?: string;
+
+  @IsOptional()
+  @IsDateString()
+  issuedDate?: string;
+
+  @IsDateString()
+  expiryDate!: string;
+
+  @IsOptional()
+  @IsEnum(ComplianceStatus)
+  status?: ComplianceStatus;
+
+  @IsOptional()
+  @IsString()
+  notes?: string;
+}
+
+export class UpdateComplianceRecordDto {
+  @IsOptional()
+  @IsEnum(ComplianceType)
+  type?: ComplianceType;
+
+  @IsOptional()
+  @IsString()
+  documentNumber?: string;
+
+  @IsOptional()
+  @IsDateString()
+  issuedDate?: string;
+
+  @IsOptional()
+  @IsDateString()
+  expiryDate?: string;
+
+  @IsOptional()
+  @IsEnum(ComplianceStatus)
+  status?: ComplianceStatus;
+
+  @IsOptional()
+  @IsString()
+  notes?: string;
+}
diff --git a/apps/edr-freight-api/src/modules/compliance/entities/compliance-record.entity.ts b/apps/edr-freight-api/src/modules/compliance/entities/compliance-record.entity.ts
new file mode 100644
index 000000000..04355c1f9
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/compliance/entities/compliance-record.entity.ts
@@ -0,0 +1,46 @@
+import { BaseEntity } from '@edr/api-common';
+import { Entity, Column, ManyToOne, JoinColumn, Index } from 'typeorm';
+import { Vehicle } from '../../vehicles/entities/vehicle.entity';
+
+export enum ComplianceType {
+  INSPECTION = 'INSPECTION',
+  INSURANCE = 'INSURANCE',
+  ROADWORTHINESS = 'ROADWORTHINESS',
+  PERMIT = 'PERMIT',
+  TAX = 'TAX',
+}
+
+export enum ComplianceStatus {
+  VALID = 'VALID',
+  EXPIRING = 'EXPIRING',
+  EXPIRED = 'EXPIRED',
+}
+
+@Entity({ name: 'compliance_records', schema: 'freight' })
+@Index(['vehicleId', 'expiryDate'])
+export class ComplianceRecord extends BaseEntity {
+  @Column({ name: 'vehicle_id', type: 'uuid' })
+  vehicleId!: string;
+
+  @ManyToOne(() => Vehicle, { eager: false, nullable: false })
+  @JoinColumn({ name: 'vehicle_id' })
+  vehicle!: Vehicle;
+
+  @Column({ name: 'type', type: 'varchar' })
+  type!: ComplianceType;
+
+  @Column({ name: 'document_number', type: 'varchar', nullable: true })
+  documentNumber?: string;
+
+  @Column({ name: 'issued_date', type: 'date', nullable: true })
+  issuedDate?: string;
+
+  @Column({ name: 'expiry_date', type: 'date' })
+  expiryDate!: string;
+
+  @Column({ name: 'status', type: 'varchar', default: ComplianceStatus.VALID })
+  status!: ComplianceStatus;
+
+  @Column({ name: 'notes', type: 'text', nullable: true })
+  notes?: string;
+}
diff --git a/apps/edr-freight-api/src/modules/contracts/booking-clearance.service.ts b/apps/edr-freight-api/src/modules/contracts/booking-clearance.service.ts
index eeea43a39..59dad2248 100644
--- a/apps/edr-freight-api/src/modules/contracts/booking-clearance.service.ts
+++ b/apps/edr-freight-api/src/modules/contracts/booking-clearance.service.ts
@@ -176,7 +176,28 @@ export class BookingClearanceService {
     }
 
     const allApproved = await this.isClearanceFullyApproved(booking);
-    const milestones = await this.workflowService.listMilestonesForBooking(bookingId);
+    let milestones = await this.workflowService.listMilestonesForBooking(bookingId);
+
+    // Self-heal: a booking that has settled its freight payment must have
+    // FREIGHT_PAYMENT_SETTLED completed. The batch settle path writes it, but an
+    // export FCFS booking (linked to its train at booking time) paid via the
+    // prepaid invoice can leave the milestone PENDING — the clearance "Payment &
+    // wagon allocation" step then never ticks. Backfill it here so already-stuck
+    // rows recover without a migration; idempotent (no-op once COMPLETED).
+    const paymentSettled = milestones.find(
+      (m) => m.milestoneCode === 'FREIGHT_PAYMENT_SETTLED',
+    );
+    if (
+      paymentSettled &&
+      paymentSettled.status === 'PENDING' &&
+      (booking.paymentStatus === 'PAID' || booking.status === 'PAID')
+    ) {
+      await this.workflowService.completeMilestoneForBooking(
+        bookingId,
+        'FREIGHT_PAYMENT_SETTLED',
+      );
+      milestones = await this.workflowService.listMilestonesForBooking(bookingId);
+    }
     const phase = this.workflowService.resolvePhaseForBooking(booking, milestones);
     const nextAction = this.workflowService.computeNextActionForBooking(booking, milestones);
     const boundary = await this.workflowService.isBoundaryCompleteForBooking(
diff --git a/apps/edr-freight-api/src/modules/contracts/clearance-milestone.service.ts b/apps/edr-freight-api/src/modules/contracts/clearance-milestone.service.ts
index e033f8e9b..4a58e50be 100644
--- a/apps/edr-freight-api/src/modules/contracts/clearance-milestone.service.ts
+++ b/apps/edr-freight-api/src/modules/contracts/clearance-milestone.service.ts
@@ -6,6 +6,7 @@ import {
   CustomsRiskLevel,
   MilestoneMetadata,
 } from './entities/clearance-milestone.entity';
+import { Booking } from '../bookings/entities/booking.entity';
 import { Contract } from './entities/contract.entity';
 import {
   HANDOFF_MILESTONES,
@@ -85,10 +86,36 @@ export class ClearanceMilestoneService {
   }
 
   async listForBooking(bookingId: string): Promise<ClearanceMilestone[]> {
-    return this.repo.find({
+    const rows = await this.repo.find({
       where: { bookingId },
       order: { sortOrder: 'ASC' },
     });
+
+    // Self-heal: a booking that has settled its freight payment must have
+    // FREIGHT_PAYMENT_SETTLED completed. The batch settle path writes it, but an
+    // export FCFS booking (linked to its train at booking time) paid via the
+    // prepaid invoice can leave the milestone PENDING — the clearance "Payment &
+    // wagon allocation" step then never ticks. getClearanceView backfills it, but
+    // the stepper reads its gating milestones straight from here, so heal here too.
+    // Idempotent (no-op once COMPLETED); recovers already-stuck rows with no migration.
+    const paymentSettled = rows.find(
+      (m) => m.milestoneCode === 'FREIGHT_PAYMENT_SETTLED',
+    );
+    if (paymentSettled && paymentSettled.status === 'PENDING') {
+      const booking = await this.dataSource.getRepository(Booking).findOne({
+        where: { id: bookingId },
+        select: { id: true, status: true, paymentStatus: true },
+      });
+      if (booking?.paymentStatus === 'PAID' || booking?.status === 'PAID') {
+        await this.completeForBooking(bookingId, 'FREIGHT_PAYMENT_SETTLED');
+        return this.repo.find({
+          where: { bookingId },
+          order: { sortOrder: 'ASC' },
+        });
+      }
+    }
+
+    return rows;
   }
 
   /**
diff --git a/apps/edr-freight-api/src/modules/contracts/contract-booking.consolidation.spec.ts b/apps/edr-freight-api/src/modules/contracts/contract-booking.consolidation.spec.ts
new file mode 100644
index 000000000..a83837350
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/contracts/contract-booking.consolidation.spec.ts
@@ -0,0 +1,181 @@
+import { ContractBookingService } from './contract-booking.service';
+import { Booking } from '../bookings/entities/booking.entity';
+
+/**
+ * The GL contract-drawdown path must run wagon consolidation before invoicing.
+ * A partial-wagon drawdown (e.g. 21× 20FT → one leftover container) parks in
+ * PENDING_CONSOLIDATION and is NOT finalized (no invoice / milestones) until it
+ * pairs with a wagon partner. These tests exercise the two new hooks directly.
+ */
+describe('ContractBookingService — drawdown consolidation gate', () => {
+  function makeService(overrides: {
+    consolidationService?: Partial<Record<string, jest.Mock>>;
+    bookingsRepository?: Partial<Record<string, jest.Mock>>;
+    invoiceService?: Partial<Record<string, jest.Mock>>;
+    milestoneService?: Partial<Record<string, jest.Mock>>;
+    contractsRepository?: Partial<Record<string, jest.Mock>>;
+  }) {
+    const consolidationService = {
+      slotsFromBooking: jest.fn().mockResolvedValue([]),
+      describePaired: jest.fn().mockReturnValue('paired'),
+      describePending: jest.fn().mockReturnValue('pending'),
+      needsConsolidationFromBooking: jest.fn().mockResolvedValue(false),
+      ...overrides.consolidationService,
+    };
+    const bookingsRepository = {
+      findConsolidationPartner: jest.fn().mockResolvedValue(null),
+      pairConsolidation: jest.fn().mockResolvedValue(undefined),
+      parkForConsolidation: jest.fn().mockResolvedValue(undefined),
+      findByIdWithFiles: jest.fn(),
+      ...overrides.bookingsRepository,
+    };
+    const invoiceService = {
+      ensureInvoiceForBooking: jest.fn().mockResolvedValue({ id: 'inv-1' }),
+      ...overrides.invoiceService,
+    };
+    const milestoneService = {
+      seedPostBookingMilestones: jest.fn().mockResolvedValue(undefined),
+      seedPreBookingMilestonesOnBooking: jest.fn().mockResolvedValue(undefined),
+      ...overrides.milestoneService,
+    };
+    const contractsRepository = {
+      findByIdWithRelations: jest.fn(),
+      currentCycle: jest.fn().mockResolvedValue(null),
+      linkBooking: jest.fn().mockResolvedValue(undefined),
+      update: jest.fn().mockResolvedValue(undefined),
+      ...overrides.contractsRepository,
+    };
+
+    const service = new ContractBookingService(
+      contractsRepository as never,
+      bookingsRepository as never,
+      {} as never, // bookingPricingService
+      consolidationService as never,
+      {} as never, // containerTypesService
+      {} as never, // ruleEngineService
+      milestoneService as never,
+      {} as never, // workflowService
+      invoiceService as never,
+      {} as never, // dataSource
+      {} as never, // trainSchedulingService
+    );
+    return {
+      service,
+      consolidationService,
+      bookingsRepository,
+      invoiceService,
+      milestoneService,
+      contractsRepository,
+    };
+  }
+
+  const booking = { id: 'b-1', reference: 'BK-1' } as Booking;
+
+  it('parks (not pairs) when no complementary partner exists', async () => {
+    const { service, bookingsRepository } = makeService({
+      consolidationService: {
+        slotsFromBooking: jest
+          .fn()
+          .mockResolvedValue([{ containerTypeId: 'ct', slotsNeeded: 1 }]),
+      },
+      bookingsRepository: {
+        findConsolidationPartner: jest.fn().mockResolvedValue(null),
+      },
+    });
+
+    const result = await (service as never as {
+      consolidateDrawdown: (b: Booking, s: string) => Promise<{ paired: boolean }>;
+    }).consolidateDrawdown(booking, 'OPERATION_REQUEST_PENDING');
+
+    expect(result.paired).toBe(false);
+    expect(bookingsRepository.parkForConsolidation).toHaveBeenCalledWith(
+      'b-1',
+      'OPERATION_REQUEST_PENDING',
+    );
+    expect(bookingsRepository.pairConsolidation).not.toHaveBeenCalled();
+  });
+
+  it('pairs when a complementary partner exists', async () => {
+    const { service, bookingsRepository } = makeService({
+      consolidationService: {
+        slotsFromBooking: jest
+          .fn()
+          .mockResolvedValue([{ containerTypeId: 'ct', slotsNeeded: 1 }]),
+      },
+      bookingsRepository: {
+        findConsolidationPartner: jest
+          .fn()
+          .mockResolvedValue({ id: 'p-1', reference: 'BK-2' }),
+      },
+    });
+
+    const result = await (service as never as {
+      consolidateDrawdown: (b: Booking, s: string) => Promise<{ paired: boolean }>;
+    }).consolidateDrawdown(booking, 'AWAITING_DOCUMENTS');
+
+    expect(result.paired).toBe(true);
+    expect(bookingsRepository.pairConsolidation).toHaveBeenCalledWith('b-1', 'p-1');
+    expect(bookingsRepository.parkForConsolidation).not.toHaveBeenCalled();
+  });
+
+  it('onConsolidationPaired finalizes a resumed contract booking (invoice + milestones)', async () => {
+    const paired = {
+      id: 'b-1',
+      reference: 'BK-1',
+      contractId: 'c-1',
+      status: 'OPERATION_REQUEST_PENDING',
+    } as Booking;
+    const contract = {
+      id: 'c-1',
+      contractKind: 'GENERAL',
+      customsClearingEnabled: true,
+      tradeDirection: 'EXPORT',
+    };
+    const { service, invoiceService, milestoneService } = makeService({
+      bookingsRepository: {
+        findByIdWithFiles: jest.fn().mockResolvedValue(paired),
+      },
+      contractsRepository: {
+        findByIdWithRelations: jest.fn().mockResolvedValue(contract),
+      },
+    });
+
+    await service.onConsolidationPaired({ bookingIds: ['b-1'] });
+
+    expect(invoiceService.ensureInvoiceForBooking).toHaveBeenCalledTimes(1);
+    // GENERAL customs → per-booking pre + post milestones.
+    expect(milestoneService.seedPreBookingMilestonesOnBooking).toHaveBeenCalled();
+    expect(milestoneService.seedPostBookingMilestones).toHaveBeenCalled();
+  });
+
+  it('onConsolidationPaired ignores a booking still PENDING_CONSOLIDATION', async () => {
+    const stillPending = {
+      id: 'b-1',
+      contractId: 'c-1',
+      status: 'PENDING_CONSOLIDATION',
+    } as Booking;
+    const { service, invoiceService } = makeService({
+      bookingsRepository: {
+        findByIdWithFiles: jest.fn().mockResolvedValue(stillPending),
+      },
+    });
+
+    await service.onConsolidationPaired({ bookingIds: ['b-1'] });
+
+    expect(invoiceService.ensureInvoiceForBooking).not.toHaveBeenCalled();
+  });
+
+  it('onConsolidationPaired ignores a non-contract (direct) booking', async () => {
+    const direct = { id: 'd-1', status: 'SUBMITTED', contractId: null } as Booking;
+    const { service, invoiceService, contractsRepository } = makeService({
+      bookingsRepository: {
+        findByIdWithFiles: jest.fn().mockResolvedValue(direct),
+      },
+    });
+
+    await service.onConsolidationPaired({ bookingIds: ['d-1'] });
+
+    expect(contractsRepository.findByIdWithRelations).not.toHaveBeenCalled();
+    expect(invoiceService.ensureInvoiceForBooking).not.toHaveBeenCalled();
+  });
+});
diff --git a/apps/edr-freight-api/src/modules/contracts/contract-booking.service.ts b/apps/edr-freight-api/src/modules/contracts/contract-booking.service.ts
index 5e80b1301..55dd5c29f 100644
--- a/apps/edr-freight-api/src/modules/contracts/contract-booking.service.ts
+++ b/apps/edr-freight-api/src/modules/contracts/contract-booking.service.ts
@@ -8,6 +8,7 @@ import {
   forwardRef,
 } from '@nestjs/common';
 import { DataSource } from 'typeorm';
+import { OnEvent } from '@nestjs/event-emitter';
 import { insertWithGeneratedReference } from '@edr/api-common';
 
 import { Booking } from '../bookings/entities/booking.entity';
@@ -15,6 +16,7 @@ import { BookingContainer } from '../bookings/entities/booking-container.entity'
 import { BookingContainerUnit } from '../bookings/entities/booking-container-unit.entity';
 import { BookingsRepository } from '../bookings/bookings.repository';
 import { BookingPricingService } from '../bookings/booking-pricing.service';
+import { ConsolidationService } from '../bookings/consolidation.service';
 import { PriceLineItemDto } from '../bookings/dto/generate-price-response.dto';
 import { BookingInvoiceService } from '../bookings/booking-invoice.service';
 import { validate20ftWeightPairing } from '../bookings/container-pairing.util';
@@ -61,6 +63,7 @@ export class ContractBookingService {
     private readonly contractsRepository: ContractsRepository,
     private readonly bookingsRepository: BookingsRepository,
     private readonly bookingPricingService: BookingPricingService,
+    private readonly consolidationService: ConsolidationService,
     private readonly containerTypesService: ContainerTypesService,
     private readonly ruleEngineService: RuleEngineService,
     private readonly milestoneService: ClearanceMilestoneService,
@@ -214,6 +217,20 @@ export class ContractBookingService {
         await this.applyWeightResults(loaded);
       }
       const computed = await this.bookingPricingService.computePriceForBooking(loaded);
+      // Reject a zero-price booking outright. A total of 0 means no contract rate
+      // matched the route/container (or the rate is unset), so the booking is not
+      // valid to ship or invoice. Roll back the just-inserted row + its lines so it
+      // does NOT occupy the one-time contract's single active-booking slot — else
+      // the customer's retry hits "already has an active booking" against a broken
+      // draft. The customer must fix the contract's rates, then rebook.
+      if (!(computed.totalAmount > 0)) {
+        await this.bookingsRepository.deleteContainers(booking.id);
+        await this.bookingsRepository.hardDelete(booking.id);
+        throw new BadRequestException(
+          'Booking price came out as 0 — no contract rate matches this ' +
+            'route/cargo. Set the contract rate and try again.',
+        );
+      }
       await this.bookingsRepository.update(booking.id, {
         totalAmount: computed.totalAmount,
         priorityScore: computed.priorityScore,
@@ -232,6 +249,105 @@ export class ContractBookingService {
       warnings.push(...computed.warnings);
     }
 
+    // Wagon consolidation gate. A container drawdown whose lines leave a partial
+    // wagon (e.g. 21× 20FT → one leftover) must share that wagon with a partner
+    // before it can ship. Direct bookings do this at submit; drawdowns have no
+    // submit step, so we run it here — BEFORE invoicing/milestones. When it parks
+    // for a partner the booking is NOT invoiced or scheduled: those steps run
+    // later in finalizeContractBooking, triggered by the pairing event. When it
+    // pairs (or needs no consolidation) we finalize inline.
+    const withContainers = await this.bookingsRepository.findByIdWithFiles(
+      booking.id,
+    );
+    const intendedStatus = generalCustoms
+      ? 'AWAITING_DOCUMENTS'
+      : 'OPERATION_REQUEST_PENDING';
+    if (
+      withContainers &&
+      freightType === 'CONTAINER' &&
+      (await this.consolidationService.needsConsolidationFromBooking(
+        withContainers,
+      ))
+    ) {
+      const parked = await this.consolidateDrawdown(
+        withContainers,
+        intendedStatus,
+      );
+      warnings.push(parked.message);
+      if (!parked.paired) {
+        // Waiting for a partner — stop here. The booking sits in
+        // PENDING_CONSOLIDATION, unbilled and unscheduled, until it pairs.
+        const pendingResult = await this.bookingsRepository.findByIdWithFiles(
+          booking.id,
+        );
+        return { booking: pendingResult ?? booking, warnings };
+      }
+    }
+
+    await this.finalizeContractBooking(
+      booking.id,
+      contract,
+      generalCustoms,
+    );
+
+    const result = await this.bookingsRepository.findByIdWithFiles(booking.id);
+    return { booking: result ?? booking, warnings };
+  }
+
+  /**
+   * Search for a complementary partner for a parked-eligible drawdown, pair it or
+   * park it in PENDING_CONSOLIDATION with the resume status it should return to.
+   * Pairing (via BookingsRepository.pairConsolidation) resumes both partners and
+   * emits booking.consolidation.paired, which finalizes any deferred contract
+   * booking. Returns whether a partner was found plus a customer-facing message.
+   */
+  private async consolidateDrawdown(
+    booking: Booking,
+    resumeStatus: string,
+  ): Promise<{ paired: boolean; message: string }> {
+    const slots = await this.consolidationService.slotsFromBooking(booking);
+    if (!slots.length) {
+      return { paired: false, message: '' };
+    }
+
+    const partner = await this.bookingsRepository.findConsolidationPartner(
+      booking,
+      slots,
+    );
+
+    if (partner) {
+      await this.bookingsRepository.pairConsolidation(booking.id, partner.id);
+      return {
+        paired: true,
+        message: this.consolidationService.describePaired(
+          partner.reference,
+          slots,
+        ),
+      };
+    }
+
+    await this.bookingsRepository.parkForConsolidation(booking.id, resumeStatus);
+    return {
+      paired: false,
+      message: this.consolidationService.describePending(booking, slots),
+    };
+  }
+
+  /**
+   * Finalize a contract booking once it is cleared to proceed (needed no
+   * consolidation, or has just paired): seed clearance milestones / link the
+   * contract cycle, then generate the invoice. Idempotent — safe to call again
+   * for a booking that pairs after having waited. Skips a booking that is still
+   * PENDING_CONSOLIDATION (guards the pairing event against a stray partner).
+   */
+  private async finalizeContractBooking(
+    bookingId: string,
+    contract: Contract,
+    generalCustoms: boolean,
+  ): Promise<void> {
+    const booking = await this.bookingsRepository.findByIdWithFiles(bookingId);
+    if (!booking || booking.status === 'PENDING_CONSOLIDATION') return;
+
     // ONE_TIME customs (legacy contract-cycle path): link the contract clearance
     // cycle to this booking, seed post-booking milestones, and lock the contract
     // to ACTIVE_SHIPMENT_IN_PROGRESS. NOT for GENERAL — it has no contract cycle
@@ -239,10 +355,10 @@ export class ContractBookingService {
     if (contract.customsClearingEnabled && !generalCustoms) {
       const cycle = await this.contractsRepository.currentCycle(contract.id);
       if (cycle) {
-        await this.contractsRepository.linkBooking(cycle.id, booking.id);
+        await this.contractsRepository.linkBooking(cycle.id, bookingId);
       }
       await this.milestoneService.seedPostBookingMilestones(
-        booking.id,
+        bookingId,
         contract.tradeDirection,
       );
       await this.contractsRepository.update(contract.id, {
@@ -252,24 +368,22 @@ export class ContractBookingService {
     } else if (generalCustoms) {
       // Per-booking clearance: seed full milestone timeline on the booking.
       await this.milestoneService.seedPreBookingMilestonesOnBooking(
-        booking.id,
+        bookingId,
         contract.tradeDirection,
       );
       await this.milestoneService.seedPostBookingMilestones(
-        booking.id,
+        bookingId,
         contract.tradeDirection,
       );
     }
 
-    const result = await this.bookingsRepository.findByIdWithFiles(booking.id);
-
     // Contract bookings are born past the billable gate (the contract is already
     // executed), so the invoice is generated here — they never pass through the
     // legacy marketingApprove → FULLY_EXECUTED path that invoices direct bookings.
     // Idempotent and non-blocking: a billing hiccup must not undo the booking.
     // Skips silently when unbillable (no company / no priced amount).
     await this.invoiceService
-      .ensureInvoiceForBooking(result ?? booking)
+      .ensureInvoiceForBooking(booking)
       .catch((err) =>
         this.logger.error(
           `Failed to generate invoice for contract booking ${booking.reference}: ${
@@ -277,8 +391,40 @@ export class ContractBookingService {
           }`,
         ),
       );
+  }
 
-    return { booking: result ?? booking, warnings };
+  /**
+   * A parked drawdown just paired — finalize whichever partner is a contract
+   * booking that was waiting (invoice + milestones deferred at creation). The
+   * pairing already resumed the booking's status from consolidationResumeStatus;
+   * this runs the create-time tail that was skipped. Non-contract partners have
+   * their own finalize path (staff accept) and are ignored here.
+   */
+  @OnEvent('booking.consolidation.paired')
+  async onConsolidationPaired(payload: {
+    bookingIds: string[];
+  }): Promise<void> {
+    for (const id of payload.bookingIds ?? []) {
+      const booking = await this.bookingsRepository.findByIdWithFiles(id);
+      if (!booking?.contractId || booking.status === 'PENDING_CONSOLIDATION') {
+        continue;
+      }
+      const contract = await this.contractsRepository.findByIdWithRelations(
+        booking.contractId,
+      );
+      if (!contract) continue;
+      const generalCustoms =
+        contract.contractKind === 'GENERAL' &&
+        Boolean(contract.customsClearingEnabled);
+      await this.finalizeContractBooking(id, contract, generalCustoms).catch(
+        (err) =>
+          this.logger.error(
+            `Failed to finalize paired contract booking ${booking.reference}: ${
+              err instanceof Error ? err.message : String(err)
+            }`,
+          ),
+      );
+    }
   }
 
   /**
diff --git a/apps/edr-freight-api/src/modules/contracts/contract-transition.service.ts b/apps/edr-freight-api/src/modules/contracts/contract-transition.service.ts
index 9cf06c905..9f12b937d 100644
--- a/apps/edr-freight-api/src/modules/contracts/contract-transition.service.ts
+++ b/apps/edr-freight-api/src/modules/contracts/contract-transition.service.ts
@@ -250,6 +250,44 @@ export class ContractTransitionService {
     return updated;
   }
 
+  /**
+   * Reject one approval step (line staff / director / CEO). The rejecting
+   * approver must supply a reason. A rejection is terminal: the whole contract
+   * moves to REJECTED and the customer must create a new one — there is no
+   * resubmit of the same contract. The reason is recorded both on the step and
+   * as a REJECTION review note so it is visible to the customer and the rest of
+   * the approval chain.
+   */
+  async rejectStep(
+    contractId: string,
+    stepId: string,
+    actorId: string,
+    reason: string,
+  ): Promise<Contract> {
+    const contract = await this.contractsService.findById(contractId);
+    assertContractStatus(contract, ['PENDING_APPROVAL', 'APPROVED_PENDING_SIGNATURE']);
+
+    const step = await this.contractsRepository.findApprovalStepById(contractId, stepId);
+    if (!step) throw new BadRequestException('Approval step not found');
+
+    await this.contractsRepository.completeApprovalStep(step.id, actorId, 'REJECTED', reason);
+
+    await this.contractsRepository.createReviewNote(
+      contractId,
+      reason,
+      'REJECTION',
+      actorId,
+      'STAFF',
+    );
+
+    await this.contractsRepository.update(contractId, {
+      status: 'REJECTED',
+    } as never);
+    const updated = await this.contractsService.findById(contractId);
+    this.notifier.rejected(updated, reason);
+    return updated;
+  }
+
   /** Approve one approval step in sequence; → APPROVED when all complete. */
   async approveStep(
     contractId: string,
diff --git a/apps/edr-freight-api/src/modules/contracts/contracts.controller.ts b/apps/edr-freight-api/src/modules/contracts/contracts.controller.ts
index 8591a54d8..4ea7634b6 100644
--- a/apps/edr-freight-api/src/modules/contracts/contracts.controller.ts
+++ b/apps/edr-freight-api/src/modules/contracts/contracts.controller.ts
@@ -60,6 +60,7 @@ import { AcceptContractDto } from './dto/accept-contract.dto';
 import {
   ApproveStepDto,
   RejectContractDto,
+  RejectStepDto,
   RequestChangesDto,
 } from './dto/approve-step.dto';
 import { SignContractDto } from './dto/sign-contract.dto';
@@ -390,6 +391,27 @@ export class ContractsController {
     );
   }
 
+  @Post(':id/approval-steps/:stepId/reject')
+  @BookingStaff([
+    FREIGHT_PERMS.contracts.approveLineStaff,
+    FREIGHT_PERMS.contracts.approveDirector,
+    FREIGHT_PERMS.contracts.approveCeo,
+  ])
+  @ApiOperation({ summary: 'Reject one approval step (terminal → REJECTED)' })
+  rejectStep(
+    @Param('id', ParseUUIDPipe) id: string,
+    @Param('stepId', ParseUUIDPipe) stepId: string,
+    @Body() dto: RejectStepDto,
+    @CurrentUser() user: AuthUserPayload,
+  ) {
+    return this.transitionService.rejectStep(
+      id,
+      stepId,
+      resolveAuthUserId(user),
+      dto.reason,
+    );
+  }
+
   @Post(':id/contract/generate')
   @BookingStaff(FREIGHT_PERMS.contracts.generateContract)
   @ApiOperation({ summary: 'Generate contract document → CONTRACT_READY' })
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 0e81f8dca..aaf064bff 100644
--- a/apps/edr-freight-api/src/modules/contracts/contracts.service.ts
+++ b/apps/edr-freight-api/src/modules/contracts/contracts.service.ts
@@ -567,6 +567,21 @@ export class ContractsService {
       );
     }
 
+    // Surface the staff "request changes" note so the portal can show the
+    // customer what to fix. Degrade to null on lookup failure — a missing note
+    // must never 500 a contract fetch.
+    if (contract.status === 'CHANGES_REQUESTED') {
+      try {
+        const note = await this.contractsRepository.findLatestReviewNote(
+          contract.id,
+          'CHANGES_REQUESTED',
+        );
+        contract.latestChangeRequestNote = note?.body ?? null;
+      } catch {
+        contract.latestChangeRequestNote = null;
+      }
+    }
+
     return contract;
   }
 
diff --git a/apps/edr-freight-api/src/modules/contracts/entities/contract.entity.ts b/apps/edr-freight-api/src/modules/contracts/entities/contract.entity.ts
index 07d08d3c0..0b0fab41b 100644
--- a/apps/edr-freight-api/src/modules/contracts/entities/contract.entity.ts
+++ b/apps/edr-freight-api/src/modules/contracts/entities/contract.entity.ts
@@ -260,4 +260,11 @@ export class Contract extends BaseEntity {
    * ContractsRepository.attachClearancePhases for list responses. Not a column.
    */
   clearancePhase?: string | null;
+
+  /**
+   * Body of the most recent CHANGES_REQUESTED review note, attached by
+   * ContractsService.findById so the portal can show the customer what staff
+   * asked them to fix. Lives in contract_review_notes, not a column here.
+   */
+  latestChangeRequestNote?: string | null;
 }
diff --git a/apps/edr-freight-api/src/modules/contracts/gl-operations.service.ts b/apps/edr-freight-api/src/modules/contracts/gl-operations.service.ts
index 181d8b688..106acdb0b 100644
--- a/apps/edr-freight-api/src/modules/contracts/gl-operations.service.ts
+++ b/apps/edr-freight-api/src/modules/contracts/gl-operations.service.ts
@@ -202,15 +202,22 @@ export class GlOperationsService {
         .findOne({ where: { id: booking.trainScheduleId } });
     }
 
+    // Per-booking journey first: a booking rides only its own leg, so ITS
+    // loaded/arrived timestamps gate clearance — a Dire→Djibouti booking that
+    // unloaded at its own destination clears while the train keeps rolling,
+    // and a booking still on board does NOT clear just because the train
+    // arrived. The schedule actuals remain only as fallback for legacy
+    // in-flight bookings that predate per-booking load/unload (no loadedAt).
+    const departedAt = booking.loadedAt ?? schedule?.actualDepartureAt ?? null;
+    const arrivedAt =
+      booking.arrivedAt ??
+      (booking.loadedAt ? null : (schedule?.actualArrivalAt ?? null));
+
     return {
       scheduleId: schedule?.id ?? null,
       wagonAllocated,
-      departedAt: schedule?.actualDepartureAt
-        ? new Date(schedule.actualDepartureAt).toISOString()
-        : null,
-      arrivedAt: schedule?.actualArrivalAt
-        ? new Date(schedule.actualArrivalAt).toISOString()
-        : null,
+      departedAt: departedAt ? new Date(departedAt).toISOString() : null,
+      arrivedAt: arrivedAt ? new Date(arrivedAt).toISOString() : null,
     };
   }
 
@@ -278,7 +285,7 @@ export class GlOperationsService {
   /**
    * GL Djibouti uploads T1 transport documents (multi-file) once the gate pass
    * is secured on the train schedule (which itself follows wagon allocation).
-   * Replaces the previous batch; locked once the train departs or T1 is closed.
+   * Replaces the previous batch; locked only once GL Ethiopia closes the T1.
    */
   async uploadT1Documents(
     bookingId: string,
@@ -304,11 +311,8 @@ export class GlOperationsService {
     if (state.closed) {
       throw new BadRequestException('T1 has been closed by GL Ethiopia — documents are final.');
     }
-    if (state.trainDepartedAt) {
-      throw new BadRequestException(
-        'The train has departed — T1 transport documents can no longer be changed.',
-      );
-    }
+    // Departure no longer locks T1 docs — GL DJ may replace them any time until
+    // GL Ethiopia closes/accepts the T1.
 
     await persistT1TransportUploads(this.filesService, bookingId, files);
     return { uploaded: files.length };
@@ -395,14 +399,20 @@ export class GlOperationsService {
     }
     if (!file) throw new BadRequestException('Attach the invoice document.');
 
+    // Invoiceable once cargo is offloaded, or — for export, where OFFLOADED is a
+    // DJ doc milestone that may never be recorded — once the Djibouti gate pass
+    // is secured. The invoice itself stays optional; nothing forces GL DJ to send one.
     const milestones = await this.milestoneService.listForBooking(bookingId);
     const offloaded = milestones.find(
       (m) => m.milestoneCode === 'OFFLOADED' && m.status === 'COMPLETED',
     );
     if (!offloaded) {
-      throw new BadRequestException(
-        'Cargo must be offloaded before the final invoice can be raised.',
-      );
+      const gatepass = await this.gatepassForBooking(bookingId);
+      if (!gatepass.granted) {
+        throw new BadRequestException(
+          'Cargo must be offloaded (or the gate pass secured) before the final invoice can be raised.',
+        );
+      }
     }
 
     const existing = await this.billingService.findInvoice(
diff --git a/apps/edr-freight-api/src/modules/contracts/phased-clearance.util.ts b/apps/edr-freight-api/src/modules/contracts/phased-clearance.util.ts
index 2e8682951..aa1c956e0 100644
--- a/apps/edr-freight-api/src/modules/contracts/phased-clearance.util.ts
+++ b/apps/edr-freight-api/src/modules/contracts/phased-clearance.util.ts
@@ -276,6 +276,7 @@ export const PHASED_CUSTOMS_BOOKING_QUEUE_STATUSES = [
   'OPERATION_CHANGES_REQUESTED',
   'ROAD_DISPATCH_PENDING',
   'IN_TRANSIT',
+  'ARRIVED',
   'PAID',
   'COMPLETED',
   'CONTRACT_ACTIVE',
diff --git a/apps/edr-freight-api/src/modules/drivers/drivers.controller.ts b/apps/edr-freight-api/src/modules/drivers/drivers.controller.ts
index b4da558e2..d86ee823a 100644
--- a/apps/edr-freight-api/src/modules/drivers/drivers.controller.ts
+++ b/apps/edr-freight-api/src/modules/drivers/drivers.controller.ts
@@ -8,9 +8,13 @@ import {
   Body,
   Query,
   ParseUUIDPipe,
+  UploadedFiles,
+  UseInterceptors,
 } from '@nestjs/common';
-import { ApiBearerAuth, ApiOperation, ApiTags } from '@nestjs/swagger';
-import { FleetManage, FleetView } from '../../common/booking-guards';
+import { AnyFilesInterceptor } from '@nestjs/platform-express';
+import { ApiBearerAuth, ApiConsumes, ApiOperation, ApiTags } from '@nestjs/swagger';
+import { BookingStaff } from '../../common/booking-guards';
+import { FREIGHT_PERMS } from '../../seed/freight-permissions.registry';
 import { DriversService } from './drivers.service';
 import { CreateDriverDto } from './dto/create-driver.dto';
 import { UpdateDriverDto } from './dto/update-driver.dto';
@@ -19,7 +23,7 @@ import { FleetHistoryService } from '../fleet-history/fleet-history.service';
 @ApiTags('drivers')
 @ApiBearerAuth()
 @Controller('drivers')
-@FleetView()
+@BookingStaff(FREIGHT_PERMS.drivers.view)
 export class DriversController {
   constructor(
     private readonly driversService: DriversService,
@@ -27,7 +31,7 @@ export class DriversController {
   ) {}
 
   @Post()
-  @FleetManage()
+  @BookingStaff(FREIGHT_PERMS.drivers.create)
   @ApiOperation({ summary: 'Create a new driver' })
   create(@Body() createDriverDto: CreateDriverDto) {
     return this.driversService.create(createDriverDto);
@@ -65,8 +69,33 @@ export class DriversController {
     return this.fleetHistory.getDriverHistory(id);
   }
 
+  @Post(':id/documents')
+  @BookingStaff(FREIGHT_PERMS.drivers.update)
+  @ApiConsumes('multipart/form-data')
+  @UseInterceptors(AnyFilesInterceptor())
+  @ApiOperation({ summary: 'Upload driver documents (code driver_docs)' })
+  uploadDocuments(
+    @Param('id', ParseUUIDPipe) id: string,
+    @UploadedFiles() files: Express.Multer.File[],
+  ) {
+    return this.driversService.uploadDocuments(id, files ?? []);
+  }
+
+  @Get(':id/documents')
+  @ApiOperation({ summary: "List a driver's documents" })
+  listDocuments(@Param('id', ParseUUIDPipe) id: string) {
+    return this.driversService.listDocuments(id);
+  }
+
+  @Delete(':id/documents/:fileId')
+  @BookingStaff(FREIGHT_PERMS.drivers.update)
+  @ApiOperation({ summary: 'Delete a driver document' })
+  removeDocument(@Param('fileId', ParseUUIDPipe) fileId: string) {
+    return this.driversService.removeDocument(fileId);
+  }
+
   @Patch(':id')
-  @FleetManage()
+  @BookingStaff(FREIGHT_PERMS.drivers.update)
   @ApiOperation({ summary: 'Update a driver' })
   update(
     @Param('id', ParseUUIDPipe) id: string,
@@ -76,7 +105,7 @@ export class DriversController {
   }
 
   @Delete(':id')
-  @FleetManage()
+  @BookingStaff(FREIGHT_PERMS.drivers.delete)
   @ApiOperation({ summary: 'Delete a driver' })
   remove(@Param('id', ParseUUIDPipe) id: string) {
     return this.driversService.remove(id);
diff --git a/apps/edr-freight-api/src/modules/drivers/drivers.module.ts b/apps/edr-freight-api/src/modules/drivers/drivers.module.ts
index 9e685dcd6..1a6e29e15 100644
--- a/apps/edr-freight-api/src/modules/drivers/drivers.module.ts
+++ b/apps/edr-freight-api/src/modules/drivers/drivers.module.ts
@@ -3,9 +3,10 @@ import { TypeOrmModule } from '@nestjs/typeorm';
 import { Driver } from './entities/driver.entity';
 import { DriversService } from './drivers.service';
 import { DriversController } from './drivers.controller';
+import { FilesModule } from '../files/files.module';
 
 @Module({
-  imports: [TypeOrmModule.forFeature([Driver])],
+  imports: [TypeOrmModule.forFeature([Driver]), FilesModule],
   providers: [DriversService],
   controllers: [DriversController],
   exports: [DriversService],
diff --git a/apps/edr-freight-api/src/modules/drivers/drivers.service.ts b/apps/edr-freight-api/src/modules/drivers/drivers.service.ts
index 6e7c1f69c..e4fa992e8 100644
--- a/apps/edr-freight-api/src/modules/drivers/drivers.service.ts
+++ b/apps/edr-freight-api/src/modules/drivers/drivers.service.ts
@@ -6,6 +6,11 @@ import { UpdateDriverDto } from './dto/update-driver.dto';
 import { Driver, DriverStatus } from './entities/driver.entity';
 import { FleetHistoryService } from '../fleet-history/fleet-history.service';
 import { FleetEventType } from '../fleet-history/entities/fleet-event.entity';
+import { FilesService } from '../files/files.service';
+
+/** Resource + code the driver-documents upload area is stored under. */
+const DRIVER_DOCS_RESOURCE = 'driver';
+const DRIVER_DOCS_CODE = 'driver_docs';
 
 @Injectable()
 export class DriversService {
@@ -13,8 +18,37 @@ export class DriversService {
     @InjectRepository(Driver)
     private readonly driverRepo: Repository<Driver>,
     private readonly history: FleetHistoryService,
+    private readonly filesService: FilesService,
   ) {}
 
+  /** Upload one or more driver documents (code "driver_docs"). */
+  async uploadDocuments(driverId: string, files: Express.Multer.File[]) {
+    const driver = await this.driverRepo.findOneBy({ id: driverId });
+    if (!driver) throw new NotFoundException(`Driver ${driverId} not found`);
+    if (!files?.length) throw new BadRequestException('No files provided');
+    return Promise.all(
+      files.map((file) =>
+        this.filesService.upload({
+          resourceId: driverId,
+          resource: DRIVER_DOCS_RESOURCE,
+          code: DRIVER_DOCS_CODE,
+          file,
+        }),
+      ),
+    );
+  }
+
+  /** List a driver's uploaded documents (code "driver_docs"). */
+  async listDocuments(driverId: string) {
+    const all = await this.filesService.findByResource(driverId, DRIVER_DOCS_RESOURCE);
+    return all.filter((f) => f.code === DRIVER_DOCS_CODE);
+  }
+
+  /** Delete a single driver document by file id. */
+  async removeDocument(fileId: string): Promise<void> {
+    await this.filesService.remove(fileId);
+  }
+
   async create(dto: CreateDriverDto): Promise<Driver> {
     if (dto.faydaVerified !== true) {
       throw new BadRequestException(
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 a5c641dd7..4966d7ff9 100644
--- a/apps/edr-freight-api/src/modules/files/files.service.ts
+++ b/apps/edr-freight-api/src/modules/files/files.service.ts
@@ -119,6 +119,11 @@ export class FilesService {
     return record;
   }
 
+  /** Soft-delete a stored file row by id (object bytes are left in MinIO). */
+  async remove(id: string): Promise<void> {
+    await this.filesRepository.softDelete(id);
+  }
+
   findByResource(resourceId: string, resource: string): Promise<FileRecord[]> {
     return this.filesRepository.findByResource(resourceId, resource);
   }
diff --git a/apps/edr-freight-api/src/modules/first-mile/first-mile-invoice.service.ts b/apps/edr-freight-api/src/modules/first-mile/first-mile-invoice.service.ts
index f4935a87b..aa618cdb7 100644
--- a/apps/edr-freight-api/src/modules/first-mile/first-mile-invoice.service.ts
+++ b/apps/edr-freight-api/src/modules/first-mile/first-mile-invoice.service.ts
@@ -1,4 +1,4 @@
-import { Injectable, Logger } from '@nestjs/common';
+import { BadRequestException, Injectable, Logger } from '@nestjs/common';
 import { OnEvent } from '@nestjs/event-emitter';
 import { Freight } from '@edr/types';
 
@@ -66,13 +66,37 @@ export class FirstMileInvoiceService {
       return null;
     }
 
+    // Reject mixed-currency truck sets — a single invoice can only be one
+    // currency, and amounts across currencies can't be summed.
+    const billableTrucks = (record.vehicleAssignments ?? []).filter(
+      (a) => Number(a.distanceKm) > 0,
+    );
+    const currencies = [
+      ...new Set(
+        billableTrucks
+          .map((a) => (a.vehicle as { currency?: string } | undefined)?.currency)
+          .filter((c): c is string => Boolean(c)),
+      ),
+    ];
+    if (currencies.length > 1) {
+      throw new BadRequestException(
+        `Cannot generate invoice: assigned trucks use mixed currencies (${currencies.join(', ')}). Assign trucks that share one currency.`,
+      );
+    }
+
+    // Currency follows the truck (price/km is quoted per vehicle), falling back
+    // to the booking's currency, then ETB.
+    const truckCurrency =
+      (record.vehicle as { currency?: string } | undefined)?.currency ||
+      (record.vehicleAssignments?.[0]?.vehicle as { currency?: string } | undefined)?.currency;
+
     return this.billing.generateInvoice({
       source: 'first_mile' as Freight.InvoiceSource,
       sourceId: record.id,
       type: 'DELIVERY_FEE',
       companyId: fm.booking!.companyId,
       companyProfileId: fm.booking!.companyProfileId || '',
-      currency: fm.booking!.paymentCurrency || 'ETB',
+      currency: truckCurrency || fm.booking!.paymentCurrency || 'ETB',
       lines: [
         {
           chargeType: 'DELIVERY',
diff --git a/apps/edr-freight-api/src/modules/first-mile/first-mile.controller.ts b/apps/edr-freight-api/src/modules/first-mile/first-mile.controller.ts
index e43fbcae8..952f924d6 100644
--- a/apps/edr-freight-api/src/modules/first-mile/first-mile.controller.ts
+++ b/apps/edr-freight-api/src/modules/first-mile/first-mile.controller.ts
@@ -14,7 +14,8 @@ import {
 } from '@nestjs/common';
 import { ApiBearerAuth, ApiOperation, ApiTags } from '@nestjs/swagger';
 
-import { TrainSchedulingManage, TrainSchedulingView } from '../../common/booking-guards';
+import { BookingStaff } from '../../common/booking-guards';
+import { FREIGHT_PERMS } from '../../seed/freight-permissions.registry';
 
 import { CreateFirstMileDto } from './dto/create-first-mile.dto';
 import { UpdateFirstMileDto } from './dto/update-first-mile.dto';
@@ -27,7 +28,7 @@ import { FirstMileInvoiceService } from './first-mile-invoice.service';
 @ApiTags('first-mile')
 @ApiBearerAuth()
 @Controller('first-mile')
-@TrainSchedulingView()
+@BookingStaff(FREIGHT_PERMS.firstMile.view)
 export class FirstMileController {
   constructor(
     private readonly firstMileService: FirstMileService,
@@ -63,27 +64,28 @@ export class FirstMileController {
   }
 
   @Get('acceptitem/:id')
+  @BookingStaff(FREIGHT_PERMS.firstMile.accept)
   @ApiOperation({ summary: 'Get a first-mile accep by ID' })
   acceptItem(@Param('id', ParseUUIDPipe) id: string) {
     return this.firstMileService.acceptBooking(id);
   }
 
   @Post('accept/:reference')
-  @TrainSchedulingManage()
+  @BookingStaff(FREIGHT_PERMS.firstMile.accept)
   @ApiOperation({ summary: 'Accept a paid booking and create a first-mile leg' })
   acceptBooking(@Param('reference') reference: string) {
     return this.firstMileService.acceptBookingByReference(reference);
   }
 
   @Post()
-  @TrainSchedulingManage()
+  @BookingStaff(FREIGHT_PERMS.firstMile.create)
   @ApiOperation({ summary: 'Create a first-mile leg' })
   create(@Body() dto: CreateFirstMileDto) {
     return this.firstMileService.create(dto);
   }
 
   @Patch(':id')
-  @TrainSchedulingManage()
+  @BookingStaff(FREIGHT_PERMS.firstMile.update)
   @ApiOperation({ summary: 'Update a first-mile leg' })
   async update(@Param('id', ParseUUIDPipe) id: string, @Body() dto: UpdateFirstMileDto) {
     // No invoice side-effects — invoices are generated only via the explicit
@@ -92,7 +94,7 @@ export class FirstMileController {
   }
 
   @Post(':id/invoice')
-  @TrainSchedulingManage()
+  @BookingStaff(FREIGHT_PERMS.firstMile.generateInvoice)
   @ApiOperation({ summary: 'Generate the first-mile delivery-fee invoice' })
   async generateInvoice(@Param('id', ParseUUIDPipe) id: string) {
     const record = await this.firstMileService.findById(id);
@@ -106,7 +108,7 @@ export class FirstMileController {
   }
 
   @Post(':id/vehicles')
-  @TrainSchedulingManage()
+  @BookingStaff(FREIGHT_PERMS.firstMile.assignVehicles)
   @ApiOperation({ summary: 'Set the vehicles assigned to a first-mile pickup (multi-truck)' })
   async setVehicles(
     @Param('id', ParseUUIDPipe) id: string,
@@ -116,7 +118,7 @@ export class FirstMileController {
   }
 
   @Post(':id/distances')
-  @TrainSchedulingManage()
+  @BookingStaff(FREIGHT_PERMS.firstMile.setDistances)
   @ApiOperation({ summary: 'Set per-vehicle actual distances (does not generate an invoice)' })
   async setDistances(
     @Param('id', ParseUUIDPipe) id: string,
@@ -126,7 +128,7 @@ export class FirstMileController {
   }
 
   @Delete(':id')
-  @TrainSchedulingManage()
+  @BookingStaff(FREIGHT_PERMS.firstMile.delete)
   @HttpCode(HttpStatus.NO_CONTENT)
   @ApiOperation({ summary: 'Soft-delete a first-mile leg' })
   remove(@Param('id', ParseUUIDPipe) id: string) {
diff --git a/apps/edr-freight-api/src/modules/first-mile/first-mile.service.ts b/apps/edr-freight-api/src/modules/first-mile/first-mile.service.ts
index 5c12d94ee..00dbb80cc 100644
--- a/apps/edr-freight-api/src/modules/first-mile/first-mile.service.ts
+++ b/apps/edr-freight-api/src/modules/first-mile/first-mile.service.ts
@@ -640,10 +640,24 @@ export class FirstMileService {
         { distanceKm: d.distanceKm },
       );
     }
-    const total = distances.reduce((s, d) => s + (Number(d.distanceKm) || 0), 0);
+
+    // Billing is per truck: amount = Σ (truck distance × truck price/km). The
+    // per-vehicle rate + currency live on the vehicle, so we ignore the legacy
+    // FIRST_MILE flat rate and any client-sent amount. `remainingPayment` param
+    // kept only for signature back-compat.
+    void remainingPayment;
+    const assignments = await this.dataSource.manager.find(FirstMileVehicleAssignment, {
+      where: { firstMileId: id },
+      relations: { vehicle: true },
+    });
+    const total = assignments.reduce((s, a) => s + (Number(a.distanceKm) || 0), 0);
+    const amount = assignments.reduce(
+      (s, a) => s + (Number(a.distanceKm) || 0) * (Number(a.vehicle?.pricePerKm) || 0),
+      0,
+    );
     await this.firstMileRepository.update(id, {
       exactKm: total,
-      ...(remainingPayment != null ? { remainingPayment } : {}),
+      remainingPayment: amount,
     } as any);
     return this.findById(id);
   }
diff --git a/apps/edr-freight-api/src/modules/fuel/fuel.controller.ts b/apps/edr-freight-api/src/modules/fuel/fuel.controller.ts
index 62207bfa1..2e5cca199 100644
--- a/apps/edr-freight-api/src/modules/fuel/fuel.controller.ts
+++ b/apps/edr-freight-api/src/modules/fuel/fuel.controller.ts
@@ -1,26 +1,40 @@
 import { Controller, Post, Get, Body, Param, Query } from '@nestjs/common';
-import { ApiTags, ApiOperation } from '@nestjs/swagger';
+import { ApiBearerAuth, ApiTags, ApiOperation } from '@nestjs/swagger';
+import { BookingStaff } from '../../common/booking-guards';
+import { FREIGHT_PERMS } from '../../seed/freight-permissions.registry';
 import { FuelService } from './fuel.service';
 import { CreateFuelPurchaseDto } from './dto/create-fuel-purchase.dto';
 
+// Stats feed the Financial Reports + Fleet Dashboard pages, so their viewers may
+// read them without full fuel access.
+const FUEL_STATS_PERMS = [
+  FREIGHT_PERMS.fuel.view,
+  FREIGHT_PERMS.fleetReports.view,
+  FREIGHT_PERMS.fleetDashboard.view,
+];
+
 @ApiTags('Fuel Management')
+@ApiBearerAuth()
 @Controller('fuel')
 export class FuelController {
   constructor(private readonly fuelService: FuelService) {}
 
   @Post('purchases')
+  @BookingStaff(FREIGHT_PERMS.fuel.create)
   @ApiOperation({ summary: 'Record fuel purchase' })
   async recordFuelPurchase(@Body() dto: CreateFuelPurchaseDto) {
     return this.fuelService.recordFuelPurchase(dto);
   }
 
   @Get('purchases')
+  @BookingStaff(FREIGHT_PERMS.fuel.view)
   @ApiOperation({ summary: 'Get all fuel purchases' })
   async getAllFuelPurchases() {
     return this.fuelService.getAllFuelPurchases();
   }
 
   @Get('purchases/:vehicleId')
+  @BookingStaff(FREIGHT_PERMS.fuel.view)
   @ApiOperation({ summary: 'Get fuel purchases for vehicle' })
   async getFuelPurchases(
     @Param('vehicleId') vehicleId: string,
@@ -35,6 +49,7 @@ export class FuelController {
   }
 
   @Get('consumption/:vehicleId/:month')
+  @BookingStaff(FREIGHT_PERMS.fuel.view)
   @ApiOperation({ summary: 'Get monthly fuel consumption' })
   async getMonthlyConsumption(
     @Param('vehicleId') vehicleId: string,
@@ -44,12 +59,14 @@ export class FuelController {
   }
 
   @Get('stats')
+  @BookingStaff(FUEL_STATS_PERMS)
   @ApiOperation({ summary: 'Get fleet-wide fuel statistics' })
   async getFleetFuelStats(@Query('months') months: number = 12) {
     return this.fuelService.getFleetFuelStats(months);
   }
 
   @Get('stats/:vehicleId')
+  @BookingStaff(FUEL_STATS_PERMS)
   @ApiOperation({ summary: 'Get fuel statistics for vehicle' })
   async getVehicleFuelStats(
     @Param('vehicleId') vehicleId: string,
diff --git a/apps/edr-freight-api/src/modules/gps-tracking/dto/gps-device.dto.ts b/apps/edr-freight-api/src/modules/gps-tracking/dto/gps-device.dto.ts
new file mode 100644
index 000000000..933699f0b
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/gps-tracking/dto/gps-device.dto.ts
@@ -0,0 +1,24 @@
+import { IsOptional, IsString, IsUUID } from 'class-validator';
+
+export class RegisterDeviceDto {
+  @IsString()
+  imei!: string;
+
+  @IsOptional()
+  @IsString()
+  name?: string;
+
+  @IsOptional()
+  @IsUUID()
+  vehicleId?: string;
+}
+
+export class UpdateDeviceDto {
+  @IsOptional()
+  @IsString()
+  name?: string;
+
+  @IsOptional()
+  @IsUUID()
+  vehicleId?: string | null;
+}
diff --git a/apps/edr-freight-api/src/modules/gps-tracking/entities/gps-device.entity.ts b/apps/edr-freight-api/src/modules/gps-tracking/entities/gps-device.entity.ts
new file mode 100644
index 000000000..ac5f7dbc6
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/gps-tracking/entities/gps-device.entity.ts
@@ -0,0 +1,55 @@
+import { BaseEntity } from '@edr/api-common';
+import { Column, Entity, Index, JoinColumn, ManyToOne } from 'typeorm';
+
+import { Vehicle } from '../../vehicles/entities/vehicle.entity';
+
+/**
+ * A physical GPS tracker (GT06). Identified by IMEI, optionally bound to a
+ * vehicle. Carries the denormalized latest fix so the live map reads one row
+ * per device without scanning position history.
+ */
+@Entity({ name: 'gps_devices', schema: 'freight' })
+@Index(['vehicleId'])
+export class GpsDevice extends BaseEntity {
+  @Column({ name: 'imei', type: 'varchar', length: 20, unique: true })
+  imei!: string;
+
+  @Column({ name: 'name', type: 'varchar', nullable: true })
+  name?: string | null;
+
+  @Column({ name: 'vehicle_id', type: 'uuid', nullable: true })
+  vehicleId?: string | null;
+
+  @ManyToOne(() => Vehicle, { nullable: true, eager: false })
+  @JoinColumn({ name: 'vehicle_id' })
+  vehicle?: Vehicle | null;
+
+  /** ONLINE once a packet arrives; OFFLINE when stale (derived on read). */
+  @Column({ name: 'status', type: 'varchar', length: 16, default: 'REGISTERED' })
+  status!: string;
+
+  @Column({ name: 'last_seen_at', type: 'timestamptz', nullable: true })
+  lastSeenAt?: Date | null;
+
+  // ── Denormalized latest fix ──
+  @Column({ name: 'last_lat', type: 'numeric', precision: 10, scale: 6, nullable: true })
+  lastLat?: number | null;
+
+  @Column({ name: 'last_lng', type: 'numeric', precision: 10, scale: 6, nullable: true })
+  lastLng?: number | null;
+
+  @Column({ name: 'last_speed', type: 'numeric', precision: 6, scale: 2, nullable: true })
+  lastSpeed?: number | null;
+
+  @Column({ name: 'last_course', type: 'int', nullable: true })
+  lastCourse?: number | null;
+
+  @Column({ name: 'last_fix_at', type: 'timestamptz', nullable: true })
+  lastFixAt?: Date | null;
+
+  @Column({ name: 'voltage_level', type: 'int', nullable: true })
+  voltageLevel?: number | null;
+
+  @Column({ name: 'gsm_level', type: 'int', nullable: true })
+  gsmLevel?: number | null;
+}
diff --git a/apps/edr-freight-api/src/modules/gps-tracking/entities/gps-position.entity.ts b/apps/edr-freight-api/src/modules/gps-tracking/entities/gps-position.entity.ts
new file mode 100644
index 000000000..8c63bb78f
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/gps-tracking/entities/gps-position.entity.ts
@@ -0,0 +1,43 @@
+import { BaseEntity } from '@edr/api-common';
+import { Column, Entity, Index } from 'typeorm';
+
+/** One GPS fix from a tracker (append-only history). */
+@Entity({ name: 'gps_positions', schema: 'freight' })
+@Index(['deviceId', 'gpsTime'])
+@Index(['vehicleId', 'gpsTime'])
+export class GpsPosition extends BaseEntity {
+  @Column({ name: 'device_id', type: 'uuid' })
+  deviceId!: string;
+
+  @Column({ name: 'imei', type: 'varchar', length: 20 })
+  imei!: string;
+
+  @Column({ name: 'vehicle_id', type: 'uuid', nullable: true })
+  vehicleId?: string | null;
+
+  @Column({ name: 'lat', type: 'numeric', precision: 10, scale: 6 })
+  lat!: number;
+
+  @Column({ name: 'lng', type: 'numeric', precision: 10, scale: 6 })
+  lng!: number;
+
+  @Column({ name: 'speed', type: 'numeric', precision: 6, scale: 2, default: 0 })
+  speed!: number;
+
+  @Column({ name: 'course', type: 'int', default: 0 })
+  course!: number;
+
+  @Column({ name: 'satellites', type: 'int', default: 0 })
+  satellites!: number;
+
+  @Column({ name: 'positioned', type: 'boolean', default: false })
+  positioned!: boolean;
+
+  /** Fix time reported by the device (UTC). */
+  @Column({ name: 'gps_time', type: 'timestamptz' })
+  gpsTime!: Date;
+
+  /** Non-zero when the fix came in via an alarm packet. */
+  @Column({ name: 'alarm', type: 'int', default: 0 })
+  alarm!: number;
+}
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
new file mode 100644
index 000000000..e380e541e
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/gps-tracking/gps-tracking.controller.ts
@@ -0,0 +1,66 @@
+import {
+  Body,
+  Controller,
+  Delete,
+  Get,
+  Param,
+  ParseUUIDPipe,
+  Patch,
+  Post,
+  Query,
+} from '@nestjs/common';
+import { ApiBearerAuth, ApiOperation, ApiTags } from '@nestjs/swagger';
+
+import { FleetManage, FleetView } from '../../common/booking-guards';
+import { GpsTrackingService } from './gps-tracking.service';
+import { RegisterDeviceDto, UpdateDeviceDto } from './dto/gps-device.dto';
+
+@ApiTags('gps-tracking')
+@ApiBearerAuth()
+@Controller('gps')
+@FleetView()
+export class GpsTrackingController {
+  constructor(private readonly gps: GpsTrackingService) {}
+
+  @Get('positions/latest')
+  @ApiOperation({ summary: 'Latest fix per device (live map feed)' })
+  latest() {
+    return this.gps.latest();
+  }
+
+  @Get('positions/:vehicleId/history')
+  @ApiOperation({ summary: 'Position history for a vehicle' })
+  history(
+    @Param('vehicleId', ParseUUIDPipe) vehicleId: string,
+    @Query('limit') limit?: string,
+  ) {
+    return this.gps.history(vehicleId, limit ? parseInt(limit, 10) : undefined);
+  }
+
+  @Get('devices')
+  @ApiOperation({ summary: 'List GPS trackers' })
+  listDevices() {
+    return this.gps.listDevices();
+  }
+
+  @Post('devices')
+  @FleetManage()
+  @ApiOperation({ summary: 'Register a GPS tracker' })
+  register(@Body() dto: RegisterDeviceDto) {
+    return this.gps.registerDevice(dto);
+  }
+
+  @Patch('devices/:id')
+  @FleetManage()
+  @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()
+  @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/gps-tracking/gps-tracking.module.ts b/apps/edr-freight-api/src/modules/gps-tracking/gps-tracking.module.ts
new file mode 100644
index 000000000..da527fff0
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/gps-tracking/gps-tracking.module.ts
@@ -0,0 +1,17 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+
+import { GpsDevice } from './entities/gps-device.entity';
+import { GpsPosition } from './entities/gps-position.entity';
+import { GpsDeviceRepository, GpsPositionRepository } from './gps-tracking.repository';
+import { GpsTrackingService } from './gps-tracking.service';
+import { GpsTrackingController } from './gps-tracking.controller';
+import { Gt06Server } from './gt06/gt06.server';
+
+@Module({
+  imports: [TypeOrmModule.forFeature([GpsDevice, GpsPosition])],
+  controllers: [GpsTrackingController],
+  providers: [GpsDeviceRepository, GpsPositionRepository, GpsTrackingService, Gt06Server],
+  exports: [GpsTrackingService],
+})
+export class GpsTrackingModule {}
diff --git a/apps/edr-freight-api/src/modules/gps-tracking/gps-tracking.repository.ts b/apps/edr-freight-api/src/modules/gps-tracking/gps-tracking.repository.ts
new file mode 100644
index 000000000..326ef66ac
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/gps-tracking/gps-tracking.repository.ts
@@ -0,0 +1,29 @@
+import { BaseRepository } from '@edr/api-common';
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+
+import { GpsDevice } from './entities/gps-device.entity';
+import { GpsPosition } from './entities/gps-position.entity';
+
+@Injectable()
+export class GpsDeviceRepository extends BaseRepository<GpsDevice> {
+  constructor(
+    @InjectRepository(GpsDevice) repository: Repository<GpsDevice>,
+  ) {
+    super(repository);
+  }
+
+  findByImei(imei: string): Promise<GpsDevice | null> {
+    return this.repository.findOne({ where: { imei } });
+  }
+}
+
+@Injectable()
+export class GpsPositionRepository extends BaseRepository<GpsPosition> {
+  constructor(
+    @InjectRepository(GpsPosition) repository: Repository<GpsPosition>,
+  ) {
+    super(repository);
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/gps-tracking/gps-tracking.service.ts b/apps/edr-freight-api/src/modules/gps-tracking/gps-tracking.service.ts
new file mode 100644
index 000000000..b5bea3a3f
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/gps-tracking/gps-tracking.service.ts
@@ -0,0 +1,124 @@
+import { BadRequestException, Injectable, Logger, NotFoundException } from '@nestjs/common';
+
+import { GpsDeviceRepository, GpsPositionRepository } from './gps-tracking.repository';
+import { GpsDevice } from './entities/gps-device.entity';
+import { Gt06Gps, Gt06Status } from './gt06/gt06.codec';
+
+/** A device is considered ONLINE if seen within this window. */
+const ONLINE_WINDOW_MS = 5 * 60 * 1000;
+
+@Injectable()
+export class GpsTrackingService {
+  private readonly logger = new Logger(GpsTrackingService.name);
+
+  constructor(
+    private readonly devices: GpsDeviceRepository,
+    private readonly positions: GpsPositionRepository,
+  ) {}
+
+  private isOnline(d: GpsDevice): boolean {
+    return Boolean(d.lastSeenAt && Date.now() - new Date(d.lastSeenAt).getTime() < ONLINE_WINDOW_MS);
+  }
+
+  /** Find the device for an IMEI, auto-registering it on first contact. */
+  private async ensureDevice(imei: string): Promise<GpsDevice> {
+    const existing = await this.devices.findByImei(imei);
+    if (existing) return existing;
+    this.logger.log(`Auto-registering new GPS tracker ${imei}`);
+    return this.devices.create({ imei, status: 'REGISTERED', lastSeenAt: new Date() });
+  }
+
+  // ── Ingestion (called by the TCP server) ──
+
+  async handleLogin(imei: string): Promise<void> {
+    const device = await this.ensureDevice(imei);
+    await this.devices.update(device.id, { lastSeenAt: new Date(), status: 'ONLINE' });
+  }
+
+  async handleHeartbeat(imei: string, status: Gt06Status): Promise<void> {
+    const device = await this.ensureDevice(imei);
+    await this.devices.update(device.id, {
+      lastSeenAt: new Date(),
+      status: 'ONLINE',
+      voltageLevel: status.voltageLevel,
+      gsmLevel: status.gsmLevel,
+    });
+  }
+
+  async handleFix(imei: string, gps: Gt06Gps, alarm = 0, status?: Gt06Status): Promise<void> {
+    const device = await this.ensureDevice(imei);
+    const now = new Date();
+    await this.devices.update(device.id, {
+      lastSeenAt: now,
+      status: 'ONLINE',
+      lastLat: gps.latitude,
+      lastLng: gps.longitude,
+      lastSpeed: gps.speed,
+      lastCourse: gps.course,
+      lastFixAt: new Date(gps.time),
+      ...(status ? { voltageLevel: status.voltageLevel, gsmLevel: status.gsmLevel } : {}),
+    });
+    await this.positions.create({
+      deviceId: device.id,
+      imei,
+      vehicleId: device.vehicleId ?? null,
+      lat: gps.latitude,
+      lng: gps.longitude,
+      speed: gps.speed,
+      course: gps.course,
+      satellites: gps.satellites,
+      positioned: gps.positioned,
+      gpsTime: new Date(gps.time),
+      alarm,
+    });
+  }
+
+  // ── Queries / management (REST) ──
+
+  private decorate(d: GpsDevice) {
+    return { ...d, online: this.isOnline(d) };
+  }
+
+  async listDevices() {
+    const rows = await this.devices.findAll({ relations: { vehicle: true }, order: { createdAt: 'DESC' } });
+    return rows.map((d) => this.decorate(d));
+  }
+
+  /** Live map feed — devices that have at least one fix. */
+  async latest() {
+    const rows = await this.devices.findAll({ relations: { vehicle: true } });
+    return rows.filter((d) => d.lastLat != null && d.lastLng != null).map((d) => this.decorate(d));
+  }
+
+  async history(vehicleId: string, limit = 200) {
+    return this.positions.findAll({
+      where: { vehicleId },
+      order: { gpsTime: 'DESC' },
+      take: Math.min(limit, 1000),
+    });
+  }
+
+  async registerDevice(dto: { imei: string; name?: string; vehicleId?: string | null }) {
+    const existing = await this.devices.findByImei(dto.imei);
+    if (existing) throw new BadRequestException(`A device with IMEI ${dto.imei} already exists`);
+    return this.devices.create({
+      imei: dto.imei,
+      name: dto.name ?? null,
+      vehicleId: dto.vehicleId ?? null,
+      status: 'REGISTERED',
+    });
+  }
+
+  async updateDevice(id: string, dto: { name?: string; vehicleId?: string | null }) {
+    const updated = await this.devices.update(id, {
+      ...(dto.name !== undefined ? { name: dto.name } : {}),
+      ...(dto.vehicleId !== undefined ? { vehicleId: dto.vehicleId } : {}),
+    });
+    if (!updated) throw new NotFoundException(`GPS device ${id} not found`);
+    return updated;
+  }
+
+  async removeDevice(id: string): Promise<void> {
+    await this.devices.softDelete(id);
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/gps-tracking/gt06/gt06.codec.ts b/apps/edr-freight-api/src/modules/gps-tracking/gt06/gt06.codec.ts
new file mode 100644
index 000000000..d54f906a2
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/gps-tracking/gt06/gt06.codec.ts
@@ -0,0 +1,207 @@
+/**
+ * GT06 GPS-tracker protocol codec.
+ *
+ * Frame: 0x78 0x78 | len(1) | protocol(1) | content(N) | serial(2) | crc(2) | 0x0D 0x0A
+ * `len` counts protocol..crc (= 5 + N). CRC-ITU (CRC-16/X.25) is computed over
+ * len..serial (inclusive) and equals the 2 crc bytes.
+ */
+
+const START = 0x7878;
+const STOP = 0x0d0a;
+
+export const GT06_PROTOCOL = {
+  LOGIN: 0x01,
+  LOCATION: 0x12,
+  HEARTBEAT: 0x13,
+  STRING: 0x15,
+  ALARM: 0x16,
+  ADDRESS_BY_PHONE: 0x1a,
+  SERVER_COMMAND: 0x80,
+} as const;
+
+/** CRC-16/X.25 (a.k.a. CRC-ITU) used by GT06 — reflected, poly 0x8408, init/xorout 0xFFFF. */
+export function crcItu(bytes: Buffer): number {
+  let fcs = 0xffff;
+  for (const b of bytes) {
+    fcs ^= b;
+    for (let i = 0; i < 8; i++) {
+      fcs = fcs & 1 ? (fcs >> 1) ^ 0x8408 : fcs >> 1;
+    }
+  }
+  return (~fcs) & 0xffff;
+}
+
+export interface Gt06Gps {
+  time: string; // ISO (UTC)
+  satellites: number;
+  latitude: number;
+  longitude: number;
+  speed: number; // km/h
+  course: number; // 0-360
+  positioned: boolean;
+}
+
+export interface Gt06Lbs {
+  mcc: number;
+  mnc: number;
+  lac: number;
+  cellId: number;
+}
+
+export interface Gt06Status {
+  terminalInfo: number;
+  voltageLevel: number;
+  gsmLevel: number;
+  alarm: number; // former byte of alarm/language
+  charging: boolean;
+  accOn: boolean;
+  gpsTracking: boolean;
+  oilCut: boolean;
+}
+
+export type Gt06Packet =
+  | { type: 'login'; protocol: number; serial: number; imei: string }
+  | { type: 'location'; protocol: number; serial: number; gps: Gt06Gps; lbs: Gt06Lbs }
+  | { type: 'heartbeat'; protocol: number; serial: number; status: Gt06Status }
+  | { type: 'alarm'; protocol: number; serial: number; gps: Gt06Gps; lbs: Gt06Lbs; status: Gt06Status }
+  | { type: 'unknown'; protocol: number; serial: number };
+
+/** Terminal ID (8 BCD bytes) → 15-digit IMEI (drops the leading pad nibble). */
+function decodeImei(buf: Buffer): string {
+  return buf.toString('hex').replace(/^0/, '');
+}
+
+function decodeDateTime(buf: Buffer, off: number): string {
+  const year = 2000 + buf[off];
+  const month = buf[off + 1];
+  const day = buf[off + 2];
+  const hour = buf[off + 3];
+  const min = buf[off + 4];
+  const sec = buf[off + 5];
+  return new Date(Date.UTC(year, month - 1, day, hour, min, sec)).toISOString();
+}
+
+/** Convert a GT06 lat/long raw uint32 to decimal degrees (magnitude only). */
+function rawToDegrees(raw: number): number {
+  return raw / 30000 / 60;
+}
+
+function decodeGps(buf: Buffer, off: number): Gt06Gps {
+  const time = decodeDateTime(buf, off);
+  const lenSat = buf[off + 6];
+  const satellites = lenSat & 0x0f;
+  const latRaw = buf.readUInt32BE(off + 7);
+  const lonRaw = buf.readUInt32BE(off + 11);
+  const speed = buf[off + 15];
+  const cs = buf.readUInt16BE(off + 16);
+  const hi = (cs >> 8) & 0xff;
+  const positioned = Boolean(hi & 0x10); // BYTE_1 Bit4
+  const isWest = Boolean(hi & 0x08); // BYTE_1 Bit3 (1 = West)
+  const isNorth = Boolean(hi & 0x04); // BYTE_1 Bit2 (1 = North)
+  const course = cs & 0x03ff; // BYTE_1 Bit1-0 + BYTE_2
+  let latitude = rawToDegrees(latRaw);
+  let longitude = rawToDegrees(lonRaw);
+  if (!isNorth) latitude = -latitude;
+  if (isWest) longitude = -longitude;
+  return { time, satellites, latitude, longitude, speed, course, positioned };
+}
+
+function decodeStatus(buf: Buffer, off: number): Gt06Status {
+  const terminalInfo = buf[off];
+  const voltageLevel = buf[off + 1];
+  const gsmLevel = buf[off + 2];
+  const alarm = buf[off + 3]; // alarm/language former byte
+  return {
+    terminalInfo,
+    voltageLevel,
+    gsmLevel,
+    alarm,
+    oilCut: Boolean(terminalInfo & 0x80),
+    gpsTracking: Boolean(terminalInfo & 0x40),
+    charging: Boolean(terminalInfo & 0x04),
+    accOn: Boolean(terminalInfo & 0x02),
+  };
+}
+
+function decodeLbs(buf: Buffer, off: number): Gt06Lbs {
+  return {
+    mcc: buf.readUInt16BE(off),
+    mnc: buf[off + 2],
+    lac: buf.readUInt16BE(off + 3),
+    cellId: buf.readUIntBE(off + 5, 3),
+  };
+}
+
+function decodeFrame(frame: Buffer): Gt06Packet | null {
+  // frame = 78 78 len ...content... serial(2) crc(2) 0D 0A
+  const len = frame[2];
+  const protocol = frame[3];
+  const serialOff = 3 + (len - 4); // after protocol + content, before serial(2)+crc(2)
+  const serial = frame.readUInt16BE(serialOff);
+  const contentOff = 4; // start of content (after protocol)
+
+  switch (protocol) {
+    case GT06_PROTOCOL.LOGIN:
+      return { type: 'login', protocol, serial, imei: decodeImei(frame.subarray(contentOff, contentOff + 8)) };
+    case GT06_PROTOCOL.LOCATION:
+      return { type: 'location', protocol, serial, gps: decodeGps(frame, contentOff), lbs: decodeLbs(frame, contentOff + 18) };
+    case GT06_PROTOCOL.HEARTBEAT:
+      return { type: 'heartbeat', protocol, serial, status: decodeStatus(frame, contentOff) };
+    case GT06_PROTOCOL.ALARM: {
+      const gps = decodeGps(frame, contentOff);
+      // content: date(6)+lenSat(1)+lat(4)+lng(4)+speed(1)+course(2)=18, lbsLen(1), lbs(8), status(1+1+1+2)
+      const lbs = decodeLbs(frame, contentOff + 18 + 1);
+      const status = decodeStatus(frame, contentOff + 18 + 1 + 8);
+      return { type: 'alarm', protocol, serial, gps, lbs, status };
+    }
+    default:
+      return { type: 'unknown', protocol, serial };
+  }
+}
+
+/**
+ * Pull all complete frames out of a stream buffer. Returns the decoded packets
+ * (skipping CRC-failed ones) and the trailing bytes that form a partial frame.
+ */
+export function parseStream(buffer: Buffer): { packets: Gt06Packet[]; rest: Buffer } {
+  const packets: Gt06Packet[] = [];
+  let i = 0;
+  while (i + 5 <= buffer.length) {
+    if (buffer.readUInt16BE(i) !== START) {
+      i += 1; // resync
+      continue;
+    }
+    const len = buffer[i + 2];
+    const frameLen = 2 + 1 + len + 2; // start + lenByte + (protocol..crc) + stop
+    if (i + frameLen > buffer.length) break; // incomplete
+    const frame = buffer.subarray(i, i + frameLen);
+    if (frame.readUInt16BE(frameLen - 2) === STOP) {
+      // CRC over len..serial (frame[2 .. frameLen-4]); crc bytes are frameLen-4..frameLen-3.
+      const crcCalc = crcItu(frame.subarray(2, frameLen - 4));
+      const crcRecv = frame.readUInt16BE(frameLen - 4);
+      if (crcCalc === crcRecv) {
+        const pkt = decodeFrame(frame);
+        if (pkt) packets.push(pkt);
+      }
+      i += frameLen;
+    } else {
+      i += 1; // bad frame, resync
+    }
+  }
+  return { packets, rest: buffer.subarray(i) };
+}
+
+/** Build a server → terminal ACK (login/heartbeat/alarm) echoing the serial. */
+export function buildAck(protocol: number, serial: number): Buffer {
+  const body = Buffer.alloc(3); // protocol + serial(2)
+  body[0] = protocol;
+  body.writeUInt16BE(serial, 1);
+  const len = body.length + 2; // + crc(2)
+  const forCrc = Buffer.concat([Buffer.from([len]), body]);
+  const crc = crcItu(forCrc);
+  return Buffer.concat([
+    Buffer.from([0x78, 0x78, len]),
+    body,
+    Buffer.from([(crc >> 8) & 0xff, crc & 0xff, 0x0d, 0x0a]),
+  ]);
+}
diff --git a/apps/edr-freight-api/src/modules/gps-tracking/gt06/gt06.server.ts b/apps/edr-freight-api/src/modules/gps-tracking/gt06/gt06.server.ts
new file mode 100644
index 000000000..a2095fa12
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/gps-tracking/gt06/gt06.server.ts
@@ -0,0 +1,97 @@
+import { Injectable, Logger, OnApplicationBootstrap, OnModuleDestroy } from '@nestjs/common';
+import * as net from 'net';
+
+import { GpsTrackingService } from '../gps-tracking.service';
+import { buildAck, GT06_PROTOCOL, parseStream } from './gt06.codec';
+
+interface Session {
+  buffer: Buffer;
+  imei: string | null;
+}
+
+const MAX_BUFFER = 64 * 1024;
+
+/**
+ * Raw TCP listener for GT06 GPS trackers. Trackers open a socket, send a login
+ * (IMEI), then stream location/heartbeat/alarm packets; we decode, persist via
+ * {@link GpsTrackingService}, and ACK login/heartbeat/alarm so the device keeps
+ * the connection alive. Disabled when GT06_TCP_PORT=0.
+ */
+@Injectable()
+export class Gt06Server implements OnApplicationBootstrap, OnModuleDestroy {
+  private readonly logger = new Logger(Gt06Server.name);
+  private server?: net.Server;
+  private readonly sessions = new Map<net.Socket, Session>();
+
+  constructor(private readonly gps: GpsTrackingService) {}
+
+  onApplicationBootstrap(): void {
+    const port = Number(process.env.GT06_TCP_PORT ?? 5023);
+    if (!port) {
+      this.logger.log('GT06 TCP listener disabled (GT06_TCP_PORT=0)');
+      return;
+    }
+    const host = process.env.GT06_TCP_HOST ?? '0.0.0.0';
+    this.server = net.createServer((socket) => this.onConnection(socket));
+    this.server.on('error', (err) => this.logger.error(`GT06 server error: ${String(err)}`));
+    this.server.listen(port, host, () => this.logger.log(`GT06 GPS tracker listener on ${host}:${port}`));
+  }
+
+  onModuleDestroy(): void {
+    for (const socket of this.sessions.keys()) socket.destroy();
+    this.sessions.clear();
+    this.server?.close();
+  }
+
+  private onConnection(socket: net.Socket): void {
+    this.sessions.set(socket, { buffer: Buffer.alloc(0), imei: null });
+    socket.on('data', (chunk) => void this.onData(socket, chunk));
+    socket.on('error', () => this.sessions.delete(socket));
+    socket.on('close', () => this.sessions.delete(socket));
+  }
+
+  private async onData(socket: net.Socket, chunk: Buffer): Promise<void> {
+    const session = this.sessions.get(socket);
+    if (!session) return;
+    session.buffer = Buffer.concat([session.buffer, chunk]);
+    if (session.buffer.length > MAX_BUFFER) session.buffer = Buffer.alloc(0); // drop garbage
+
+    const { packets, rest } = parseStream(session.buffer);
+    session.buffer = rest;
+
+    for (const pkt of packets) {
+      try {
+        await this.handle(socket, session, pkt);
+      } catch (err) {
+        this.logger.error(`Failed to handle GT06 packet (${pkt.type}): ${String(err)}`);
+      }
+    }
+  }
+
+  private async handle(
+    socket: net.Socket,
+    session: Session,
+    pkt: ReturnType<typeof parseStream>['packets'][number],
+  ): Promise<void> {
+    switch (pkt.type) {
+      case 'login':
+        session.imei = pkt.imei;
+        await this.gps.handleLogin(pkt.imei);
+        socket.write(buildAck(GT06_PROTOCOL.LOGIN, pkt.serial));
+        break;
+      case 'heartbeat':
+        if (session.imei) await this.gps.handleHeartbeat(session.imei, pkt.status);
+        socket.write(buildAck(GT06_PROTOCOL.HEARTBEAT, pkt.serial));
+        break;
+      case 'location':
+        if (session.imei) await this.gps.handleFix(session.imei, pkt.gps);
+        break;
+      case 'alarm':
+        if (session.imei) await this.gps.handleFix(session.imei, pkt.gps, pkt.status.alarm, pkt.status);
+        socket.write(buildAck(GT06_PROTOCOL.ALARM, pkt.serial));
+        break;
+      default:
+        break;
+    }
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/incidents/dto/create-incident.dto.ts b/apps/edr-freight-api/src/modules/incidents/dto/create-incident.dto.ts
new file mode 100644
index 000000000..5d76885b4
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/incidents/dto/create-incident.dto.ts
@@ -0,0 +1,48 @@
+import { IsUUID, IsString, IsDateString, IsNumber, IsOptional, IsEnum } from 'class-validator';
+import { IncidentType, IncidentSeverity, IncidentStatus } from '../entities/incident.entity';
+
+export class CreateIncidentDto {
+  @IsOptional()
+  @IsUUID()
+  vehicleId?: string;
+
+  @IsOptional()
+  @IsUUID()
+  driverId?: string;
+
+  @IsOptional()
+  @IsUUID()
+  bookingId?: string;
+
+  @IsEnum(IncidentType)
+  type!: IncidentType;
+
+  @IsEnum(IncidentSeverity)
+  severity!: IncidentSeverity;
+
+  @IsDateString()
+  occurredAt!: string;
+
+  @IsOptional()
+  @IsString()
+  location?: string;
+
+  @IsString()
+  description!: string;
+
+  @IsOptional()
+  @IsNumber()
+  damageEstimate?: number;
+
+  @IsOptional()
+  @IsEnum(IncidentStatus)
+  status?: IncidentStatus;
+
+  @IsOptional()
+  @IsString()
+  insuranceClaimNumber?: string;
+
+  @IsOptional()
+  @IsString()
+  reportedBy?: string;
+}
diff --git a/apps/edr-freight-api/src/modules/incidents/dto/update-incident.dto.ts b/apps/edr-freight-api/src/modules/incidents/dto/update-incident.dto.ts
new file mode 100644
index 000000000..b45d478e0
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/incidents/dto/update-incident.dto.ts
@@ -0,0 +1,52 @@
+import { IsUUID, IsString, IsDateString, IsNumber, IsOptional, IsEnum } from 'class-validator';
+import { IncidentType, IncidentSeverity, IncidentStatus } from '../entities/incident.entity';
+
+export class UpdateIncidentDto {
+  @IsOptional()
+  @IsUUID()
+  vehicleId?: string;
+
+  @IsOptional()
+  @IsUUID()
+  driverId?: string;
+
+  @IsOptional()
+  @IsUUID()
+  bookingId?: string;
+
+  @IsOptional()
+  @IsEnum(IncidentType)
+  type?: IncidentType;
+
+  @IsOptional()
+  @IsEnum(IncidentSeverity)
+  severity?: IncidentSeverity;
+
+  @IsOptional()
+  @IsDateString()
+  occurredAt?: string;
+
+  @IsOptional()
+  @IsString()
+  location?: string;
+
+  @IsOptional()
+  @IsString()
+  description?: string;
+
+  @IsOptional()
+  @IsNumber()
+  damageEstimate?: number;
+
+  @IsOptional()
+  @IsEnum(IncidentStatus)
+  status?: IncidentStatus;
+
+  @IsOptional()
+  @IsString()
+  insuranceClaimNumber?: string;
+
+  @IsOptional()
+  @IsString()
+  reportedBy?: string;
+}
diff --git a/apps/edr-freight-api/src/modules/incidents/entities/incident.entity.ts b/apps/edr-freight-api/src/modules/incidents/entities/incident.entity.ts
new file mode 100644
index 000000000..2c71cc8a3
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/incidents/entities/incident.entity.ts
@@ -0,0 +1,76 @@
+import { BaseEntity } from '@edr/api-common';
+import { Entity, Column, ManyToOne, JoinColumn, Index } from 'typeorm';
+import { Vehicle } from '../../vehicles/entities/vehicle.entity';
+import { Driver } from '../../drivers/entities/driver.entity';
+
+export enum IncidentType {
+  ACCIDENT = 'ACCIDENT',
+  BREAKDOWN = 'BREAKDOWN',
+  TRAFFIC_VIOLATION = 'TRAFFIC_VIOLATION',
+  THEFT = 'THEFT',
+  OTHER = 'OTHER',
+}
+
+export enum IncidentSeverity {
+  MINOR = 'MINOR',
+  MODERATE = 'MODERATE',
+  MAJOR = 'MAJOR',
+  CRITICAL = 'CRITICAL',
+}
+
+export enum IncidentStatus {
+  REPORTED = 'REPORTED',
+  UNDER_REVIEW = 'UNDER_REVIEW',
+  CLAIM_FILED = 'CLAIM_FILED',
+  RESOLVED = 'RESOLVED',
+  CLOSED = 'CLOSED',
+}
+
+@Entity({ name: 'incidents', schema: 'freight' })
+@Index(['driverId', 'occurredAt'])
+@Index(['vehicleId', 'occurredAt'])
+export class Incident extends BaseEntity {
+  @Column({ name: 'vehicle_id', type: 'uuid', nullable: true })
+  vehicleId?: string;
+
+  @ManyToOne(() => Vehicle, { eager: false, nullable: true })
+  @JoinColumn({ name: 'vehicle_id' })
+  vehicle?: Vehicle;
+
+  @Column({ name: 'driver_id', type: 'uuid', nullable: true })
+  driverId?: string;
+
+  @ManyToOne(() => Driver, { eager: false, nullable: true })
+  @JoinColumn({ name: 'driver_id' })
+  driver?: Driver;
+
+  @Column({ name: 'booking_id', type: 'uuid', nullable: true })
+  bookingId?: string;
+
+  @Column({ name: 'type', type: 'varchar' })
+  type!: IncidentType;
+
+  @Column({ name: 'severity', type: 'varchar' })
+  severity!: IncidentSeverity;
+
+  @Column({ name: 'occurred_at', type: 'timestamptz' })
+  occurredAt!: Date;
+
+  @Column({ name: 'location', type: 'varchar', nullable: true })
+  location?: string;
+
+  @Column({ name: 'description', type: 'text' })
+  description!: string;
+
+  @Column({ name: 'damage_estimate', type: 'numeric', precision: 14, scale: 2, nullable: true })
+  damageEstimate?: number;
+
+  @Column({ name: 'status', type: 'varchar', default: IncidentStatus.REPORTED })
+  status!: IncidentStatus;
+
+  @Column({ name: 'insurance_claim_number', type: 'varchar', nullable: true })
+  insuranceClaimNumber?: string;
+
+  @Column({ name: 'reported_by', type: 'varchar', nullable: true })
+  reportedBy?: string;
+}
diff --git a/apps/edr-freight-api/src/modules/incidents/incidents.controller.ts b/apps/edr-freight-api/src/modules/incidents/incidents.controller.ts
new file mode 100644
index 000000000..ab6d5ef08
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/incidents/incidents.controller.ts
@@ -0,0 +1,69 @@
+import {
+  Controller,
+  Post,
+  Get,
+  Patch,
+  Delete,
+  Body,
+  Param,
+  Query,
+} from '@nestjs/common';
+import { ApiTags, ApiOperation } from '@nestjs/swagger';
+import { IncidentsService } from './incidents.service';
+import { CreateIncidentDto } from './dto/create-incident.dto';
+import { UpdateIncidentDto } from './dto/update-incident.dto';
+import { IncidentStatus, IncidentType } from './entities/incident.entity';
+
+@ApiTags('Accident & Incident Management')
+@Controller('incidents')
+export class IncidentsController {
+  constructor(private readonly incidentsService: IncidentsService) {}
+
+  @Post()
+  @ApiOperation({ summary: 'Report an incident' })
+  async create(@Body() dto: CreateIncidentDto) {
+    return this.incidentsService.create(dto);
+  }
+
+  @Get()
+  @ApiOperation({ summary: 'List incidents (optionally filtered)' })
+  async findAll(
+    @Query('vehicleId') vehicleId?: string,
+    @Query('driverId') driverId?: string,
+    @Query('status') status?: IncidentStatus,
+    @Query('type') type?: IncidentType,
+  ) {
+    return this.incidentsService.findAll({ vehicleId, driverId, status, type });
+  }
+
+  @Get('driver/:driverId/stats')
+  @ApiOperation({ summary: 'Get incident statistics for a driver' })
+  async statsForDriver(@Param('driverId') driverId: string) {
+    return this.incidentsService.statsForDriver(driverId);
+  }
+
+  @Get('driver/:driverId')
+  @ApiOperation({ summary: 'List incidents for a driver (incident history)' })
+  async findByDriver(@Param('driverId') driverId: string) {
+    return this.incidentsService.findByDriver(driverId);
+  }
+
+  @Get(':id')
+  @ApiOperation({ summary: 'Get an incident by id' })
+  async findById(@Param('id') id: string) {
+    return this.incidentsService.findById(id);
+  }
+
+  @Patch(':id')
+  @ApiOperation({ summary: 'Update an incident' })
+  async update(@Param('id') id: string, @Body() dto: UpdateIncidentDto) {
+    return this.incidentsService.update(id, dto);
+  }
+
+  @Delete(':id')
+  @ApiOperation({ summary: 'Delete an incident' })
+  async remove(@Param('id') id: string) {
+    await this.incidentsService.remove(id);
+    return { success: true };
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/incidents/incidents.module.ts b/apps/edr-freight-api/src/modules/incidents/incidents.module.ts
new file mode 100644
index 000000000..872fbaab1
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/incidents/incidents.module.ts
@@ -0,0 +1,14 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { Incident } from './entities/incident.entity';
+import { IncidentsService } from './incidents.service';
+import { IncidentsRepository } from './incidents.repository';
+import { IncidentsController } from './incidents.controller';
+
+@Module({
+  imports: [TypeOrmModule.forFeature([Incident])],
+  providers: [IncidentsService, IncidentsRepository],
+  controllers: [IncidentsController],
+  exports: [IncidentsService],
+})
+export class IncidentsModule {}
diff --git a/apps/edr-freight-api/src/modules/incidents/incidents.repository.ts b/apps/edr-freight-api/src/modules/incidents/incidents.repository.ts
new file mode 100644
index 000000000..1d9f17770
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/incidents/incidents.repository.ts
@@ -0,0 +1,15 @@
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { BaseRepository } from '@edr/api-common';
+import { Repository } from 'typeorm';
+import { Incident } from './entities/incident.entity';
+
+@Injectable()
+export class IncidentsRepository extends BaseRepository<Incident> {
+  constructor(
+    @InjectRepository(Incident)
+    incidentRepository: Repository<Incident>,
+  ) {
+    super(incidentRepository);
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/incidents/incidents.service.ts b/apps/edr-freight-api/src/modules/incidents/incidents.service.ts
new file mode 100644
index 000000000..ea28a96e2
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/incidents/incidents.service.ts
@@ -0,0 +1,95 @@
+import { Injectable, NotFoundException } from '@nestjs/common';
+import { FindOptionsWhere } from 'typeorm';
+import { IncidentsRepository } from './incidents.repository';
+import {
+  Incident,
+  IncidentStatus,
+  IncidentType,
+} from './entities/incident.entity';
+import { CreateIncidentDto } from './dto/create-incident.dto';
+import { UpdateIncidentDto } from './dto/update-incident.dto';
+
+export interface IncidentFilter {
+  vehicleId?: string;
+  driverId?: string;
+  status?: IncidentStatus;
+  type?: IncidentType;
+}
+
+export interface DriverIncidentStats {
+  total: number;
+  byType: Record<string, number>;
+  lastIncidentAt: Date | null;
+}
+
+@Injectable()
+export class IncidentsService {
+  constructor(private readonly incidentsRepository: IncidentsRepository) {}
+
+  async create(dto: CreateIncidentDto): Promise<Incident> {
+    return this.incidentsRepository.create({
+      ...dto,
+      occurredAt: new Date(dto.occurredAt),
+    });
+  }
+
+  async findAll(filter: IncidentFilter = {}): Promise<Incident[]> {
+    const where: FindOptionsWhere<Incident> = {};
+    if (filter.vehicleId) where.vehicleId = filter.vehicleId;
+    if (filter.driverId) where.driverId = filter.driverId;
+    if (filter.status) where.status = filter.status;
+    if (filter.type) where.type = filter.type;
+
+    return this.incidentsRepository.findAll({
+      where,
+      order: { occurredAt: 'DESC' },
+    });
+  }
+
+  async findByDriver(driverId: string): Promise<Incident[]> {
+    return this.incidentsRepository.findAll({
+      where: { driverId },
+      order: { occurredAt: 'DESC' },
+    });
+  }
+
+  async findById(id: string): Promise<Incident> {
+    const incident = await this.incidentsRepository.findById(id);
+    if (!incident) {
+      throw new NotFoundException(`Incident ${id} not found`);
+    }
+    return incident;
+  }
+
+  async update(id: string, dto: UpdateIncidentDto): Promise<Incident> {
+    await this.findById(id);
+    const updated = await this.incidentsRepository.update(id, {
+      ...dto,
+      occurredAt: dto.occurredAt ? new Date(dto.occurredAt) : undefined,
+    });
+    return updated!;
+  }
+
+  async remove(id: string): Promise<void> {
+    await this.findById(id);
+    await this.incidentsRepository.softDelete(id);
+  }
+
+  async statsForDriver(driverId: string): Promise<DriverIncidentStats> {
+    const incidents = await this.incidentsRepository.findAll({
+      where: { driverId },
+      order: { occurredAt: 'DESC' },
+    });
+
+    const byType: Record<string, number> = {};
+    for (const incident of incidents) {
+      byType[incident.type] = (byType[incident.type] || 0) + 1;
+    }
+
+    return {
+      total: incidents.length,
+      byType,
+      lastIncidentAt: incidents.length > 0 ? incidents[0].occurredAt : null,
+    };
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/last-mile/dto/update-last-mile.dto.ts b/apps/edr-freight-api/src/modules/last-mile/dto/update-last-mile.dto.ts
index 9d0c4262d..405273a54 100644
--- a/apps/edr-freight-api/src/modules/last-mile/dto/update-last-mile.dto.ts
+++ b/apps/edr-freight-api/src/modules/last-mile/dto/update-last-mile.dto.ts
@@ -1,5 +1,18 @@
-import { PartialType } from '@nestjs/mapped-types';
+import { ApiPropertyOptional, PartialType } from '@nestjs/swagger';
+import { IsISO8601, IsOptional } from 'class-validator';
 
 import { CreateLastMileDto } from './create-last-mile.dto';
 
-export class UpdateLastMileDto extends PartialType(CreateLastMileDto) {}
+export class UpdateLastMileDto extends PartialType(CreateLastMileDto) {
+  /** Truck-detention clock start (vehicle arrived at destination). Overrides the auto-stamp. */
+  @ApiPropertyOptional({ description: 'Vehicle arrival time (ISO 8601) — detention clock start.' })
+  @IsOptional()
+  @IsISO8601()
+  arrivedAt?: string;
+
+  /** Truck-detention clock end (cargo cleared / vehicle returned). Overrides the auto-stamp. */
+  @ApiPropertyOptional({ description: 'Delivery/return time (ISO 8601) — detention clock end.' })
+  @IsOptional()
+  @IsISO8601()
+  deliveredAt?: string;
+}
diff --git a/apps/edr-freight-api/src/modules/last-mile/entities/last-mile.entity.ts b/apps/edr-freight-api/src/modules/last-mile/entities/last-mile.entity.ts
index 1f8bda8fc..5dca86cc4 100644
--- a/apps/edr-freight-api/src/modules/last-mile/entities/last-mile.entity.ts
+++ b/apps/edr-freight-api/src/modules/last-mile/entities/last-mile.entity.ts
@@ -30,6 +30,15 @@ export class LastMile extends BaseEntity {
   @Column({ name: 'status', type: 'varchar', length: 30, default: 'PAYMENT_PENDING' })
   status!: LastMileStatus;
 
+  // Truck-detention window. arrivedAt = vehicle reached destination (IN_TRANSIT);
+  // deliveredAt = cargo cleared / vehicle returned (DELIVERED). Detention accrues
+  // between them beyond the rule's grace hours (default 3h), per truck per day.
+  @Column({ name: 'arrived_at', type: 'timestamptz', nullable: true })
+  arrivedAt?: Date | null;
+
+  @Column({ name: 'delivered_at', type: 'timestamptz', nullable: true })
+  deliveredAt?: Date | null;
+
   @Column({ name: 'advanced_payment', type: 'numeric', precision: 14, scale: 2, default: 0 })
   advancedPayment!: number;
 
diff --git a/apps/edr-freight-api/src/modules/last-mile/last-mile-invoice.service.ts b/apps/edr-freight-api/src/modules/last-mile/last-mile-invoice.service.ts
index 7b14f6887..8a6ec0779 100644
--- a/apps/edr-freight-api/src/modules/last-mile/last-mile-invoice.service.ts
+++ b/apps/edr-freight-api/src/modules/last-mile/last-mile-invoice.service.ts
@@ -1,4 +1,4 @@
-import { Injectable, Logger } from '@nestjs/common';
+import { BadRequestException, Injectable, Logger } from '@nestjs/common';
 import { OnEvent } from '@nestjs/event-emitter';
 import { Freight } from '@edr/types';
 
@@ -63,6 +63,30 @@ export class LastMileInvoiceService {
       return null;
     }
 
+    // Reject mixed-currency truck sets — a single invoice can only be one
+    // currency, and amounts across currencies can't be summed.
+    const billableTrucks = (record.vehicleAssignments ?? []).filter(
+      (a) => Number(a.distanceKm) > 0,
+    );
+    const currencies = [
+      ...new Set(
+        billableTrucks
+          .map((a) => (a.vehicle as { currency?: string } | undefined)?.currency)
+          .filter((c): c is string => Boolean(c)),
+      ),
+    ];
+    if (currencies.length > 1) {
+      throw new BadRequestException(
+        `Cannot generate invoice: assigned trucks use mixed currencies (${currencies.join(', ')}). Assign trucks that share one currency.`,
+      );
+    }
+
+    // Currency follows the truck (price/km is quoted per vehicle), falling back
+    // to the booking's currency, then ETB.
+    const truckCurrency =
+      (record.vehicle as { currency?: string } | undefined)?.currency ||
+      (record.vehicleAssignments?.[0]?.vehicle as { currency?: string } | undefined)?.currency;
+
     // Generate invoice with remainingPayment as totalAmount
     const input: GenerateInvoiceInput = {
       source: 'last_mile' as Freight.InvoiceSource,
@@ -70,7 +94,7 @@ export class LastMileInvoiceService {
       type: 'DELIVERY_FEE',
       companyId: lm.booking!.companyId,
       companyProfileId: lm.booking!.companyProfileId || '',
-      currency: lm.booking!.paymentCurrency || 'ETB',
+      currency: truckCurrency || lm.booking!.paymentCurrency || 'ETB',
       lines: [
         {
           chargeType: 'DELIVERY',
diff --git a/apps/edr-freight-api/src/modules/last-mile/last-mile.controller.ts b/apps/edr-freight-api/src/modules/last-mile/last-mile.controller.ts
index 2931a1f85..207b71a25 100644
--- a/apps/edr-freight-api/src/modules/last-mile/last-mile.controller.ts
+++ b/apps/edr-freight-api/src/modules/last-mile/last-mile.controller.ts
@@ -14,7 +14,8 @@ import {
 } from '@nestjs/common';
 import { ApiBearerAuth, ApiOperation, ApiTags } from '@nestjs/swagger';
 
-import { TrainSchedulingManage, TrainSchedulingView } from '../../common/booking-guards';
+import { BookingStaff } from '../../common/booking-guards';
+import { FREIGHT_PERMS } from '../../seed/freight-permissions.registry';
 
 import { CreateLastMileDto } from './dto/create-last-mile.dto';
 import { UpdateLastMileDto } from './dto/update-last-mile.dto';
@@ -27,7 +28,7 @@ import { LastMileInvoiceService } from './last-mile-invoice.service';
 @ApiTags('last-mile')
 @ApiBearerAuth()
 @Controller('last-mile')
-@TrainSchedulingView()
+@BookingStaff(FREIGHT_PERMS.lastMile.view)
 export class LastMileController {
   constructor(
     private readonly lastMileService: LastMileService,
@@ -63,21 +64,21 @@ export class LastMileController {
   }
 
   @Post('accept/:reference')
-  @TrainSchedulingManage()
+  @BookingStaff(FREIGHT_PERMS.lastMile.accept)
   @ApiOperation({ summary: 'Accept a paid booking and create a last-mile leg' })
   acceptBooking(@Param('reference') reference: string) {
     return this.lastMileService.acceptBookingByReference(reference);
   }
 
   @Post()
-  @TrainSchedulingManage()
+  @BookingStaff(FREIGHT_PERMS.lastMile.create)
   @ApiOperation({ summary: 'Create a last-mile leg' })
   create(@Body() dto: CreateLastMileDto) {
     return this.lastMileService.create(dto);
   }
 
   @Patch(':id')
-  @TrainSchedulingManage()
+  @BookingStaff(FREIGHT_PERMS.lastMile.update)
   @ApiOperation({ summary: 'Update a last-mile leg' })
   async update(@Param('id', ParseUUIDPipe) id: string, @Body() dto: UpdateLastMileDto) {
     // No invoice side-effects here — invoices are generated only via the
@@ -86,7 +87,7 @@ export class LastMileController {
   }
 
   @Delete(':id')
-  @TrainSchedulingManage()
+  @BookingStaff(FREIGHT_PERMS.lastMile.delete)
   @HttpCode(HttpStatus.NO_CONTENT)
   @ApiOperation({ summary: 'Soft-delete a last-mile leg' })
   remove(@Param('id', ParseUUIDPipe) id: string) {
@@ -95,7 +96,7 @@ export class LastMileController {
 
 
   @Post(':id/vehicles')
-  @TrainSchedulingManage()
+  @BookingStaff(FREIGHT_PERMS.lastMile.assignVehicles)
   @ApiOperation({ summary: 'Set the vehicles assigned to a last-mile delivery (multi-truck)' })
   async setVehicles(
     @Param('id', ParseUUIDPipe) id: string,
@@ -105,7 +106,7 @@ export class LastMileController {
   }
 
   @Post(':id/distances')
-  @TrainSchedulingManage()
+  @BookingStaff(FREIGHT_PERMS.lastMile.setDistances)
   @ApiOperation({ summary: 'Set per-vehicle actual distances (does not generate an invoice)' })
   async setDistances(
     @Param('id', ParseUUIDPipe) id: string,
@@ -115,7 +116,7 @@ export class LastMileController {
   }
 
   @Post(':id/invoice')
-  @TrainSchedulingManage()
+  @BookingStaff(FREIGHT_PERMS.lastMile.generateInvoice)
   @ApiOperation({ summary: 'Generate the delivery-fee invoice for a last-mile leg' })
   async generateInvoice(@Param('id', ParseUUIDPipe) id: string) {
     const record = await this.lastMileService.findById(id);
diff --git a/apps/edr-freight-api/src/modules/last-mile/last-mile.service.ts b/apps/edr-freight-api/src/modules/last-mile/last-mile.service.ts
index 22f25a6aa..15b8df3e7 100644
--- a/apps/edr-freight-api/src/modules/last-mile/last-mile.service.ts
+++ b/apps/edr-freight-api/src/modules/last-mile/last-mile.service.ts
@@ -282,6 +282,17 @@ export class LastMileService {
       ...(dto.exactKm !== undefined ? { exactKm: dto.exactKm } : {}),
       ...(dto.vehicleId !== undefined ? { vehicleId: dto.vehicleId } : {}),
       ...(dtoAny.paid !== undefined ? { paid: dtoAny.paid } : {}),
+      // Truck-detention clock: stamp arrival when the vehicle goes IN_TRANSIT and
+      // delivery when it reaches DELIVERED (first time only). Explicit dto values
+      // below override the auto-stamp so staff can record the real times.
+      ...(dto.status === 'IN_TRANSIT' && existing.status !== 'IN_TRANSIT' && !existing.arrivedAt
+        ? { arrivedAt: new Date() }
+        : {}),
+      ...(dto.status === 'DELIVERED' && existing.status !== 'DELIVERED' && !existing.deliveredAt
+        ? { deliveredAt: new Date() }
+        : {}),
+      ...(dtoAny.arrivedAt !== undefined ? { arrivedAt: dtoAny.arrivedAt ? new Date(dtoAny.arrivedAt) : null } : {}),
+      ...(dtoAny.deliveredAt !== undefined ? { deliveredAt: dtoAny.deliveredAt ? new Date(dtoAny.deliveredAt) : null } : {}),
     } as any);
 
     if (!updated) {
@@ -510,10 +521,24 @@ export class LastMileService {
         { distanceKm: d.distanceKm },
       );
     }
-    const total = distances.reduce((s, d) => s + (Number(d.distanceKm) || 0), 0);
+
+    // Billing is per truck: amount = Σ (truck distance × truck price/km). The
+    // per-vehicle rate + currency live on the vehicle, so we ignore the legacy
+    // LAST_MILE flat rate and any client-sent amount. `remainingPayment` param
+    // kept only for signature back-compat.
+    void remainingPayment;
+    const assignments = await this.dataSource.manager.find(LastMileVehicleAssignment, {
+      where: { lastMileId: id },
+      relations: { vehicle: true },
+    });
+    const total = assignments.reduce((s, a) => s + (Number(a.distanceKm) || 0), 0);
+    const amount = assignments.reduce(
+      (s, a) => s + (Number(a.distanceKm) || 0) * (Number(a.vehicle?.pricePerKm) || 0),
+      0,
+    );
     await this.lastMileRepository.update(id, {
       exactKm: total,
-      ...(remainingPayment != null ? { remainingPayment } : {}),
+      remainingPayment: amount,
     } as any);
     return this.findById(id);
   }
diff --git a/apps/edr-freight-api/src/modules/maintenance/dto/create-maintenance-depth.dto.ts b/apps/edr-freight-api/src/modules/maintenance/dto/create-maintenance-depth.dto.ts
new file mode 100644
index 000000000..56c886a74
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/maintenance/dto/create-maintenance-depth.dto.ts
@@ -0,0 +1,171 @@
+import {
+  IsUUID,
+  IsString,
+  IsDateString,
+  IsNumber,
+  IsInt,
+  IsOptional,
+  IsEnum,
+  Min,
+} from 'class-validator';
+import { WorkOrderStatus, WorkOrderPriority } from '../entities/work-order.entity';
+
+export class CreateWorkOrderDto {
+  @IsUUID()
+  vehicleId!: string;
+
+  @IsString()
+  title!: string;
+
+  @IsOptional()
+  @IsString()
+  description?: string;
+
+  @IsOptional()
+  @IsEnum(WorkOrderStatus)
+  status?: WorkOrderStatus;
+
+  @IsOptional()
+  @IsEnum(WorkOrderPriority)
+  priority?: WorkOrderPriority;
+
+  @IsOptional()
+  @IsString()
+  assignedTo?: string;
+
+  @IsOptional()
+  @IsDateString()
+  openedAt?: string;
+
+  @IsOptional()
+  @IsDateString()
+  closedAt?: string;
+
+  @IsOptional()
+  @IsNumber()
+  laborCost?: number;
+
+  @IsOptional()
+  @IsNumber()
+  partsCost?: number;
+}
+
+export class UpdateWorkOrderDto {
+  @IsOptional()
+  @IsString()
+  title?: string;
+
+  @IsOptional()
+  @IsString()
+  description?: string;
+
+  @IsOptional()
+  @IsEnum(WorkOrderStatus)
+  status?: WorkOrderStatus;
+
+  @IsOptional()
+  @IsEnum(WorkOrderPriority)
+  priority?: WorkOrderPriority;
+
+  @IsOptional()
+  @IsString()
+  assignedTo?: string;
+
+  @IsOptional()
+  @IsDateString()
+  closedAt?: string;
+
+  @IsOptional()
+  @IsNumber()
+  laborCost?: number;
+
+  @IsOptional()
+  @IsNumber()
+  partsCost?: number;
+}
+
+export class CreatePartDto {
+  @IsString()
+  name!: string;
+
+  @IsOptional()
+  @IsString()
+  sku?: string;
+
+  @IsOptional()
+  @IsString()
+  category?: string;
+
+  @IsOptional()
+  @IsInt()
+  @Min(0)
+  quantityInStock?: number;
+
+  @IsOptional()
+  @IsInt()
+  @Min(0)
+  reorderLevel?: number;
+
+  @IsOptional()
+  @IsNumber()
+  unitCost?: number;
+
+  @IsOptional()
+  @IsString()
+  location?: string;
+}
+
+export class UpdatePartDto {
+  @IsOptional()
+  @IsString()
+  name?: string;
+
+  @IsOptional()
+  @IsString()
+  sku?: string;
+
+  @IsOptional()
+  @IsString()
+  category?: string;
+
+  @IsOptional()
+  @IsInt()
+  @Min(0)
+  quantityInStock?: number;
+
+  @IsOptional()
+  @IsInt()
+  @Min(0)
+  reorderLevel?: number;
+
+  @IsOptional()
+  @IsNumber()
+  unitCost?: number;
+
+  @IsOptional()
+  @IsString()
+  location?: string;
+}
+
+export class CreateWarrantyDto {
+  @IsUUID()
+  vehicleId!: string;
+
+  @IsString()
+  component!: string;
+
+  @IsOptional()
+  @IsString()
+  provider?: string;
+
+  @IsOptional()
+  @IsDateString()
+  startDate?: string;
+
+  @IsDateString()
+  expiryDate!: string;
+
+  @IsOptional()
+  @IsString()
+  coverageNotes?: string;
+}
diff --git a/apps/edr-freight-api/src/modules/maintenance/entities/part.entity.ts b/apps/edr-freight-api/src/modules/maintenance/entities/part.entity.ts
new file mode 100644
index 000000000..caa478d88
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/maintenance/entities/part.entity.ts
@@ -0,0 +1,27 @@
+import { BaseEntity } from '@edr/api-common';
+import { Entity, Column, Index } from 'typeorm';
+
+@Entity({ name: 'parts', schema: 'freight' })
+@Index(['category'])
+export class Part extends BaseEntity {
+  @Column({ name: 'name', type: 'varchar' })
+  name!: string;
+
+  @Column({ name: 'sku', type: 'varchar', nullable: true })
+  sku?: string;
+
+  @Column({ name: 'category', type: 'varchar', nullable: true })
+  category?: string; // includes 'TIRE' — doubles as tire inventory
+
+  @Column({ name: 'quantity_in_stock', type: 'int', default: 0 })
+  quantityInStock!: number;
+
+  @Column({ name: 'reorder_level', type: 'int', default: 0 })
+  reorderLevel!: number;
+
+  @Column({ name: 'unit_cost', type: 'numeric', precision: 14, scale: 2, nullable: true })
+  unitCost?: number;
+
+  @Column({ name: 'location', type: 'varchar', nullable: true })
+  location?: string;
+}
diff --git a/apps/edr-freight-api/src/modules/maintenance/entities/warranty.entity.ts b/apps/edr-freight-api/src/modules/maintenance/entities/warranty.entity.ts
new file mode 100644
index 000000000..56c44fcbd
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/maintenance/entities/warranty.entity.ts
@@ -0,0 +1,29 @@
+import { BaseEntity } from '@edr/api-common';
+import { Entity, Column, ManyToOne, JoinColumn, Index } from 'typeorm';
+import { Vehicle } from '../../vehicles/entities/vehicle.entity';
+
+@Entity({ name: 'warranties', schema: 'freight' })
+@Index(['vehicleId', 'expiryDate'])
+export class Warranty extends BaseEntity {
+  @Column({ name: 'vehicle_id', type: 'uuid' })
+  vehicleId!: string;
+
+  @ManyToOne(() => Vehicle, { eager: false })
+  @JoinColumn({ name: 'vehicle_id' })
+  vehicle!: Vehicle;
+
+  @Column({ name: 'component', type: 'varchar' })
+  component!: string;
+
+  @Column({ name: 'provider', type: 'varchar', nullable: true })
+  provider?: string;
+
+  @Column({ name: 'start_date', type: 'date', nullable: true })
+  startDate?: string;
+
+  @Column({ name: 'expiry_date', type: 'date' })
+  expiryDate!: string;
+
+  @Column({ name: 'coverage_notes', type: 'text', nullable: true })
+  coverageNotes?: string;
+}
diff --git a/apps/edr-freight-api/src/modules/maintenance/entities/work-order.entity.ts b/apps/edr-freight-api/src/modules/maintenance/entities/work-order.entity.ts
new file mode 100644
index 000000000..224b74f74
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/maintenance/entities/work-order.entity.ts
@@ -0,0 +1,55 @@
+import { BaseEntity } from '@edr/api-common';
+import { Entity, Column, ManyToOne, JoinColumn, Index } from 'typeorm';
+import { Vehicle } from '../../vehicles/entities/vehicle.entity';
+
+export enum WorkOrderStatus {
+  OPEN = 'OPEN',
+  IN_PROGRESS = 'IN_PROGRESS',
+  COMPLETED = 'COMPLETED',
+  CANCELLED = 'CANCELLED',
+}
+
+export enum WorkOrderPriority {
+  LOW = 'LOW',
+  MEDIUM = 'MEDIUM',
+  HIGH = 'HIGH',
+  URGENT = 'URGENT',
+}
+
+@Entity({ name: 'work_orders', schema: 'freight' })
+@Index(['vehicleId', 'status'])
+export class WorkOrder extends BaseEntity {
+  @Column({ name: 'vehicle_id', type: 'uuid' })
+  vehicleId!: string;
+
+  @ManyToOne(() => Vehicle, { eager: false })
+  @JoinColumn({ name: 'vehicle_id' })
+  vehicle!: Vehicle;
+
+  @Column({ name: 'title', type: 'varchar' })
+  title!: string;
+
+  @Column({ name: 'description', type: 'text', nullable: true })
+  description?: string;
+
+  @Column({ name: 'status', type: 'varchar', default: WorkOrderStatus.OPEN })
+  status!: WorkOrderStatus;
+
+  @Column({ name: 'priority', type: 'varchar', default: WorkOrderPriority.MEDIUM })
+  priority!: WorkOrderPriority;
+
+  @Column({ name: 'assigned_to', type: 'varchar', nullable: true })
+  assignedTo?: string;
+
+  @Column({ name: 'opened_at', type: 'timestamptz' })
+  openedAt!: Date;
+
+  @Column({ name: 'closed_at', type: 'timestamptz', nullable: true })
+  closedAt?: Date;
+
+  @Column({ name: 'labor_cost', type: 'numeric', precision: 14, scale: 2, nullable: true })
+  laborCost?: number;
+
+  @Column({ name: 'parts_cost', type: 'numeric', precision: 14, scale: 2, nullable: true })
+  partsCost?: number;
+}
diff --git a/apps/edr-freight-api/src/modules/maintenance/maintenance-depth.service.ts b/apps/edr-freight-api/src/modules/maintenance/maintenance-depth.service.ts
new file mode 100644
index 000000000..212fe909a
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/maintenance/maintenance-depth.service.ts
@@ -0,0 +1,99 @@
+import { Injectable, NotFoundException } from '@nestjs/common';
+import { WorkOrderRepository } from './work-order.repository';
+import { PartRepository } from './part.repository';
+import { WarrantyRepository } from './warranty.repository';
+import { WorkOrder, WorkOrderStatus } from './entities/work-order.entity';
+import { Part } from './entities/part.entity';
+import { Warranty } from './entities/warranty.entity';
+import {
+  CreateWorkOrderDto,
+  UpdateWorkOrderDto,
+  CreatePartDto,
+  UpdatePartDto,
+  CreateWarrantyDto,
+} from './dto/create-maintenance-depth.dto';
+
+@Injectable()
+export class MaintenanceDepthService {
+  constructor(
+    private readonly workOrderRepository: WorkOrderRepository,
+    private readonly partRepository: PartRepository,
+    private readonly warrantyRepository: WarrantyRepository,
+  ) {}
+
+  // ---- Work Orders ----
+
+  async createWorkOrder(dto: CreateWorkOrderDto): Promise<WorkOrder> {
+    return this.workOrderRepository.create({
+      ...dto,
+      openedAt: dto.openedAt ? new Date(dto.openedAt) : new Date(),
+      closedAt: dto.closedAt ? new Date(dto.closedAt) : undefined,
+    });
+  }
+
+  async findWorkOrders(filters: { vehicleId?: string; status?: WorkOrderStatus }) {
+    return this.workOrderRepository.findFiltered(filters);
+  }
+
+  async findWorkOrderById(id: string): Promise<WorkOrder> {
+    const workOrder = await this.workOrderRepository.findById(id);
+    if (!workOrder) throw new NotFoundException(`Work order ${id} not found`);
+    return workOrder;
+  }
+
+  async updateWorkOrder(id: string, dto: UpdateWorkOrderDto): Promise<WorkOrder> {
+    await this.findWorkOrderById(id);
+    const updated = await this.workOrderRepository.update(id, {
+      ...dto,
+      closedAt: dto.closedAt ? new Date(dto.closedAt) : undefined,
+    });
+    return updated!;
+  }
+
+  async deleteWorkOrder(id: string): Promise<{ id: string; deleted: boolean }> {
+    await this.findWorkOrderById(id);
+    await this.workOrderRepository.softDelete(id);
+    return { id, deleted: true };
+  }
+
+  // ---- Parts / Tires ----
+
+  async createPart(dto: CreatePartDto): Promise<Part> {
+    return this.partRepository.create({ ...dto });
+  }
+
+  async findParts(filters: { category?: string; lowStock?: boolean }) {
+    return this.partRepository.findFiltered(filters);
+  }
+
+  async updatePart(id: string, dto: UpdatePartDto): Promise<Part> {
+    const part = await this.partRepository.findById(id);
+    if (!part) throw new NotFoundException(`Part ${id} not found`);
+    const updated = await this.partRepository.update(id, { ...dto });
+    return updated!;
+  }
+
+  async deletePart(id: string): Promise<{ id: string; deleted: boolean }> {
+    const part = await this.partRepository.findById(id);
+    if (!part) throw new NotFoundException(`Part ${id} not found`);
+    await this.partRepository.softDelete(id);
+    return { id, deleted: true };
+  }
+
+  // ---- Warranties ----
+
+  async createWarranty(dto: CreateWarrantyDto): Promise<Warranty> {
+    return this.warrantyRepository.create({ ...dto });
+  }
+
+  async findWarranties(filters: { vehicleId?: string }) {
+    return this.warrantyRepository.findFiltered(filters);
+  }
+
+  async deleteWarranty(id: string): Promise<{ id: string; deleted: boolean }> {
+    const warranty = await this.warrantyRepository.findById(id);
+    if (!warranty) throw new NotFoundException(`Warranty ${id} not found`);
+    await this.warrantyRepository.softDelete(id);
+    return { id, deleted: true };
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/maintenance/maintenance.controller.ts b/apps/edr-freight-api/src/modules/maintenance/maintenance.controller.ts
index de5ff08f2..4ad8026f2 100644
--- a/apps/edr-freight-api/src/modules/maintenance/maintenance.controller.ts
+++ b/apps/edr-freight-api/src/modules/maintenance/maintenance.controller.ts
@@ -1,52 +1,173 @@
-import { Controller, Post, Get, Patch, Body, Param } from '@nestjs/common';
-import { ApiTags, ApiOperation } from '@nestjs/swagger';
+import { Controller, Post, Get, Patch, Delete, Body, Param, Query } from '@nestjs/common';
+import { ApiBearerAuth, ApiTags, ApiOperation } from '@nestjs/swagger';
+import { BookingStaff } from '../../common/booking-guards';
+import { FREIGHT_PERMS } from '../../seed/freight-permissions.registry';
 import { MaintenanceService } from './maintenance.service';
+import { MaintenanceDepthService } from './maintenance-depth.service';
 import { CreateMaintenanceScheduleDto, CreateMaintenanceCostDto, UpdateMaintenanceScheduleDto } from './dto/create-maintenance.dto';
+import {
+  CreateWorkOrderDto,
+  UpdateWorkOrderDto,
+  CreatePartDto,
+  UpdatePartDto,
+  CreateWarrantyDto,
+} from './dto/create-maintenance-depth.dto';
+import { WorkOrderStatus } from './entities/work-order.entity';
 
 @ApiTags('Maintenance Management')
+@ApiBearerAuth()
 @Controller('maintenance')
 export class MaintenanceController {
-  constructor(private readonly maintenanceService: MaintenanceService) {}
+  constructor(
+    private readonly maintenanceService: MaintenanceService,
+    private readonly maintenanceDepthService: MaintenanceDepthService,
+  ) {}
 
   @Post('schedules')
+  @BookingStaff(FREIGHT_PERMS.maintenance.create)
   @ApiOperation({ summary: 'Schedule maintenance' })
   async scheduleMaintenanceAsync(@Body() dto: CreateMaintenanceScheduleDto) {
     return this.maintenanceService.scheduleMaintenanceAsync(dto);
   }
 
   @Post('costs')
+  @BookingStaff(FREIGHT_PERMS.maintenance.create)
   @ApiOperation({ summary: 'Record maintenance cost' })
   async recordCost(@Body() dto: CreateMaintenanceCostDto) {
     return this.maintenanceService.recordMaintenanceCost(dto);
   }
 
   @Patch('schedules/:id')
+  @BookingStaff(FREIGHT_PERMS.maintenance.update)
   @ApiOperation({ summary: 'Update maintenance schedule' })
   async updateSchedule(@Param('id') id: string, @Body() dto: UpdateMaintenanceScheduleDto) {
     return this.maintenanceService.updateMaintenanceSchedule(id, dto);
   }
 
   @Get('upcoming/:vehicleId')
+  @BookingStaff(FREIGHT_PERMS.maintenance.view)
   @ApiOperation({ summary: 'Get upcoming maintenance' })
   async getUpcoming(@Param('vehicleId') vehicleId: string) {
     return this.maintenanceService.getUpcomingMaintenance(vehicleId);
   }
 
   @Get('history/:vehicleId')
+  @BookingStaff(FREIGHT_PERMS.maintenance.view)
   @ApiOperation({ summary: 'Get maintenance history' })
   async getHistory(@Param('vehicleId') vehicleId: string) {
     return this.maintenanceService.getMaintenanceHistory(vehicleId);
   }
 
   @Get('stats')
+  @BookingStaff([FREIGHT_PERMS.maintenance.view, FREIGHT_PERMS.fleetReports.view, FREIGHT_PERMS.fleetDashboard.view])
   @ApiOperation({ summary: 'Get fleet-wide maintenance statistics' })
   async getFleetStats() {
     return this.maintenanceService.getFleetMaintenanceStats();
   }
 
   @Get('stats/:vehicleId')
+  @BookingStaff([FREIGHT_PERMS.maintenance.view, FREIGHT_PERMS.fleetReports.view, FREIGHT_PERMS.fleetDashboard.view])
   @ApiOperation({ summary: 'Get maintenance statistics' })
   async getStats(@Param('vehicleId') vehicleId: string) {
     return this.maintenanceService.getVehicleMaintenanceStats(vehicleId);
   }
+
+  // ---- Work Orders ----
+
+  @Post('work-orders')
+  @BookingStaff(FREIGHT_PERMS.maintenance.create)
+  @ApiOperation({ summary: 'Create work order' })
+  async createWorkOrder(@Body() dto: CreateWorkOrderDto) {
+    return this.maintenanceDepthService.createWorkOrder(dto);
+  }
+
+  @Get('work-orders')
+  @BookingStaff(FREIGHT_PERMS.maintenance.view)
+  @ApiOperation({ summary: 'List work orders' })
+  async listWorkOrders(
+    @Query('vehicleId') vehicleId?: string,
+    @Query('status') status?: WorkOrderStatus,
+  ) {
+    return this.maintenanceDepthService.findWorkOrders({ vehicleId, status });
+  }
+
+  @Get('work-orders/:id')
+  @BookingStaff(FREIGHT_PERMS.maintenance.view)
+  @ApiOperation({ summary: 'Get work order' })
+  async getWorkOrder(@Param('id') id: string) {
+    return this.maintenanceDepthService.findWorkOrderById(id);
+  }
+
+  @Patch('work-orders/:id')
+  @BookingStaff(FREIGHT_PERMS.maintenance.update)
+  @ApiOperation({ summary: 'Update work order' })
+  async updateWorkOrder(@Param('id') id: string, @Body() dto: UpdateWorkOrderDto) {
+    return this.maintenanceDepthService.updateWorkOrder(id, dto);
+  }
+
+  @Delete('work-orders/:id')
+  @BookingStaff(FREIGHT_PERMS.maintenance.delete)
+  @ApiOperation({ summary: 'Delete work order' })
+  async deleteWorkOrder(@Param('id') id: string) {
+    return this.maintenanceDepthService.deleteWorkOrder(id);
+  }
+
+  // ---- Parts / Tires ----
+
+  @Post('parts')
+  @BookingStaff(FREIGHT_PERMS.maintenance.create)
+  @ApiOperation({ summary: 'Create part' })
+  async createPart(@Body() dto: CreatePartDto) {
+    return this.maintenanceDepthService.createPart(dto);
+  }
+
+  @Get('parts')
+  @BookingStaff(FREIGHT_PERMS.maintenance.view)
+  @ApiOperation({ summary: 'List parts / tire inventory' })
+  async listParts(
+    @Query('category') category?: string,
+    @Query('lowStock') lowStock?: string,
+  ) {
+    return this.maintenanceDepthService.findParts({
+      category,
+      lowStock: lowStock === 'true',
+    });
+  }
+
+  @Patch('parts/:id')
+  @BookingStaff(FREIGHT_PERMS.maintenance.update)
+  @ApiOperation({ summary: 'Update part' })
+  async updatePart(@Param('id') id: string, @Body() dto: UpdatePartDto) {
+    return this.maintenanceDepthService.updatePart(id, dto);
+  }
+
+  @Delete('parts/:id')
+  @BookingStaff(FREIGHT_PERMS.maintenance.delete)
+  @ApiOperation({ summary: 'Delete part' })
+  async deletePart(@Param('id') id: string) {
+    return this.maintenanceDepthService.deletePart(id);
+  }
+
+  // ---- Warranties ----
+
+  @Post('warranties')
+  @BookingStaff(FREIGHT_PERMS.maintenance.create)
+  @ApiOperation({ summary: 'Create warranty' })
+  async createWarranty(@Body() dto: CreateWarrantyDto) {
+    return this.maintenanceDepthService.createWarranty(dto);
+  }
+
+  @Get('warranties')
+  @BookingStaff(FREIGHT_PERMS.maintenance.view)
+  @ApiOperation({ summary: 'List warranties' })
+  async listWarranties(@Query('vehicleId') vehicleId?: string) {
+    return this.maintenanceDepthService.findWarranties({ vehicleId });
+  }
+
+  @Delete('warranties/:id')
+  @BookingStaff(FREIGHT_PERMS.maintenance.delete)
+  @ApiOperation({ summary: 'Delete warranty' })
+  async deleteWarranty(@Param('id') id: string) {
+    return this.maintenanceDepthService.deleteWarranty(id);
+  }
 }
diff --git a/apps/edr-freight-api/src/modules/maintenance/maintenance.module.ts b/apps/edr-freight-api/src/modules/maintenance/maintenance.module.ts
index a0227a733..8f4fe1d0b 100644
--- a/apps/edr-freight-api/src/modules/maintenance/maintenance.module.ts
+++ b/apps/edr-freight-api/src/modules/maintenance/maintenance.module.ts
@@ -2,14 +2,30 @@ import { Module } from '@nestjs/common';
 import { TypeOrmModule } from '@nestjs/typeorm';
 import { MaintenanceSchedule } from './entities/maintenance-schedule.entity';
 import { MaintenanceCost } from './entities/maintenance-cost.entity';
+import { WorkOrder } from './entities/work-order.entity';
+import { Part } from './entities/part.entity';
+import { Warranty } from './entities/warranty.entity';
 import { MaintenanceService } from './maintenance.service';
+import { MaintenanceDepthService } from './maintenance-depth.service';
 import { MaintenanceRepository } from './maintenance.repository';
+import { WorkOrderRepository } from './work-order.repository';
+import { PartRepository } from './part.repository';
+import { WarrantyRepository } from './warranty.repository';
 import { MaintenanceController } from './maintenance.controller';
 
 @Module({
-  imports: [TypeOrmModule.forFeature([MaintenanceSchedule, MaintenanceCost])],
-  providers: [MaintenanceService, MaintenanceRepository],
+  imports: [
+    TypeOrmModule.forFeature([MaintenanceSchedule, MaintenanceCost, WorkOrder, Part, Warranty]),
+  ],
+  providers: [
+    MaintenanceService,
+    MaintenanceDepthService,
+    MaintenanceRepository,
+    WorkOrderRepository,
+    PartRepository,
+    WarrantyRepository,
+  ],
   controllers: [MaintenanceController],
-  exports: [MaintenanceService],
+  exports: [MaintenanceService, MaintenanceDepthService],
 })
 export class MaintenanceModule {}
diff --git a/apps/edr-freight-api/src/modules/maintenance/part.repository.ts b/apps/edr-freight-api/src/modules/maintenance/part.repository.ts
new file mode 100644
index 000000000..d6b221332
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/maintenance/part.repository.ts
@@ -0,0 +1,27 @@
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { BaseRepository } from '@edr/api-common';
+import { Repository } from 'typeorm';
+import { Part } from './entities/part.entity';
+
+@Injectable()
+export class PartRepository extends BaseRepository<Part> {
+  constructor(
+    @InjectRepository(Part)
+    private readonly partRepository: Repository<Part>,
+  ) {
+    super(partRepository);
+  }
+
+  async findFiltered(filters: { category?: string; lowStock?: boolean }) {
+    const qb = this.partRepository.createQueryBuilder('part');
+    if (filters.category) {
+      qb.andWhere('part.category = :category', { category: filters.category });
+    }
+    if (filters.lowStock) {
+      qb.andWhere('part.quantityInStock <= part.reorderLevel');
+    }
+    qb.orderBy('part.name', 'ASC');
+    return qb.getMany();
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/maintenance/warranty.repository.ts b/apps/edr-freight-api/src/modules/maintenance/warranty.repository.ts
new file mode 100644
index 000000000..e59bd358d
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/maintenance/warranty.repository.ts
@@ -0,0 +1,24 @@
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { BaseRepository } from '@edr/api-common';
+import { Repository, FindOptionsWhere } from 'typeorm';
+import { Warranty } from './entities/warranty.entity';
+
+@Injectable()
+export class WarrantyRepository extends BaseRepository<Warranty> {
+  constructor(
+    @InjectRepository(Warranty)
+    private readonly warrantyRepository: Repository<Warranty>,
+  ) {
+    super(warrantyRepository);
+  }
+
+  async findFiltered(filters: { vehicleId?: string }) {
+    const where: FindOptionsWhere<Warranty> = {};
+    if (filters.vehicleId) where.vehicleId = filters.vehicleId;
+    return this.warrantyRepository.find({
+      where,
+      order: { expiryDate: 'ASC' },
+    });
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/maintenance/work-order.repository.ts b/apps/edr-freight-api/src/modules/maintenance/work-order.repository.ts
new file mode 100644
index 000000000..057f1fa6d
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/maintenance/work-order.repository.ts
@@ -0,0 +1,25 @@
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { BaseRepository } from '@edr/api-common';
+import { Repository, FindOptionsWhere } from 'typeorm';
+import { WorkOrder, WorkOrderStatus } from './entities/work-order.entity';
+
+@Injectable()
+export class WorkOrderRepository extends BaseRepository<WorkOrder> {
+  constructor(
+    @InjectRepository(WorkOrder)
+    private readonly workOrderRepository: Repository<WorkOrder>,
+  ) {
+    super(workOrderRepository);
+  }
+
+  async findFiltered(filters: { vehicleId?: string; status?: WorkOrderStatus }) {
+    const where: FindOptionsWhere<WorkOrder> = {};
+    if (filters.vehicleId) where.vehicleId = filters.vehicleId;
+    if (filters.status) where.status = filters.status;
+    return this.workOrderRepository.find({
+      where,
+      order: { openedAt: 'DESC' },
+    });
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/otp/otp.entity.ts b/apps/edr-freight-api/src/modules/otp/otp.entity.ts
index 022bbf767..f661bb662 100644
--- a/apps/edr-freight-api/src/modules/otp/otp.entity.ts
+++ b/apps/edr-freight-api/src/modules/otp/otp.entity.ts
@@ -7,6 +7,11 @@ import {
 import { BaseEntity } from "@edr/api-common";
 
 @Entity({
+  // Table lives in the freight schema like every other freight entity. Without
+  // this the entity inherits the DataSource default schema (public), so TypeORM
+  // queries public.otp_verifications — which doesn't exist — and OTP verify
+  // (e.g. the contract-signature sudo gate) fails with a 500 QueryFailedError.
+  schema: "freight",
   name: "otp_verifications",
 })
 export class OtpVerification extends BaseEntity{
diff --git a/apps/edr-freight-api/src/modules/otp/otp.service.ts b/apps/edr-freight-api/src/modules/otp/otp.service.ts
index 67fbdec9b..e26ed35c9 100644
--- a/apps/edr-freight-api/src/modules/otp/otp.service.ts
+++ b/apps/edr-freight-api/src/modules/otp/otp.service.ts
@@ -72,8 +72,14 @@ export class OtpService {
         message: "OTP sent successfully",
       };
     } catch (error) {
-      console.log(error);
-
+      // Log the real cause (DB/SMS/email failure) with its stack so a deployed
+      // "Failed to send OTP" 400 is diagnosable from the API logs, not opaque.
+      this.logger.error(
+        `Failed to send OTP to ${target.email ?? target.phone}: ${
+          error instanceof Error ? error.message : String(error)
+        }`,
+        error instanceof Error ? error.stack : undefined,
+      );
       throw new BadRequestException("Failed to send OTP");
     }
   }
diff --git a/apps/edr-freight-api/src/modules/procurement/dto/procurement.dto.ts b/apps/edr-freight-api/src/modules/procurement/dto/procurement.dto.ts
new file mode 100644
index 000000000..943d79296
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/procurement/dto/procurement.dto.ts
@@ -0,0 +1,193 @@
+import {
+  IsUUID,
+  IsString,
+  IsDateString,
+  IsNumber,
+  IsInt,
+  IsOptional,
+  IsEnum,
+  IsBoolean,
+} from 'class-validator';
+import { VendorType } from '../entities/vendor.entity';
+import { AcquisitionType, AcquisitionStatus } from '../entities/asset-acquisition.entity';
+import { DisposalMethod } from '../entities/asset-disposal.entity';
+
+export class CreateVendorDto {
+  @IsString()
+  name!: string;
+
+  @IsOptional()
+  @IsEnum(VendorType)
+  type?: VendorType;
+
+  @IsOptional()
+  @IsString()
+  contactPerson?: string;
+
+  @IsOptional()
+  @IsString()
+  phone?: string;
+
+  @IsOptional()
+  @IsString()
+  email?: string;
+
+  @IsOptional()
+  @IsString()
+  address?: string;
+
+  @IsOptional()
+  @IsBoolean()
+  isActive?: boolean;
+}
+
+export class UpdateVendorDto {
+  @IsOptional()
+  @IsString()
+  name?: string;
+
+  @IsOptional()
+  @IsEnum(VendorType)
+  type?: VendorType;
+
+  @IsOptional()
+  @IsString()
+  contactPerson?: string;
+
+  @IsOptional()
+  @IsString()
+  phone?: string;
+
+  @IsOptional()
+  @IsString()
+  email?: string;
+
+  @IsOptional()
+  @IsString()
+  address?: string;
+
+  @IsOptional()
+  @IsBoolean()
+  isActive?: boolean;
+}
+
+export class CreateAcquisitionDto {
+  @IsOptional()
+  @IsUUID()
+  vehicleId?: string;
+
+  @IsOptional()
+  @IsUUID()
+  vendorId?: string;
+
+  @IsEnum(AcquisitionType)
+  acquisitionType!: AcquisitionType;
+
+  @IsDateString()
+  acquisitionDate!: string;
+
+  @IsOptional()
+  @IsNumber()
+  cost?: number;
+
+  @IsOptional()
+  @IsInt()
+  usefulLifeMonths?: number;
+
+  @IsOptional()
+  @IsNumber()
+  salvageValue?: number;
+
+  @IsOptional()
+  @IsDateString()
+  leaseStart?: string;
+
+  @IsOptional()
+  @IsDateString()
+  leaseEnd?: string;
+
+  @IsOptional()
+  @IsNumber()
+  monthlyPayment?: number;
+
+  @IsOptional()
+  @IsEnum(AcquisitionStatus)
+  status?: AcquisitionStatus;
+
+  @IsOptional()
+  @IsString()
+  notes?: string;
+}
+
+export class UpdateAcquisitionDto {
+  @IsOptional()
+  @IsUUID()
+  vehicleId?: string;
+
+  @IsOptional()
+  @IsUUID()
+  vendorId?: string;
+
+  @IsOptional()
+  @IsEnum(AcquisitionType)
+  acquisitionType?: AcquisitionType;
+
+  @IsOptional()
+  @IsDateString()
+  acquisitionDate?: string;
+
+  @IsOptional()
+  @IsNumber()
+  cost?: number;
+
+  @IsOptional()
+  @IsInt()
+  usefulLifeMonths?: number;
+
+  @IsOptional()
+  @IsNumber()
+  salvageValue?: number;
+
+  @IsOptional()
+  @IsDateString()
+  leaseStart?: string;
+
+  @IsOptional()
+  @IsDateString()
+  leaseEnd?: string;
+
+  @IsOptional()
+  @IsNumber()
+  monthlyPayment?: number;
+
+  @IsOptional()
+  @IsEnum(AcquisitionStatus)
+  status?: AcquisitionStatus;
+
+  @IsOptional()
+  @IsString()
+  notes?: string;
+}
+
+export class CreateDisposalDto {
+  @IsUUID()
+  vehicleId!: string;
+
+  @IsDateString()
+  disposalDate!: string;
+
+  @IsEnum(DisposalMethod)
+  method!: DisposalMethod;
+
+  @IsOptional()
+  @IsNumber()
+  salePrice?: number;
+
+  @IsOptional()
+  @IsString()
+  buyer?: string;
+
+  @IsOptional()
+  @IsString()
+  notes?: string;
+}
diff --git a/apps/edr-freight-api/src/modules/procurement/entities/asset-acquisition.entity.ts b/apps/edr-freight-api/src/modules/procurement/entities/asset-acquisition.entity.ts
new file mode 100644
index 000000000..d4f781c15
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/procurement/entities/asset-acquisition.entity.ts
@@ -0,0 +1,64 @@
+import { BaseEntity } from '@edr/api-common';
+import { Entity, Column, ManyToOne, JoinColumn, Index } from 'typeorm';
+import { Vehicle } from '../../vehicles/entities/vehicle.entity';
+import { Vendor } from './vendor.entity';
+
+export enum AcquisitionType {
+  PURCHASE = 'PURCHASE',
+  LEASE = 'LEASE',
+  RENTAL = 'RENTAL',
+}
+
+export enum AcquisitionStatus {
+  ACTIVE = 'ACTIVE',
+  LEASE_EXPIRING = 'LEASE_EXPIRING',
+  DISPOSED = 'DISPOSED',
+}
+
+@Entity({ name: 'asset_acquisitions', schema: 'freight' })
+@Index(['vehicleId', 'acquisitionDate'])
+export class AssetAcquisition extends BaseEntity {
+  @Column({ name: 'vehicle_id', type: 'uuid', nullable: true })
+  vehicleId?: string;
+
+  @ManyToOne(() => Vehicle, { eager: false, nullable: true, onDelete: 'SET NULL' })
+  @JoinColumn({ name: 'vehicle_id' })
+  vehicle?: Vehicle;
+
+  @Column({ name: 'vendor_id', type: 'uuid', nullable: true })
+  vendorId?: string;
+
+  @ManyToOne(() => Vendor, { eager: false, nullable: true, onDelete: 'SET NULL' })
+  @JoinColumn({ name: 'vendor_id' })
+  vendor?: Vendor;
+
+  @Column({ name: 'acquisition_type', type: 'varchar' })
+  acquisitionType!: AcquisitionType;
+
+  @Column({ name: 'acquisition_date', type: 'date' })
+  acquisitionDate!: string;
+
+  @Column({ name: 'cost', type: 'numeric', precision: 14, scale: 2, nullable: true })
+  cost?: number;
+
+  @Column({ name: 'useful_life_months', type: 'int', nullable: true })
+  usefulLifeMonths?: number;
+
+  @Column({ name: 'salvage_value', type: 'numeric', precision: 14, scale: 2, nullable: true })
+  salvageValue?: number;
+
+  @Column({ name: 'lease_start', type: 'date', nullable: true })
+  leaseStart?: string;
+
+  @Column({ name: 'lease_end', type: 'date', nullable: true })
+  leaseEnd?: string;
+
+  @Column({ name: 'monthly_payment', type: 'numeric', precision: 14, scale: 2, nullable: true })
+  monthlyPayment?: number;
+
+  @Column({ name: 'status', type: 'varchar', default: AcquisitionStatus.ACTIVE })
+  status!: AcquisitionStatus;
+
+  @Column({ name: 'notes', type: 'text', nullable: true })
+  notes?: string;
+}
diff --git a/apps/edr-freight-api/src/modules/procurement/entities/asset-disposal.entity.ts b/apps/edr-freight-api/src/modules/procurement/entities/asset-disposal.entity.ts
new file mode 100644
index 000000000..301e3ec1c
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/procurement/entities/asset-disposal.entity.ts
@@ -0,0 +1,31 @@
+import { BaseEntity } from '@edr/api-common';
+import { Entity, Column, Index } from 'typeorm';
+
+export enum DisposalMethod {
+  SALE = 'SALE',
+  SCRAP = 'SCRAP',
+  RETURN_LEASE = 'RETURN_LEASE',
+  TRADE_IN = 'TRADE_IN',
+}
+
+@Entity({ name: 'asset_disposals', schema: 'freight' })
+@Index(['vehicleId', 'disposalDate'])
+export class AssetDisposal extends BaseEntity {
+  @Column({ name: 'vehicle_id', type: 'uuid' })
+  vehicleId!: string;
+
+  @Column({ name: 'disposal_date', type: 'date' })
+  disposalDate!: string;
+
+  @Column({ name: 'method', type: 'varchar' })
+  method!: DisposalMethod;
+
+  @Column({ name: 'sale_price', type: 'numeric', precision: 14, scale: 2, nullable: true })
+  salePrice?: number;
+
+  @Column({ name: 'buyer', nullable: true })
+  buyer?: string;
+
+  @Column({ name: 'notes', type: 'text', nullable: true })
+  notes?: string;
+}
diff --git a/apps/edr-freight-api/src/modules/procurement/entities/vendor.entity.ts b/apps/edr-freight-api/src/modules/procurement/entities/vendor.entity.ts
new file mode 100644
index 000000000..cbe394d16
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/procurement/entities/vendor.entity.ts
@@ -0,0 +1,34 @@
+import { BaseEntity } from '@edr/api-common';
+import { Entity, Column } from 'typeorm';
+
+export enum VendorType {
+  DEALER = 'DEALER',
+  LEASING = 'LEASING',
+  PARTS = 'PARTS',
+  SERVICE = 'SERVICE',
+  OTHER = 'OTHER',
+}
+
+@Entity({ name: 'vendors', schema: 'freight' })
+export class Vendor extends BaseEntity {
+  @Column({ name: 'name' })
+  name!: string;
+
+  @Column({ name: 'type', type: 'varchar', nullable: true })
+  type?: VendorType;
+
+  @Column({ name: 'contact_person', nullable: true })
+  contactPerson?: string;
+
+  @Column({ name: 'phone', nullable: true })
+  phone?: string;
+
+  @Column({ name: 'email', nullable: true })
+  email?: string;
+
+  @Column({ name: 'address', nullable: true })
+  address?: string;
+
+  @Column({ name: 'is_active', type: 'boolean', default: true })
+  isActive!: boolean;
+}
diff --git a/apps/edr-freight-api/src/modules/procurement/procurement.controller.ts b/apps/edr-freight-api/src/modules/procurement/procurement.controller.ts
new file mode 100644
index 000000000..e5c69f37c
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/procurement/procurement.controller.ts
@@ -0,0 +1,98 @@
+import { Controller, Post, Get, Patch, Delete, Body, Param, Query } from '@nestjs/common';
+import { ApiTags, ApiOperation } from '@nestjs/swagger';
+import { ProcurementService } from './procurement.service';
+import {
+  CreateVendorDto,
+  UpdateVendorDto,
+  CreateAcquisitionDto,
+  UpdateAcquisitionDto,
+  CreateDisposalDto,
+} from './dto/procurement.dto';
+
+@ApiTags('Procurement & Asset Lifecycle')
+@Controller('procurement')
+export class ProcurementController {
+  constructor(private readonly procurementService: ProcurementService) {}
+
+  // ---- Vendors ----
+  @Post('vendors')
+  @ApiOperation({ summary: 'Create a vendor' })
+  async createVendor(@Body() dto: CreateVendorDto) {
+    return this.procurementService.createVendor(dto);
+  }
+
+  @Get('vendors')
+  @ApiOperation({ summary: 'List vendors' })
+  async listVendors() {
+    return this.procurementService.listVendors();
+  }
+
+  @Patch('vendors/:id')
+  @ApiOperation({ summary: 'Update a vendor' })
+  async updateVendor(@Param('id') id: string, @Body() dto: UpdateVendorDto) {
+    return this.procurementService.updateVendor(id, dto);
+  }
+
+  @Delete('vendors/:id')
+  @ApiOperation({ summary: 'Delete a vendor' })
+  async deleteVendor(@Param('id') id: string) {
+    return this.procurementService.deleteVendor(id);
+  }
+
+  // ---- Acquisitions ----
+  @Post('acquisitions')
+  @ApiOperation({ summary: 'Create an asset acquisition' })
+  async createAcquisition(@Body() dto: CreateAcquisitionDto) {
+    return this.procurementService.createAcquisition(dto);
+  }
+
+  @Get('acquisitions')
+  @ApiOperation({ summary: 'List asset acquisitions (optionally filtered by vehicleId)' })
+  async listAcquisitions(@Query('vehicleId') vehicleId?: string) {
+    return this.procurementService.listAcquisitions(vehicleId);
+  }
+
+  @Get('acquisitions/:id')
+  @ApiOperation({ summary: 'Get an asset acquisition by id' })
+  async getAcquisition(@Param('id') id: string) {
+    return this.procurementService.getAcquisition(id);
+  }
+
+  @Patch('acquisitions/:id')
+  @ApiOperation({ summary: 'Update an asset acquisition' })
+  async updateAcquisition(@Param('id') id: string, @Body() dto: UpdateAcquisitionDto) {
+    return this.procurementService.updateAcquisition(id, dto);
+  }
+
+  @Delete('acquisitions/:id')
+  @ApiOperation({ summary: 'Delete an asset acquisition' })
+  async deleteAcquisition(@Param('id') id: string) {
+    return this.procurementService.deleteAcquisition(id);
+  }
+
+  // ---- Disposals ----
+  @Post('disposals')
+  @ApiOperation({ summary: 'Create an asset disposal' })
+  async createDisposal(@Body() dto: CreateDisposalDto) {
+    return this.procurementService.createDisposal(dto);
+  }
+
+  @Get('disposals')
+  @ApiOperation({ summary: 'List asset disposals' })
+  async listDisposals() {
+    return this.procurementService.listDisposals();
+  }
+
+  @Delete('disposals/:id')
+  @ApiOperation({ summary: 'Delete an asset disposal' })
+  async deleteDisposal(@Param('id') id: string) {
+    return this.procurementService.deleteDisposal(id);
+  }
+
+  // ---- Lifecycle ----
+  @Get('lifecycle/:vehicleId')
+  @ApiOperation({ summary: 'Get asset lifecycle (acquisition, disposal, depreciation) for a vehicle' })
+  async lifecycle(@Param('vehicleId') vehicleId: string) {
+    return this.procurementService.lifecycle(vehicleId);
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/procurement/procurement.module.ts b/apps/edr-freight-api/src/modules/procurement/procurement.module.ts
new file mode 100644
index 000000000..d4b0d8315
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/procurement/procurement.module.ts
@@ -0,0 +1,16 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { Vendor } from './entities/vendor.entity';
+import { AssetAcquisition } from './entities/asset-acquisition.entity';
+import { AssetDisposal } from './entities/asset-disposal.entity';
+import { ProcurementService } from './procurement.service';
+import { ProcurementRepository } from './procurement.repository';
+import { ProcurementController } from './procurement.controller';
+
+@Module({
+  imports: [TypeOrmModule.forFeature([Vendor, AssetAcquisition, AssetDisposal])],
+  providers: [ProcurementService, ProcurementRepository],
+  controllers: [ProcurementController],
+  exports: [ProcurementService],
+})
+export class ProcurementModule {}
diff --git a/apps/edr-freight-api/src/modules/procurement/procurement.repository.ts b/apps/edr-freight-api/src/modules/procurement/procurement.repository.ts
new file mode 100644
index 000000000..1a049d52b
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/procurement/procurement.repository.ts
@@ -0,0 +1,102 @@
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { BaseRepository } from '@edr/api-common';
+import { DeepPartial, Repository } from 'typeorm';
+import { Vendor } from './entities/vendor.entity';
+import { AssetAcquisition } from './entities/asset-acquisition.entity';
+import { AssetDisposal } from './entities/asset-disposal.entity';
+
+@Injectable()
+export class ProcurementRepository extends BaseRepository<AssetAcquisition> {
+  constructor(
+    @InjectRepository(AssetAcquisition)
+    private readonly acquisitionRepository: Repository<AssetAcquisition>,
+    @InjectRepository(Vendor)
+    private readonly vendorRepository: Repository<Vendor>,
+    @InjectRepository(AssetDisposal)
+    private readonly disposalRepository: Repository<AssetDisposal>,
+  ) {
+    super(acquisitionRepository);
+  }
+
+  // ---- Vendors ----
+  async createVendor(data: DeepPartial<Vendor>): Promise<Vendor> {
+    const vendor = this.vendorRepository.create(data);
+    return this.vendorRepository.save(vendor);
+  }
+
+  async findVendors(): Promise<Vendor[]> {
+    return this.vendorRepository.find({ order: { createdAt: 'DESC' } });
+  }
+
+  async updateVendor(id: string, data: DeepPartial<Vendor>): Promise<Vendor | null> {
+    await this.vendorRepository.update(id, data as never);
+    return this.vendorRepository.findOneBy({ id });
+  }
+
+  async softDeleteVendor(id: string): Promise<void> {
+    await this.vendorRepository.softDelete(id);
+  }
+
+  // ---- Acquisitions ----
+  async createAcquisition(data: DeepPartial<AssetAcquisition>): Promise<AssetAcquisition> {
+    const acquisition = this.acquisitionRepository.create(data);
+    return this.acquisitionRepository.save(acquisition);
+  }
+
+  async findAcquisitions(vehicleId?: string): Promise<AssetAcquisition[]> {
+    return this.acquisitionRepository.find({
+      where: vehicleId ? { vehicleId } : {},
+      relations: ['vehicle', 'vendor'],
+      order: { acquisitionDate: 'DESC' },
+    });
+  }
+
+  async findAcquisitionById(id: string): Promise<AssetAcquisition | null> {
+    return this.acquisitionRepository.findOne({
+      where: { id },
+      relations: ['vehicle', 'vendor'],
+    });
+  }
+
+  async updateAcquisition(
+    id: string,
+    data: DeepPartial<AssetAcquisition>,
+  ): Promise<AssetAcquisition | null> {
+    await this.acquisitionRepository.update(id, data as never);
+    return this.findAcquisitionById(id);
+  }
+
+  async softDeleteAcquisition(id: string): Promise<void> {
+    await this.acquisitionRepository.softDelete(id);
+  }
+
+  async findLatestAcquisitionByVehicle(vehicleId: string): Promise<AssetAcquisition | null> {
+    return this.acquisitionRepository.findOne({
+      where: { vehicleId },
+      relations: ['vehicle', 'vendor'],
+      order: { acquisitionDate: 'DESC' },
+    });
+  }
+
+  // ---- Disposals ----
+  async createDisposal(data: DeepPartial<AssetDisposal>): Promise<AssetDisposal> {
+    const disposal = this.disposalRepository.create(data);
+    return this.disposalRepository.save(disposal);
+  }
+
+  async findDisposals(): Promise<AssetDisposal[]> {
+    return this.disposalRepository.find({ order: { disposalDate: 'DESC' } });
+  }
+
+  async softDeleteDisposal(id: string): Promise<void> {
+    await this.disposalRepository.softDelete(id);
+  }
+
+  async findLatestDisposalByVehicle(vehicleId: string): Promise<AssetDisposal | null> {
+    return this.disposalRepository.findOne({
+      where: { vehicleId },
+      order: { disposalDate: 'DESC' },
+    });
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/procurement/procurement.service.ts b/apps/edr-freight-api/src/modules/procurement/procurement.service.ts
new file mode 100644
index 000000000..e799d5ff9
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/procurement/procurement.service.ts
@@ -0,0 +1,143 @@
+import { Injectable } from '@nestjs/common';
+import { ProcurementRepository } from './procurement.repository';
+import { Vendor } from './entities/vendor.entity';
+import { AssetAcquisition } from './entities/asset-acquisition.entity';
+import { AssetDisposal } from './entities/asset-disposal.entity';
+import {
+  CreateVendorDto,
+  UpdateVendorDto,
+  CreateAcquisitionDto,
+  UpdateAcquisitionDto,
+  CreateDisposalDto,
+} from './dto/procurement.dto';
+
+export interface DepreciationResult {
+  method: 'STRAIGHT_LINE';
+  cost: number;
+  salvageValue: number;
+  usefulLifeMonths: number;
+  monthsElapsed: number;
+  monthlyDepreciation: number;
+  bookValue: number;
+}
+
+export interface LifecycleResult {
+  vehicleId: string;
+  acquisition: AssetAcquisition | null;
+  disposal: AssetDisposal | null;
+  depreciation: DepreciationResult | null;
+}
+
+@Injectable()
+export class ProcurementService {
+  constructor(private readonly procurementRepository: ProcurementRepository) {}
+
+  // ---- Vendors ----
+  async createVendor(dto: CreateVendorDto): Promise<Vendor> {
+    return this.procurementRepository.createVendor(dto);
+  }
+
+  async listVendors(): Promise<Vendor[]> {
+    return this.procurementRepository.findVendors();
+  }
+
+  async updateVendor(id: string, dto: UpdateVendorDto): Promise<Vendor | null> {
+    return this.procurementRepository.updateVendor(id, dto);
+  }
+
+  async deleteVendor(id: string): Promise<{ success: boolean }> {
+    await this.procurementRepository.softDeleteVendor(id);
+    return { success: true };
+  }
+
+  // ---- Acquisitions ----
+  async createAcquisition(dto: CreateAcquisitionDto): Promise<AssetAcquisition> {
+    return this.procurementRepository.createAcquisition(dto);
+  }
+
+  async listAcquisitions(vehicleId?: string): Promise<AssetAcquisition[]> {
+    return this.procurementRepository.findAcquisitions(vehicleId);
+  }
+
+  async getAcquisition(id: string): Promise<AssetAcquisition | null> {
+    return this.procurementRepository.findAcquisitionById(id);
+  }
+
+  async updateAcquisition(id: string, dto: UpdateAcquisitionDto): Promise<AssetAcquisition | null> {
+    return this.procurementRepository.updateAcquisition(id, dto);
+  }
+
+  async deleteAcquisition(id: string): Promise<{ success: boolean }> {
+    await this.procurementRepository.softDeleteAcquisition(id);
+    return { success: true };
+  }
+
+  // ---- Disposals ----
+  async createDisposal(dto: CreateDisposalDto): Promise<AssetDisposal> {
+    return this.procurementRepository.createDisposal(dto);
+  }
+
+  async listDisposals(): Promise<AssetDisposal[]> {
+    return this.procurementRepository.findDisposals();
+  }
+
+  async deleteDisposal(id: string): Promise<{ success: boolean }> {
+    await this.procurementRepository.softDeleteDisposal(id);
+    return { success: true };
+  }
+
+  // ---- Lifecycle ----
+  async lifecycle(vehicleId: string): Promise<LifecycleResult> {
+    const acquisition = await this.procurementRepository.findLatestAcquisitionByVehicle(vehicleId);
+    const disposal = await this.procurementRepository.findLatestDisposalByVehicle(vehicleId);
+
+    return {
+      vehicleId,
+      acquisition,
+      disposal,
+      depreciation: this.computeStraightLineDepreciation(acquisition),
+    };
+  }
+
+  /**
+   * Straight-line depreciation. Requires a cost and a positive useful life.
+   * monthlyDep = (cost - salvageValue) / usefulLifeMonths
+   * bookValue  = cost - monthlyDep * monthsElapsedSinceAcquisition, floored at salvageValue.
+   */
+  private computeStraightLineDepreciation(
+    acquisition: AssetAcquisition | null,
+  ): DepreciationResult | null {
+    if (!acquisition) return null;
+
+    const cost = acquisition.cost != null ? Number(acquisition.cost) : null;
+    const usefulLifeMonths =
+      acquisition.usefulLifeMonths != null ? Number(acquisition.usefulLifeMonths) : null;
+
+    if (cost == null || usefulLifeMonths == null || usefulLifeMonths <= 0) {
+      return null;
+    }
+
+    const salvageValue = acquisition.salvageValue != null ? Number(acquisition.salvageValue) : 0;
+    const monthlyDepreciation = (cost - salvageValue) / usefulLifeMonths;
+
+    const acquiredAt = new Date(acquisition.acquisitionDate);
+    const now = new Date();
+    const monthsElapsed = Math.max(
+      0,
+      (now.getFullYear() - acquiredAt.getFullYear()) * 12 +
+        (now.getMonth() - acquiredAt.getMonth()),
+    );
+
+    const bookValue = Math.max(cost - monthlyDepreciation * monthsElapsed, salvageValue);
+
+    return {
+      method: 'STRAIGHT_LINE',
+      cost,
+      salvageValue,
+      usefulLifeMonths,
+      monthsElapsed,
+      monthlyDepreciation,
+      bookValue,
+    };
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/rule-engine/controllers/priority-configs.controller.ts b/apps/edr-freight-api/src/modules/rule-engine/controllers/priority-configs.controller.ts
index 36b863dd6..8dcc58e77 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/controllers/priority-configs.controller.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/controllers/priority-configs.controller.ts
@@ -21,7 +21,7 @@ export class PriorityConfigsController {
   @ApiOperation({ summary: 'List priority configs' })
   findAll(@Query() query: Record<string, string>) {
     return this.service.findAll({
-      type: (query['type'] as 'WAGON' | 'CURRENCY') || undefined,
+      type: (query['type'] as 'WAGON' | 'CURRENCY' | 'CUSTOMS') || undefined,
       isActive: query['isActive'] !== undefined ? query['isActive'] === 'true' : undefined,
       page: query['page'] ? parseInt(query['page'], 10) : undefined,
       pageSize: query['pageSize'] ? parseInt(query['pageSize'], 10) : undefined,
diff --git a/apps/edr-freight-api/src/modules/rule-engine/dto/create-priority-config.dto.ts b/apps/edr-freight-api/src/modules/rule-engine/dto/create-priority-config.dto.ts
index d2ca44d93..484d3fbaf 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/dto/create-priority-config.dto.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/dto/create-priority-config.dto.ts
@@ -2,9 +2,12 @@ import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
 import { IsBoolean, IsIn, IsInt, IsOptional, IsString, Max, MaxLength, Min } from 'class-validator';
 
 export class CreatePriorityConfigDto {
-  @ApiProperty({ description: 'Config type: WAGON or CURRENCY', enum: ['WAGON', 'CURRENCY'] })
-  @IsIn(['WAGON', 'CURRENCY'])
-  type!: 'WAGON' | 'CURRENCY';
+  @ApiProperty({
+    description: 'Config type: WAGON, CURRENCY, or CUSTOMS',
+    enum: ['WAGON', 'CURRENCY', 'CUSTOMS'],
+  })
+  @IsIn(['WAGON', 'CURRENCY', 'CUSTOMS'])
+  type!: 'WAGON' | 'CURRENCY' | 'CUSTOMS';
 
   @ApiProperty({ description: 'Human-readable label', maxLength: 100 })
   @IsString()
@@ -12,7 +15,8 @@ export class CreatePriorityConfigDto {
   label!: string;
 
   @ApiPropertyOptional({
-    description: 'Currency code (e.g., USD, ETB). Required for type=CURRENCY, must be null for type=WAGON',
+    description:
+      'Currency code (e.g., USD, ETB). Required for type=CURRENCY, must be null for type=WAGON and type=CUSTOMS',
     maxLength: 5,
   })
   @IsOptional()
diff --git a/apps/edr-freight-api/src/modules/rule-engine/dto/create-service-type.dto.ts b/apps/edr-freight-api/src/modules/rule-engine/dto/create-service-type.dto.ts
index d68625fdc..a8e030bba 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/dto/create-service-type.dto.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/dto/create-service-type.dto.ts
@@ -1,5 +1,5 @@
 import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
-import { IsBoolean, IsInt, IsOptional, IsString, IsUUID, Max, MaxLength, Min } from 'class-validator';
+import { IsBoolean, IsInt, IsOptional, IsString, IsUUID, MaxLength, Min } from 'class-validator';
 
 export class CreateServiceTypeDto {
   @ApiProperty({ description: 'Service type display name', maxLength: 255 })
@@ -32,17 +32,6 @@ export class CreateServiceTypeDto {
   @IsBoolean()
   includesCustoms?: boolean;
 
-  @ApiPropertyOptional({
-    description: 'Priority bonus points awarded when this service is used (0–15)',
-    default: 0,
-    maximum: 15,
-  })
-  @IsOptional()
-  @IsInt()
-  @Min(0)
-  @Max(15)
-  priorityBonusPoints?: number;
-
   @ApiPropertyOptional({ default: true })
   @IsOptional()
   @IsBoolean()
diff --git a/apps/edr-freight-api/src/modules/rule-engine/entities/priority-config.entity.ts b/apps/edr-freight-api/src/modules/rule-engine/entities/priority-config.entity.ts
index df60b3ea1..e1fa5bfa7 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/entities/priority-config.entity.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/entities/priority-config.entity.ts
@@ -6,7 +6,7 @@ import { Column, Entity, Index } from 'typeorm';
 @Index(['currency', 'type'])
 export class PriorityConfig extends BaseEntity {
   @Column({ name: 'type', type: 'varchar', length: 20 })
-  type!: 'WAGON' | 'CURRENCY';
+  type!: 'WAGON' | 'CURRENCY' | 'CUSTOMS';
 
   @Column({ name: 'label', type: 'varchar', length: 100 })
   label!: string;
diff --git a/apps/edr-freight-api/src/modules/rule-engine/entities/service-type.entity.ts b/apps/edr-freight-api/src/modules/rule-engine/entities/service-type.entity.ts
index 2b7cb3f23..b882f1a08 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/entities/service-type.entity.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/entities/service-type.entity.ts
@@ -27,9 +27,6 @@ export class ServiceType extends BaseEntity {
   @Column({ name: 'includes_customs', type: 'boolean', default: false })
   includesCustoms!: boolean;
 
-  @Column({ name: 'priority_bonus_points', type: 'int', default: 0 })
-  priorityBonusPoints!: number;
-
   @Column({ name: 'is_active', type: 'boolean', default: true })
   isActive!: boolean;
 
diff --git a/apps/edr-freight-api/src/modules/rule-engine/rule-engine.service.ts b/apps/edr-freight-api/src/modules/rule-engine/rule-engine.service.ts
index 0fee8e75a..e451098fc 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/rule-engine.service.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/rule-engine.service.ts
@@ -176,13 +176,12 @@ export class RuleEngineService {
     }
 
     const serviceType = await this.serviceTypesRepo.findById(input.serviceTypeId);
-    if (serviceType) {
-      priorityScore += serviceType.priorityBonusPoints;
-    }
+    const includesCustoms = serviceType?.includesCustoms ?? false;
 
     // Additive priority blocks, each keyed on the booking's total wagon count:
     //  - WAGON    rules apply regardless of currency.
     //  - CURRENCY rules apply only when the payment currency matches.
+    //  - CUSTOMS  rules apply only when the service type includes customs.
     const priorityConfigs = await this.priorityConfigsRepo.findAllActive();
     const wagonsInRange = (cfg: { minWagonCount: number; maxWagonCount: number }) =>
       input.totalWagons >= cfg.minWagonCount &&
@@ -191,7 +190,8 @@ export class RuleEngineService {
     for (const cfg of priorityConfigs) {
       const applies =
         cfg.type === 'WAGON' ||
-        (cfg.type === 'CURRENCY' && cfg.currency === input.paymentCurrency);
+        (cfg.type === 'CURRENCY' && cfg.currency === input.paymentCurrency) ||
+        (cfg.type === 'CUSTOMS' && includesCustoms);
       if (applies && wagonsInRange(cfg)) {
         priorityScore += cfg.scorePoints;
       }
diff --git a/apps/edr-freight-api/src/modules/rule-engine/services/priority-configs.service.ts b/apps/edr-freight-api/src/modules/rule-engine/services/priority-configs.service.ts
index 173c63f21..6d7034ad4 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/services/priority-configs.service.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/services/priority-configs.service.ts
@@ -17,7 +17,7 @@ export class PriorityConfigsService {
   ) {}
 
   async findAll(filter: {
-    type?: 'WAGON' | 'CURRENCY';
+    type?: 'WAGON' | 'CURRENCY' | 'CUSTOMS';
     isActive?: boolean;
     page?: number;
     pageSize?: number;
@@ -87,12 +87,15 @@ export class PriorityConfigsService {
     await this.displayOrder.moveOne(PriorityConfig, 'displayOrder', id, direction);
   }
 
-  private validateCurrencyField(type: 'WAGON' | 'CURRENCY', currency: string | undefined | null): void {
+  private validateCurrencyField(
+    type: 'WAGON' | 'CURRENCY' | 'CUSTOMS',
+    currency: string | undefined | null,
+  ): void {
     if (type === 'CURRENCY' && !currency) {
       throw new BadRequestException('currency field is required when type is CURRENCY');
     }
-    if (type === 'WAGON' && currency) {
-      throw new BadRequestException('currency field must be null when type is WAGON');
+    if (type !== 'CURRENCY' && currency) {
+      throw new BadRequestException(`currency field must be null when type is ${type}`);
     }
   }
 }
diff --git a/apps/edr-freight-api/src/modules/rule-engine/services/service-types.service.ts b/apps/edr-freight-api/src/modules/rule-engine/services/service-types.service.ts
index 2ad8753c3..6608749d1 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/services/service-types.service.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/services/service-types.service.ts
@@ -76,7 +76,6 @@ export class ServiceTypesService {
       includesFirstMile: dto.includesFirstMile ?? false,
       includesLastMile: dto.includesLastMile ?? false,
       includesCustoms: dto.includesCustoms ?? false,
-      priorityBonusPoints: dto.priorityBonusPoints ?? 0,
       isActive: dto.isActive ?? true,
       displayOrder,
     });
diff --git a/apps/edr-freight-api/src/modules/train-schedules/entities/train-schedule.entity.ts b/apps/edr-freight-api/src/modules/train-schedules/entities/train-schedule.entity.ts
index f82d9696d..899b302fc 100644
--- a/apps/edr-freight-api/src/modules/train-schedules/entities/train-schedule.entity.ts
+++ b/apps/edr-freight-api/src/modules/train-schedules/entities/train-schedule.entity.ts
@@ -61,6 +61,12 @@ export class TrainSchedule extends BaseEntity {
   @Column({ name: 'train_number', type: 'varchar', length: 20, nullable: true })
   trainNumber?: string | null;
 
+  // Human-facing unique schedule reference (S-YYYY-NNNNN). Shown on the schedule
+  // list, booking windows, and load lists. Assigned at creation from the highest
+  // sequence issued this year (see TrainSchedulesRepository.maxReferenceSequence).
+  @Column({ name: 'reference', type: 'varchar', length: 20, nullable: true, unique: true })
+  reference?: string | null;
+
   @Column({ name: 'direction', type: 'varchar', length: 10, nullable: true })
   direction?: string | null;
 
diff --git a/apps/edr-freight-api/src/modules/train-schedules/train-schedules.repository.ts b/apps/edr-freight-api/src/modules/train-schedules/train-schedules.repository.ts
index 58e71143c..700a38983 100644
--- a/apps/edr-freight-api/src/modules/train-schedules/train-schedules.repository.ts
+++ b/apps/edr-freight-api/src/modules/train-schedules/train-schedules.repository.ts
@@ -58,4 +58,22 @@ export class TrainSchedulesRepository extends BaseRepository<TrainSchedule> {
   ): Promise<void> {
     await this.repo(manager).update(id, { status, ...extra } as never);
   }
+
+  /**
+   * Highest NNNNN sequence already issued for `S-<year>-…` references. Includes
+   * soft-deleted rows so the next number never reuses one still occupying the
+   * unique index (see the same pattern on BookingsRepository).
+   */
+  async maxReferenceSequence(year: number): Promise<number> {
+    const row = await this.repository
+      .createQueryBuilder('schedule')
+      .withDeleted()
+      .select(
+        "COALESCE(MAX(CAST(SUBSTRING(schedule.reference FROM '[0-9]+$') AS int)), 0)",
+        'max',
+      )
+      .where('schedule.reference LIKE :prefix', { prefix: `S-${year}-%` })
+      .getRawOne<{ max: string | number | null }>();
+    return Number(row?.max ?? 0);
+  }
 }
diff --git a/apps/edr-freight-api/src/modules/train-scheduling/booking-batch.service.spec.ts b/apps/edr-freight-api/src/modules/train-scheduling/booking-batch.service.spec.ts
index 8f11cfc95..31d3c8855 100644
--- a/apps/edr-freight-api/src/modules/train-scheduling/booking-batch.service.spec.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/booking-batch.service.spec.ts
@@ -21,6 +21,8 @@ describe('BookingBatchService — PAID reconcile', () => {
     findPaidUnlinkedForSchedule: jest.Mock;
     findBatchPool: jest.Mock;
     findBatchPoolByRouteDay: jest.Mock;
+    findBatchPoolByCorridorDay: jest.Mock;
+    findUnacceptedForRouteDay: jest.Mock;
     findReservedForSchedule: jest.Mock;
     update: jest.Mock;
   };
@@ -53,6 +55,8 @@ describe('BookingBatchService — PAID reconcile', () => {
       findPaidUnlinkedForSchedule: jest.fn().mockResolvedValue([]),
       findBatchPool: jest.fn().mockResolvedValue([]),
       findBatchPoolByRouteDay: jest.fn().mockResolvedValue([]),
+      findBatchPoolByCorridorDay: jest.fn().mockResolvedValue([]),
+      findUnacceptedForRouteDay: jest.fn().mockResolvedValue([]),
       findReservedForSchedule: jest.fn().mockResolvedValue([]),
       update: jest.fn().mockResolvedValue(undefined),
     };
@@ -121,7 +125,10 @@ describe('BookingBatchService — PAID reconcile', () => {
       notifier as never,
       { addTimeout: jest.fn(), deleteTimeout: jest.fn(), doesExist: jest.fn() } as never,
       trainSchedulingService as never,
-      { syncPayableDueDate: jest.fn(), expirePayable: jest.fn() } as never,
+      {
+        syncPayableDueDate: jest.fn().mockResolvedValue(undefined),
+        expirePayable: jest.fn().mockResolvedValue(undefined),
+      } as never,
       { emitPhase: jest.fn() } as never,
     );
   });
@@ -196,6 +203,8 @@ describe('BookingBatchService — PAID reconcile', () => {
         cargoTotalWeightVgm: 10,
         freightType: 'CONTAINER',
         bookingContainers: [],
+        originYardId,
+        destinationYardId,
       }) as unknown as Booking;
 
     beforeEach(() => {
@@ -227,13 +236,15 @@ describe('BookingBatchService — PAID reconcile', () => {
           trainSetId: `set-${id}`,
           trainSet: { locomotive: smallLoco },
           scheduleBookings: [],
+          originStationId: originYardId,
+          destinationStationId: destinationYardId,
         }),
       );
     });
 
     it('spills overflow to the next train by priority, then reports unplaced', async () => {
       // 3 commercial bookings, descending priority; only 1 fits per train (2 total).
-      bookingsRepository.findBatchPoolByRouteDay.mockResolvedValue([
+      bookingsRepository.findBatchPoolByCorridorDay.mockResolvedValue([
         commercial('hi', 30),
         commercial('mid', 20),
         commercial('lo', 10),
@@ -241,9 +252,8 @@ describe('BookingBatchService — PAID reconcile', () => {
 
       const touched = await service.fillRouteDay(originYardId, destinationYardId, day);
 
-      expect(bookingsRepository.findBatchPoolByRouteDay).toHaveBeenCalledWith(
-        originYardId,
-        destinationYardId,
+      expect(bookingsRepository.findBatchPoolByCorridorDay).toHaveBeenCalledWith(
+        [originYardId, destinationYardId],
         day,
       );
       // Both trains were processed.
@@ -258,7 +268,7 @@ describe('BookingBatchService — PAID reconcile', () => {
     });
 
     it('reserves the chosen train id on each commercial booking', async () => {
-      bookingsRepository.findBatchPoolByRouteDay.mockResolvedValue([commercial('hi', 30)]);
+      bookingsRepository.findBatchPoolByCorridorDay.mockResolvedValue([commercial('hi', 30)]);
 
       await service.fillRouteDay(originYardId, destinationYardId, day);
 
@@ -286,9 +296,11 @@ describe('BookingBatchService — PAID reconcile', () => {
           freightType: 'CONTAINER',
           consolidationPartnerId: partnerId,
           bookingContainers: [{ quantity: 1 }],
+          originYardId,
+          destinationYardId,
         }) as unknown as Booking;
 
-      bookingsRepository.findBatchPoolByRouteDay.mockResolvedValue([
+      bookingsRepository.findBatchPoolByCorridorDay.mockResolvedValue([
         consol('a', 'b', 30),
         consol('b', 'a', 20),
       ]);
@@ -313,9 +325,11 @@ describe('BookingBatchService — PAID reconcile', () => {
         freightType: 'CONTAINER',
         consolidationPartnerId: 'missing-partner',
         bookingContainers: [{ quantity: 1 }],
+        originYardId,
+        destinationYardId,
       } as unknown as Booking;
 
-      bookingsRepository.findBatchPoolByRouteDay.mockResolvedValue([lonely]);
+      bookingsRepository.findBatchPoolByCorridorDay.mockResolvedValue([lonely]);
 
       await service.fillRouteDay(originYardId, destinationYardId, day);
 
@@ -323,4 +337,177 @@ describe('BookingBatchService — PAID reconcile', () => {
       expect(notifier.payNow).not.toHaveBeenCalled();
     });
   });
+
+  describe('expireUnacceptedForRouteDay — doc-review sweep', () => {
+    const originYardId = 'yard-origin';
+    const destinationYardId = 'yard-dest';
+    const day = '2026-06-20';
+
+    const pendingBooking = {
+      id: 'pending-1',
+      reference: 'BK-PENDING-1',
+      status: 'OPERATION_REQUEST_PENDING',
+      isGovernment: false,
+      originYardId,
+      destinationYardId,
+    } as unknown as Booking;
+
+    beforeEach(() => {
+      // One fillable schedule on this corridor/day so corridorYardsForRouteDay
+      // resolves a non-empty yard set (legacy two-stop route → [origin, dest]).
+      trainSchedulesRepository.findAll.mockResolvedValue([
+        {
+          id: 'sched-1',
+          originStationId: originYardId,
+          destinationStationId: destinationYardId,
+          scheduledDepartureDate: new Date('2026-06-20T06:00:00.000Z'),
+        },
+      ]);
+    });
+
+    it('expires each un-accepted booking and clears its scheduled day', async () => {
+      bookingsRepository.findUnacceptedForRouteDay.mockResolvedValue([pendingBooking]);
+
+      await service.expireUnacceptedForRouteDay({
+        originYardId,
+        destinationYardId,
+        day,
+      });
+
+      expect(bookingsRepository.findUnacceptedForRouteDay).toHaveBeenCalledWith(
+        expect.arrayContaining([originYardId, destinationYardId]),
+        day,
+      );
+      expect(bookingsRepository.update).toHaveBeenCalledWith(
+        'pending-1',
+        expect.objectContaining({
+          status: 'EXPIRED',
+          schedulingStatus: 'ELIGIBLE',
+          scheduledDate: null,
+        }),
+      );
+      expect(notifier.expired).toHaveBeenCalledWith(pendingBooking);
+    });
+
+    it('is a no-op when nothing is un-accepted', async () => {
+      bookingsRepository.findUnacceptedForRouteDay.mockResolvedValue([]);
+
+      await service.expireUnacceptedForRouteDay({
+        originYardId,
+        destinationYardId,
+        day,
+      });
+
+      expect(bookingsRepository.update).not.toHaveBeenCalled();
+      expect(notifier.expired).not.toHaveBeenCalled();
+    });
+
+    it('does nothing when the route-day has no fillable schedule', async () => {
+      trainSchedulesRepository.findAll.mockResolvedValue([]);
+
+      await service.expireUnacceptedForRouteDay({
+        originYardId,
+        destinationYardId,
+        day,
+      });
+
+      expect(bookingsRepository.findUnacceptedForRouteDay).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('maybeOfferPartial — split-eligibility gate', () => {
+    const importGeneral = {
+      id: 'b1',
+      reference: 'b1',
+      isGovernment: false,
+      tradeDirection: 'IMPORT',
+      contractKind: 'GENERAL',
+      consolidationPartnerId: null,
+    } as unknown as Booking;
+
+    const call = (booking: Booking, isPair: boolean): boolean =>
+      (
+        service as unknown as {
+          isSplitEligible: (b: Booking, p: boolean) => boolean;
+        }
+      ).isSplitEligible(booking, isPair);
+
+    it('allows IMPORT + GENERAL when splitService is present', () => {
+      const withSplit = new BookingBatchService(
+        dataSource as never,
+        bookingsRepository as never,
+        trainSchedulesRepository as never,
+        trainScheduleBookingsRepository as never,
+        notifier as never,
+        { addTimeout: jest.fn(), deleteTimeout: jest.fn(), doesExist: jest.fn() } as never,
+        trainSchedulingService as never,
+        { syncPayableDueDate: jest.fn(), expirePayable: jest.fn() } as never,
+        { emitPhase: jest.fn() } as never,
+        undefined,
+        { findOpenOffer: jest.fn() } as never,
+      );
+      const eligible = (
+        withSplit as unknown as {
+          isSplitEligible: (b: Booking, p: boolean) => boolean;
+        }
+      ).isSplitEligible(importGeneral, false);
+      expect(eligible).toBe(true);
+    });
+
+    it('allows IMPORT + ONE_TIME (promoted to GENERAL on split)', () => {
+      const withSplit = new BookingBatchService(
+        dataSource as never,
+        bookingsRepository as never,
+        trainSchedulesRepository as never,
+        trainScheduleBookingsRepository as never,
+        notifier as never,
+        { addTimeout: jest.fn(), deleteTimeout: jest.fn(), doesExist: jest.fn() } as never,
+        trainSchedulingService as never,
+        { syncPayableDueDate: jest.fn(), expirePayable: jest.fn() } as never,
+        { emitPhase: jest.fn() } as never,
+        undefined,
+        { findOpenOffer: jest.fn() } as never,
+      );
+      const eligible = (
+        withSplit as unknown as {
+          isSplitEligible: (b: Booking, p: boolean) => boolean;
+        }
+      ).isSplitEligible(
+        { ...importGeneral, contractKind: 'ONE_TIME' } as Booking,
+        false,
+      );
+      expect(eligible).toBe(true);
+    });
+
+    it('rejects when splitService is absent (default test service)', () => {
+      // `service` from the outer beforeEach was built without a splitService.
+      expect(call(importGeneral, false)).toBe(false);
+    });
+
+    it('rejects EXPORT, government, consolidated pairs, and other directions', () => {
+      const withSplit = new BookingBatchService(
+        dataSource as never,
+        bookingsRepository as never,
+        trainSchedulesRepository as never,
+        trainScheduleBookingsRepository as never,
+        notifier as never,
+        { addTimeout: jest.fn(), deleteTimeout: jest.fn(), doesExist: jest.fn() } as never,
+        trainSchedulingService as never,
+        { syncPayableDueDate: jest.fn(), expirePayable: jest.fn() } as never,
+        { emitPhase: jest.fn() } as never,
+        undefined,
+        { findOpenOffer: jest.fn() } as never,
+      );
+      const check = (
+        withSplit as unknown as {
+          isSplitEligible: (b: Booking, p: boolean) => boolean;
+        }
+      ).isSplitEligible.bind(withSplit);
+
+      expect(check({ ...importGeneral, tradeDirection: 'EXPORT' } as Booking, false)).toBe(false);
+      expect(check({ ...importGeneral, isGovernment: true } as Booking, false)).toBe(false);
+      expect(check(importGeneral, true)).toBe(false); // consolidated pair
+      expect(check({ ...importGeneral, contractKind: null } as Booking, false)).toBe(false);
+    });
+  });
 });
diff --git a/apps/edr-freight-api/src/modules/train-scheduling/booking-batch.service.ts b/apps/edr-freight-api/src/modules/train-scheduling/booking-batch.service.ts
index 889af7cc5..2a9169ab7 100644
--- a/apps/edr-freight-api/src/modules/train-scheduling/booking-batch.service.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/booking-batch.service.ts
@@ -15,6 +15,7 @@ import { Booking } from '../bookings/entities/booking.entity';
 import { BookingsRepository } from '../bookings/bookings.repository';
 import { Locomotive } from '../locomotives/entities/locomotive.entity';
 import { formatRouteLabel } from '../routes/entities/route.entity';
+import { RouteMilestone } from '../routes/entities/route-milestone.entity';
 import { TrainSchedule } from '../train-schedules/entities/train-schedule.entity';
 import { TrainScheduleBooking } from '../train-schedules/entities/train-schedule-booking.entity';
 import { TrainSchedulesRepository } from '../train-schedules/train-schedules.repository';
@@ -42,13 +43,14 @@ import { ClearanceMilestoneService } from '../contracts/clearance-milestone.serv
 import { BookingSplitService } from './booking-split.service';
 import { BookingWindowGateway } from './booking-window.gateway';
 import { MAX_TEU_SLOTS_PER_WAGON } from './wagon-plan.util';
+import {
+  Capacity,
+  CorridorBudget,
+  CorridorLeg,
+  stopYardsFor,
+} from './corridor-capacity.util';
 
-/** A train's remaining capacity along the three physical limits the batch enforces. */
-export interface Capacity {
-  wagons: number;
-  weightTons: number;
-  lengthMeters: number;
-}
+export type { Capacity } from './corridor-capacity.util';
 
 /** A day-level pool key: all trains on this route departing on this EAT day. */
 interface RouteDayGroup {
@@ -78,6 +80,10 @@ export interface BatchBoardBooking {
   lengthMeters: number;
   paymentDeadline: string | null;
   state: BatchBoardBookingState;
+  /** Rule-engine priority score used to rank the batch (higher = boards first). */
+  priorityScore: number;
+  /** CONTAINER | BULK — for the priority-tracking visuals. */
+  freightType: string | null;
 }
 
 export type BookingAllocationStatus =
@@ -382,6 +388,18 @@ export class BookingBatchService implements OnModuleInit {
       this.logger.log(
         `Linked PAID booking ${booking.reference ?? bookingId} to schedule ${booking.trainScheduleId}`,
       );
+    } else {
+      // Already linked at booking time (export FCFS: the customer books a
+      // specific train, so allocate() ran up front). allocate() is where the
+      // payment-settled tracking milestones are written, so on this branch we
+      // record them here — otherwise a paid, already-linked booking leaves
+      // FREIGHT_PAYMENT_SETTLED stuck PENDING and the clearance step never ticks.
+      void this.completeTrackingMilestones(bookingId, [
+        "WAGON_REQUESTED",
+        "FREIGHT_PAYMENT_PENDING",
+        "FREIGHT_PAYMENT_SETTLED",
+      ]);
+      void this.markWagonAllocatedMilestone(bookingId);
     }
 
     const schedule = await this.trainSchedulesRepository.findByIdWithFullGraph(
@@ -447,18 +465,14 @@ export class BookingBatchService implements OnModuleInit {
       throw new BadRequestException('Booking has no scheduled date');
     }
     const day = eatDay(new Date(booking.scheduledDate));
+    // Corridor-aware: any train whose route carries the booking's origin
+    // strictly before its destination qualifies — a Dire→Djibouti booking may
+    // ride an Addis→…→Djibouti train. The leg check below (legOf) enforces the
+    // stop order, so we fetch the day's open trains without endpoint filters.
     const corridor = await this.trainSchedulesRepository.findAll({
       where: [
-        {
-          originStationId: booking.originYardId,
-          destinationStationId: booking.destinationYardId,
-          status: TrainScheduleStatusEnum.Draft,
-        },
-        {
-          originStationId: booking.originYardId,
-          destinationStationId: booking.destinationYardId,
-          status: TrainScheduleStatusEnum.Scheduled,
-        },
+        { status: TrainScheduleStatusEnum.Draft },
+        { status: TrainScheduleStatusEnum.Scheduled },
       ],
     });
     const candidates = corridor
@@ -481,6 +495,7 @@ export class BookingBatchService implements OnModuleInit {
     const rules = await this.loadGlobalRules();
     const wagonLengths = await this.loadWagonLengths();
     const required = need ?? this.needFor(booking, wagonLengths);
+    let corridorMatched = false;
     for (const candidate of candidates) {
       const schedule = await this.trainSchedulesRepository.findByIdWithFullGraph(
         candidate.id,
@@ -488,8 +503,16 @@ export class BookingBatchService implements OnModuleInit {
       const locomotive = schedule?.trainSet?.locomotive;
       if (!schedule || !locomotive) continue;
       const limits = await this.capacityLimits(locomotive, rules);
-      const budget = await this.remainingCapacity(schedule, limits, wagonLengths);
-      if (this.fits(required, budget)) return schedule.id;
+      const budget = await this.remainingBudget(schedule, limits, wagonLengths);
+      const leg = budget.legOf(booking.originYardId, booking.destinationYardId);
+      if (!leg) continue; // this train's route doesn't carry the booking's leg
+      corridorMatched = true;
+      if (budget.fits(required, leg)) return schedule.id;
+    }
+    if (!corridorMatched) {
+      throw new ConflictException(
+        'No export train is accepting bookings for this day',
+      );
     }
     throw new ConflictException('Train is full — no export capacity left for this day');
   }
@@ -619,6 +642,8 @@ export class BookingBatchService implements OnModuleInit {
             ? b.paymentDeadline.toISOString()
             : null,
           state: this.boardState(b, linkedIds.has(b.id)),
+          priorityScore: Number(b.priorityScore ?? 0),
+          freightType: b.freightType ?? null,
         };
       });
 
@@ -707,6 +732,8 @@ export class BookingBatchService implements OnModuleInit {
           ? b.paymentDeadline.toISOString()
           : null,
         state: this.boardState(b, linkedIds.has(b.id)),
+        priorityScore: Number(b.priorityScore ?? 0),
+        freightType: b.freightType ?? null,
         fullyExecutedAt: b.fullyExecutedAt
           ? b.fullyExecutedAt.toISOString()
           : null,
@@ -997,8 +1024,8 @@ export class BookingBatchService implements OnModuleInit {
     const wagonLengths = await this.loadWagonLengths();
     const limits = await this.capacityLimits(locomotive, rules);
     await this.syncScheduleMaxWagons(schedule, locomotive, rules);
-    let budget = await this.remainingCapacity(schedule, limits, wagonLengths);
-    if (budget.wagons <= 0) {
+    const budget = await this.remainingBudget(schedule, limits, wagonLengths);
+    if (budget.maxRemaining().wagons <= 0) {
       await this.setWindow(scheduleId, "FULL");
       return;
     }
@@ -1007,6 +1034,15 @@ export class BookingBatchService implements OnModuleInit {
     const units = this.groupConsolidatedPool(pool);
     let armed = false;
 
+    // Batch fill trace: caps + pool at entry. Kept on debug level — invaluable when
+    // reservations trickle instead of landing in one pass (a reserve() throwing
+    // mid-loop, e.g. schema drift, or a mis-synced capacity cap).
+    this.logger.debug(
+      `[fillSchedule ${scheduleId}] limits=${JSON.stringify(limits)} ` +
+        `maxWagons=${schedule.maxWagons} remaining=${JSON.stringify(budget.maxRemaining())} ` +
+        `poolSize=${pool.length} units=${units.length}`,
+    );
+
     for (const unit of units) {
       const { primary: booking, partner } = unit;
       const isPair = partner != null;
@@ -1014,17 +1050,39 @@ export class BookingBatchService implements OnModuleInit {
         ? this.combinedNeed(booking, partner, wagonLengths)
         : this.needFor(booking, wagonLengths);
       const isGov = booking.isGovernment || (partner?.isGovernment ?? false);
+      // Consolidated partners always share one corridor, so the primary's leg
+      // stands for the pair.
+      const leg = budget.legForYards(booking.originYardId, booking.destinationYardId);
 
-      if (!this.fits(need, budget)) {
+      // Per-unit fit trace: which axis (wagons/weight/length) admits or rejects.
+      this.logger.debug(
+        `[fillSchedule ${scheduleId}] unit ${booking.reference}: need=${JSON.stringify(need)} ` +
+          `roomOnLeg=${JSON.stringify(budget.remainingFor(leg))} fits=${budget.fits(need, leg)}`,
+      );
+
+      if (!budget.fits(need, leg)) {
         if (isGov) {
-          budget = await this.preemptForGovernment(
+          const freed = await this.preemptForGovernment(
             scheduleId,
             need,
+            leg,
             budget,
             wagonLengths,
           );
-          if (!this.fits(need, budget)) continue; // still doesn't fit even after preempt
+          if (!freed) continue; // still doesn't fit even after preempt
         } else {
+          // Doesn't fit whole. A split-eligible import booking is offered the part
+          // that fits in the remaining room (top-up path splits the boundary
+          // booking, mirroring fillRouteDay); otherwise skip and try the next.
+          const cand: { id: string; budget: CorridorBudget; armed: boolean } = {
+            id: scheduleId,
+            budget,
+            armed,
+          };
+          if (await this.maybeOfferPartial(booking, isPair, [cand], need)) {
+            armed = cand.armed;
+            continue;
+          }
           continue; // skip a unit that exceeds weight/length/wagons, try the next
         }
       }
@@ -1037,11 +1095,11 @@ export class BookingBatchService implements OnModuleInit {
         if (partner) await this.reserve(partner, scheduleId);
         armed = true;
       }
-      budget = this.subtract(budget, need);
-      if (budget.wagons <= 0) break; // no wagon slots left — nothing more can board
+      budget.subtract(need, leg);
+      if (budget.maxRemaining().wagons <= 0) break; // every leg exhausted — nothing more can board
     }
 
-    if (budget.wagons <= 0) await this.setWindow(scheduleId, "FULL");
+    if (budget.maxRemaining().wagons <= 0) await this.setWindow(scheduleId, "FULL");
     if (armed) this.armSettle(scheduleId);
     void this.triggerWagonAllocation(scheduleId);
   }
@@ -1094,8 +1152,8 @@ export class BookingBatchService implements OnModuleInit {
     const rules = await this.loadGlobalRules();
     const wagonLengths = await this.loadWagonLengths();
 
-    // Live per-schedule budget + arm flag, in departure order.
-    const trains: Array<{ id: string; budget: Capacity; armed: boolean }> = [];
+    // Live per-schedule corridor budget + arm flag, in departure order.
+    const trains: Array<{ id: string; budget: CorridorBudget; armed: boolean }> = [];
     for (const id of scheduleIds) {
       const schedule =
         await this.trainSchedulesRepository.findByIdWithFullGraph(id);
@@ -1108,24 +1166,31 @@ export class BookingBatchService implements OnModuleInit {
       }
       const limits = await this.capacityLimits(locomotive, rules);
       await this.syncScheduleMaxWagons(schedule, locomotive, rules);
-      const budget = await this.remainingCapacity(
-        schedule,
-        limits,
-        wagonLengths,
-      );
+      const budget = await this.remainingBudget(schedule, limits, wagonLengths);
       trains.push({ id, budget, armed: false });
     }
     if (trains.length === 0) return [];
 
-    const pool = await this.bookingsRepository.findBatchPoolByRouteDay(
-      originYardId,
-      destinationYardId,
+    // The day pool covers every booking whose leg lies somewhere on one of the
+    // day's corridors — full-route AND sub-corridor (e.g. Dire→Djibouti on an
+    // Addis→Djibouti train). Which train actually takes a booking is decided
+    // by the per-train legOf check below.
+    const corridorYards = [...new Set(trains.flatMap((t) => t.budget.stops))];
+    const pool = await this.bookingsRepository.findBatchPoolByCorridorDay(
+      corridorYards,
       day,
     );
     // Consolidated partners collapse into one atomic unit (both-or-neither); a
     // consolidated booking whose partner isn't ready this cycle is skipped.
     const units = this.groupConsolidatedPool(pool);
 
+    // Batch fill trace: each train's caps + the day pool size at entry.
+    this.logger.debug(
+      `[fillRouteDay ${originYardId}->${destinationYardId} ${day}] ` +
+        `trains=${trains.map((t) => `${t.id}:${JSON.stringify(t.budget.maxRemaining())}`).join(",")} ` +
+        `poolSize=${pool.length} units=${units.length}`,
+    );
+
     for (const unit of units) {
       const { primary: booking, partner } = unit;
       const isPair = partner != null;
@@ -1134,20 +1199,42 @@ export class BookingBatchService implements OnModuleInit {
         : this.needFor(booking, wagonLengths);
       const isGov = booking.isGovernment || (partner?.isGovernment ?? false);
 
-      // First train (earliest departure) that fits this unit as-is.
-      let target = trains.find((t) => this.fits(need, t.budget));
+      const legOn = (t: { budget: CorridorBudget }): CorridorLeg | null =>
+        t.budget.legOf(booking.originYardId, booking.destinationYardId);
+
+      // First train (earliest departure) whose corridor carries this booking's
+      // leg and still fits it as-is.
+      let target = trains.find((t) => {
+        const leg = legOn(t);
+        return leg != null && t.budget.fits(need, leg);
+      });
+
+      // Per-unit trace: chosen train + each train's remaining room on this leg.
+      this.logger.debug(
+        `[fillRouteDay] unit ${booking.reference}: need=${JSON.stringify(need)} ` +
+          `targetTrain=${target?.id ?? "none"} ` +
+          `rooms=${trains
+            .map((t) => {
+              const leg = legOn(t);
+              return leg ? `${t.id}:${JSON.stringify(t.budget.remainingFor(leg))}` : `${t.id}:offleg`;
+            })
+            .join(",")}`,
+      );
 
       if (!target && isGov) {
         // Government fits nowhere on its own — try to preempt commercial
-        // on each train (earliest first) until one frees enough room.
+        // on each corridor-matching train (earliest first) until one frees room.
         for (const t of trains) {
-          t.budget = await this.preemptForGovernment(
+          const leg = legOn(t);
+          if (!leg) continue;
+          const freed = await this.preemptForGovernment(
             t.id,
             need,
+            leg,
             t.budget,
             wagonLengths,
           );
-          if (this.fits(need, t.budget)) {
+          if (freed) {
             target = t;
             break;
           }
@@ -1155,33 +1242,14 @@ export class BookingBatchService implements OnModuleInit {
       }
 
       if (!target) {
-        // A consolidated pair is placed whole or not at all — never split.
-        if (!isPair) {
-          // Fits no train whole. Import GENERAL-contract commercial bookings get a
-          // partial-capacity offer on the train with the most free wagons.
-          const partialTarget = [...trains]
-            .filter((t) => t.budget.wagons >= 1)
-            .sort((a, b) => b.budget.wagons - a.budget.wagons)[0];
-          if (
-            partialTarget &&
-            !booking.isGovernment &&
-            booking.tradeDirection === "IMPORT" &&
-            booking.contractKind === "GENERAL" &&
-            this.splitService
-          ) {
-            const offered = await this.tryPartialOffer(
-              booking,
-              partialTarget.id,
-              partialTarget.budget,
-              need,
-            );
-            if (offered) {
-              partialTarget.budget = this.subtract(partialTarget.budget, offered);
-              partialTarget.armed = true;
-              continue;
-            }
-          }
-        }
+        // Fits no train whole. A split-eligible booking is offered the largest
+        // part that fits on the train with the most free wagons on its leg (this
+        // covers both "fits nowhere" and the boundary case where earlier bookings
+        // already consumed most of the room). Consolidated pairs / government /
+        // non-import never split — isSplitEligible guards that. Passing the live
+        // `trains` entries lets maybeOfferPartial mutate the chosen budget/armed.
+        const offered = await this.maybeOfferPartial(booking, isPair, trains, need);
+        if (offered) continue;
         // Stays in the pool, retried next batch/window cycle.
         this.notifier.unplaced(booking, day);
         if (partner) this.notifier.unplaced(partner, day);
@@ -1196,11 +1264,11 @@ export class BookingBatchService implements OnModuleInit {
         if (partner) await this.reserve(partner, target.id);
         target.armed = true;
       }
-      target.budget = this.subtract(target.budget, need);
+      target.budget.subtract(need, legOn(target)!);
     }
 
     for (const t of trains) {
-      if (t.budget.wagons <= 0) await this.setWindow(t.id, "FULL");
+      if (t.budget.maxRemaining().wagons <= 0) await this.setWindow(t.id, "FULL");
       if (t.armed) this.armSettle(t.id);
       void this.triggerWagonAllocation(t.id);
     }
@@ -1208,6 +1276,57 @@ export class BookingBatchService implements OnModuleInit {
     return trains.map((t) => t.id);
   }
 
+  /**
+   * A lone commercial IMPORT booking on a GENERAL or ONE_TIME contract may be
+   * offered a partial (split-on-payment). Consolidated pairs never split (both-or-
+   * neither shared wagon) and government bookings never split (they preempt).
+   */
+  private isSplitEligible(booking: Booking, isPair: boolean): boolean {
+    return (
+      !isPair &&
+      !booking.isGovernment &&
+      booking.tradeDirection === "IMPORT" &&
+      (booking.contractKind === "GENERAL" || booking.contractKind === "ONE_TIME") &&
+      this.splitService != null
+    );
+  }
+
+  /**
+   * Offer the largest fitting part of a booking that does not fit any candidate
+   * train whole, on the train with the most free wagons on the booking's leg.
+   * Mutates the chosen candidate's budget + armed flag in place. Returns true when
+   * an offer was opened (caller should `continue` past this unit), false otherwise.
+   * Shared by fillRouteDay (multi-train) and fillSchedule (single train). The leg
+   * is computed per candidate from the booking's yards, so callers pass their live
+   * train entries and only leg-carrying trains are considered.
+   */
+  private async maybeOfferPartial(
+    booking: Booking,
+    isPair: boolean,
+    candidates: Array<{ id: string; budget: CorridorBudget; armed: boolean }>,
+    need: Capacity,
+  ): Promise<boolean> {
+    if (!this.isSplitEligible(booking, isPair)) return false;
+    const target = candidates
+      .map((c) => {
+        const leg = c.budget.legOf(booking.originYardId, booking.destinationYardId);
+        return leg ? { c, leg, room: c.budget.remainingFor(leg) } : null;
+      })
+      .filter((x): x is NonNullable<typeof x> => x != null && x.room.wagons >= 1)
+      .sort((a, b) => b.room.wagons - a.room.wagons)[0];
+    if (!target) return false;
+    const offered = await this.tryPartialOffer(
+      booking,
+      target.c.id,
+      target.room,
+      need,
+    );
+    if (!offered) return false;
+    target.c.budget.subtract(offered, target.leg);
+    target.c.armed = true;
+    return true;
+  }
+
   /**
    * Offer the largest fitting part of an over-capacity booking as a partial
    * (split-on-payment). Returns the capacity the offer consumes, or null when no
@@ -1402,10 +1521,10 @@ export class BookingBatchService implements OnModuleInit {
         "Target schedule is not accepting bookings",
       );
     }
-    if (
-      schedule.originStationId !== booking.originYardId ||
-      schedule.destinationStationId !== booking.destinationYardId
-    ) {
+    const stops = await this.stopsForSchedule(schedule);
+    const fromIdx = stops.indexOf(booking.originYardId);
+    const toIdx = stops.indexOf(booking.destinationYardId);
+    if (fromIdx < 0 || toIdx < 0 || fromIdx >= toIdx) {
       throw new BadRequestException(
         "Target schedule is not on the booking route",
       );
@@ -1449,13 +1568,14 @@ export class BookingBatchService implements OnModuleInit {
   // ---- intercity ride-along API ---------------------------------------------
 
   /**
-   * Remaining capacity budget (wagons / weight / length) for a schedule, and
-   * the per-booking need calculator — exposed for the intercity accept flow,
-   * which reserves ride-along bookings onto import/export trains outside the
-   * batch engine.
+   * Remaining corridor capacity budget (per-edge wagons / weight / length) for
+   * a schedule, and the per-booking need calculator — exposed for the intercity
+   * accept flow, which reserves ride-along bookings onto import/export trains
+   * outside the batch engine. Segment-based: an intercity booking fits whenever
+   * ITS leg has room, even if the train is full on other legs.
    */
   async intercityCapacity(scheduleId: string): Promise<{
-    budget: Capacity;
+    budget: CorridorBudget;
     needFor: (booking: Booking) => Capacity;
   } | null> {
     const schedule =
@@ -1465,7 +1585,7 @@ export class BookingBatchService implements OnModuleInit {
     const rules = await this.loadGlobalRules();
     const wagonLengths = await this.loadWagonLengths();
     const limits = await this.capacityLimits(locomotive, rules);
-    const budget = await this.remainingCapacity(schedule, limits, wagonLengths);
+    const budget = await this.remainingBudget(schedule, limits, wagonLengths);
     return { budget, needFor: (booking) => this.needFor(booking, wagonLengths) };
   }
 
@@ -1620,16 +1740,93 @@ export class BookingBatchService implements OnModuleInit {
     this.notifier.expired(booking);
   }
 
+  /**
+   * Union of stop yards across the day's fillable schedules on this corridor —
+   * the same pool scope fillRouteDay uses, so full-route AND sub-corridor bookings
+   * are covered. Empty when no fillable schedule exists for the group.
+   */
+  private async corridorYardsForRouteDay(
+    group: RouteDayGroup,
+  ): Promise<string[]> {
+    const corridor = await this.trainSchedulesRepository.findAll({
+      where: [
+        {
+          originStationId: group.originYardId,
+          destinationStationId: group.destinationYardId,
+          status: TrainScheduleStatusEnum.Draft,
+        },
+        {
+          originStationId: group.originYardId,
+          destinationStationId: group.destinationYardId,
+          status: TrainScheduleStatusEnum.Scheduled,
+        },
+      ],
+    });
+    const yards = new Set<string>();
+    for (const schedule of corridor) {
+      if (
+        schedule.scheduledDepartureDate == null ||
+        eatDay(schedule.scheduledDepartureDate) !== group.day
+      ) {
+        continue;
+      }
+      for (const yardId of await this.stopsForSchedule(schedule)) {
+        yards.add(yardId);
+      }
+    }
+    return [...yards];
+  }
+
+  /**
+   * Sweep bookings on a route-day whose operation request staff did NOT accept by
+   * the time the window's document-review phase ends. They never reached
+   * FULLY_EXECUTED, so they never enter the batch — expire them (customer must
+   * rebook a new window). No reservation and no invoice exists yet at this stage,
+   * so this is a lighter expiry than `expire()`: just flip status + notify, and
+   * best-effort close any payable if one was issued early. Government/export are
+   * excluded by the query.
+   */
+  async expireUnacceptedForRouteDay(group: RouteDayGroup): Promise<void> {
+    const corridorYards = await this.corridorYardsForRouteDay(group);
+    if (corridorYards.length === 0) return;
+    const unaccepted = await this.bookingsRepository.findUnacceptedForRouteDay(
+      corridorYards,
+      group.day,
+    );
+    for (const booking of unaccepted) {
+      await this.bookingsRepository.update(booking.id, {
+        status: "EXPIRED",
+        schedulingStatus: "ELIGIBLE",
+        // Free the shipment day so the customer can rebook a fresh window.
+        scheduledDate: null,
+      } as never);
+      // Close any payable issued before doc-review end (normally none — the invoice
+      // is created at ops-accept, which by definition has not happened here).
+      await this.billing
+        .expirePayable(Freight.InvoiceSource.Booking, booking.id, "PREPAID")
+        .catch(() => undefined);
+      this.notifier.expired(booking);
+      this.logger.log(
+        `Expired unaccepted booking ${booking.reference}:${booking.id} at doc-review end ` +
+          `(${group.originYardId}->${group.destinationYardId} ${group.day})`,
+      );
+    }
+  }
+
   /**
    * Free capacity for a government booking by displacing the lowest-priority commercial
    * bookings (reserved first, then allocated — including PAID). Displaced → EXPIRED + notified.
+   * Only victims whose legs overlap the government booking's leg actually free useful
+   * room, so others are skipped. Mutates `budget`; returns whether the need now fits.
    */
   private async preemptForGovernment(
     scheduleId: string,
     need: Capacity,
-    budget: Capacity,
+    leg: CorridorLeg,
+    budget: CorridorBudget,
     wagonLengths: WagonLengths,
-  ): Promise<Capacity> {
+  ): Promise<boolean> {
+    if (budget.fits(need, leg)) return true;
     const reservedCommercial = (
       await this.bookingsRepository.findReservedForSchedule(scheduleId)
     ).filter((b) => !b.isGovernment);
@@ -1643,9 +1840,16 @@ export class BookingBatchService implements OnModuleInit {
       (a, b) => (a.priorityScore ?? 0) - (b.priorityScore ?? 0),
     );
 
-    let freed = budget;
     for (const victim of candidates) {
-      if (this.fits(need, freed)) break;
+      if (budget.fits(need, leg)) break;
+      const victimLeg = budget.legForYards(
+        victim.originYardId,
+        victim.destinationYardId,
+      );
+      // Displacing a booking on a disjoint leg frees nothing the government
+      // booking can use — don't kill it for nothing.
+      const overlaps = victimLeg.fromEdge < leg.toEdge && leg.fromEdge < victimLeg.toEdge;
+      if (!overlaps) continue;
       await this.dataSource.transaction(async (manager) => {
         await this.trainScheduleBookingsRepository.deleteByScheduleAndBooking(
           scheduleId,
@@ -1668,9 +1872,9 @@ export class BookingBatchService implements OnModuleInit {
         );
       });
       this.notifier.displaced(victim);
-      freed = this.add(freed, this.needFor(victim, wagonLengths));
+      budget.add(this.needFor(victim, wagonLengths), victimLeg);
     }
-    return freed;
+    return budget.fits(need, leg);
   }
 
   // ---- capacity helpers -----------------------------------------------------
@@ -1778,22 +1982,6 @@ export class BookingBatchService implements OnModuleInit {
     );
   }
 
-  private subtract(budget: Capacity, need: Capacity): Capacity {
-    return {
-      wagons: budget.wagons - need.wagons,
-      weightTons: budget.weightTons - need.weightTons,
-      lengthMeters: budget.lengthMeters - need.lengthMeters,
-    };
-  }
-
-  private add(budget: Capacity, freed: Capacity): Capacity {
-    return {
-      wagons: budget.wagons + freed.wagons,
-      weightTons: budget.weightTons + freed.weightTons,
-      lengthMeters: budget.lengthMeters + freed.lengthMeters,
-    };
-  }
-
   /** Locomotive + wagon-type-derived caps (weight, length, wagon slots — not a fixed 53). */
   private async capacityLimits(
     locomotive: Locomotive,
@@ -1871,37 +2059,68 @@ export class BookingBatchService implements OnModuleInit {
       .findOne({ where: {} });
   }
 
-  /** Remaining capacity = hard caps minus what allocated + reserved bookings already use. */
-  private async remainingCapacity(
+  /**
+   * Ordered stop yards of the schedule's route (origin → milestones →
+   * destination); the legacy two-stop pseudo-route when milestones are absent.
+   */
+  private async stopsForSchedule(schedule: TrainSchedule): Promise<string[]> {
+    let milestoneYards: string[] | null = null;
+    if (schedule.routeId) {
+      const milestones = await this.dataSource
+        .getRepository(RouteMilestone)
+        .find({ where: { routeId: schedule.routeId }, order: { sequenceNo: 'ASC' } });
+      if (milestones.length >= 2) milestoneYards = milestones.map((m) => m.yardId);
+    }
+    return stopYardsFor(
+      milestoneYards,
+      schedule.originStationId,
+      schedule.destinationStationId,
+    );
+  }
+
+  /**
+   * Remaining capacity per corridor edge = hard caps minus what allocated +
+   * reserved bookings already use ON THEIR OWN LEGS. A booking riding only
+   * Dire→Djibouti leaves the Addis→Dire edges untouched.
+   */
+  private async remainingBudget(
     schedule: TrainSchedule,
     limits: Capacity,
     wagonLengths: WagonLengths,
-  ): Promise<Capacity> {
+  ): Promise<CorridorBudget> {
+    const stops = await this.stopsForSchedule(schedule);
+    const budget = new CorridorBudget(stops, limits);
     const allocated = (schedule.scheduleBookings ?? [])
       .map((sb) => sb.booking)
       .filter((b): b is Booking => Boolean(b));
     const reserved = await this.bookingsRepository.findReservedForSchedule(
       schedule.id,
     );
-    const used = [...allocated, ...reserved].reduce<Capacity>(
-      (acc, b) => this.add(acc, this.needFor(b, wagonLengths)),
-      { wagons: 0, weightTons: 0, lengthMeters: 0 },
-    );
-    return this.subtract(limits, used);
+    for (const b of [...allocated, ...reserved]) {
+      budget.subtract(
+        this.needFor(b, wagonLengths),
+        budget.legForYards(b.originYardId, b.destinationYardId),
+      );
+    }
+    return budget;
   }
 
-  /** maxWagons minus wagons already taken by allocated + reserved bookings. */
+  /**
+   * Wagon slots still boardable somewhere on the corridor (most-open edge).
+   * ≤ 0 means no leg can take another booking — the train-wide FULL signal.
+   */
   private async remainingWagons(schedule: TrainSchedule): Promise<number> {
-    const allocated = (schedule.scheduleBookings ?? [])
-      .map((sb) => sb.booking)
-      .filter((b): b is Booking => Boolean(b));
-    const reserved = await this.bookingsRepository.findReservedForSchedule(
-      schedule.id,
+    const wagonLengths = await this.loadWagonLengths();
+    const budget = await this.remainingBudget(
+      schedule,
+      {
+        wagons: schedule.maxWagons ?? 0,
+        weightTons: Number.POSITIVE_INFINITY,
+        lengthMeters: Number.POSITIVE_INFINITY,
+      },
+      wagonLengths,
     );
-    const used =
-      allocated.reduce((s, b) => s + this.wagonsFor(b), 0) +
-      reserved.reduce((s, b) => s + this.wagonsFor(b), 0);
-    return (schedule.maxWagons ?? 0) - used;
+    return budget.maxRemaining().wagons;
   }
 
   async setWindow(
diff --git a/apps/edr-freight-api/src/modules/train-scheduling/booking-journey.service.ts b/apps/edr-freight-api/src/modules/train-scheduling/booking-journey.service.ts
new file mode 100644
index 000000000..cdc58083c
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/train-scheduling/booking-journey.service.ts
@@ -0,0 +1,394 @@
+import {
+  BadRequestException,
+  Injectable,
+  Logger,
+  NotFoundException,
+  Optional,
+} from '@nestjs/common';
+import { InjectDataSource } from '@nestjs/typeorm';
+import { DataSource, EntityManager, In } from 'typeorm';
+import { Freight } from '@edr/types';
+
+import { Booking } from '../bookings/entities/booking.entity';
+import { ClearanceMilestoneService } from '../contracts/clearance-milestone.service';
+import { Yard } from '../rule-engine/entities/yard.entity';
+import { TrainSetWagon } from '../train-sets/entities/train-set-wagon.entity';
+import { TrainSchedule } from '../train-schedules/entities/train-schedule.entity';
+import { WagonBookingAllocation } from '../train-schedules/entities/wagon-booking-allocation.entity';
+import { Wagon } from '../wagons/entities/wagon.entity';
+import { WagonMovement } from '../wagons/entities/wagon-movement.entity';
+import { TrainCheckpointEvent } from './entities/train-checkpoint-event.entity';
+
+/**
+ * Per-booking journey along a train's corridor — for EVERY trade direction.
+ *
+ * A booking rides only its own origin→destination leg, so "dispatched" and
+ * "arrived" are per-booking facts confirmed by the yard operator, not train
+ * facts: load at the booking's origin yard (PAID → IN_TRANSIT, loadedAt) and
+ * unload at its destination yard (IN_TRANSIT → ARRIVED for import/export,
+ * → COMPLETED for intercity), possibly long before the train's final arrival.
+ * Both are gated on the train's latest recorded checkpoint being at that yard.
+ *
+ * Unloading also settles the physical wagons: each wagon that alights with the
+ * booking is released at that yard and the move is written to the
+ * wagon_movements ledger.
+ */
+@Injectable()
+export class BookingJourneyService {
+  private readonly logger = new Logger(BookingJourneyService.name);
+
+  constructor(
+    @InjectDataSource() private readonly dataSource: DataSource,
+    @Optional() private readonly milestoneService?: ClearanceMilestoneService,
+  ) {}
+
+  /** Statuses from which a booking may be loaded (gov bookings don't prepay). */
+  private canLoad(booking: Booking): boolean {
+    if (booking.status === 'PAID') return true;
+    return booking.isGovernment && booking.status === 'APPROVED';
+  }
+
+  async loadBooking(scheduleId: string, bookingId: string, userId?: string | null) {
+    const { schedule, booking } = await this.getScheduleBooking(scheduleId, bookingId);
+    if (booking.loadedAt || booking.status === 'IN_TRANSIT') {
+      throw new BadRequestException('Booking is already loaded');
+    }
+    if (!this.canLoad(booking)) {
+      throw new BadRequestException(
+        `Booking must be paid before loading (currently ${booking.status})`,
+      );
+    }
+    await this.assertTrainAtYard(schedule, booking.originYardId, 'origin');
+
+    const now = new Date();
+    await this.dataSource.transaction(async (manager) => {
+      await manager.getRepository(Booking).update(bookingId, {
+        status: 'IN_TRANSIT',
+        loadedAt: now,
+        loadedByUserId: userId ?? null,
+      } as never);
+      await this.setAllocationStatuses(manager, scheduleId, bookingId, 'LOADED');
+    });
+
+    // Customer tracking: cargo is on the train — loading milestones plus the
+    // direction's "departed" handoff. Doc-trigger path no-ops non-customs
+    // bookings (intercity) and already-completed codes.
+    void this.completeMilestones(booking, [
+      'CARGO_ARRIVED',
+      'READY_FOR_LOADING',
+      'LOADED',
+      ...(booking.tradeDirection === 'IMPORT'
+        ? ['DEPARTED_FROM_DJIBOUTI']
+        : booking.tradeDirection === 'EXPORT'
+          ? ['DEPARTED_TO_DJIBOUTI']
+          : []),
+    ]);
+
+    return { bookingId, status: 'IN_TRANSIT' as const, loadedAt: now.toISOString() };
+  }
+
+  async unloadBooking(scheduleId: string, bookingId: string, userId?: string | null) {
+    const { schedule, booking } = await this.getScheduleBooking(scheduleId, bookingId);
+    if (booking.status !== 'IN_TRANSIT') {
+      throw new BadRequestException(
+        `Booking must be loaded/in transit before unloading (currently ${booking.status})`,
+      );
+    }
+    await this.assertTrainAtYard(schedule, booking.destinationYardId, 'destination');
+
+    // Intercity has no clearance/delivery tail — unloading completes it. Import/
+    // export continue into clearance, keyed on the booking's own arrival.
+    const nextStatus = booking.tradeDirection === 'DOMESTIC' ? 'COMPLETED' : 'ARRIVED';
+    const now = new Date();
+    await this.dataSource.transaction(async (manager) => {
+      await manager.getRepository(Booking).update(bookingId, {
+        status: nextStatus,
+        arrivedAt: now,
+        arrivedByUserId: userId ?? null,
+      } as never);
+      await this.setAllocationStatuses(manager, scheduleId, bookingId, 'DEPARTED');
+      await this.settleWagonsOnUnload(manager, schedule, booking, now, userId ?? null);
+    });
+
+    // Customer tracking: THIS booking arrived (train may still be rolling).
+    void this.completeMilestones(booking, [
+      ...(booking.tradeDirection === 'IMPORT'
+        ? ['ARRIVED_ETHIOPIA']
+        : booking.tradeDirection === 'EXPORT'
+          ? ['ARRIVED_AT_DJIBOUTI']
+          : []),
+    ]);
+
+    return { bookingId, status: nextStatus, arrivedAt: now.toISOString() };
+  }
+
+  /**
+   * Per-yard operator worklist for a schedule: which bookings board / alight at
+   * each stop, with their journey state, so the yard operator at Dire sees
+   * exactly what to load and unload when the train is there.
+   */
+  async listYardWork(scheduleId: string) {
+    const schedule = await this.getSchedule(scheduleId);
+    const bookings = await this.dataSource
+      .getRepository(Booking)
+      .createQueryBuilder('booking')
+      .leftJoinAndSelect('booking.company', 'company')
+      .leftJoinAndSelect('booking.originYard', 'originYard')
+      .leftJoinAndSelect('booking.destinationYard', 'destinationYard')
+      .innerJoin(
+        'freight.train_schedule_bookings',
+        'tsb',
+        'tsb.booking_id = booking.id AND tsb.train_schedule_id = :scheduleId AND tsb.deleted_at IS NULL',
+        { scheduleId },
+      )
+      .getMany();
+
+    const latest = await this.latestCheckpoint(scheduleId);
+    const yardIds = [
+      ...new Set(
+        bookings.flatMap((b) => [b.originYardId, b.destinationYardId]).filter(Boolean),
+      ),
+    ];
+    const yards = yardIds.length
+      ? await this.dataSource.getRepository(Yard).find({ where: { id: In(yardIds) } })
+      : [];
+    const yardById = new Map(yards.map((y) => [y.id, y]));
+    const yardLabel = (id: string) =>
+      yardById.get(id)?.label ?? yardById.get(id)?.code ?? id;
+
+    const mapBooking = (b: Booking) => ({
+      id: b.id,
+      reference: b.reference,
+      status: b.status,
+      tradeDirection: b.tradeDirection,
+      isGovernment: b.isGovernment,
+      customer: b.company?.name ?? 'Unknown customer',
+      originYardId: b.originYardId,
+      destinationYardId: b.destinationYardId,
+      origin: yardLabel(b.originYardId),
+      destination: yardLabel(b.destinationYardId),
+      loadedAt: b.loadedAt?.toISOString() ?? null,
+      arrivedAt: b.arrivedAt?.toISOString() ?? null,
+      canLoad: !b.loadedAt && this.canLoad(b),
+      canUnload: b.status === 'IN_TRANSIT',
+    });
+
+    const byYard = new Map<
+      string,
+      { yardId: string; yard: string; toLoad: ReturnType<typeof mapBooking>[]; toUnload: ReturnType<typeof mapBooking>[] }
+    >();
+    const bucket = (yardId: string) => {
+      let entry = byYard.get(yardId);
+      if (!entry) {
+        entry = { yardId, yard: yardLabel(yardId), toLoad: [], toUnload: [] };
+        byYard.set(yardId, entry);
+      }
+      return entry;
+    };
+    for (const b of bookings) {
+      bucket(b.originYardId).toLoad.push(mapBooking(b));
+      bucket(b.destinationYardId).toUnload.push(mapBooking(b));
+    }
+
+    return {
+      scheduleId,
+      scheduleStatus: schedule.status,
+      trainAtYardId: latest?.yardId ?? (schedule.status === 'DISPATCHED' ? null : schedule.originStationId),
+      yards: [...byYard.values()],
+    };
+  }
+
+  /**
+   * Bulk fallback at the train's FINAL arrival: any booking destined for the
+   * final yard that operators didn't unload individually gets its per-booking
+   * arrival stamped now, so nothing stays stuck. Mid-corridor bookings are NOT
+   * touched — their arrival is their own unload. Returns the affected ids.
+   */
+  async autoArriveAtFinalYard(
+    manager: EntityManager,
+    schedule: TrainSchedule,
+    now: Date,
+  ): Promise<string[]> {
+    const rows: Array<{ id: string; trade_direction: string }> = await manager.query(
+      `UPDATE freight.bookings b
+          SET status = CASE WHEN b.trade_direction = 'DOMESTIC' THEN 'COMPLETED' ELSE 'ARRIVED' END,
+              scheduling_status = 'DISPATCHED',
+              arrived_at = COALESCE(b.arrived_at, $3),
+              loaded_at = COALESCE(b.loaded_at, b.created_at)
+         FROM freight.train_schedule_bookings tsb
+        WHERE tsb.booking_id = b.id
+          AND tsb.train_schedule_id = $1
+          AND tsb.deleted_at IS NULL
+          AND b.deleted_at IS NULL
+          AND b.destination_yard_id = $2
+          AND b.status NOT IN ('DRAFT', 'REJECTED', 'CANCELLED', 'COMPLETED', 'ARRIVED', 'DELIVERED')
+        RETURNING b.id, b.trade_direction`,
+      [schedule.id, schedule.destinationStationId, now],
+    );
+    return rows.map((r) => r.id);
+  }
+
+  // ---- helpers ---------------------------------------------------------------
+
+  private async getSchedule(scheduleId: string): Promise<TrainSchedule> {
+    const schedule = await this.dataSource
+      .getRepository(TrainSchedule)
+      .findOne({ where: { id: scheduleId } });
+    if (!schedule) {
+      throw new NotFoundException(`Train schedule ${scheduleId} not found`);
+    }
+    return schedule;
+  }
+
+  private async getScheduleBooking(scheduleId: string, bookingId: string) {
+    const schedule = await this.getSchedule(scheduleId);
+    const booking = await this.dataSource
+      .getRepository(Booking)
+      .findOne({ where: { id: bookingId } });
+    if (!booking) throw new NotFoundException(`Booking ${bookingId} not found`);
+    if (booking.trainScheduleId !== scheduleId) {
+      throw new BadRequestException('Booking is not assigned to this schedule');
+    }
+    return { schedule, booking };
+  }
+
+  private async latestCheckpoint(scheduleId: string): Promise<TrainCheckpointEvent | null> {
+    return this.dataSource.getRepository(TrainCheckpointEvent).findOne({
+      where: { trainScheduleId: scheduleId },
+      order: { occurredAt: 'DESC', createdAt: 'DESC' },
+    });
+  }
+
+  /**
+   * The train is "at" a yard when the latest recorded checkpoint is that yard,
+   * or — for a booking boarding at the train's own origin — when the train has
+   * not recorded any checkpoint yet (still sitting at its origin).
+   */
+  private async assertTrainAtYard(
+    schedule: TrainSchedule,
+    yardId: string,
+    side: 'origin' | 'destination',
+  ): Promise<void> {
+    const latest = await this.latestCheckpoint(schedule.id);
+    if (!latest) {
+      if (side === 'origin' && schedule.originStationId === yardId) return;
+      throw new BadRequestException(
+        'Train has not reached this yard yet — record its checkpoint first',
+      );
+    }
+    if (latest.yardId !== yardId) {
+      throw new BadRequestException(
+        `Train's last recorded position is not at the booking's ${side} yard`,
+      );
+    }
+  }
+
+  private async setAllocationStatuses(
+    manager: EntityManager,
+    scheduleId: string,
+    bookingId: string,
+    status: 'LOADED' | 'DEPARTED',
+  ): Promise<void> {
+    const allocations = await this.allocationsForBooking(manager, scheduleId, bookingId);
+    if (!allocations.length) return;
+    await manager
+      .getRepository(WagonBookingAllocation)
+      .update({ id: In(allocations.map((a) => a.id)) }, { status });
+  }
+
+  private async allocationsForBooking(
+    manager: EntityManager,
+    scheduleId: string,
+    bookingId: string,
+  ): Promise<Array<WagonBookingAllocation & { trainSetWagon?: TrainSetWagon }>> {
+    return manager
+      .getRepository(WagonBookingAllocation)
+      .createQueryBuilder('alloc')
+      .innerJoinAndSelect('alloc.trainSetWagon', 'slot')
+      .innerJoin(
+        'freight.train_schedules',
+        'schedule',
+        'schedule.train_set_id = slot.train_set_id AND schedule.id = :scheduleId',
+        { scheduleId },
+      )
+      .where('alloc.booking_id = :bookingId', { bookingId })
+      .getMany();
+  }
+
+  /**
+   * On unload: write the wagon_movements ledger rows (board yard → unload yard,
+   * kind LOADED) for the booking's pinned wagons, and release each wagon whose
+   * slot alights here — it detaches, stays at this yard, and becomes Available
+   * (dynamic consist). Wagons shared with a still-loaded consolidated partner
+   * stay pinned until the last booking on the slot unloads.
+   */
+  private async settleWagonsOnUnload(
+    manager: EntityManager,
+    schedule: TrainSchedule,
+    booking: Booking,
+    now: Date,
+    userId: string | null,
+  ): Promise<void> {
+    const allocations = await this.allocationsForBooking(manager, schedule.id, booking.id);
+    for (const alloc of allocations) {
+      const slot = alloc.trainSetWagon;
+      if (!slot?.physicalWagonId) continue;
+
+      const boardYardId = slot.boardYardId ?? schedule.originStationId;
+      await manager.getRepository(WagonMovement).save(
+        manager.getRepository(WagonMovement).create({
+          wagonId: slot.physicalWagonId,
+          fromYardId: boardYardId,
+          toYardId: booking.destinationYardId,
+          trainScheduleId: schedule.id,
+          bookingId: booking.id,
+          kind: Freight.WagonMovementKind.Loaded,
+          movedByUserId: userId,
+          occurredAt: now,
+        }),
+      );
+
+      // Detach only when this yard is where the slot's leg ends and no other
+      // booking on the wagon is still in transit.
+      const slotAlightYardId = slot.alightYardId ?? schedule.destinationStationId;
+      if (slotAlightYardId !== booking.destinationYardId) continue;
+      const siblings = await manager
+        .getRepository(WagonBookingAllocation)
+        .createQueryBuilder('alloc')
+        .innerJoin('alloc.booking', 'b')
+        .where('alloc.train_set_wagon_id = :slotId', { slotId: slot.id })
+        .andWhere('alloc.booking_id != :bookingId', { bookingId: booking.id })
+        .andWhere(`b.status = 'IN_TRANSIT'`)
+        .getCount();
+      if (siblings > 0) continue;
+
+      await manager.getRepository(TrainSetWagon).update(slot.id, { status: 'DEPARTED' });
+      const wagon = await manager
+        .getRepository(Wagon)
+        .findOne({ where: { id: slot.physicalWagonId } });
+      // Only settle a wagon still bound to this schedule (it may have been
+      // re-pinned elsewhere already).
+      if (wagon && wagon.currentTrainScheduleId === schedule.id) {
+        await manager.getRepository(Wagon).update(wagon.id, {
+          currentYardId: booking.destinationYardId,
+          currentTrainScheduleId: null,
+          trainSetWagonId: null,
+          status: Freight.WagonStatus.Available,
+        });
+      }
+    }
+  }
+
+  private async completeMilestones(booking: Booking, codes: string[]): Promise<void> {
+    if (!this.milestoneService || !codes.length) return;
+    for (const code of codes) {
+      try {
+        await this.milestoneService.completeByDocTrigger({ bookingId: booking.id }, code);
+      } catch (err) {
+        this.logger.warn(
+          `Milestone ${code} completion failed for booking ${booking.id}: ${(err as Error).message}`,
+        );
+      }
+    }
+  }
+}
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/booking-split.service.spec.ts b/apps/edr-freight-api/src/modules/train-scheduling/booking-split.service.spec.ts
new file mode 100644
index 000000000..6d706c423
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/train-scheduling/booking-split.service.spec.ts
@@ -0,0 +1,101 @@
+import { BookingSplitService } from './booking-split.service';
+import { Booking } from '../bookings/entities/booking.entity';
+import { BookingContainer } from '../bookings/entities/booking-container.entity';
+import { BookingContainerUnit } from '../bookings/entities/booking-container-unit.entity';
+import { Contract } from '../contracts/entities/contract.entity';
+import { BookingBatchOffer } from './entities/booking-batch-offer.entity';
+
+/**
+ * applySplit promotion behaviour: a ONE_TIME contract must be flipped to GENERAL
+ * (both the parent contract row and the booking's denormalized copy) so the split
+ * remainder can be rebooked. A GENERAL booking is left untouched.
+ */
+describe('BookingSplitService — applySplit ONE_TIME promotion', () => {
+  const bookingId = 'bk-1';
+  const contractId = 'ct-1';
+  const offerId = 'of-1';
+
+  const buildService = (bookingContractKind: 'ONE_TIME' | 'GENERAL') => {
+    const offer = {
+      id: offerId,
+      bookingId,
+      status: 'OFFERED',
+      offeredWagons: 3,
+      totalWagons: 5,
+      offeredWeightTons: 30,
+      offeredAmount: 300,
+      offeredPricingBreakdown: {},
+      offeredLines: null,
+    } as unknown as BookingBatchOffer;
+
+    const bookingRepo = {
+      update: jest.fn().mockResolvedValue(undefined),
+      findOne: jest.fn().mockResolvedValue({
+        id: bookingId,
+        contractId,
+        contractKind: bookingContractKind,
+      }),
+      find: jest.fn().mockResolvedValue([]),
+      softDelete: jest.fn().mockResolvedValue(undefined),
+    };
+    const contractRepo = { update: jest.fn().mockResolvedValue(undefined) };
+    const offerRepo = {
+      findOne: jest.fn().mockResolvedValue(offer),
+      update: jest.fn().mockResolvedValue(undefined),
+    };
+    const containerRepo = {
+      find: jest.fn().mockResolvedValue([]),
+      update: jest.fn(),
+      softDelete: jest.fn(),
+    };
+    const unitRepo = { find: jest.fn().mockResolvedValue([]), softDelete: jest.fn() };
+
+    const repoFor = (entity: unknown) => {
+      if (entity === Booking) return bookingRepo;
+      if (entity === Contract) return contractRepo;
+      if (entity === BookingBatchOffer) return offerRepo;
+      if (entity === BookingContainer) return containerRepo;
+      if (entity === BookingContainerUnit) return unitRepo;
+      return { find: jest.fn().mockResolvedValue([]), update: jest.fn() };
+    };
+
+    const dataSource = {
+      getRepository: jest.fn(repoFor),
+      transaction: jest.fn(async (fn: (m: unknown) => Promise<void>) => {
+        await fn({ getRepository: repoFor });
+      }),
+    };
+
+    const service = new BookingSplitService(
+      dataSource as never,
+      {} as never,
+      {} as never,
+      { expirePayable: jest.fn() } as never,
+      { payNowPartial: jest.fn() } as never,
+    );
+    return { service, bookingRepo, contractRepo };
+  };
+
+  it('promotes a ONE_TIME booking + parent contract to GENERAL', async () => {
+    const { service, bookingRepo, contractRepo } = buildService('ONE_TIME');
+
+    await service.applySplit(bookingId);
+
+    expect(bookingRepo.update).toHaveBeenCalledWith(
+      bookingId,
+      expect.objectContaining({ contractKind: 'GENERAL' }),
+    );
+    expect(contractRepo.update).toHaveBeenCalledWith(
+      contractId,
+      expect.objectContaining({ contractKind: 'GENERAL' }),
+    );
+  });
+
+  it('leaves a GENERAL booking untouched (no contract promotion)', async () => {
+    const { service, contractRepo } = buildService('GENERAL');
+
+    await service.applySplit(bookingId);
+
+    expect(contractRepo.update).not.toHaveBeenCalled();
+  });
+});
diff --git a/apps/edr-freight-api/src/modules/train-scheduling/booking-split.service.ts b/apps/edr-freight-api/src/modules/train-scheduling/booking-split.service.ts
index 2cd2df6d9..44886f116 100644
--- a/apps/edr-freight-api/src/modules/train-scheduling/booking-split.service.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/booking-split.service.ts
@@ -9,6 +9,7 @@ import { BillingService } from '../billing/billing.service';
 import { Booking } from '../bookings/entities/booking.entity';
 import { BookingContainer } from '../bookings/entities/booking-container.entity';
 import { BookingContainerUnit } from '../bookings/entities/booking-container-unit.entity';
+import { Contract } from '../contracts/entities/contract.entity';
 import {
   BookingBatchOffer,
   OfferedLine,
@@ -30,10 +31,11 @@ export interface SizedOffer {
  * pays, which is the act of accepting the split (applySplit). No payment →
  * offer expires and the booking stays whole.
  *
- * Only GENERAL-contract commercial bookings are offered partials: the remainder
+ * GENERAL and ONE_TIME commercial bookings are offered partials: the remainder
  * returns to the contract's quantity cap (derived live from booking_container
  * rows, so reducing the lines releases it automatically) and can be rebooked in
- * any later window within contract validity.
+ * any later window within contract validity. A ONE_TIME contract is promoted to
+ * GENERAL on split (see applySplit) so its remainder is actually rebookable.
  */
 @Injectable()
 export class BookingSplitService {
@@ -245,6 +247,25 @@ export class BookingSplitService {
         pricingBreakdown: offer.offeredPricingBreakdown,
       } as never);
 
+      // A ONE_TIME contract permits a single active booking, which would block the
+      // split remainder from ever being rebooked. Promote the parent contract (and
+      // the booking's denormalized copy) to GENERAL so the leftover quantity draws
+      // down against the cap like any general contract, within the same validity.
+      const booking = await manager.getRepository(Booking).findOne({
+        where: { id: bookingId },
+        select: { id: true, contractId: true, contractKind: true },
+      });
+      if (booking?.contractKind === 'ONE_TIME') {
+        await manager
+          .getRepository(Booking)
+          .update(bookingId, { contractKind: 'GENERAL' } as never);
+        if (booking.contractId) {
+          await manager
+            .getRepository(Contract)
+            .update(booking.contractId, { contractKind: 'GENERAL' } as never);
+        }
+      }
+
       await manager
         .getRepository(BookingBatchOffer)
         .update(offer.id, { status: 'APPLIED' });
diff --git a/apps/edr-freight-api/src/modules/train-scheduling/booking-window.service.spec.ts b/apps/edr-freight-api/src/modules/train-scheduling/booking-window.service.spec.ts
new file mode 100644
index 000000000..f96c388f8
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/train-scheduling/booking-window.service.spec.ts
@@ -0,0 +1,201 @@
+import { BookingWindowService } from './booking-window.service';
+import type { TrainSchedule } from '../train-schedules/entities/train-schedule.entity';
+
+/**
+ * Window state-machine tests: exercise the real advanceImport transitions and the
+ * concludeCycle reopen/done decision with mocked collaborators. Drives the exact
+ * production phase logic (PRE_WINDOW → OPEN → DOC_REVIEW → PAYMENT → conclude) and
+ * asserts the side effects the batch/settle/reopen flow depends on.
+ */
+describe('BookingWindowService — window state machine', () => {
+  const scheduleId = 'sched-1';
+
+  let service: BookingWindowService;
+  let batch: {
+    setWindow: jest.Mock;
+    processRouteDay: jest.Mock;
+    expireUnacceptedForRouteDay: jest.Mock;
+    settleDueReservations: jest.Mock;
+    isScheduleFull: jest.Mock;
+  };
+  let trainSchedulesRepository: { findById: jest.Mock; findAll: jest.Mock };
+  let trainSchedulingService: { finalizeSchedule: jest.Mock; getWindowConfig: jest.Mock };
+  let updateMock: jest.Mock;
+
+  const cfg = {
+    importWindowLeadDays: 3,
+    exportBookingLeadHours: 24,
+    windowOpenHour: 0, // 24h desk → reopen opens immediately
+    windowCloseHour: 0,
+    windowDurationHours: 1,
+    docReviewMinutes: 30,
+    paymentWindowMinutes: 60,
+    reopenDelayMinutes: 0,
+  };
+
+  const baseSchedule = (over: Partial<TrainSchedule>): TrainSchedule =>
+    ({
+      id: scheduleId,
+      direction: 'IMPORT',
+      originStationId: 'yard-o',
+      destinationStationId: 'yard-d',
+      scheduledDepartureDate: new Date('2026-08-01T06:00:00.000Z'),
+      bookingWindowStatus: 'CLOSED',
+      windowPhase: 'PRE_WINDOW',
+      bookingCycleNo: 0,
+      windowOpensAt: null,
+      windowClosesAt: null,
+      docReviewEndsAt: null,
+      docReviewCompletedAt: null,
+      paymentPhaseEndsAt: null,
+      ...over,
+    }) as unknown as TrainSchedule;
+
+  const advanceImport = (s: TrainSchedule, now: Date): Promise<boolean> =>
+    (service as unknown as {
+      advanceImport: (s: TrainSchedule, c: unknown, n: Date) => Promise<boolean>;
+    }).advanceImport(s, cfg, now);
+  const concludeCycle = (s: TrainSchedule, now: Date): Promise<void> =>
+    (service as unknown as {
+      concludeCycle: (s: TrainSchedule, c: unknown, n: Date) => Promise<void>;
+    }).concludeCycle(s, cfg, now);
+
+  beforeEach(() => {
+    updateMock = jest.fn().mockResolvedValue(undefined);
+    batch = {
+      setWindow: jest.fn().mockResolvedValue(undefined),
+      processRouteDay: jest.fn().mockResolvedValue(undefined),
+      expireUnacceptedForRouteDay: jest.fn().mockResolvedValue(undefined),
+      settleDueReservations: jest.fn().mockResolvedValue(undefined),
+      isScheduleFull: jest.fn().mockResolvedValue(false),
+    };
+    trainSchedulesRepository = {
+      findById: jest.fn().mockResolvedValue(null),
+      findAll: jest.fn().mockResolvedValue([]),
+    };
+    trainSchedulingService = {
+      finalizeSchedule: jest.fn().mockResolvedValue(undefined),
+      getWindowConfig: jest.fn().mockResolvedValue(cfg),
+    };
+
+    service = new BookingWindowService(
+      { getRepository: () => ({ update: updateMock }) } as never,
+      trainSchedulesRepository as never,
+      batch as never,
+      trainSchedulingService as never,
+      { directSend: jest.fn() } as never,
+      { notify: jest.fn() } as never,
+      { emitPhase: jest.fn() } as never,
+    );
+  });
+
+  it('PRE_WINDOW → OPEN at windowOpensAt (opens the customer window)', async () => {
+    const s = baseSchedule({
+      windowPhase: 'PRE_WINDOW',
+      windowOpensAt: new Date('2026-07-01T00:00:00.000Z'),
+    });
+    const advanced = await advanceImport(s, new Date('2026-07-01T00:00:01.000Z'));
+    expect(advanced).toBe(true);
+    expect(s.windowPhase).toBe('OPEN');
+    expect(s.bookingCycleNo).toBe(1);
+    expect(batch.setWindow).toHaveBeenCalledWith(scheduleId, 'OPEN');
+  });
+
+  it('OPEN → DOC_REVIEW at windowClosesAt (closes booking, sets doc-review deadline)', async () => {
+    const closesAt = new Date('2026-07-01T01:00:00.000Z');
+    const s = baseSchedule({
+      windowPhase: 'OPEN',
+      bookingWindowStatus: 'OPEN',
+      windowClosesAt: closesAt,
+    });
+    const advanced = await advanceImport(s, new Date('2026-07-01T01:00:01.000Z'));
+    expect(advanced).toBe(true);
+    expect(s.windowPhase).toBe('DOC_REVIEW');
+    expect(s.docReviewEndsAt).toEqual(new Date(closesAt.getTime() + 30 * 60_000));
+    expect(batch.setWindow).toHaveBeenCalledWith(scheduleId, 'CLOSED');
+  });
+
+  it('DOC_REVIEW → PAYMENT expires un-accepted, then runs the batch', async () => {
+    const s = baseSchedule({
+      windowPhase: 'DOC_REVIEW',
+      docReviewEndsAt: new Date('2026-07-01T01:30:00.000Z'),
+    });
+    const advanced = await advanceImport(s, new Date('2026-07-01T01:30:01.000Z'));
+    expect(advanced).toBe(true);
+    expect(s.windowPhase).toBe('PAYMENT');
+    expect(s.paymentPhaseEndsAt).not.toBeNull();
+    // Expiry sweep runs BEFORE the batch (unaccepted must not compete for capacity).
+    expect(batch.expireUnacceptedForRouteDay).toHaveBeenCalledTimes(1);
+    expect(batch.processRouteDay).toHaveBeenCalledTimes(1);
+    const expireOrder = batch.expireUnacceptedForRouteDay.mock.invocationCallOrder[0];
+    const batchOrder = batch.processRouteDay.mock.invocationCallOrder[0];
+    expect(expireOrder).toBeLessThan(batchOrder);
+  });
+
+  it('DOC_REVIEW → PAYMENT also fires when staff finished review early (docReviewCompletedAt)', async () => {
+    const s = baseSchedule({
+      windowPhase: 'DOC_REVIEW',
+      docReviewEndsAt: new Date('2026-07-01T05:00:00.000Z'), // far future
+      docReviewCompletedAt: new Date('2026-07-01T01:31:00.000Z'), // staff clicked done
+    });
+    const advanced = await advanceImport(s, new Date('2026-07-01T01:31:01.000Z'));
+    expect(advanced).toBe(true);
+    expect(s.windowPhase).toBe('PAYMENT');
+  });
+
+  it('PAYMENT → conclude at paymentPhaseEndsAt settles due reservations', async () => {
+    const s = baseSchedule({
+      windowPhase: 'PAYMENT',
+      paymentPhaseEndsAt: new Date('2026-07-01T02:30:00.000Z'),
+    });
+    const advanced = await advanceImport(s, new Date('2026-07-01T02:30:01.000Z'));
+    expect(advanced).toBe(true);
+    // settleDueReservations runs (allocate paid / expire unpaid, then top-up).
+    expect(batch.settleDueReservations).toHaveBeenCalledWith(scheduleId);
+  });
+
+  it('conclude: train FULL → window FULL + phase DONE + auto-finalize', async () => {
+    batch.isScheduleFull.mockResolvedValue(true);
+    const s = baseSchedule({ windowPhase: 'PAYMENT' });
+    await concludeCycle(s, new Date('2026-07-01T02:30:02.000Z'));
+    expect(batch.setWindow).toHaveBeenCalledWith(scheduleId, 'FULL');
+    expect(s.windowPhase).toBe('DONE');
+    expect(trainSchedulingService.finalizeSchedule).toHaveBeenCalledWith(scheduleId);
+  });
+
+  it('conclude: NOT full + a cycle fits before departure → REOPEN (back to PRE_WINDOW)', async () => {
+    batch.isScheduleFull.mockResolvedValue(false);
+    const s = baseSchedule({
+      windowPhase: 'PAYMENT',
+      // departure well in the future so nextCycleOpensAt returns a real time.
+      scheduledDepartureDate: new Date('2026-08-01T06:00:00.000Z'),
+    });
+    await concludeCycle(s, new Date('2026-07-01T02:30:03.000Z'));
+    expect(s.windowPhase).toBe('PRE_WINDOW');
+    expect(s.windowOpensAt).not.toBeNull();
+    expect(trainSchedulingService.finalizeSchedule).not.toHaveBeenCalled();
+  });
+
+  it('conclude: NOT full but NO cycle fits before departure → DONE', async () => {
+    batch.isScheduleFull.mockResolvedValue(false);
+    const s = baseSchedule({
+      windowPhase: 'PAYMENT',
+      // departure already passed → nextCycleOpensAt returns null → finish.
+      scheduledDepartureDate: new Date('2026-07-01T00:00:00.000Z'),
+    });
+    await concludeCycle(s, new Date('2026-07-01T02:30:04.000Z'));
+    expect(s.windowPhase).toBe('DONE');
+  });
+
+  it('no transition fires before its deadline (idempotent tick)', async () => {
+    const s = baseSchedule({
+      windowPhase: 'OPEN',
+      bookingWindowStatus: 'OPEN',
+      windowClosesAt: new Date('2026-07-01T10:00:00.000Z'), // future
+    });
+    const advanced = await advanceImport(s, new Date('2026-07-01T01:00:00.000Z'));
+    expect(advanced).toBe(false);
+    expect(s.windowPhase).toBe('OPEN');
+    expect(batch.setWindow).not.toHaveBeenCalled();
+  });
+});
diff --git a/apps/edr-freight-api/src/modules/train-scheduling/booking-window.service.ts b/apps/edr-freight-api/src/modules/train-scheduling/booking-window.service.ts
index 429a03a05..0f600d549 100644
--- a/apps/edr-freight-api/src/modules/train-scheduling/booking-window.service.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/booking-window.service.ts
@@ -263,14 +263,19 @@ export class BookingWindowService implements OnModuleInit {
     ) {
       const paymentPhaseEndsAt = new Date(now.getTime() + cfg.paymentWindowMinutes * 60_000);
       await this.setPhase(schedule, { windowPhase: 'PAYMENT', paymentPhaseEndsAt });
-      // Run the batch: priority fill over the route-day pool, reserving pay windows
-      // (or allocating government) — skipped automatically for everyone who fits
-      // is handled inside the fill (all fit → all reserved → all notified).
-      await this.bookingBatchService.processRouteDay({
+      const routeDay = {
         originYardId: schedule.originStationId,
         destinationYardId: schedule.destinationStationId,
         day: eatDay(schedule.scheduledDepartureDate),
-      });
+      };
+      // Doc review is over: bookings staff never accepted (still pending) can no
+      // longer make this train — expire them BEFORE the batch so they never
+      // compete for capacity and never reach the pool.
+      await this.bookingBatchService.expireUnacceptedForRouteDay(routeDay);
+      // Run the batch: priority fill over the route-day pool, reserving pay windows
+      // (or allocating government) — skipped automatically for everyone who fits
+      // is handled inside the fill (all fit → all reserved → all notified).
+      await this.bookingBatchService.processRouteDay(routeDay);
       this.logger.log(
         `Batch ran for schedule ${schedule.id}; payment phase until ${paymentPhaseEndsAt.toISOString()}`,
       );
diff --git a/apps/edr-freight-api/src/modules/train-scheduling/corridor-capacity.util.ts b/apps/edr-freight-api/src/modules/train-scheduling/corridor-capacity.util.ts
new file mode 100644
index 000000000..b16b25179
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/train-scheduling/corridor-capacity.util.ts
@@ -0,0 +1,148 @@
+/**
+ * Segment (leg) aware capacity accounting for corridor bookings.
+ *
+ * A train's route is an ordered list of stops; a booking occupies only the
+ * edges between its own origin and destination. Capacity (wagons / weight /
+ * length) is therefore tracked PER EDGE, not per train: two bookings whose
+ * legs don't overlap (Addis→Dire and Dire→Djibouti) consume the same wagon
+ * budget on disjoint edges and can share physical wagons.
+ *
+ * Legacy schedules without route milestones degrade to a single-edge corridor
+ * ([origin, destination]) where this is exactly the old train-wide math.
+ */
+
+export interface Capacity {
+  wagons: number;
+  weightTons: number;
+  lengthMeters: number;
+}
+
+/** Half-open edge span along the stop list: occupies edges [fromEdge, toEdge). */
+export interface CorridorLeg {
+  fromEdge: number;
+  toEdge: number;
+}
+
+export function addCapacity(a: Capacity, b: Capacity): Capacity {
+  return {
+    wagons: a.wagons + b.wagons,
+    weightTons: a.weightTons + b.weightTons,
+    lengthMeters: a.lengthMeters + b.lengthMeters,
+  };
+}
+
+export function subtractCapacity(a: Capacity, b: Capacity): Capacity {
+  return {
+    wagons: a.wagons - b.wagons,
+    weightTons: a.weightTons - b.weightTons,
+    lengthMeters: a.lengthMeters - b.lengthMeters,
+  };
+}
+
+export function capacityFits(need: Capacity, budget: Capacity): boolean {
+  return (
+    need.wagons <= budget.wagons &&
+    need.weightTons <= budget.weightTons &&
+    need.lengthMeters <= budget.lengthMeters
+  );
+}
+
+/**
+ * Ordered stop yard ids for a schedule. Route milestones (already ordered by
+ * sequence) when there are at least two; otherwise the schedule's own
+ * origin/destination pair — the legacy two-stop pseudo-route.
+ */
+export function stopYardsFor(
+  milestoneYardIdsInOrder: string[] | null | undefined,
+  originStationId: string,
+  destinationStationId: string,
+): string[] {
+  if (milestoneYardIdsInOrder && milestoneYardIdsInOrder.length >= 2) {
+    return milestoneYardIdsInOrder;
+  }
+  return [originStationId, destinationStationId];
+}
+
+/** Per-edge capacity budget along a schedule's stop list. */
+export class CorridorBudget {
+  private readonly edges: Capacity[];
+  private readonly stopIndex: Map<string, number>;
+
+  constructor(
+    readonly stops: string[],
+    initial: Capacity,
+  ) {
+    const edgeCount = Math.max(1, stops.length - 1);
+    this.edges = Array.from({ length: edgeCount }, () => ({ ...initial }));
+    this.stopIndex = new Map(stops.map((yardId, i) => [yardId, i]));
+  }
+
+  /** The leg between two stops, or null when they aren't on this corridor in order. */
+  legOf(originYardId: string, destinationYardId: string): CorridorLeg | null {
+    const from = this.stopIndex.get(originYardId);
+    const to = this.stopIndex.get(destinationYardId);
+    if (from == null || to == null || from >= to) return null;
+    return { fromEdge: from, toEdge: to };
+  }
+
+  /** Every edge — for whole-route consumers and unknown-leg fallbacks. */
+  fullLeg(): CorridorLeg {
+    return { fromEdge: 0, toEdge: this.edges.length };
+  }
+
+  /**
+   * The leg a booking occupies; bookings whose yards aren't on the corridor
+   * (legacy data drift) conservatively occupy the whole route so capacity is
+   * never double-booked against them.
+   */
+  legForYards(originYardId: string, destinationYardId: string): CorridorLeg {
+    return this.legOf(originYardId, destinationYardId) ?? this.fullLeg();
+  }
+
+  /** Remaining capacity usable by this leg = min across its edges. */
+  remainingFor(leg: CorridorLeg): Capacity {
+    let min = { ...this.edges[leg.fromEdge] };
+    for (let i = leg.fromEdge + 1; i < leg.toEdge; i++) {
+      const e = this.edges[i];
+      min = {
+        wagons: Math.min(min.wagons, e.wagons),
+        weightTons: Math.min(min.weightTons, e.weightTons),
+        lengthMeters: Math.min(min.lengthMeters, e.lengthMeters),
+      };
+    }
+    return min;
+  }
+
+  fits(need: Capacity, leg: CorridorLeg): boolean {
+    return capacityFits(need, this.remainingFor(leg));
+  }
+
+  subtract(need: Capacity, leg: CorridorLeg): void {
+    for (let i = leg.fromEdge; i < leg.toEdge; i++) {
+      this.edges[i] = subtractCapacity(this.edges[i], need);
+    }
+  }
+
+  add(freed: Capacity, leg: CorridorLeg): void {
+    for (let i = leg.fromEdge; i < leg.toEdge; i++) {
+      this.edges[i] = addCapacity(this.edges[i], freed);
+    }
+  }
+
+  /**
+   * The most open edge — when even this has no wagon slots left, nothing can
+   * board anywhere and the schedule's window is genuinely FULL. (A train can be
+   * full on one leg while another still has room, so train-wide FULL keys on
+   * the max, not the min.)
+   */
+  maxRemaining(): Capacity {
+    return this.edges.reduce(
+      (max, e) => ({
+        wagons: Math.max(max.wagons, e.wagons),
+        weightTons: Math.max(max.weightTons, e.weightTons),
+        lengthMeters: Math.max(max.lengthMeters, e.lengthMeters),
+      }),
+      { ...this.edges[0] },
+    );
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/train-scheduling/intercity.service.ts b/apps/edr-freight-api/src/modules/train-scheduling/intercity.service.ts
index 659eea456..bce4207d3 100644
--- a/apps/edr-freight-api/src/modules/train-scheduling/intercity.service.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/intercity.service.ts
@@ -10,8 +10,8 @@ import { DataSource } from 'typeorm';
 import { Booking } from '../bookings/entities/booking.entity';
 import { RouteMilestone } from '../routes/entities/route-milestone.entity';
 import { TrainSchedule } from '../train-schedules/entities/train-schedule.entity';
-import { BookingBatchService, type Capacity } from './booking-batch.service';
-import { TrainCheckpointEvent } from './entities/train-checkpoint-event.entity';
+import { BookingBatchService } from './booking-batch.service';
+import { BookingJourneyService } from './booking-journey.service';
 
 /**
  * Intercity (DOMESTIC) ride-along: intercity bookings never get their own
@@ -32,6 +32,7 @@ export class IntercityService {
   constructor(
     @InjectDataSource() private readonly dataSource: DataSource,
     private readonly bookingBatchService: BookingBatchService,
+    private readonly bookingJourneyService: BookingJourneyService,
   ) {}
 
   /**
@@ -52,13 +53,20 @@ export class IntercityService {
     return {
       scheduleId,
       routeId: schedule.routeId ?? null,
-      remaining: capacity?.budget ?? null,
+      // Segment-based: "remaining" is the most-open edge; each candidate's
+      // `fits` is judged against ITS OWN leg, so a booking on a free leg fits
+      // even when the train is full elsewhere.
+      remaining: capacity?.budget.maxRemaining() ?? null,
       candidates: waiting.map((booking) => {
         const need = capacity?.needFor(booking) ?? null;
+        const leg = capacity?.budget.legOf(
+          booking.originYardId,
+          booking.destinationYardId,
+        );
         return {
           ...this.mapBooking(booking),
           need,
-          fits: need && capacity ? fits(need, capacity.budget) : false,
+          fits: Boolean(need && capacity && leg && capacity.budget.fits(need, leg)),
         };
       }),
       accepted: accepted.map((booking) => ({
@@ -94,7 +102,7 @@ export class IntercityService {
 
     const accepted: string[] = [];
     const rejected: Array<{ bookingId: string; reason: string }> = [];
-    let budget = capacity.budget;
+    const budget = capacity.budget;
 
     for (const bookingId of bookingIds) {
       const booking = await this.dataSource
@@ -110,45 +118,35 @@ export class IntercityService {
         continue;
       }
       const need = capacity.needFor(booking);
-      if (!fits(need, budget)) {
+      const leg = budget.legOf(booking.originYardId, booking.destinationYardId);
+      // Segment-based: only the booking's own leg must have room, so an
+      // intercity booking still boards a train that is full on other legs.
+      if (!leg || !budget.fits(need, leg)) {
         rejected.push({
           bookingId,
-          reason: 'Does not fit the remaining wagon/weight/length capacity',
+          reason:
+            'Does not fit the remaining wagon/weight/length capacity on its leg',
         });
         continue;
       }
       await this.bookingBatchService.acceptIntercity(booking, scheduleId);
-      budget = subtract(budget, need);
+      budget.subtract(need, leg);
       accepted.push(bookingId);
       this.logger.log(
         `Intercity booking ${booking.reference ?? bookingId} accepted onto schedule ${scheduleId}`,
       );
     }
 
-    return { accepted, rejected, remaining: budget };
+    return { accepted, rejected, remaining: budget.maxRemaining() };
   }
 
   /**
-   * Mark an accepted intercity booking's cargo as loaded. Only allowed while
-   * the train is physically at the booking's origin yard: either it has not
-   * departed yet and the booking boards at the train's own origin, or the
-   * latest recorded checkpoint is at the booking's origin yard.
+   * Mark an accepted intercity booking's cargo as loaded. Delegates to the
+   * shared per-booking journey flow (same checkpoint gating as import/export).
    */
   async loadBooking(scheduleId: string, bookingId: string) {
-    const { schedule, booking } = await this.getAcceptedBooking(
-      scheduleId,
-      bookingId,
-    );
-    if (booking.status !== 'PAID') {
-      throw new BadRequestException(
-        `Booking must be paid before loading (currently ${booking.status})`,
-      );
-    }
-    await this.assertTrainAtYard(schedule, booking.originYardId, 'origin');
-    await this.dataSource
-      .getRepository(Booking)
-      .update(bookingId, { status: 'IN_TRANSIT' });
-    return { bookingId, status: 'IN_TRANSIT' as const };
+    await this.getAcceptedBooking(scheduleId, bookingId); // intercity-only guard
+    return this.bookingJourneyService.loadBooking(scheduleId, bookingId);
   }
 
   /**
@@ -156,20 +154,8 @@ export class IntercityService {
    * requires the latest checkpoint to be at that yard. Completes the booking.
    */
   async unloadBooking(scheduleId: string, bookingId: string) {
-    const { schedule, booking } = await this.getAcceptedBooking(
-      scheduleId,
-      bookingId,
-    );
-    if (booking.status !== 'IN_TRANSIT') {
-      throw new BadRequestException(
-        `Booking must be loaded/in transit before unloading (currently ${booking.status})`,
-      );
-    }
-    await this.assertTrainAtYard(schedule, booking.destinationYardId, 'destination');
-    await this.dataSource
-      .getRepository(Booking)
-      .update(bookingId, { status: 'COMPLETED' });
-    return { bookingId, status: 'COMPLETED' as const };
+    await this.getAcceptedBooking(scheduleId, bookingId); // intercity-only guard
+    return this.bookingJourneyService.unloadBooking(scheduleId, bookingId);
   }
 
   // ---- helpers ---------------------------------------------------------------
@@ -298,36 +284,6 @@ export class IntercityService {
     return { schedule, booking };
   }
 
-  /**
-   * The train is "at" a yard when the latest recorded checkpoint is that yard,
-   * or — for a booking boarding at the train's own origin — when the train has
-   * not recorded any checkpoint yet (still sitting at its origin).
-   */
-  private async assertTrainAtYard(
-    schedule: TrainSchedule,
-    yardId: string,
-    side: 'origin' | 'destination',
-  ): Promise<void> {
-    const latest = await this.dataSource
-      .getRepository(TrainCheckpointEvent)
-      .findOne({
-        where: { trainScheduleId: schedule.id },
-        order: { occurredAt: 'DESC', createdAt: 'DESC' },
-      });
-
-    if (!latest) {
-      if (side === 'origin' && schedule.originStationId === yardId) return;
-      throw new BadRequestException(
-        'Train has not reached this yard yet — record its checkpoint first',
-      );
-    }
-    if (latest.yardId !== yardId) {
-      throw new BadRequestException(
-        `Train's last recorded position is not at the booking's ${side} yard`,
-      );
-    }
-  }
-
   private mapBooking(booking: Booking) {
     return {
       id: booking.id,
@@ -350,18 +306,3 @@ export class IntercityService {
   }
 }
 
-function fits(need: Capacity, budget: Capacity): boolean {
-  return (
-    need.wagons <= budget.wagons &&
-    need.weightTons <= budget.weightTons &&
-    need.lengthMeters <= budget.lengthMeters
-  );
-}
-
-function subtract(budget: Capacity, need: Capacity): Capacity {
-  return {
-    wagons: budget.wagons - need.wagons,
-    weightTons: budget.weightTons - need.weightTons,
-    lengthMeters: budget.lengthMeters - need.lengthMeters,
-  };
-}
diff --git a/apps/edr-freight-api/src/modules/train-scheduling/train-scheduling.controller.ts b/apps/edr-freight-api/src/modules/train-scheduling/train-scheduling.controller.ts
index 1648bd957..7dba44f83 100644
--- a/apps/edr-freight-api/src/modules/train-scheduling/train-scheduling.controller.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/train-scheduling.controller.ts
@@ -47,6 +47,7 @@ import { UpdateScheduleWindowRuleDto } from "./dto/update-schedule-window-rule.d
 import { UpdateScheduleDateDto } from "./dto/update-schedule-date.dto";
 import { TrainSchedulingService } from "./train-scheduling.service";
 import { BookingBatchService } from "./booking-batch.service";
+import { BookingJourneyService } from "./booking-journey.service";
 import { BookingWindowService } from "./booking-window.service";
 import { IntercityService } from "./intercity.service";
 import { BillingService } from "../billing/billing.service";
@@ -60,6 +61,7 @@ export class TrainSchedulingController {
     private readonly bookingBatchService: BookingBatchService,
     private readonly bookingWindowService: BookingWindowService,
     private readonly intercityService: IntercityService,
+    private readonly bookingJourneyService: BookingJourneyService,
     private readonly billingService: BillingService,
   ) { }
 
@@ -432,6 +434,42 @@ export class TrainSchedulingController {
     return this.intercityService.acceptBookings(id, dto.bookingIds);
   }
 
+  @Get("schedules/:id/yard-work")
+  @TrainSchedulingView()
+  @ApiOperation({
+    summary:
+      "Per-yard operator worklist: which bookings board/alight at each stop, with journey state",
+  })
+  getYardWork(@Param("id", ParseUUIDPipe) id: string) {
+    return this.bookingJourneyService.listYardWork(id);
+  }
+
+  @Post("schedules/:id/bookings/:bookingId/load")
+  @TrainSchedulingManage()
+  @ApiOperation({
+    summary:
+      "Confirm a booking's cargo loaded at its origin yard (any direction; train must be at that yard)",
+  })
+  loadScheduleBooking(
+    @Param("id", ParseUUIDPipe) id: string,
+    @Param("bookingId", ParseUUIDPipe) bookingId: string,
+  ) {
+    return this.bookingJourneyService.loadBooking(id, bookingId);
+  }
+
+  @Post("schedules/:id/bookings/:bookingId/unload")
+  @TrainSchedulingManage()
+  @ApiOperation({
+    summary:
+      "Confirm a booking's cargo unloaded at its destination yard — per-booking arrival, may precede the train's final arrival",
+  })
+  unloadScheduleBooking(
+    @Param("id", ParseUUIDPipe) id: string,
+    @Param("bookingId", ParseUUIDPipe) bookingId: string,
+  ) {
+    return this.bookingJourneyService.unloadBooking(id, bookingId);
+  }
+
   @Post("schedules/:id/intercity/:bookingId/load")
   @TrainSchedulingManage()
   @ApiOperation({
diff --git a/apps/edr-freight-api/src/modules/train-scheduling/train-scheduling.module.ts b/apps/edr-freight-api/src/modules/train-scheduling/train-scheduling.module.ts
index 792fb7c64..1e1eb1695 100644
--- a/apps/edr-freight-api/src/modules/train-scheduling/train-scheduling.module.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/train-scheduling.module.ts
@@ -30,8 +30,10 @@ import { BookingWindowGateway } from './booking-window.gateway';
 import { BookingWindowService } from './booking-window.service';
 import { IntercityService } from './intercity.service';
 import { WsAuthService } from '../notification-inbox/ws-auth.service';
+import { BookingJourneyService } from './booking-journey.service';
 import { BookingSplitService } from './booking-split.service';
 import { BookingBatchOffer } from './entities/booking-batch-offer.entity';
+import { WagonMovement } from '../wagons/entities/wagon-movement.entity';
 import { NotificationsModule } from '../notifications/notifications.module';
 import { NotificationInboxModule } from '../notification-inbox/notification-inbox.module';
 import { ContractsModule } from '../contracts/contracts.module';
@@ -51,6 +53,7 @@ import { ContractsModule } from '../contracts/contracts.module';
       TrainCheckpointEvent,
       ImportDjiboutiOperation,
       BookingBatchOffer,
+      WagonMovement,
       // WsAuthService (booking-window gateway handshake) verifies IAM sessions.
       Session,
     ]),
@@ -77,6 +80,7 @@ import { ContractsModule } from '../contracts/contracts.module';
     BookingWindowService,
     BookingSplitService,
     IntercityService,
+    BookingJourneyService,
   ],
   exports: [
     TrainSchedulingService,
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 6aecd94a8..04a972ed7 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
@@ -155,6 +155,10 @@ describe('TrainSchedulingService', () => {
         htmlToPdfBuffer: jest.fn(),
       } as never,
       { emitPhase: jest.fn() } as never, // bookingWindowGateway
+      {
+        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 67eac7bd1..754a302d3 100644
--- a/apps/edr-freight-api/src/modules/train-scheduling/train-scheduling.service.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/train-scheduling.service.ts
@@ -4,6 +4,7 @@
   SchedulingStatus,
   TrainCheckpointKind,
   TrainScheduleStatus as TrainScheduleStatusEnum,
+  WagonMovementKind,
   WagonStatus,
 } from '@edr/types';
 import {
@@ -16,7 +17,7 @@ import {
 } from '@nestjs/common';
 import { ConfigService } from '@nestjs/config';
 import { InjectDataSource } from '@nestjs/typeorm';
-import { DataSource, EntityManager, In, IsNull, Not } from 'typeorm';
+import { DataSource, EntityManager, In, IsNull, Not, QueryFailedError } from 'typeorm';
 
 import { BookingsRepository } from '../bookings/bookings.repository';
 import { Booking } from '../bookings/entities/booking.entity';
@@ -27,6 +28,7 @@ import { Container } from '../container-management/entities/container.entity';
 import { Locomotive } from '../locomotives/entities/locomotive.entity';
 import { LocomotivesRepository } from '../locomotives/locomotives.repository';
 import { formatRouteLabel, Route } from '../routes/entities/route.entity';
+import { WagonMovement } from '../wagons/entities/wagon-movement.entity';
 import { TrainSetLocomotive } from '../train-sets/entities/train-set-locomotive.entity';
 import { TrainSetWagon } from '../train-sets/entities/train-set-wagon.entity';
 import { TrainSet } from '../train-sets/entities/train-set.entity';
@@ -70,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,
@@ -113,6 +116,7 @@ import {
   eatDay,
 } from './batch-window.util';
 import { TrainCheckpointEvent } from './entities/train-checkpoint-event.entity';
+import { BookingJourneyService } from './booking-journey.service';
 import { TrainCheckpointEventsRepository } from './train-checkpoint-events.repository';
 import { RecordCheckpointDto } from './dto/record-checkpoint.dto';
 import { RouteMilestone } from '../routes/entities/route-milestone.entity';
@@ -239,6 +243,7 @@ const DEFAULT_TRAIN_LIMITS: Required<TrainLimitConfig> = {
 /** Raw row shape for the booking-window queries (company- and contract-scoped). */
 interface BookingWindowRow {
   schedule_id: string;
+  reference: string | null;
   contract_id: string | null;
   contract_kind: string | null;
   direction: string | null;
@@ -276,10 +281,39 @@ export class TrainSchedulingService {
     private readonly warehouseInventoryService: WarehouseInventoryService,
     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,
@@ -290,15 +324,26 @@ export class TrainSchedulingService {
   private async completeMilestonesForScheduleBookings(
     scheduleId: string,
     codes: string[],
+    filter?: { originYardId?: string; destinationYardId?: string },
   ): Promise<void> {
     if (!this.milestoneService || codes.length === 0) return;
     try {
+      const conditions = ['tsb.train_schedule_id = $1', 'tsb.deleted_at IS NULL'];
+      const params: unknown[] = [scheduleId];
+      if (filter?.originYardId) {
+        params.push(filter.originYardId);
+        conditions.push(`b.origin_yard_id = $${params.length}`);
+      }
+      if (filter?.destinationYardId) {
+        params.push(filter.destinationYardId);
+        conditions.push(`b.destination_yard_id = $${params.length}`);
+      }
       const rows: Array<{ booking_id: string }> = await this.dataSource.query(
         `SELECT tsb.booking_id
            FROM freight.train_schedule_bookings tsb
-          WHERE tsb.train_schedule_id = $1
-            AND tsb.deleted_at IS NULL`,
-        [scheduleId],
+           JOIN freight.bookings b ON b.id = tsb.booking_id
+          WHERE ${conditions.join(' AND ')}`,
+        params,
       );
       for (const { booking_id } of rows) {
         for (const code of codes) {
@@ -806,20 +851,24 @@ export class TrainSchedulingService {
               ...ruleSnapshot,
               ...computeImportWindowTimes(departure, windowCfg, new Date()),
             };
-      const schedule = manager.getRepository(TrainSchedule).create({
-        trainSetId: trainSet.id,
-        routeId: route.id,
-        originStationId: route.originYardId,
-        destinationStationId: route.destinationYardId,
-        scheduledDepartureDate: departure,
-        status: TrainScheduleStatusEnum.Draft,
-        direction,
-        maxWagons: (
-          await this.resolveTrainLimitConfig(dto, limitLoco)
-        ).maxWagonsPerTrain,
-        ...windowFields,
-      });
-      const saved = await manager.getRepository(TrainSchedule).save(schedule);
+      const maxWagons = (await this.resolveTrainLimitConfig(dto, limitLoco))
+        .maxWagonsPerTrain;
+      // Retry past a concurrent insert that grabbed the same S-<year> sequence
+      // (the unique index rejects the loser; it re-reads the max and tries again).
+      const saved = await this.insertScheduleWithReference(manager, (reference) =>
+        manager.getRepository(TrainSchedule).create({
+          reference,
+          trainSetId: trainSet.id,
+          routeId: route.id,
+          originStationId: route.originYardId,
+          destinationStationId: route.destinationYardId,
+          scheduledDepartureDate: departure,
+          status: TrainScheduleStatusEnum.Draft,
+          direction,
+          maxWagons,
+          ...windowFields,
+        }),
+      );
       // Locomotives stay in their current status until dispatch — advance scheduling
       // must not block the locomotive from serving earlier trains.
       return saved.id;
@@ -1457,6 +1506,24 @@ export class TrainSchedulingService {
           manager,
         );
       }
+      // Per-booking journey fallback: bookings boarding at the TRAIN's origin
+      // that the operator didn't load individually are auto-loaded now — the
+      // train is leaving with them. Mid-corridor boarders stay PAID until the
+      // operator loads them at their own yard.
+      await manager.query(
+        `UPDATE freight.bookings b
+            SET status = 'IN_TRANSIT',
+                loaded_at = COALESCE(b.loaded_at, $3)
+           FROM freight.train_schedule_bookings tsb
+          WHERE tsb.booking_id = b.id
+            AND tsb.train_schedule_id = $1
+            AND tsb.deleted_at IS NULL
+            AND b.deleted_at IS NULL
+            AND b.origin_yard_id = $2
+            AND b.loaded_at IS NULL
+            AND (b.status = 'PAID' OR (b.is_government = true AND b.status = 'APPROVED'))`,
+        [scheduleId, schedule.originStationId, now],
+      );
       // Close the booking window; any still-pending (unallocated) reservations don't ride this train.
       await manager
         .getRepository(TrainSchedule)
@@ -1488,19 +1555,26 @@ export class TrainSchedulingService {
     // Dispatch closed the window — drop it from portal/GL cards right away.
     void this.emitWindowState(scheduleId);
     // Customer tracking: cargo is on the departing train — loading milestones
-    // plus the direction's "departed" handoff milestone.
+    // plus the direction's "departed" handoff milestone. Restricted to bookings
+    // that BOARD at the train's origin; mid-corridor boarders get their loading
+    // milestones from their own operator load at their own yard.
     if (schedule.direction === 'IMPORT' || schedule.direction === 'EXPORT') {
-      void this.completeMilestonesForScheduleBookings(scheduleId, [
-        // CARGO_ARRIVED is export-only (cargo reached the origin yard) — the
-        // doc-trigger path no-ops it for import bookings.
-        'CARGO_ARRIVED',
-        'READY_FOR_LOADING',
-        'LOADED',
-        schedule.direction === 'IMPORT'
-          ? 'DEPARTED_FROM_DJIBOUTI'
-          : 'DEPARTED_TO_DJIBOUTI',
-      ]);
+      void this.completeMilestonesForScheduleBookings(
+        scheduleId,
+        [
+          // CARGO_ARRIVED is export-only (cargo reached the origin yard) — the
+          // doc-trigger path no-ops it for import bookings.
+          'CARGO_ARRIVED',
+          'READY_FOR_LOADING',
+          'LOADED',
+          schedule.direction === 'IMPORT'
+            ? 'DEPARTED_FROM_DJIBOUTI'
+            : 'DEPARTED_TO_DJIBOUTI',
+        ],
+        { originYardId: schedule.originStationId },
+      );
     }
+    void this.notifyScheduleBookings(schedule, 'dispatched');
     return this.getTrainScheduleById(scheduleId);
   }
 
@@ -2426,18 +2500,11 @@ export class TrainSchedulingService {
         });
       }
 
-      await manager.query(
-        `UPDATE freight.bookings b
-            SET status = $2,
-                scheduling_status = $3
-           FROM freight.train_schedule_bookings tsb
-          WHERE tsb.booking_id = b.id
-            AND tsb.train_schedule_id = $1
-            AND tsb.deleted_at IS NULL
-            AND b.deleted_at IS NULL
-            AND b.status NOT IN ('DRAFT', 'REJECTED', 'CANCELLED', 'COMPLETED')`,
-        [scheduleId, 'IN_TRANSIT', SchedulingStatus.Dispatched],
-      );
+      // Per-booking journey: bookings destined for the FINAL yard that the
+      // operator didn't unload individually get their arrival stamped now as a
+      // bulk fallback. Mid-corridor bookings are NOT touched — their arrival is
+      // their own unload (possibly already done while the train kept rolling).
+      await this.bookingJourneyService.autoArriveAtFinalYard(manager, schedule, now);
 
       // Release every locomotive of the set (not just the legacy primary) and move it
       // to the destination yard where it physically arrived.
@@ -2455,12 +2522,33 @@ export class TrainSchedulingService {
           .getRepository(Wagon)
           .findOne({ where: { id: slot.physicalWagonId } });
         if (!wagon) continue;
+        // A wagon that already alighted mid-route (unload released it, possibly
+        // re-pinned elsewhere since) is no longer this schedule's to move.
+        if (wagon.currentTrainScheduleId !== scheduleId) continue;
+        // Dynamic consist: the wagon settles at its slot's alight yard, not
+        // blanket at the train's destination.
+        const settleYardId = slot.alightYardId ?? schedule.destinationStationId;
         await manager.getRepository(Wagon).update(wagon.id, {
           currentTrainScheduleId: null,
           trainSetWagonId: null,
           status: WagonStatus.Available,
-          currentYardId: schedule.destinationStationId,
+          currentYardId: settleYardId,
         });
+        // Ledger: the wagon rode this schedule to its settle yard.
+        const slotAllocations = slot.allocations ?? [];
+        await manager.getRepository(WagonMovement).save(
+          manager.getRepository(WagonMovement).create({
+            wagonId: wagon.id,
+            fromYardId: slot.boardYardId ?? schedule.originStationId,
+            toYardId: settleYardId,
+            trainScheduleId: scheduleId,
+            bookingId: slotAllocations[0]?.bookingId ?? null,
+            kind: slotAllocations.length
+              ? WagonMovementKind.Loaded
+              : WagonMovementKind.EmptyReposition,
+            occurredAt: now,
+          }),
+        );
       }
 
       // Ensure a destination checkpoint exists so the timeline shows ARRIVED.
@@ -2482,12 +2570,17 @@ export class TrainSchedulingService {
       }
     });
 
-    // Customer tracking: the train reached the corridor's far end.
+    // Customer tracking: the train reached the corridor's far end. Restricted
+    // to bookings destined for the FINAL yard — mid-corridor bookings get their
+    // arrival milestone from their own operator unload at their own yard.
     if (schedule.direction === 'IMPORT' || schedule.direction === 'EXPORT') {
-      void this.completeMilestonesForScheduleBookings(scheduleId, [
-        schedule.direction === 'IMPORT' ? 'ARRIVED_ETHIOPIA' : 'ARRIVED_AT_DJIBOUTI',
-      ]);
+      void this.completeMilestonesForScheduleBookings(
+        scheduleId,
+        [schedule.direction === 'IMPORT' ? 'ARRIVED_ETHIOPIA' : 'ARRIVED_AT_DJIBOUTI'],
+        { destinationYardId: schedule.destinationStationId },
+      );
     }
+    void this.notifyScheduleBookings(schedule, 'arrived');
 
     const detail = await this.getTrainScheduleById(scheduleId);
     const warehouseAutomation = await this.runWarehouseArrivalAutomation(scheduleId);
@@ -2503,7 +2596,8 @@ export class TrainSchedulingService {
         destinationStation: true,
         scheduleBookings: { booking: true },
       },
-      order: { scheduledDepartureDate: 'DESC', createdAt: 'DESC' },
+      // Newest-created first (the client can re-sort; this is the default order).
+      order: { createdAt: 'DESC', scheduledDepartureDate: 'DESC' },
     });
     return schedules.map((s) => this.mapScheduleListItem(s));
   }
@@ -2635,17 +2729,26 @@ export class TrainSchedulingService {
     }
 
     if (
-      bookings.some((b) => {
-        if (targetScheduleId && b.trainScheduleId === targetScheduleId) {
-          return false;
+      await (async () => {
+        // Corridor-aware: a booking belongs on this train when its origin and
+        // destination lie on the schedule's stop list in order — sub-corridor
+        // bookings (Dire→Djibouti on an Addis→…→Djibouti train) are valid.
+        let stops = [dto.originStationId, dto.destinationStationId];
+        if (targetScheduleId) {
+          const target = await this.trainSchedulesRepository.findById(targetScheduleId);
+          if (target) stops = await this.stopYardsForSchedule(target);
         }
-        return (
-          b.originYardId !== dto.originStationId ||
-          b.destinationYardId !== dto.destinationStationId
-        );
-      })
+        return bookings.some((b) => {
+          if (targetScheduleId && b.trainScheduleId === targetScheduleId) {
+            return false;
+          }
+          const fromIdx = stops.indexOf(b.originYardId);
+          const toIdx = stops.indexOf(b.destinationYardId);
+          return fromIdx < 0 || toIdx < 0 || fromIdx >= toIdx;
+        });
+      })()
     ) {
-      violations.push('Selected bookings must share the same origin and destination as the schedule');
+      violations.push('Selected bookings must lie on the schedule route (origin before destination)');
     }
 
     if (!forceAssign) {
@@ -2695,7 +2798,37 @@ export class TrainSchedulingService {
     }
 
     const originYardId = dto.originStationId;
-    const fleetCounts = await this.countFleetAvailability(originYardId, targetScheduleId);
+    // Dynamic consist: a slot's physical wagon may ride from the train's origin
+    // OR already sit at the booking's own boarding yard and attach there — so
+    // the usable fleet is the union across the origin and every boarding yard.
+    const boardYardIds = [
+      ...new Set(
+        [originYardId, ...bookings.map((b) => b.originYardId)].filter(Boolean),
+      ),
+    ];
+    const fleetCountsByYard = await Promise.all(
+      boardYardIds.map((yardId) =>
+        this.countFleetAvailability(yardId, targetScheduleId),
+      ),
+    );
+    const mergedFleet = new Map<string, { code: string; available: number }>();
+    for (const rows of fleetCountsByYard) {
+      for (const row of rows) {
+        const existing = mergedFleet.get(row.wagonTypeId) ?? {
+          code: row.wagonTypeCode,
+          available: 0,
+        };
+        existing.available += row.available;
+        mergedFleet.set(row.wagonTypeId, existing);
+      }
+    }
+    const fleetCounts = [...mergedFleet.entries()].map(
+      ([wagonTypeId, value]) => ({
+        wagonTypeId,
+        wagonTypeCode: value.code,
+        available: value.available,
+      }),
+    );
     const fleetByTypeId = new Map(fleetCounts.map((row) => [row.wagonTypeId, row.available]));
     fleetAvailability = computeFleetAvailability(
       demandPlan,
@@ -2720,6 +2853,12 @@ export class TrainSchedulingService {
       containerWagonType,
       bulkWagonType,
     });
+    this.stampSlotLegs(
+      wagonPlan,
+      fittingBookings,
+      dto.originStationId,
+      dto.destinationStationId,
+    );
 
     violations.push(
       ...(await this.validatePhysicalFleetForPlan(
@@ -3047,6 +3186,7 @@ export class TrainSchedulingService {
         wagonTypeId: slot.wagonTypeId,
         wagonTypeCode: typeCodeById.get(slot.wagonTypeId) ?? slot.wagonTypeId,
         trainSetWagonId: slot.id,
+        boardYardId: slot.boardYardId ?? null,
       }));
 
     const unpinnable = this.findUnpinnableWagonSlots(
@@ -3100,6 +3240,7 @@ export class TrainSchedulingService {
         sequenceNo: slot.sequenceNo,
         wagonTypeId: slot.wagonTypeId,
         wagonTypeCode: slot.wagonTypeCode,
+        boardYardId: slot.boardYardId ?? null,
       })),
       wagons,
       targetScheduleId,
@@ -3108,7 +3249,12 @@ export class TrainSchedulingService {
   }
 
   private findUnpinnableWagonSlots(
-    slots: Array<{ sequenceNo: number; wagonTypeId: string; wagonTypeCode: string }>,
+    slots: Array<{
+      sequenceNo: number;
+      wagonTypeId: string;
+      wagonTypeCode: string;
+      boardYardId?: string | null;
+    }>,
     wagons: Wagon[],
     scheduleId: string | undefined,
     originYardId: string,
@@ -3136,22 +3282,35 @@ export class TrainSchedulingService {
     return violations;
   }
 
+  /**
+   * Dynamic consist: a slot's wagon may either ride from the train's origin
+   * yard (attaching there, possibly empty until the slot's board yard) or
+   * already sit AT the slot's board yard and hook on when the train arrives.
+   */
   private pickPhysicalWagonForSlot(
-    slot: { wagonTypeId: string },
+    slot: { wagonTypeId: string; boardYardId?: string | null },
     wagons: Wagon[],
     scheduleId: string | undefined,
     originYardId: string,
     assignedPhysicalIds: Set<string>,
   ): Wagon | undefined {
-    return wagons.find((wagon) => {
+    const usable = (wagon: Wagon): boolean => {
       if (wagon.wagonTypeId !== slot.wagonTypeId) return false;
       if (assignedPhysicalIds.has(wagon.id)) return false;
       const pinnedOnSchedule = scheduleId
         ? wagon.currentTrainScheduleId === scheduleId
         : false;
-      if (wagon.status !== WagonStatus.Available && !pinnedOnSchedule) return false;
-      return wagon.currentYardId === originYardId;
-    });
+      return wagon.status === WagonStatus.Available || pinnedOnSchedule;
+    };
+    // Prefer a wagon already waiting at the slot's board yard (no empty haul);
+    // fall back to one riding from the train's origin.
+    if (slot.boardYardId) {
+      const atBoardYard = wagons.find(
+        (w) => usable(w) && w.currentYardId === slot.boardYardId,
+      );
+      if (atBoardYard) return atBoardYard;
+    }
+    return wagons.find((w) => usable(w) && w.currentYardId === originYardId);
   }
 
   private positiveNumber(value: number | undefined, fallback: number): number {
@@ -3303,6 +3462,42 @@ export class TrainSchedulingService {
     return containerType?.wagonType?.isActive ? containerType.wagonType : null;
   }
 
+  /**
+   * Stamp each plan slot with the leg it occupies (dynamic consist): the
+   * boarding/alighting yards of the bookings it carries. Null means the
+   * schedule's own endpoint (whole-route slot, legacy behavior). A slot
+   * carrying bookings with mixed corridors stays whole-route (conservative).
+   */
+  private stampSlotLegs(
+    wagonPlan: WagonPlanSlot[],
+    bookings: Booking[],
+    scheduleOriginYardId: string,
+    scheduleDestinationYardId: string,
+  ): void {
+    const bookingById = new Map(bookings.map((b) => [b.id, b]));
+    for (const slot of wagonPlan) {
+      const slotBookings = [
+        ...new Set(slot.allocations.map((a) => a.bookingId)),
+      ]
+        .map((id) => bookingById.get(id))
+        .filter((b): b is Booking => Boolean(b));
+      if (!slotBookings.length) continue;
+      const [first] = slotBookings;
+      const sameCorridor = slotBookings.every(
+        (b) =>
+          b.originYardId === first.originYardId &&
+          b.destinationYardId === first.destinationYardId,
+      );
+      if (!sameCorridor) continue;
+      slot.boardYardId =
+        first.originYardId === scheduleOriginYardId ? null : first.originYardId;
+      slot.alightYardId =
+        first.destinationYardId === scheduleDestinationYardId
+          ? null
+          : first.destinationYardId;
+    }
+  }
+
   private async persistTrainSetWagons(
     manager: EntityManager,
     trainSetId: string,
@@ -3318,6 +3513,8 @@ export class TrainSchedulingService {
         lengthMeters: slot.lengthMeters,
         assignedWeightTons: slot.assignedWeightTons,
         status: 'PLANNED',
+        boardYardId: slot.boardYardId ?? null,
+        alightYardId: slot.alightYardId ?? null,
       }),
     );
     return manager.getRepository(TrainSetWagon).save(wagons);
@@ -3625,9 +3822,41 @@ export class TrainSchedulingService {
     return null;
   }
 
+  /**
+   * Insert a schedule with a freshly generated S-<year>-NNNNN reference, retrying
+   * past a concurrent insert that grabbed the same sequence (the unique index
+   * rejects the loser). Mirrors insertWithGeneratedReference for bookings, but
+   * runs inside the caller's transaction manager so the row joins the same commit.
+   */
+  private async insertScheduleWithReference(
+    manager: EntityManager,
+    build: (reference: string) => TrainSchedule,
+  ): Promise<TrainSchedule> {
+    const year = new Date().getFullYear();
+    const repo = manager.getRepository(TrainSchedule);
+    for (let attempt = 0; attempt < 5; attempt += 1) {
+      const seq = await this.trainSchedulesRepository.maxReferenceSequence(year);
+      const reference = `S-${year}-${String(seq + 1).padStart(5, '0')}`;
+      try {
+        return await repo.save(build(reference));
+      } catch (err) {
+        // 23505 = unique_violation on ux_train_schedules_reference; re-read + retry.
+        const code = (err as { driverError?: { code?: string } })?.driverError?.code;
+        if (err instanceof QueryFailedError && code === '23505' && attempt < 4) {
+          continue;
+        }
+        throw err;
+      }
+    }
+    // Unreachable — the loop either returns or throws — but satisfies the compiler.
+    throw new ConflictException('Could not allocate a unique schedule reference');
+  }
+
   private mapScheduleListItem(schedule: import('../train-schedules/entities/train-schedule.entity').TrainSchedule) {
     return {
       id: schedule.id,
+      reference: schedule.reference ?? null,
+      createdAt: schedule.createdAt ?? null,
       scheduleDate: schedule.scheduledDepartureDate,
       trainNumber: schedule.trainNumber ?? null,
       routeName: schedule.route ? formatRouteLabel(schedule.route) : null,
@@ -3722,6 +3951,7 @@ export class TrainSchedulingService {
     const rows: Array<BookingWindowRow> = await this.dataSource.query(
       `SELECT DISTINCT ON (ts.id)
               ts.id AS schedule_id,
+              ts.reference AS reference,
               cr.contract_id AS contract_id,
               c.contract_kind AS contract_kind,
               ts.direction,
@@ -3752,14 +3982,16 @@ export class TrainSchedulingService {
           AND ts.window_phase IS NOT NULL
           AND ts.window_phase NOT IN ('DONE', 'CLOSED_FOR_DAY')
           AND ts.scheduled_departure_date >= now()
-        ORDER BY ts.id, c.id NULLS LAST, ts.window_opens_at ASC NULLS LAST`,
+        ORDER BY ts.id, c.id NULLS LAST, ts.scheduled_departure_date ASC NULLS LAST`,
       [companyId],
     );
+    // Nearest dispatch (departure) date first — the DISTINCT ON above forces a
+    // per-row ordering, so re-sort the mapped rows by departure for the client.
     return rows
       .map((r) => this.mapBookingWindowRow(r))
       .sort((a, b) => {
-        const ta = a.windowOpensAt ? new Date(a.windowOpensAt).getTime() : Infinity;
-        const tb = b.windowOpensAt ? new Date(b.windowOpensAt).getTime() : Infinity;
+        const ta = a.departureDate ? new Date(a.departureDate).getTime() : Infinity;
+        const tb = b.departureDate ? new Date(b.departureDate).getTime() : Infinity;
         return ta - tb;
       });
   }
@@ -3772,6 +4004,7 @@ export class TrainSchedulingService {
   async getBookingWindowsForContract(contractId: string) {
     const rows: Array<BookingWindowRow> = await this.dataSource.query(
       `SELECT DISTINCT ts.id AS schedule_id,
+              ts.reference AS reference,
               cr.contract_id AS contract_id,
               c.contract_kind AS contract_kind,
               ts.direction,
@@ -3801,7 +4034,7 @@ export class TrainSchedulingService {
           AND ts.window_phase IS NOT NULL
           AND ts.window_phase NOT IN ('DONE', 'CLOSED_FOR_DAY')
           AND ts.scheduled_departure_date >= now()
-        ORDER BY ts.window_opens_at ASC NULLS LAST`,
+        ORDER BY ts.scheduled_departure_date ASC NULLS LAST`,
       [contractId],
     );
     return rows.map((r) => this.mapBookingWindowRow(r));
@@ -3819,6 +4052,7 @@ export class TrainSchedulingService {
       }
     > = await this.dataSource.query(
       `SELECT ts.id AS schedule_id,
+              ts.reference AS reference,
               ts.train_number,
               ts.direction,
               ts.window_phase,
@@ -3839,7 +4073,7 @@ export class TrainSchedulingService {
           AND ts.window_phase IS NOT NULL
           AND ts.window_phase NOT IN ('DONE', 'CLOSED_FOR_DAY')
           AND ts.scheduled_departure_date >= now()
-        ORDER BY ts.window_opens_at ASC NULLS LAST`,
+        ORDER BY ts.scheduled_departure_date ASC NULLS LAST`,
     );
     return rows.map((r) => ({
       ...this.mapBookingWindowRow({
@@ -3854,6 +4088,7 @@ export class TrainSchedulingService {
   private mapBookingWindowRow(r: BookingWindowRow) {
     return {
       scheduleId: r.schedule_id,
+      reference: r.reference ?? null,
       contractId: r.contract_id,
       contractKind: r.contract_kind,
       direction: r.direction,
@@ -4012,26 +4247,44 @@ export class TrainSchedulingService {
 
     // How many wagons of that type the cargo needs.
     const slotsNeeded = this.wagonsNeededForCargo(input, requiredType);
+    void slotsNeeded; // TEMP: unused while the wagon-availability filter is off.
 
-    // AVAILABLE wagons of the required type, counted once per origin yard.
-    const availableByYard = new Map<string, number>();
-    const availableAt = async (yardId: string): Promise<number> => {
-      const cached = availableByYard.get(yardId);
-      if (cached !== undefined) return cached;
-      const counts = await this.countFleetAvailability(yardId);
-      const n =
-        counts.find((c) => c.wagonTypeId === requiredType.id)?.available ?? 0;
-      availableByYard.set(yardId, n);
-      return n;
-    };
+    // TEMP (per request): wagon-availability filtering is DISABLED. A day is now
+    // offered whenever a bookable schedule that day has remaining train capacity
+    // — regardless of whether matching wagons are actually available at the
+    // origin / boarding yard. This surfaces days even when no wagon is on hand.
+    // Restore the block below to bring back the "enough matching wagons" gate.
+    //
+    // // AVAILABLE wagons of the required type, counted once per origin yard.
+    // const availableByYard = new Map<string, number>();
+    // const availableAt = async (yardId: string): Promise<number> => {
+    //   const cached = availableByYard.get(yardId);
+    //   if (cached !== undefined) return cached;
+    //   const counts = await this.countFleetAvailability(yardId);
+    //   const n =
+    //     counts.find((c) => c.wagonTypeId === requiredType.id)?.available ?? 0;
+    //   availableByYard.set(yardId, n);
+    //   return n;
+    // };
 
     const days = new Set<string>();
     for (const s of schedules) {
       const hasCapacity =
         Math.max(0, (s.maxWagons ?? 0) - (s.trainSet?.wagonCount ?? 0)) > 0;
       if (!hasCapacity) continue;
-      const enoughWagons = (await availableAt(s.originStationId)) >= slotsNeeded;
-      if (!enoughWagons) continue;
+      // TEMP (per request): wagon-availability check commented out — see note
+      // above. Dynamic consist: wagons may ride from the train's origin OR
+      // already sit at the booking's own boarding yard and attach when the train
+      // arrives — either pool can serve a sub-corridor booking.
+      // let enoughWagons = (await availableAt(s.originStationId)) >= slotsNeeded;
+      // if (
+      //   !enoughWagons &&
+      //   input.originYardId &&
+      //   input.originYardId !== s.originStationId
+      // ) {
+      //   enoughWagons = (await availableAt(input.originYardId)) >= slotsNeeded;
+      // }
+      // if (!enoughWagons) continue;
       if (s.scheduledDepartureDate)
         days.add(eatDay(new Date(s.scheduledDepartureDate)));
     }
@@ -4063,6 +4316,33 @@ export class TrainSchedulingService {
     return Math.max(1, Math.ceil(teu / 2));
   }
 
+  /**
+   * Ordered stop yards of a schedule's route: origin → milestones → destination,
+   * de-duplicated. Falls back to the two-endpoint pseudo-route when the schedule
+   * has no route milestones. Shared by corridor (sub-leg) validation everywhere.
+   */
+  async stopYardsForSchedule(schedule: TrainSchedule): Promise<string[]> {
+    let milestoneYards: string[] = [];
+    if (schedule.route?.milestones?.length) {
+      milestoneYards = [...schedule.route.milestones]
+        .sort((a, b) => a.sequenceNo - b.sequenceNo)
+        .map((m) => m.yardId);
+    } else if (schedule.routeId) {
+      const milestones = await this.dataSource
+        .getRepository(RouteMilestone)
+        .find({ where: { routeId: schedule.routeId }, order: { sequenceNo: 'ASC' } });
+      milestoneYards = milestones.map((m) => m.yardId);
+    }
+    const raw = milestoneYards.length >= 2
+      ? milestoneYards
+      : [schedule.originStationId, ...milestoneYards, schedule.destinationStationId];
+    const unique: string[] = [];
+    for (const yardId of raw) {
+      if (yardId && !unique.includes(yardId)) unique.push(yardId);
+    }
+    return unique;
+  }
+
   /** Whether a route has ≥1 OPEN bookable departure on a given EAT day. */
   async existsOpenScheduleOnRouteDay(
     originYardId: string,
@@ -4170,6 +4450,7 @@ export class TrainSchedulingService {
 
     return {
       id: schedule.id,
+      reference: schedule.reference ?? null,
       status: schedule.status,
       freightType: this.resolveScheduleFreightType(schedule),
       trainNumber: schedule.trainNumber ?? null,
diff --git a/apps/edr-freight-api/src/modules/train-scheduling/wagon-plan.util.ts b/apps/edr-freight-api/src/modules/train-scheduling/wagon-plan.util.ts
index 35d5ce185..21dd7b985 100644
--- a/apps/edr-freight-api/src/modules/train-scheduling/wagon-plan.util.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/wagon-plan.util.ts
@@ -38,6 +38,13 @@ export type WagonPlanSlot = {
   assignedWeightTons: number;
   allocations: WagonAllocationRecord[];
   slotLoadType?: SlotLoadType;
+  /**
+   * Leg occupancy for sub-corridor bookings (dynamic consist): the slot boards
+   * at boardYardId and alights at alightYardId. Null = the schedule's own
+   * endpoint (whole-route slot, legacy behavior).
+   */
+  boardYardId?: string | null;
+  alightYardId?: string | null;
 };
 
 export type ContainerUnitRow = {
diff --git a/apps/edr-freight-api/src/modules/train-sets/entities/train-set-wagon.entity.ts b/apps/edr-freight-api/src/modules/train-sets/entities/train-set-wagon.entity.ts
index a220218e0..5deedb12d 100644
--- a/apps/edr-freight-api/src/modules/train-sets/entities/train-set-wagon.entity.ts
+++ b/apps/edr-freight-api/src/modules/train-sets/entities/train-set-wagon.entity.ts
@@ -55,6 +55,17 @@ export class TrainSetWagon extends BaseEntity {
   @Column({ name: 'status', type: 'varchar', length: 20, default: 'PLANNED' })
   status!: string;
 
+  // ── Leg occupancy (segment corridor bookings) ──────────────────────────────
+  // A slot may occupy only part of the route: it boards (attaches/loads) at
+  // board_yard_id and alights (unloads/detaches) at alight_yard_id. NULL on both
+  // means the slot rides the whole route (legacy full-route bookings). Slots
+  // whose legs don't overlap coexist without consuming each other's capacity.
+  @Column({ name: 'board_yard_id', type: 'uuid', nullable: true })
+  boardYardId?: string | null;
+
+  @Column({ name: 'alight_yard_id', type: 'uuid', nullable: true })
+  alightYardId?: string | null;
+
   @OneToMany(() => WagonBookingAllocation, (allocation) => allocation.trainSetWagon)
   allocations?: WagonBookingAllocation[];
 }
diff --git a/apps/edr-freight-api/src/modules/vehicles/dto/create-vehicle.dto.ts b/apps/edr-freight-api/src/modules/vehicles/dto/create-vehicle.dto.ts
index 9158ecca0..33d441ecb 100644
--- a/apps/edr-freight-api/src/modules/vehicles/dto/create-vehicle.dto.ts
+++ b/apps/edr-freight-api/src/modules/vehicles/dto/create-vehicle.dto.ts
@@ -65,4 +65,12 @@ export class CreateVehicleDto {
   @IsOptional()
   @IsUUID()
   locationId?: string;
+
+  @IsOptional()
+  @IsNumber()
+  pricePerKm?: number;
+
+  @IsOptional()
+  @IsString()
+  currency?: string;
 }
diff --git a/apps/edr-freight-api/src/modules/vehicles/entities/vehicle.entity.ts b/apps/edr-freight-api/src/modules/vehicles/entities/vehicle.entity.ts
index 416cddee6..534019bc4 100644
--- a/apps/edr-freight-api/src/modules/vehicles/entities/vehicle.entity.ts
+++ b/apps/edr-freight-api/src/modules/vehicles/entities/vehicle.entity.ts
@@ -88,4 +88,29 @@ export class Vehicle extends BaseEntity {
 
   @Column({ name: 'location_id', type: 'uuid', nullable: true })
   locationId?: string;
+
+  // --- Haulage pricing ---
+  @Column({ name: 'price_per_km', type: 'numeric', precision: 14, scale: 2, nullable: true })
+  pricePerKm?: number;
+
+  /** Currency for pricePerKm: ETB | USD */
+  @Column({ name: 'currency', type: 'varchar', length: 8, default: 'ETB' })
+  currency?: string;
+
+  // --- Compliance / expiry tracking ---
+  @Column({ name: 'vin', type: 'varchar', nullable: true })
+  vin?: string;
+
+  /** Owned | Leased | Rented */
+  @Column({ name: 'ownership', type: 'varchar', nullable: true })
+  ownership?: string;
+
+  @Column({ name: 'insurance_expiry', type: 'date', nullable: true })
+  insuranceExpiry?: string;
+
+  @Column({ name: 'registration_expiry', type: 'date', nullable: true })
+  registrationExpiry?: string;
+
+  @Column({ name: 'next_inspection_date', type: 'date', nullable: true })
+  nextInspectionDate?: string;
 }
diff --git a/apps/edr-freight-api/src/modules/vehicles/vehicles.controller.ts b/apps/edr-freight-api/src/modules/vehicles/vehicles.controller.ts
index f0a77791a..737574dd9 100644
--- a/apps/edr-freight-api/src/modules/vehicles/vehicles.controller.ts
+++ b/apps/edr-freight-api/src/modules/vehicles/vehicles.controller.ts
@@ -10,7 +10,8 @@ import {
   ParseUUIDPipe,
 } 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 { VehiclesService } from './vehicles.service';
 import { CreateVehicleDto } from './dto/create-vehicle.dto';
 import { UpdateVehicleDto } from './dto/update-vehicle.dto';
@@ -19,7 +20,7 @@ import { FleetHistoryService } from '../fleet-history/fleet-history.service';
 @ApiTags('vehicles')
 @ApiBearerAuth()
 @Controller('vehicles')
-@FleetView()
+@BookingStaff(FREIGHT_PERMS.vehicles.view)
 export class VehiclesController {
   constructor(
     private readonly vehiclesService: VehiclesService,
@@ -27,7 +28,7 @@ export class VehiclesController {
   ) {}
 
   @Post()
-  @FleetManage()
+  @BookingStaff(FREIGHT_PERMS.vehicles.create)
   @ApiOperation({ summary: 'Create a new vehicle' })
   create(@Body() createVehicleDto: CreateVehicleDto) {
     return this.vehiclesService.create(createVehicleDto);
@@ -68,7 +69,7 @@ export class VehiclesController {
   }
 
   @Patch(':id')
-  @FleetManage()
+  @BookingStaff(FREIGHT_PERMS.vehicles.update)
   @ApiOperation({ summary: 'Update a vehicle' })
   update(
     @Param('id', ParseUUIDPipe) id: string,
@@ -78,7 +79,7 @@ export class VehiclesController {
   }
 
   @Delete(':id')
-  @FleetManage()
+  @BookingStaff(FREIGHT_PERMS.vehicles.delete)
   @ApiOperation({ summary: 'Delete a vehicle' })
   remove(@Param('id', ParseUUIDPipe) id: string) {
     return this.vehiclesService.remove(id);
diff --git a/apps/edr-freight-api/src/modules/wagons/entities/wagon-movement.entity.ts b/apps/edr-freight-api/src/modules/wagons/entities/wagon-movement.entity.ts
new file mode 100644
index 000000000..7c5ed092c
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/wagons/entities/wagon-movement.entity.ts
@@ -0,0 +1,59 @@
+import { BaseEntity } from '@edr/api-common';
+import { WagonMovementKind } from '@edr/types';
+import { Column, Entity, Index, JoinColumn, ManyToOne } from 'typeorm';
+
+import { Yard } from '../../rule-engine/entities/yard.entity';
+import { Wagon } from './wagon.entity';
+
+/**
+ * Ledger of every physical wagon relocation between yards — one row per move.
+ * Written when a wagon carries a booking's leg (LOADED), rides a train empty to
+ * reposition (EMPTY_REPOSITION), or staff manually correct its yard (MANUAL).
+ * `wagons.current_yard_id` is the derived "where is it now"; this table is the
+ * auditable history of how it got there and by whom.
+ */
+@Entity({ schema: 'freight', name: 'wagon_movements' })
+@Index(['wagonId', 'occurredAt'])
+export class WagonMovement extends BaseEntity {
+  @Column({ name: 'wagon_id', type: 'uuid' })
+  wagonId!: string;
+
+  @ManyToOne(() => Wagon, { onDelete: 'CASCADE' })
+  @JoinColumn({ name: 'wagon_id' })
+  wagon?: Wagon;
+
+  /** Null when the prior location is unknown (e.g. first manual registration). */
+  @Column({ name: 'from_yard_id', type: 'uuid', nullable: true })
+  fromYardId?: string | null;
+
+  @ManyToOne(() => Yard, { nullable: true })
+  @JoinColumn({ name: 'from_yard_id' })
+  fromYard?: Yard | null;
+
+  @Column({ name: 'to_yard_id', type: 'uuid' })
+  toYardId!: string;
+
+  @ManyToOne(() => Yard)
+  @JoinColumn({ name: 'to_yard_id' })
+  toYard?: Yard | null;
+
+  /** Set when the move happened by riding a scheduled train (LOADED / EMPTY_REPOSITION). */
+  @Column({ name: 'train_schedule_id', type: 'uuid', nullable: true })
+  trainScheduleId?: string | null;
+
+  /** Set when the move carried a specific booking's cargo (kind LOADED). */
+  @Column({ name: 'booking_id', type: 'uuid', nullable: true })
+  bookingId?: string | null;
+
+  @Column({ name: 'kind', type: 'varchar', length: 30 })
+  kind!: WagonMovementKind;
+
+  @Column({ name: 'moved_by_user_id', type: 'uuid', nullable: true })
+  movedByUserId?: string | null;
+
+  @Column({ name: 'occurred_at', type: 'timestamptz' })
+  occurredAt!: Date;
+
+  @Column({ name: 'note', type: 'text', nullable: true })
+  note?: string | null;
+}
diff --git a/apps/edr-freight-api/src/modules/wagons/wagons.controller.ts b/apps/edr-freight-api/src/modules/wagons/wagons.controller.ts
index ec98a4a4b..1d5287dba 100644
--- a/apps/edr-freight-api/src/modules/wagons/wagons.controller.ts
+++ b/apps/edr-freight-api/src/modules/wagons/wagons.controller.ts
@@ -43,6 +43,14 @@ export class WagonsController {
     return this.wagonsService.findById(id);
   }
 
+  @Get(':id/movements')
+  @ApiOperation({
+    summary: "Wagon movement ledger (loaded legs, empty repositions, manual moves), newest first",
+  })
+  listMovements(@Param('id', ParseUUIDPipe) id: string) {
+    return this.wagonsService.listMovements(id);
+  }
+
   @Patch(':id')
   @FleetManage()
   @ApiOperation({ summary: 'Update a wagon' })
diff --git a/apps/edr-freight-api/src/modules/wagons/wagons.service.ts b/apps/edr-freight-api/src/modules/wagons/wagons.service.ts
index ac10a2ef3..9d1f1b41f 100644
--- a/apps/edr-freight-api/src/modules/wagons/wagons.service.ts
+++ b/apps/edr-freight-api/src/modules/wagons/wagons.service.ts
@@ -1,4 +1,4 @@
-import { WagonStatus } from '@edr/types';
+import { WagonMovementKind, WagonStatus } from '@edr/types';
 import { Injectable, NotFoundException, ConflictException } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
 import { Repository, DataSource, FindOptionsOrder, FindOptionsWhere, ILike } from 'typeorm';
@@ -8,6 +8,7 @@ import { UpdateWagonDto } from './dto/update-wagon.dto';
 import { AssignWagonToTrainDto } from './dto/assign-wagon-to-train.dto';
 import { ReorderWagonsDto } from './dto/reorder-wagons.dto';
 import { Wagon } from './entities/wagon.entity';
+import { WagonMovement } from './entities/wagon-movement.entity';
 import { Train } from '../trains/entities/train.entity';
 
 @Injectable()
@@ -74,8 +75,9 @@ export class WagonsService {
     return wagon;
   }
 
-  async update(id: string, dto: UpdateWagonDto): Promise<Wagon> {
+  async update(id: string, dto: UpdateWagonDto, userId?: string | null): Promise<Wagon> {
     const wagon = await this.findById(id);
+    const previousYardId = wagon.currentYardId ?? null;
     Object.assign(wagon, dto);
     // `findById` eager-loads `currentYard`; when the DTO changes the scalar FK
     // TypeORM otherwise re-derives `current_yard_id` from the STALE relation
@@ -85,11 +87,40 @@ export class WagonsService {
       wagon.currentYard = null;
     }
     await this.wagonRepo.save(wagon);
+    // Staff manually relocated the wagon — write the movement ledger row so the
+    // wagon's yard history stays auditable (who moved it, from where, when).
+    if (
+      dto.currentYardId !== undefined &&
+      dto.currentYardId !== null &&
+      dto.currentYardId !== previousYardId
+    ) {
+      const movementRepo = this.dataSource.getRepository(WagonMovement);
+      await movementRepo.save(
+        movementRepo.create({
+          wagonId: id,
+          fromYardId: previousYardId,
+          toYardId: dto.currentYardId,
+          kind: WagonMovementKind.Manual,
+          movedByUserId: userId ?? null,
+          occurredAt: new Date(),
+        }),
+      );
+    }
     // Re-read with the relation so the response reflects the new yard label
     // instead of the stale relation object loaded before the assign.
     return this.findById(id);
   }
 
+  /** Movement ledger for one wagon, newest first (loaded legs, repositions, manual moves). */
+  async listMovements(wagonId: string): Promise<WagonMovement[]> {
+    await this.findById(wagonId); // 404 on unknown wagon
+    return this.dataSource.getRepository(WagonMovement).find({
+      where: { wagonId },
+      relations: { fromYard: true, toYard: true },
+      order: { occurredAt: 'DESC', createdAt: 'DESC' },
+    });
+  }
+
   async remove(id: string): Promise<void> {
     const wagon = await this.findById(id);
     await this.wagonRepo.remove(wagon);
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..900a9d8ac 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
@@ -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)
diff --git a/apps/edr-freight-api/src/modules/warehouses/dto/fee-rule.dto.ts b/apps/edr-freight-api/src/modules/warehouses/dto/fee-rule.dto.ts
index 1213b1177..a688f3e1a 100644
--- a/apps/edr-freight-api/src/modules/warehouses/dto/fee-rule.dto.ts
+++ b/apps/edr-freight-api/src/modules/warehouses/dto/fee-rule.dto.ts
@@ -87,6 +87,17 @@ export class CreateFeeRuleDto {
   @Min(0)
   ratePerDay!: number;
 
+  @ApiPropertyOptional({ description: 'Truck detention only: grace window in hours (default 3).' })
+  @IsOptional()
+  @IsInt()
+  @Min(0)
+  freeHours?: number;
+
+  @ApiPropertyOptional({ description: 'Truck detention only: scope by vehicle type (TRUCK | VAN | TRAILER | …). Null = any.' })
+  @IsOptional()
+  @IsString()
+  vehicleType?: string;
+
   @ApiPropertyOptional({
     enum: FEE_RULE_BASES,
     description: 'Double-handling charge basis: PER_CONTAINER | PER_TON | PER_ITEM.',
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/entities/warehouse-fee-rule.entity.ts b/apps/edr-freight-api/src/modules/warehouses/entities/warehouse-fee-rule.entity.ts
index a8bc7bf23..a233143cf 100644
--- a/apps/edr-freight-api/src/modules/warehouses/entities/warehouse-fee-rule.entity.ts
+++ b/apps/edr-freight-api/src/modules/warehouses/entities/warehouse-fee-rule.entity.ts
@@ -55,6 +55,11 @@ export class WarehouseFeeRule extends BaseEntity {
   @Column({ name: 'container_type', type: 'varchar', length: 40, nullable: true })
   containerType?: string | null;
 
+  // Truck detention only: scope by vehicle type (TRUCK | VAN | TRAILER | TANKER
+  // | FLATBED | …). Null = any truck type.
+  @Column({ name: 'vehicle_type', type: 'varchar', length: 20, nullable: true })
+  vehicleType?: string | null;
+
   @Column({ name: 'facility_id', type: 'uuid', nullable: true })
   facilityId?: string | null;
 
@@ -71,6 +76,11 @@ export class WarehouseFeeRule extends BaseEntity {
   @Column({ name: 'free_days', type: 'int', default: 0 })
   freeDays!: number;
 
+  // Truck detention only: grace window in HOURS before detention accrues
+  // (contract default 3h). Null/0 → the 3-hour default.
+  @Column({ name: 'free_hours', type: 'int', nullable: true })
+  freeHours?: number | null;
+
   @Column({ name: 'rate_per_day', type: 'numeric', precision: 14, scale: 2, default: 0 })
   ratePerDay!: number;
 
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..d91ba4cbe 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,9 @@
 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 handover records. A booking has one handover per truck (single truck ⇒
@@ -13,7 +15,32 @@ 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,
+  ) {}
+
+  /** 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;
+      await this.inbox.notify({
+        recipients: { companyId: b.companyId },
+        audience: NotificationAudience.PORTAL,
+        type: NotificationType.DOCUMENT_ACTION,
+        title: 'Handover — signature needed',
+        body: `Your import handover ${reference} for booking ${b.reference} is ready. Please review and sign it from the portal before the truck leaves.`,
+        link: `/bookings/${bookingId}`,
+        data: { bookingId, reference },
+      });
+    } 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({
@@ -54,6 +81,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/scheduling-read.facade.ts b/apps/edr-freight-api/src/modules/warehouses/scheduling-read.facade.ts
index 5fcf59dd5..41ca7facb 100644
--- a/apps/edr-freight-api/src/modules/warehouses/scheduling-read.facade.ts
+++ b/apps/edr-freight-api/src/modules/warehouses/scheduling-read.facade.ts
@@ -340,6 +340,7 @@ export class SchedulingReadFacade {
         'LOADED',
         'DISPATCHED',
         'IN_TRANSIT',
+        'ARRIVED',
         'ARRIVED_AT_DJIBOUTI',
         'ARRIVED_AT_PORT',
         'ARRIVED_AT_DESTINATION',
diff --git a/apps/edr-freight-api/src/modules/warehouses/warehouse-fee.service.ts b/apps/edr-freight-api/src/modules/warehouses/warehouse-fee.service.ts
index 16eca7849..14a3375c7 100644
--- a/apps/edr-freight-api/src/modules/warehouses/warehouse-fee.service.ts
+++ b/apps/edr-freight-api/src/modules/warehouses/warehouse-fee.service.ts
@@ -14,6 +14,8 @@ interface ItemAttributes {
   tradeDirection: string | null;
   cargoTypeCode: string | null;
   containerTypeCode: string | null;
+  /** Vehicle type of the truck (truck detention scoping); null otherwise. */
+  vehicleType: string | null;
   inventoryQuantity: number;
   bookingContainerCount: number;
   /** Booking cargo total in the cargo's unit of measure: tonnes (PER_TON) or item count (PER_ITEM). */
@@ -52,6 +54,16 @@ export interface FeePreview {
     ratePerDay: number;
     amount: number;
   }>;
+  /** Truck detention: per-vehicle-type breakdown — each truck-type group billed by its own matching rule. */
+  groups?: Array<{
+    vehicleType: string | null;
+    truckCount: number;
+    chargeableDays: number;
+    ratePerDay: number;
+    amount: number;
+    ruleId: string | null;
+    ruleName: string | null;
+  }>;
 }
 
 const MS_PER_DAY = 24 * 60 * 60 * 1000;
@@ -194,6 +206,7 @@ export class WarehouseFeeService {
     if (!check(rule.tradeDirection, item.tradeDirection, { allowBoth: true })) return null;
     if (!check(rule.cargoTypeCode, item.cargoTypeCode)) return null;
     if (!check(rule.containerType, item.containerTypeCode)) return null;
+    if (!check(rule.vehicleType, item.vehicleType)) return null;
     if (!check(rule.facilityId, item.facilityId)) return null;
     if (!check(rule.warehouseId, item.warehouseId)) return null;
     if (!check(rule.yardId, item.yardId)) return null;
@@ -374,7 +387,9 @@ export class WarehouseFeeService {
     // PER_TON (tonnes) and PER_ITEM (piece count) both read the cargo total,
     // which is stored in the cargo's own unit of measure.
     const cargoQuantity = Math.max(0, Number(item.cargoQuantity) || 0);
-    const quantity = basis === 'PER_CONTAINER' ? containerCount : cargoQuantity;
+    // Double handling applies to IMPORT only — no charge for export/domestic.
+    const isImport = (item.tradeDirection ?? '').toUpperCase() === 'IMPORT';
+    const quantity = !isImport ? 0 : basis === 'PER_CONTAINER' ? containerCount : cargoQuantity;
     const sourceAmount = Math.round(rate * quantity * 100) / 100;
     const amount = ruleCurrency ? await this.convertAmount(sourceAmount, ruleCurrency, targetCurrency) : 0;
     const convertedRate = ruleCurrency ? await this.convertAmount(rate, ruleCurrency, targetCurrency) : 0;
@@ -407,12 +422,9 @@ export class WarehouseFeeService {
     const rules = await this.feeRuleRepository.findAll({ where: { isActive: true } });
     const now = new Date();
 
-    const byType: FeeRuleType[] = [
-      'DEMURRAGE_FEE',
-      'STORAGE_FEE',
-      'DOUBLE_HANDLING_FEE',
-      'TRUCK_DETENTION_FEE',
-    ];
+    // Truck detention is a per-truck last-mile charge, not a per-inventory fee —
+    // it is computed separately via previewTruckDetention(), not here.
+    const byType: FeeRuleType[] = ['DEMURRAGE_FEE', 'STORAGE_FEE', 'DOUBLE_HANDLING_FEE'];
     return Promise.all(
       byType.map((type) =>
         this.compute(
@@ -425,4 +437,197 @@ export class WarehouseFeeService {
       ),
     );
   }
+
+  /**
+   * Truck detention preview for an EDR last-mile leg. The vehicle should be
+   * returned within the rule's grace window (default 3h) of arriving; beyond
+   * that, detention accrues per truck per day (flat rate/day or progressive
+   * tiers by detention day) until it is delivered/returned (or now, if open).
+   */
+  async previewTruckDetention(lastMileId: string, billingCurrency = 'USD'): Promise<FeePreview> {
+    const [leg] = await this.dataSource.query(
+      `SELECT lm.arrived_at   AS "arrivedAt",
+              lm.delivered_at AS "deliveredAt",
+              b.freight_type  AS "freightType",
+              b.trade_direction AS "tradeDirection"
+         FROM freight.last_mile lm
+         LEFT JOIN freight.bookings b ON b.id = lm.booking_id
+        WHERE lm.id = $1 AND lm.deleted_at IS NULL`,
+      [lastMileId],
+    );
+    if (!leg) throw new NotFoundException(`Last-mile record ${lastMileId} not found`);
+
+    // Truck detention applies to IMPORT only — no charge for export/domestic.
+    if ((leg.tradeDirection ?? '').toUpperCase() !== 'IMPORT') {
+      const cur = this.normalizeCurrency(billingCurrency);
+      return {
+        ruleType: 'TRUCK_DETENTION_FEE',
+        basis: null,
+        ruleId: null,
+        ruleName: null,
+        freeDays: 0,
+        ratePerDay: 0,
+        currency: cur,
+        ruleCurrency: null,
+        billingCurrency: cur,
+        startDate: leg.arrivedAt ? new Date(leg.arrivedAt).toISOString() : null,
+        endDate: (leg.deliveredAt ? new Date(leg.deliveredAt) : new Date()).toISOString(),
+        endIsOpen: !leg.deliveredAt,
+        elapsedDays: 0,
+        chargeableDays: 0,
+        containerCount: 0,
+        billableUnits: 0,
+        amount: 0,
+        tiers: [],
+        groups: [],
+      };
+    }
+
+    // Group the leg's vehicles by type so each truck type is billed by its own
+    // matching rule (rates differ by truck type). Falls back to one untyped group.
+    const groupRows: Array<{ vehicleType: string | null; truckCount: number | string }> =
+      await this.dataSource.query(
+        `SELECT v.vehicle_type AS "vehicleType", count(*)::int AS "truckCount"
+           FROM freight.last_mile_vehicle_assignments va
+           JOIN freight.vehicles v ON v.id = va.vehicle_id AND v.deleted_at IS NULL
+          WHERE va.last_mile_id = $1 AND va.deleted_at IS NULL
+          GROUP BY v.vehicle_type`,
+        [lastMileId],
+      );
+    const groups = groupRows.length ? groupRows : [{ vehicleType: null, truckCount: 1 }];
+
+    const rules = await this.feeRuleRepository.findAll({ where: { isActive: true } });
+    const detentionRules = rules.filter((r) => r.ruleType === 'TRUCK_DETENTION_FEE');
+    const now = new Date();
+    const targetCurrency = this.normalizeCurrency(billingCurrency);
+
+    const computed = await Promise.all(
+      groups.map(async (g) => {
+        const item: ItemAttributes = {
+          arrivedAt: null,
+          gateClearedAt: null,
+          releaseDate: null,
+          freightType: leg.freightType ?? null,
+          tradeDirection: leg.tradeDirection ?? null,
+          cargoTypeCode: null,
+          containerTypeCode: null,
+          vehicleType: g.vehicleType ?? null,
+          inventoryQuantity: 1,
+          bookingContainerCount: 1,
+          cargoQuantity: 0,
+          facilityId: null,
+          warehouseId: null,
+          yardId: null,
+          zoneId: null,
+        };
+        const rule = this.bestRule(detentionRules, item);
+        const c = await this.computeTruckDetention(
+          rule,
+          { arrivedAt: leg.arrivedAt, deliveredAt: leg.deliveredAt, truckCount: g.truckCount },
+          now,
+          billingCurrency,
+        );
+        return { vehicleType: g.vehicleType ?? null, truckCount: Math.max(1, Math.round(Number(g.truckCount) || 1)), c };
+      }),
+    );
+
+    const totalAmount = Math.round(computed.reduce((s, x) => s + x.c.amount, 0) * 100) / 100;
+    const totalTrucks = computed.reduce((s, x) => s + x.truckCount, 0);
+    const totalBillable = computed.reduce((s, x) => s + x.c.billableUnits, 0);
+    const chargeableDays = computed[0]?.c.chargeableDays ?? 0;
+    const single = computed.length === 1 ? computed[0].c : null;
+    const anyRuleName = computed.find((x) => x.c.ruleId)?.c.ruleName ?? null;
+
+    return {
+      ruleType: 'TRUCK_DETENTION_FEE',
+      basis: null,
+      ruleId: single?.ruleId ?? null,
+      ruleName: single ? single.ruleName : computed.length > 1 && anyRuleName ? 'Per truck-type rules' : anyRuleName,
+      freeDays: 0,
+      ratePerDay: single?.ratePerDay ?? 0,
+      currency: targetCurrency,
+      ruleCurrency: single?.ruleCurrency ?? null,
+      billingCurrency: targetCurrency,
+      startDate: leg.arrivedAt ? new Date(leg.arrivedAt).toISOString() : null,
+      endDate: (leg.deliveredAt ? new Date(leg.deliveredAt) : now).toISOString(),
+      endIsOpen: !leg.deliveredAt,
+      elapsedDays: chargeableDays,
+      chargeableDays,
+      containerCount: totalTrucks,
+      billableUnits: totalBillable,
+      amount: totalAmount,
+      tiers: single ? single.tiers : [],
+      groups: computed.map((x) => ({
+        vehicleType: x.vehicleType,
+        truckCount: x.truckCount,
+        chargeableDays: x.c.chargeableDays,
+        ratePerDay: x.c.ratePerDay,
+        amount: x.c.amount,
+        ruleId: x.c.ruleId,
+        ruleName: x.c.ruleName,
+      })),
+    };
+  }
+
+  private async computeTruckDetention(
+    rule: WarehouseFeeRule | null,
+    row: { arrivedAt: Date | string | null; deliveredAt: Date | string | null; truckCount: number | string },
+    now: Date,
+    billingCurrency: string,
+  ): Promise<FeePreview> {
+    const graceHours = rule?.freeHours && Number(rule.freeHours) > 0 ? Number(rule.freeHours) : 3;
+    const truckCount = Math.max(1, Math.round(Number(row.truckCount) || 1));
+    const start = row.arrivedAt ? new Date(row.arrivedAt) : null;
+    const end = row.deliveredAt ? new Date(row.deliveredAt) : now;
+    const endIsOpen = !row.deliveredAt;
+
+    let chargeableDays = 0;
+    if (start) {
+      const detentionMs = end.getTime() - start.getTime() - graceHours * 60 * 60 * 1000;
+      chargeableDays = detentionMs > 0 ? Math.ceil(detentionMs / MS_PER_DAY) : 0;
+    }
+
+    const ratePerDay = Number(rule?.ratePerDay ?? 0);
+    const ruleCurrency = rule ? this.normalizeCurrency(rule.currency) : null;
+    const targetCurrency = this.normalizeCurrency(billingCurrency);
+    const hasTiers = Boolean(rule?.tiers?.length);
+    const tiered = this.calculateTieredAmount(rule?.tiers, chargeableDays, truckCount);
+    const billableUnits = hasTiers ? tiered.billableUnits : chargeableDays * truckCount;
+    const sourceAmount = hasTiers ? tiered.sourceAmount : Math.round(billableUnits * ratePerDay * 100) / 100;
+    const amount = ruleCurrency ? await this.convertAmount(sourceAmount, ruleCurrency, targetCurrency) : 0;
+    const sourceRatePerDay = hasTiers ? tiered.weightedRatePerDay : ratePerDay;
+    const convertedRatePerDay = ruleCurrency
+      ? await this.convertAmount(sourceRatePerDay, ruleCurrency, targetCurrency)
+      : 0;
+    const convertedTiers = ruleCurrency
+      ? await Promise.all(
+          tiered.tiers.map(async (tier) => ({
+            ...tier,
+            ratePerDay: await this.convertAmount(tier.ratePerDay, ruleCurrency, targetCurrency),
+            amount: await this.convertAmount(tier.amount, ruleCurrency, targetCurrency),
+          })),
+        )
+      : [];
+
+    return {
+      ruleType: 'TRUCK_DETENTION_FEE',
+      basis: null,
+      ruleId: rule?.id ?? null,
+      ruleName: rule?.name ?? null,
+      freeDays: 0,
+      ratePerDay: convertedRatePerDay,
+      currency: targetCurrency,
+      ruleCurrency,
+      billingCurrency: targetCurrency,
+      startDate: start ? start.toISOString() : null,
+      endDate: end.toISOString(),
+      endIsOpen,
+      elapsedDays: chargeableDays,
+      chargeableDays,
+      containerCount: truckCount, // reused as the per-truck count
+      billableUnits,
+      amount,
+      tiers: hasTiers ? convertedTiers : [],
+    };
+  }
 }
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..0a0c56821 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
@@ -44,7 +44,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,
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 bf7139d72..004704bea 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
@@ -39,6 +39,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'];
@@ -383,8 +385,39 @@ 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
+    try {
+      await this.inbox.notify({
+        recipients: { companyId: booking.companyId },
+        audience: NotificationAudience.PORTAL,
+        type: NotificationType.BOOKING_STATUS,
+        title: 'Assign a truck for pickup',
+        body: `Booking ${booking.reference ?? bookingId} has been received at the warehouse. Please assign your collection truck(s) from the portal to proceed.`,
+        link: `/bookings/${bookingId}`,
+        data: { bookingId, action: 'ASSIGN_TRUCK' },
+      });
+    } 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
@@ -510,7 +543,7 @@ export class WarehouseInventoryService {
   // ── Batch 4.5: Arrival / Unload / Load automation ──────────────────────────
 
   /** Bookings whose goods have arrived and may be unloaded into the warehouse. */
-  private readonly ARRIVED_BOOKING_STATUSES = ['IN_TRANSIT'];
+  private readonly ARRIVED_BOOKING_STATUSES = ['IN_TRANSIT', 'ARRIVED'];
 
   /** Arrived bookings + their current inventory/inspection state (queue view). */
   async arrivalQueue(): Promise<ArrivalQueueItem[]> {
@@ -866,7 +899,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 +1038,7 @@ export class WarehouseInventoryService {
 
         result.receivedCount += 1;
         result.results.push({ bookingId, status: 'RECEIVED', inventoryId: saved.id, grnNumber });
+        void this.notifyTruckAssignmentNeeded(booking, bookingId);
       }
     });
 
@@ -2020,7 +2057,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,
@@ -2677,7 +2714,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'],
     ];
@@ -3608,8 +3645,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 +3768,7 @@ export class WarehouseInventoryService {
         `${(data.truckPlateNumber && data.truckWeightKg
           ? data.truckWeightKg
           : data.weight
-        ).toLocaleString()} kg`,
+        ).toLocaleString()} t`,
       ],
       ['Warehouse', data.warehouse],
       ['Yard', data.yard],
@@ -3894,8 +3931,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 +4005,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 +4340,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 +4394,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 +4457,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 +4467,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.controller.ts b/apps/edr-freight-api/src/modules/warehouses/warehouse-invoice.controller.ts
index 8b16e3bec..a1c5db837 100644
--- a/apps/edr-freight-api/src/modules/warehouses/warehouse-invoice.controller.ts
+++ b/apps/edr-freight-api/src/modules/warehouses/warehouse-invoice.controller.ts
@@ -18,6 +18,15 @@ export class WarehouseInvoiceController {
     return this.invoiceService.generateForInventory(id, dto);
   }
 
+  @Post('last-mile/:id/generate-truck-detention-invoice')
+  @ApiOperation({ summary: 'Generate a truck-detention invoice for a last-mile leg (per truck per day)' })
+  generateTruckDetention(
+    @Param('id', ParseUUIDPipe) id: string,
+    @Body() dto: GenerateInvoiceDto,
+  ) {
+    return this.invoiceService.generateTruckDetentionInvoice(id, dto);
+  }
+
   @Get('warehouse-inventory/:id/fee-invoices')
   @ApiOperation({ summary: 'List fee invoices for an inventory item' })
   listForInventory(@Param('id', ParseUUIDPipe) id: string) {
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 b7cd3628e..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 ───────────────────────────────────────────────────────────
@@ -269,6 +272,104 @@ export class WarehouseInvoiceService {
     return detail;
   }
 
+  /**
+   * Generate a truck-detention invoice for a last-mile leg. Unlike warehouse fees
+   * (per inventory item), detention is a per-truck charge on the last-mile leg, so
+   * it becomes a `last_mile` invoice with its own `TRUCK_DETENTION_FEE` type — kept
+   * separate from the delivery-fee invoice. Returns the global Invoice.
+   */
+  async generateTruckDetentionInvoice(
+    lastMileId: string,
+    opts: { billingCurrency?: "ETB" | "USD"; confirmZero?: boolean } = {},
+  ): Promise<Invoice> {
+    const [lm] = await this.dataSource.query(
+      `SELECT lm.id,
+              b.company_id         AS "companyId",
+              b.company_profile_id AS "companyProfileId",
+              b.payment_currency   AS "paymentCurrency"
+         FROM freight.last_mile lm
+         LEFT JOIN freight.bookings b ON b.id = lm.booking_id
+        WHERE lm.id = $1 AND lm.deleted_at IS NULL`,
+      [lastMileId],
+    );
+    if (!lm) throw new NotFoundException(`Last-mile record ${lastMileId} not found`);
+    if (!lm.companyId) {
+      throw new BadRequestException(
+        "Cannot invoice truck detention: the last-mile leg has no billable company (no associated booking).",
+      );
+    }
+
+    const existing = await this.billing.findPayable(
+      "last_mile" as Freight.InvoiceSource,
+      lastMileId,
+      "TRUCK_DETENTION_FEE",
+    );
+    if (existing) {
+      throw new ConflictException(
+        "An active truck detention invoice already exists for this last-mile leg. Cancel it before generating a new one.",
+      );
+    }
+
+    const billingCurrency: "ETB" | "USD" =
+      opts.billingCurrency ?? (lm.paymentCurrency === "ETB" ? "ETB" : "USD");
+    const preview = await this.feeService.previewTruckDetention(lastMileId, billingCurrency);
+    if (preview.amount <= 0 && !opts.confirmZero) {
+      throw new BadRequestException(
+        "No truck detention is currently payable for this last-mile leg.",
+      );
+    }
+
+    // One line per truck-type group (each billed by its own matching rule). Groups
+    // with no matching rule bill 0 and are dropped. Falls back to a single line.
+    const groups = preview.groups && preview.groups.length ? preview.groups : null;
+    const lines: InvoiceLineInput[] = groups
+      ? groups
+          .filter((g) => g.amount > 0)
+          .map((g) => ({
+            chargeType: "TRUCK_DETENTION",
+            description: `Truck detention${g.vehicleType ? ` (${g.vehicleType})` : ""} - ${g.chargeableDays} day(s) x ${g.truckCount} truck(s)`,
+            quantity: g.truckCount * g.chargeableDays,
+            unitRate: g.ratePerDay,
+            amount: g.amount,
+            currency: preview.currency,
+            metadata: {
+              feeRuleId: g.ruleId ?? null,
+              chargeableDays: g.chargeableDays,
+              vehicleType: g.vehicleType ?? null,
+            },
+          }))
+      : [
+          {
+            chargeType: "TRUCK_DETENTION",
+            description: `Truck detention - ${preview.chargeableDays} day(s) x ${preview.containerCount} truck(s)`,
+            quantity: preview.billableUnits,
+            unitRate: preview.ratePerDay,
+            amount: preview.amount,
+            currency: preview.currency,
+            metadata: {
+              feeRuleId: preview.ruleId ?? null,
+              chargeableDays: preview.chargeableDays ?? null,
+            },
+          },
+        ];
+    if (lines.length === 0) {
+      throw new BadRequestException(
+        "No truck detention is currently payable for this last-mile leg.",
+      );
+    }
+
+    return this.billing.generateInvoice({
+      source: "last_mile" as Freight.InvoiceSource,
+      sourceId: lastMileId,
+      type: "TRUCK_DETENTION_FEE",
+      companyId: lm.companyId,
+      companyProfileId: lm.companyProfileId || "",
+      currency: billingCurrency,
+      lines,
+      status: Freight.InvoiceStatus.Issued,
+    });
+  }
+
   // ── Reads ────────────────────────────────────────────────────────────────
   async findById(id: string): Promise<WarehouseFeeInvoiceDetail> {
     const invoice = await this.loadWarehouseInvoice(id);
@@ -870,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/warehouse-rules.controller.ts b/apps/edr-freight-api/src/modules/warehouses/warehouse-rules.controller.ts
index 715080612..d35587d9e 100644
--- a/apps/edr-freight-api/src/modules/warehouses/warehouse-rules.controller.ts
+++ b/apps/edr-freight-api/src/modules/warehouses/warehouse-rules.controller.ts
@@ -85,4 +85,13 @@ export class WarehouseRulesController {
   ) {
     return this.feeService.previewForInventory(id, billingCurrency);
   }
+
+  @Get('last-mile/:id/truck-detention-preview')
+  @ApiOperation({ summary: 'Preview truck detention for a last-mile leg (per truck per day after grace)' })
+  truckDetentionPreview(
+    @Param('id', ParseUUIDPipe) id: string,
+    @Query('billingCurrency') billingCurrency?: string,
+  ) {
+    return this.feeService.previewTruckDetention(id, billingCurrency);
+  }
 }
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/scripts/seed-gate-pass-train-scenarios.ts b/apps/edr-freight-api/src/scripts/seed-gate-pass-train-scenarios.ts
index a57ce84c7..9aa9e169c 100644
--- a/apps/edr-freight-api/src/scripts/seed-gate-pass-train-scenarios.ts
+++ b/apps/edr-freight-api/src/scripts/seed-gate-pass-train-scenarios.ts
@@ -196,7 +196,6 @@ async function ensureReferences(manager: any) {
         includesFirstMile: false,
         includesLastMile: false,
         includesCustoms: false,
-        priorityBonusPoints: 0,
         isActive: true,
         displayOrder: 1,
       }),
diff --git a/apps/edr-freight-api/src/scripts/seed-negad-indode-arrived-train.ts b/apps/edr-freight-api/src/scripts/seed-negad-indode-arrived-train.ts
index ff4a34493..3ebcca6ab 100644
--- a/apps/edr-freight-api/src/scripts/seed-negad-indode-arrived-train.ts
+++ b/apps/edr-freight-api/src/scripts/seed-negad-indode-arrived-train.ts
@@ -138,7 +138,6 @@ async function main() {
             includesFirstMile: false,
             includesLastMile: false,
             includesCustoms: false,
-            priorityBonusPoints: 0,
             isActive: true,
             displayOrder: 1,
           }),
diff --git a/apps/edr-freight-api/src/seed/approved-first-lastmile-demo-bookings.seeder.ts b/apps/edr-freight-api/src/seed/approved-first-lastmile-demo-bookings.seeder.ts
index b67f1f572..989e18bf1 100644
--- a/apps/edr-freight-api/src/seed/approved-first-lastmile-demo-bookings.seeder.ts
+++ b/apps/edr-freight-api/src/seed/approved-first-lastmile-demo-bookings.seeder.ts
@@ -214,7 +214,6 @@ export class ApprovedFirstLastMileDemoBookingsSeeder {
           includesFirstMile: true,
           includesLastMile: true,
           includesCustoms: false,
-          priorityBonusPoints: 0,
           isActive: true,
           displayOrder: 10,
         },
diff --git a/apps/edr-freight-api/src/seed/demo-bookings.seeder.ts b/apps/edr-freight-api/src/seed/demo-bookings.seeder.ts
index be5e1c87d..c42d831bc 100644
--- a/apps/edr-freight-api/src/seed/demo-bookings.seeder.ts
+++ b/apps/edr-freight-api/src/seed/demo-bookings.seeder.ts
@@ -295,7 +295,6 @@ export class DemoBookingsSeeder {
           includesFirstMile: false,
           includesLastMile: false,
           includesCustoms: false,
-          priorityBonusPoints: 0,
           isActive: true,
           displayOrder: 1,
         },
diff --git a/apps/edr-freight-api/src/seed/file-upload-settings.seeder.ts b/apps/edr-freight-api/src/seed/file-upload-settings.seeder.ts
index e5e3bb139..1aef33801 100644
--- a/apps/edr-freight-api/src/seed/file-upload-settings.seeder.ts
+++ b/apps/edr-freight-api/src/seed/file-upload-settings.seeder.ts
@@ -512,6 +512,32 @@ const CONTRACT_INTAKE_SETTINGS: OnboardingDocumentSetting[] = [
 const CLEARANCE_DESCRIPTION =
   "Operation/clearance documents collected after contract execution, by operation, freight type and customs.";
 
+// ── Driver documents ────────────────────────────────────────────────────────
+// Configurable upload area (code "driver_docs") attached to a driver profile —
+// license, national ID, contracts, training certificates, etc.
+const DRIVER_DOCUMENT_FIELDS: OnboardingField[] = [
+  {
+    fileKey: "driver_docs",
+    fileLabel: "Driver documents",
+    helpText: "License, national ID, contracts, training certificates, etc.",
+    isRequired: false,
+    isMultiple: true,
+    maxFiles: 20,
+    allowedExtensions: ["pdf", "jpg", "jpeg", "png", "doc", "docx"],
+    maxSizeMb: 10,
+    displayOrder: 1,
+  },
+];
+
+const DRIVER_DOCUMENT_SETTINGS: OnboardingDocumentSetting[] = [
+  {
+    code: "driver_docs",
+    label: "Driver documents",
+    entity: "driver",
+    fields: DRIVER_DOCUMENT_FIELDS,
+  },
+];
+
 @Injectable()
 export class FileUploadSettingsSeeder {
   private readonly logger = new Logger(FileUploadSettingsSeeder.name);
@@ -549,6 +575,11 @@ export class FileUploadSettingsSeeder {
           description:
             "Commercial/framework documents attached at contract submission.",
         })),
+        ...DRIVER_DOCUMENT_SETTINGS.map((s) => ({
+          ...s,
+          description:
+            "Documents uploaded against a driver profile (license, ID, contracts, etc.).",
+        })),
       ];
 
       for (const documentSetting of allSettings) {
diff --git a/apps/edr-freight-api/src/seed/freight-positions.seeder.ts b/apps/edr-freight-api/src/seed/freight-positions.seeder.ts
new file mode 100644
index 000000000..09901b502
--- /dev/null
+++ b/apps/edr-freight-api/src/seed/freight-positions.seeder.ts
@@ -0,0 +1,171 @@
+import { Injectable, Logger } from '@nestjs/common';
+import {
+  Organization,
+  Permission,
+  Position,
+  PositionPermission,
+  Unit,
+} from '@tria-plc/iamapi-common';
+import { DataSource, EntityManager, In } from 'typeorm';
+
+import { EDR_FREIGHT_POSITIONS } from './edr-freight.seed';
+
+const SEED_FLAG = 'SEED_EDR_ORG';
+const EDR_ORG_KEY = 'edr_freight';
+const EDR_UNIT_KEY = 'edr_freight_app';
+
+/**
+ * Seeds the operational freight positions (CEO, Chief, Director, Marketer,
+ * Operation, Ethiopian GL, Djibouti GL) as Position + PositionPermission rows
+ * on the `edr_freight_app` unit. Positions-as-roles: users get their freight
+ * access by being assigned to a Position (via EmployeePosition), and the
+ * position's PositionPermission grants come from EDR_FREIGHT_POSITIONS.
+ *
+ * Gated behind the same SEED_EDR_ORG flag as EdrOrgSeeder and depends on the
+ * org/unit/permission catalog it seeds, so it must run AFTER EdrOrgSeeder.
+ * Idempotent: positions upsert by (key, unitId); grants insert only the
+ * permission ids a position is still missing.
+ */
+@Injectable()
+export class FreightPositionsSeeder {
+  private readonly logger = new Logger(FreightPositionsSeeder.name);
+
+  constructor(private readonly dataSource: DataSource) {}
+
+  async run() {
+    if (process.env[SEED_FLAG]?.trim().toLowerCase() !== 'true') {
+      this.logger.log(
+        `Skipping freight positions seed because ${SEED_FLAG} is not enabled`,
+      );
+      return;
+    }
+
+    await this.dataSource.transaction(async (manager) => {
+      const organization = await manager.getRepository(Organization).findOne({
+        where: { key: EDR_ORG_KEY },
+        select: { id: true },
+      });
+
+      if (!organization) {
+        throw new Error(`missing_organization:${EDR_ORG_KEY}`);
+      }
+
+      const unit = await manager.getRepository(Unit).findOne({
+        where: { key: EDR_UNIT_KEY, organizationId: organization.id },
+        select: { id: true },
+      });
+
+      if (!unit) {
+        throw new Error(`missing_unit:${EDR_UNIT_KEY}`);
+      }
+
+      const permissionKeyToId = await this.loadPermissionIds(manager);
+
+      for (const seed of EDR_FREIGHT_POSITIONS) {
+        const positionId = await this.ensurePosition(
+          manager,
+          seed,
+          unit.id as string,
+          organization.id as string,
+        );
+
+        await this.ensurePositionPermissions(
+          manager,
+          positionId,
+          seed,
+          permissionKeyToId,
+        );
+      }
+    });
+
+    this.logger.log(
+      `Ensured ${EDR_FREIGHT_POSITIONS.length} freight positions on unit '${EDR_UNIT_KEY}'`,
+    );
+  }
+
+  /** Resolve every permission key referenced by any position to its id. */
+  private async loadPermissionIds(
+    manager: EntityManager,
+  ): Promise<Map<string, string>> {
+    const keys = [
+      ...new Set(EDR_FREIGHT_POSITIONS.flatMap((p) => p.permissionKeys)),
+    ];
+
+    const permissions = await manager.getRepository(Permission).find({
+      where: { key: In(keys) },
+      select: { id: true, key: true },
+    });
+
+    const map = new Map(permissions.map((p) => [p.key, p.id as string]));
+
+    const missing = keys.filter((key) => !map.has(key));
+    if (missing.length > 0) {
+      throw new Error(`missing_permissions:${missing.join(',')}`);
+    }
+
+    return map;
+  }
+
+  private async ensurePosition(
+    manager: EntityManager,
+    seed: (typeof EDR_FREIGHT_POSITIONS)[number],
+    unitId: string,
+    organizationId: string,
+  ): Promise<string> {
+    const positionRepository = manager.getRepository(Position);
+
+    const existing = await positionRepository.findOne({
+      where: { key: seed.key, unitId },
+      select: { id: true },
+    });
+
+    if (existing) {
+      return existing.id as string;
+    }
+
+    const inserted = await positionRepository.insert({
+      key: seed.key,
+      name: { ...seed.name },
+      rank: seed.rank,
+      unitId,
+      organizationId,
+    });
+
+    this.logger.log(`Seeded freight position '${seed.key}'`);
+
+    return inserted.identifiers[0]?.id as string;
+  }
+
+  private async ensurePositionPermissions(
+    manager: EntityManager,
+    positionId: string,
+    seed: (typeof EDR_FREIGHT_POSITIONS)[number],
+    permissionKeyToId: Map<string, string>,
+  ) {
+    const positionPermissionRepository =
+      manager.getRepository(PositionPermission);
+
+    const existing = await positionPermissionRepository.find({
+      where: { positionId },
+      select: { permissionId: true },
+    });
+    const existingPermissionIds = new Set(
+      existing.map((row) => row.permissionId),
+    );
+
+    const rowsToInsert = seed.permissionKeys
+      .map((key) => permissionKeyToId.get(key) as string)
+      .filter((permissionId) => !existingPermissionIds.has(permissionId))
+      .map((permissionId) => ({ positionId, permissionId }));
+
+    if (rowsToInsert.length === 0) {
+      return;
+    }
+
+    await positionPermissionRepository.insert(rowsToInsert);
+
+    this.logger.log(
+      `Granted ${rowsToInsert.length} permissions to position '${seed.key}'`,
+    );
+  }
+}
diff --git a/apps/edr-freight-api/src/seed/freight-staff-users.seeder.ts b/apps/edr-freight-api/src/seed/freight-staff-users.seeder.ts
index a8c16ef05..6de3bc4de 100644
--- a/apps/edr-freight-api/src/seed/freight-staff-users.seeder.ts
+++ b/apps/edr-freight-api/src/seed/freight-staff-users.seeder.ts
@@ -16,7 +16,7 @@ import { DataSource } from 'typeorm';
 
 const SEED_FLAG = 'SEED_FREIGHT_STAFF';
 const EDR_ORG_KEY = 'edr_freight';
-const EDR_UNIT_KEY = 'edr_freight_hq';
+const EDR_UNIT_KEY = 'edr_freight_app';
 
 // roleKey is kept only for backwards compatibility with existing UserRole rows;
 // access is granted via the assigned position (positionKey) + PositionPermission.
diff --git a/apps/edr-freight-api/src/seed/paid-import-export-mile-demo.seeder.ts b/apps/edr-freight-api/src/seed/paid-import-export-mile-demo.seeder.ts
index 732653a9d..e1c46d168 100644
--- a/apps/edr-freight-api/src/seed/paid-import-export-mile-demo.seeder.ts
+++ b/apps/edr-freight-api/src/seed/paid-import-export-mile-demo.seeder.ts
@@ -136,7 +136,6 @@ export class PaidImportExportMileDemoSeeder {
           includesFirstMile: true,
           includesLastMile: true,
           includesCustoms: false,
-          priorityBonusPoints: 0,
           isActive: true,
           displayOrder: 11,
         },
diff --git a/apps/edr-freight-web/backoffice/package.json b/apps/edr-freight-web/backoffice/package.json
index 4efc5c2d4..b89807b72 100644
--- a/apps/edr-freight-web/backoffice/package.json
+++ b/apps/edr-freight-web/backoffice/package.json
@@ -22,6 +22,7 @@
     "@tabler/icons-react": "^3.44.0",
     "@tanstack/react-query": "^5.100.11",
     "@tria-plc/iamui": "file:../../../local-packages/tria-plc-iamui-0.1.1.tgz",
+    "@vis.gl/react-google-maps": "^1.8.3",
     "axios": "^1.7.7",
     "class-variance-authority": "^0.7.1",
     "clsx": "^2.1.1",
@@ -44,6 +45,7 @@
     "@edr/eslint-config": "workspace:*",
     "@edr/tsconfig": "workspace:*",
     "@tailwindcss/vite": "^4.3.0",
+    "@types/google.maps": "^3.65.2",
     "@types/react": "^18.3.11",
     "@types/react-dom": "^18.3.0",
     "@vitejs/plugin-react": "^4.3.2",
diff --git a/apps/edr-freight-web/backoffice/src/App.tsx b/apps/edr-freight-web/backoffice/src/App.tsx
index 06454e885..df8db49d4 100644
--- a/apps/edr-freight-web/backoffice/src/App.tsx
+++ b/apps/edr-freight-web/backoffice/src/App.tsx
@@ -94,6 +94,10 @@ import { MaintenancePage } from "./pages/fleet/MaintenancePage";
 import { FinancialReportsPage } from "./pages/fleet/FinancialReportsPage";
 import { FleetDashboard } from "./pages/fleet/FleetDashboard";
 import { TrackingPage } from "./pages/fleet/TrackingPage";
+import CompliancePage from "./pages/fleet/CompliancePage";
+import IncidentsPage from "./pages/fleet/IncidentsPage";
+import WorkOrdersPage from "./pages/fleet/WorkOrdersPage";
+import ProcurementPage from "./pages/fleet/ProcurementPage";
 import { getCategorySidebarChildren } from "./pages/ruleEngine/config/resources";
 import RuleEngineLegacyRedirect from "./pages/ruleEngine/RuleEngineLegacyRedirect";
 import RuleEngineResourcePage from "./pages/ruleEngine/RuleEngineResourcePage";
@@ -212,13 +216,13 @@ const buildSidebarSections = (demoItems: SidebarItem[]): SidebarSection[] => [
         label: "First Mile",
         href: "/dashboard/operations/first-mile",
         icon: <Truck />,
-        permission: FREIGHT_PERMS.trainScheduling.view,
+        permission: FREIGHT_PERMS.firstMile.view,
       },
       {
         label: "Last Mile",
         href: "/dashboard/operations/last-mile",
         icon: <Truck />,
-        permission: FREIGHT_PERMS.trainScheduling.view,
+        permission: FREIGHT_PERMS.lastMile.view,
       },
     ],
   },
@@ -229,7 +233,7 @@ const buildSidebarSections = (demoItems: SidebarItem[]): SidebarSection[] => [
         label: "Fleet Dashboard",
         href: "/dashboard/fleet-dashboard",
         icon: <LayoutDashboard />,
-        permission: FREIGHT_PERMS.fleet.view,
+        permission: FREIGHT_PERMS.fleetDashboard.view,
       },
       {
         label: "Routes",
@@ -259,43 +263,67 @@ const buildSidebarSections = (demoItems: SidebarItem[]): SidebarSection[] => [
         label: "Vehicles",
         href: "/dashboard/vehicles",
         icon: <Truck />,
-        permission: FREIGHT_PERMS.fleet.view,
+        permission: FREIGHT_PERMS.vehicles.view,
       },
       {
         label: "Drivers",
         href: "/dashboard/drivers",
         icon: <Users />,
-        permission: FREIGHT_PERMS.fleet.view,
+        permission: FREIGHT_PERMS.drivers.view,
       },
       {
         label: "Track Vehicles",
         href: "/dashboard/tracking",
         icon: <MapPin />,
-        permission: FREIGHT_PERMS.fleet.view,
+        permission: FREIGHT_PERMS.tracking.view,
       },
       {
         label: "Fuel Purchases",
         href: "/dashboard/fuel-purchases",
         icon: <Truck />,
-        permission: FREIGHT_PERMS.fleet.view,
+        permission: FREIGHT_PERMS.fuel.view,
       },
       {
         label: "Fuel Analytics",
         href: "/dashboard/fuel-stats",
         icon: <Truck />,
-        permission: FREIGHT_PERMS.fleet.view,
+        permission: FREIGHT_PERMS.fuel.view,
       },
       {
         label: "Maintenance",
         href: "/dashboard/maintenance",
         icon: <Truck />,
+        permission: FREIGHT_PERMS.maintenance.view,
+      },
+      {
+        label: "Work Orders",
+        href: "/dashboard/work-orders",
+        icon: <SlidersHorizontal />,
+        permission: FREIGHT_PERMS.maintenance.view,
+      },
+      {
+        label: "Compliance & Alerts",
+        href: "/dashboard/compliance",
+        icon: <ShieldCheck />,
+        permission: FREIGHT_PERMS.fleet.view,
+      },
+      {
+        label: "Incidents",
+        href: "/dashboard/incidents",
+        icon: <FileText />,
+        permission: FREIGHT_PERMS.fleet.view,
+      },
+      {
+        label: "Procurement",
+        href: "/dashboard/procurement",
+        icon: <Package />,
         permission: FREIGHT_PERMS.fleet.view,
       },
       {
         label: "Financial Reports",
         href: "/dashboard/financial-reports",
         icon: <Wallet />,
-        permission: FREIGHT_PERMS.fleet.view,
+        permission: FREIGHT_PERMS.fleetReports.view,
       },
       // {
       //   label: "Containers",
@@ -868,7 +896,7 @@ const App = () => {
         <Route
           path="operations/first-mile"
           element={
-            <RequirePermission permission={FREIGHT_PERMS.trainScheduling.view}>
+            <RequirePermission permission={FREIGHT_PERMS.firstMile.view}>
               <FirstMilePage />
             </RequirePermission>
           }
@@ -876,7 +904,7 @@ const App = () => {
         <Route
           path="operations/last-mile"
           element={
-            <RequirePermission permission={FREIGHT_PERMS.trainScheduling.view}>
+            <RequirePermission permission={FREIGHT_PERMS.lastMile.view}>
               <LastMilePage />
             </RequirePermission>
           }
@@ -972,7 +1000,7 @@ const App = () => {
         <Route
           path="vehicles"
           element={
-            <RequirePermission permission={FREIGHT_PERMS.fleet.view}>
+            <RequirePermission permission={FREIGHT_PERMS.vehicles.view}>
               <FleetResourcePage />
             </RequirePermission>
           }
@@ -980,7 +1008,7 @@ const App = () => {
         <Route
           path="vehicles/:id"
           element={
-            <RequirePermission permission={FREIGHT_PERMS.fleet.view}>
+            <RequirePermission permission={FREIGHT_PERMS.vehicles.view}>
               <VehicleDetailPage />
             </RequirePermission>
           }
@@ -988,7 +1016,7 @@ const App = () => {
         <Route
           path="drivers"
           element={
-            <RequirePermission permission={FREIGHT_PERMS.fleet.view}>
+            <RequirePermission permission={FREIGHT_PERMS.drivers.view}>
               <FleetResourcePage />
             </RequirePermission>
           }
@@ -996,7 +1024,7 @@ const App = () => {
         <Route
           path="drivers/:id"
           element={
-            <RequirePermission permission={FREIGHT_PERMS.fleet.view}>
+            <RequirePermission permission={FREIGHT_PERMS.drivers.view}>
               <DriverDetailPage />
             </RequirePermission>
           }
@@ -1058,7 +1086,7 @@ const App = () => {
         <Route
           path="fuel-purchases"
           element={
-            <RequirePermission permission={FREIGHT_PERMS.fleet.view}>
+            <RequirePermission permission={FREIGHT_PERMS.fuel.view}>
               <FuelPurchasePage />
             </RequirePermission>
           }
@@ -1066,7 +1094,7 @@ const App = () => {
         <Route
           path="fuel-stats"
           element={
-            <RequirePermission permission={FREIGHT_PERMS.fleet.view}>
+            <RequirePermission permission={FREIGHT_PERMS.fuel.view}>
               <FuelStatsPage />
             </RequirePermission>
           }
@@ -1074,7 +1102,7 @@ const App = () => {
         <Route
           path="maintenance"
           element={
-            <RequirePermission permission={FREIGHT_PERMS.fleet.view}>
+            <RequirePermission permission={FREIGHT_PERMS.maintenance.view}>
               <MaintenancePage />
             </RequirePermission>
           }
@@ -1082,7 +1110,7 @@ const App = () => {
         <Route
           path="financial-reports"
           element={
-            <RequirePermission permission={FREIGHT_PERMS.fleet.view}>
+            <RequirePermission permission={FREIGHT_PERMS.fleetReports.view}>
               <FinancialReportsPage />
             </RequirePermission>
           }
@@ -1090,7 +1118,7 @@ const App = () => {
         <Route
           path="fleet-dashboard"
           element={
-            <RequirePermission permission={FREIGHT_PERMS.fleet.view}>
+            <RequirePermission permission={FREIGHT_PERMS.fleetDashboard.view}>
               <FleetDashboard />
             </RequirePermission>
           }
@@ -1098,11 +1126,43 @@ const App = () => {
         <Route
           path="tracking"
           element={
-            <RequirePermission permission={FREIGHT_PERMS.fleet.view}>
+            <RequirePermission permission={FREIGHT_PERMS.tracking.view}>
               <TrackingPage />
             </RequirePermission>
           }
         />
+        <Route
+          path="compliance"
+          element={
+            <RequirePermission permission={FREIGHT_PERMS.fleet.view}>
+              <CompliancePage />
+            </RequirePermission>
+          }
+        />
+        <Route
+          path="incidents"
+          element={
+            <RequirePermission permission={FREIGHT_PERMS.fleet.view}>
+              <IncidentsPage />
+            </RequirePermission>
+          }
+        />
+        <Route
+          path="work-orders"
+          element={
+            <RequirePermission permission={FREIGHT_PERMS.maintenance.view}>
+              <WorkOrdersPage />
+            </RequirePermission>
+          }
+        />
+        <Route
+          path="procurement"
+          element={
+            <RequirePermission permission={FREIGHT_PERMS.fleet.view}>
+              <ProcurementPage />
+            </RequirePermission>
+          }
+        />
         <Route
           path="locomotives"
           element={
diff --git a/apps/edr-freight-web/backoffice/src/components/bookings/BookingStatusBadge.tsx b/apps/edr-freight-web/backoffice/src/components/bookings/BookingStatusBadge.tsx
index 1b2960b8f..7d1fff022 100644
--- a/apps/edr-freight-web/backoffice/src/components/bookings/BookingStatusBadge.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/bookings/BookingStatusBadge.tsx
@@ -18,6 +18,7 @@ const statusColorMap: Record<string, string> = {
   EXPIRED: "red",
   PAID: "edr-green",
   IN_TRANSIT: "cyan",
+  ARRIVED: "teal",
   COMPLETED: "indigo",
   REJECTED: "red",
   CANCELLED: "red",
diff --git a/apps/edr-freight-web/backoffice/src/components/bookings/detail/BookingDocumentsPanel.tsx b/apps/edr-freight-web/backoffice/src/components/bookings/detail/BookingDocumentsPanel.tsx
new file mode 100644
index 000000000..3c36f757e
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/components/bookings/detail/BookingDocumentsPanel.tsx
@@ -0,0 +1,146 @@
+import { useMemo } from "react";
+import { Box, Center, Group, Loader, Stack, Text } from "@mantine/core";
+import { FileText, FolderOpen } from "lucide-react";
+import { useQuery } from "@tanstack/react-query";
+import type { Freight } from "@edr/types";
+
+import { bookingsService } from "@/services/bookings.service";
+import { downloadBookingFile } from "@/services/files.service";
+import { useFileViewer } from "@/hooks/useFileViewer";
+import { ClearanceWorkflowFilesPanel } from "@/components/contracts/ClearanceWorkflowFilesPanel";
+import { PhasedUploadedFileRow } from "@/components/contracts/PhasedUploadedFileRow";
+import { SectionCard } from "./SectionCard";
+
+interface LabeledFile {
+  label: string;
+  file: { id: string; name: string };
+}
+
+/**
+ * Every document tied to a booking, in one tab: the customer/GL clearance
+ * documents, the customs workflow files (declaration/duty/transit/Djibouti),
+ * the duty-tax notice, and the final invoice + payment slip. All fetched from
+ * the booking's clearance view (the only endpoint that surfaces booking files),
+ * each with inline view + download.
+ */
+export function BookingDocumentsPanel({ bookingId }: { bookingId: string }) {
+  const { view, viewer } = useFileViewer();
+
+  const { data: clearance, isLoading, isError } = useQuery({
+    queryKey: ["clearance", bookingId],
+    queryFn: () => bookingsService.getClearance(bookingId),
+  });
+
+  const onDownload = (f: { id: string; name: string }) =>
+    void downloadBookingFile(f.id, f.name);
+
+  // Uploaded customer + GL clearance documents (skip the not-yet-uploaded slots).
+  const clearanceDocs = useMemo<
+    Array<{ doc: Freight.ClearanceDocument; file: { id: string; name: string } }>
+  >(
+    () =>
+      (clearance?.documents ?? [])
+        .filter((d) => d.file)
+        .map((d) => ({ doc: d, file: d.file! })),
+    [clearance],
+  );
+
+  const workflowFiles = useMemo(
+    () => (clearance?.workflowFiles ?? []).filter((f) => f.file),
+    [clearance],
+  );
+
+  // Duty notice + final invoice + payment slip — loose files that don't ride in
+  // the documents/workflow arrays.
+  const otherFiles = useMemo<LabeledFile[]>(() => {
+    const rows: LabeledFile[] = [];
+    const notice = clearance?.dutyAdvice?.noticeFile;
+    if (notice) rows.push({ label: "Duty & tax notice", file: notice });
+    const inv = clearance?.finalInvoice;
+    if (inv?.invoiceFile)
+      rows.push({ label: `Final invoice · ${inv.invoiceNumber}`, file: inv.invoiceFile });
+    if (inv?.slipFile)
+      rows.push({ label: "Final invoice payment slip", file: inv.slipFile });
+    return rows;
+  }, [clearance]);
+
+  if (isLoading) {
+    return (
+      <Center py={60}>
+        <Group gap={10}>
+          <Loader color="edr-green" />
+          <Text c="dimmed">Loading documents…</Text>
+        </Group>
+      </Center>
+    );
+  }
+
+  const hasAny =
+    clearanceDocs.length > 0 || workflowFiles.length > 0 || otherFiles.length > 0;
+
+  if (isError || !hasAny) {
+    return (
+      <SectionCard icon={FolderOpen} title="Documents" accent="edr-green">
+        <Center py={28}>
+          <Stack align="center" gap={6}>
+            <FolderOpen size={26} color="var(--mantine-color-gray-5)" />
+            <Text fw={600}>No documents yet</Text>
+            <Text size="sm" c="dimmed" ta="center" maw={360}>
+              {isError
+                ? "Couldn’t load this booking’s documents."
+                : "Documents attached to this booking will appear here as they’re uploaded."}
+            </Text>
+          </Stack>
+        </Center>
+      </SectionCard>
+    );
+  }
+
+  return (
+    <Stack gap="lg">
+      {clearanceDocs.length > 0 && (
+        <SectionCard icon={FileText} title="Clearance documents" accent="edr-green">
+          <Stack gap={8}>
+            {clearanceDocs.map(({ doc, file }) => (
+              <PhasedUploadedFileRow
+                key={doc.fileKey}
+                label={`${doc.label}${doc.uploadedBy === "gl" ? " · GL" : ""}`}
+                file={file}
+                onView={view}
+                onDownload={onDownload}
+                compact
+              />
+            ))}
+          </Stack>
+        </SectionCard>
+      )}
+
+      {workflowFiles.length > 0 && (
+        <ClearanceWorkflowFilesPanel
+          files={workflowFiles}
+          onView={view}
+          onDownload={onDownload}
+        />
+      )}
+
+      {otherFiles.length > 0 && (
+        <SectionCard icon={FileText} title="Invoices & notices" accent="edr-green">
+          <Stack gap={8}>
+            {otherFiles.map((row) => (
+              <PhasedUploadedFileRow
+                key={row.file.id}
+                label={row.label}
+                file={row.file}
+                onView={view}
+                onDownload={onDownload}
+                compact
+              />
+            ))}
+          </Stack>
+        </SectionCard>
+      )}
+
+      <Box>{viewer}</Box>
+    </Stack>
+  );
+}
diff --git a/apps/edr-freight-web/backoffice/src/components/bookings/detail/index.ts b/apps/edr-freight-web/backoffice/src/components/bookings/detail/index.ts
index 003f3d4de..b948cc5dc 100644
--- a/apps/edr-freight-web/backoffice/src/components/bookings/detail/index.ts
+++ b/apps/edr-freight-web/backoffice/src/components/bookings/detail/index.ts
@@ -1,6 +1,7 @@
 export * from "./booking-detail.styles";
 export * from "./SectionCard";
 export * from "./ClearanceReviewSection";
+export * from "./BookingDocumentsPanel";
 export * from "./ContractOrdersPanel";
 export * from "./MetricTile";
 export * from "./BookingDetailToolbar";
diff --git a/apps/edr-freight-web/backoffice/src/components/contracts/ContractApprovalStepsCard.tsx b/apps/edr-freight-web/backoffice/src/components/contracts/ContractApprovalStepsCard.tsx
index 0d7adc5be..044c729ee 100644
--- a/apps/edr-freight-web/backoffice/src/components/contracts/ContractApprovalStepsCard.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/contracts/ContractApprovalStepsCard.tsx
@@ -1,5 +1,5 @@
 import { useMemo, useState } from "react";
-import { Check, ShieldCheck } from "lucide-react";
+import { Check, ShieldCheck, X } from "lucide-react";
 import {
   Stack,
   Group,
@@ -8,6 +8,7 @@ import {
   Button,
   Box,
   Modal,
+  Textarea,
 } from "@mantine/core";
 import type { Freight } from "@edr/types";
 
@@ -30,6 +31,10 @@ export function ContractApprovalStepsCard({
   const [confirmOpen, setConfirmOpen] = useState(false);
   const [pendingStep, setPendingStep] =
     useState<Freight.IContractApprovalStep | null>(null);
+  const [rejectOpen, setRejectOpen] = useState(false);
+  const [rejectStepRow, setRejectStepRow] =
+    useState<Freight.IContractApprovalStep | null>(null);
+  const [rejectReason, setRejectReason] = useState("");
 
   const steps = useMemo(
     () =>
@@ -60,6 +65,28 @@ export function ContractApprovalStepsCard({
     );
   };
 
+  const openReject = (step: Freight.IContractApprovalStep) => {
+    setRejectStepRow(step);
+    setRejectReason("");
+    setRejectOpen(true);
+  };
+
+  const closeReject = () => {
+    setRejectOpen(false);
+    setRejectStepRow(null);
+    setRejectReason("");
+  };
+
+  const trimmedReason = rejectReason.trim();
+
+  const runReject = () => {
+    if (!rejectStepRow || !trimmedReason) return;
+    mutations.rejectStep.mutate(
+      { stepId: rejectStepRow.id, reason: trimmedReason },
+      { onSuccess: () => closeReject() },
+    );
+  };
+
   const subtitle =
     summary.detail ||
     (nextPending
@@ -106,8 +133,12 @@ export function ContractApprovalStepsCard({
                 key={step.id}
                 step={step}
                 isNext={nextPending?.id === step.id}
-                isPending={mutations.approveStep.isPending}
+                isPending={
+                  mutations.approveStep.isPending ||
+                  mutations.rejectStep.isPending
+                }
                 onApprove={() => openApprove(step)}
+                onReject={() => openReject(step)}
               />
             ))}
           </Stack>
@@ -149,6 +180,54 @@ export function ContractApprovalStepsCard({
           </Group>
         </Stack>
       </Modal>
+
+      <Modal
+        opened={rejectOpen}
+        onClose={closeReject}
+        title="Reject this step?"
+        radius="md"
+        centered
+      >
+        <Stack gap="md">
+          <Text size="sm" c="dimmed">
+            Rejecting the{" "}
+            <Text span fw={600} c="dark">
+              {rejectStepRow?.requiredRole}
+            </Text>{" "}
+            step rejects contract{" "}
+            <Text span fw={600} c="dark">
+              {contract.reference}
+            </Text>{" "}
+            outright. The customer must create a new contract — this cannot be
+            undone.
+          </Text>
+          <Textarea
+            label="Reason for rejection"
+            description="Shared with the customer and the approval chain."
+            placeholder="Explain why this contract is rejected…"
+            minRows={3}
+            autosize
+            withAsterisk
+            value={rejectReason}
+            onChange={(e) => setRejectReason(e.currentTarget.value)}
+          />
+          <Group justify="flex-end" gap="sm">
+            <Button variant="default" radius="md" onClick={closeReject}>
+              Cancel
+            </Button>
+            <Button
+              color="red"
+              radius="md"
+              leftSection={<X size={16} />}
+              loading={mutations.rejectStep.isPending}
+              disabled={!trimmedReason}
+              onClick={runReject}
+            >
+              Reject contract
+            </Button>
+          </Group>
+        </Stack>
+      </Modal>
     </>
   );
 }
@@ -158,11 +237,13 @@ function StepRow({
   isNext,
   isPending,
   onApprove,
+  onReject,
 }: {
   step: Freight.IContractApprovalStep;
   isNext: boolean;
   isPending: boolean;
   onApprove: () => void;
+  onReject: () => void;
 }) {
   const statusColor =
     step.status === "APPROVED"
@@ -222,15 +303,27 @@ function StepRow({
       </Group>
       <Group gap="xs" wrap="nowrap" style={{ flexShrink: 0 }}>
         {isNext && step.status === "PENDING" && (
-          <Button
-            size="compact-sm"
-            color="edr-green"
-            leftSection={<Check size={14} />}
-            disabled={isPending}
-            onClick={onApprove}
-          >
-            Approve
-          </Button>
+          <>
+            <Button
+              size="compact-sm"
+              color="edr-green"
+              leftSection={<Check size={14} />}
+              disabled={isPending}
+              onClick={onApprove}
+            >
+              Approve
+            </Button>
+            <Button
+              size="compact-sm"
+              variant="light"
+              color="red"
+              leftSection={<X size={14} />}
+              disabled={isPending}
+              onClick={onReject}
+            >
+              Reject
+            </Button>
+          </>
         )}
         <Badge
           variant="light"
diff --git a/apps/edr-freight-web/backoffice/src/components/contracts/ContractClearanceReviewSection.tsx b/apps/edr-freight-web/backoffice/src/components/contracts/ContractClearanceReviewSection.tsx
index 36b18bbec..f2383b649 100644
--- a/apps/edr-freight-web/backoffice/src/components/contracts/ContractClearanceReviewSection.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/contracts/ContractClearanceReviewSection.tsx
@@ -630,6 +630,20 @@ function DocReviewCard({
                 </Button>
               </Tooltip>
             )}
+          {hasFile && (
+            <Tooltip label="Download">
+              <Button
+                component="a"
+                href={fileViewUrl(doc.file!.id, true)}
+                size="compact-xs"
+                variant="default"
+                radius="md"
+                leftSection={<Download size={13} />}
+              >
+                Download
+              </Button>
+            </Tooltip>
+          )}
         </Group>
       </Group>
 
diff --git a/apps/edr-freight-web/backoffice/src/components/contracts/ExportClearanceStepper.tsx b/apps/edr-freight-web/backoffice/src/components/contracts/ExportClearanceStepper.tsx
index db6e79430..dc59c4dfc 100644
--- a/apps/edr-freight-web/backoffice/src/components/contracts/ExportClearanceStepper.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/contracts/ExportClearanceStepper.tsx
@@ -646,7 +646,9 @@ function FinalInvoiceStep({
   const invoice = clearance.finalInvoice ?? null;
   const paid = invoice?.status === "PAID";
 
-  if (!clearance.offloaded && !invoice) {
+  // Export: OFFLOADED is a DJ doc milestone that may never be recorded, so the
+  // secured gate pass is enough to open invoicing. Sending an invoice is optional.
+  if (!clearance.offloaded && !clearance.gatepassGranted && !invoice) {
     return (
       <StepStatus
         done={false}
@@ -740,7 +742,7 @@ function FinalInvoiceStep({
       ) : canDjAct && bookingId ? (
         <>
           <Text size="sm" c="dimmed">
-            Cargo offloaded — send the final invoice to the customer.
+            Send the final invoice to the customer if post-arrival charges apply (optional).
           </Text>
           <Button
             color="edr-green"
diff --git a/apps/edr-freight-web/backoffice/src/components/contracts/GlCreateBookingForm.tsx b/apps/edr-freight-web/backoffice/src/components/contracts/GlCreateBookingForm.tsx
index 6f52d287f..547e9ce9f 100644
--- a/apps/edr-freight-web/backoffice/src/components/contracts/GlCreateBookingForm.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/contracts/GlCreateBookingForm.tsx
@@ -150,16 +150,19 @@ export default function GlCreateBookingForm() {
     [bookingWindows],
   );
 
-  // Soonest future window across all routes, used for the "next window" notice.
+  // Next future window across all routes, used for the "next window" notice —
+  // the train dispatching soonest among those not yet open, matching the
+  // departure-date ordering of the window cards.
   const nextWindow = useMemo(() => {
     const now = Date.now();
     return (bookingWindows ?? [])
       .filter((w) => w.windowOpensAt && new Date(w.windowOpensAt).getTime() > now)
-      .sort(
-        (a, b) =>
-          new Date(a.windowOpensAt!).getTime() -
-          new Date(b.windowOpensAt!).getTime(),
-      )[0];
+      .sort((a, b) => {
+        const da = a.departureDate ? new Date(a.departureDate).getTime() : Infinity;
+        const db = b.departureDate ? new Date(b.departureDate).getTime() : Infinity;
+        if (da !== db) return da - db;
+        return new Date(a.windowOpensAt!).getTime() - new Date(b.windowOpensAt!).getTime();
+      })[0];
   }, [bookingWindows]);
 
   const [scheduledDate, setScheduledDate] = useState("");
diff --git a/apps/edr-freight-web/backoffice/src/components/contracts/GlUpcomingWindowsSection.tsx b/apps/edr-freight-web/backoffice/src/components/contracts/GlUpcomingWindowsSection.tsx
index 6f21a50a2..c35537d9e 100644
--- a/apps/edr-freight-web/backoffice/src/components/contracts/GlUpcomingWindowsSection.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/contracts/GlUpcomingWindowsSection.tsx
@@ -21,7 +21,29 @@ import { CountdownTimer } from "@edr/ui-common";
 
 import { useBookingWindowSocket } from "@/features/bookingWindows/useBookingWindowSocket";
 import { api } from "@/services/api";
-import type { StaffBookingWindow } from "@/types/trainScheduling";
+
+/**
+ * The fields a window card needs. Structural so both `StaffBookingWindow`
+ * (all-lanes staff feed) and `BookingWindow` (contract-scoped feed, which
+ * carries no train number) satisfy it.
+ */
+interface WindowRow {
+  scheduleId: string;
+  reference?: string | null;
+  trainNumber?: string | null;
+  direction: string | null;
+  windowPhase: string | null;
+  isOpenNow: boolean;
+  windowOpensAt: string | null;
+  windowClosesAt: string | null;
+  docReviewEndsAt: string | null;
+  paymentPhaseEndsAt: string | null;
+  bookingWindowStatus: string;
+  bookingCycleNo: number;
+  departureDate: string;
+  origin: string | null;
+  destination: string | null;
+}
 
 /** All window times are communicated in East Africa Time. */
 const TZ = "Africa/Addis_Ababa";
@@ -46,7 +68,7 @@ function fmtTime(iso: string): string {
   });
 }
 
-function windowLabel(w: StaffBookingWindow): string {
+function windowLabel(w: WindowRow): string {
   if (w.windowOpensAt && w.windowClosesAt) {
     return `${fmtDay(w.windowOpensAt)} · ${fmtTime(w.windowOpensAt)} – ${fmtTime(
       w.windowClosesAt,
@@ -64,7 +86,7 @@ function windowLabel(w: StaffBookingWindow): string {
  * between refetches announces what comes next rather than the bare "Expired".
  */
 function phaseCountdown(
-  w: StaffBookingWindow,
+  w: WindowRow,
 ): { label: string; deadline: string; expiredText: string } | null {
   switch (w.windowPhase) {
     case "PRE_WINDOW":
@@ -104,19 +126,18 @@ function phaseCountdown(
   }
 }
 
-/** Drop windows whose booking window (or the train itself) has already passed. */
-function isPast(w: StaffBookingWindow): boolean {
-  const now = Date.now();
-  const closes = w.windowClosesAt ? new Date(w.windowClosesAt).getTime() : null;
-  const departs = w.departureDate ? new Date(w.departureDate).getTime() : null;
-  // Still live while in a post-close staff phase (doc review / payment).
-  if (w.windowPhase === "DOC_REVIEW" || w.windowPhase === "PAYMENT") return false;
-  if (departs != null && departs <= now) return true;
-  if (closes != null && closes <= now) return true;
-  return false;
+/**
+ * Drop windows the SERVER considers finished — keyed off windowPhase, never the
+ * client clock. The server query already excludes terminal / departed rows;
+ * comparing `Date.now()` here only re-introduced clock skew that made a card
+ * vanish and reappear on refresh. Trust the server phase (live-patched over the
+ * socket) instead.
+ */
+function isPast(w: WindowRow): boolean {
+  return w.windowPhase === "DONE" || w.windowPhase === "CLOSED_FOR_DAY";
 }
 
-function WindowCard({ w }: { w: StaffBookingWindow }) {
+function WindowCard({ w }: { w: WindowRow }) {
   const cd = phaseCountdown(w);
   const open = w.isOpenNow;
   const isImport = w.direction === "IMPORT";
@@ -175,6 +196,11 @@ function WindowCard({ w }: { w: StaffBookingWindow }) {
               {w.destination ?? "—"}
             </Text>
           </Group>
+          {w.reference ? (
+            <Text fz={12} fw={600} ff="monospace" c="edr-green.7" truncate>
+              {w.reference}
+            </Text>
+          ) : null}
           {w.trainNumber ? (
             <Text fz={12} c="dimmed" truncate>
               Train {w.trainNumber}
@@ -218,21 +244,45 @@ function WindowCard({ w }: { w: StaffBookingWindow }) {
   );
 }
 
+interface GlUpcomingWindowsSectionProps {
+  /**
+   * Scope the card to one contract: only windows on that contract's routes
+   * (and therefore its import/export direction) are shown. Omit for the
+   * all-lanes staff feed on the clearance queue.
+   */
+  contractId?: string;
+}
+
 /**
- * All announced booking windows (import cycles + export FCFS) across every lane,
- * shown to GL ET on the clearance queue as a paged carousel — three lanes per
- * page, arrows to flip. Mirrors the customer's portal "Booking Windows" card.
- * Hidden when nothing is pending.
+ * Announced booking windows (import cycles + export FCFS) as a paged carousel —
+ * three lanes per page, arrows to flip. Without `contractId` it shows every
+ * lane (GL ET clearance queue); with `contractId` it shows only the windows
+ * matching that contract's routes/direction (clearance detail page). Mirrors
+ * the customer's portal "Booking Windows" card. Hidden when nothing is pending.
  */
-export function GlUpcomingWindowsSection() {
+export function GlUpcomingWindowsSection({
+  contractId,
+}: GlUpcomingWindowsSectionProps = {}) {
   // Live pushes flip cards the moment the window engine transitions a phase;
   // the 60s poll below stays only as a fallback.
   useBookingWindowSocket();
-  const { data, isLoading } = useQuery(
-    api.trainScheduling.allBookingWindows.queryOptions({
+  const allLanes = useQuery({
+    ...api.trainScheduling.allBookingWindows.queryOptions({
       refetchInterval: 60_000,
     }),
-  );
+    enabled: !contractId,
+  });
+  const contractLanes = useQuery({
+    ...api.trainScheduling.contractBookingWindows.queryOptions({
+      input: { contractId: contractId ?? "" },
+      refetchInterval: 60_000,
+    }),
+    enabled: Boolean(contractId),
+  });
+  const data: WindowRow[] | undefined = contractId
+    ? contractLanes.data
+    : allLanes.data;
+  const isLoading = contractId ? contractLanes.isLoading : allLanes.isLoading;
   const [page, setPage] = useState(0);
 
   const windows = useMemo(() => {
@@ -241,13 +291,13 @@ export function GlUpcomingWindowsSection() {
     );
     // Canceled schedules are retired to windowPhase='DONE' server-side, so the
     // guard above already excludes them; they never reach the upcoming list.
-    // Open lanes first, then by opening time.
+    // Order by the train's dispatch (departure) date, nearest first. Open-now
+    // breaks ties on the same departure.
     return rows.sort((a, b) => {
-      const openDiff = Number(b.isOpenNow) - Number(a.isOpenNow);
-      if (openDiff !== 0) return openDiff;
-      const at = a.windowOpensAt ? new Date(a.windowOpensAt).getTime() : Infinity;
-      const bt = b.windowOpensAt ? new Date(b.windowOpensAt).getTime() : Infinity;
-      return at - bt;
+      const da = a.departureDate ? new Date(a.departureDate).getTime() : Infinity;
+      const db = b.departureDate ? new Date(b.departureDate).getTime() : Infinity;
+      if (da !== db) return da - db;
+      return Number(b.isOpenNow) - Number(a.isOpenNow);
     });
   }, [data]);
 
@@ -270,7 +320,9 @@ export function GlUpcomingWindowsSection() {
               Booking windows
             </Text>
             <Text fz={13} c="dimmed">
-              Import and export booking windows across all lanes (EAT)
+              {contractId
+                ? "Booking windows on this contract's routes (EAT)"
+                : "Import and export booking windows across all lanes (EAT)"}
             </Text>
           </Box>
         </Group>
diff --git a/apps/edr-freight-web/backoffice/src/components/contracts/PhasedClearanceActionPanel.tsx b/apps/edr-freight-web/backoffice/src/components/contracts/PhasedClearanceActionPanel.tsx
index 75e901d10..6256bd9cc 100644
--- a/apps/edr-freight-web/backoffice/src/components/contracts/PhasedClearanceActionPanel.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/contracts/PhasedClearanceActionPanel.tsx
@@ -727,9 +727,9 @@ function ImportT1UploadStep({
     );
   }
 
-  const departed = Boolean(t1.trainDepartedAt);
-  const canUpload =
-    canDjAct && t1.wagonAllocated && gatepassGranted && !departed && !t1.closed;
+  // Departure no longer locks T1 docs — GL DJ may replace them until GL Ethiopia
+  // closes/accepts the T1.
+  const canUpload = canDjAct && t1.wagonAllocated && gatepassGranted && !t1.closed;
 
   return (
     <Stack gap="sm">
@@ -769,10 +769,6 @@ function ImportT1UploadStep({
           pendingLabel="Waiting for the gate pass to be secured on the train schedule."
           doneLabel=""
         />
-      ) : departed ? (
-        <Alert color="orange" variant="light" icon={<AlertTriangle size={16} />}>
-          The train has departed — T1 documents are locked and can no longer be changed.
-        </Alert>
       ) : uploaded.length === 0 && !canUpload ? (
         <StepStatus
           done={false}
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 31c7efc52..5bd6a7527 100644
--- a/apps/edr-freight-web/backoffice/src/components/customers/badges.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/customers/badges.tsx
@@ -177,6 +177,7 @@ const BOOKING_STATUS_COLOR: Record<CustomerBookingStatus, string> = {
   APPROVED: "cyan",
   PAID: "edr-green",
   IN_TRANSIT: "blue",
+  ARRIVED: "teal",
   COMPLETED: "indigo",
   REJECTED: "red",
   CANCELLED: "red",
diff --git a/apps/edr-freight-web/backoffice/src/components/fleet/FleetFormDialog.tsx b/apps/edr-freight-web/backoffice/src/components/fleet/FleetFormDialog.tsx
index f314ab35e..7262e7927 100644
--- a/apps/edr-freight-web/backoffice/src/components/fleet/FleetFormDialog.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/fleet/FleetFormDialog.tsx
@@ -7,6 +7,7 @@ import {
   Group,
   Modal,
   NumberInput,
+  Radio,
   Select,
   MultiSelect,
   SimpleGrid,
@@ -293,6 +294,26 @@ const FleetFormDialog = ({
     // only by verification and never hand-edited.
     const isDisabled = Boolean(field.disabled || field.faydaLocked);
 
+    if (field.type === "radio") {
+      return (
+        <Radio.Group
+          key={field.name}
+          label={field.label}
+          value={value == null ? "" : String(value)}
+          onChange={(next) =>
+            setValues((current) => ({ ...current, [field.name]: next }))
+          }
+          error={error}
+        >
+          <Group gap="lg" mt={6}>
+            {(field.options ?? []).map((o) => (
+              <Radio key={o.value} value={o.value} label={o.label} disabled={isDisabled} />
+            ))}
+          </Group>
+        </Radio.Group>
+      );
+    }
+
     if (field.type === "select") {
       return (
         <Select
diff --git a/apps/edr-freight-web/backoffice/src/components/fleet/FleetRecordActions.tsx b/apps/edr-freight-web/backoffice/src/components/fleet/FleetRecordActions.tsx
index de010e380..887b235c4 100644
--- a/apps/edr-freight-web/backoffice/src/components/fleet/FleetRecordActions.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/fleet/FleetRecordActions.tsx
@@ -33,7 +33,9 @@ const FleetRecordActions = ({
   const isVehicle = config.slug === "vehicles";
   const showHistory =
     Boolean(onHistory) &&
-    (config.slug === "drivers" || config.slug === "vehicles");
+    (config.slug === "drivers" ||
+      config.slug === "vehicles" ||
+      config.slug === "wagons");
 
   const handleDetail = () => {
     if (!config.detailPath || !("id" in record)) return;
diff --git a/apps/edr-freight-web/backoffice/src/components/fleet/WagonMovementHistoryModal.tsx b/apps/edr-freight-web/backoffice/src/components/fleet/WagonMovementHistoryModal.tsx
new file mode 100644
index 000000000..e2713fdcb
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/components/fleet/WagonMovementHistoryModal.tsx
@@ -0,0 +1,133 @@
+import type { ReactNode } from "react";
+import { Badge, Center, Group, Loader, Modal, Text, Timeline } from "@mantine/core";
+import { useQuery } from "@tanstack/react-query";
+import { ArrowRight, PackageCheck, TrainFront, Wrench } from "lucide-react";
+
+import { api } from "@/services/api";
+import type { FleetRecord } from "@/services/fleet/fleet.service";
+import type { WagonMovementRecord } from "@/services/wagon.service";
+
+export interface WagonMovementHistoryModalProps {
+  opened: boolean;
+  onClose: () => void;
+  record: FleetRecord | null;
+}
+
+const asObj = (r: FleetRecord | null) => (r ?? {}) as Record<string, unknown>;
+
+/** Chip style per wagon_movements ledger kind. */
+const KIND_META: Record<string, { label: string; color: string; icon: ReactNode }> = {
+  LOADED: {
+    label: "Loaded leg",
+    color: "edr-green",
+    icon: <PackageCheck size={14} />,
+  },
+  EMPTY_REPOSITION: {
+    label: "Empty reposition",
+    color: "blue",
+    icon: <TrainFront size={14} />,
+  },
+  MANUAL: {
+    label: "Manual move",
+    color: "orange",
+    icon: <Wrench size={14} />,
+  },
+};
+
+const yardLabel = (
+  yard: { label?: string; code?: string } | null | undefined,
+  yardId: string | null,
+) => yard?.label ?? yard?.code ?? yardId ?? "Unknown";
+
+const fmt = (iso: string) => {
+  const d = new Date(iso);
+  return Number.isNaN(d.getTime()) ? iso : d.toLocaleString();
+};
+
+/**
+ * Movement ledger for one wagon: every relocation between yards — booking legs,
+ * empty reposition rides, and manual staff corrections — newest first.
+ */
+const WagonMovementHistoryModal = ({
+  opened,
+  onClose,
+  record,
+}: WagonMovementHistoryModalProps) => {
+  const r = asObj(record);
+  const id = r.id ? String(r.id) : "";
+  const wagonNumber = r.wagonNumber ? String(r.wagonNumber) : "";
+
+  const { data, isLoading } = useQuery(
+    api.wagons.movements.queryOptions({
+      input: { id },
+      enabled: opened && Boolean(id),
+    }),
+  );
+
+  const movements: WagonMovementRecord[] = data ?? [];
+
+  return (
+    <Modal
+      opened={opened}
+      onClose={onClose}
+      title={<Text fw={600}>{`Wagon history — ${wagonNumber}`.trim()}</Text>}
+      radius="lg"
+      size="lg"
+      centered
+    >
+      {isLoading ? (
+        <Center py="xl">
+          <Loader size="sm" />
+        </Center>
+      ) : movements.length === 0 ? (
+        <Text c="dimmed" ta="center" py="lg" size="sm">
+          No movements recorded yet. Every yard-to-yard move appears here — a
+          booking's loaded leg, an empty reposition ride, or a manual correction.
+        </Text>
+      ) : (
+        <Timeline active={movements.length} bulletSize={24} lineWidth={2}>
+          {movements.map((movement) => {
+            const meta = KIND_META[movement.kind] ?? {
+              label: movement.kind,
+              color: "gray",
+              icon: <TrainFront size={14} />,
+            };
+            const from = yardLabel(movement.fromYard, movement.fromYardId);
+            const to = yardLabel(movement.toYard, movement.toYardId);
+            return (
+              <Timeline.Item
+                key={movement.id}
+                bullet={meta.icon}
+                title={
+                  <Group gap={6} wrap="nowrap">
+                    <Text size="sm" fw={600}>
+                      {from}
+                    </Text>
+                    <ArrowRight size={13} />
+                    <Text size="sm" fw={600}>
+                      {to}
+                    </Text>
+                    <Badge size="xs" variant="light" color={meta.color}>
+                      {meta.label}
+                    </Badge>
+                  </Group>
+                }
+              >
+                {movement.note && (
+                  <Text size="sm" c="dimmed">
+                    {movement.note}
+                  </Text>
+                )}
+                <Text size="xs" mt={4} c="dimmed">
+                  {fmt(movement.occurredAt)}
+                </Text>
+              </Timeline.Item>
+            );
+          })}
+        </Timeline>
+      )}
+    </Modal>
+  );
+};
+
+export default WagonMovementHistoryModal;
diff --git a/apps/edr-freight-web/backoffice/src/components/operations/TruckDetentionModal.tsx b/apps/edr-freight-web/backoffice/src/components/operations/TruckDetentionModal.tsx
new file mode 100644
index 000000000..2088db32d
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/components/operations/TruckDetentionModal.tsx
@@ -0,0 +1,245 @@
+import {
+  Alert,
+  Badge,
+  Button,
+  Divider,
+  Group,
+  Loader,
+  Modal,
+  Paper,
+  Stack,
+  Table,
+  Text,
+} from '@mantine/core';
+import { DateTimePicker } from '@mantine/dates';
+import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
+import { Receipt } from 'lucide-react';
+import { useEffect, useState } from 'react';
+
+import { QUERY_KEYS } from '@/constants/QUERY_KEYS';
+import { useToast } from '@/hooks/use-toast';
+import { lastMileService, type LastMileRecord } from '@/services/last-mile.service';
+
+interface TruckDetentionModalProps {
+  opened: boolean;
+  onClose: () => void;
+  record: LastMileRecord | null;
+}
+
+const money = (amount: number, currency: string) =>
+  `${Number(amount).toLocaleString()} ${currency === 'ETB' ? 'Birr (ETB)' : currency}`;
+
+function Stat({ label, value, strong }: { label: string; value: React.ReactNode; strong?: boolean }) {
+  return (
+    <Paper withBorder p="sm" radius="md" style={{ flex: 1, minWidth: 120 }}>
+      <Text size="xs" c="dimmed" tt="uppercase" fw={600}>
+        {label}
+      </Text>
+      <Text size={strong ? 'lg' : 'md'} fw={strong ? 800 : 600}>
+        {value}
+      </Text>
+    </Paper>
+  );
+}
+
+/**
+ * View/override the detention clock (arrival + delivery/return) for a last-mile
+ * leg, preview the per-truck-per-day charge, and generate the detention invoice.
+ */
+export function TruckDetentionModal({ opened, onClose, record }: TruckDetentionModalProps) {
+  const { toast } = useToast();
+  const qc = useQueryClient();
+  const id = record?.id ?? null;
+  const [arrived, setArrived] = useState<Date | null>(null);
+  const [delivered, setDelivered] = useState<Date | null>(null);
+
+  useEffect(() => {
+    setArrived(record?.arrivedAt ? new Date(record.arrivedAt) : null);
+    setDelivered(record?.deliveredAt ? new Date(record.deliveredAt) : null);
+  }, [record?.id, record?.arrivedAt, record?.deliveredAt, opened]);
+
+  const previewQuery = useQuery({
+    queryKey: ['truck-detention-preview', id],
+    queryFn: async () => (await lastMileService.truckDetentionPreview(id as string)).data,
+    enabled: opened && Boolean(id),
+  });
+  const preview = previewQuery.data;
+
+  const saveTimes = useMutation({
+    mutationFn: () =>
+      lastMileService.update(id as string, {
+        arrivedAt: arrived ? arrived.toISOString() : null,
+        deliveredAt: delivered ? delivered.toISOString() : null,
+      }),
+    onSuccess: () => {
+      void qc.invalidateQueries({ queryKey: QUERY_KEYS.LAST_MILE.ROOT });
+      void previewQuery.refetch();
+      toast({ title: 'Detention times saved' });
+    },
+    onError: () => toast({ title: 'Save failed', variant: 'destructive' }),
+  });
+
+  const generate = useMutation({
+    mutationFn: () => lastMileService.generateTruckDetentionInvoice(id as string),
+    onSuccess: () => {
+      void qc.invalidateQueries({ queryKey: QUERY_KEYS.LAST_MILE.ROOT });
+      toast({ title: 'Truck detention invoice generated' });
+      onClose();
+    },
+    onError: (e: unknown) => {
+      const description = (e as { response?: { data?: { message?: string } } })?.response?.data?.message;
+      toast({ title: 'Detention invoice failed', description, variant: 'destructive' });
+    },
+  });
+
+  return (
+    <Modal
+      opened={opened}
+      onClose={onClose}
+      centered
+      size="lg"
+      title={
+        <Text fw={700}>
+          Truck detention{record?.booking?.reference ? ` · ${record.booking.reference}` : ''}
+        </Text>
+      }
+    >
+      <Stack gap="md">
+        <Group grow align="flex-start">
+          <DateTimePicker
+            label="Arrived at"
+            description="Detention clock start"
+            value={arrived}
+            onChange={(v) => setArrived(v ? new Date(v) : null)}
+            clearable
+          />
+          <DateTimePicker
+            label="Delivered / returned at"
+            description="Clock end (blank = still out)"
+            value={delivered}
+            onChange={(v) => setDelivered(v ? new Date(v) : null)}
+            clearable
+          />
+        </Group>
+        <Group justify="flex-end">
+          <Button variant="light" loading={saveTimes.isPending} onClick={() => saveTimes.mutate()}>
+            Save times
+          </Button>
+        </Group>
+
+        <Divider label="Detention preview" labelPosition="left" />
+
+        {previewQuery.isLoading ? (
+          <Group justify="center" py="md">
+            <Loader />
+          </Group>
+        ) : !preview ? (
+          <Alert color="gray" variant="light">
+            No preview available.
+          </Alert>
+        ) : !preview.ruleId ? (
+          <Alert color="orange" variant="light">
+            No active Truck Detention rule matches this booking. Create one under Warehouse → Fee rules
+            (rule type "Truck Detention Cost").
+          </Alert>
+        ) : (
+          <Stack gap="sm">
+            <Group grow>
+              <Stat label="Chargeable days" value={preview.chargeableDays} />
+              <Stat label="Trucks" value={preview.containerCount} />
+              <Stat label="Amount" value={money(preview.amount, preview.currency)} strong />
+            </Group>
+            {preview.endIsOpen && (
+              <Text size="xs" c="orange">
+                Still accruing — no delivery/return time yet. The amount grows until the vehicle is returned.
+              </Text>
+            )}
+            {preview.groups && preview.groups.length > 1 ? (
+              <Table withTableBorder withColumnBorders verticalSpacing="xs" fz="xs">
+                <Table.Thead>
+                  <Table.Tr>
+                    <Table.Th>Truck type</Table.Th>
+                    <Table.Th>Trucks</Table.Th>
+                    <Table.Th>Days</Table.Th>
+                    <Table.Th ta="right">Rate / truck / day</Table.Th>
+                    <Table.Th ta="right">Amount</Table.Th>
+                  </Table.Tr>
+                </Table.Thead>
+                <Table.Tbody>
+                  {preview.groups.map((g, i) => (
+                    <Table.Tr key={i}>
+                      <Table.Td>
+                        {g.vehicleType ?? 'Unknown'}
+                        {!g.ruleId && (
+                          <Text span size="xs" c="red">
+                            {' '}· no rule
+                          </Text>
+                        )}
+                      </Table.Td>
+                      <Table.Td>{g.truckCount}</Table.Td>
+                      <Table.Td>{g.chargeableDays}</Table.Td>
+                      <Table.Td ta="right">{money(g.ratePerDay, preview.currency)}</Table.Td>
+                      <Table.Td ta="right">{money(g.amount, preview.currency)}</Table.Td>
+                    </Table.Tr>
+                  ))}
+                </Table.Tbody>
+              </Table>
+            ) : preview.tiers && preview.tiers.length > 0 ? (
+              <Table withTableBorder withColumnBorders verticalSpacing="xs" fz="xs">
+                <Table.Thead>
+                  <Table.Tr>
+                    <Table.Th>From day</Table.Th>
+                    <Table.Th>To day</Table.Th>
+                    <Table.Th>Days</Table.Th>
+                    <Table.Th ta="right">Rate / truck / day</Table.Th>
+                    <Table.Th ta="right">Amount</Table.Th>
+                  </Table.Tr>
+                </Table.Thead>
+                <Table.Tbody>
+                  {preview.tiers.map((t, i) => (
+                    <Table.Tr key={i}>
+                      <Table.Td>{t.appliedFromDay}</Table.Td>
+                      <Table.Td>{t.appliedToDay}</Table.Td>
+                      <Table.Td>{t.days}</Table.Td>
+                      <Table.Td ta="right">{money(t.ratePerDay, preview.currency)}</Table.Td>
+                      <Table.Td ta="right">{money(t.amount, preview.currency)}</Table.Td>
+                    </Table.Tr>
+                  ))}
+                </Table.Tbody>
+              </Table>
+            ) : (
+              <Text size="sm" c="dimmed">
+                Flat {money(preview.ratePerDay, preview.currency)} per truck per day after the grace window.
+              </Text>
+            )}
+            <Group gap="xs">
+              <Badge variant="light" color="gray">
+                {preview.ruleName ?? 'Detention rule'}
+              </Badge>
+              {preview.billableUnits > 0 && (
+                <Text size="xs" c="dimmed">
+                  {preview.billableUnits} billable truck-day(s)
+                </Text>
+              )}
+            </Group>
+          </Stack>
+        )}
+
+        <Group justify="flex-end" mt="sm">
+          <Button variant="default" onClick={onClose}>
+            Close
+          </Button>
+          <Button
+            color="edr-green"
+            leftSection={<Receipt size={16} />}
+            disabled={!preview || preview.amount <= 0}
+            loading={generate.isPending}
+            onClick={() => generate.mutate()}
+          >
+            Generate invoice
+          </Button>
+        </Group>
+      </Stack>
+    </Modal>
+  );
+}
diff --git a/apps/edr-freight-web/backoffice/src/components/trainScheduling/PriorityTrackingTab.tsx b/apps/edr-freight-web/backoffice/src/components/trainScheduling/PriorityTrackingTab.tsx
new file mode 100644
index 000000000..0271d199c
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/components/trainScheduling/PriorityTrackingTab.tsx
@@ -0,0 +1,557 @@
+import { useMemo } from "react";
+import {
+  Box,
+  Group,
+  Paper,
+  Progress,
+  Stack,
+  Text,
+  ThemeIcon,
+  Tooltip,
+} from "@mantine/core";
+import {
+  Boxes,
+  CheckCircle2,
+  Clock,
+  Container,
+  Crown,
+  Hourglass,
+  Layers,
+  ListOrdered,
+  TrainFront,
+  Trophy,
+  XCircle,
+} from "lucide-react";
+import { CountdownTimer } from "@edr/ui-common";
+
+import type {
+  BatchBoardBookingDetail,
+  BatchBoardBookingState,
+  BatchBoardScheduleDetail,
+} from "@/types/trainScheduling";
+import { WindowPhasePill } from "./batchVisuals";
+
+/**
+ * Priority Tracking tab — live, glanceable ranking of every booking on this
+ * schedule in the exact order the batch engine boards them (government first,
+ * then rule-engine priority score, then oldest). Bookings above the train's
+ * wagon-capacity line render as "selected" (green), below it as the waiting
+ * list; during the PAYMENT phase selected bookings show a live pay-window
+ * countdown. Purely presentational — data comes from the batch-board detail
+ * response the page already polls (+ socket-invalidates).
+ */
+
+type Props = {
+  data: BatchBoardScheduleDetail;
+  bookings: BatchBoardBookingDetail[];
+};
+
+const STATE_STYLE: Record<
+  BatchBoardBookingState,
+  { label: string; color: string; icon: typeof CheckCircle2 }
+> = {
+  ALLOCATED: { label: "Allocated", color: "edr-green", icon: CheckCircle2 },
+  SELECTED_FOR_BATCH: { label: "Selected · pay now", color: "orange", icon: Clock },
+  READY: { label: "Ready", color: "teal", icon: Hourglass },
+  WAITING: { label: "Paid · waiting slot", color: "blue", icon: Hourglass },
+  PENDING_CONTRACT: { label: "Pending contract", color: "gray", icon: Hourglass },
+  EXPIRED: { label: "Expired", color: "red", icon: XCircle },
+};
+
+/** States that occupy a wagon slot on this train (i.e. are "in" the batch). */
+const OCCUPIES_SLOT: BatchBoardBookingState[] = [
+  "ALLOCATED",
+  "SELECTED_FOR_BATCH",
+  "WAITING",
+];
+
+const cardVar = (color: string, shade: number) =>
+  `var(--mantine-color-${color}-${shade})`;
+
+/** Highest score across the ranked pool → used to scale the priority mini-bar. */
+function maxScore(bookings: BatchBoardBookingDetail[]): number {
+  return bookings.reduce((m, b) => Math.max(m, b.priorityScore ?? 0), 0);
+}
+
+function FreightIcon({ type }: { type: string | null }) {
+  const Icon = type === "BULK" ? Boxes : Container;
+  return (
+    <Tooltip label={type === "BULK" ? "Bulk" : "Container"} withArrow>
+      <ThemeIcon size="sm" radius="sm" variant="light" color="gray">
+        <Icon size={13} />
+      </ThemeIcon>
+    </Tooltip>
+  );
+}
+
+/** One ranked booking row rendered as a card, colored by its batch state. */
+function RankedCard({
+  rank,
+  booking,
+  scoreMax,
+  phase,
+  isPayPhase,
+}: {
+  rank: number;
+  booking: BatchBoardBookingDetail;
+  scoreMax: number;
+  phase: string | null;
+  isPayPhase: boolean;
+}) {
+  const style = STATE_STYLE[booking.state];
+  const Icon = style.icon;
+  const selected = booking.state === "SELECTED_FOR_BATCH";
+  const allocated = booking.state === "ALLOCATED";
+  const expired = booking.state === "EXPIRED";
+  // Green surface for the winners (allocated + selected); muted for the rest.
+  const surfaceColor = allocated
+    ? "edr-green"
+    : selected
+      ? "edr-green"
+      : expired
+        ? "red"
+        : "gray";
+  const scorePct =
+    scoreMax > 0 ? Math.max(4, Math.round((booking.priorityScore / scoreMax) * 100)) : 0;
+
+  return (
+    <Paper
+      radius="md"
+      p="sm"
+      withBorder
+      style={{
+        borderColor: cardVar(surfaceColor, allocated || selected ? 4 : 2),
+        background:
+          allocated || selected
+            ? `linear-gradient(90deg, ${cardVar("edr-green", 0)} 0%, var(--mantine-color-white) 60%)`
+            : expired
+              ? cardVar("red", 0)
+              : "var(--mantine-color-white)",
+        opacity: expired ? 0.72 : 1,
+        transition: "background 200ms ease, border-color 200ms ease",
+      }}
+    >
+      <Group justify="space-between" wrap="nowrap" gap="sm">
+        <Group wrap="nowrap" gap="sm" style={{ minWidth: 0 }}>
+          {/* Rank medallion */}
+          <ThemeIcon
+            size={34}
+            radius="xl"
+            variant={rank <= 3 ? "filled" : "light"}
+            color={
+              booking.isGovernment
+                ? "grape"
+                : rank <= 3
+                  ? "edr-green"
+                  : "gray"
+            }
+            style={{ flexShrink: 0, fontWeight: 800 }}
+          >
+            {booking.isGovernment ? (
+              <Crown size={16} />
+            ) : (
+              <Text fw={800} size="sm">
+                {rank}
+              </Text>
+            )}
+          </ThemeIcon>
+
+          <Stack gap={2} style={{ minWidth: 0 }}>
+            <Group gap={6} wrap="nowrap">
+              <Text fw={700} size="sm" truncate>
+                {booking.reference}
+              </Text>
+              <FreightIcon type={booking.freightType} />
+              {booking.isGovernment ? (
+                <Tooltip label="Government — boards first" withArrow>
+                  <ThemeIcon size="xs" radius="sm" variant="light" color="grape">
+                    <Crown size={11} />
+                  </ThemeIcon>
+                </Tooltip>
+              ) : null}
+            </Group>
+            <Text size="xs" c="dimmed" truncate>
+              {booking.company}
+            </Text>
+          </Stack>
+        </Group>
+
+        <Group wrap="nowrap" gap="lg" style={{ flexShrink: 0 }}>
+          {/* Priority score with a mini strength bar */}
+          <Tooltip
+            label={`Priority score ${booking.priorityScore}${booking.isGovernment ? " + government bonus" : ""}`}
+            withArrow
+          >
+            <Stack gap={2} align="flex-end" w={92}>
+              <Group gap={4} wrap="nowrap">
+                <Trophy size={12} color={cardVar("edr-green", 6)} />
+                <Text fw={800} size="sm" c="edr-green.7">
+                  {booking.priorityScore}
+                </Text>
+              </Group>
+              <Progress
+                value={scorePct}
+                size="xs"
+                color="edr-green"
+                w={92}
+                radius="xl"
+              />
+            </Stack>
+          </Tooltip>
+
+          {/* Wagons */}
+          <Group gap={4} wrap="nowrap" w={58} justify="flex-end">
+            <TrainFront size={13} color={cardVar("gray", 6)} />
+            <Text fw={700} size="sm">
+              {booking.wagons}w
+            </Text>
+          </Group>
+
+          {/* State chip / pay countdown */}
+          <Box w={168} style={{ textAlign: "right" }}>
+            {selected && isPayPhase && booking.paymentDeadline ? (
+              <CountdownTimer
+                deadline={booking.paymentDeadline}
+                label="Pay in"
+                expiredText="Window closed"
+                size="sm"
+              />
+            ) : (
+              <Group gap={5} justify="flex-end" wrap="nowrap">
+                <ThemeIcon
+                  size="sm"
+                  radius="sm"
+                  variant="light"
+                  color={style.color}
+                >
+                  <Icon size={12} />
+                </ThemeIcon>
+                <Text size="xs" fw={600} c={`${style.color}.7`}>
+                  {style.label}
+                </Text>
+              </Group>
+            )}
+          </Box>
+        </Group>
+      </Group>
+      {/* phase hint only used for the a11y title; keeps `phase` referenced */}
+      <span hidden aria-hidden>
+        {phase}
+      </span>
+    </Paper>
+  );
+}
+
+/** The capacity cut line drawn between "in the batch" and "waiting list". */
+function CapacityDivider({ used, max }: { used: number; max: number | null }) {
+  const full = max != null && used >= max;
+  return (
+    <Group gap="xs" my={4} wrap="nowrap">
+      <Box style={{ flex: 1, height: 2, background: cardVar("orange", 3) }} />
+      <Group gap={6} wrap="nowrap">
+        <ThemeIcon size="sm" radius="xl" variant="light" color="orange">
+          <Layers size={12} />
+        </ThemeIcon>
+        <Text size="xs" fw={700} c="orange.7">
+          Capacity line{max != null ? ` · ${used}/${max} wagons` : ` · ${used} wagons`}
+          {full ? " · FULL" : ""}
+        </Text>
+      </Group>
+      <Box style={{ flex: 1, height: 2, background: cardVar("orange", 3) }} />
+    </Group>
+  );
+}
+
+export function PriorityTrackingTab({ data, bookings }: Props) {
+  const phase = data.windowPhase;
+  const isPayPhase = phase === "PAYMENT";
+
+  // Rank exactly as the batch engine does: government first, then priority score
+  // desc, then oldest (fullyExecutedAt / selectedForBatchAt as the tiebreak the
+  // backend uses). The board already returns them in this order, but re-sort
+  // defensively so the tab is correct even if the source order ever changes.
+  const ranked = useMemo(() => {
+    const time = (b: BatchBoardBookingDetail) =>
+      b.fullyExecutedAt ? new Date(b.fullyExecutedAt).getTime() : Number.MAX_SAFE_INTEGER;
+    return [...bookings].sort((a, b) => {
+      if (a.isGovernment !== b.isGovernment) return a.isGovernment ? -1 : 1;
+      if (b.priorityScore !== a.priorityScore) return b.priorityScore - a.priorityScore;
+      return time(a) - time(b);
+    });
+  }, [bookings]);
+
+  const scoreMax = useMemo(() => maxScore(ranked), [ranked]);
+  // maxWagons is not on the board DTO (capacity is length/weight-based), so the
+  // capacity line shows the wagons currently committed rather than a hard cap.
+  const maxWagons: number | null = null;
+
+  // Split the ranking at the capacity line: cumulative wagons of slot-occupying
+  // bookings (allocated + selected + paid-waiting) up to the train's wagon cap.
+  const capUsed = useMemo(
+    () =>
+      ranked
+        .filter((b) => OCCUPIES_SLOT.includes(b.state))
+        .reduce((sum, b) => sum + b.wagons, 0),
+    [ranked],
+  );
+
+  // Group for the lane layout.
+  const lanes = useMemo(() => {
+    const inBatch = ranked.filter((b) => OCCUPIES_SLOT.includes(b.state));
+    const waiting = ranked.filter(
+      (b) => b.state === "READY" || b.state === "PENDING_CONTRACT",
+    );
+    const expired = ranked.filter((b) => b.state === "EXPIRED");
+    return { inBatch, waiting, expired };
+  }, [ranked]);
+
+  if (ranked.length === 0) {
+    return (
+      <Paper radius="lg" withBorder p="xl">
+        <Group justify="center" gap="sm">
+          <ThemeIcon variant="light" color="gray" radius="xl" size="lg">
+            <ListOrdered size={18} />
+          </ThemeIcon>
+          <Text c="dimmed">No bookings on this schedule yet.</Text>
+        </Group>
+      </Paper>
+    );
+  }
+
+  let rankNo = 0;
+
+  return (
+    <Stack gap="lg">
+      {/* Header: phase + capacity meter */}
+      <Paper radius="lg" withBorder p="lg">
+        <Group justify="space-between" wrap="wrap" gap="md">
+          <Group gap="sm">
+            <ThemeIcon variant="light" color="edr-green" radius="md" size="lg">
+              <Trophy size={18} />
+            </ThemeIcon>
+            <Stack gap={2}>
+              <Text fw={700}>Priority ranking</Text>
+              <Text size="xs" c="dimmed">
+                Government first, then rule-engine score, then earliest booked.
+              </Text>
+            </Stack>
+          </Group>
+          <Group gap="md">
+            {phase ? (
+              <WindowPhasePill phase={phase} cycleNo={data.bookingCycleNo} />
+            ) : null}
+            {isPayPhase && data.paymentPhaseEndsAt ? (
+              <CountdownTimer
+                deadline={data.paymentPhaseEndsAt}
+                label="Payment window"
+                expiredText="Window closed"
+                size="md"
+              />
+            ) : phase === "DOC_REVIEW" && data.docReviewEndsAt ? (
+              <CountdownTimer
+                deadline={data.docReviewEndsAt}
+                label="Doc review ends"
+                expiredText="Review over"
+                size="md"
+              />
+            ) : phase === "OPEN" && data.windowClosesAt ? (
+              <CountdownTimer
+                deadline={data.windowClosesAt}
+                label="Booking closes"
+                expiredText="Closed"
+                size="md"
+              />
+            ) : null}
+          </Group>
+        </Group>
+
+        {/* Capacity meter */}
+        <Box mt="md">
+          <Group justify="space-between" mb={4}>
+            <Text size="xs" c="dimmed" fw={600}>
+              Wagon capacity used
+            </Text>
+            <Text size="xs" fw={700}>
+              {data.capacity.allocatedWagons} allocated ·{" "}
+              {capUsed} in batch
+            </Text>
+          </Group>
+          <Progress.Root size="lg" radius="xl">
+            <Progress.Section
+              value={
+                capUsed > 0
+                  ? Math.min(100, (data.capacity.allocatedWagons / capUsed) * 100)
+                  : 0
+              }
+              color="edr-green"
+            />
+            <Progress.Section
+              value={
+                capUsed > 0
+                  ? Math.min(
+                      100,
+                      ((capUsed - data.capacity.allocatedWagons) / capUsed) * 100,
+                    )
+                  : 0
+              }
+              color="orange"
+            />
+          </Progress.Root>
+        </Box>
+      </Paper>
+
+      {/* Phase banner explaining what's happening now */}
+      <PhaseBanner phase={phase} />
+
+      {/* IN THE BATCH (green winners) — ranked */}
+      {lanes.inBatch.length > 0 ? (
+        <Stack gap={6}>
+          <Group gap="xs">
+            <ThemeIcon size="sm" radius="sm" variant="light" color="edr-green">
+              <CheckCircle2 size={13} />
+            </ThemeIcon>
+            <Text fw={700} size="sm">
+              In the batch{" "}
+              <Text span c="dimmed" fw={500}>
+                ({lanes.inBatch.length})
+              </Text>
+            </Text>
+          </Group>
+          {lanes.inBatch.map((b) => {
+            rankNo += 1;
+            return (
+              <RankedCard
+                key={b.id}
+                rank={rankNo}
+                booking={b}
+                scoreMax={scoreMax}
+                phase={phase}
+                isPayPhase={isPayPhase}
+              />
+            );
+          })}
+        </Stack>
+      ) : null}
+
+      <CapacityDivider used={capUsed} max={maxWagons} />
+
+      {/* WAITING LIST — ranked, below the line */}
+      {lanes.waiting.length > 0 ? (
+        <Stack gap={6}>
+          <Group gap="xs">
+            <ThemeIcon size="sm" radius="sm" variant="light" color="blue">
+              <Hourglass size={13} />
+            </ThemeIcon>
+            <Text fw={700} size="sm">
+              Waiting list{" "}
+              <Text span c="dimmed" fw={500}>
+                ({lanes.waiting.length}) — next in line if a slot frees up
+              </Text>
+            </Text>
+          </Group>
+          {lanes.waiting.map((b) => {
+            rankNo += 1;
+            return (
+              <RankedCard
+                key={b.id}
+                rank={rankNo}
+                booking={b}
+                scoreMax={scoreMax}
+                phase={phase}
+                isPayPhase={isPayPhase}
+              />
+            );
+          })}
+        </Stack>
+      ) : null}
+
+      {/* EXPIRED */}
+      {lanes.expired.length > 0 ? (
+        <Stack gap={6}>
+          <Group gap="xs">
+            <ThemeIcon size="sm" radius="sm" variant="light" color="red">
+              <XCircle size={13} />
+            </ThemeIcon>
+            <Text fw={700} size="sm" c="red.7">
+              Expired{" "}
+              <Text span c="dimmed" fw={500}>
+                ({lanes.expired.length}) — missed the payment window
+              </Text>
+            </Text>
+          </Group>
+          {lanes.expired.map((b) => (
+            <RankedCard
+              key={b.id}
+              rank={0}
+              booking={b}
+              scoreMax={scoreMax}
+              phase={phase}
+              isPayPhase={isPayPhase}
+            />
+          ))}
+        </Stack>
+      ) : null}
+    </Stack>
+  );
+}
+
+/** Contextual banner describing the current window phase in plain language. */
+function PhaseBanner({ phase }: { phase: string | null }) {
+  const meta: Record<string, { color: string; text: string; icon: typeof Clock }> = {
+    OPEN: {
+      color: "edr-green",
+      icon: Clock,
+      text: "Booking window OPEN — new bookings are ranked live as they arrive and get accepted.",
+    },
+    DOC_REVIEW: {
+      color: "yellow",
+      icon: Hourglass,
+      text: "Document review — staff accept/reject; un-accepted bookings expire when review ends, then the batch runs.",
+    },
+    PAYMENT: {
+      color: "blue",
+      icon: Clock,
+      text: "Payment window — selected bookings must pay before their countdown ends; unpaid slots pass to the waiting list.",
+    },
+    PRE_WINDOW: {
+      color: "gray",
+      icon: Hourglass,
+      text: "Window not open yet — bookings are pre-ranked and will compete when it opens.",
+    },
+    CLOSED_FOR_DAY: {
+      color: "gray",
+      icon: Hourglass,
+      text: "Window closed for the day — reopens for the next cycle if the train isn't full.",
+    },
+    DONE: {
+      color: "gray",
+      icon: CheckCircle2,
+      text: "Booking cycles finished for this train.",
+    },
+  };
+  const m = phase ? meta[phase] : null;
+  if (!m) return null;
+  const Icon = m.icon;
+  return (
+    <Paper
+      radius="md"
+      p="sm"
+      withBorder
+      style={{
+        background: cardVar(m.color, 0),
+        borderColor: cardVar(m.color, 2),
+      }}
+    >
+      <Group gap="sm" wrap="nowrap">
+        <ThemeIcon variant="light" color={m.color} radius="md">
+          <Icon size={16} />
+        </ThemeIcon>
+        <Text size="sm" fw={500} c={`${m.color}.8`}>
+          {m.text}
+        </Text>
+      </Group>
+    </Paper>
+  );
+}
+
+export default PriorityTrackingTab;
diff --git a/apps/edr-freight-web/backoffice/src/components/trainScheduling/YardWorkPanel.tsx b/apps/edr-freight-web/backoffice/src/components/trainScheduling/YardWorkPanel.tsx
new file mode 100644
index 000000000..76ccdfde2
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/components/trainScheduling/YardWorkPanel.tsx
@@ -0,0 +1,333 @@
+import {
+  Alert,
+  Badge,
+  Button,
+  Divider,
+  Group,
+  Loader,
+  Paper,
+  Stack,
+  Table,
+  Text,
+  Tooltip,
+} from "@mantine/core";
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import { AlertCircle, MapPin, PackageCheck, PackageOpen, TrainFront } from "lucide-react";
+import { Freight } from "@edr/types";
+
+import { api } from "@/services/api";
+import { useToast } from "@/hooks/use-toast";
+import { BookingStatusBadge } from "@/components/bookings/BookingStatusBadge";
+import type { YardWorkBookingRow, YardWorkYard } from "@/types/trainScheduling";
+
+const parseError = (error: unknown, fallback: string) => {
+  const message = (error as { response?: { data?: { message?: string | string[] } } })
+    ?.response?.data?.message;
+  if (Array.isArray(message)) return message.join("; ");
+  return message || (error as Error)?.message || fallback;
+};
+
+const fmtDate = (iso: string) => {
+  const d = new Date(iso);
+  return Number.isNaN(d.getTime()) ? iso : d.toLocaleString();
+};
+
+const DIRECTION_COLORS: Record<string, string> = {
+  IMPORT: "blue",
+  EXPORT: "teal",
+  DOMESTIC: "violet",
+};
+
+/** DOMESTIC displays as "Intercity" — shared with the rest of the platform. */
+const DIRECTION_LABELS: Record<string, string> = Freight.TRADE_DIRECTION_LABELS;
+
+function DirectionChip({ direction }: { direction: string }) {
+  return (
+    <Badge size="sm" variant="light" color={DIRECTION_COLORS[direction] ?? "gray"}>
+      {DIRECTION_LABELS[direction] ?? direction}
+    </Badge>
+  );
+}
+
+function BookingCell({ row }: { row: YardWorkBookingRow }) {
+  return (
+    <Group gap={6} wrap="nowrap">
+      <Text size="sm" fw={600}>
+        {row.reference ?? row.id.slice(0, 8)}
+      </Text>
+      {row.isGovernment && (
+        <Badge size="xs" variant="light" color="grape">
+          GOV
+        </Badge>
+      )}
+    </Group>
+  );
+}
+
+function WorkTable({
+  rows,
+  side,
+  trainHere,
+  onLoad,
+  onUnload,
+  pendingBookingId,
+}: {
+  rows: YardWorkBookingRow[];
+  side: "load" | "unload";
+  trainHere: boolean;
+  onLoad: (bookingId: string) => void;
+  onUnload: (bookingId: string) => void;
+  pendingBookingId: string | null;
+}) {
+  if (rows.length === 0) {
+    return (
+      <Text size="sm" c="dimmed">
+        {side === "load" ? "No bookings board here." : "No bookings alight here."}
+      </Text>
+    );
+  }
+  return (
+    <Table.ScrollContainer minWidth={720}>
+      <Table verticalSpacing="xs" highlightOnHover>
+        <Table.Thead>
+          <Table.Tr>
+            <Table.Th>Booking</Table.Th>
+            <Table.Th>Customer</Table.Th>
+            <Table.Th>Direction</Table.Th>
+            <Table.Th>Status</Table.Th>
+            <Table.Th>{side === "load" ? "Loaded" : "Arrived"}</Table.Th>
+            <Table.Th />
+          </Table.Tr>
+        </Table.Thead>
+        <Table.Tbody>
+          {rows.map((row) => {
+            const timestamp = side === "load" ? row.loadedAt : row.arrivedAt;
+            const canAct = side === "load" ? row.canLoad : row.canUnload;
+            return (
+              <Table.Tr key={row.id}>
+                <Table.Td>
+                  <BookingCell row={row} />
+                </Table.Td>
+                <Table.Td>
+                  <Text size="sm">{row.customer}</Text>
+                </Table.Td>
+                <Table.Td>
+                  <DirectionChip direction={row.tradeDirection} />
+                </Table.Td>
+                <Table.Td>
+                  <BookingStatusBadge status={row.status} />
+                </Table.Td>
+                <Table.Td>
+                  {timestamp ? (
+                    <Text size="xs" c="dimmed">
+                      {fmtDate(timestamp)}
+                    </Text>
+                  ) : (
+                    <Text size="xs" c="dimmed">
+                      —
+                    </Text>
+                  )}
+                </Table.Td>
+                <Table.Td>
+                  <Group gap="xs" justify="flex-end">
+                    {side === "load" ? (
+                      <Tooltip
+                        label={
+                          trainHere
+                            ? "Confirm cargo loaded at this yard"
+                            : "Train must be at this yard"
+                        }
+                        disabled={!canAct && Boolean(row.loadedAt)}
+                      >
+                        <Button
+                          size="compact-xs"
+                          variant="light"
+                          leftSection={<PackageCheck size={13} />}
+                          disabled={!canAct || !trainHere}
+                          loading={pendingBookingId === row.id}
+                          onClick={() => onLoad(row.id)}
+                        >
+                          Load
+                        </Button>
+                      </Tooltip>
+                    ) : (
+                      <Tooltip
+                        label={
+                          trainHere
+                            ? "Confirm cargo unloaded at this yard"
+                            : "Train must be at this yard"
+                        }
+                        disabled={!canAct && Boolean(row.arrivedAt)}
+                      >
+                        <Button
+                          size="compact-xs"
+                          variant="light"
+                          color="orange"
+                          leftSection={<PackageOpen size={13} />}
+                          disabled={!canAct || !trainHere}
+                          loading={pendingBookingId === row.id}
+                          onClick={() => onUnload(row.id)}
+                        >
+                          Unload
+                        </Button>
+                      </Tooltip>
+                    )}
+                  </Group>
+                </Table.Td>
+              </Table.Tr>
+            );
+          })}
+        </Table.Tbody>
+      </Table>
+    </Table.ScrollContainer>
+  );
+}
+
+/**
+ * Per-yard load/unload worklist for one schedule — every trade direction. Each
+ * booking boards at its origin yard and alights at its destination yard; the
+ * operator confirms both while the train's last recorded checkpoint is at that
+ * yard (the server validates the position). Unloading stamps the booking's own
+ * arrival — ARRIVED for import/export, COMPLETED for intercity.
+ */
+export function YardWorkPanel({ scheduleId }: { scheduleId: string }) {
+  const { toast } = useToast();
+  const queryClient = useQueryClient();
+
+  const yardWorkQuery = useQuery(
+    api.trainScheduling.yardWork.queryOptions({
+      input: { scheduleId },
+      refetchInterval: 60_000,
+    }),
+  );
+
+  const invalidate = () =>
+    queryClient.invalidateQueries({
+      queryKey: api.trainScheduling.yardWork.queryKey({ scheduleId }),
+    });
+
+  const load = useMutation(
+    api.trainScheduling.loadScheduleBooking.mutationOptions({
+      onSuccess: () => {
+        void invalidate();
+        toast({ title: "Cargo loaded" });
+      },
+      onError: (err) =>
+        toast({
+          title: "Load failed",
+          description: parseError(err, "Could not confirm loading"),
+          variant: "destructive",
+        }),
+    }),
+  );
+
+  const unload = useMutation(
+    api.trainScheduling.unloadScheduleBooking.mutationOptions({
+      onSuccess: (result) => {
+        void invalidate();
+        toast({
+          title:
+            result.status === "COMPLETED"
+              ? "Cargo unloaded — booking completed"
+              : "Cargo unloaded — booking arrived",
+        });
+      },
+      onError: (err) =>
+        toast({
+          title: "Unload failed",
+          description: parseError(err, "Could not confirm unloading"),
+          variant: "destructive",
+        }),
+    }),
+  );
+
+  const data = yardWorkQuery.data;
+  const yards: YardWorkYard[] = data?.yards ?? [];
+  const trainAtYardId = data?.trainAtYardId ?? null;
+  const pendingLoadId = load.isPending ? (load.variables?.bookingId ?? null) : null;
+  const pendingUnloadId = unload.isPending ? (unload.variables?.bookingId ?? null) : null;
+
+  return (
+    <Paper withBorder radius="lg" p="lg" mt="md">
+      <Stack gap="md">
+        <Group gap="xs">
+          <MapPin size={18} />
+          <Text fw={700}>Yard load / unload</Text>
+        </Group>
+
+        {yardWorkQuery.isLoading ? (
+          <Group gap="xs">
+            <Loader size="xs" />
+            <Text size="sm" c="dimmed">
+              Loading yard worklists…
+            </Text>
+          </Group>
+        ) : yardWorkQuery.isError ? (
+          <Alert color="red" variant="light" icon={<AlertCircle size={16} />}>
+            {parseError(yardWorkQuery.error, "Could not load the yard worklist")}
+          </Alert>
+        ) : yards.length === 0 ? (
+          <Text size="sm" c="dimmed">
+            No bookings are assigned to this schedule yet.
+          </Text>
+        ) : (
+          <>
+            <Text size="sm" c="dimmed">
+              What boards and alights at each stop. Confirm loading at a booking's
+              origin and unloading at its destination while the train is at that
+              yard — unloading stamps the booking's own arrival, even before the
+              train's final stop.
+            </Text>
+            {yards.map((yard, index) => {
+              const trainHere = trainAtYardId === yard.yardId;
+              return (
+                <Stack key={yard.yardId} gap="sm">
+                  {index > 0 && <Divider />}
+                  <Group gap="xs">
+                    <Text fw={600}>{yard.yard}</Text>
+                    {trainHere && (
+                      <Badge
+                        size="sm"
+                        variant="light"
+                        color="edr-green"
+                        leftSection={<TrainFront size={12} />}
+                      >
+                        Train here
+                      </Badge>
+                    )}
+                  </Group>
+                  <Stack gap={6}>
+                    <Text size="sm" fw={600} c="dimmed">
+                      Board here
+                    </Text>
+                    <WorkTable
+                      rows={yard.toLoad}
+                      side="load"
+                      trainHere={trainHere}
+                      onLoad={(bookingId) => load.mutate({ scheduleId, bookingId })}
+                      onUnload={(bookingId) => unload.mutate({ scheduleId, bookingId })}
+                      pendingBookingId={pendingLoadId}
+                    />
+                  </Stack>
+                  <Stack gap={6}>
+                    <Text size="sm" fw={600} c="dimmed">
+                      Alight here
+                    </Text>
+                    <WorkTable
+                      rows={yard.toUnload}
+                      side="unload"
+                      trainHere={trainHere}
+                      onLoad={(bookingId) => load.mutate({ scheduleId, bookingId })}
+                      onUnload={(bookingId) => unload.mutate({ scheduleId, bookingId })}
+                      pendingBookingId={pendingUnloadId}
+                    />
+                  </Stack>
+                </Stack>
+              );
+            })}
+          </>
+        )}
+      </Stack>
+    </Paper>
+  );
+}
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..b1afff27b 100644
--- a/apps/edr-freight-web/backoffice/src/components/warehouses/CreateWarehouseModal.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/warehouses/CreateWarehouseModal.tsx
@@ -169,7 +169,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/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 9e017d5fc..828f4ab44 100644
--- a/apps/edr-freight-web/backoffice/src/components/warehouses/LoadToTrainPanel.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/warehouses/LoadToTrainPanel.tsx
@@ -1,22 +1,26 @@
 import {
   Alert,
   Badge,
+  Box,
   Button,
   Checkbox,
   Group,
   Loader,
-  Select,
+  Paper,
   Stack,
   Table,
-  Tabs,
   Text,
 } from '@mantine/core';
 import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
-import { TrainFront } from 'lucide-react';
+import { ChevronDown, ChevronRight, TrainFront } from 'lucide-react';
 import { useMemo, useState } from 'react';
 
 import { useToast } from '@/hooks/use-toast';
-import { warehouseService, type TrainLoadableItem } from '@/services/warehouse.service';
+import {
+  warehouseService,
+  type LoadableTrain,
+  type TrainLoadableItem,
+} from '@/services/warehouse.service';
 import { extractErrorMessage } from './options';
 
 const STAGE_COLOR: Record<string, string> = {
@@ -27,226 +31,277 @@ 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;
+  bookingReference: string | null;
+  customerName: string | null;
+  items: TrainLoadableItem[];
+}
+
+function groupByBooking(items: TrainLoadableItem[]): BookingGroup[] {
+  const map = new Map<string, BookingGroup>();
+  for (const i of items) {
+    const key = i.bookingId ?? i.bookingReference ?? 'unknown';
+    let g = map.get(key);
+    if (!g) {
+      g = { bookingId: i.bookingId, bookingReference: i.bookingReference, customerName: i.customerName, items: [] };
+      map.set(key, g);
+    }
+    g.items.push(i);
+  }
+  return [...map.values()];
+}
 
 /**
- * Load to Train — pick an allocated EXPORT train, see the arrived containers/cargoes
- * assigned to it (stage tabs), multiselect the ready ones and load them onto their
- * already-allocated wagons. Loading follows train + wagon allocation: only items
- * that are READY_FOR_LOADING and have an allocated wagon are selectable.
+ * Load to Train — a datatable of allocated EXPORT trains. Expand a train to see
+ * the bookings allocated to it; expand a booking to see its containers/cargoes
+ * and load the ready ones onto their wagons. Only READY_FOR_LOADING items with an
+ * allocated wagon are selectable.
  */
 export function LoadToTrainPanel() {
-  const { toast } = useToast();
-  const queryClient = useQueryClient();
-  const [scheduleId, setScheduleId] = useState<string | null>(null);
-  const [tab, setTab] = useState('received');
-  const [selected, setSelected] = useState<string[]>([]);
-
-  const trainsKey = ['loadable-trains'];
-  const { data: trains = [], isLoading: trainsLoading } = useQuery({
-    queryKey: trainsKey,
+  const { data: trains = [], isLoading } = useQuery({
+    queryKey: ['loadable-trains'],
     queryFn: () => warehouseService.getLoadableTrains(),
   });
-
-  const itemsKey = ['train-loadable-items', scheduleId];
-  const { data: items = [], isLoading } = useQuery({
-    queryKey: itemsKey,
-    queryFn: () => warehouseService.getTrainLoadableItems(scheduleId as string),
-    enabled: Boolean(scheduleId),
-  });
-
-  const received = useMemo(() => items.filter((i) => i.status !== 'LOADED'), [items]);
-  const loaded = useMemo(() => items.filter((i) => i.status === 'LOADED'), [items]);
-  const visible = tab === 'loaded' ? loaded : received;
-
-  const trainOptions = trains.map((t) => ({
-    value: t.scheduleId,
-    label:
-      `${t.trainNumber ?? t.scheduleId.slice(0, 8)}` +
-      (t.origin || t.destination ? ` · ${t.origin ?? '?'}→${t.destination ?? '?'}` : '') +
-      ` · ${t.readyCount} ready / ${t.loadedCount} loaded`,
-  }));
-
-  const selectableVisible = visible.filter((i) => i.loadable);
-  const allSelected =
-    selectableVisible.length > 0 && selectableVisible.every((i) => selected.includes(i.id));
+  const [expanded, setExpanded] = useState<Set<string>>(new Set());
   const toggle = (id: string) =>
+    setExpanded((s) => {
+      const next = new Set(s);
+      next.has(id) ? next.delete(id) : next.add(id);
+      return next;
+    });
+
+  if (isLoading) {
+    return (
+      <Group justify="center" py="lg">
+        <Loader />
+      </Group>
+    );
+  }
+  if (trains.length === 0) {
+    return (
+      <Alert color="gray" variant="light">
+        No allocated EXPORT trains awaiting loading. Trains appear here after train and wagon allocation.
+      </Alert>
+    );
+  }
+
+  return (
+    <Table.ScrollContainer minWidth={720}>
+      <Table verticalSpacing="sm">
+        <Table.Thead>
+          <Table.Tr>
+            <Table.Th w={40} />
+            <Table.Th>Train</Table.Th>
+            <Table.Th>Route</Table.Th>
+            <Table.Th ta="center">Ready</Table.Th>
+            <Table.Th ta="center">Loaded</Table.Th>
+          </Table.Tr>
+        </Table.Thead>
+        <Table.Tbody>
+          {trains.map((t) => (
+            <TrainRow
+              key={t.scheduleId}
+              train={t}
+              expanded={expanded.has(t.scheduleId)}
+              onToggle={() => toggle(t.scheduleId)}
+            />
+          ))}
+        </Table.Tbody>
+      </Table>
+    </Table.ScrollContainer>
+  );
+}
+
+function TrainRow({ train, expanded, onToggle }: { train: LoadableTrain; expanded: boolean; onToggle: () => void }) {
+  const { data: items = [], isLoading } = useQuery({
+    queryKey: ['train-loadable-items', train.scheduleId],
+    queryFn: () => warehouseService.getTrainLoadableItems(train.scheduleId),
+    enabled: expanded,
+  });
+  const bookings = useMemo(() => groupByBooking(items), [items]);
+  const route =
+    train.origin || train.destination ? `${train.origin ?? '?'} → ${train.destination ?? '?'}` : '—';
+
+  return (
+    <>
+      <Table.Tr style={{ cursor: 'pointer' }} onClick={onToggle}>
+        <Table.Td>{expanded ? <ChevronDown size={16} /> : <ChevronRight size={16} />}</Table.Td>
+        <Table.Td>
+          <Group gap="xs" wrap="nowrap">
+            <TrainFront size={16} />
+            <Text fw={600}>{train.trainNumber ?? train.scheduleId.slice(0, 8)}</Text>
+          </Group>
+        </Table.Td>
+        <Table.Td>{route}</Table.Td>
+        <Table.Td ta="center">
+          <Badge color="blue" variant="light">
+            {train.readyCount}
+          </Badge>
+        </Table.Td>
+        <Table.Td ta="center">
+          <Badge color="green" variant="light">
+            {train.loadedCount}
+          </Badge>
+        </Table.Td>
+      </Table.Tr>
+      {expanded && (
+        <Table.Tr>
+          <Table.Td colSpan={5} p={0}>
+            <Box p="sm" bg="var(--mantine-color-gray-0)">
+              {isLoading ? (
+                <Group justify="center" py="md">
+                  <Loader size="sm" />
+                </Group>
+              ) : bookings.length === 0 ? (
+                <Alert color="gray" variant="light">
+                  No arrived containers/cargoes allocated to this train yet.
+                </Alert>
+              ) : (
+                <Stack gap="xs">
+                  {bookings.map((b) => (
+                    <BookingBlock key={b.bookingId ?? b.bookingReference} scheduleId={train.scheduleId} booking={b} />
+                  ))}
+                </Stack>
+              )}
+            </Box>
+          </Table.Td>
+        </Table.Tr>
+      )}
+    </>
+  );
+}
+
+function BookingBlock({ scheduleId, booking }: { scheduleId: string; booking: BookingGroup }) {
+  const { toast } = useToast();
+  const queryClient = useQueryClient();
+  const [open, setOpen] = useState(false);
+  const [selected, setSelected] = useState<string[]>([]);
+
+  const loadedCount = booking.items.filter((i) => i.status === 'LOADED').length;
+  const selectable = booking.items.filter((i) => i.loadable);
+  const allSelected = selectable.length > 0 && selectable.every((i) => selected.includes(i.id));
+  const toggleItem = (id: string) =>
     setSelected((s) => (s.includes(id) ? s.filter((x) => x !== id) : [...s, id]));
   const toggleAll = () =>
     setSelected((s) =>
-      allSelected
-        ? s.filter((id) => !selectableVisible.some((i) => i.id === id))
-        : Array.from(new Set([...s, ...selectableVisible.map((i) => i.id)])),
+      allSelected ? s.filter((id) => !selectable.some((i) => i.id === id)) : selectable.map((i) => i.id),
     );
 
   const loadMutation = useMutation({
-    mutationFn: () => warehouseService.loadItemsOntoTrain(scheduleId as string, selected),
+    mutationFn: () => warehouseService.loadItemsOntoTrain(scheduleId, selected),
     onSuccess: (r) => {
-      queryClient.invalidateQueries({ queryKey: itemsKey });
-      queryClient.invalidateQueries({ queryKey: trainsKey });
+      queryClient.invalidateQueries({ queryKey: ['train-loadable-items', scheduleId] });
+      queryClient.invalidateQueries({ queryKey: ['loadable-trains'] });
       setSelected([]);
-      toast({
-        title: 'Loaded onto train',
-        description: `Loaded ${r.loadedCount} item(s); skipped ${r.skippedCount}.`,
-      });
+      toast({ title: 'Loaded onto train', description: `Loaded ${r.loadedCount}; skipped ${r.skippedCount}.` });
     },
     onError: (e) =>
       toast({ variant: 'destructive', title: 'Load failed', description: extractErrorMessage(e) }),
   });
 
-  const renderRow = (i: TrainLoadableItem) => (
-    <Table.Tr key={i.id}>
-      <Table.Td>
-        <Checkbox
-          checked={selected.includes(i.id)}
-          onChange={() => toggle(i.id)}
-          disabled={!i.loadable}
-        />
-      </Table.Td>
-      <Table.Td>
-        <Text fw={600}>{i.containerNumber ?? i.cargoType ?? '—'}</Text>
-      </Table.Td>
-      <Table.Td>{i.cargoType ?? '—'}</Table.Td>
-      <Table.Td>{weight(i.weight)}</Table.Td>
-      <Table.Td>
-        <Badge color={STAGE_COLOR[i.status] ?? 'gray'} variant="light">
-          {i.status.replace(/_/g, ' ')}
-        </Badge>
-      </Table.Td>
-      <Table.Td>
-        {i.wagonNumber ? (
-          <Badge variant="outline" color="indigo">
-            {i.wagonNumber}
-          </Badge>
-        ) : (
-          <Text size="xs" c="red">
-            Not allocated
-          </Text>
-        )}
-      </Table.Td>
-      <Table.Td>{i.bookingReference ?? '—'}</Table.Td>
-      <Table.Td>{i.customerName ?? '—'}</Table.Td>
-      <Table.Td>
-        {i.inspectionStatus ? (
-          <Badge size="xs" variant="light" color={i.inspectionStatus === 'PASSED' ? 'green' : 'orange'}>
-            {i.inspectionStatus}
-          </Badge>
-        ) : (
-          '—'
-        )}
-      </Table.Td>
-    </Table.Tr>
-  );
-
   return (
-    <Stack gap="md">
-      <Group align="flex-end" justify="space-between">
-        <Select
-          label="Train"
-          description="Allocated EXPORT trains awaiting loading"
-          placeholder={trainsLoading ? 'Loading trains…' : trainOptions.length ? 'Select a train' : 'No trains to load'}
-          data={trainOptions}
-          value={scheduleId}
-          onChange={(v) => {
-            setScheduleId(v);
-            setSelected([]);
-            setTab('received');
-          }}
-          disabled={trainOptions.length === 0}
-          leftSection={<TrainFront size={16} />}
-          w={460}
-          searchable
-        />
+    <Paper withBorder radius="sm" p="xs">
+      <Group justify="space-between" style={{ cursor: 'pointer' }} onClick={() => setOpen((o) => !o)} wrap="nowrap">
+        <Group gap="xs" wrap="nowrap">
+          {open ? <ChevronDown size={15} /> : <ChevronRight size={15} />}
+          <Text fw={600}>{booking.bookingReference ?? booking.bookingId?.slice(0, 8) ?? '—'}</Text>
+          <Text size="sm" c="dimmed">
+            {booking.customerName ?? '—'}
+          </Text>
+        </Group>
+        <Group gap="xs" wrap="nowrap">
+          <Badge variant="light" color="blue">
+            {booking.items.length} item(s)
+          </Badge>
+          {loadedCount > 0 && (
+            <Badge variant="light" color="green">
+              {loadedCount} loaded
+            </Badge>
+          )}
+        </Group>
       </Group>
 
-      {!scheduleId ? (
-        <Alert color="gray" variant="light">
-          Pick a train to see the arrived containers/cargoes allocated to it. Items appear here only
-          after train and wagon allocation.
-        </Alert>
-      ) : (
-        <>
-          <Tabs value={tab} onChange={(v) => setTab(v ?? 'received')}>
-            <Tabs.List>
-              <Tabs.Tab
-                value="received"
-                rightSection={
-                  <Badge size="xs" variant="light" color="blue">
-                    {received.length}
+      {open && (
+       <>
+        <Table striped highlightOnHover verticalSpacing="xs" mt="xs">
+          <Table.Thead>
+            <Table.Tr>
+              <Table.Th w={36}>
+                <Checkbox
+                  checked={allSelected}
+                  indeterminate={!allSelected && selected.length > 0}
+                  onChange={toggleAll}
+                  disabled={selectable.length === 0}
+                />
+              </Table.Th>
+              <Table.Th>Container / Cargo</Table.Th>
+              <Table.Th>Goods</Table.Th>
+              <Table.Th>Weight</Table.Th>
+              <Table.Th>Stage</Table.Th>
+              <Table.Th>Wagon</Table.Th>
+              <Table.Th>Inspection</Table.Th>
+            </Table.Tr>
+          </Table.Thead>
+          <Table.Tbody>
+            {booking.items.map((i) => (
+              <Table.Tr key={i.id}>
+                <Table.Td>
+                  <Checkbox checked={selected.includes(i.id)} onChange={() => toggleItem(i.id)} disabled={!i.loadable} />
+                </Table.Td>
+                <Table.Td>
+                  <Text fw={600}>{i.containerNumber ?? i.cargoType ?? '—'}</Text>
+                </Table.Td>
+                <Table.Td>{i.cargoType ?? '—'}</Table.Td>
+                <Table.Td>{weight(i.weight)}</Table.Td>
+                <Table.Td>
+                  <Badge color={STAGE_COLOR[i.status] ?? 'gray'} variant="light">
+                    {i.status.replace(/_/g, ' ')}
                   </Badge>
-                }
-              >
-                Received
-              </Tabs.Tab>
-              <Tabs.Tab
-                value="loaded"
-                rightSection={
-                  <Badge size="xs" variant="light" color="green">
-                    {loaded.length}
-                  </Badge>
-                }
-              >
-                Loaded
-              </Tabs.Tab>
-            </Tabs.List>
-          </Tabs>
-
-          {isLoading ? (
-            <Group justify="center" py="lg">
-              <Loader />
-            </Group>
-          ) : visible.length === 0 ? (
-            <Alert color="gray" variant="light">
-              {tab === 'loaded' ? 'Nothing loaded onto this train yet.' : 'No arrived items ready for this train.'}
-            </Alert>
-          ) : (
-            <Table.ScrollContainer minWidth={900}>
-              <Table striped highlightOnHover verticalSpacing="xs">
-                <Table.Thead>
-                  <Table.Tr>
-                    <Table.Th>
-                      {tab === 'received' && (
-                        <Checkbox
-                          checked={allSelected}
-                          indeterminate={!allSelected && selected.length > 0}
-                          onChange={toggleAll}
-                          disabled={selectableVisible.length === 0}
-                        />
-                      )}
-                    </Table.Th>
-                    <Table.Th>Container / Cargo</Table.Th>
-                    <Table.Th>Goods</Table.Th>
-                    <Table.Th>Weight</Table.Th>
-                    <Table.Th>Stage</Table.Th>
-                    <Table.Th>Wagon</Table.Th>
-                    <Table.Th>Booking</Table.Th>
-                    <Table.Th>Customer</Table.Th>
-                    <Table.Th>Inspection</Table.Th>
-                  </Table.Tr>
-                </Table.Thead>
-                <Table.Tbody>{visible.map(renderRow)}</Table.Tbody>
-              </Table>
-            </Table.ScrollContainer>
-          )}
-
-          {tab === 'received' && (
-            <Group justify="space-between" align="center">
-              <Text size="sm" c="dimmed">
-                {selected.length} selected · only READY_FOR_LOADING items with an allocated wagon can be loaded
-              </Text>
-              <Button
-                color="edr-green"
-                leftSection={<TrainFront size={16} />}
-                disabled={selected.length === 0}
-                loading={loadMutation.isPending}
-                onClick={() => loadMutation.mutate()}
-              >
-                Load {selected.length || ''} onto train
-              </Button>
-            </Group>
-          )}
-        </>
+                </Table.Td>
+                <Table.Td>
+                  {i.wagonNumber ? (
+                    <Badge variant="outline" color="indigo">
+                      {i.wagonNumber}
+                    </Badge>
+                  ) : (
+                    <Text size="xs" c="red">
+                      Not allocated
+                    </Text>
+                  )}
+                </Table.Td>
+                <Table.Td>
+                  {i.inspectionStatus ? (
+                    <Badge size="xs" variant="light" color={i.inspectionStatus === 'PASSED' ? 'green' : 'orange'}>
+                      {i.inspectionStatus}
+                    </Badge>
+                  ) : (
+                    '—'
+                  )}
+                </Table.Td>
+              </Table.Tr>
+            ))}
+          </Table.Tbody>
+        </Table>
+        <Group justify="space-between" align="center" mt="xs">
+          <Text size="xs" c="dimmed">
+            {selected.length} selected · only READY_FOR_LOADING items with a wagon can be loaded
+          </Text>
+          <Button
+            size="compact-sm"
+            color="edr-green"
+            leftSection={<TrainFront size={14} />}
+            disabled={selected.length === 0}
+            loading={loadMutation.isPending}
+            onClick={() => loadMutation.mutate()}
+          >
+            Load {selected.length || ''} onto train
+          </Button>
+        </Group>
+       </>
       )}
-    </Stack>
+    </Paper>
   );
 }
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..822f350a2 100644
--- a/apps/edr-freight-web/backoffice/src/components/warehouses/ReceiveInventoryModal.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/warehouses/ReceiveInventoryModal.tsx
@@ -520,14 +520,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 +596,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) })}
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..1bf371e5d 100644
--- a/apps/edr-freight-web/backoffice/src/components/warehouses/ReleaseOrderModal.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/warehouses/ReleaseOrderModal.tsx
@@ -78,7 +78,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 : '';
@@ -397,13 +397,13 @@ export function ReleaseOrderModal({ opened, onClose, item, truckPrefill }: Relea
           <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="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/constants/URLS.ts b/apps/edr-freight-web/backoffice/src/constants/URLS.ts
index fce620235..05bb06372 100644
--- a/apps/edr-freight-web/backoffice/src/constants/URLS.ts
+++ b/apps/edr-freight-web/backoffice/src/constants/URLS.ts
@@ -162,6 +162,8 @@ export const URL_CONSTANTS = {
     STAFF_REJECT: (id: string) => `/contracts/${id}/staff/reject`,
     APPROVE_STEP: (id: string, stepId: string) =>
       `/contracts/${id}/approval-steps/${stepId}/approve`,
+    REJECT_STEP: (id: string, stepId: string) =>
+      `/contracts/${id}/approval-steps/${stepId}/reject`,
     CONTRACT_GENERATE: (id: string) => `/contracts/${id}/contract/generate`,
     CONTRACT_VIEW: (id: string) => `/contracts/${id}/contract/view`,
     CONTRACT_DOCUMENT: (id: string) => `/contracts/${id}/contract/document`,
@@ -324,6 +326,11 @@ export const URL_CONSTANTS = {
     PIN_WAGONS: (id: string) => `/train-scheduling/schedules/${id}/pin-wagons`,
     FINALIZE: (id: string) => `/train-scheduling/schedules/${id}/finalize`,
     DISPATCH: (id: string) => `/train-scheduling/schedules/${id}/dispatch`,
+    YARD_WORK: (id: string) => `/train-scheduling/schedules/${id}/yard-work`,
+    BOOKING_LOAD: (id: string, bookingId: string) =>
+      `/train-scheduling/schedules/${id}/bookings/${bookingId}/load`,
+    BOOKING_UNLOAD: (id: string, bookingId: string) =>
+      `/train-scheduling/schedules/${id}/bookings/${bookingId}/unload`,
     INTERCITY_CANDIDATES: (id: string) =>
       `/train-scheduling/schedules/${id}/intercity-candidates`,
     INTERCITY_ACCEPT: (id: string) =>
diff --git a/apps/edr-freight-web/backoffice/src/features/bookingWindows/useBookingWindowSocket.ts b/apps/edr-freight-web/backoffice/src/features/bookingWindows/useBookingWindowSocket.ts
index 3941c487c..e6075f06f 100644
--- a/apps/edr-freight-web/backoffice/src/features/bookingWindows/useBookingWindowSocket.ts
+++ b/apps/edr-freight-web/backoffice/src/features/bookingWindows/useBookingWindowSocket.ts
@@ -15,11 +15,56 @@ import { QUERY_KEYS } from "@/constants/QUERY_KEYS";
 // prefix — strip a trailing `/api` if the base URL carries one.
 const SOCKET_ORIGIN = String(API_BASE_URL ?? "").replace(/\/api\/?$/, "");
 
+// The two carousel window lists share the MyBookingWindow-shaped row and can be
+// patched in place. The batch board is a richer, differently-shaped view, so it
+// stays on a (debounced) invalidate.
+const WINDOW_ACTIONS = new Set(["all-booking-windows", "contractBookingWindows"]);
+
+/** Shape shared by both carousel window lists (all-lanes + contract-scoped). */
+interface WindowRow {
+  scheduleId: string;
+  windowPhase: string | null;
+  isOpenNow: boolean;
+  windowOpensAt: string | null;
+  windowClosesAt: string | null;
+  docReviewEndsAt: string | null;
+  paymentPhaseEndsAt: string | null;
+  bookingWindowStatus: string;
+  bookingCycleNo: number;
+  departureDate: string;
+}
+
+function isWindowKey(key: readonly unknown[]): boolean {
+  return key[0] === "train-scheduling" && WINDOW_ACTIONS.has(String(key[1]));
+}
+
 /**
- * Subscribes to live booking-window pushes for staff. Every phase transition
- * the window engine applies invalidates the GL windows carousel and the batch
- * board, so both flip the moment the backend does — polling stays only as a
- * fallback.
+ * Fold a server phase push onto a cached window row, recomputing isOpenNow the
+ * same way the server does (phase OPEN + status OPEN) so live-patched state can
+ * never disagree with a fresh REST fetch on refresh.
+ */
+function applyEvent<T extends WindowRow>(row: T, event: BookingWindowPhaseEvent): T {
+  return {
+    ...row,
+    windowPhase: event.phase,
+    bookingWindowStatus: event.bookingWindowStatus ?? row.bookingWindowStatus,
+    bookingCycleNo: event.bookingCycleNo,
+    isOpenNow: event.phase === "OPEN" && event.bookingWindowStatus === "OPEN",
+    windowOpensAt: event.windowOpensAt,
+    windowClosesAt: event.windowClosesAt,
+    docReviewEndsAt: event.docReviewEndsAt,
+    paymentPhaseEndsAt: event.paymentPhaseEndsAt,
+    departureDate: event.scheduledDepartureDate ?? row.departureDate,
+  };
+}
+
+/**
+ * Subscribes to live booking-window pushes for staff. A phase transition carries
+ * the schedule's full new state; we fold it straight into the carousel window
+ * lists with setQueriesData rather than invalidating — same rationale as the
+ * portal hook (no per-push refetch storm; live + refreshed state agree, killing
+ * the refresh-jump). The batch board is a different-shaped view, so it keeps a
+ * debounced invalidate, as do pushes for schedules not present in any list.
  */
 export function useBookingWindowSocket(enabled: boolean = true) {
   const qc = useQueryClient();
@@ -47,19 +92,60 @@ export function useBookingWindowSocket(enabled: boolean = true) {
       console.debug("[booking-windows] socket disconnected:", reason),
     );
 
-    socket.on(
-      BOOKING_WINDOW_WS_EVENTS.PHASE,
-      (_event: BookingWindowPhaseEvent) => {
-        qc.invalidateQueries({
-          queryKey: ["train-scheduling", "all-booking-windows"],
-        });
-        qc.invalidateQueries({
+    // Coalesce the batch-board refresh (and the unknown-schedule fallback) so a
+    // burst of pushes triggers at most one invalidation per window.
+    let refetchTimer: ReturnType<typeof setTimeout> | null = null;
+    const scheduleRefetch = (includeWindowLists: boolean) => {
+      if (refetchTimer) return;
+      refetchTimer = setTimeout(() => {
+        refetchTimer = null;
+        void qc.invalidateQueries({
           queryKey: QUERY_KEYS.TRAIN_SCHEDULING.batchBoard(),
         });
+        if (includeWindowLists) {
+          void qc.invalidateQueries({
+            predicate: (q) => isWindowKey(q.queryKey),
+          });
+        }
+      }, 800);
+    };
+
+    socket.on(
+      BOOKING_WINDOW_WS_EVENTS.PHASE,
+      (event: BookingWindowPhaseEvent) => {
+        let patchedSomewhere = false;
+
+        qc.setQueriesData<WindowRow[]>(
+          { predicate: (q) => isWindowKey(q.queryKey) },
+          (rows) => {
+            if (!rows) return rows;
+            let changed = false;
+            const next = rows.map((row) => {
+              if (row.scheduleId !== event.scheduleId) return row;
+              changed = true;
+              patchedSomewhere = true;
+              return applyEvent(row, event);
+            });
+            return changed ? next : rows;
+          },
+        );
+
+        // Refresh the batch-board DETAIL for the schedule that transitioned so the
+        // Priority Tracking tab reranks + updates its countdowns immediately (the
+        // detail is a different shape from the list — invalidate, don't patch).
+        void qc.invalidateQueries({
+          queryKey: QUERY_KEYS.TRAIN_SCHEDULING.batchBoardDetail(event.scheduleId),
+        });
+
+        // Always refresh the batch board (different shape, not patched). When the
+        // schedule wasn't in any window list either, refresh those too so a newly
+        // announced window surfaces. Both debounced — no per-push stampede.
+        scheduleRefetch(!patchedSomewhere);
       },
     );
 
     return () => {
+      if (refetchTimer) clearTimeout(refetchTimer);
       socket.off();
       socket.disconnect();
     };
diff --git a/apps/edr-freight-web/backoffice/src/features/bookings/booking-status.config.ts b/apps/edr-freight-web/backoffice/src/features/bookings/booking-status.config.ts
index 127c8e708..25f4b51bc 100644
--- a/apps/edr-freight-web/backoffice/src/features/bookings/booking-status.config.ts
+++ b/apps/edr-freight-web/backoffice/src/features/bookings/booking-status.config.ts
@@ -66,6 +66,10 @@ export const BOOKING_STATUS_STYLES: Record<string, StatusStyle> = {
     label: "In Transit",
     color: "bg-sky-50 text-sky-700 border-sky-200",
   },
+  ARRIVED: {
+    label: "Arrived",
+    color: "bg-emerald-50 text-emerald-700 border-emerald-200",
+  },
   COMPLETED: {
     label: "Completed",
     color: "bg-indigo-50 text-indigo-700 border-indigo-200",
@@ -208,6 +212,12 @@ export const BOOKING_STATUS_META: Record<string, StatusMeta> = {
     color: "text-sky-600",
     stage: 4,
   },
+  ARRIVED: {
+    title: "Arrived",
+    description: "Cargo unloaded at its destination yard.",
+    color: "text-emerald-600",
+    stage: 4,
+  },
   COMPLETED: {
     title: "Completed",
     description: "Booking fulfilled.",
@@ -290,7 +300,7 @@ export const BOOKING_LIST_TABS = [
   {
     key: "operations",
     label: "Operations",
-    statuses: ["PAID", "IN_TRANSIT", "ROAD_DISPATCH_PENDING"],
+    statuses: ["PAID", "IN_TRANSIT", "ARRIVED", "ROAD_DISPATCH_PENDING"],
   },
   { key: "completed", label: "Completed", statuses: ["COMPLETED"] },
   { key: "closed", label: "Closed", statuses: ["REJECTED", "CANCELLED"] },
@@ -328,7 +338,7 @@ export const WORKFLOW_STAGES = [
   },
   {
     label: "Operations",
-    statuses: ["PAID", "IN_TRANSIT"],
+    statuses: ["PAID", "IN_TRANSIT", "ARRIVED"],
   },
   { label: "Done", statuses: ["COMPLETED"] },
 ] as const;
diff --git a/apps/edr-freight-web/backoffice/src/features/bookings/mapBookingListRow.ts b/apps/edr-freight-web/backoffice/src/features/bookings/mapBookingListRow.ts
index a5bc34170..bc10fd064 100644
--- a/apps/edr-freight-web/backoffice/src/features/bookings/mapBookingListRow.ts
+++ b/apps/edr-freight-web/backoffice/src/features/bookings/mapBookingListRow.ts
@@ -39,7 +39,6 @@ export function toBookingListRow(booking: BookingDetail): BookingListRow {
       booking.serviceType?.label ??
       booking.serviceType?.name ??
       booking.serviceType?.code,
-    serviceTypeBonus: booking.serviceType?.priorityBonusPoints ?? 0,
     trainScheduleId: booking.trainScheduleId ?? null,
     isGovernment: booking.isGovernment ?? false,
     governmentInstitution: booking.governmentInstitution ?? null,
diff --git a/apps/edr-freight-web/backoffice/src/hooks/contracts/useContracts.ts b/apps/edr-freight-web/backoffice/src/hooks/contracts/useContracts.ts
index 04a4720aa..69e4e1739 100644
--- a/apps/edr-freight-web/backoffice/src/hooks/contracts/useContracts.ts
+++ b/apps/edr-freight-web/backoffice/src/hooks/contracts/useContracts.ts
@@ -181,6 +181,15 @@ export function useContractMutations(contractId: string) {
     onError: () => toast.error("Failed to approve step"),
   });
 
+  // Per-step rejection by an approver (line staff / director / CEO). Terminal:
+  // the contract goes to REJECTED and the customer must create a new one.
+  const rejectStep = useMutation({
+    mutationFn: ({ stepId, reason }: { stepId: string; reason: string }) =>
+      contractsService.rejectStep({ id: contractId, stepId, reason }),
+    onSuccess: (data) => onSuccess(data, "Contract rejected"),
+    onError: () => toast.error("Failed to reject step"),
+  });
+
   // Manual fallback generate — used only if auto-generation failed.
   const generateContract = useMutation({
     mutationFn: () => contractsService.generateContract(contractId),
@@ -210,6 +219,7 @@ export function useContractMutations(contractId: string) {
     requestChanges.isPending ||
     reject.isPending ||
     approveStep.isPending ||
+    rejectStep.isPending ||
     generateContract.isPending ||
     signContract.isPending ||
     createBooking.isPending;
@@ -219,6 +229,7 @@ export function useContractMutations(contractId: string) {
     requestChanges,
     reject,
     approveStep,
+    rejectStep,
     generateContract,
     signContract,
     createBooking,
diff --git a/apps/edr-freight-web/backoffice/src/main.tsx b/apps/edr-freight-web/backoffice/src/main.tsx
index 8c467156e..9cf9f6c35 100644
--- a/apps/edr-freight-web/backoffice/src/main.tsx
+++ b/apps/edr-freight-web/backoffice/src/main.tsx
@@ -60,3 +60,5 @@ createRoot(rootElement).render(
     </MantineProvider>
   </QueryClientProvider>
 );
+
+// run
\ No newline at end of file
diff --git a/apps/edr-freight-web/backoffice/src/pages/bookings/BookingRequestDetailPage.tsx b/apps/edr-freight-web/backoffice/src/pages/bookings/BookingRequestDetailPage.tsx
index d1830b45a..622773d66 100644
--- a/apps/edr-freight-web/backoffice/src/pages/bookings/BookingRequestDetailPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/bookings/BookingRequestDetailPage.tsx
@@ -1,6 +1,7 @@
 import { useNavigate, useParams, useSearchParams } from "react-router-dom";
 import {
   ArrowLeft,
+  FolderOpen,
   Layers,
   LayoutGrid,
   Milestone,
@@ -37,6 +38,7 @@ import {
   BookingContractSummaryCard,
   BookingContainerUnitsCard,
   ClearanceReviewSection,
+  BookingDocumentsPanel,
   ContractOrdersPanel,
 } from "@/components/bookings/detail";
 import { WarehouseInfoCard } from "@/components/warehouses";
@@ -142,14 +144,17 @@ export default function BookingRequestDetailPage() {
   // A general contract drives an "Orders" tab: each drawdown order spawns a
   // child booking that staff manage (clearance/approval) independently.
   const isGeneralContract = booking.bookingType === "GENERAL_CONTRACT";
-  const showTabs = showClearanceTab || isGeneralContract;
+  // The Documents tab is always available — every booking can accrue clearance,
+  // customs-workflow, invoice or notice files — so the tab bar always renders.
   const requestedTab = searchParams.get("tab");
   const activeTab =
     requestedTab === "clearance" && showClearanceTab
       ? "clearance"
       : requestedTab === "orders" && isGeneralContract
         ? "orders"
-        : "overview";
+        : requestedTab === "documents"
+          ? "documents"
+          : "overview";
   const setActiveTab = (tab: string | null) => {
     const next = new URLSearchParams(searchParams);
     if (tab && tab !== "overview") next.set("tab", tab);
@@ -187,10 +192,10 @@ export default function BookingRequestDetailPage() {
         )}
 
         <Grid gap="lg">
-          {/* LEFT — primary content, split into tabs to keep each view focused */}
+          {/* LEFT — primary content, split into tabs to keep each view focused.
+              The Documents tab is always present, so the tab bar always renders. */}
           <Grid.Col span={{ base: 12, lg: 8 }}>
-            {showTabs ? (
-              <Tabs
+            <Tabs
                 value={activeTab}
                 onChange={setActiveTab}
                 variant="pills"
@@ -217,6 +222,12 @@ export default function BookingRequestDetailPage() {
                       Customer clearance
                     </Tabs.Tab>
                   )}
+                  <Tabs.Tab
+                    value="documents"
+                    leftSection={<FolderOpen size={16} />}
+                  >
+                    Documents
+                  </Tabs.Tab>
                 </Tabs.List>
 
                 <Tabs.Panel value="overview">
@@ -238,10 +249,10 @@ export default function BookingRequestDetailPage() {
                     />
                   </Tabs.Panel>
                 )}
+                <Tabs.Panel value="documents">
+                  <BookingDocumentsPanel bookingId={booking.id} />
+                </Tabs.Panel>
               </Tabs>
-            ) : (
-              <OverviewPanel booking={booking} row={row} />
-            )}
           </Grid.Col>
 
           {/* RIGHT — sticky action / summary rail */}
diff --git a/apps/edr-freight-web/backoffice/src/pages/contracts/ContractClearanceDetailPage.tsx b/apps/edr-freight-web/backoffice/src/pages/contracts/ContractClearanceDetailPage.tsx
index 2c3e6fa9d..76666c320 100644
--- a/apps/edr-freight-web/backoffice/src/pages/contracts/ContractClearanceDetailPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/contracts/ContractClearanceDetailPage.tsx
@@ -30,6 +30,7 @@ import { PageContainer } from "@/components/page/PageContainer";
 import { PageHeader } from "@/components/page/PageHeader";
 import { SectionCard } from "@/components/bookings/detail/SectionCard";
 import { ContractClearanceReviewSection } from "@/components/contracts/ContractClearanceReviewSection";
+import { GlUpcomingWindowsSection } from "@/components/contracts/GlUpcomingWindowsSection";
 import { PhasedClearanceActionPanel } from "@/components/contracts/PhasedClearanceActionPanel";
 import { QUERY_KEYS } from "@/constants/QUERY_KEYS";
 import { useFileViewer } from "@/hooks/useFileViewer";
@@ -90,11 +91,16 @@ export default function ContractClearanceDetailPage() {
       ].includes(contract.status),
   );
   const linkedBookingId = useMemo(() => {
+    // Prefer the clearance view's server-resolved linkedBookingId (same field the
+    // GL Djibouti page uses). The contract's clearanceCycles[cycle].bookingId can
+    // be null/stale for an export FCFS booking, which would disable
+    // useBookingMilestones → empty milestones → the export "Payment & wagon
+    // allocation" step reads FREIGHT_PAYMENT_SETTLED as not-done and stays stuck.
     const cycle = contract?.clearanceCycles?.find(
       (c) => c.cycleNumber === (contract?.clearanceCycleNumber ?? 1),
     );
-    return cycle?.bookingId ?? undefined;
-  }, [contract]);
+    return clearance?.linkedBookingId ?? cycle?.bookingId ?? undefined;
+  }, [clearance, contract]);
   const bookingAlreadyCreated = Boolean(linkedBookingId) || shipmentLocked;
   const canCreateBooking = ready && !bookingAlreadyCreated;
   const reviewReadOnly = shipmentLocked;
@@ -194,6 +200,10 @@ export default function ContractClearanceDetailPage() {
 
         <ClearanceHero contract={contract} stats={stats} />
 
+        {/* Windows on this contract's routes/direction only — tells GL ET when
+            it can actually create the booking without checking the schedule board. */}
+        {id ? <GlUpcomingWindowsSection contractId={id} /> : null}
+
         {bookingAlreadyCreated ? (
           <Alert
             color="blue"
diff --git a/apps/edr-freight-web/backoffice/src/pages/documents/FileUploadSettingsPage.tsx b/apps/edr-freight-web/backoffice/src/pages/documents/FileUploadSettingsPage.tsx
index 24c2772aa..9283fc070 100644
--- a/apps/edr-freight-web/backoffice/src/pages/documents/FileUploadSettingsPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/documents/FileUploadSettingsPage.tsx
@@ -18,14 +18,11 @@ import {
   HardDrive,
   Layers,
   Paperclip,
-  Pencil,
-  Plus,
   Search,
   Settings,
-  Trash2,
   X,
 } from "lucide-react";
-import { useMutation, useQuery } from "@tanstack/react-query";
+import { useQuery } from "@tanstack/react-query";
 
 import { KpiStrip, PageContainer, PageHeader } from "@/components/page";
 import { ruleEngineTable } from "@/components/ruleEngine/ruleEngineStyles";
@@ -33,9 +30,7 @@ import { api } from "@/services/api";
 import { getMinFiles, type FileUploadSetting } from "@/types/fileUploadSettings";
 import { DataTable, type ColumnDef } from "@edr/ui-common";
 
-import EditFileUploadSettingDialog from "./EditFileUploadSettingDialog";
 import ManageFileUploadFieldsDialog from "./ManageFileUploadFieldsDialog";
-import DeleteFileUploadSettingDialog from "./DeleteFileUploadSettingDialog";
 
 export default function FileUploadSettingsPage() {
   const [query, setQuery] = useState("");
@@ -43,7 +38,6 @@ export default function FileUploadSettingsPage() {
   const { data, isLoading, isError, error, refetch } = useQuery(
     api.fileUploadSettings.list.queryOptions(),
   );
-  const deleteMutation = useMutation(api.fileUploadSettings.remove.mutationOptions());
 
   const fileUploadSettings = useMemo(
     () => (Array.isArray(data) ? data : []),
@@ -178,6 +172,8 @@ export default function FileUploadSettingsPage() {
           headerClassName,
           cellClassName: `${cellClassName} whitespace-nowrap`,
         },
+        // Settings are seeded/fixed — staff may only update a setting's fields,
+        // not create, edit, or delete the settings themselves.
         cell: ({ row }) => {
           const setting = row.original;
           return (
@@ -191,33 +187,12 @@ export default function FileUploadSettingsPage() {
                   Fields
                 </Button>
               </ManageFileUploadFieldsDialog>
-
-              <EditFileUploadSettingDialog mode="edit" setting={setting}>
-                <ActionIcon variant="default" aria-label="Edit setting">
-                  <Pencil size={16} />
-                </ActionIcon>
-              </EditFileUploadSettingDialog>
-
-              <DeleteFileUploadSettingDialog
-                settingLabel={setting.label}
-                settingCode={setting.code}
-                onConfirm={() => deleteMutation.mutate({ id: setting.id })}
-              >
-                <ActionIcon
-                  variant="default"
-                  color="red"
-                  disabled={deleteMutation.isPending}
-                  aria-label="Delete setting"
-                >
-                  <Trash2 size={16} />
-                </ActionIcon>
-              </DeleteFileUploadSettingDialog>
             </Group>
           );
         },
       },
     ];
-  }, [deleteMutation]);
+  }, []);
 
   const tableStatus = isLoading ? "loading" : isError ? "error" : "success";
 
@@ -226,11 +201,6 @@ export default function FileUploadSettingsPage() {
       <PageHeader
         title="File upload settings"
         subtitle="Define the file inputs every form in the platform should render — required/optional, single/multiple, allowed types and size."
-        action={
-          <EditFileUploadSettingDialog mode="create">
-            <Button leftSection={<Plus size={18} />}>New setting</Button>
-          </EditFileUploadSettingDialog>
-        }
       />
 
       <KpiStrip
@@ -286,7 +256,7 @@ export default function FileUploadSettingsPage() {
               emptyMessage={
                 query.trim()
                   ? "No file upload settings match your search."
-                  : 'No file upload settings yet. Click "New setting" to add one.'
+                  : "No file upload settings configured."
               }
               containerClassName="border-0 shadow-none bg-transparent min-w-[920px]"
             />
diff --git a/apps/edr-freight-web/backoffice/src/pages/fleet/CompliancePage.tsx b/apps/edr-freight-web/backoffice/src/pages/fleet/CompliancePage.tsx
new file mode 100644
index 000000000..008fee25b
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/pages/fleet/CompliancePage.tsx
@@ -0,0 +1,343 @@
+import { useState } from "react";
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import {
+  Badge,
+  Button,
+  Card,
+  Container,
+  Grid,
+  Group,
+  Loader,
+  Modal,
+  Select,
+  Stack,
+  Table,
+  Text,
+  TextInput,
+  Title,
+} from "@mantine/core";
+import { Plus, AlertTriangle } from "lucide-react";
+import Breadcrumbs from "@/components/ui/Breadcrumbs";
+import { useToast } from "@/hooks/use-toast";
+import {
+  complianceService,
+  type ComplianceAlert,
+  type ComplianceRecord,
+  type ComplianceType,
+} from "@/services/compliance.service";
+import { vehiclesService, type Vehicle as VehicleType } from "@/services/vehicles.service";
+
+const COMPLIANCE_TYPES: ComplianceType[] = [
+  "INSPECTION",
+  "INSURANCE",
+  "ROADWORTHINESS",
+  "PERMIT",
+  "TAX",
+];
+
+const severityColor = (severity: ComplianceAlert["severity"]) =>
+  severity === "OVERDUE" ? "red" : "yellow";
+
+const statusColor = (status: ComplianceRecord["status"]) => {
+  if (status === "EXPIRED") return "red";
+  if (status === "EXPIRING") return "yellow";
+  return "green";
+};
+
+const formatDate = (value?: string | null) =>
+  value ? new Date(value).toLocaleDateString() : "—";
+
+const emptyForm = {
+  vehicleId: "",
+  type: "INSPECTION" as ComplianceType,
+  documentNumber: "",
+  issuedDate: "",
+  expiryDate: new Date().toISOString().split("T")[0],
+  notes: "",
+};
+
+export default function CompliancePage() {
+  const { toast } = useToast();
+  const qc = useQueryClient();
+  const [modalOpen, setModalOpen] = useState(false);
+  const [formData, setFormData] = useState(emptyForm);
+
+  const { data: vehiclesData } = useQuery({
+    queryKey: ["vehicles", "compliance-select"],
+    queryFn: async () => {
+      const res = await vehiclesService.getAll({ limit: 1000 });
+      return res.data || [];
+    },
+  });
+
+  const { data: alerts = [], isLoading: isLoadingAlerts } = useQuery({
+    queryKey: ["compliance", "alerts"],
+    queryFn: async () => {
+      const res = await complianceService.getAlerts();
+      return res.data || [];
+    },
+  });
+
+  const { data: records = [], isLoading: isLoadingRecords } = useQuery({
+    queryKey: ["compliance"],
+    queryFn: async () => {
+      const res = await complianceService.list();
+      return res.data || [];
+    },
+  });
+
+  const createMutation = useMutation({
+    mutationFn: async (data: typeof formData) => {
+      const res = await complianceService.create({
+        vehicleId: data.vehicleId,
+        type: data.type,
+        expiryDate: data.expiryDate,
+        documentNumber: data.documentNumber || undefined,
+        issuedDate: data.issuedDate || undefined,
+        notes: data.notes || undefined,
+      });
+      return res.data;
+    },
+    onSuccess: () => {
+      toast({ title: "Compliance record created" });
+      setModalOpen(false);
+      setFormData(emptyForm);
+      qc.invalidateQueries({ queryKey: ["compliance"] });
+      qc.invalidateQueries({ queryKey: ["compliance", "alerts"] });
+    },
+    onError: (error: any) => {
+      toast({
+        title: "Error creating record",
+        description:
+          error?.response?.data?.message || "Failed to create compliance record",
+        variant: "destructive",
+      });
+    },
+  });
+
+  const vehicleOptions =
+    vehiclesData?.map((v: VehicleType) => ({
+      value: v.id,
+      label: `${v.plateNumber ?? v.code ?? v.id} - ${v.manufacturer ?? ""} ${v.model ?? ""}`.trim(),
+    })) || [];
+
+  const vehicleLabel = (record: ComplianceRecord) =>
+    record.vehicle?.plateNumber ||
+    vehiclesData?.find((v) => v.id === record.vehicleId)?.plateNumber ||
+    record.vehicleId;
+
+  const overdueCount = (alerts as ComplianceAlert[]).filter(
+    (a) => a.severity === "OVERDUE",
+  ).length;
+  const dueSoonCount = (alerts as ComplianceAlert[]).filter(
+    (a) => a.severity === "DUE_SOON",
+  ).length;
+
+  return (
+    <Container size="xl" py="xl" px="lg">
+      <Breadcrumbs items={[{ label: "Fleet" }, { label: "Compliance" }]} />
+
+      <Group justify="space-between" mb="lg">
+        <Title order={1}>Compliance & Alerts</Title>
+        <Button
+          leftSection={<Plus size={16} />}
+          onClick={() => setModalOpen(true)}
+          color="edr-green"
+        >
+          New Record
+        </Button>
+      </Group>
+
+      {/* Alerts */}
+      <Group mb="sm" gap="xs">
+        <AlertTriangle size={18} />
+        <Title order={3}>Expiry Alerts</Title>
+        {overdueCount > 0 && (
+          <Badge color="red" variant="light">
+            {overdueCount} overdue
+          </Badge>
+        )}
+        {dueSoonCount > 0 && (
+          <Badge color="yellow" variant="light">
+            {dueSoonCount} due soon
+          </Badge>
+        )}
+      </Group>
+
+      {isLoadingAlerts ? (
+        <Group justify="center" py="md" mb="lg">
+          <Loader size="sm" />
+        </Group>
+      ) : (alerts as ComplianceAlert[]).length === 0 ? (
+        <Card withBorder padding="lg" mb="lg">
+          <Text c="dimmed" ta="center">
+            No compliance items are overdue or due soon. All clear.
+          </Text>
+        </Card>
+      ) : (
+        <Grid mb="lg">
+          {(alerts as ComplianceAlert[]).map((alert, index) => (
+            <Grid.Col
+              key={`${alert.vehicleId}-${alert.kind}-${index}`}
+              span={{ base: 12, sm: 6, md: 4 }}
+            >
+              <Card withBorder padding="md" h="100%">
+                <Group justify="space-between" mb="xs">
+                  <Badge color={severityColor(alert.severity)}>
+                    {alert.severity === "OVERDUE" ? "Overdue" : "Due Soon"}
+                  </Badge>
+                  <Text size="sm" c="dimmed">
+                    {alert.daysUntil < 0
+                      ? `${Math.abs(alert.daysUntil)}d ago`
+                      : `in ${alert.daysUntil}d`}
+                  </Text>
+                </Group>
+                <Text fw={600}>{alert.label}</Text>
+                <Text size="sm" c="dimmed">
+                  {alert.vehiclePlate || alert.vehicleId}
+                </Text>
+                <Text size="sm" mt="xs">
+                  Expires {formatDate(alert.expiryDate)}
+                </Text>
+              </Card>
+            </Grid.Col>
+          ))}
+        </Grid>
+      )}
+
+      {/* Records */}
+      <Title order={3} mb="sm">
+        Compliance Records
+      </Title>
+      <Card withBorder>
+        <Table striped highlightOnHover>
+          <Table.Thead>
+            <Table.Tr>
+              <Table.Th>Vehicle</Table.Th>
+              <Table.Th>Type</Table.Th>
+              <Table.Th>Document #</Table.Th>
+              <Table.Th>Issued</Table.Th>
+              <Table.Th>Expiry</Table.Th>
+              <Table.Th>Status</Table.Th>
+            </Table.Tr>
+          </Table.Thead>
+          <Table.Tbody>
+            {isLoadingRecords ? (
+              <Table.Tr>
+                <Table.Td colSpan={6}>
+                  <Group justify="center" py="md">
+                    <Loader size="sm" />
+                  </Group>
+                </Table.Td>
+              </Table.Tr>
+            ) : (records as ComplianceRecord[]).length === 0 ? (
+              <Table.Tr>
+                <Table.Td colSpan={6}>
+                  <Text c="dimmed" ta="center" py="md">
+                    No compliance records yet.
+                  </Text>
+                </Table.Td>
+              </Table.Tr>
+            ) : null}
+            {(records as ComplianceRecord[]).map((record) => (
+              <Table.Tr key={record.id}>
+                <Table.Td>{vehicleLabel(record)}</Table.Td>
+                <Table.Td>
+                  <Badge variant="light" size="sm">
+                    {record.type}
+                  </Badge>
+                </Table.Td>
+                <Table.Td>{record.documentNumber || "—"}</Table.Td>
+                <Table.Td>{formatDate(record.issuedDate)}</Table.Td>
+                <Table.Td>{formatDate(record.expiryDate)}</Table.Td>
+                <Table.Td>
+                  <Badge color={statusColor(record.status)} size="sm">
+                    {record.status}
+                  </Badge>
+                </Table.Td>
+              </Table.Tr>
+            ))}
+          </Table.Tbody>
+        </Table>
+      </Card>
+
+      {/* Modal */}
+      <Modal
+        opened={modalOpen}
+        onClose={() => setModalOpen(false)}
+        title="New Compliance Record"
+        size="lg"
+      >
+        <Stack gap="md">
+          <Select
+            label="Vehicle"
+            placeholder="Select vehicle"
+            data={vehicleOptions}
+            value={formData.vehicleId}
+            onChange={(val) => setFormData({ ...formData, vehicleId: val || "" })}
+            searchable
+            required
+          />
+
+          <Select
+            label="Type"
+            data={COMPLIANCE_TYPES.map((t) => ({ value: t, label: t }))}
+            value={formData.type}
+            onChange={(val) =>
+              setFormData({ ...formData, type: (val as ComplianceType) || "INSPECTION" })
+            }
+            required
+          />
+
+          <TextInput
+            label="Document Number"
+            placeholder="Optional"
+            value={formData.documentNumber}
+            onChange={(e) =>
+              setFormData({ ...formData, documentNumber: e.currentTarget.value })
+            }
+          />
+
+          <TextInput
+            label="Issued Date"
+            type="date"
+            value={formData.issuedDate}
+            onChange={(e) =>
+              setFormData({ ...formData, issuedDate: e.currentTarget.value })
+            }
+          />
+
+          <TextInput
+            label="Expiry Date"
+            type="date"
+            value={formData.expiryDate}
+            onChange={(e) =>
+              setFormData({ ...formData, expiryDate: e.currentTarget.value })
+            }
+            required
+          />
+
+          <TextInput
+            label="Notes"
+            placeholder="Optional notes"
+            value={formData.notes}
+            onChange={(e) => setFormData({ ...formData, notes: e.currentTarget.value })}
+          />
+
+          <Group justify="flex-end">
+            <Button variant="light" onClick={() => setModalOpen(false)}>
+              Cancel
+            </Button>
+            <Button
+              onClick={() => createMutation.mutate(formData)}
+              loading={createMutation.isPending}
+              disabled={!formData.vehicleId || !formData.expiryDate}
+            >
+              Create Record
+            </Button>
+          </Group>
+        </Stack>
+      </Modal>
+    </Container>
+  );
+}
diff --git a/apps/edr-freight-web/backoffice/src/pages/fleet/DriverDetailPage.tsx b/apps/edr-freight-web/backoffice/src/pages/fleet/DriverDetailPage.tsx
index d5e8655be..c97d7c418 100644
--- a/apps/edr-freight-web/backoffice/src/pages/fleet/DriverDetailPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/fleet/DriverDetailPage.tsx
@@ -1,9 +1,10 @@
-import { useMemo } from "react";
+import { useMemo, useState } from "react";
 import { useParams, useNavigate } from "react-router-dom";
-import { useQuery } from "@tanstack/react-query";
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
 import {
   ActionIcon,
   Badge,
+  Button,
   Card,
   Center,
   Container,
@@ -17,11 +18,18 @@ import {
   Timeline,
   Title,
 } from "@mantine/core";
+import { SmartFileInput } from "@edr/ui-common";
+import type { IFileUploadSetting } from "@edr/types/freight";
 import {
   ArrowLeft,
+  Download,
+  Eye,
+  FileText,
   History,
   Route,
   ShieldCheck,
+  Trash2,
+  Upload,
   Truck,
   User,
 } from "lucide-react";
@@ -29,6 +37,8 @@ import {
 import { driversService } from "@/services/drivers.service";
 import { vehiclesService } from "@/services/vehicles.service";
 import { fleetHistoryService, type FleetHistoryEvent } from "@/services/fleet-history.service";
+import { fileUploadSettingsService } from "@/services/fileUploadSettings.service";
+import { useToast } from "@/hooks/use-toast";
 
 const fmtDate = (iso?: string | null) => {
   if (!iso) return "—";
@@ -55,6 +65,178 @@ const Loading = () => (
   <Center py="xl"><Loader size="sm" /></Center>
 );
 
+const fmtSize = (bytes: number) => {
+  if (!bytes) return "—";
+  const kb = bytes / 1024;
+  return kb < 1024 ? `${kb.toFixed(0)} KB` : `${(kb / 1024).toFixed(1)} MB`;
+};
+
+/** Upload-area setting code configured on the File Settings page. */
+const DRIVER_DOCS_CODE = "driver_docs";
+// Field key the FALLBACK setting is keyed on (used only when the "driver_docs"
+// upload area hasn't been configured in File Settings yet).
+const DRIVER_DOCS_KEY = "driver_docs";
+/** Fallback single-field setting so the dropzone still works before an admin
+ *  configures the "driver_docs" area in File Settings. */
+const DRIVER_DOCS_FALLBACK: IFileUploadSetting = {
+  id: "driver-docs-setting",
+  createdAt: "",
+  updatedAt: "",
+  deletedAt: null,
+  code: "driver_docs",
+  label: "Driver documents",
+  description: null,
+  entity: "other",
+  fields: [
+    {
+      id: "driver-docs-field",
+      createdAt: "",
+      updatedAt: "",
+      deletedAt: null,
+      settingId: "driver-docs-setting",
+      fileKey: DRIVER_DOCS_KEY,
+      fileLabel: "Upload driver document(s)",
+      helpText: "License, national ID, contracts, training certificates, etc.",
+      isRequired: false,
+      isMultiple: true,
+      maxFiles: 20,
+      allowedExtensions: ["pdf", "png", "jpg", "jpeg", "doc", "docx"],
+      maxSizeMb: 10,
+      order: 1,
+    },
+  ],
+};
+
+/** Driver documents upload + view area (files stored under code "driver_docs"). */
+const DriverDocuments = ({ driverId }: { driverId: string }) => {
+  const { toast } = useToast();
+  const qc = useQueryClient();
+  // Files selected per configured field key (SmartFileInput is multi-field).
+  const [selectedMap, setSelectedMap] = useState<Record<string, File | File[] | null>>({});
+  const selectedFiles = Object.values(selectedMap).flatMap((v) =>
+    Array.isArray(v) ? v : v ? [v] : [],
+  );
+
+  // Upload-area configuration from the File Settings page (code "driver_docs").
+  // Falls back to a default field until an admin configures it there.
+  const { data: setting } = useQuery({
+    queryKey: ["file-upload-setting", DRIVER_DOCS_CODE],
+    queryFn: () => fileUploadSettingsService.getByCode(DRIVER_DOCS_CODE),
+    retry: false,
+  });
+  const activeSetting = setting ?? DRIVER_DOCS_FALLBACK;
+
+  const { data: docs = [], isLoading } = useQuery({
+    queryKey: ["driver", driverId, "documents"],
+    queryFn: () => driversService.listDocuments(driverId).then((r) => r.data ?? []),
+    enabled: Boolean(driverId),
+  });
+
+  const uploadMutation = useMutation({
+    mutationFn: (files: File[]) => driversService.uploadDocuments(driverId, files),
+    onSuccess: () => {
+      toast({ title: "Documents uploaded" });
+      void qc.invalidateQueries({ queryKey: ["driver", driverId, "documents"] });
+    },
+    onError: (err: unknown) => {
+      const description =
+        (err as { response?: { data?: { message?: string } } })?.response?.data?.message ??
+        "Upload failed";
+      toast({ title: "Upload failed", description, variant: "destructive" });
+    },
+  });
+
+  const removeMutation = useMutation({
+    mutationFn: (fileId: string) => driversService.removeDocument(driverId, fileId),
+    onSuccess: () => {
+      toast({ title: "Document deleted" });
+      void qc.invalidateQueries({ queryKey: ["driver", driverId, "documents"] });
+    },
+    onError: () => toast({ title: "Delete failed", variant: "destructive" }),
+  });
+
+  // /files/:id is a public inline-serving route; open directly for preview/download.
+  const fileUrl = (fileId: string, download = false) =>
+    `${import.meta.env.VITE_API_URL}/files/${fileId}${download ? "?download=1" : ""}`;
+
+  return (
+    <Card withBorder padding="lg" radius="md">
+      <Stack gap="md" mb="lg">
+        <Text fw={600} size="sm">{activeSetting.label ?? "Upload documents"}</Text>
+        <SmartFileInput
+          file={activeSetting}
+          value={selectedMap}
+          onChange={setSelectedMap}
+        />
+        <Group justify="flex-end">
+          <Button
+            size="xs"
+            leftSection={<Upload size={14} />}
+            loading={uploadMutation.isPending}
+            disabled={selectedFiles.length === 0}
+            onClick={() =>
+              uploadMutation.mutate(selectedFiles, { onSuccess: () => setSelectedMap({}) })
+            }
+          >
+            Upload {selectedFiles.length > 0 ? `(${selectedFiles.length})` : ""}
+          </Button>
+        </Group>
+      </Stack>
+
+      <Text fw={600} size="sm" mb="sm">Uploaded documents ({docs.length})</Text>
+      {isLoading ? (
+        <Loading />
+      ) : docs.length === 0 ? (
+        <Text c="dimmed" size="sm" ta="center" py="md">No documents uploaded yet.</Text>
+      ) : (
+        <Table highlightOnHover>
+          <Table.Thead>
+            <Table.Tr>
+              <Table.Th>Name</Table.Th>
+              <Table.Th>Size</Table.Th>
+              <Table.Th>Uploaded</Table.Th>
+              <Table.Th ta="right">Actions</Table.Th>
+            </Table.Tr>
+          </Table.Thead>
+          <Table.Tbody>
+            {docs.map((doc) => (
+              <Table.Tr key={doc.id}>
+                <Table.Td>
+                  <Group gap="xs" wrap="nowrap">
+                    <FileText size={15} />
+                    <Text size="sm" truncate>{doc.name}</Text>
+                  </Group>
+                </Table.Td>
+                <Table.Td>{fmtSize(doc.size)}</Table.Td>
+                <Table.Td>{fmtDate(doc.createdAt)}</Table.Td>
+                <Table.Td>
+                  <Group gap={4} justify="flex-end" wrap="nowrap">
+                    <ActionIcon variant="subtle" aria-label="View" onClick={() => window.open(fileUrl(doc.id), "_blank")}>
+                      <Eye size={16} />
+                    </ActionIcon>
+                    <ActionIcon variant="subtle" aria-label="Download" onClick={() => window.open(fileUrl(doc.id, true), "_blank")}>
+                      <Download size={16} />
+                    </ActionIcon>
+                    <ActionIcon
+                      variant="subtle"
+                      color="red"
+                      aria-label="Delete"
+                      loading={removeMutation.isPending && removeMutation.variables === doc.id}
+                      onClick={() => removeMutation.mutate(doc.id)}
+                    >
+                      <Trash2 size={16} />
+                    </ActionIcon>
+                  </Group>
+                </Table.Td>
+              </Table.Tr>
+            ))}
+          </Table.Tbody>
+        </Table>
+      )}
+    </Card>
+  );
+};
+
 const DriverDetailPage = () => {
   const { id = "" } = useParams<{ id: string }>();
   const navigate = useNavigate();
@@ -106,6 +288,7 @@ const DriverDetailPage = () => {
             <Tabs.Tab value="vehicles" leftSection={<Truck size={14} />}>Vehicles</Tabs.Tab>
             <Tabs.Tab value="history" leftSection={<History size={14} />}>History</Tabs.Tab>
             <Tabs.Tab value="trips" leftSection={<Route size={14} />}>Trips</Tabs.Tab>
+            <Tabs.Tab value="documents" leftSection={<FileText size={14} />}>Documents</Tabs.Tab>
           </Tabs.List>
 
           <Tabs.Panel value="overview" pt="lg">
@@ -149,6 +332,10 @@ const DriverDetailPage = () => {
           <Tabs.Panel value="trips" pt="lg">
             <TripsTab driverId={id} />
           </Tabs.Panel>
+
+          <Tabs.Panel value="documents" pt="lg">
+            <DriverDocuments driverId={id} />
+          </Tabs.Panel>
         </Tabs>
       )}
     </Container>
diff --git a/apps/edr-freight-web/backoffice/src/pages/fleet/FleetResourcePage.tsx b/apps/edr-freight-web/backoffice/src/pages/fleet/FleetResourcePage.tsx
index f7bee5b41..93c02682a 100644
--- a/apps/edr-freight-web/backoffice/src/pages/fleet/FleetResourcePage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/fleet/FleetResourcePage.tsx
@@ -13,6 +13,7 @@ import FleetFormDialog from "@/components/fleet/FleetFormDialog";
 import FleetHistoryModal from "@/components/fleet/FleetHistoryModal";
 import FleetRecordActions from "@/components/fleet/FleetRecordActions";
 import FleetToolbar from "@/components/fleet/FleetToolbar";
+import WagonMovementHistoryModal from "@/components/fleet/WagonMovementHistoryModal";
 import { formatFleetCell, registerFleetOptionLabels } from "@/components/fleet/fleetFormat";
 import { useFleetViewMode } from "@/components/fleet/useFleetViewMode";
 import { ruleEngineTable } from "@/components/ruleEngine/ruleEngineStyles";
@@ -393,7 +394,7 @@ const FleetResourcePage = () => {
                       <Group key={filter.key} gap={4} wrap="wrap">
                         <Text size="xs" fw={500} c="dimmed">{filter.label}:</Text>
                         <Group gap={4} wrap="wrap">
-                          {[{ value: "ALL", label: "All" }, ...filter.data].map((option) => (
+                          {filter.data.map((option) => (
                             <Button
                               key={option.value}
                               size="xs"
@@ -585,12 +586,20 @@ const FleetResourcePage = () => {
         </Stack>
       </Modal>
 
-      <FleetHistoryModal
-        opened={Boolean(historyTarget)}
-        onClose={() => setHistoryTarget(null)}
-        entity={slug === "vehicles" ? "vehicle" : "driver"}
-        record={historyTarget}
-      />
+      {slug === "wagons" ? (
+        <WagonMovementHistoryModal
+          opened={Boolean(historyTarget)}
+          onClose={() => setHistoryTarget(null)}
+          record={historyTarget}
+        />
+      ) : (
+        <FleetHistoryModal
+          opened={Boolean(historyTarget)}
+          onClose={() => setHistoryTarget(null)}
+          entity={slug === "vehicles" ? "vehicle" : "driver"}
+          record={historyTarget}
+        />
+      )}
     </Container>
   );
 };
diff --git a/apps/edr-freight-web/backoffice/src/pages/fleet/IncidentsPage.tsx b/apps/edr-freight-web/backoffice/src/pages/fleet/IncidentsPage.tsx
new file mode 100644
index 000000000..2d947b73a
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/pages/fleet/IncidentsPage.tsx
@@ -0,0 +1,399 @@
+import { useState } from "react";
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import {
+  Button,
+  Card,
+  Container,
+  Group,
+  Loader,
+  Modal,
+  NumberInput,
+  Select,
+  Stack,
+  Table,
+  Text,
+  Textarea,
+  TextInput,
+  Title,
+  Badge,
+  Grid,
+} from "@mantine/core";
+import { Plus } from "lucide-react";
+import Breadcrumbs from "@/components/ui/Breadcrumbs";
+import { useToast } from "@/hooks/use-toast";
+import {
+  incidentsService,
+  type Incident,
+  type IncidentSeverity,
+  type IncidentStatus,
+  type IncidentType,
+  type SaveIncidentPayload,
+} from "@/services/incidents.service";
+import { vehiclesService, type Vehicle as VehicleType } from "@/services/vehicles.service";
+import { driversService, type Driver as DriverType } from "@/services/drivers.service";
+
+const TYPE_OPTIONS: IncidentType[] = [
+  "ACCIDENT",
+  "BREAKDOWN",
+  "TRAFFIC_VIOLATION",
+  "THEFT",
+  "OTHER",
+];
+const SEVERITY_OPTIONS: IncidentSeverity[] = ["MINOR", "MODERATE", "MAJOR", "CRITICAL"];
+
+const TYPE_COLORS: Record<IncidentType, string> = {
+  ACCIDENT: "red",
+  BREAKDOWN: "orange",
+  TRAFFIC_VIOLATION: "yellow",
+  THEFT: "grape",
+  OTHER: "gray",
+};
+
+const SEVERITY_COLORS: Record<IncidentSeverity, string> = {
+  MINOR: "gray",
+  MODERATE: "yellow",
+  MAJOR: "orange",
+  CRITICAL: "red",
+};
+
+const STATUS_COLORS: Record<IncidentStatus, string> = {
+  REPORTED: "blue",
+  UNDER_REVIEW: "yellow",
+  CLAIM_FILED: "grape",
+  RESOLVED: "teal",
+  CLOSED: "gray",
+};
+
+const OPEN_STATUSES: IncidentStatus[] = ["REPORTED", "UNDER_REVIEW", "CLAIM_FILED"];
+
+const formatMoney = (value: unknown) =>
+  `ETB ${(Number(value) || 0).toLocaleString("en-US", {
+    minimumFractionDigits: 2,
+    maximumFractionDigits: 2,
+  })}`;
+
+const initialForm = {
+  type: "ACCIDENT" as IncidentType,
+  severity: "MINOR" as IncidentSeverity,
+  occurredAt: new Date().toISOString().split("T")[0],
+  vehicleId: "",
+  driverId: "",
+  location: "",
+  description: "",
+  damageEstimate: undefined as number | undefined,
+  reportedBy: "",
+};
+
+export default function IncidentsPage() {
+  const { toast } = useToast();
+  const qc = useQueryClient();
+  const [modalOpen, setModalOpen] = useState(false);
+  const [formData, setFormData] = useState(initialForm);
+
+  // Fetch vehicles
+  const { data: vehiclesData } = useQuery({
+    queryKey: ["vehicles", "incidents-select"],
+    queryFn: async () => {
+      const res = await vehiclesService.getAll({ limit: 1000 });
+      return res.data || [];
+    },
+  });
+
+  // Fetch drivers
+  const { data: driversData } = useQuery({
+    queryKey: ["drivers", "incidents-select"],
+    queryFn: async () => {
+      const res = await driversService.getAll({ limit: 1000 });
+      return res.data || [];
+    },
+  });
+
+  // Fetch incidents
+  const { data: incidentsData = [], isLoading } = useQuery({
+    queryKey: ["incidents"],
+    queryFn: async () => {
+      const res = await incidentsService.getAll();
+      return res.data || [];
+    },
+  });
+
+  const createMutation = useMutation({
+    mutationFn: async (data: typeof formData) => {
+      const payload: SaveIncidentPayload = {
+        type: data.type,
+        severity: data.severity,
+        occurredAt: new Date(data.occurredAt).toISOString(),
+        description: data.description,
+      };
+      if (data.vehicleId) payload.vehicleId = data.vehicleId;
+      if (data.driverId) payload.driverId = data.driverId;
+      if (data.location) payload.location = data.location;
+      if (data.damageEstimate != null) payload.damageEstimate = Number(data.damageEstimate);
+      if (data.reportedBy) payload.reportedBy = data.reportedBy;
+      const res = await incidentsService.create(payload);
+      return res.data;
+    },
+    onSuccess: () => {
+      toast({ title: "Incident reported" });
+      setModalOpen(false);
+      setFormData(initialForm);
+      qc.invalidateQueries({ queryKey: ["incidents"] });
+    },
+    onError: (error: any) => {
+      toast({
+        title: "Error reporting incident",
+        description: error?.response?.data?.message || "Failed to report incident",
+        variant: "destructive",
+      });
+    },
+  });
+
+  const vehicleOptions =
+    vehiclesData?.map((v: VehicleType) => ({
+      value: v.id,
+      label: `${v.plateNumber} - ${v.manufacturer} ${v.model}`,
+    })) || [];
+
+  const driverOptions =
+    driversData?.map((d: DriverType) => ({
+      value: d.id,
+      label: `${d.firstName} ${d.lastName}${d.licenseNumber ? ` (${d.licenseNumber})` : ""}`,
+    })) || [];
+
+  const incidents = incidentsData as Incident[];
+  const totalCount = incidents.length;
+  const openCount = incidents.filter((i) => OPEN_STATUSES.includes(i.status)).length;
+  const underReviewCount = incidents.filter((i) => i.status === "UNDER_REVIEW").length;
+  const resolvedCount = incidents.filter((i) => i.status === "RESOLVED").length;
+
+  const vehicleLabel = (incident: Incident) =>
+    incident.vehicle?.plateNumber ||
+    incident.vehicle?.registrationNumber ||
+    incident.vehicleId ||
+    "—";
+
+  const driverLabel = (incident: Incident) => {
+    if (incident.driver) {
+      const name = `${incident.driver.firstName ?? ""} ${incident.driver.lastName ?? ""}`.trim();
+      if (name) return name;
+    }
+    return incident.driverId || "—";
+  };
+
+  return (
+    <Container size="xl" py="xl" px="lg">
+      <Breadcrumbs items={[{ label: "Fleet" }, { label: "Incidents" }]} />
+
+      <Group justify="space-between" mb="lg">
+        <Title order={1}>Accidents &amp; Incidents</Title>
+        <Button leftSection={<Plus size={16} />} onClick={() => setModalOpen(true)} color="edr-green">
+          Report Incident
+        </Button>
+      </Group>
+
+      {/* Stats Cards */}
+      <Grid mb="lg">
+        <Grid.Col span={{ base: 12, sm: 6, md: 3 }}>
+          <Card withBorder padding="lg">
+            <Text size="sm" c="dimmed" fw={500}>
+              Total Incidents
+            </Text>
+            <Text fw={700} size="lg">
+              {totalCount}
+            </Text>
+          </Card>
+        </Grid.Col>
+        <Grid.Col span={{ base: 12, sm: 6, md: 3 }}>
+          <Card withBorder padding="lg">
+            <Text size="sm" c="dimmed" fw={500}>
+              Open
+            </Text>
+            <Text fw={700} size="lg">
+              {openCount}
+            </Text>
+          </Card>
+        </Grid.Col>
+        <Grid.Col span={{ base: 12, sm: 6, md: 3 }}>
+          <Card withBorder padding="lg">
+            <Text size="sm" c="dimmed" fw={500}>
+              Under Review
+            </Text>
+            <Text fw={700} size="lg">
+              {underReviewCount}
+            </Text>
+          </Card>
+        </Grid.Col>
+        <Grid.Col span={{ base: 12, sm: 6, md: 3 }}>
+          <Card withBorder padding="lg">
+            <Text size="sm" c="dimmed" fw={500}>
+              Resolved
+            </Text>
+            <Text fw={700} size="lg">
+              {resolvedCount}
+            </Text>
+          </Card>
+        </Grid.Col>
+      </Grid>
+
+      {/* Incidents Table */}
+      <Card withBorder>
+        <Table striped highlightOnHover>
+          <Table.Thead>
+            <Table.Tr>
+              <Table.Th>Date</Table.Th>
+              <Table.Th>Type</Table.Th>
+              <Table.Th>Severity</Table.Th>
+              <Table.Th>Vehicle</Table.Th>
+              <Table.Th>Driver</Table.Th>
+              <Table.Th align="right">Damage</Table.Th>
+              <Table.Th>Status</Table.Th>
+            </Table.Tr>
+          </Table.Thead>
+          <Table.Tbody>
+            {isLoading ? (
+              <Table.Tr>
+                <Table.Td colSpan={7}>
+                  <Group justify="center" py="md">
+                    <Loader size="sm" />
+                  </Group>
+                </Table.Td>
+              </Table.Tr>
+            ) : incidents.length === 0 ? (
+              <Table.Tr>
+                <Table.Td colSpan={7}>
+                  <Text c="dimmed" ta="center" py="md">
+                    No incidents recorded yet.
+                  </Text>
+                </Table.Td>
+              </Table.Tr>
+            ) : null}
+            {incidents.map((incident) => (
+              <Table.Tr key={incident.id}>
+                <Table.Td>{new Date(incident.occurredAt).toLocaleDateString()}</Table.Td>
+                <Table.Td>
+                  <Badge size="sm" color={TYPE_COLORS[incident.type]}>
+                    {incident.type.replace(/_/g, " ")}
+                  </Badge>
+                </Table.Td>
+                <Table.Td>
+                  <Badge size="sm" color={SEVERITY_COLORS[incident.severity]}>
+                    {incident.severity}
+                  </Badge>
+                </Table.Td>
+                <Table.Td>{vehicleLabel(incident)}</Table.Td>
+                <Table.Td>{driverLabel(incident)}</Table.Td>
+                <Table.Td align="right">
+                  {incident.damageEstimate != null ? formatMoney(incident.damageEstimate) : "—"}
+                </Table.Td>
+                <Table.Td>
+                  <Badge size="sm" color={STATUS_COLORS[incident.status]} variant="light">
+                    {incident.status.replace(/_/g, " ")}
+                  </Badge>
+                </Table.Td>
+              </Table.Tr>
+            ))}
+          </Table.Tbody>
+        </Table>
+      </Card>
+
+      {/* Modal */}
+      <Modal opened={modalOpen} onClose={() => setModalOpen(false)} title="Report Incident" size="lg">
+        <Stack gap="md">
+          <Select
+            label="Type"
+            data={TYPE_OPTIONS.map((t) => ({ value: t, label: t.replace(/_/g, " ") }))}
+            value={formData.type}
+            onChange={(val) => setFormData({ ...formData, type: (val as IncidentType) || "ACCIDENT" })}
+            required
+          />
+
+          <Select
+            label="Severity"
+            data={SEVERITY_OPTIONS.map((s) => ({ value: s, label: s }))}
+            value={formData.severity}
+            onChange={(val) =>
+              setFormData({ ...formData, severity: (val as IncidentSeverity) || "MINOR" })
+            }
+            required
+          />
+
+          <TextInput
+            label="Occurred At"
+            type="date"
+            value={formData.occurredAt}
+            onChange={(e) => setFormData({ ...formData, occurredAt: e.currentTarget.value })}
+            required
+          />
+
+          <Select
+            label="Vehicle"
+            placeholder="Select vehicle"
+            data={vehicleOptions}
+            value={formData.vehicleId || null}
+            onChange={(val) => setFormData({ ...formData, vehicleId: val || "" })}
+            clearable
+            searchable
+          />
+
+          <Select
+            label="Driver"
+            placeholder="Select driver"
+            data={driverOptions}
+            value={formData.driverId || null}
+            onChange={(val) => setFormData({ ...formData, driverId: val || "" })}
+            clearable
+            searchable
+          />
+
+          <Textarea
+            label="Description"
+            placeholder="What happened?"
+            value={formData.description}
+            onChange={(e) => setFormData({ ...formData, description: e.currentTarget.value })}
+            minRows={3}
+            required
+          />
+
+          <NumberInput
+            label="Damage Estimate (ETB)"
+            placeholder="0.00"
+            value={formData.damageEstimate}
+            onChange={(val) =>
+              setFormData({ ...formData, damageEstimate: val as number | undefined })
+            }
+            decimalScale={2}
+            min={0}
+            thousandSeparator=","
+          />
+
+          <TextInput
+            label="Location"
+            placeholder="Where did it happen?"
+            value={formData.location}
+            onChange={(e) => setFormData({ ...formData, location: e.currentTarget.value })}
+          />
+
+          <TextInput
+            label="Reported By"
+            placeholder="Optional"
+            value={formData.reportedBy}
+            onChange={(e) => setFormData({ ...formData, reportedBy: e.currentTarget.value })}
+          />
+
+          <Group justify="flex-end">
+            <Button variant="light" onClick={() => setModalOpen(false)}>
+              Cancel
+            </Button>
+            <Button
+              onClick={() => createMutation.mutate(formData)}
+              loading={createMutation.isPending}
+              disabled={!formData.description.trim()}
+            >
+              Report Incident
+            </Button>
+          </Group>
+        </Stack>
+      </Modal>
+    </Container>
+  );
+}
diff --git a/apps/edr-freight-web/backoffice/src/pages/fleet/ProcurementPage.tsx b/apps/edr-freight-web/backoffice/src/pages/fleet/ProcurementPage.tsx
new file mode 100644
index 000000000..0c6bbabf0
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/pages/fleet/ProcurementPage.tsx
@@ -0,0 +1,665 @@
+import { useState } from "react";
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import {
+  Badge,
+  Button,
+  Card,
+  Container,
+  Group,
+  Loader,
+  Modal,
+  NumberInput,
+  Select,
+  Stack,
+  Switch,
+  Table,
+  Tabs,
+  Text,
+  TextInput,
+  Title,
+} from "@mantine/core";
+import { Plus } from "lucide-react";
+import Breadcrumbs from "@/components/ui/Breadcrumbs";
+import { useToast } from "@/hooks/use-toast";
+import { vehiclesService, type Vehicle } from "@/services/vehicles.service";
+import {
+  procurementService,
+  type AssetAcquisition,
+  type AssetDisposal,
+  type Vendor,
+  type AcquisitionType,
+  type AcquisitionStatus,
+  type VendorType,
+  type DisposalMethod,
+} from "@/services/procurement.service";
+
+const money = (x: number | null | undefined) =>
+  `ETB ${(Number(x) || 0).toLocaleString("en-US", {
+    minimumFractionDigits: 2,
+    maximumFractionDigits: 2,
+  })}`;
+
+const ACQUISITION_TYPES: AcquisitionType[] = ["PURCHASE", "LEASE", "RENTAL"];
+const ACQUISITION_STATUSES: AcquisitionStatus[] = ["ACTIVE", "LEASE_EXPIRING", "DISPOSED"];
+const VENDOR_TYPES: VendorType[] = ["DEALER", "LEASING", "PARTS", "SERVICE", "OTHER"];
+const DISPOSAL_METHODS: DisposalMethod[] = ["SALE", "SCRAP", "RETURN_LEASE", "TRADE_IN"];
+
+const typeBadgeColor = (t: AcquisitionType) =>
+  t === "PURCHASE" ? "green" : t === "LEASE" ? "blue" : "grape";
+const statusBadgeColor = (s: AcquisitionStatus) =>
+  s === "ACTIVE" ? "green" : s === "LEASE_EXPIRING" ? "yellow" : "gray";
+
+const vehicleLabel = (
+  v?: { plateNumber?: string | null; registrationNumber?: string | null } | null,
+  fallback?: string | null,
+) => v?.plateNumber || v?.registrationNumber || fallback || "—";
+
+// Strip empty strings / null / undefined before sending to the API (ValidationPipe rejects "" for UUID fields).
+const clean = <T extends Record<string, unknown>>(obj: T): Partial<T> =>
+  Object.fromEntries(
+    Object.entries(obj).filter(([, v]) => v !== "" && v !== undefined && v !== null),
+  ) as Partial<T>;
+
+const emptyAcquisition = {
+  vehicleId: "",
+  vendorId: "",
+  acquisitionType: "PURCHASE" as AcquisitionType,
+  acquisitionDate: new Date().toISOString().split("T")[0],
+  cost: undefined as number | undefined,
+  usefulLifeMonths: undefined as number | undefined,
+  salvageValue: undefined as number | undefined,
+  leaseStart: "",
+  leaseEnd: "",
+  monthlyPayment: undefined as number | undefined,
+  status: "ACTIVE" as AcquisitionStatus,
+  notes: "",
+};
+
+const emptyVendor = {
+  name: "",
+  type: "" as VendorType | "",
+  contactPerson: "",
+  phone: "",
+  email: "",
+  address: "",
+  isActive: true,
+};
+
+const emptyDisposal = {
+  vehicleId: "",
+  disposalDate: new Date().toISOString().split("T")[0],
+  method: "SALE" as DisposalMethod,
+  salePrice: undefined as number | undefined,
+  buyer: "",
+  notes: "",
+};
+
+export default function ProcurementPage() {
+  const { toast } = useToast();
+  const qc = useQueryClient();
+
+  const [tab, setTab] = useState<string>("acquisitions");
+  const [acqModalOpen, setAcqModalOpen] = useState(false);
+  const [vendorModalOpen, setVendorModalOpen] = useState(false);
+  const [disposalModalOpen, setDisposalModalOpen] = useState(false);
+
+  const [acqForm, setAcqForm] = useState({ ...emptyAcquisition });
+  const [vendorForm, setVendorForm] = useState({ ...emptyVendor });
+  const [disposalForm, setDisposalForm] = useState({ ...emptyDisposal });
+
+  // ---- Queries ----
+  const { data: vehiclesData } = useQuery({
+    queryKey: ["vehicles", "list"],
+    queryFn: async () => {
+      const res = await vehiclesService.getAll({ limit: 1000 });
+      return res.data || [];
+    },
+  });
+
+  const { data: acquisitions = [], isLoading: loadingAcquisitions } = useQuery({
+    queryKey: ["procurement", "acquisitions"],
+    queryFn: async () => {
+      const res = await procurementService.listAcquisitions();
+      return res.data || [];
+    },
+  });
+
+  const { data: vendors = [], isLoading: loadingVendors } = useQuery({
+    queryKey: ["procurement", "vendors"],
+    queryFn: async () => {
+      const res = await procurementService.listVendors();
+      return res.data || [];
+    },
+  });
+
+  const { data: disposals = [], isLoading: loadingDisposals } = useQuery({
+    queryKey: ["procurement", "disposals"],
+    queryFn: async () => {
+      const res = await procurementService.listDisposals();
+      return res.data || [];
+    },
+  });
+
+  const vehicleOptions =
+    vehiclesData?.map((v: Vehicle) => ({
+      value: v.id,
+      label: `${v.plateNumber} - ${v.manufacturer} ${v.model}`,
+    })) || [];
+
+  const vendorOptions = vendors.map((v: Vendor) => ({ value: v.id, label: v.name }));
+
+  // ---- Mutations ----
+  const createAcquisition = useMutation({
+    mutationFn: async () => {
+      const res = await procurementService.createAcquisition(clean(acqForm) as never);
+      return res.data;
+    },
+    onSuccess: () => {
+      toast({ title: "Acquisition recorded" });
+      setAcqModalOpen(false);
+      setAcqForm({ ...emptyAcquisition });
+      qc.invalidateQueries({ queryKey: ["procurement", "acquisitions"] });
+    },
+    onError: (error: any) => {
+      toast({
+        title: "Error recording acquisition",
+        description: error?.response?.data?.message || "Failed to record acquisition",
+        variant: "destructive",
+      });
+    },
+  });
+
+  const createVendor = useMutation({
+    mutationFn: async () => {
+      const res = await procurementService.createVendor(clean(vendorForm) as never);
+      return res.data;
+    },
+    onSuccess: () => {
+      toast({ title: "Vendor created" });
+      setVendorModalOpen(false);
+      setVendorForm({ ...emptyVendor });
+      qc.invalidateQueries({ queryKey: ["procurement", "vendors"] });
+    },
+    onError: (error: any) => {
+      toast({
+        title: "Error creating vendor",
+        description: error?.response?.data?.message || "Failed to create vendor",
+        variant: "destructive",
+      });
+    },
+  });
+
+  const createDisposal = useMutation({
+    mutationFn: async () => {
+      const res = await procurementService.createDisposal(clean(disposalForm) as never);
+      return res.data;
+    },
+    onSuccess: () => {
+      toast({ title: "Disposal recorded" });
+      setDisposalModalOpen(false);
+      setDisposalForm({ ...emptyDisposal });
+      qc.invalidateQueries({ queryKey: ["procurement", "disposals"] });
+    },
+    onError: (error: any) => {
+      toast({
+        title: "Error recording disposal",
+        description: error?.response?.data?.message || "Failed to record disposal",
+        variant: "destructive",
+      });
+    },
+  });
+
+  return (
+    <Container size="xl" py="xl" px="lg">
+      <Breadcrumbs items={[{ label: "Fleet" }, { label: "Procurement" }]} />
+
+      <Group justify="space-between" mb="lg">
+        <Title order={1}>Procurement & Assets</Title>
+      </Group>
+
+      <Tabs value={tab} onChange={(val) => setTab(val || "acquisitions")}>
+        <Tabs.List mb="lg">
+          <Tabs.Tab value="acquisitions">Acquisitions</Tabs.Tab>
+          <Tabs.Tab value="vendors">Vendors</Tabs.Tab>
+          <Tabs.Tab value="disposals">Disposals</Tabs.Tab>
+        </Tabs.List>
+
+        {/* ---- Acquisitions ---- */}
+        <Tabs.Panel value="acquisitions">
+          <Group justify="flex-end" mb="md">
+            <Button
+              leftSection={<Plus size={16} />}
+              onClick={() => setAcqModalOpen(true)}
+              color="edr-green"
+            >
+              New Acquisition
+            </Button>
+          </Group>
+          <Card withBorder>
+            <Table striped highlightOnHover>
+              <Table.Thead>
+                <Table.Tr>
+                  <Table.Th>Vehicle</Table.Th>
+                  <Table.Th>Type</Table.Th>
+                  <Table.Th>Date</Table.Th>
+                  <Table.Th align="right">Cost</Table.Th>
+                  <Table.Th>Status</Table.Th>
+                </Table.Tr>
+              </Table.Thead>
+              <Table.Tbody>
+                {loadingAcquisitions ? (
+                  <Table.Tr>
+                    <Table.Td colSpan={5}>
+                      <Group justify="center" py="md">
+                        <Loader size="sm" />
+                      </Group>
+                    </Table.Td>
+                  </Table.Tr>
+                ) : acquisitions.length === 0 ? (
+                  <Table.Tr>
+                    <Table.Td colSpan={5}>
+                      <Text c="dimmed" ta="center" py="md">
+                        No acquisitions recorded yet.
+                      </Text>
+                    </Table.Td>
+                  </Table.Tr>
+                ) : null}
+                {acquisitions.map((a: AssetAcquisition) => (
+                  <Table.Tr key={a.id}>
+                    <Table.Td>{vehicleLabel(a.vehicle, a.vehicleId)}</Table.Td>
+                    <Table.Td>
+                      <Badge size="sm" color={typeBadgeColor(a.acquisitionType)}>
+                        {a.acquisitionType}
+                      </Badge>
+                    </Table.Td>
+                    <Table.Td>{new Date(a.acquisitionDate).toLocaleDateString()}</Table.Td>
+                    <Table.Td align="right">{money(a.cost)}</Table.Td>
+                    <Table.Td>
+                      <Badge size="sm" color={statusBadgeColor(a.status)}>
+                        {a.status}
+                      </Badge>
+                    </Table.Td>
+                  </Table.Tr>
+                ))}
+              </Table.Tbody>
+            </Table>
+          </Card>
+        </Tabs.Panel>
+
+        {/* ---- Vendors ---- */}
+        <Tabs.Panel value="vendors">
+          <Group justify="flex-end" mb="md">
+            <Button
+              leftSection={<Plus size={16} />}
+              onClick={() => setVendorModalOpen(true)}
+              color="edr-green"
+            >
+              New Vendor
+            </Button>
+          </Group>
+          <Card withBorder>
+            <Table striped highlightOnHover>
+              <Table.Thead>
+                <Table.Tr>
+                  <Table.Th>Name</Table.Th>
+                  <Table.Th>Type</Table.Th>
+                  <Table.Th>Contact</Table.Th>
+                  <Table.Th>Phone</Table.Th>
+                  <Table.Th>Email</Table.Th>
+                  <Table.Th>Active</Table.Th>
+                </Table.Tr>
+              </Table.Thead>
+              <Table.Tbody>
+                {loadingVendors ? (
+                  <Table.Tr>
+                    <Table.Td colSpan={6}>
+                      <Group justify="center" py="md">
+                        <Loader size="sm" />
+                      </Group>
+                    </Table.Td>
+                  </Table.Tr>
+                ) : vendors.length === 0 ? (
+                  <Table.Tr>
+                    <Table.Td colSpan={6}>
+                      <Text c="dimmed" ta="center" py="md">
+                        No vendors added yet.
+                      </Text>
+                    </Table.Td>
+                  </Table.Tr>
+                ) : null}
+                {vendors.map((v: Vendor) => (
+                  <Table.Tr key={v.id}>
+                    <Table.Td>{v.name}</Table.Td>
+                    <Table.Td>{v.type ? <Badge size="sm">{v.type}</Badge> : "—"}</Table.Td>
+                    <Table.Td>{v.contactPerson || "—"}</Table.Td>
+                    <Table.Td>{v.phone || "—"}</Table.Td>
+                    <Table.Td>{v.email || "—"}</Table.Td>
+                    <Table.Td>
+                      <Badge size="sm" color={v.isActive ? "green" : "gray"}>
+                        {v.isActive ? "Active" : "Inactive"}
+                      </Badge>
+                    </Table.Td>
+                  </Table.Tr>
+                ))}
+              </Table.Tbody>
+            </Table>
+          </Card>
+        </Tabs.Panel>
+
+        {/* ---- Disposals ---- */}
+        <Tabs.Panel value="disposals">
+          <Group justify="flex-end" mb="md">
+            <Button
+              leftSection={<Plus size={16} />}
+              onClick={() => setDisposalModalOpen(true)}
+              color="edr-green"
+            >
+              New Disposal
+            </Button>
+          </Group>
+          <Card withBorder>
+            <Table striped highlightOnHover>
+              <Table.Thead>
+                <Table.Tr>
+                  <Table.Th>Vehicle</Table.Th>
+                  <Table.Th>Method</Table.Th>
+                  <Table.Th>Date</Table.Th>
+                  <Table.Th align="right">Sale Price</Table.Th>
+                  <Table.Th>Buyer</Table.Th>
+                </Table.Tr>
+              </Table.Thead>
+              <Table.Tbody>
+                {loadingDisposals ? (
+                  <Table.Tr>
+                    <Table.Td colSpan={5}>
+                      <Group justify="center" py="md">
+                        <Loader size="sm" />
+                      </Group>
+                    </Table.Td>
+                  </Table.Tr>
+                ) : disposals.length === 0 ? (
+                  <Table.Tr>
+                    <Table.Td colSpan={5}>
+                      <Text c="dimmed" ta="center" py="md">
+                        No disposals recorded yet.
+                      </Text>
+                    </Table.Td>
+                  </Table.Tr>
+                ) : null}
+                {disposals.map((d: AssetDisposal) => (
+                  <Table.Tr key={d.id}>
+                    <Table.Td>{d.vehicleId}</Table.Td>
+                    <Table.Td>
+                      <Badge size="sm">{d.method}</Badge>
+                    </Table.Td>
+                    <Table.Td>{new Date(d.disposalDate).toLocaleDateString()}</Table.Td>
+                    <Table.Td align="right">{money(d.salePrice)}</Table.Td>
+                    <Table.Td>{d.buyer || "—"}</Table.Td>
+                  </Table.Tr>
+                ))}
+              </Table.Tbody>
+            </Table>
+          </Card>
+        </Tabs.Panel>
+      </Tabs>
+
+      {/* ---- Acquisition Modal ---- */}
+      <Modal
+        opened={acqModalOpen}
+        onClose={() => setAcqModalOpen(false)}
+        title="New Acquisition"
+        size="lg"
+      >
+        <Stack gap="md">
+          <Select
+            label="Vehicle"
+            placeholder="Select vehicle"
+            data={vehicleOptions}
+            value={acqForm.vehicleId}
+            onChange={(val) => setAcqForm({ ...acqForm, vehicleId: val || "" })}
+            searchable
+            clearable
+          />
+          <Select
+            label="Vendor"
+            placeholder="Select vendor"
+            data={vendorOptions}
+            value={acqForm.vendorId}
+            onChange={(val) => setAcqForm({ ...acqForm, vendorId: val || "" })}
+            searchable
+            clearable
+          />
+          <Select
+            label="Acquisition Type"
+            data={ACQUISITION_TYPES}
+            value={acqForm.acquisitionType}
+            onChange={(val) =>
+              setAcqForm({ ...acqForm, acquisitionType: (val as AcquisitionType) || "PURCHASE" })
+            }
+            required
+          />
+          <TextInput
+            label="Acquisition Date"
+            type="date"
+            value={acqForm.acquisitionDate}
+            onChange={(e) => setAcqForm({ ...acqForm, acquisitionDate: e.currentTarget.value })}
+            required
+          />
+          <NumberInput
+            label="Cost"
+            placeholder="0.00"
+            value={acqForm.cost}
+            onChange={(val) => setAcqForm({ ...acqForm, cost: val as number | undefined })}
+            decimalScale={2}
+            min={0}
+          />
+          <NumberInput
+            label="Useful Life (months)"
+            placeholder="Optional"
+            value={acqForm.usefulLifeMonths}
+            onChange={(val) =>
+              setAcqForm({ ...acqForm, usefulLifeMonths: val as number | undefined })
+            }
+            decimalScale={0}
+            min={0}
+          />
+          <NumberInput
+            label="Salvage Value"
+            placeholder="0.00"
+            value={acqForm.salvageValue}
+            onChange={(val) => setAcqForm({ ...acqForm, salvageValue: val as number | undefined })}
+            decimalScale={2}
+            min={0}
+          />
+          <TextInput
+            label="Lease Start"
+            type="date"
+            value={acqForm.leaseStart}
+            onChange={(e) => setAcqForm({ ...acqForm, leaseStart: e.currentTarget.value })}
+          />
+          <TextInput
+            label="Lease End"
+            type="date"
+            value={acqForm.leaseEnd}
+            onChange={(e) => setAcqForm({ ...acqForm, leaseEnd: e.currentTarget.value })}
+          />
+          <NumberInput
+            label="Monthly Payment"
+            placeholder="0.00"
+            value={acqForm.monthlyPayment}
+            onChange={(val) =>
+              setAcqForm({ ...acqForm, monthlyPayment: val as number | undefined })
+            }
+            decimalScale={2}
+            min={0}
+          />
+          <Select
+            label="Status"
+            data={ACQUISITION_STATUSES}
+            value={acqForm.status}
+            onChange={(val) =>
+              setAcqForm({ ...acqForm, status: (val as AcquisitionStatus) || "ACTIVE" })
+            }
+          />
+          <TextInput
+            label="Notes"
+            placeholder="Optional notes"
+            value={acqForm.notes}
+            onChange={(e) => setAcqForm({ ...acqForm, notes: e.currentTarget.value })}
+          />
+          <Group justify="flex-end">
+            <Button variant="light" onClick={() => setAcqModalOpen(false)}>
+              Cancel
+            </Button>
+            <Button
+              onClick={() => createAcquisition.mutate()}
+              loading={createAcquisition.isPending}
+              disabled={!acqForm.acquisitionDate}
+            >
+              Save Acquisition
+            </Button>
+          </Group>
+        </Stack>
+      </Modal>
+
+      {/* ---- Vendor Modal ---- */}
+      <Modal
+        opened={vendorModalOpen}
+        onClose={() => setVendorModalOpen(false)}
+        title="New Vendor"
+        size="lg"
+      >
+        <Stack gap="md">
+          <TextInput
+            label="Name"
+            placeholder="Vendor name"
+            value={vendorForm.name}
+            onChange={(e) => setVendorForm({ ...vendorForm, name: e.currentTarget.value })}
+            required
+          />
+          <Select
+            label="Type"
+            placeholder="Select type"
+            data={VENDOR_TYPES}
+            value={vendorForm.type || null}
+            onChange={(val) => setVendorForm({ ...vendorForm, type: (val as VendorType) || "" })}
+            clearable
+          />
+          <TextInput
+            label="Contact Person"
+            placeholder="Optional"
+            value={vendorForm.contactPerson}
+            onChange={(e) => setVendorForm({ ...vendorForm, contactPerson: e.currentTarget.value })}
+          />
+          <TextInput
+            label="Phone"
+            placeholder="Optional"
+            value={vendorForm.phone}
+            onChange={(e) => setVendorForm({ ...vendorForm, phone: e.currentTarget.value })}
+          />
+          <TextInput
+            label="Email"
+            placeholder="Optional"
+            value={vendorForm.email}
+            onChange={(e) => setVendorForm({ ...vendorForm, email: e.currentTarget.value })}
+          />
+          <TextInput
+            label="Address"
+            placeholder="Optional"
+            value={vendorForm.address}
+            onChange={(e) => setVendorForm({ ...vendorForm, address: e.currentTarget.value })}
+          />
+          <Switch
+            label="Active"
+            checked={vendorForm.isActive}
+            onChange={(e) => setVendorForm({ ...vendorForm, isActive: e.currentTarget.checked })}
+          />
+          <Group justify="flex-end">
+            <Button variant="light" onClick={() => setVendorModalOpen(false)}>
+              Cancel
+            </Button>
+            <Button
+              onClick={() => createVendor.mutate()}
+              loading={createVendor.isPending}
+              disabled={!vendorForm.name}
+            >
+              Save Vendor
+            </Button>
+          </Group>
+        </Stack>
+      </Modal>
+
+      {/* ---- Disposal Modal ---- */}
+      <Modal
+        opened={disposalModalOpen}
+        onClose={() => setDisposalModalOpen(false)}
+        title="New Disposal"
+        size="lg"
+      >
+        <Stack gap="md">
+          <Select
+            label="Vehicle"
+            placeholder="Select vehicle"
+            data={vehicleOptions}
+            value={disposalForm.vehicleId}
+            onChange={(val) => setDisposalForm({ ...disposalForm, vehicleId: val || "" })}
+            searchable
+            required
+          />
+          <TextInput
+            label="Disposal Date"
+            type="date"
+            value={disposalForm.disposalDate}
+            onChange={(e) =>
+              setDisposalForm({ ...disposalForm, disposalDate: e.currentTarget.value })
+            }
+            required
+          />
+          <Select
+            label="Method"
+            data={DISPOSAL_METHODS}
+            value={disposalForm.method}
+            onChange={(val) =>
+              setDisposalForm({ ...disposalForm, method: (val as DisposalMethod) || "SALE" })
+            }
+            required
+          />
+          <NumberInput
+            label="Sale Price"
+            placeholder="0.00"
+            value={disposalForm.salePrice}
+            onChange={(val) =>
+              setDisposalForm({ ...disposalForm, salePrice: val as number | undefined })
+            }
+            decimalScale={2}
+            min={0}
+          />
+          <TextInput
+            label="Buyer"
+            placeholder="Optional"
+            value={disposalForm.buyer}
+            onChange={(e) => setDisposalForm({ ...disposalForm, buyer: e.currentTarget.value })}
+          />
+          <TextInput
+            label="Notes"
+            placeholder="Optional notes"
+            value={disposalForm.notes}
+            onChange={(e) => setDisposalForm({ ...disposalForm, notes: e.currentTarget.value })}
+          />
+          <Group justify="flex-end">
+            <Button variant="light" onClick={() => setDisposalModalOpen(false)}>
+              Cancel
+            </Button>
+            <Button
+              onClick={() => createDisposal.mutate()}
+              loading={createDisposal.isPending}
+              disabled={!disposalForm.vehicleId || !disposalForm.disposalDate}
+            >
+              Save Disposal
+            </Button>
+          </Group>
+        </Stack>
+      </Modal>
+    </Container>
+  );
+}
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 f60c7f72b..14bb32d33 100644
--- a/apps/edr-freight-web/backoffice/src/pages/fleet/TrackingPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/fleet/TrackingPage.tsx
@@ -1,368 +1,500 @@
-import { useState, useMemo } from 'react';
-import { useQuery } from '@tanstack/react-query';
-import { Container, Grid, Card, Stack, Group, Select, Text, Badge, Button, Box, Table, SimpleGrid } from '@mantine/core';
-import { MapPin, Navigation, Radio, Activity } from 'lucide-react';
-import Breadcrumbs from '@/components/ui/Breadcrumbs';
-import { QUERY_KEYS } from '@/constants/QUERY_KEYS';
-import { vehiclesService } from '@/services/vehicles.service';
-import { freightBrand } from '@/theme/freight-brand';
+import { useEffect, useMemo, useState } from "react";
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import {
+  ActionIcon,
+  Badge,
+  Box,
+  Button,
+  Card,
+  Container,
+  Grid,
+  Group,
+  Modal,
+  Select,
+  SimpleGrid,
+  Stack,
+  Table,
+  Text,
+  TextInput,
+} from "@mantine/core";
+import {
+  APIProvider,
+  InfoWindow,
+  Map as GoogleMap,
+  Marker,
+  useMap,
+} from "@vis.gl/react-google-maps";
+import { Activity, Pencil, Plus, Radio, Trash2 } from "lucide-react";
+import Breadcrumbs from "@/components/ui/Breadcrumbs";
+import { useToast } from "@/hooks/use-toast";
+import { vehiclesService } from "@/services/vehicles.service";
+import { gpsTrackingService, type GpsDevice } from "@/services/gps-tracking.service";
+import { freightBrand } from "@/theme/freight-brand";
 
-interface Vehicle {
-  id: string;
-  registrationNumber: string;
-  plateNumber: string;
-  manufacturer: string;
-  model: string;
-  status?: string;
+// Same default key + env override the portal's LocationPicker uses.
+const GOOGLE_MAPS_API_KEY =
+  import.meta.env.VITE_GOOGLE_MAPS_API_KEY ||
+  "AIzaSyBg4tN31-fgvH_2Ix_TPo6VSfOA2uA5CCI";
+const DEFAULT_CENTER = { lat: 9.03, lng: 38.74 }; // Addis Ababa
+
+const toNum = (v: number | string | null | undefined): number | null =>
+  v == null || v === "" ? null : Number(v);
+
+const deviceLabel = (d: GpsDevice) =>
+  d.vehicle
+    ? [d.vehicle.code, d.vehicle.plateNumber].filter(Boolean).join(" · ")
+    : d.name || d.imei;
+
+const fmtTime = (iso?: string | null) => {
+  if (!iso) return "—";
+  const d = new Date(iso);
+  return Number.isNaN(d.getTime()) ? "—" : d.toLocaleString();
+};
+
+const StatBox = ({ label, value }: { label: string; value: string }) => (
+  <Box p="sm" style={{ backgroundColor: "#f8f9fa", borderRadius: 8 }}>
+    <Text size="xs" c="dimmed">{label}</Text>
+    <Text fw={600} size="sm">{value}</Text>
+  </Box>
+);
+
+type LatLng = { lat: number; lng: number };
+
+/** Flip a flag once the map (and thus the Maps JS classes) is loaded. */
+function ReadyProbe({ onReady }: { onReady: () => void }) {
+  const map = useMap();
+  useEffect(() => {
+    if (map) onReady();
+  }, [map, onReady]);
+  return null;
 }
 
-interface GPSLocation {
+/** Fit the map to the current markers (or center on a single one). */
+function FitBounds({ points }: { points: LatLng[] }) {
+  const map = useMap();
+  useEffect(() => {
+    if (!map || points.length === 0 || typeof google === "undefined") return;
+    if (points.length === 1) {
+      map.setCenter(points[0]);
+      map.setZoom(14);
+      return;
+    }
+    const b = new google.maps.LatLngBounds();
+    points.forEach((p) => b.extend(p));
+    map.fitBounds(b, 60);
+  }, [map, points]);
+  return null;
+}
+
+/** Lazily reverse-geocode a coordinate to a human address. */
+function useAddress(lat: number, lng: number): string | null {
+  const [addr, setAddr] = useState<string | null>(null);
+  useEffect(() => {
+    if (typeof google === "undefined" || !google.maps?.Geocoder) return;
+    setAddr(null);
+    let cancelled = false;
+    new google.maps.Geocoder().geocode({ location: { lat, lng } }, (res, status) => {
+      if (cancelled) return;
+      setAddr(status === "OK" && res?.[0] ? res[0].formatted_address : "Unknown location");
+    });
+    return () => { cancelled = true; };
+  }, [lat, lng]);
+  return addr;
+}
+
+/** Hover popup: label, coordinates, speed/course, and the reverse-geocoded place. */
+function HoverInfo({
+  device,
+  lat,
+  lng,
+  onClose,
+}: {
+  device: GpsDevice;
   lat: number;
   lng: number;
-  speed?: number;
-  heading?: number;
-  lastUpdate?: string;
+  onClose: () => void;
+}) {
+  const address = useAddress(lat, lng);
+  return (
+    <InfoWindow position={{ lat, lng }} pixelOffset={[0, -46]} onCloseClick={onClose}>
+      <div style={{ minWidth: 190, fontSize: 13 }}>
+        <div style={{ fontWeight: 600, marginBottom: 2 }}>{deviceLabel(device)}</div>
+        <div style={{ fontFamily: "monospace" }}>
+          {lat.toFixed(5)}, {lng.toFixed(5)}
+        </div>
+        <div style={{ color: "#555" }}>
+          {toNum(device.lastSpeed) ?? 0} km/h · {device.lastCourse ?? 0}°
+        </div>
+        <div style={{ color: "#777", marginTop: 4 }}>{address ?? "Locating…"}</div>
+      </div>
+    </InfoWindow>
+  );
 }
 
-// Mock GPS data for demo (no real GPS backend exists — these are simulated values)
-const generateMockGPS = (): GPSLocation => ({
-  lat: 9.0 + Math.random() * 0.5,
-  lng: 38.7 + Math.random() * 0.5,
-  speed: Math.floor(Math.random() * 120),
-  heading: Math.floor(Math.random() * 360),
-  lastUpdate: new Date(Date.now() - Math.random() * 300000).toLocaleTimeString(),
-});
+/** Draw the selected vehicle's recent path as a polyline. */
+function RouteTrail({ path }: { path: LatLng[] }) {
+  const map = useMap();
+  useEffect(() => {
+    if (!map || path.length < 2 || typeof google === "undefined") return;
+    const line = new google.maps.Polyline({
+      path,
+      strokeColor: freightBrand.primary,
+      strokeOpacity: 0.85,
+      strokeWeight: 4,
+    });
+    line.setMap(map);
+    return () => line.setMap(null);
+  }, [map, path]);
+  return null;
+}
 
 export function TrackingPage() {
-  const [selectedVehicleId, setSelectedVehicleId] = useState<string | null>(null);
-  const [mapCenter] = useState({ lat: 9.0, lng: 38.8 });
+  const { toast } = useToast();
+  const qc = useQueryClient();
+  const [selectedId, setSelectedId] = useState<string | null>(null);
+  const [hoverId, setHoverId] = useState<string | null>(null);
+  const [mapsReady, setMapsReady] = useState(false);
+  const [modalOpen, setModalOpen] = useState(false);
+  const [editDevice, setEditDevice] = useState<GpsDevice | null>(null);
+  const [form, setForm] = useState({ imei: "", name: "", vehicleId: "" });
 
-  const { data: vehicles = [] } = useQuery({
-    queryKey: QUERY_KEYS.VEHICLES.list(),
-    queryFn: async () => {
-      const res = await vehiclesService.getAll({ limit: 1000 });
-      return res.data || [];
+  const openRegister = () => {
+    setEditDevice(null);
+    setForm({ imei: "", name: "", vehicleId: "" });
+    setModalOpen(true);
+  };
+  const openEdit = (d: GpsDevice) => {
+    setEditDevice(d);
+    setForm({ imei: d.imei, name: d.name ?? "", vehicleId: d.vehicleId ?? "" });
+    setModalOpen(true);
+  };
+
+  // Poll every 10s so the map tracks live movement.
+  const { data: devices = [] } = useQuery({
+    queryKey: ["gps", "devices"],
+    queryFn: async () => (await gpsTrackingService.listDevices()).data ?? [],
+    refetchInterval: 10_000,
+  });
+
+  const { data: vehiclesData } = useQuery({
+    queryKey: ["vehicles", "all"],
+    queryFn: async () => (await vehiclesService.getAll({ limit: 1000 })).data ?? [],
+  });
+  const vehicleOptions = useMemo(
+    () =>
+      (vehiclesData ?? []).map((v) => ({
+        value: v.id,
+        label: `${v.plateNumber} - ${v.manufacturer} ${v.model}`,
+      })),
+    [vehiclesData],
+  );
+
+  const positioned = useMemo(
+    () =>
+      devices
+        .map((d) => ({ d, lat: toNum(d.lastLat), lng: toNum(d.lastLng) }))
+        .filter((x): x is { d: GpsDevice; lat: number; lng: number } => x.lat != null && x.lng != null),
+    [devices],
+  );
+
+  const selected = devices.find((d) => d.id === selectedId) ?? null;
+  const onlineCount = devices.filter((d) => d.online).length;
+
+  // Route history for the selected device's vehicle (chronological trail).
+  const { data: history = [] } = useQuery({
+    queryKey: ["gps", "history", selected?.vehicleId],
+    queryFn: async () => (await gpsTrackingService.history(selected!.vehicleId!, 300)).data ?? [],
+    enabled: Boolean(selected?.vehicleId),
+  });
+  const trail = useMemo(
+    () => [...history].reverse().map((h) => ({ lat: Number(h.lat), lng: Number(h.lng) })),
+    [history],
+  );
+
+  // Teardrop pin colored by state with a white truck glyph inside.
+  const markerIcon = (d: GpsDevice, selectedFlag: boolean): google.maps.Icon | undefined => {
+    // Maps API loads async — Size/Point classes may not exist yet at first render.
+    if (typeof google === "undefined" || !google.maps?.Size || !mapsReady) return undefined;
+    const color = selectedFlag ? freightBrand.primary : d.online ? "#2f80ed" : "#95a5a6";
+    const svg = `<svg xmlns="http://www.w3.org/2000/svg" width="40" height="48" viewBox="0 0 40 48">
+      <path d="M20 2C10 2 2 10 2 20c0 12 18 26 18 26s18-14 18-26C38 10 30 2 20 2Z" fill="${color}" stroke="#ffffff" stroke-width="1.5"/>
+      <g transform="translate(8,7)" fill="none" stroke="#ffffff" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+        <path d="M14 18V6a1 1 0 0 0-1-1H2a1 1 0 0 0-1 1v11a1 1 0 0 0 1 1h1"/>
+        <path d="M15 18H9"/>
+        <path d="M19 18h2a1 1 0 0 0 1-1v-3.65a1 1 0 0 0-.22-.62l-3.48-4.35A1 1 0 0 0 17.52 8H14"/>
+        <circle cx="7" cy="18" r="2"/>
+        <circle cx="17" cy="18" r="2"/>
+      </g>
+    </svg>`;
+    return {
+      url: `data:image/svg+xml,${encodeURIComponent(svg)}`,
+      scaledSize: new google.maps.Size(40, 48),
+      anchor: new google.maps.Point(20, 48),
+    };
+  };
+
+  const saveMutation = useMutation({
+    mutationFn: () =>
+      editDevice
+        ? gpsTrackingService.update(editDevice.id, {
+            name: form.name.trim() || undefined,
+            vehicleId: form.vehicleId || null,
+          })
+        : gpsTrackingService.register({
+            imei: form.imei.trim(),
+            name: form.name.trim() || undefined,
+            vehicleId: form.vehicleId || null,
+          }),
+    onSuccess: () => {
+      toast({ title: editDevice ? "Tracker updated" : "Tracker registered" });
+      setModalOpen(false);
+      setEditDevice(null);
+      setForm({ imei: "", name: "", vehicleId: "" });
+      void qc.invalidateQueries({ queryKey: ["gps", "devices"] });
+    },
+    onError: (err: unknown) => {
+      const description =
+        (err as { response?: { data?: { message?: string } } })?.response?.data?.message ?? "Failed";
+      toast({ title: editDevice ? "Update failed" : "Registration failed", description, variant: "destructive" });
     },
   });
 
-  // Generate mock GPS data for each vehicle
-  const vehiclesWithGPS = useMemo(() => {
-    return (vehicles as Vehicle[]).map((v) => ({
-      ...v,
-      gps: generateMockGPS(),
-    }));
-  }, [vehicles]);
+  const assignMutation = useMutation({
+    mutationFn: ({ id, vehicleId }: { id: string; vehicleId: string | null }) =>
+      gpsTrackingService.update(id, { vehicleId }),
+    onSuccess: () => {
+      toast({ title: "Tracker updated" });
+      void qc.invalidateQueries({ queryKey: ["gps", "devices"] });
+    },
+    onError: () => toast({ title: "Update failed", variant: "destructive" }),
+  });
 
-  // For demo: show all vehicles as trackable (or filter by ACTIVE if status data available)
-  const trackableVehicles = useMemo(
-    () => vehiclesWithGPS.slice(0, 10), // Limit to first 10 for demo
-    [vehiclesWithGPS]
-  );
-
-  const selectedVehicle = trackableVehicles.find(v => v.id === selectedVehicleId);
-  const vehicleOptions = useMemo(
-    () => trackableVehicles.map(v => ({ label: v.registrationNumber, value: v.id })),
-    [trackableVehicles]
-  );
-
-  // Map dimensions
-  const mapWidth = 800;
-  const mapHeight = 500;
-  const pixelsPerLat = mapHeight / 0.6;
-  const pixelsPerLng = mapWidth / 0.6;
-
-  const getMapCoords = (lat: number, lng: number) => ({
-    x: ((lng - (mapCenter.lng - 0.3)) * pixelsPerLng),
-    y: ((mapCenter.lat + 0.3 - lat) * pixelsPerLat),
+  const deleteMutation = useMutation({
+    mutationFn: (id: string) => gpsTrackingService.remove(id),
+    onSuccess: () => {
+      toast({ title: "Tracker removed" });
+      setSelectedId(null);
+      void qc.invalidateQueries({ queryKey: ["gps", "devices"] });
+    },
+    onError: () => toast({ title: "Delete failed", variant: "destructive" }),
   });
 
   return (
     <Container size="xl" py="xl" px="lg">
-      <Breadcrumbs items={[{ label: 'Fleet' }, { label: 'Vehicle Tracking' }]} />
+      <Breadcrumbs items={[{ label: "Fleet" }, { label: "Vehicle Tracking" }]} />
 
-      <Stack gap="xl">
-        <Group justify="space-between">
-          <div>
-            <Group gap="xs" align="center">
-              <Text fw={700} size="xl">
-                Real-Time Vehicle Tracking
-              </Text>
-              <Badge color="yellow" variant="light">
-                Simulated GPS
-              </Badge>
-            </Group>
-            <Text c="dimmed" size="sm">
-              Monitor vehicle locations, speed, and status
-            </Text>
-          </div>
-        </Group>
+      <Group justify="space-between" mb="xl">
+        <div>
+          <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>
+      </Group>
 
-        <Grid>
-          {/* Map Section */}
-          <Grid.Col span={{ base: 12, lg: 8 }}>
-            <Card withBorder p="lg">
-              <Card.Section p="md" withBorder>
-                <Group justify="space-between">
-                  <Text fw={500}>Map View</Text>
-                  <Group gap="xs">
-                    <Badge color="edr-green" leftSection={<Radio size={12} />}>
-                      {trackableVehicles.length} Tracked
-                    </Badge>
-                  </Group>
-                </Group>
-              </Card.Section>
-
-              <Card.Section p="md">
-                <Box style={{ overflowX: 'auto', maxWidth: '100%' }}>
-                  <Box
-                    pos="relative"
-                    style={{
-                      width: mapWidth,
-                      height: mapHeight,
-                      backgroundColor: '#f0f8f7',
-                      border: `2px solid ${freightBrand.primary}`,
-                      borderRadius: '8px',
-                      overflow: 'hidden',
-                    }}
+      <Grid>
+        {/* Map */}
+        <Grid.Col span={{ base: 12, lg: 8 }}>
+          <Card withBorder p="lg">
+            <Card.Section p="md" withBorder>
+              <Group justify="space-between">
+                <Text fw={500}>Live Map</Text>
+                <Badge color="edr-green" leftSection={<Radio size={12} />}>
+                  {onlineCount} online · {positioned.length} located
+                </Badge>
+              </Group>
+            </Card.Section>
+            <Card.Section p="md">
+              <Box style={{ height: 500, width: "100%", borderRadius: 8, overflow: "hidden" }}>
+                <APIProvider apiKey={GOOGLE_MAPS_API_KEY}>
+                  <GoogleMap
+                    defaultCenter={DEFAULT_CENTER}
+                    defaultZoom={7}
+                    gestureHandling="greedy"
+                    disableDefaultUI={false}
+                    style={{ width: "100%", height: "100%" }}
                   >
-                  {/* Grid background */}
-                  <svg
-                    width={mapWidth}
-                    height={mapHeight}
-                    style={{ position: 'absolute', top: 0, left: 0 }}
-                  >
-                    {/* Latitude lines */}
-                    {[0, 1, 2, 3, 4, 5, 6].map(i => (
-                      <line
-                        key={`lat-${i}`}
-                        x1={0}
-                        y1={(i / 6) * mapHeight}
-                        x2={mapWidth}
-                        y2={(i / 6) * mapHeight}
-                        stroke="#e0e0e0"
-                        strokeWidth={1}
+                    <ReadyProbe onReady={() => setMapsReady(true)} />
+                    {positioned.map(({ d, lat, lng }) => (
+                      <Marker
+                        key={d.id}
+                        position={{ lat, lng }}
+                        title={`${deviceLabel(d)}\n${lat.toFixed(5)}, ${lng.toFixed(5)}`}
+                        icon={markerIcon(d, d.id === selectedId)}
+                        onClick={() => setSelectedId(d.id)}
+                        onMouseOver={() => setHoverId(d.id)}
                       />
                     ))}
-                    {/* Longitude lines */}
-                    {[0, 1, 2, 3, 4, 5, 6].map(i => (
-                      <line
-                        key={`lng-${i}`}
-                        x1={(i / 6) * mapWidth}
-                        y1={0}
-                        x2={(i / 6) * mapWidth}
-                        y2={mapHeight}
-                        stroke="#e0e0e0"
-                        strokeWidth={1}
-                      />
-                    ))}
-                  </svg>
-
-                  {/* Vehicle markers */}
-                  {trackableVehicles.map((vehicle) => {
-                    const coords = getMapCoords(vehicle.gps.lat, vehicle.gps.lng);
-                    const isSelected = vehicle.id === selectedVehicleId;
-
-                    return (
-                      <Box
-                        key={vehicle.id}
-                        pos="absolute"
-                        style={{
-                          left: coords.x - 15,
-                          top: coords.y - 15,
-                          width: 30,
-                          height: 30,
-                          cursor: 'pointer',
-                          zIndex: isSelected ? 100 : 10,
-                        }}
-                        onClick={() => setSelectedVehicleId(vehicle.id)}
-                        title={vehicle.registrationNumber}
-                      >
-                        <Box
-                          pos="absolute"
-                          inset={0}
-                          style={{
-                            backgroundColor: isSelected ? freightBrand.primary : '#3498db',
-                            borderRadius: '50%',
-                            border: isSelected ? `3px solid ${freightBrand.primaryDark}` : 'none',
-                            display: 'flex',
-                            alignItems: 'center',
-                            justifyContent: 'center',
-                            color: 'white',
-                            fontSize: '16px',
-                            boxShadow: isSelected ? `0 0 0 8px ${freightBrand.ring}` : 'none',
-                          }}
-                        >
-                          <Navigation size={16} />
-                        </Box>
-                      </Box>
-                    );
-                  })}
-
-                  {/* Map labels */}
-                  <Box pos="absolute" bottom={8} left={8} style={{ zIndex: 50 }}>
-                    <Text size="xs" c="dimmed">
-                      📍 Addis Ababa, Ethiopia
-                    </Text>
-                  </Box>
-                  </Box>
-                </Box>
-                <Text size="xs" c="dimmed" mt="xs">
-                  Simulated map — coordinates, speed, and heading are demo values, not live GPS.
+                    {(() => {
+                      const h = positioned.find((p) => p.d.id === hoverId);
+                      return h ? (
+                        <HoverInfo device={h.d} lat={h.lat} lng={h.lng} onClose={() => setHoverId(null)} />
+                      ) : null;
+                    })()}
+                    <FitBounds points={positioned.map((p) => ({ lat: p.lat, lng: p.lng }))} />
+                    {selected?.vehicleId && trail.length > 1 && <RouteTrail path={trail} />}
+                  </GoogleMap>
+                </APIProvider>
+              </Box>
+              {positioned.length === 0 && (
+                <Text size="sm" c="dimmed" ta="center" mt="sm">
+                  No located trackers yet — waiting for GPS fixes.
                 </Text>
-              </Card.Section>
-            </Card>
-          </Grid.Col>
-
-          {/* Sidebar */}
-          <Grid.Col span={{ base: 12, lg: 4 }}>
-            <Stack gap="md">
-              {/* Vehicle Selector */}
-              <Card withBorder p="lg">
-                <Stack gap="md">
-                  <Select
-                    label="Track Vehicle"
-                    placeholder="Select a vehicle to track"
-                    data={vehicleOptions}
-                    value={selectedVehicleId}
-                    onChange={setSelectedVehicleId}
-                    searchable
-                  />
-                  {selectedVehicle && (
-                    <Box p="md" style={{ backgroundColor: freightBrand.mutedBg, borderRadius: '8px' }}>
-                      <Stack gap="sm">
-                        <div>
-                          <Text size="sm" c="dimmed">
-                            Registration
-                          </Text>
-                          <Text fw={600}>{selectedVehicle.registrationNumber}</Text>
-                        </div>
-                        <div>
-                          <Text size="sm" c="dimmed">
-                            Vehicle
-                          </Text>
-                          <Text fw={600}>
-                            {selectedVehicle.manufacturer} {selectedVehicle.model}
-                          </Text>
-                        </div>
-                        <div>
-                          <Text size="sm" c="dimmed">
-                            Status
-                          </Text>
-                          <Badge color={selectedVehicle.status === 'ACTIVE' ? 'edr-green' : 'gray'}>
-                            {selectedVehicle.status || 'Unknown'}
-                          </Badge>
-                        </div>
-                      </Stack>
-                    </Box>
-                  )}
-                </Stack>
-              </Card>
-
-              {/* GPS Details */}
-              {selectedVehicle && (
-                <Card withBorder p="lg">
-                  <Stack gap="md">
-                    <Group justify="space-between">
-                      <Text fw={500}>GPS Location</Text>
-                      <Badge color="edr-green" leftSection={<Activity size={12} />}>
-                        Live
-                      </Badge>
-                    </Group>
-
-                    <SimpleGrid cols={2} spacing="sm">
-                      <Box p="sm" style={{ backgroundColor: '#f8f9fa', borderRadius: '8px' }}>
-                        <Text size="xs" c="dimmed">
-                          Latitude
-                        </Text>
-                        <Text fw={600} size="sm">
-                          {selectedVehicle.gps.lat.toFixed(4)}°
-                        </Text>
-                      </Box>
-                      <Box p="sm" style={{ backgroundColor: '#f8f9fa', borderRadius: '8px' }}>
-                        <Text size="xs" c="dimmed">
-                          Longitude
-                        </Text>
-                        <Text fw={600} size="sm">
-                          {selectedVehicle.gps.lng.toFixed(4)}°
-                        </Text>
-                      </Box>
-                      <Box p="sm" style={{ backgroundColor: '#f8f9fa', borderRadius: '8px' }}>
-                        <Text size="xs" c="dimmed">
-                          Speed
-                        </Text>
-                        <Text fw={600} size="sm">
-                          {selectedVehicle.gps.speed} km/h
-                        </Text>
-                      </Box>
-                      <Box p="sm" style={{ backgroundColor: '#f8f9fa', borderRadius: '8px' }}>
-                        <Text size="xs" c="dimmed">
-                          Heading
-                        </Text>
-                        <Text fw={600} size="sm">
-                          {selectedVehicle.gps.heading}°
-                        </Text>
-                      </Box>
-                    </SimpleGrid>
-
-                    <div>
-                      <Text size="xs" c="dimmed">
-                        Last Update
-                      </Text>
-                      <Text fw={500}>{selectedVehicle.gps.lastUpdate}</Text>
-                    </div>
-
-                    <Button color="edr-green" fullWidth leftSection={<MapPin size={16} />}>
-                      View Full History
-                    </Button>
-                  </Stack>
-                </Card>
               )}
+            </Card.Section>
+          </Card>
+        </Grid.Col>
 
-              {/* Tracked Vehicles List */}
+        {/* Sidebar */}
+        <Grid.Col span={{ base: 12, lg: 4 }}>
+          <Stack gap="md">
+            {selected && (
               <Card withBorder p="lg">
                 <Stack gap="md">
-                  <Text fw={500}>Tracked Vehicles ({trackableVehicles.length})</Text>
-                  <div style={{ maxHeight: '300px', overflowY: 'auto' }}>
-                    <Table>
-                      <Table.Tbody>
-                        {trackableVehicles.map(v => (
-                          <Table.Tr
-                            key={v.id}
-                            style={{
-                              cursor: 'pointer',
-                              backgroundColor: v.id === selectedVehicleId ? freightBrand.mutedBg : 'transparent',
-                            }}
-                            onClick={() => setSelectedVehicleId(v.id)}
-                          >
-                            <Table.Td>
-                              <Stack gap={0}>
-                                <Text size="sm" fw={600}>
-                                  {v.registrationNumber}
-                                </Text>
-                                <Text size="xs" c="dimmed">
-                                  {v.gps.speed} km/h
-                                </Text>
-                              </Stack>
-                            </Table.Td>
-                            <Table.Td align="right">
-                              <Badge
-                                color={v.status === 'ACTIVE' ? 'edr-green' : 'gray'}
-                                size="sm"
-                              >
-                                {v.status || 'N/A'}
-                              </Badge>
-                            </Table.Td>
-                          </Table.Tr>
-                        ))}
-                      </Table.Tbody>
-                    </Table>
+                  <Group justify="space-between">
+                    <Text fw={500}>{deviceLabel(selected)}</Text>
+                    <Group gap="xs">
+                      <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>
+                    </Group>
+                  </Group>
+
+                  <SimpleGrid cols={2} spacing="sm">
+                    <StatBox label="Latitude" value={toNum(selected.lastLat)?.toFixed(5) ?? "—"} />
+                    <StatBox label="Longitude" value={toNum(selected.lastLng)?.toFixed(5) ?? "—"} />
+                    <StatBox label="Speed" value={`${toNum(selected.lastSpeed) ?? 0} km/h`} />
+                    <StatBox label="Course" value={`${selected.lastCourse ?? 0}°`} />
+                    <StatBox label="Voltage" value={selected.voltageLevel != null ? `${selected.voltageLevel}/6` : "—"} />
+                    <StatBox label="GSM" value={selected.gsmLevel != null ? `${selected.gsmLevel}/4` : "—"} />
+                  </SimpleGrid>
+
+                  <div>
+                    <Text size="xs" c="dimmed">IMEI</Text>
+                    <Text fw={500} size="sm">{selected.imei}</Text>
                   </div>
+                  <div>
+                    <Text size="xs" c="dimmed">Last fix</Text>
+                    <Text fw={500} size="sm">{fmtTime(selected.lastFixAt)}</Text>
+                  </div>
+                  {selected.vehicleId && (
+                    <Text size="xs" c="dimmed">
+                      Showing last {trail.length} fixes as a route trail.
+                    </Text>
+                  )}
+
+                  <Select
+                    label="Assigned vehicle"
+                    placeholder="Unassigned"
+                    data={vehicleOptions}
+                    value={selected.vehicleId ?? null}
+                    onChange={(v) => assignMutation.mutate({ id: selected.id, vehicleId: v })}
+                    searchable
+                    clearable
+                  />
                 </Stack>
               </Card>
-            </Stack>
-          </Grid.Col>
-        </Grid>
-      </Stack>
+            )}
+
+            <Card withBorder p="lg">
+              <Stack gap="md">
+                <Text fw={500}>Trackers ({devices.length})</Text>
+                <div style={{ maxHeight: 340, overflowY: "auto" }}>
+                  <Table>
+                    <Table.Tbody>
+                      {devices.map((d) => (
+                        <Table.Tr
+                          key={d.id}
+                          style={{ cursor: "pointer", backgroundColor: d.id === selectedId ? freightBrand.mutedBg : "transparent" }}
+                          onClick={() => setSelectedId(d.id)}
+                        >
+                          <Table.Td>
+                            <Stack gap={0}>
+                              <Text size="sm" fw={600}>{deviceLabel(d)}</Text>
+                              <Text size="xs" c="dimmed">{toNum(d.lastSpeed) ?? 0} km/h · {fmtTime(d.lastFixAt)}</Text>
+                            </Stack>
+                          </Table.Td>
+                          <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>
+                            </Group>
+                          </Table.Td>
+                        </Table.Tr>
+                      ))}
+                      {devices.length === 0 && (
+                        <Table.Tr>
+                          <Table.Td colSpan={2}>
+                            <Text size="sm" c="dimmed" ta="center" py="md">No trackers registered yet.</Text>
+                          </Table.Td>
+                        </Table.Tr>
+                      )}
+                    </Table.Tbody>
+                  </Table>
+                </div>
+              </Stack>
+            </Card>
+          </Stack>
+        </Grid.Col>
+      </Grid>
+
+      {/* Register / edit modal */}
+      <Modal
+        opened={modalOpen}
+        onClose={() => setModalOpen(false)}
+        title={editDevice ? "Edit GPS tracker" : "Register GPS tracker"}
+        radius="lg"
+        centered
+      >
+        <Stack gap="md">
+          <TextInput
+            label="IMEI"
+            placeholder="15-digit device IMEI"
+            required
+            disabled={Boolean(editDevice)}
+            value={form.imei}
+            onChange={(e) => setForm({ ...form, imei: e.currentTarget.value })}
+          />
+          <TextInput
+            label="Name"
+            placeholder="Optional label"
+            value={form.name}
+            onChange={(e) => setForm({ ...form, name: e.currentTarget.value })}
+          />
+          <Select
+            label="Vehicle"
+            placeholder="Assign to a vehicle (optional)"
+            data={vehicleOptions}
+            value={form.vehicleId || null}
+            onChange={(v) => setForm({ ...form, vehicleId: v ?? "" })}
+            searchable
+            clearable
+          />
+          <Group justify="flex-end">
+            <Button variant="default" onClick={() => setModalOpen(false)}>Cancel</Button>
+            <Button
+              loading={saveMutation.isPending}
+              disabled={!form.imei.trim()}
+              onClick={() => saveMutation.mutate()}
+            >
+              {editDevice ? "Save" : "Register"}
+            </Button>
+          </Group>
+        </Stack>
+      </Modal>
     </Container>
   );
 }
+
+export default TrackingPage;
diff --git a/apps/edr-freight-web/backoffice/src/pages/fleet/WorkOrdersPage.tsx b/apps/edr-freight-web/backoffice/src/pages/fleet/WorkOrdersPage.tsx
new file mode 100644
index 000000000..71c591bb7
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/pages/fleet/WorkOrdersPage.tsx
@@ -0,0 +1,830 @@
+import { useState } from 'react';
+import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
+import {
+  Card,
+  Button,
+  Modal,
+  Stack,
+  Group,
+  Select,
+  TextInput,
+  Textarea,
+  NumberInput,
+  Table,
+  Badge,
+  Text,
+  Title,
+  Container,
+  Tabs,
+  Loader,
+  Switch,
+  ActionIcon,
+} from '@mantine/core';
+import { Plus, Trash2, Pencil, Wrench, Package, ShieldCheck } from 'lucide-react';
+import Breadcrumbs from '@/components/ui/Breadcrumbs';
+import { useToast } from '@/hooks/use-toast';
+import {
+  maintenanceDepthService,
+  type WorkOrder,
+  type WorkOrderStatus,
+  type WorkOrderPriority,
+  type Part,
+  type Warranty,
+} from '@/services/maintenance-depth.service';
+import { vehiclesService, type Vehicle as VehicleType } from '@/services/vehicles.service';
+
+const WORK_ORDER_STATUSES: WorkOrderStatus[] = ['OPEN', 'IN_PROGRESS', 'COMPLETED', 'CANCELLED'];
+const WORK_ORDER_PRIORITIES: WorkOrderPriority[] = ['LOW', 'MEDIUM', 'HIGH', 'URGENT'];
+const PART_CATEGORIES = ['TIRE', 'ENGINE', 'BRAKE', 'ELECTRICAL', 'FILTER', 'FLUID', 'OTHER'];
+
+const etb = (x: number | string | null | undefined) =>
+  `ETB ${(Number(x) || 0).toLocaleString('en-US', {
+    minimumFractionDigits: 2,
+    maximumFractionDigits: 2,
+  })}`;
+
+const statusColor = (status: string) => {
+  const colors: Record<string, string> = {
+    OPEN: 'edr-blue',
+    IN_PROGRESS: 'edr-amber-soft',
+    COMPLETED: 'edr-green',
+    CANCELLED: 'edr-slate',
+  };
+  return colors[status] || 'edr-slate';
+};
+
+const priorityColor = (priority: string) => {
+  const colors: Record<string, string> = {
+    LOW: 'edr-slate',
+    MEDIUM: 'edr-blue',
+    HIGH: 'edr-amber-soft',
+    URGENT: 'edr-red',
+  };
+  return colors[priority] || 'edr-slate';
+};
+
+const emptyWorkOrder = {
+  vehicleId: '',
+  title: '',
+  description: '',
+  status: 'OPEN' as WorkOrderStatus,
+  priority: 'MEDIUM' as WorkOrderPriority,
+  assignedTo: '',
+  laborCost: 0,
+  partsCost: 0,
+};
+
+const emptyPart = {
+  name: '',
+  sku: '',
+  category: 'TIRE',
+  quantityInStock: 0,
+  reorderLevel: 0,
+  unitCost: 0,
+  location: '',
+};
+
+const emptyWarranty = {
+  vehicleId: '',
+  component: '',
+  provider: '',
+  startDate: '',
+  expiryDate: new Date().toISOString().split('T')[0],
+  coverageNotes: '',
+};
+
+export default function WorkOrdersPage() {
+  const { toast } = useToast();
+  const queryClient = useQueryClient();
+
+  const [activeTab, setActiveTab] = useState<string | null>('work-orders');
+
+  // Work orders
+  const [statusFilter, setStatusFilter] = useState<string | null>(null);
+  const [openWorkOrderModal, setOpenWorkOrderModal] = useState(false);
+  const [workOrderForm, setWorkOrderForm] = useState(emptyWorkOrder);
+
+  // Parts
+  const [lowStockOnly, setLowStockOnly] = useState(false);
+  const [openPartModal, setOpenPartModal] = useState(false);
+  const [editingPartId, setEditingPartId] = useState<string | null>(null);
+  const [partForm, setPartForm] = useState(emptyPart);
+
+  // Warranties
+  const [openWarrantyModal, setOpenWarrantyModal] = useState(false);
+  const [warrantyForm, setWarrantyForm] = useState(emptyWarranty);
+
+  const { data: vehiclesData } = useQuery({
+    queryKey: ['vehicles', 'all-for-maintenance-depth'],
+    queryFn: async () => {
+      const res = await vehiclesService.getAll({ limit: 1000 });
+      return res.data || [];
+    },
+  });
+
+  const vehicleOptions =
+    vehiclesData?.map((v: VehicleType) => ({
+      value: v.id,
+      label: v.plateNumber
+        ? `${v.plateNumber} - ${v.manufacturer} ${v.model}`
+        : v.registrationNumber || v.id,
+    })) || [];
+
+  const vehicleLabel = (vehicleId: string) =>
+    vehicleOptions.find((o) => o.value === vehicleId)?.label || vehicleId;
+
+  // ---- Work orders queries/mutations ----
+  const { data: workOrders, isLoading: workOrdersLoading } = useQuery({
+    queryKey: ['maintenance-work-orders', statusFilter],
+    queryFn: async () => {
+      const res = await maintenanceDepthService.getWorkOrders({
+        status: (statusFilter as WorkOrderStatus) || undefined,
+      });
+      return res.data || [];
+    },
+  });
+  const workOrderList: WorkOrder[] = Array.isArray(workOrders) ? workOrders : [];
+
+  const createWorkOrderMutation = useMutation({
+    mutationFn: async () => {
+      const res = await maintenanceDepthService.createWorkOrder({
+        vehicleId: workOrderForm.vehicleId,
+        title: workOrderForm.title,
+        description: workOrderForm.description || undefined,
+        status: workOrderForm.status,
+        priority: workOrderForm.priority,
+        assignedTo: workOrderForm.assignedTo || undefined,
+        laborCost: Number(workOrderForm.laborCost) || undefined,
+        partsCost: Number(workOrderForm.partsCost) || undefined,
+      });
+      return res.data;
+    },
+    onSuccess: () => {
+      toast({ title: 'Work order created' });
+      queryClient.invalidateQueries({ queryKey: ['maintenance-work-orders'] });
+      setOpenWorkOrderModal(false);
+      setWorkOrderForm(emptyWorkOrder);
+    },
+    onError: (err: any) => {
+      toast({
+        title: 'Error',
+        description: err?.response?.data?.message ?? 'Failed',
+        variant: 'destructive',
+      });
+    },
+  });
+
+  const deleteWorkOrderMutation = useMutation({
+    mutationFn: async (id: string) => {
+      await maintenanceDepthService.deleteWorkOrder(id);
+    },
+    onSuccess: () => {
+      toast({ title: 'Work order deleted' });
+      queryClient.invalidateQueries({ queryKey: ['maintenance-work-orders'] });
+    },
+    onError: (err: any) => {
+      toast({
+        title: 'Error',
+        description: err?.response?.data?.message ?? 'Failed',
+        variant: 'destructive',
+      });
+    },
+  });
+
+  // ---- Parts queries/mutations ----
+  const { data: parts, isLoading: partsLoading } = useQuery({
+    queryKey: ['maintenance-parts', lowStockOnly],
+    queryFn: async () => {
+      const res = await maintenanceDepthService.getParts({ lowStock: lowStockOnly || undefined });
+      return res.data || [];
+    },
+  });
+  const partList: Part[] = Array.isArray(parts) ? parts : [];
+
+  const savePartMutation = useMutation({
+    mutationFn: async () => {
+      const payload = {
+        name: partForm.name,
+        sku: partForm.sku || undefined,
+        category: partForm.category || undefined,
+        quantityInStock: Number(partForm.quantityInStock) || 0,
+        reorderLevel: Number(partForm.reorderLevel) || 0,
+        unitCost: Number(partForm.unitCost) || undefined,
+        location: partForm.location || undefined,
+      };
+      if (editingPartId) {
+        const res = await maintenanceDepthService.updatePart(editingPartId, payload);
+        return res.data;
+      }
+      const res = await maintenanceDepthService.createPart(payload);
+      return res.data;
+    },
+    onSuccess: () => {
+      toast({ title: editingPartId ? 'Part updated' : 'Part created' });
+      queryClient.invalidateQueries({ queryKey: ['maintenance-parts'] });
+      setOpenPartModal(false);
+      setPartForm(emptyPart);
+      setEditingPartId(null);
+    },
+    onError: (err: any) => {
+      toast({
+        title: 'Error',
+        description: err?.response?.data?.message ?? 'Failed',
+        variant: 'destructive',
+      });
+    },
+  });
+
+  const deletePartMutation = useMutation({
+    mutationFn: async (id: string) => {
+      await maintenanceDepthService.deletePart(id);
+    },
+    onSuccess: () => {
+      toast({ title: 'Part deleted' });
+      queryClient.invalidateQueries({ queryKey: ['maintenance-parts'] });
+    },
+    onError: (err: any) => {
+      toast({
+        title: 'Error',
+        description: err?.response?.data?.message ?? 'Failed',
+        variant: 'destructive',
+      });
+    },
+  });
+
+  // ---- Warranties queries/mutations ----
+  const { data: warranties, isLoading: warrantiesLoading } = useQuery({
+    queryKey: ['maintenance-warranties'],
+    queryFn: async () => {
+      const res = await maintenanceDepthService.getWarranties();
+      return res.data || [];
+    },
+  });
+  const warrantyList: Warranty[] = Array.isArray(warranties) ? warranties : [];
+
+  const createWarrantyMutation = useMutation({
+    mutationFn: async () => {
+      const res = await maintenanceDepthService.createWarranty({
+        vehicleId: warrantyForm.vehicleId,
+        component: warrantyForm.component,
+        provider: warrantyForm.provider || undefined,
+        startDate: warrantyForm.startDate || undefined,
+        expiryDate: warrantyForm.expiryDate,
+        coverageNotes: warrantyForm.coverageNotes || undefined,
+      });
+      return res.data;
+    },
+    onSuccess: () => {
+      toast({ title: 'Warranty created' });
+      queryClient.invalidateQueries({ queryKey: ['maintenance-warranties'] });
+      setOpenWarrantyModal(false);
+      setWarrantyForm(emptyWarranty);
+    },
+    onError: (err: any) => {
+      toast({
+        title: 'Error',
+        description: err?.response?.data?.message ?? 'Failed',
+        variant: 'destructive',
+      });
+    },
+  });
+
+  const deleteWarrantyMutation = useMutation({
+    mutationFn: async (id: string) => {
+      await maintenanceDepthService.deleteWarranty(id);
+    },
+    onSuccess: () => {
+      toast({ title: 'Warranty deleted' });
+      queryClient.invalidateQueries({ queryKey: ['maintenance-warranties'] });
+    },
+    onError: (err: any) => {
+      toast({
+        title: 'Error',
+        description: err?.response?.data?.message ?? 'Failed',
+        variant: 'destructive',
+      });
+    },
+  });
+
+  const openPartForEdit = (part: Part) => {
+    setEditingPartId(part.id);
+    setPartForm({
+      name: part.name,
+      sku: part.sku || '',
+      category: part.category || 'OTHER',
+      quantityInStock: part.quantityInStock,
+      reorderLevel: part.reorderLevel,
+      unitCost: Number(part.unitCost) || 0,
+      location: part.location || '',
+    });
+    setOpenPartModal(true);
+  };
+
+  const openPartForCreate = () => {
+    setEditingPartId(null);
+    setPartForm(emptyPart);
+    setOpenPartModal(true);
+  };
+
+  return (
+    <Container size="xl" py="xl" px="lg">
+      <Breadcrumbs items={[{ label: 'Fleet' }, { label: 'Maintenance' }, { label: 'Work Orders' }]} />
+
+      <Group justify="space-between" mb="lg">
+        <Title order={1}>Work Orders &amp; Parts</Title>
+      </Group>
+
+      <Tabs value={activeTab} onChange={setActiveTab}>
+        <Tabs.List>
+          <Tabs.Tab value="work-orders" leftSection={<Wrench size={14} />}>
+            Work Orders
+          </Tabs.Tab>
+          <Tabs.Tab value="parts" leftSection={<Package size={14} />}>
+            Parts / Tires
+          </Tabs.Tab>
+          <Tabs.Tab value="warranties" leftSection={<ShieldCheck size={14} />}>
+            Warranties
+          </Tabs.Tab>
+        </Tabs.List>
+
+        {/* ---- Work Orders tab ---- */}
+        <Tabs.Panel value="work-orders" pt="lg">
+          <Group justify="space-between" mb="md">
+            <Select
+              placeholder="All statuses"
+              data={WORK_ORDER_STATUSES}
+              value={statusFilter}
+              onChange={setStatusFilter}
+              clearable
+              w={220}
+            />
+            <Button
+              onClick={() => setOpenWorkOrderModal(true)}
+              color="edr-green"
+              leftSection={<Plus size={16} />}
+            >
+              New Work Order
+            </Button>
+          </Group>
+
+          <Card withBorder>
+            {workOrdersLoading ? (
+              <Group justify="center" p="xl">
+                <Loader />
+              </Group>
+            ) : workOrderList.length > 0 ? (
+              <Table.ScrollContainer minWidth={800}>
+                <Table striped highlightOnHover>
+                  <Table.Thead>
+                    <Table.Tr>
+                      <Table.Th>Title</Table.Th>
+                      <Table.Th>Vehicle</Table.Th>
+                      <Table.Th>Priority</Table.Th>
+                      <Table.Th>Status</Table.Th>
+                      <Table.Th>Assigned</Table.Th>
+                      <Table.Th>Labor</Table.Th>
+                      <Table.Th>Parts</Table.Th>
+                      <Table.Th>Opened</Table.Th>
+                      <Table.Th />
+                    </Table.Tr>
+                  </Table.Thead>
+                  <Table.Tbody>
+                    {workOrderList.map((wo) => (
+                      <Table.Tr key={wo.id}>
+                        <Table.Td>{wo.title}</Table.Td>
+                        <Table.Td>{vehicleLabel(wo.vehicleId)}</Table.Td>
+                        <Table.Td>
+                          <Badge color={priorityColor(wo.priority)}>{wo.priority}</Badge>
+                        </Table.Td>
+                        <Table.Td>
+                          <Badge color={statusColor(wo.status)}>{wo.status}</Badge>
+                        </Table.Td>
+                        <Table.Td>{wo.assignedTo || '—'}</Table.Td>
+                        <Table.Td>{etb(wo.laborCost)}</Table.Td>
+                        <Table.Td>{etb(wo.partsCost)}</Table.Td>
+                        <Table.Td>{new Date(wo.openedAt).toLocaleDateString()}</Table.Td>
+                        <Table.Td>
+                          <ActionIcon
+                            variant="subtle"
+                            color="edr-red"
+                            onClick={() => deleteWorkOrderMutation.mutate(wo.id)}
+                            aria-label="Delete work order"
+                          >
+                            <Trash2 size={16} />
+                          </ActionIcon>
+                        </Table.Td>
+                      </Table.Tr>
+                    ))}
+                  </Table.Tbody>
+                </Table>
+              </Table.ScrollContainer>
+            ) : (
+              <Text c="dimmed" ta="center" p="xl">
+                No work orders yet
+              </Text>
+            )}
+          </Card>
+        </Tabs.Panel>
+
+        {/* ---- Parts / Tires tab ---- */}
+        <Tabs.Panel value="parts" pt="lg">
+          <Group justify="space-between" mb="md">
+            <Switch
+              label="Low stock only"
+              checked={lowStockOnly}
+              onChange={(e) => setLowStockOnly(e.currentTarget.checked)}
+            />
+            <Button onClick={openPartForCreate} color="edr-green" leftSection={<Plus size={16} />}>
+              New Part
+            </Button>
+          </Group>
+
+          <Card withBorder>
+            {partsLoading ? (
+              <Group justify="center" p="xl">
+                <Loader />
+              </Group>
+            ) : partList.length > 0 ? (
+              <Table.ScrollContainer minWidth={800}>
+                <Table striped highlightOnHover>
+                  <Table.Thead>
+                    <Table.Tr>
+                      <Table.Th>Name</Table.Th>
+                      <Table.Th>SKU</Table.Th>
+                      <Table.Th>Category</Table.Th>
+                      <Table.Th>In Stock</Table.Th>
+                      <Table.Th>Reorder Level</Table.Th>
+                      <Table.Th>Unit Cost</Table.Th>
+                      <Table.Th>Location</Table.Th>
+                      <Table.Th />
+                    </Table.Tr>
+                  </Table.Thead>
+                  <Table.Tbody>
+                    {partList.map((p) => (
+                      <Table.Tr key={p.id}>
+                        <Table.Td>{p.name}</Table.Td>
+                        <Table.Td>{p.sku || '—'}</Table.Td>
+                        <Table.Td>
+                          {p.category ? <Badge variant="light">{p.category}</Badge> : '—'}
+                        </Table.Td>
+                        <Table.Td>
+                          <Group gap="xs">
+                            {p.quantityInStock}
+                            {p.quantityInStock <= p.reorderLevel && (
+                              <Badge color="edr-red" size="sm">
+                                Low stock
+                              </Badge>
+                            )}
+                          </Group>
+                        </Table.Td>
+                        <Table.Td>{p.reorderLevel}</Table.Td>
+                        <Table.Td>{etb(p.unitCost)}</Table.Td>
+                        <Table.Td>{p.location || '—'}</Table.Td>
+                        <Table.Td>
+                          <Group gap={4} wrap="nowrap">
+                            <ActionIcon
+                              variant="subtle"
+                              onClick={() => openPartForEdit(p)}
+                              aria-label="Adjust part"
+                            >
+                              <Pencil size={16} />
+                            </ActionIcon>
+                            <ActionIcon
+                              variant="subtle"
+                              color="edr-red"
+                              onClick={() => deletePartMutation.mutate(p.id)}
+                              aria-label="Delete part"
+                            >
+                              <Trash2 size={16} />
+                            </ActionIcon>
+                          </Group>
+                        </Table.Td>
+                      </Table.Tr>
+                    ))}
+                  </Table.Tbody>
+                </Table>
+              </Table.ScrollContainer>
+            ) : (
+              <Text c="dimmed" ta="center" p="xl">
+                No parts in inventory
+              </Text>
+            )}
+          </Card>
+        </Tabs.Panel>
+
+        {/* ---- Warranties tab ---- */}
+        <Tabs.Panel value="warranties" pt="lg">
+          <Group justify="flex-end" mb="md">
+            <Button
+              onClick={() => setOpenWarrantyModal(true)}
+              color="edr-green"
+              leftSection={<Plus size={16} />}
+            >
+              New Warranty
+            </Button>
+          </Group>
+
+          <Card withBorder>
+            {warrantiesLoading ? (
+              <Group justify="center" p="xl">
+                <Loader />
+              </Group>
+            ) : warrantyList.length > 0 ? (
+              <Table.ScrollContainer minWidth={700}>
+                <Table striped highlightOnHover>
+                  <Table.Thead>
+                    <Table.Tr>
+                      <Table.Th>Component</Table.Th>
+                      <Table.Th>Vehicle</Table.Th>
+                      <Table.Th>Provider</Table.Th>
+                      <Table.Th>Start</Table.Th>
+                      <Table.Th>Expiry</Table.Th>
+                      <Table.Th />
+                    </Table.Tr>
+                  </Table.Thead>
+                  <Table.Tbody>
+                    {warrantyList.map((w) => {
+                      const expired = new Date(w.expiryDate) < new Date();
+                      return (
+                        <Table.Tr key={w.id}>
+                          <Table.Td>{w.component}</Table.Td>
+                          <Table.Td>{vehicleLabel(w.vehicleId)}</Table.Td>
+                          <Table.Td>{w.provider || '—'}</Table.Td>
+                          <Table.Td>
+                            {w.startDate ? new Date(w.startDate).toLocaleDateString() : '—'}
+                          </Table.Td>
+                          <Table.Td>
+                            <Group gap="xs">
+                              {new Date(w.expiryDate).toLocaleDateString()}
+                              <Badge color={expired ? 'edr-red' : 'edr-green'} size="sm">
+                                {expired ? 'Expired' : 'Active'}
+                              </Badge>
+                            </Group>
+                          </Table.Td>
+                          <Table.Td>
+                            <ActionIcon
+                              variant="subtle"
+                              color="edr-red"
+                              onClick={() => deleteWarrantyMutation.mutate(w.id)}
+                              aria-label="Delete warranty"
+                            >
+                              <Trash2 size={16} />
+                            </ActionIcon>
+                          </Table.Td>
+                        </Table.Tr>
+                      );
+                    })}
+                  </Table.Tbody>
+                </Table>
+              </Table.ScrollContainer>
+            ) : (
+              <Text c="dimmed" ta="center" p="xl">
+                No warranties recorded
+              </Text>
+            )}
+          </Card>
+        </Tabs.Panel>
+      </Tabs>
+
+      {/* ---- Work Order modal ---- */}
+      <Modal
+        opened={openWorkOrderModal}
+        onClose={() => setOpenWorkOrderModal(false)}
+        title="New Work Order"
+        size="md"
+      >
+        <Stack gap="md">
+          <Select
+            label="Vehicle"
+            placeholder="Pick a vehicle"
+            data={vehicleOptions}
+            value={workOrderForm.vehicleId || null}
+            onChange={(v) => setWorkOrderForm({ ...workOrderForm, vehicleId: v || '' })}
+            searchable
+            required
+          />
+          <TextInput
+            label="Title"
+            placeholder="e.g., Replace front brake pads"
+            value={workOrderForm.title}
+            onChange={(e) => setWorkOrderForm({ ...workOrderForm, title: e.currentTarget.value })}
+            required
+          />
+          <Textarea
+            label="Description"
+            placeholder="Details of the work needed"
+            value={workOrderForm.description}
+            onChange={(e) =>
+              setWorkOrderForm({ ...workOrderForm, description: e.currentTarget.value })
+            }
+          />
+          <Group grow>
+            <Select
+              label="Priority"
+              data={WORK_ORDER_PRIORITIES}
+              value={workOrderForm.priority}
+              onChange={(v) =>
+                setWorkOrderForm({ ...workOrderForm, priority: (v as WorkOrderPriority) || 'MEDIUM' })
+              }
+            />
+            <Select
+              label="Status"
+              data={WORK_ORDER_STATUSES}
+              value={workOrderForm.status}
+              onChange={(v) =>
+                setWorkOrderForm({ ...workOrderForm, status: (v as WorkOrderStatus) || 'OPEN' })
+              }
+            />
+          </Group>
+          <TextInput
+            label="Assigned To"
+            placeholder="e.g., Mechanic name"
+            value={workOrderForm.assignedTo}
+            onChange={(e) =>
+              setWorkOrderForm({ ...workOrderForm, assignedTo: e.currentTarget.value })
+            }
+          />
+          <Group grow>
+            <NumberInput
+              label="Labor Cost (ETB)"
+              min={0}
+              value={workOrderForm.laborCost}
+              onChange={(v) => setWorkOrderForm({ ...workOrderForm, laborCost: Number(v) || 0 })}
+            />
+            <NumberInput
+              label="Parts Cost (ETB)"
+              min={0}
+              value={workOrderForm.partsCost}
+              onChange={(v) => setWorkOrderForm({ ...workOrderForm, partsCost: Number(v) || 0 })}
+            />
+          </Group>
+          <Group justify="flex-end">
+            <Button variant="light" onClick={() => setOpenWorkOrderModal(false)}>
+              Cancel
+            </Button>
+            <Button
+              onClick={() => createWorkOrderMutation.mutate()}
+              loading={createWorkOrderMutation.isPending}
+              disabled={!workOrderForm.vehicleId || !workOrderForm.title}
+            >
+              Create
+            </Button>
+          </Group>
+        </Stack>
+      </Modal>
+
+      {/* ---- Part modal ---- */}
+      <Modal
+        opened={openPartModal}
+        onClose={() => {
+          setOpenPartModal(false);
+          setEditingPartId(null);
+        }}
+        title={editingPartId ? 'Adjust Part' : 'New Part'}
+        size="md"
+      >
+        <Stack gap="md">
+          <TextInput
+            label="Name"
+            placeholder="e.g., 315/80R22.5 Tire"
+            value={partForm.name}
+            onChange={(e) => setPartForm({ ...partForm, name: e.currentTarget.value })}
+            required
+          />
+          <Group grow>
+            <TextInput
+              label="SKU"
+              placeholder="Optional"
+              value={partForm.sku}
+              onChange={(e) => setPartForm({ ...partForm, sku: e.currentTarget.value })}
+            />
+            <Select
+              label="Category"
+              data={PART_CATEGORIES}
+              value={partForm.category}
+              onChange={(v) => setPartForm({ ...partForm, category: v || 'OTHER' })}
+            />
+          </Group>
+          <Group grow>
+            <NumberInput
+              label="Quantity in Stock"
+              min={0}
+              value={partForm.quantityInStock}
+              onChange={(v) => setPartForm({ ...partForm, quantityInStock: Number(v) || 0 })}
+            />
+            <NumberInput
+              label="Reorder Level"
+              min={0}
+              value={partForm.reorderLevel}
+              onChange={(v) => setPartForm({ ...partForm, reorderLevel: Number(v) || 0 })}
+            />
+          </Group>
+          <Group grow>
+            <NumberInput
+              label="Unit Cost (ETB)"
+              min={0}
+              value={partForm.unitCost}
+              onChange={(v) => setPartForm({ ...partForm, unitCost: Number(v) || 0 })}
+            />
+            <TextInput
+              label="Location"
+              placeholder="e.g., Shelf A3"
+              value={partForm.location}
+              onChange={(e) => setPartForm({ ...partForm, location: e.currentTarget.value })}
+            />
+          </Group>
+          <Group justify="flex-end">
+            <Button
+              variant="light"
+              onClick={() => {
+                setOpenPartModal(false);
+                setEditingPartId(null);
+              }}
+            >
+              Cancel
+            </Button>
+            <Button
+              onClick={() => savePartMutation.mutate()}
+              loading={savePartMutation.isPending}
+              disabled={!partForm.name}
+            >
+              {editingPartId ? 'Save' : 'Create'}
+            </Button>
+          </Group>
+        </Stack>
+      </Modal>
+
+      {/* ---- Warranty modal ---- */}
+      <Modal
+        opened={openWarrantyModal}
+        onClose={() => setOpenWarrantyModal(false)}
+        title="New Warranty"
+        size="md"
+      >
+        <Stack gap="md">
+          <Select
+            label="Vehicle"
+            placeholder="Pick a vehicle"
+            data={vehicleOptions}
+            value={warrantyForm.vehicleId || null}
+            onChange={(v) => setWarrantyForm({ ...warrantyForm, vehicleId: v || '' })}
+            searchable
+            required
+          />
+          <TextInput
+            label="Component"
+            placeholder="e.g., Engine, Transmission"
+            value={warrantyForm.component}
+            onChange={(e) => setWarrantyForm({ ...warrantyForm, component: e.currentTarget.value })}
+            required
+          />
+          <TextInput
+            label="Provider"
+            placeholder="e.g., Manufacturer name"
+            value={warrantyForm.provider}
+            onChange={(e) => setWarrantyForm({ ...warrantyForm, provider: e.currentTarget.value })}
+          />
+          <Group grow>
+            <TextInput
+              label="Start Date"
+              type="date"
+              value={warrantyForm.startDate}
+              onChange={(e) =>
+                setWarrantyForm({ ...warrantyForm, startDate: e.currentTarget.value })
+              }
+            />
+            <TextInput
+              label="Expiry Date"
+              type="date"
+              value={warrantyForm.expiryDate}
+              onChange={(e) =>
+                setWarrantyForm({ ...warrantyForm, expiryDate: e.currentTarget.value })
+              }
+              required
+            />
+          </Group>
+          <Textarea
+            label="Coverage Notes"
+            placeholder="What the warranty covers"
+            value={warrantyForm.coverageNotes}
+            onChange={(e) =>
+              setWarrantyForm({ ...warrantyForm, coverageNotes: e.currentTarget.value })
+            }
+          />
+          <Group justify="flex-end">
+            <Button variant="light" onClick={() => setOpenWarrantyModal(false)}>
+              Cancel
+            </Button>
+            <Button
+              onClick={() => createWarrantyMutation.mutate()}
+              loading={createWarrantyMutation.isPending}
+              disabled={!warrantyForm.vehicleId || !warrantyForm.component || !warrantyForm.expiryDate}
+            >
+              Create
+            </Button>
+          </Group>
+        </Stack>
+      </Modal>
+    </Container>
+  );
+}
diff --git a/apps/edr-freight-web/backoffice/src/pages/fleet/config/vehicles.ts b/apps/edr-freight-web/backoffice/src/pages/fleet/config/vehicles.ts
index 5e76584ed..eb1508601 100644
--- a/apps/edr-freight-web/backoffice/src/pages/fleet/config/vehicles.ts
+++ b/apps/edr-freight-web/backoffice/src/pages/fleet/config/vehicles.ts
@@ -29,6 +29,11 @@ const VEHICLE_AVAILABILITY_OPTIONS = [
   { label: "Busy", value: "BUSY" },
 ];
 
+const CURRENCY_OPTIONS = [
+  { label: "ETB", value: "ETB" },
+  { label: "USD", value: "USD" },
+];
+
 export const vehiclesConfig: FleetResourceConfig = {
   slug: "vehicles",
   label: "Vehicles",
@@ -84,12 +89,14 @@ export const vehiclesConfig: FleetResourceConfig = {
     { name: "locationId", label: "Location", type: "select", dynamicOptions: "yards" },
     { name: "estimatedDistanceKm", label: "Estimated Distance (KM)", type: "number" },
     { name: "actualDistanceKm", label: "Actual Distance (KM)", type: "number" },
+    { name: "pricePerKm", label: "Price per KM", type: "number" },
+    { name: "currency", label: "Currency", type: "radio", options: CURRENCY_OPTIONS },
     { name: "status", label: "Status", type: "select", required: true, options: VEHICLE_STATUS_OPTIONS },
     { name: "availability", label: "Availability", type: "select", required: true, options: VEHICLE_AVAILABILITY_OPTIONS },
     { name: "description", label: "Description", type: "textarea" },
   ],
   emptyValues: {
-    code: "",
+    code: "03-ET",
     plateNumber: "",
     powerPlateNo: "",
     trailerPlateNo: "",
@@ -102,6 +109,8 @@ export const vehiclesConfig: FleetResourceConfig = {
     locationId: null,
     estimatedDistanceKm: "",
     actualDistanceKm: "",
+    pricePerKm: "",
+    currency: "ETB",
     status: "ACTIVE",
     availability: "FREE",
     description: "",
diff --git a/apps/edr-freight-web/backoffice/src/pages/operations/FirstMilePage.tsx b/apps/edr-freight-web/backoffice/src/pages/operations/FirstMilePage.tsx
index 2b130848c..a8c55ecf4 100644
--- a/apps/edr-freight-web/backoffice/src/pages/operations/FirstMilePage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/operations/FirstMilePage.tsx
@@ -20,7 +20,7 @@ import type { ColumnDef } from "@edr/ui-common";
 import { DataTable, DataTableFooter, usePagination } from "@edr/ui-common";
 import {
   ActionIcon,
-  Autocomplete,
+  Alert,
   Badge,
   Box,
   Button,
@@ -54,7 +54,6 @@ import {
 } from "@/services/first-mile.service";
 import { bookingsService } from "@/services/bookings.service";
 import { vehiclesService } from "@/services/vehicles.service";
-import { ratesService } from "@/services/rates.service";
 import type { BookingDetail } from "@/types/booking";
 
 const formatPrice = (amount: number | string | null | undefined, currency = "ETB") =>
@@ -191,7 +190,24 @@ const isPostPaymentPending = (r: FirstMileRecord) =>
 
 // Map API record → display fields used in modals and trip slip
 const bookingRef = (r: FirstMileRecord) => r.booking?.reference ?? r.bookingId;
-const currencyOf = (r: FirstMileRecord) => r.booking?.paymentCurrency ?? "ETB";
+const currencyOf = (r: FirstMileRecord) =>
+  r.vehicle?.currency ??
+  r.vehicleAssignments?.[0]?.vehicle?.currency ??
+  r.booking?.paymentCurrency ??
+  "ETB";
+
+type FmAssignment = NonNullable<FirstMileRecord["vehicleAssignments"]>[number];
+const truckShort = (a: FmAssignment) =>
+  a.vehicle ? [a.vehicle.code, a.vehicle.plateNumber].filter(Boolean).join(" · ") : a.vehicleId;
+/** Billing problems on the trucks that have distance: zero price/km, mixed currency. */
+const billingIssues = (r: FirstMileRecord) => {
+  const trucks = (r.vehicleAssignments ?? []).filter((a) => Number(a.distanceKm) > 0);
+  const zeroPrice = trucks.filter((a) => !(Number(a.vehicle?.pricePerKm) > 0)).map(truckShort);
+  const currencies = [
+    ...new Set(trucks.map((a) => a.vehicle?.currency).filter((c): c is string => Boolean(c))),
+  ];
+  return { zeroPrice, mixedCurrency: currencies.length > 1, currencies };
+};
 const customerName = (r: FirstMileRecord) => r.booking?.company?.name ?? "—";
 const pickupLocation = (r: FirstMileRecord) => r.booking?.firstMilePickupAddress ?? "—";
 const cargoDesc = (r: FirstMileRecord) => {
@@ -480,6 +496,8 @@ const FirstMilePage = () => {
   const [distanceOpen, setDistanceOpen] = useState(false);
   // Per-vehicle actual distance, keyed by vehicleId.
   const [distanceRows, setDistanceRows] = useState<Record<string, string>>({});
+  // Record pending invoice-generation confirmation (shows a summary first).
+  const [invoiceConfirm, setInvoiceConfirm] = useState<FirstMileRecord | null>(null);
   const [warehouseReceiveOpen, setWarehouseReceiveOpen] = useState(false);
   const [warehouseReceiveRecord, setWarehouseReceiveRecord] = useState<FirstMileRecord | null>(null);
 
@@ -500,14 +518,6 @@ const FirstMilePage = () => {
     },
   });
 
-  const { data: ratesData } = useQuery({
-    queryKey: ["rates", "FIRST_MILE"],
-    queryFn: async () => {
-      const res = await ratesService.getByType("FIRST_MILE");
-      return res.data;
-    },
-  });
-
   const { data: paidBookingsData, isLoading: bookingsLoading } = useQuery({
     queryKey: QUERY_KEYS.BOOKINGS.list({ status: "PAID" }),
     queryFn: () => bookingsService.list({ status: "PAID", pageSize: 100 }),
@@ -572,10 +582,17 @@ const FirstMilePage = () => {
       distances: Array<{ vehicleId: string; distanceKm: number }>;
       remainingPayment?: number;
     }) => firstMileService.setDistances(id, distances, remainingPayment),
-    onSuccess: () => {
+    onSuccess: (res) => {
       void qc.invalidateQueries({ queryKey: QUERY_KEYS.FIRST_MILE.list() });
       toast({ title: "Distances saved", description: activeRecord ? bookingRef(activeRecord) : undefined });
+      const updated = res?.data as FirstMileRecord | undefined;
       closeDistance();
+      // Every truck has a distance and it isn't billed yet → offer to invoice now.
+      const trucks = updated?.vehicleAssignments ?? [];
+      const allFilled = trucks.length > 0 && trucks.every((a) => Number(a.distanceKm) > 0);
+      if (updated && allFilled && !updated.invoice) {
+        setInvoiceConfirm(updated);
+      }
     },
     onError: () => {
       toast({ title: "Update failed", variant: "destructive" });
@@ -783,18 +800,9 @@ const FirstMilePage = () => {
       return;
     }
 
-    const total = distances.reduce((s, d) => s + d.distanceKm, 0);
-    let remainingPayment: number | undefined;
-    if (ratesData?.data) {
-      const firstMileRate = ratesData.data.find(
-        (r) => r.rateType === "FIRST_MILE" && (r.status === "LIVE" || r.status === "DRAFT")
-      );
-      if (firstMileRate) {
-        remainingPayment = total * parseFloat(firstMileRate.rateValue);
-      }
-    }
-
-    setDistancesMutation.mutate({ id: activeId, distances, remainingPayment });
+    // Amount is computed server-side per truck (distance × the vehicle's
+    // price/km, in the vehicle's currency) — no flat FIRST_MILE rate.
+    setDistancesMutation.mutate({ id: activeId, distances });
   };
 
   const matchesFilter = (r: FirstMileRecord) => {
@@ -849,6 +857,33 @@ const FirstMilePage = () => {
     return filteredRecords.slice(start, start + pagination.pageSize);
   }, [filteredRecords, pagination]);
 
+  // Billing problems on the leg pending invoice confirmation.
+  const confirmIssues = invoiceConfirm
+    ? billingIssues(invoiceConfirm)
+    : { zeroPrice: [] as string[], mixedCurrency: false, currencies: [] as string[] };
+
+  // Guard invoice generation: block mixed currency, warn (but proceed) on trucks
+  // priced at 0/km.
+  const handleGenerateInvoice = (r: FirstMileRecord) => {
+    const { zeroPrice, mixedCurrency, currencies } = billingIssues(r);
+    if (mixedCurrency) {
+      toast({
+        title: "Mixed truck currencies",
+        description: `Trucks use ${currencies.join(", ")}. Assign trucks that share one currency.`,
+        variant: "destructive",
+      });
+      return;
+    }
+    if (zeroPrice.length) {
+      toast({
+        title: "Truck has no price/km",
+        description: `${zeroPrice.join(", ")} will bill 0 — set Price per KM on the vehicle.`,
+        variant: "destructive",
+      });
+    }
+    generateInvoiceMutation.mutate(r.id);
+  };
+
   const openAssign = (id: string | null) => {
     const resolved = id ?? filteredRecords.find((r) => !isAssigned(r))?.id ?? null;
     const rec = records.find((r) => r.id === resolved);
@@ -1173,7 +1208,7 @@ const FirstMilePage = () => {
                       !(row.original.exactKm != null && row.original.exactKm > 0) ||
                       Boolean(row.original.invoice)
                     }
-                    onClick={() => generateInvoiceMutation.mutate(row.original.id)}
+                    onClick={() => handleGenerateInvoice(row.original)}
                   >
                     {row.original.invoice ? "Invoice generated" : "Generate Invoice"}
                   </Menu.Item>
@@ -1337,21 +1372,29 @@ const FirstMilePage = () => {
                   clearable
                   disabled={assignVehicleOptions.length === 0}
                 />
-                <Autocomplete
+                <Select
                   style={{ flex: 1 }}
                   label={i === 0 ? "Container no." : undefined}
-                  placeholder="Container number"
-                  data={containerOptions.filter(
-                    (n) =>
-                      n === row.containerNumber ||
-                      !vehicleRows.some((r, idx) => idx !== i && r.containerNumber === n),
-                  )}
-                  value={row.containerNumber}
+                  placeholder={containerOptions.length ? "Select container" : "No container numbers"}
+                  data={[
+                    ...containerOptions.filter(
+                      (n) =>
+                        n === row.containerNumber ||
+                        !vehicleRows.some((r, idx) => idx !== i && r.containerNumber === n),
+                    ),
+                    // keep a manual/legacy value selectable even if not in the booking
+                    ...(row.containerNumber && !containerOptions.includes(row.containerNumber)
+                      ? [row.containerNumber]
+                      : []),
+                  ]}
+                  value={row.containerNumber || null}
                   onChange={(value) =>
                     setVehicleRows((prev) =>
-                      prev.map((x, idx) => (idx === i ? { ...x, containerNumber: value } : x)),
+                      prev.map((x, idx) => (idx === i ? { ...x, containerNumber: value ?? "" } : x)),
                     )
                   }
+                  searchable
+                  clearable
                 />
                 {vehicleRows.length > 1 && (
                   <ActionIcon
@@ -1740,6 +1783,77 @@ const FirstMilePage = () => {
           </Group>
         </Stack>
       </Modal>
+
+      {/* Generate Invoice — confirmation summary */}
+      <Modal
+        opened={Boolean(invoiceConfirm)}
+        onClose={() => setInvoiceConfirm(null)}
+        title={<Text fw={600}>Generate Invoice</Text>}
+        size="md"
+        radius="lg"
+        centered
+      >
+        {invoiceConfirm && (
+          <Stack gap="md">
+            <Group justify="space-between">
+              <Text fw={600} size="sm">{bookingRef(invoiceConfirm)}</Text>
+              <Text size="sm" c="dimmed">{customerName(invoiceConfirm)}</Text>
+            </Group>
+            <Card withBorder padding="sm" radius="md" bg="var(--mantine-color-gray-0)">
+              <Stack gap={6}>
+                {(invoiceConfirm.vehicleAssignments ?? []).map((a) => {
+                  const v = a.vehicle;
+                  const label = v ? [v.code, v.plateNumber].filter(Boolean).join(" · ") : a.vehicleId;
+                  return (
+                    <Group key={a.id} justify="space-between" wrap="nowrap">
+                      <Text size="sm">
+                        {label}
+                        {a.containerNumber ? ` · ${a.containerNumber}` : ""}
+                      </Text>
+                      <Text size="sm">{a.distanceKm != null ? `${a.distanceKm} km` : "—"}</Text>
+                    </Group>
+                  );
+                })}
+              </Stack>
+            </Card>
+            <Group justify="space-between">
+              <Text size="sm" c="dimmed">Total distance</Text>
+              <Text size="sm" fw={500}>{invoiceConfirm.exactKm ?? 0} km</Text>
+            </Group>
+            <Group justify="space-between">
+              <Text fw={600}>Invoice amount</Text>
+              <Text fw={700}>{formatPrice(invoiceConfirm.remainingPayment, currencyOf(invoiceConfirm))}</Text>
+            </Group>
+            {confirmIssues.mixedCurrency && (
+              <Alert color="red" variant="light" title="Mixed truck currencies">
+                Trucks use {confirmIssues.currencies.join(", ")}. Assign trucks that share one currency before invoicing.
+              </Alert>
+            )}
+            {confirmIssues.zeroPrice.length > 0 && (
+              <Alert color="yellow" variant="light" title="Truck has no price/km">
+                {confirmIssues.zeroPrice.join(", ")} will bill 0 — set Price per KM on the vehicle.
+              </Alert>
+            )}
+            <Text size="xs" c="dimmed">
+              Generate the delivery-fee invoice now, or close and generate later from the row actions.
+            </Text>
+            <Group justify="flex-end" gap="sm">
+              <Button variant="default" onClick={() => setInvoiceConfirm(null)}>Later</Button>
+              <Button
+                loading={generateInvoiceMutation.isPending}
+                disabled={confirmIssues.mixedCurrency}
+                onClick={() =>
+                  generateInvoiceMutation.mutate(invoiceConfirm.id, {
+                    onSuccess: () => setInvoiceConfirm(null),
+                  })
+                }
+              >
+                Generate Invoice
+              </Button>
+            </Group>
+          </Stack>
+        )}
+      </Modal>
     </Stack>
   );
 };
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 4b5cec080..d57210e1e 100644
--- a/apps/edr-freight-web/backoffice/src/pages/operations/LastMilePage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/operations/LastMilePage.tsx
@@ -19,7 +19,6 @@ import { DataTable, DataTableFooter, usePagination } from "@edr/ui-common";
 import {
   ActionIcon,
   Alert,
-  Autocomplete,
   Badge,
   Box,
   Button,
@@ -56,8 +55,8 @@ import {
 } from "@/services/last-mile.service";
 import { vehiclesService } from "@/services/vehicles.service";
 import { driversService, type Driver } from "@/services/drivers.service";
-import { ratesService } from "@/services/rates.service";
 import { ReleaseOrderModal, type ReleaseOrderTruckPrefill } from "@/components/warehouses/ReleaseOrderModal";
+import { TruckDetentionModal } from "@/components/operations/TruckDetentionModal";
 import { LastMileStepper, type LastMileStepState } from "@/components/operations/LastMileSteps";
 
 const formatPrice = (amount: number | string | null | undefined, currency = "ETB") =>
@@ -233,7 +232,24 @@ const computeLastMileSteps = (
 };
 
 const bookingRef = (r: LastMileRecord) => r.booking?.reference ?? r.bookingId;
-const currencyOf = (r: LastMileRecord) => r.booking?.paymentCurrency ?? "ETB";
+const currencyOf = (r: LastMileRecord) =>
+  r.vehicle?.currency ??
+  r.vehicleAssignments?.[0]?.vehicle?.currency ??
+  r.booking?.paymentCurrency ??
+  "ETB";
+
+type LmAssignment = NonNullable<LastMileRecord["vehicleAssignments"]>[number];
+const truckShort = (a: LmAssignment) =>
+  a.vehicle ? [a.vehicle.code, a.vehicle.plateNumber].filter(Boolean).join(" · ") : a.vehicleId;
+/** Billing problems on the trucks that have distance: zero price/km, mixed currency. */
+const billingIssues = (r: LastMileRecord) => {
+  const trucks = (r.vehicleAssignments ?? []).filter((a) => Number(a.distanceKm) > 0);
+  const zeroPrice = trucks.filter((a) => !(Number(a.vehicle?.pricePerKm) > 0)).map(truckShort);
+  const currencies = [
+    ...new Set(trucks.map((a) => a.vehicle?.currency).filter((c): c is string => Boolean(c))),
+  ];
+  return { zeroPrice, mixedCurrency: currencies.length > 1, currencies };
+};
 const customerName = (r: LastMileRecord) => r.booking?.company?.name ?? "—";
 const deliveryLocation = (r: LastMileRecord) => r.booking?.lastMileDeliveryAddress ?? "—";
 const cargoDesc = (r: LastMileRecord) => {
@@ -544,6 +560,7 @@ const LastMilePage = () => {
   const [tripSlipVehicleId, setTripSlipVehicleId] = useState<string | null>(null);
   const [tripSlipSelectOpen, setTripSlipSelectOpen] = useState(false);
   const [activeId, setActiveId] = useState<string | null>(null);
+  const [detentionRecord, setDetentionRecord] = useState<LastMileRecord | null>(null);
   // Multi-vehicle assign: one row per truck — vehicle + the container it carries.
   const [vehicleRows, setVehicleRows] = useState<
     Array<{ vehicleId: string | null; containerNumber: string }>
@@ -581,14 +598,6 @@ const LastMilePage = () => {
     },
   });
 
-  const { data: ratesData } = useQuery({
-    queryKey: ["rates", "LAST_MILE"],
-    queryFn: async () => {
-      const res = await ratesService.getByType("LAST_MILE");
-      return res.data;
-    },
-  });
-
   const records = listData?.data ?? [];
   const existingLastMileBookingIds = useMemo(
     () => new Set(records.map((record) => record.bookingId)),
@@ -667,10 +676,17 @@ const LastMilePage = () => {
       distances: Array<{ vehicleId: string; distanceKm: number }>;
       remainingPayment?: number;
     }) => lastMileService.setDistances(id, distances, remainingPayment),
-    onSuccess: () => {
+    onSuccess: (res) => {
       void qc.invalidateQueries({ queryKey: QUERY_KEYS.LAST_MILE.ROOT });
       toast({ title: "Distances saved", description: activeRecord ? bookingRef(activeRecord) : undefined });
+      const updated = res?.data as LastMileRecord | undefined;
       closeDistance();
+      // Every truck has a distance and it isn't billed yet → offer to invoice now.
+      const trucks = updated?.vehicleAssignments ?? [];
+      const allFilled = trucks.length > 0 && trucks.every((a) => Number(a.distanceKm) > 0);
+      if (updated && allFilled && !updated.invoice) {
+        setInvoiceConfirm(updated);
+      }
     },
     onError: () => {
       toast({ title: "Update failed", variant: "destructive" });
@@ -802,18 +818,9 @@ const LastMilePage = () => {
       return;
     }
 
-    const total = distances.reduce((s, d) => s + d.distanceKm, 0);
-    let remainingPayment: number | undefined;
-    if (ratesData?.data) {
-      const lastMileRate = ratesData.data.find(
-        (r) => r.rateType === "LAST_MILE" && (r.status === "LIVE" || r.status === "DRAFT")
-      );
-      if (lastMileRate) {
-        remainingPayment = total * parseFloat(lastMileRate.rateValue);
-      }
-    }
-
-    distanceMutation.mutate({ id: activeId, distances, remainingPayment });
+    // Amount is computed server-side per truck (distance × the vehicle's
+    // price/km, in the vehicle's currency) — no flat LAST_MILE rate.
+    distanceMutation.mutate({ id: activeId, distances });
   };
 
   const activeRecord = useMemo(
@@ -929,6 +936,11 @@ const LastMilePage = () => {
     [records],
   );
 
+  // Billing problems on the leg pending invoice confirmation.
+  const confirmIssues = invoiceConfirm
+    ? billingIssues(invoiceConfirm)
+    : { zeroPrice: [] as string[], mixedCurrency: false, currencies: [] as string[] };
+
   const filteredRecords = useMemo(() => {
     const term = search.trim().toLowerCase();
     return records.filter((r) => {
@@ -1270,6 +1282,17 @@ const LastMilePage = () => {
             Boolean(releaseRow?.releaseOrderReference) && !releaseRow?.releaseDate && !pastTransit;
           return (
             <Group gap={4} justify="flex-end" wrap="nowrap">
+              {pastTransit && (
+                <Button
+                  size="compact-xs"
+                  variant="light"
+                  color="orange"
+                  leftSection={<Receipt size={13} />}
+                  onClick={() => setDetentionRecord(row.original)}
+                >
+                  Detention
+                </Button>
+              )}
               <Menu
                 position="bottom-end"
                 width={200}
@@ -1360,6 +1383,16 @@ const LastMilePage = () => {
                   >
                     {row.original.invoice ? "Invoice generated" : "Generate Invoice"}
                   </Menu.Item>
+                  {/* Truck detention: set/adjust arrival & return times, preview the
+                      per-truck-per-day charge, and generate its invoice. Available
+                      once the vehicle is en route/delivered (clock has a start). */}
+                  <Menu.Item
+                    leftSection={<Receipt size={15} />}
+                    disabled={!pastTransit}
+                    onClick={() => setDetentionRecord(row.original)}
+                  >
+                    Truck detention
+                  </Menu.Item>
                   {canPrint && (
                     <Menu.Item
                       leftSection={<Printer size={15} />}
@@ -1697,21 +1730,29 @@ const LastMilePage = () => {
                   clearable
                   disabled={assignVehicleOptions.length === 0}
                 />
-                <Autocomplete
+                <Select
                   style={{ flex: 1 }}
                   label={i === 0 ? "Container no." : undefined}
-                  placeholder="Container number"
-                  data={containerOptions.filter(
-                    (n) =>
-                      n === row.containerNumber ||
-                      !vehicleRows.some((r, idx) => idx !== i && r.containerNumber === n),
-                  )}
-                  value={row.containerNumber}
+                  placeholder={containerOptions.length ? "Select container" : "No container numbers"}
+                  data={[
+                    ...containerOptions.filter(
+                      (n) =>
+                        n === row.containerNumber ||
+                        !vehicleRows.some((r, idx) => idx !== i && r.containerNumber === n),
+                    ),
+                    // keep a manual/legacy value selectable even if not in the booking
+                    ...(row.containerNumber && !containerOptions.includes(row.containerNumber)
+                      ? [row.containerNumber]
+                      : []),
+                  ]}
+                  value={row.containerNumber || null}
                   onChange={(value) =>
                     setVehicleRows((prev) =>
-                      prev.map((x, idx) => (idx === i ? { ...x, containerNumber: value } : x)),
+                      prev.map((x, idx) => (idx === i ? { ...x, containerNumber: value ?? "" } : x)),
                     )
                   }
+                  searchable
+                  clearable
                 />
                 {vehicleRows.length > 1 && (
                   <ActionIcon
@@ -1993,6 +2034,16 @@ const LastMilePage = () => {
               <Text fw={600}>Invoice amount</Text>
               <Text fw={700}>{formatPrice(invoiceConfirm.remainingPayment, currencyOf(invoiceConfirm))}</Text>
             </Group>
+            {confirmIssues.mixedCurrency && (
+              <Alert color="red" variant="light" title="Mixed truck currencies">
+                Trucks use {confirmIssues.currencies.join(", ")}. Assign trucks that share one currency before invoicing.
+              </Alert>
+            )}
+            {confirmIssues.zeroPrice.length > 0 && (
+              <Alert color="yellow" variant="light" title="Truck has no price/km">
+                {confirmIssues.zeroPrice.join(", ")} will bill 0 — set Price per KM on the vehicle.
+              </Alert>
+            )}
             <Text size="xs" c="dimmed">
               This creates the delivery-fee invoice. Confirm the distances and amount are correct.
             </Text>
@@ -2000,6 +2051,7 @@ const LastMilePage = () => {
               <Button variant="default" onClick={() => setInvoiceConfirm(null)}>Cancel</Button>
               <Button
                 loading={generateInvoiceMutation.isPending}
+                disabled={confirmIssues.mixedCurrency}
                 onClick={() =>
                   generateInvoiceMutation.mutate(invoiceConfirm.id, {
                     onSuccess: () => setInvoiceConfirm(null),
@@ -2019,6 +2071,12 @@ const LastMilePage = () => {
         item={releaseItem}
         truckPrefill={releaseTruckPrefill}
       />
+
+      <TruckDetentionModal
+        opened={Boolean(detentionRecord)}
+        onClose={() => setDetentionRecord(null)}
+        record={detentionRecord}
+      />
     </Stack>
   );
 };
diff --git a/apps/edr-freight-web/backoffice/src/pages/ruleEngine/config/resources.ts b/apps/edr-freight-web/backoffice/src/pages/ruleEngine/config/resources.ts
index 2014f9c65..a9ad6ea39 100644
--- a/apps/edr-freight-web/backoffice/src/pages/ruleEngine/config/resources.ts
+++ b/apps/edr-freight-web/backoffice/src/pages/ruleEngine/config/resources.ts
@@ -15,7 +15,7 @@ export type ColumnFormat =
   | "entityLabel"
   | "rateLabel";
 
-export type FormFieldType = "text" | "number" | "boolean" | "date" | "email" | "select" | "multiselect" | "textarea";
+export type FormFieldType = "text" | "number" | "boolean" | "date" | "email" | "select" | "multiselect" | "textarea" | "radio";
 
 export interface ResourceColumn {
   id: string;
@@ -92,6 +92,12 @@ const TRADE_DIRECTIONS = [
   { label: "Both", value: "BOTH" },
 ];
 
+// Mirrors the YardCountry enum in @edr/types — the only two countries on the line.
+const YARD_COUNTRIES = [
+  { label: "Ethiopia", value: "Ethiopia" },
+  { label: "Djibouti", value: "Djibouti" },
+];
+
 const APPROVAL_ROLES = [
   { label: "Line staff", value: "LINE_STAFF" },
   { label: "Director", value: "DIRECTOR" },
@@ -181,6 +187,7 @@ const CURRENCIES = [
 const PRIORITY_CONFIG_TYPES = [
   { label: "Wagon count", value: "WAGON" },
   { label: "Payment currency", value: "CURRENCY" },
+  { label: "Customs clearance", value: "CUSTOMS" },
 ];
 
 const codeColumn = (key: string, header = "Code"): ResourceColumn => ({
@@ -304,7 +311,7 @@ export const RULE_ENGINE_RESOURCES: RuleEngineResourceConfig[] = [
     slug: "priority-configs",
     label: "Priority Rules",
     category: "rules",
-    subtitle: "Wagon-count and payment-currency scoring rules",
+    subtitle: "Wagon-count, payment-currency, and customs scoring rules",
     searchPlaceholder: "Search priority rules...",
     orderConfig: { field: "displayOrder", label: "Display order" },
     columns: [
@@ -331,7 +338,7 @@ export const RULE_ENGINE_RESOURCES: RuleEngineResourceConfig[] = [
         optional: true,
         options: [{ label: "None", value: RULE_ENGINE_SELECT_NONE }, ...CURRENCIES],
         placeholder: "Select a currency",
-        hideWhen: { field: "type", equals: ["WAGON"] },
+        hideWhen: { field: "type", equals: ["WAGON", "CUSTOMS"] },
       },
       { name: "minWagonCount", label: "Min wagon count", type: "number", required: true },
       { name: "maxWagonCount", label: "Max wagon count", type: "number", required: true },
@@ -351,7 +358,6 @@ export const RULE_ENGINE_RESOURCES: RuleEngineResourceConfig[] = [
       codeColumn("code"),
       { id: "serviceName", header: "Service name", accessorKey: "serviceName" },
       { id: "displayOrder", header: "#", accessorKey: "displayOrder", format: "number" },
-      { id: "priorityBonusPoints", header: "Bonus pts", accessorKey: "priorityBonusPoints", format: "number" },
       activeColumn,
     ],
     formFields: [
@@ -361,7 +367,6 @@ export const RULE_ENGINE_RESOURCES: RuleEngineResourceConfig[] = [
       { name: "includesFirstMile", label: "Includes first mile", type: "boolean" },
       { name: "includesLastMile", label: "Includes last mile", type: "boolean" },
       { name: "includesCustoms", label: "Includes customs", type: "boolean" },
-      { name: "priorityBonusPoints", label: "Priority bonus points", type: "number" },
       { name: "isActive", label: "Active", type: "boolean" },
     ],
   },
@@ -431,7 +436,13 @@ export const RULE_ENGINE_RESOURCES: RuleEngineResourceConfig[] = [
     ],
     formFields: [
       { name: "label", label: "Label", type: "text", required: true },
-      { name: "country", label: "Country", type: "text", required: true },
+      {
+        name: "country",
+        label: "Country",
+        type: "select",
+        required: true,
+        options: YARD_COUNTRIES,
+      },
       { name: "isActive", label: "Active", type: "boolean" },
     ],
   },
diff --git a/apps/edr-freight-web/backoffice/src/pages/trainScheduling/BatchScheduleDetailPage.tsx b/apps/edr-freight-web/backoffice/src/pages/trainScheduling/BatchScheduleDetailPage.tsx
index de6ecfa9b..6daf79221 100644
--- a/apps/edr-freight-web/backoffice/src/pages/trainScheduling/BatchScheduleDetailPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/trainScheduling/BatchScheduleDetailPage.tsx
@@ -33,6 +33,7 @@ import {
   RefreshCw,
   Ruler,
   TrainFront,
+  Trophy,
   Weight,
   XCircle,
 } from "lucide-react";
@@ -55,6 +56,8 @@ import {
   WindowStatusPill,
 } from "@/components/trainScheduling/batchVisuals";
 import { RouteCorridor } from "@/components/trainScheduling/scheduleVisuals";
+import { PriorityTrackingTab } from "@/components/trainScheduling/PriorityTrackingTab";
+import { useBookingWindowSocket } from "@/features/bookingWindows/useBookingWindowSocket";
 import { BookingsManager } from "./BookingsManager";
 import { useMutation, useQuery } from "@tanstack/react-query";
 import { api } from "@/services/api";
@@ -578,9 +581,23 @@ export default function BatchScheduleDetailPage() {
     api.trainScheduling.batchBoardDetail.queryOptions({
       input: { scheduleId: scheduleId ?? "" },
       enabled: Boolean(scheduleId),
-      refetchInterval: 30_000,
+      // Poll fast while a window cycle is actively moving (open / doc-review /
+      // payment) so the priority ranking + pay countdowns stay live; back off to
+      // 30s once the cycle is idle (pre-window / closed / done).
+      refetchInterval: (query) => {
+        const phase = (query.state.data as BatchBoardScheduleDetail | undefined)
+          ?.windowPhase;
+        return phase === "OPEN" ||
+          phase === "DOC_REVIEW" ||
+          phase === "PAYMENT"
+          ? 5_000
+          : 30_000;
+      },
     }),
   );
+  // Keep the board in sync with server-pushed window-phase transitions too
+  // (invalidates the batch-board list + patches window carousels).
+  useBookingWindowSocket(Boolean(scheduleId));
   const runAllocation = useMutation(
     api.trainScheduling.runAllocation.mutationOptions(),
   );
@@ -735,6 +752,13 @@ export default function BatchScheduleDetailPage() {
       <Tabs value={activeTab} onChange={setActiveTab}>
         <Tabs.List>
           <Tabs.Tab value="overview">Overview</Tabs.Tab>
+          <Tabs.Tab
+            value="priority"
+            leftSection={<Trophy size={14} />}
+          >
+            Priority Tracking{" "}
+            {allBookings.length > 0 && `(${allBookings.length})`}
+          </Tabs.Tab>
           <Tabs.Tab value="composition">
             Train Composition{" "}
             {scheduleDetailQuery.data?.trainSet?.wagons &&
@@ -1095,6 +1119,10 @@ export default function BatchScheduleDetailPage() {
           </Stack>
         </Tabs.Panel>
 
+        <Tabs.Panel value="priority" pt="lg">
+          <PriorityTrackingTab data={data} bookings={allBookings} />
+        </Tabs.Panel>
+
         <Tabs.Panel value="composition" pt="lg">
           {scheduleDetailQuery.data && scheduleDetailQuery.data.trainSet ? (
             <Group align="stretch" gap="md" wrap="nowrap">
diff --git a/apps/edr-freight-web/backoffice/src/pages/trainScheduling/TrainScheduleTrackPage.tsx b/apps/edr-freight-web/backoffice/src/pages/trainScheduling/TrainScheduleTrackPage.tsx
index 7eb995ac2..e253a8db8 100644
--- a/apps/edr-freight-web/backoffice/src/pages/trainScheduling/TrainScheduleTrackPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/trainScheduling/TrainScheduleTrackPage.tsx
@@ -16,7 +16,7 @@ import {
   Group,
   Loader,
   Paper,
-  Progress,
+  RingProgress,
   Stack,
   Text,
   ThemeIcon,
@@ -26,7 +26,11 @@ import {
 
 import { PageContainer } from "@/components/page";
 import { RouteCorridorTrack } from "@/components/trainScheduling/RouteCorridorTrack";
-import { RouteCorridor, StatusPill } from "@/components/trainScheduling/scheduleVisuals";
+import {
+  RouteCorridor,
+  StatusPill,
+  scheduleBrand,
+} from "@/components/trainScheduling/scheduleVisuals";
 import { freightBrand } from "@/theme/freight-brand";
 import { useMutation, useQuery } from "@tanstack/react-query";
 import { api } from "@/services/api";
@@ -52,8 +56,11 @@ function formatDateTime(iso?: string | null) {
   });
 }
 
-/** Compact icon + label + value cell used in the header meta strip. */
-function MetaStat({
+/**
+ * A single fact in the hero's glass meta strip — icon chip + uppercase label +
+ * value, laid on the translucent panel over the gradient.
+ */
+function HeroStat({
   icon,
   label,
   value,
@@ -63,15 +70,33 @@ function MetaStat({
   value: string;
 }) {
   return (
-    <Group gap={8} wrap="nowrap" style={{ minWidth: 0 }}>
-      <ThemeIcon size={32} radius="md" variant="light" color="edr-green">
+    <Group gap={10} wrap="nowrap" style={{ minWidth: 0 }}>
+      <Box
+        style={{
+          width: 34,
+          height: 34,
+          borderRadius: 10,
+          display: "flex",
+          alignItems: "center",
+          justifyContent: "center",
+          background: "rgba(255,255,255,0.16)",
+          border: "1px solid rgba(255,255,255,0.24)",
+          color: "white",
+          flexShrink: 0,
+        }}
+      >
         {icon}
-      </ThemeIcon>
-      <Stack gap={0} style={{ minWidth: 0 }}>
-        <Text size="10px" fw={700} tt="uppercase" c="dimmed" style={{ letterSpacing: 0.5 }}>
+      </Box>
+      <Stack gap={1} style={{ minWidth: 0 }}>
+        <Text
+          size="10px"
+          fw={700}
+          tt="uppercase"
+          style={{ letterSpacing: 0.6, color: "rgba(255,255,255,0.72)" }}
+        >
           {label}
         </Text>
-        <Text size="sm" fw={700} c="dark.5" truncate>
+        <Text size="sm" fw={700} c="white" truncate>
           {value}
         </Text>
       </Stack>
@@ -79,6 +104,38 @@ function MetaStat({
   );
 }
 
+/** Section header — icon chip + title + one-line hint. Shared by the cards. */
+function SectionHead({
+  icon,
+  title,
+  hint,
+}: {
+  icon: React.ReactNode;
+  title: string;
+  hint: string;
+}) {
+  return (
+    <Group gap="sm" align="center" wrap="nowrap">
+      <ThemeIcon size={36} radius="md" variant="light" color="edr-green">
+        {icon}
+      </ThemeIcon>
+      <Stack gap={0} style={{ minWidth: 0 }}>
+        <Text fw={800} size="sm">
+          {title}
+        </Text>
+        <Text size="xs" c="dimmed">
+          {hint}
+        </Text>
+      </Stack>
+    </Group>
+  );
+}
+
+const CARD_STYLE = {
+  borderColor: scheduleBrand.mutedBorder,
+  boxShadow: scheduleBrand.shadowSm,
+} as const;
+
 export default function TrainScheduleTrackPage() {
   const { scheduleId } = useParams<{ scheduleId: string }>();
   const { toast } = useToast();
@@ -116,9 +173,13 @@ export default function TrainScheduleTrackPage() {
   const canLog = track.status === "DISPATCHED";
   const totalStations = track.stations.length;
   const reached = Math.min(track.currentSequenceNo + 1, totalStations);
-  const progressPct = totalStations > 1 ? (track.currentSequenceNo / (totalStations - 1)) * 100 : 0;
+  const progressPct =
+    totalStations > 1 ? (track.currentSequenceNo / (totalStations - 1)) * 100 : 0;
   const clampedPct = Math.min(100, Math.max(0, progressPct));
-  const currentStation = track.stations[Math.max(0, track.currentSequenceNo)]?.label ?? "—";
+  const currentStation =
+    track.stations[Math.max(0, track.currentSequenceNo)]?.label ?? "—";
+  const inTransit = track.status === "DISPATCHED";
+  const arrived = track.status === "ARRIVED";
 
   const handleLog = (sequenceNo: number) => {
     const isFinal = sequenceNo === track.stations[totalStations - 1]?.sequenceNo;
@@ -156,160 +217,259 @@ export default function TrainScheduleTrackPage() {
         Back to schedule
       </Button>
 
-      {/* Header */}
-      <Paper radius="lg" withBorder p="lg">
-        <Stack gap="lg">
-          <Group justify="space-between" align="flex-start" wrap="wrap" gap="md">
-            <Group gap="md" align="flex-start" wrap="nowrap" style={{ minWidth: 0 }}>
-              <Box
-                style={{
-                  width: 48,
-                  height: 48,
-                  borderRadius: 12,
-                  display: "flex",
-                  alignItems: "center",
-                  justifyContent: "center",
-                  background: freightBrand.gradient,
-                  color: "white",
-                  flexShrink: 0,
-                }}
-              >
-                <Navigation size={24} />
-              </Box>
-              <Stack gap={6} style={{ minWidth: 0 }}>
-                <Group gap="sm" align="center" wrap="wrap">
-                  <Title order={3} fw={800}>
-                    Train tracking
-                  </Title>
-                  {track.trainNumber ? (
-                    <Badge variant="light" color="edr-green" radius="sm">
-                      {track.trainNumber}
-                    </Badge>
-                  ) : null}
-                  {track.direction ? (
-                    <Badge variant="light" color="gray" radius="sm">
-                      {track.direction}
-                    </Badge>
-                  ) : null}
-                </Group>
-                <Box maw={360}>
-                  <RouteCorridor origin={track.origin} destination={track.destination} variant="compact" />
+      {/* ── Hero: gradient wash, route + a bold progress ring woven together ── */}
+      <Paper
+        radius="lg"
+        p={0}
+        style={{ overflow: "hidden", boxShadow: scheduleBrand.shadow }}
+      >
+        <Box
+          style={{
+            background: scheduleBrand.heroGradient,
+            padding: "26px 28px",
+            position: "relative",
+          }}
+        >
+          {/* soft decorative glow, purely artistic */}
+          <Box
+            style={{
+              position: "absolute",
+              top: -80,
+              right: -60,
+              width: 260,
+              height: 260,
+              borderRadius: "50%",
+              background: "rgba(255,255,255,0.10)",
+              pointerEvents: "none",
+            }}
+          />
+
+          <Group
+            justify="space-between"
+            align="flex-start"
+            wrap="wrap"
+            gap="xl"
+            style={{ position: "relative" }}
+          >
+            {/* left — identity + route */}
+            <Stack gap={14} style={{ minWidth: 260, flex: 1 }}>
+              <Group gap="md" align="center" wrap="nowrap">
+                <Box
+                  style={{
+                    width: 52,
+                    height: 52,
+                    borderRadius: 14,
+                    display: "flex",
+                    alignItems: "center",
+                    justifyContent: "center",
+                    background: "rgba(255,255,255,0.16)",
+                    border: "1px solid rgba(255,255,255,0.26)",
+                    color: "white",
+                    flexShrink: 0,
+                  }}
+                >
+                  <Navigation size={26} />
                 </Box>
-              </Stack>
-            </Group>
-            <StatusPill status={track.status} />
-          </Group>
+                <Stack gap={6} style={{ minWidth: 0 }}>
+                  <Group gap="sm" align="center" wrap="wrap">
+                    <Title order={3} fw={800} c="white">
+                      Train tracking
+                    </Title>
+                    {track.trainNumber ? (
+                      <Badge
+                        variant="white"
+                        color="dark"
+                        radius="sm"
+                        styles={{ root: { color: freightBrand.primaryDark } }}
+                      >
+                        {track.trainNumber}
+                      </Badge>
+                    ) : null}
+                    {track.direction ? (
+                      <Badge
+                        variant="outline"
+                        radius="sm"
+                        styles={{
+                          root: {
+                            color: "white",
+                            borderColor: "rgba(255,255,255,0.5)",
+                          },
+                        }}
+                      >
+                        {track.direction}
+                      </Badge>
+                    ) : null}
+                  </Group>
+                  <Box maw={380}>
+                    <RouteCorridor
+                      origin={track.origin}
+                      destination={track.destination}
+                      variant="compact"
+                      onDark
+                    />
+                  </Box>
+                </Stack>
+              </Group>
 
-          {/* Journey progress */}
-          <Box>
-            <Group justify="space-between" mb={6}>
-              <Text size="xs" fw={700} c="gray.7" tt="uppercase" style={{ letterSpacing: 0.4 }}>
-                Journey progress
-              </Text>
-              <Text size="xs" fw={700} c="edr-green.8">
-                {reached} / {totalStations} stations · {Math.round(clampedPct)}%
-              </Text>
-            </Group>
-            <Progress
-              value={clampedPct}
-              size="lg"
-              radius="xl"
-              color="edr-green"
-              striped={track.status === "DISPATCHED"}
-              animated={track.status === "DISPATCHED"}
-            />
-          </Box>
+              <Group gap="sm">
+                <StatusPill status={track.status} size="md" />
+                <Box
+                  px={12}
+                  py={5}
+                  style={{
+                    borderRadius: 999,
+                    background: "rgba(255,255,255,0.16)",
+                    border: "1px solid rgba(255,255,255,0.24)",
+                  }}
+                >
+                  <Text size="xs" fw={700} c="white" style={{ letterSpacing: 0.2 }}>
+                    {arrived
+                      ? "Journey complete"
+                      : inTransit
+                        ? `En route · ${currentStation}`
+                        : "Awaiting dispatch"}
+                  </Text>
+                </Box>
+              </Group>
+            </Stack>
 
-          {/* Meta strip */}
-          <Group justify="space-between" wrap="wrap" gap="lg">
-            <MetaStat icon={<MapPin size={16} />} label="Current" value={currentStation} />
-            <MetaStat
-              icon={<CalendarClock size={16} />}
-              label="Departed"
-              value={formatDateTime(track.actualDepartureAt)}
-            />
-            <MetaStat
-              icon={<Flag size={16} />}
-              label="Arrived"
-              value={formatDateTime(track.actualArrivalAt)}
-            />
-            <MetaStat
-              icon={<Train size={16} />}
-              label="Stations"
-              value={`${reached} of ${totalStations}`}
+            {/* right — progress ring, the artistic focal point */}
+            <RingProgress
+              size={132}
+              thickness={11}
+              roundCaps
+              sections={[{ value: clampedPct, color: "white" }]}
+              rootColor="rgba(255,255,255,0.22)"
+              label={
+                <Stack gap={0} align="center">
+                  <Text fw={800} fz={26} lh={1} c="white">
+                    {Math.round(clampedPct)}%
+                  </Text>
+                  <Text
+                    size="10px"
+                    fw={700}
+                    tt="uppercase"
+                    style={{ letterSpacing: 0.6, color: "rgba(255,255,255,0.8)" }}
+                  >
+                    {reached}/{totalStations} stops
+                  </Text>
+                </Stack>
+              }
             />
           </Group>
-        </Stack>
+        </Box>
+
+        {/* glass meta strip below the wash */}
+        <Group
+          justify="space-between"
+          wrap="wrap"
+          gap="lg"
+          px={28}
+          py="md"
+          style={{
+            background: freightBrand.primaryDark,
+            borderTop: "1px solid rgba(255,255,255,0.12)",
+          }}
+        >
+          <HeroStat icon={<MapPin size={16} />} label="Current" value={currentStation} />
+          <HeroStat
+            icon={<CalendarClock size={16} />}
+            label="Departed"
+            value={formatDateTime(track.actualDepartureAt)}
+          />
+          <HeroStat
+            icon={<Flag size={16} />}
+            label="Arrived"
+            value={formatDateTime(track.actualArrivalAt)}
+          />
+          <HeroStat
+            icon={<Train size={16} />}
+            label="Stations"
+            value={`${reached} of ${totalStations}`}
+          />
+        </Group>
       </Paper>
 
-      {/* Corridor */}
-      <Paper radius="lg" p="lg" withBorder>
+      {/* ── Route corridor ── */}
+      <Paper radius="lg" p="lg" withBorder style={CARD_STYLE}>
         <Stack gap="md">
-          <Group gap="sm" align="center" wrap="nowrap">
-            <ThemeIcon size={34} radius="md" variant="light" color="edr-green">
-              <Navigation size={17} />
-            </ThemeIcon>
-            <Stack gap={0}>
-              <Text fw={800} size="sm">
-                Route corridor
-              </Text>
-              <Text size="xs" c="dimmed">
-                {canLog
-                  ? "Log the train passing each station; the final station marks arrival."
-                  : track.status === "ARRIVED"
-                    ? "This train has arrived at its destination."
-                    : "Tracking becomes available once the train is dispatched."}
-              </Text>
-            </Stack>
-          </Group>
-
+          <SectionHead
+            icon={<Navigation size={17} />}
+            title="Route corridor"
+            hint={
+              canLog
+                ? "Log the train passing each station; the final station marks arrival."
+                : arrived
+                  ? "This train has arrived at its destination."
+                  : "Tracking becomes available once the train is dispatched."
+            }
+          />
           <RouteCorridorTrack
             stations={track.stations}
             currentSequenceNo={track.currentSequenceNo}
             checkpoints={track.checkpoints}
             canLog={canLog}
             loggingSeq={
-              recordCheckpoint.isPending ? recordCheckpoint.variables?.payload.sequenceNo : null
+              recordCheckpoint.isPending
+                ? recordCheckpoint.variables?.payload.sequenceNo
+                : null
             }
             onLogCheckpoint={handleLog}
           />
         </Stack>
       </Paper>
 
-      {/* Checkpoint log */}
-      <Paper radius="lg" p="lg" withBorder>
-        <Group gap="sm" align="center" wrap="nowrap" mb="md">
-          <ThemeIcon size={34} radius="md" variant="light" color="edr-green">
-            <CheckCircle2 size={17} />
-          </ThemeIcon>
-          <Stack gap={0}>
-            <Text fw={800} size="sm">
-              Checkpoint log
-            </Text>
-            <Text size="xs" c="dimmed">
-              {track.checkpoints.length} event{track.checkpoints.length === 1 ? "" : "s"} recorded
-            </Text>
-          </Stack>
+      {/* ── Checkpoint log ── */}
+      <Paper radius="lg" p="lg" withBorder style={CARD_STYLE}>
+        <Group justify="space-between" wrap="nowrap" mb="md">
+          <SectionHead
+            icon={<CheckCircle2 size={17} />}
+            title="Checkpoint log"
+            hint={`${track.checkpoints.length} event${
+              track.checkpoints.length === 1 ? "" : "s"
+            } recorded`}
+          />
         </Group>
 
         {track.checkpoints.length === 0 ? (
-          <Stack align="center" gap="xs" py="xl">
-            <ThemeIcon size={44} radius="xl" variant="light" color="gray">
-              <MapPin size={20} />
+          <Stack
+            align="center"
+            gap="xs"
+            py={40}
+            style={{
+              borderRadius: 14,
+              border: `1px dashed ${scheduleBrand.mutedBorder}`,
+              background: scheduleBrand.softSurface,
+            }}
+          >
+            <ThemeIcon size={48} radius="xl" variant="light" color="edr-green">
+              <MapPin size={22} />
             </ThemeIcon>
-            <Text size="sm" fw={600} c="gray.7">
+            <Text size="sm" fw={700} c="gray.7">
               No checkpoints yet
             </Text>
-            <Text size="xs" c="dimmed" ta="center" maw={300}>
-              Each station the train passes will be logged here with its timestamp.
+            <Text size="xs" c="dimmed" ta="center" maw={320}>
+              Each station the train passes will be logged here with its
+              timestamp.
             </Text>
           </Stack>
         ) : (
-          <Timeline active={track.checkpoints.length} bulletSize={22} lineWidth={2} color="edr-green">
+          <Timeline
+            active={track.checkpoints.length}
+            bulletSize={24}
+            lineWidth={2}
+            color="edr-green"
+          >
             {track.checkpoints.map((cp) => (
               <Timeline.Item
                 key={cp.id}
-                bullet={cp.kind === "ARRIVED" ? <CheckCircle2 size={13} /> : <MapPin size={12} />}
+                bullet={
+                  cp.kind === "ARRIVED" ? (
+                    <CheckCircle2 size={13} />
+                  ) : (
+                    <MapPin size={12} />
+                  )
+                }
                 title={
                   <Group gap="sm">
                     <Text fw={700} size="sm">
@@ -319,7 +479,13 @@ export default function TrainScheduleTrackPage() {
                       size="xs"
                       radius="sm"
                       variant="light"
-                      color={cp.kind === "ARRIVED" ? "teal" : cp.kind === "DEPARTED" ? "blue" : "edr-green"}
+                      color={
+                        cp.kind === "ARRIVED"
+                          ? "teal"
+                          : cp.kind === "DEPARTED"
+                            ? "blue"
+                            : "edr-green"
+                      }
                     >
                       {cp.kind}
                     </Badge>
diff --git a/apps/edr-freight-web/backoffice/src/pages/trainScheduling/TrainScheduleV2DetailPage.tsx b/apps/edr-freight-web/backoffice/src/pages/trainScheduling/TrainScheduleV2DetailPage.tsx
index 7ee0f7896..f4cd3be02 100644
--- a/apps/edr-freight-web/backoffice/src/pages/trainScheduling/TrainScheduleV2DetailPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/trainScheduling/TrainScheduleV2DetailPage.tsx
@@ -49,6 +49,7 @@ import {
 import { ContainerPlacementGrid } from "@/components/trainScheduling/ContainerPlacementGrid";
 import { FleetAvailabilitySummary } from "@/components/trainScheduling/FleetAvailabilitySummary";
 import { IntercityRideAlongPanel } from "@/components/trainScheduling/IntercityRideAlongPanel";
+import { YardWorkPanel } from "@/components/trainScheduling/YardWorkPanel";
 // import { ImportLoadingConfirmationPanel } from "@/components/trainScheduling/ImportLoadingConfirmationPanel";
 import { RescheduleTrainDialog } from "@/components/trainScheduling/RescheduleTrainDialog";
 import BookingWindowSettingsModal from "@/components/trainScheduling/BookingWindowSettingsModal";
@@ -863,6 +864,16 @@ export default function TrainScheduleV2DetailPage() {
               </ThemeIcon>
               <Stack gap={6}>
                 <Group gap="sm" align="center" wrap="wrap">
+                  {schedule.reference ? (
+                    <Badge
+                      variant="filled"
+                      color="edr-green"
+                      radius="sm"
+                      style={{ fontWeight: 700, fontFamily: "monospace" }}
+                    >
+                      {schedule.reference}
+                    </Badge>
+                  ) : null}
                   <Title order={2} fw={700} style={{ color: "#0f172a" }}>
                     {schedule.route?.name ?? "Train schedule"}
                   </Title>
@@ -1131,6 +1142,7 @@ export default function TrainScheduleV2DetailPage() {
               void detailQuery.refetch();
             }}
           />
+          {scheduleId ? <YardWorkPanel scheduleId={scheduleId} /> : null}
           {scheduleId ? (
             <IntercityRideAlongPanel
               scheduleId={scheduleId}
diff --git a/apps/edr-freight-web/backoffice/src/pages/trainScheduling/TrainScheduleV2ListPage.tsx b/apps/edr-freight-web/backoffice/src/pages/trainScheduling/TrainScheduleV2ListPage.tsx
index f36ce8394..14432d8ed 100644
--- a/apps/edr-freight-web/backoffice/src/pages/trainScheduling/TrainScheduleV2ListPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/trainScheduling/TrainScheduleV2ListPage.tsx
@@ -89,6 +89,13 @@ export default function TrainScheduleV2ListPage() {
   const [search, setSearch] = useState("");
   const [statusFilter, setStatusFilter] = useState("ALL");
   const [freightFilter, setFreightFilter] = useState("ALL");
+  const [originFilter, setOriginFilter] = useState("ALL");
+  const [destinationFilter, setDestinationFilter] = useState("ALL");
+  // Default: newest-created first, matching the API's default order.
+  const [sortBy, setSortBy] = useState<"createdAt" | "scheduleDate" | "reference">(
+    "createdAt",
+  );
+  const [sortDir, setSortDir] = useState<"desc" | "asc">("desc");
   const [createOpen, setCreateOpen] = useState(false);
   const [windowSettingsId, setWindowSettingsId] = useState<string | null>(null);
   const [editDateSchedule, setEditDateSchedule] =
@@ -152,13 +159,32 @@ export default function TrainScheduleV2ListPage() {
     return base;
   }, [allSchedules]);
 
+  // Distinct origins/destinations present in the loaded schedules, for the
+  // corridor filters. Sorted A→Z; "ALL" prepended by the Select data below.
+  const originOptions = useMemo(
+    () =>
+      [...new Set(allSchedules.map((s) => s.origin).filter(Boolean))].sort() as string[],
+    [allSchedules],
+  );
+  const destinationOptions = useMemo(
+    () =>
+      [
+        ...new Set(allSchedules.map((s) => s.destination).filter(Boolean)),
+      ].sort() as string[],
+    [allSchedules],
+  );
+
   const filtered = useMemo(() => {
     const query = search.trim().toLowerCase();
-    return allSchedules.filter((s) => {
+    const matched = allSchedules.filter((s) => {
       if (statusFilter !== "ALL" && s.status !== statusFilter) return false;
       if (freightFilter !== "ALL" && s.freightType !== freightFilter) return false;
+      if (originFilter !== "ALL" && s.origin !== originFilter) return false;
+      if (destinationFilter !== "ALL" && s.destination !== destinationFilter)
+        return false;
       if (!query) return true;
       const haystack = [
+        s.reference,
         s.trainNumber,
         s.routeName,
         s.origin,
@@ -173,7 +199,31 @@ export default function TrainScheduleV2ListPage() {
         .toLowerCase();
       return haystack.includes(query);
     });
-  }, [allSchedules, search, statusFilter, freightFilter]);
+
+    const dir = sortDir === "asc" ? 1 : -1;
+    const sorted = [...matched].sort((a, b) => {
+      let cmp = 0;
+      if (sortBy === "reference") {
+        cmp = (a.reference ?? "").localeCompare(b.reference ?? "");
+      } else {
+        // createdAt or scheduleDate — compare as timestamps (missing sorts last).
+        const av = new Date(a[sortBy] ?? 0).getTime();
+        const bv = new Date(b[sortBy] ?? 0).getTime();
+        cmp = av - bv;
+      }
+      return cmp * dir;
+    });
+    return sorted;
+  }, [
+    allSchedules,
+    search,
+    statusFilter,
+    freightFilter,
+    originFilter,
+    destinationFilter,
+    sortBy,
+    sortDir,
+  ]);
 
   const pageCount = Math.max(1, Math.ceil(filtered.length / pagination.pageSize));
   const paged = useMemo(() => {
@@ -185,6 +235,16 @@ export default function TrainScheduleV2ListPage() {
     const headerClassName = ruleEngineTable.headerCell;
     const cellClassName = ruleEngineTable.bodyCell;
     return [
+      {
+        id: "reference",
+        header: "Ref",
+        meta: { headerClassName, cellClassName },
+        cell: ({ row }) => (
+          <Text size="sm" fw={600} ff="monospace" c="edr-green.8">
+            {row.original.reference ?? "—"}
+          </Text>
+        ),
+      },
       {
         id: "date",
         header: "Departure",
@@ -471,6 +531,58 @@ export default function TrainScheduleV2ListPage() {
                     w={140}
                     styles={{ input: { borderColor: "var(--mantine-color-gray-3)" } }}
                   />
+                  <Select
+                    size="sm"
+                    radius="lg"
+                    placeholder="Origin"
+                    searchable
+                    value={originFilter}
+                    onChange={(v) => setOriginFilter(v ?? "ALL")}
+                    data={[
+                      { value: "ALL", label: "All origins" },
+                      ...originOptions.map((o) => ({ value: o, label: o })),
+                    ]}
+                    w={160}
+                    styles={{ input: { borderColor: "var(--mantine-color-gray-3)" } }}
+                  />
+                  <Select
+                    size="sm"
+                    radius="lg"
+                    placeholder="Destination"
+                    searchable
+                    value={destinationFilter}
+                    onChange={(v) => setDestinationFilter(v ?? "ALL")}
+                    data={[
+                      { value: "ALL", label: "All destinations" },
+                      ...destinationOptions.map((d) => ({ value: d, label: d })),
+                    ]}
+                    w={170}
+                    styles={{ input: { borderColor: "var(--mantine-color-gray-3)" } }}
+                  />
+                  <Select
+                    size="sm"
+                    radius="lg"
+                    value={`${sortBy}:${sortDir}`}
+                    onChange={(v) => {
+                      if (!v) return;
+                      const [by, dir] = v.split(":") as [
+                        typeof sortBy,
+                        typeof sortDir,
+                      ];
+                      setSortBy(by);
+                      setSortDir(dir);
+                    }}
+                    data={[
+                      { value: "createdAt:desc", label: "Newest created" },
+                      { value: "createdAt:asc", label: "Oldest created" },
+                      { value: "scheduleDate:desc", label: "Departure ↓" },
+                      { value: "scheduleDate:asc", label: "Departure ↑" },
+                      { value: "reference:asc", label: "Reference ↑" },
+                      { value: "reference:desc", label: "Reference ↓" },
+                    ]}
+                    w={170}
+                    styles={{ input: { borderColor: "var(--mantine-color-gray-3)" } }}
+                  />
                 </>
               }
             />
@@ -693,9 +805,16 @@ function ScheduleCard({
               <Train size={18} />
             </ThemeIcon>
             <Stack gap={0} style={{ minWidth: 0 }}>
-              <Text fw={600} size="sm" lineClamp={1}>
-                {schedule.routeName ?? "Train schedule"}
-              </Text>
+              <Group gap={6} wrap="nowrap">
+                {schedule.reference ? (
+                  <Text size="xs" fw={700} ff="monospace" c="edr-green.8">
+                    {schedule.reference}
+                  </Text>
+                ) : null}
+                <Text fw={600} size="sm" lineClamp={1}>
+                  {schedule.routeName ?? "Train schedule"}
+                </Text>
+              </Group>
               <Text size="xs" c="dimmed">
                 {day} · {time}
               </Text>
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 458e71de6..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 {
@@ -37,6 +39,9 @@ import {
   FEE_RULE_BASIS_LABELS,
   FEE_RULE_TYPES,
   FEE_RULE_TYPE_LABELS,
+  VEHICLE_TYPES,
+  type AllocationRule,
+  type FeeRule,
   type FeeRuleBasis,
   type FeeRuleType,
 } from '@/types/warehouse';
@@ -120,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,
@@ -141,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,
@@ -152,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()) {
@@ -159,7 +183,7 @@ function AllocationRules() {
       return;
     }
 
-    await create.mutateAsync({
+    const payload = {
       name: form.name.trim(),
       priority: form.priority,
       freightType: clean(form.freightType) ?? null,
@@ -169,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 (
@@ -181,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>
@@ -228,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>
               ))}
@@ -244,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}>
@@ -339,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>
@@ -362,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,
@@ -372,7 +413,9 @@ function FeeRules() {
     tradeDirection: '',
     cargoTypeCode: '',
     containerType: '',
+    vehicleType: '',
     freeDays: 3,
+    freeHours: 3,
     ratePerDay: 0,
     tiers: [] as Array<{ fromDay: number; toDay: number | null; ratePerDay: number }>,
     currency: 'USD',
@@ -385,8 +428,14 @@ function FeeRules() {
   // Double handling is a flat per-unit charge (basis × rate), not day-based:
   // no free days, no progressive tiers.
   const isDoubleHandling = form.ruleType === 'DOUBLE_HANDLING_FEE';
+  // Truck detention: per truck per day after an HOURS-based grace (default 3h),
+  // with day tiers. Uses "free hours" instead of "free days".
+  const isTruckDetention = form.ruleType === 'TRUCK_DETENTION_FEE';
+  // 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',
@@ -395,11 +444,34 @@ function FeeRules() {
       tradeDirection: '',
       cargoTypeCode: '',
       containerType: '',
+      vehicleType: '',
       freeDays: 3,
+      freeHours: 3,
       ratePerDay: 0,
       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) => {
@@ -456,24 +528,30 @@ function FeeRules() {
       name: form.name.trim(),
       ruleType: form.ruleType,
       freightType: clean(form.freightType) ?? null,
-      tradeDirection: clean(form.tradeDirection) ?? null,
+      tradeDirection: isImportOnly ? 'IMPORT' : clean(form.tradeDirection) ?? null,
       cargoTypeCode: isBulkRule ? (clean(form.cargoTypeCode) ?? null) : null,
       containerType: isContainerRule ? (clean(form.containerType) ?? null) : null,
-      // Double handling: flat basis × rate — no free days, no tiers.
-      freeDays: isDoubleHandling ? 0 : form.freeDays,
+      // Double handling: flat basis × rate. Truck detention: HOURS-based grace.
+      freeDays: isDoubleHandling || isTruckDetention ? 0 : form.freeDays,
       ratePerDay: form.ratePerDay,
       currency: form.currency || 'USD',
       ...(isDoubleHandling ? { basis: form.basis } : {}),
+      ...(isTruckDetention ? { freeHours: form.freeHours, vehicleType: clean(form.vehicleType) ?? null } : {}),
       ...(!isDoubleHandling && tiers.length ? { tiers } : {}),
     };
 
     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,
@@ -494,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) });
     }
   };
 
@@ -504,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>
@@ -566,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>
               ))}
@@ -582,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
@@ -627,11 +710,23 @@ function FeeRules() {
             />
             <Select
               label="Trade direction"
+              description={isImportOnly ? 'Import only for this fee type' : undefined}
               data={TRADE}
-              value={form.tradeDirection || null}
+              value={isImportOnly ? 'IMPORT' : form.tradeDirection || null}
               onChange={(value) => setForm((f) => ({ ...f, tradeDirection: selectValue(value) }))}
-              clearable
+              disabled={isImportOnly}
+              clearable={!isImportOnly}
             />
+            {isTruckDetention && (
+              <Select
+                label="Truck type"
+                placeholder="Any truck type"
+                data={VEHICLE_TYPES.map((v) => ({ value: v, label: v.charAt(0) + v.slice(1).toLowerCase() }))}
+                value={form.vehicleType || null}
+                onChange={(value) => setForm((f) => ({ ...f, vehicleType: selectValue(value) }))}
+                clearable
+              />
+            )}
             {isBulkRule && (
               <Select
                 label="Cargo type"
@@ -668,6 +763,14 @@ function FeeRules() {
                 }
                 allowDeselect={false}
               />
+            ) : isTruckDetention ? (
+              <NumberInput
+                label="Free hours"
+                description="Grace before detention accrues"
+                min={0}
+                value={form.freeHours}
+                onChange={(value) => setForm((f) => ({ ...f, freeHours: numberValue(value) }))}
+              />
             ) : (
               <NumberInput
                 label="Free days"
@@ -744,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 27648cab2..c991c54f6 100644
--- a/apps/edr-freight-web/backoffice/src/services/api.ts
+++ b/apps/edr-freight-web/backoffice/src/services/api.ts
@@ -180,6 +180,7 @@ import {
   wagonService,
   type Wagon,
   type WagonListFilters,
+  type WagonMovementRecord,
 } from "./wagon.service";
 import { warehouseService } from "./warehouse.service";
 
@@ -593,6 +594,40 @@ export const api = {
       () => TRAIN_SCHEDULING_INVALIDATIONS,
     ),
 
+    yardWork: endpoint<
+      { scheduleId: string },
+      import("@/types/trainScheduling").YardWorkResult
+    >(
+      "train-scheduling",
+      "yard-work",
+      ({ scheduleId }) => trainSchedulingService.getYardWork(scheduleId),
+      ({ scheduleId }) => ["train-scheduling", "yard-work", scheduleId],
+    ),
+
+    loadScheduleBooking: endpoint<
+      { scheduleId: string; bookingId: string },
+      import("@/types/trainScheduling").BookingLoadResult
+    >(
+      "train-scheduling",
+      "booking-load",
+      ({ scheduleId, bookingId }) =>
+        trainSchedulingService.loadScheduleBooking(scheduleId, bookingId),
+      undefined,
+      () => TRAIN_SCHEDULING_INVALIDATIONS,
+    ),
+
+    unloadScheduleBooking: endpoint<
+      { scheduleId: string; bookingId: string },
+      import("@/types/trainScheduling").BookingUnloadResult
+    >(
+      "train-scheduling",
+      "booking-unload",
+      ({ scheduleId, bookingId }) =>
+        trainSchedulingService.unloadScheduleBooking(scheduleId, bookingId),
+      undefined,
+      () => TRAIN_SCHEDULING_INVALIDATIONS,
+    ),
+
     intercityCandidates: endpoint<
       { scheduleId: string },
       import("@/types/trainScheduling").IntercityCandidatesResult
@@ -1493,6 +1528,13 @@ export const api = {
       wagonService.getById(id).then((r) => r.data),
     ),
 
+    movements: endpoint<{ id: string }, WagonMovementRecord[]>(
+      "wagons",
+      "movements",
+      ({ id }) => wagonService.getMovements(id).then((r) => r.data),
+      ({ id }) => ["wagons", "movements", id],
+    ),
+
     assignToTrain: endpoint<
       { wagonId: string; trainId: string; sequenceNumber?: number },
       Wagon
diff --git a/apps/edr-freight-web/backoffice/src/services/compliance.service.ts b/apps/edr-freight-web/backoffice/src/services/compliance.service.ts
new file mode 100644
index 000000000..a73494c2a
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/services/compliance.service.ts
@@ -0,0 +1,73 @@
+import { api as apiClient } from '../auth/http';
+
+export type ComplianceType =
+  | 'INSPECTION'
+  | 'INSURANCE'
+  | 'ROADWORTHINESS'
+  | 'PERMIT'
+  | 'TAX';
+
+export type ComplianceStatus = 'VALID' | 'EXPIRING' | 'EXPIRED';
+
+export type AlertSeverity = 'OVERDUE' | 'DUE_SOON';
+
+export interface ComplianceRecord {
+  id: string;
+  vehicleId: string;
+  vehicle?: {
+    id: string;
+    plateNumber?: string | null;
+    manufacturer?: string | null;
+    model?: string | null;
+  };
+  type: ComplianceType;
+  documentNumber?: string | null;
+  issuedDate?: string | null;
+  expiryDate: string;
+  status: ComplianceStatus;
+  notes?: string | null;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface ComplianceAlert {
+  vehicleId: string;
+  vehiclePlate?: string;
+  kind: string;
+  label: string;
+  expiryDate: string;
+  daysUntil: number;
+  severity: AlertSeverity;
+}
+
+export interface ComplianceListFilters {
+  vehicleId?: string;
+  type?: ComplianceType;
+}
+
+export interface SaveCompliancePayload {
+  vehicleId: string;
+  type: ComplianceType;
+  documentNumber?: string;
+  issuedDate?: string;
+  expiryDate: string;
+  status?: ComplianceStatus;
+  notes?: string;
+}
+
+export const complianceService = {
+  list: (filters: ComplianceListFilters = {}) => {
+    const params = new URLSearchParams();
+    if (filters.vehicleId) params.set('vehicleId', filters.vehicleId);
+    if (filters.type) params.set('type', filters.type);
+    const qs = params.toString();
+    return apiClient.get<ComplianceRecord[]>(`/compliance${qs ? `?${qs}` : ''}`);
+  },
+  getAlerts: () => apiClient.get<ComplianceAlert[]>('/compliance/alerts'),
+  getById: (id: string) => apiClient.get<ComplianceRecord>(`/compliance/${id}`),
+  create: (data: SaveCompliancePayload) =>
+    apiClient.post<ComplianceRecord>('/compliance', data),
+  update: (id: string, data: Partial<SaveCompliancePayload>) =>
+    apiClient.patch<ComplianceRecord>(`/compliance/${id}`, data),
+  remove: (id: string) => apiClient.delete(`/compliance/${id}`),
+};
diff --git a/apps/edr-freight-web/backoffice/src/services/contracts.service.ts b/apps/edr-freight-web/backoffice/src/services/contracts.service.ts
index 7ad051ce7..c23b51df2 100644
--- a/apps/edr-freight-web/backoffice/src/services/contracts.service.ts
+++ b/apps/edr-freight-web/backoffice/src/services/contracts.service.ts
@@ -185,6 +185,16 @@ export const contractsService = {
       requiredRole,
     }),
 
+  rejectStep: ({
+    id,
+    stepId,
+    reason,
+  }: {
+    id: string;
+    stepId: string;
+    reason: string;
+  }) => postContract<Freight.IContract>(C.REJECT_STEP(id, stepId), { reason }),
+
   // ── Contract document ──
   generateContract: (id: string) =>
     postContract<Freight.IContract>(C.CONTRACT_GENERATE(id)),
diff --git a/apps/edr-freight-web/backoffice/src/services/drivers.service.ts b/apps/edr-freight-web/backoffice/src/services/drivers.service.ts
index 79b0f88ef..c16f3b083 100644
--- a/apps/edr-freight-web/backoffice/src/services/drivers.service.ts
+++ b/apps/edr-freight-web/backoffice/src/services/drivers.service.ts
@@ -39,6 +39,17 @@ export type SaveDriverPayload = Omit<
   'id' | 'createdAt' | 'updatedAt' | 'totalTrips' | 'rating'
 >;
 
+/** A stored driver document (code "driver_docs"). */
+export interface DriverDocument {
+  id: string;
+  name: string;
+  url: string;
+  size: number;
+  mimeType: string;
+  code: string;
+  createdAt: string;
+}
+
 export const driversService = {
   getAll: (filters: DriverListFilters = {}) => {
     const params = new URLSearchParams();
@@ -59,4 +70,18 @@ export const driversService = {
   update: (id: string, data: Partial<SaveDriverPayload>) =>
     apiClient.patch(URL_CONSTANTS.DRIVERS.BY_ID(id), data),
   delete: (id: string) => apiClient.delete(URL_CONSTANTS.DRIVERS.BY_ID(id)),
+
+  // ── Driver documents (upload area code "driver_docs") ──
+  listDocuments: (id: string) =>
+    apiClient.get<DriverDocument[]>(`${URL_CONSTANTS.DRIVERS.BY_ID(id)}/documents`),
+  uploadDocuments: (id: string, files: File[]) => {
+    const form = new FormData();
+    for (const f of files) form.append('files', f);
+    return apiClient.post<DriverDocument[]>(
+      `${URL_CONSTANTS.DRIVERS.BY_ID(id)}/documents`,
+      form,
+    );
+  },
+  removeDocument: (id: string, fileId: string) =>
+    apiClient.delete(`${URL_CONSTANTS.DRIVERS.BY_ID(id)}/documents/${fileId}`),
 };
diff --git a/apps/edr-freight-web/backoffice/src/services/first-mile.service.ts b/apps/edr-freight-web/backoffice/src/services/first-mile.service.ts
index 6fc80a282..275bf84ea 100644
--- a/apps/edr-freight-web/backoffice/src/services/first-mile.service.ts
+++ b/apps/edr-freight-web/backoffice/src/services/first-mile.service.ts
@@ -47,6 +47,8 @@ export interface FirstMileVehicle {
   trailerPlateNo?: string | null;
   assignedDriverId?: string | null;
   assignedDriverName?: string | null;
+  pricePerKm?: number | string | null;
+  currency?: string | null;
 }
 
 export interface FirstMileRecord {
diff --git a/apps/edr-freight-web/backoffice/src/services/gps-tracking.service.ts b/apps/edr-freight-web/backoffice/src/services/gps-tracking.service.ts
new file mode 100644
index 000000000..d11898328
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/services/gps-tracking.service.ts
@@ -0,0 +1,48 @@
+import { api } from "@/auth/http";
+
+export interface GpsDevice {
+  id: string;
+  imei: string;
+  name?: string | null;
+  vehicleId?: string | null;
+  vehicle?: {
+    id: string;
+    plateNumber?: string;
+    code?: string | null;
+    manufacturer?: string;
+    model?: string;
+  } | null;
+  status: string;
+  online: boolean;
+  lastSeenAt?: string | null;
+  lastLat?: number | string | null;
+  lastLng?: number | string | null;
+  lastSpeed?: number | string | null;
+  lastCourse?: number | null;
+  lastFixAt?: string | null;
+  voltageLevel?: number | null;
+  gsmLevel?: number | null;
+}
+
+export interface GpsPosition {
+  id: string;
+  lat: number | string;
+  lng: number | string;
+  speed: number | string;
+  course: number;
+  satellites: number;
+  gpsTime: string;
+  alarm: number;
+}
+
+export const gpsTrackingService = {
+  latest: () => api.get<GpsDevice[]>("/gps/positions/latest"),
+  listDevices: () => api.get<GpsDevice[]>("/gps/devices"),
+  history: (vehicleId: string, limit = 200) =>
+    api.get<GpsPosition[]>(`/gps/positions/${vehicleId}/history?limit=${limit}`),
+  register: (data: { imei: string; name?: string; vehicleId?: string | null }) =>
+    api.post<GpsDevice>("/gps/devices", data),
+  update: (id: string, data: { name?: string; vehicleId?: string | null }) =>
+    api.patch<GpsDevice>(`/gps/devices/${id}`, data),
+  remove: (id: string) => api.delete<void>(`/gps/devices/${id}`),
+};
diff --git a/apps/edr-freight-web/backoffice/src/services/incidents.service.ts b/apps/edr-freight-web/backoffice/src/services/incidents.service.ts
new file mode 100644
index 000000000..6e54ec68b
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/services/incidents.service.ts
@@ -0,0 +1,87 @@
+import { api } from '@/auth/http';
+
+export type IncidentType = 'ACCIDENT' | 'BREAKDOWN' | 'TRAFFIC_VIOLATION' | 'THEFT' | 'OTHER';
+export type IncidentSeverity = 'MINOR' | 'MODERATE' | 'MAJOR' | 'CRITICAL';
+export type IncidentStatus =
+  | 'REPORTED'
+  | 'UNDER_REVIEW'
+  | 'CLAIM_FILED'
+  | 'RESOLVED'
+  | 'CLOSED';
+
+export interface Incident {
+  id: string;
+  vehicleId?: string | null;
+  driverId?: string | null;
+  bookingId?: string | null;
+  type: IncidentType;
+  severity: IncidentSeverity;
+  occurredAt: string;
+  location?: string | null;
+  description: string;
+  /** API sends numeric as string; coerce with Number. */
+  damageEstimate?: number | string | null;
+  status: IncidentStatus;
+  insuranceClaimNumber?: string | null;
+  reportedBy?: string | null;
+  vehicle?: {
+    id: string;
+    plateNumber?: string | null;
+    registrationNumber?: string | null;
+  } | null;
+  driver?: {
+    id: string;
+    firstName?: string | null;
+    lastName?: string | null;
+  } | null;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface IncidentFilters {
+  vehicleId?: string;
+  driverId?: string;
+  status?: IncidentStatus;
+  type?: IncidentType;
+}
+
+export interface DriverIncidentStats {
+  total: number;
+  byType: Record<string, number>;
+  lastIncidentAt: string | null;
+}
+
+export interface SaveIncidentPayload {
+  vehicleId?: string;
+  driverId?: string;
+  bookingId?: string;
+  type: IncidentType;
+  severity: IncidentSeverity;
+  occurredAt: string;
+  location?: string;
+  description: string;
+  damageEstimate?: number;
+  status?: IncidentStatus;
+  insuranceClaimNumber?: string;
+  reportedBy?: string;
+}
+
+export const incidentsService = {
+  getAll: (filters: IncidentFilters = {}) => {
+    const params = new URLSearchParams();
+    if (filters.vehicleId) params.set('vehicleId', filters.vehicleId);
+    if (filters.driverId) params.set('driverId', filters.driverId);
+    if (filters.status) params.set('status', filters.status);
+    if (filters.type) params.set('type', filters.type);
+    const qs = params.toString();
+    return api.get<Incident[]>(`/incidents${qs ? `?${qs}` : ''}`);
+  },
+  getByDriver: (driverId: string) => api.get<Incident[]>(`/incidents/driver/${driverId}`),
+  getDriverStats: (driverId: string) =>
+    api.get<DriverIncidentStats>(`/incidents/driver/${driverId}/stats`),
+  getById: (id: string) => api.get<Incident>(`/incidents/${id}`),
+  create: (data: SaveIncidentPayload) => api.post<Incident>('/incidents', data),
+  update: (id: string, data: Partial<SaveIncidentPayload>) =>
+    api.patch<Incident>(`/incidents/${id}`, data),
+  delete: (id: string) => api.delete(`/incidents/${id}`),
+};
diff --git a/apps/edr-freight-web/backoffice/src/services/last-mile.service.ts b/apps/edr-freight-web/backoffice/src/services/last-mile.service.ts
index 88e4bb9c0..4b4133b6a 100644
--- a/apps/edr-freight-web/backoffice/src/services/last-mile.service.ts
+++ b/apps/edr-freight-web/backoffice/src/services/last-mile.service.ts
@@ -1,5 +1,6 @@
 import { api } from '../auth/http';
 import { URL_CONSTANTS } from '@/constants/URLS';
+import type { FeePreview } from '@/types/warehouse';
 
 export const LAST_MILE_STATUSES = [
   'PAYMENT_PENDING',
@@ -47,6 +48,8 @@ export interface LastMileVehicle {
   trailerPlateNo?: string | null;
   assignedDriverId?: string | null;
   assignedDriverName?: string | null;
+  pricePerKm?: number | string | null;
+  currency?: string | null;
 }
 
 export interface LastMileRecord {
@@ -70,6 +73,9 @@ export interface LastMileRecord {
   }>;
   /** Present only when an invoice has actually been generated (not on distance). */
   invoice?: { id: string; number: string; status: string } | null;
+  /** Truck-detention clock: vehicle arrival + delivery/return times. */
+  arrivedAt?: string | null;
+  deliveredAt?: string | null;
   createdAt: string;
   updatedAt: string;
 }
@@ -85,7 +91,7 @@ export const lastMileService = {
   list: (pageSize = 1000) =>
     api.get<LastMileListResponse>(`${LM.BASE}?pageSize=${pageSize}`),
   getById: (id: string) => api.get<LastMileRecord>(LM.BY_ID(id)),
-  update: (id: string, data: { status?: LastMileApiStatus; vehicleId?: string | null; estimatedKm?: number | null; exactKm?: number | null; paid?: boolean }) =>
+  update: (id: string, data: { status?: LastMileApiStatus; vehicleId?: string | null; estimatedKm?: number | null; exactKm?: number | null; paid?: boolean; arrivedAt?: string | null; deliveredAt?: string | null }) =>
     api.patch<LastMileRecord>(LM.BY_ID(id), data),
   accept: (bookingReference: string) =>
     api.post<LastMileRecord>(LM.ACCEPT(encodeURIComponent(bookingReference))),
@@ -102,4 +108,12 @@ export const lastMileService = {
   ) => api.post<LastMileRecord>(`${LM.BASE}/${id}/distances`, { distances, remainingPayment }),
   generateInvoice: (id: string) =>
     api.post<{ id: string; invoiceNumber?: string } | null>(`${LM.BASE}/${id}/invoice`),
+  /** Generate a truck-detention invoice (per truck per day after the grace window). */
+  generateTruckDetentionInvoice: (id: string) =>
+    api.post<{ id: string; invoiceNumber?: string } | null>(
+      `${LM.BASE}/${id}/generate-truck-detention-invoice`,
+    ),
+  /** Preview the truck-detention charge for a last-mile leg. */
+  truckDetentionPreview: (id: string) =>
+    api.get<FeePreview>(`${LM.BASE}/${id}/truck-detention-preview`),
 };
diff --git a/apps/edr-freight-web/backoffice/src/services/maintenance-depth.service.ts b/apps/edr-freight-web/backoffice/src/services/maintenance-depth.service.ts
new file mode 100644
index 000000000..83ae34e67
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/services/maintenance-depth.service.ts
@@ -0,0 +1,130 @@
+import { api } from '@/auth/http';
+
+export type WorkOrderStatus = 'OPEN' | 'IN_PROGRESS' | 'COMPLETED' | 'CANCELLED';
+export type WorkOrderPriority = 'LOW' | 'MEDIUM' | 'HIGH' | 'URGENT';
+
+export interface WorkOrder {
+  id: string;
+  vehicleId: string;
+  title: string;
+  description?: string | null;
+  status: WorkOrderStatus;
+  priority: WorkOrderPriority;
+  assignedTo?: string | null;
+  openedAt: string;
+  closedAt?: string | null;
+  /** API sends numeric as string; coerce with Number. */
+  laborCost?: number | string | null;
+  partsCost?: number | string | null;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface SaveWorkOrderPayload {
+  vehicleId: string;
+  title: string;
+  description?: string;
+  status?: WorkOrderStatus;
+  priority?: WorkOrderPriority;
+  assignedTo?: string;
+  openedAt?: string;
+  closedAt?: string;
+  laborCost?: number;
+  partsCost?: number;
+}
+
+export interface WorkOrderFilters {
+  vehicleId?: string;
+  status?: WorkOrderStatus;
+}
+
+export interface Part {
+  id: string;
+  name: string;
+  sku?: string | null;
+  category?: string | null;
+  quantityInStock: number;
+  reorderLevel: number;
+  /** API sends numeric as string; coerce with Number. */
+  unitCost?: number | string | null;
+  location?: string | null;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface SavePartPayload {
+  name: string;
+  sku?: string;
+  category?: string;
+  quantityInStock?: number;
+  reorderLevel?: number;
+  unitCost?: number;
+  location?: string;
+}
+
+export interface PartFilters {
+  category?: string;
+  lowStock?: boolean;
+}
+
+export interface Warranty {
+  id: string;
+  vehicleId: string;
+  component: string;
+  provider?: string | null;
+  startDate?: string | null;
+  expiryDate: string;
+  coverageNotes?: string | null;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface SaveWarrantyPayload {
+  vehicleId: string;
+  component: string;
+  provider?: string;
+  startDate?: string;
+  expiryDate: string;
+  coverageNotes?: string;
+}
+
+export const maintenanceDepthService = {
+  // Work Orders
+  getWorkOrders: (filters: WorkOrderFilters = {}) => {
+    const params = new URLSearchParams();
+    if (filters.vehicleId) params.set('vehicleId', filters.vehicleId);
+    if (filters.status) params.set('status', filters.status);
+    const qs = params.toString();
+    return api.get<WorkOrder[]>(`/maintenance/work-orders${qs ? `?${qs}` : ''}`);
+  },
+  getWorkOrder: (id: string) => api.get<WorkOrder>(`/maintenance/work-orders/${id}`),
+  createWorkOrder: (data: SaveWorkOrderPayload) =>
+    api.post<WorkOrder>('/maintenance/work-orders', data),
+  updateWorkOrder: (id: string, data: Partial<SaveWorkOrderPayload>) =>
+    api.patch<WorkOrder>(`/maintenance/work-orders/${id}`, data),
+  deleteWorkOrder: (id: string) => api.delete(`/maintenance/work-orders/${id}`),
+
+  // Parts / Tires
+  getParts: (filters: PartFilters = {}) => {
+    const params = new URLSearchParams();
+    if (filters.category) params.set('category', filters.category);
+    if (filters.lowStock) params.set('lowStock', 'true');
+    const qs = params.toString();
+    return api.get<Part[]>(`/maintenance/parts${qs ? `?${qs}` : ''}`);
+  },
+  createPart: (data: SavePartPayload) => api.post<Part>('/maintenance/parts', data),
+  updatePart: (id: string, data: Partial<SavePartPayload>) =>
+    api.patch<Part>(`/maintenance/parts/${id}`, data),
+  deletePart: (id: string) => api.delete(`/maintenance/parts/${id}`),
+
+  // Warranties
+  getWarranties: (vehicleId?: string) => {
+    const params = new URLSearchParams();
+    if (vehicleId) params.set('vehicleId', vehicleId);
+    const qs = params.toString();
+    return api.get<Warranty[]>(`/maintenance/warranties${qs ? `?${qs}` : ''}`);
+  },
+  createWarranty: (data: SaveWarrantyPayload) =>
+    api.post<Warranty>('/maintenance/warranties', data),
+  deleteWarranty: (id: string) => api.delete(`/maintenance/warranties/${id}`),
+};
diff --git a/apps/edr-freight-web/backoffice/src/services/procurement.service.ts b/apps/edr-freight-web/backoffice/src/services/procurement.service.ts
new file mode 100644
index 000000000..684dcd37f
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/services/procurement.service.ts
@@ -0,0 +1,138 @@
+import { api } from "@/auth/http";
+
+export type VendorType = "DEALER" | "LEASING" | "PARTS" | "SERVICE" | "OTHER";
+export type AcquisitionType = "PURCHASE" | "LEASE" | "RENTAL";
+export type AcquisitionStatus = "ACTIVE" | "LEASE_EXPIRING" | "DISPOSED";
+export type DisposalMethod = "SALE" | "SCRAP" | "RETURN_LEASE" | "TRADE_IN";
+
+export interface Vendor {
+  id: string;
+  name: string;
+  type?: VendorType | null;
+  contactPerson?: string | null;
+  phone?: string | null;
+  email?: string | null;
+  address?: string | null;
+  isActive: boolean;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface AssetAcquisition {
+  id: string;
+  vehicleId?: string | null;
+  vendorId?: string | null;
+  acquisitionType: AcquisitionType;
+  acquisitionDate: string;
+  cost?: number | null;
+  usefulLifeMonths?: number | null;
+  salvageValue?: number | null;
+  leaseStart?: string | null;
+  leaseEnd?: string | null;
+  monthlyPayment?: number | null;
+  status: AcquisitionStatus;
+  notes?: string | null;
+  vehicle?: {
+    id: string;
+    plateNumber?: string | null;
+    registrationNumber?: string | null;
+    manufacturer?: string | null;
+    model?: string | null;
+  } | null;
+  vendor?: Vendor | null;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface AssetDisposal {
+  id: string;
+  vehicleId: string;
+  disposalDate: string;
+  method: DisposalMethod;
+  salePrice?: number | null;
+  buyer?: string | null;
+  notes?: string | null;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface DepreciationResult {
+  method: "STRAIGHT_LINE";
+  cost: number;
+  salvageValue: number;
+  usefulLifeMonths: number;
+  monthsElapsed: number;
+  monthlyDepreciation: number;
+  bookValue: number;
+}
+
+export interface LifecycleResult {
+  vehicleId: string;
+  acquisition: AssetAcquisition | null;
+  disposal: AssetDisposal | null;
+  depreciation: DepreciationResult | null;
+}
+
+export interface CreateVendorPayload {
+  name: string;
+  type?: VendorType;
+  contactPerson?: string;
+  phone?: string;
+  email?: string;
+  address?: string;
+  isActive?: boolean;
+}
+
+export interface CreateAcquisitionPayload {
+  vehicleId?: string;
+  vendorId?: string;
+  acquisitionType: AcquisitionType;
+  acquisitionDate: string;
+  cost?: number;
+  usefulLifeMonths?: number;
+  salvageValue?: number;
+  leaseStart?: string;
+  leaseEnd?: string;
+  monthlyPayment?: number;
+  status?: AcquisitionStatus;
+  notes?: string;
+}
+
+export interface CreateDisposalPayload {
+  vehicleId: string;
+  disposalDate: string;
+  method: DisposalMethod;
+  salePrice?: number;
+  buyer?: string;
+  notes?: string;
+}
+
+export const procurementService = {
+  // Vendors
+  listVendors: () => api.get<Vendor[]>("/procurement/vendors"),
+  createVendor: (data: CreateVendorPayload) => api.post("/procurement/vendors", data),
+  updateVendor: (id: string, data: Partial<CreateVendorPayload>) =>
+    api.patch(`/procurement/vendors/${id}`, data),
+  deleteVendor: (id: string) => api.delete(`/procurement/vendors/${id}`),
+
+  // Acquisitions
+  listAcquisitions: (vehicleId?: string) =>
+    api.get<AssetAcquisition[]>(
+      `/procurement/acquisitions${vehicleId ? `?vehicleId=${vehicleId}` : ""}`,
+    ),
+  getAcquisition: (id: string) => api.get<AssetAcquisition>(`/procurement/acquisitions/${id}`),
+  createAcquisition: (data: CreateAcquisitionPayload) =>
+    api.post("/procurement/acquisitions", data),
+  updateAcquisition: (id: string, data: Partial<CreateAcquisitionPayload>) =>
+    api.patch(`/procurement/acquisitions/${id}`, data),
+  deleteAcquisition: (id: string) => api.delete(`/procurement/acquisitions/${id}`),
+
+  // Disposals
+  listDisposals: () => api.get<AssetDisposal[]>("/procurement/disposals"),
+  createDisposal: (data: CreateDisposalPayload) => api.post("/procurement/disposals", data),
+  deleteDisposal: (id: string) => api.delete(`/procurement/disposals/${id}`),
+
+  // Lifecycle
+  lifecycle: (vehicleId: string) =>
+    api.get<LifecycleResult>(`/procurement/lifecycle/${vehicleId}`),
+};
diff --git a/apps/edr-freight-web/backoffice/src/services/trainScheduling.service.ts b/apps/edr-freight-web/backoffice/src/services/trainScheduling.service.ts
index 3f4c6822f..be05c6d8c 100644
--- a/apps/edr-freight-web/backoffice/src/services/trainScheduling.service.ts
+++ b/apps/edr-freight-web/backoffice/src/services/trainScheduling.service.ts
@@ -8,6 +8,8 @@ import type {
   BookableSchedule,
   BookingWindow,
   AssignBookingsPayload,
+  BookingLoadResult,
+  BookingUnloadResult,
   CompositionRemovalEntry,
   UnassignedBookingsResponse,
   CreateTrainSchedulePayload,
@@ -35,6 +37,7 @@ import type {
   UploadImportDjiboutiDocumentPayload,
   WagonAllocationAttemptResult,
   YardOption,
+  YardWorkResult,
 } from "@/types/trainScheduling";
 
 interface BookingReferenceDataResponse {
@@ -330,6 +333,35 @@ export const trainSchedulingService = {
     return unwrap(response.data);
   },
 
+  getYardWork: async (scheduleId: string): Promise<YardWorkResult> => {
+    const response = await client.get<YardWorkResult>(
+      URL_CONSTANTS.TRAIN_SCHEDULING.YARD_WORK(scheduleId),
+    );
+    return unwrap(response.data);
+  },
+
+  loadScheduleBooking: async (
+    scheduleId: string,
+    bookingId: string,
+  ): Promise<BookingLoadResult> => {
+    const response = await client.post<BookingLoadResult>(
+      URL_CONSTANTS.TRAIN_SCHEDULING.BOOKING_LOAD(scheduleId, bookingId),
+      {},
+    );
+    return unwrap(response.data);
+  },
+
+  unloadScheduleBooking: async (
+    scheduleId: string,
+    bookingId: string,
+  ): Promise<BookingUnloadResult> => {
+    const response = await client.post<BookingUnloadResult>(
+      URL_CONSTANTS.TRAIN_SCHEDULING.BOOKING_UNLOAD(scheduleId, bookingId),
+      {},
+    );
+    return unwrap(response.data);
+  },
+
   getIntercityCandidates: async (
     scheduleId: string,
   ): Promise<IntercityCandidatesResult> => {
diff --git a/apps/edr-freight-web/backoffice/src/services/vehicles.service.ts b/apps/edr-freight-web/backoffice/src/services/vehicles.service.ts
index 6b48ed801..749e7656c 100644
--- a/apps/edr-freight-web/backoffice/src/services/vehicles.service.ts
+++ b/apps/edr-freight-web/backoffice/src/services/vehicles.service.ts
@@ -38,6 +38,9 @@ export interface Vehicle {
   /** Odometer-derived distances (API sends numeric strings; coerce with Number). */
   estimatedDistanceKm?: number | null;
   actualDistanceKm?: number | null;
+  /** Haulage rate per km + its currency (ETB | USD). */
+  pricePerKm?: number | null;
+  currency?: string | null;
   createdAt: string;
   updatedAt: string;
 }
diff --git a/apps/edr-freight-web/backoffice/src/services/wagon.service.ts b/apps/edr-freight-web/backoffice/src/services/wagon.service.ts
index da7b2b509..a200195e0 100644
--- a/apps/edr-freight-web/backoffice/src/services/wagon.service.ts
+++ b/apps/edr-freight-web/backoffice/src/services/wagon.service.ts
@@ -37,6 +37,27 @@ export interface WagonListFilters {
   trainId?: string;
 }
 
+/**
+ * One row of the wagon_movements ledger: every physical relocation between
+ * yards — a booking's loaded leg, an empty reposition ride, or a manual staff
+ * correction. Returned newest first by the API.
+ */
+export interface WagonMovementRecord {
+  id: string;
+  wagonId: string;
+  fromYardId: string | null;
+  toYardId: string;
+  fromYard?: { id?: string; label?: string; code?: string } | null;
+  toYard?: { id?: string; label?: string; code?: string } | null;
+  trainScheduleId: string | null;
+  bookingId: string | null;
+  kind: Freight.WagonMovementKind;
+  movedByUserId: string | null;
+  occurredAt: string;
+  note: string | null;
+  createdAt: string;
+}
+
 export const wagonService = {
   getAll: (filters: WagonListFilters = {}) => {
     const params = new URLSearchParams();
@@ -49,6 +70,8 @@ export const wagonService = {
     return apiClient.get<Wagon[]>(`/wagons${qs ? `?${qs}` : ''}`);
   },
   getById: (id: string) => apiClient.get<Wagon>(`/wagons/${id}`),
+  getMovements: (id: string) =>
+    apiClient.get<WagonMovementRecord[]>(`/wagons/${id}/movements`),
   getByTrain: (trainId: string) => apiClient.get<Wagon[]>(`/wagons?trainId=${trainId}`),
   assignToTrain: (wagonId: string, trainId: string, sequenceNumber?: number) =>
     apiClient.post(`/wagons/${wagonId}/assign-train`, { trainId, sequenceNumber }),
diff --git a/apps/edr-freight-web/backoffice/src/types/booking.ts b/apps/edr-freight-web/backoffice/src/types/booking.ts
index 2c0be4726..dc9a29db8 100644
--- a/apps/edr-freight-web/backoffice/src/types/booking.ts
+++ b/apps/edr-freight-web/backoffice/src/types/booking.ts
@@ -19,6 +19,7 @@ export const BOOKING_STATUSES = [
   "PAYMENT_VERIFICATION_IN_PROGRESS",
   "PAID",
   "IN_TRANSIT",
+  "ARRIVED",
   "COMPLETED",
   "REJECTED",
   "CANCELLED",
@@ -206,7 +207,7 @@ export interface BookingDetail {
   company?: BookingNamedRef & Partial<BookingCompany>;
   originYard?: BookingNamedRef;
   destinationYard?: BookingNamedRef;
-  serviceType?: BookingNamedRef & { code?: string; priorityBonusPoints?: number; includesCustoms?: boolean; includesFirstMile?: boolean; includesLastMile?: boolean };
+  serviceType?: BookingNamedRef & { code?: string; includesCustoms?: boolean; includesFirstMile?: boolean; includesLastMile?: boolean };
   cargoType?: BookingNamedRef;
   shippingLine?: BookingNamedRef;
   bookingContainers?: BookingContainerLine[];
@@ -238,7 +239,6 @@ export interface BookingListRow {
   priorityScore: number;
   schedulingStatus?: string;
   serviceTypeLabel?: string;
-  serviceTypeBonus?: number;
   trainScheduleId?: string | null;
   isGovernment?: boolean;
   governmentInstitution?: string | null;
diff --git a/apps/edr-freight-web/backoffice/src/types/customer.ts b/apps/edr-freight-web/backoffice/src/types/customer.ts
index a67f1732f..e92d75c89 100644
--- a/apps/edr-freight-web/backoffice/src/types/customer.ts
+++ b/apps/edr-freight-web/backoffice/src/types/customer.ts
@@ -118,6 +118,7 @@ export type CustomerBookingStatus =
   | "APPROVED"
   | "PAID"
   | "IN_TRANSIT"
+  | "ARRIVED"
   | "COMPLETED"
   | "REJECTED"
   | "CANCELLED";
diff --git a/apps/edr-freight-web/backoffice/src/types/trainScheduling.ts b/apps/edr-freight-web/backoffice/src/types/trainScheduling.ts
index 68ad375d8..2f0422c6f 100644
--- a/apps/edr-freight-web/backoffice/src/types/trainScheduling.ts
+++ b/apps/edr-freight-web/backoffice/src/types/trainScheduling.ts
@@ -152,6 +152,8 @@ export interface LocomotiveRecord {
 
 export interface TrainScheduleListItem {
   id: string;
+  reference?: string | null;
+  createdAt?: string | null;
   scheduleDate: string;
   trainNumber?: string | null;
   routeName?: string | null;
@@ -225,6 +227,10 @@ export interface BatchBoardBooking {
   lengthMeters: number;
   paymentDeadline: string | null;
   state: BatchBoardBookingState;
+  /** Rule-engine priority score used to rank the batch (higher = boards first). */
+  priorityScore: number;
+  /** CONTAINER | BULK — for the priority-tracking visuals. */
+  freightType: string | null;
 }
 
 /**
@@ -233,6 +239,7 @@ export interface BatchBoardBooking {
  */
 export interface StaffBookingWindow {
   scheduleId: string;
+  reference: string | null;
   trainNumber: string | null;
   direction: "IMPORT" | "EXPORT" | null;
   windowPhase: BookingWindowPhase | string | null;
@@ -359,6 +366,8 @@ export interface BookingWindow {
   isOpenNow: boolean;
   windowOpensAt: string | null;
   windowClosesAt: string | null;
+  docReviewEndsAt: string | null;
+  paymentPhaseEndsAt: string | null;
   bookingWindowStatus: string;
   bookingCycleNo: number;
   departureDate: string;
@@ -426,6 +435,7 @@ export interface UpdateScheduleWindowRulePayload {
 
 export interface TrainScheduleDetail {
   id: string;
+  reference?: string | null;
   status: TrainScheduleStatus | string;
   deferredBookings?: DeferredBookingRow[];
   freightType?: FreightType | null;
@@ -794,3 +804,52 @@ export interface IntercityAcceptResult {
   rejected: Array<{ bookingId: string; reason: string }>;
   remaining: IntercityCapacity;
 }
+
+// ── Yard load / unload worklist ──────────────────────────────────────────────
+// Per-booking journey along the train's corridor: every booking boards at its
+// origin yard and alights at its destination yard, confirmed by the yard
+// operator while the train's latest checkpoint is at that yard.
+
+export interface YardWorkBookingRow {
+  id: string;
+  reference: string | null;
+  status: string;
+  tradeDirection: string;
+  isGovernment: boolean;
+  customer: string;
+  originYardId: string;
+  destinationYardId: string;
+  origin: string;
+  destination: string;
+  loadedAt: string | null;
+  arrivedAt: string | null;
+  canLoad: boolean;
+  canUnload: boolean;
+}
+
+export interface YardWorkYard {
+  yardId: string;
+  yard: string;
+  toLoad: YardWorkBookingRow[];
+  toUnload: YardWorkBookingRow[];
+}
+
+export interface YardWorkResult {
+  scheduleId: string;
+  scheduleStatus: string;
+  trainAtYardId: string | null;
+  yards: YardWorkYard[];
+}
+
+export interface BookingLoadResult {
+  bookingId: string;
+  status: string;
+  loadedAt: string;
+}
+
+export interface BookingUnloadResult {
+  bookingId: string;
+  /** 'ARRIVED' for import/export, 'COMPLETED' for intercity. */
+  status: string;
+  arrivedAt: string;
+}
diff --git a/apps/edr-freight-web/backoffice/src/types/warehouse.ts b/apps/edr-freight-web/backoffice/src/types/warehouse.ts
index 70c68aa11..48ec6f7b3 100644
--- a/apps/edr-freight-web/backoffice/src/types/warehouse.ts
+++ b/apps/edr-freight-web/backoffice/src/types/warehouse.ts
@@ -763,6 +763,10 @@ export const FEE_RULE_BASIS_LABELS: Record<FeeRuleBasis, string> = {
   PER_ITEM: 'Per Item',
 };
 
+/** Vehicle types a Truck Detention rule can be scoped to (rates differ by truck type). */
+export const VEHICLE_TYPES = ['TRUCK', 'VAN', 'CAR', 'BUS', 'TRAILER', 'TANKER', 'FLATBED'] as const;
+export type VehicleTypeCode = (typeof VEHICLE_TYPES)[number];
+
 export interface FeeRule {
   id: string;
   name: string;
@@ -774,11 +778,15 @@ export interface FeeRule {
   tradeDirection?: string | null;
   cargoTypeCode?: string | null;
   containerType?: string | null;
+  /** Truck detention only: scope by vehicle type (null = any). */
+  vehicleType?: string | null;
   facilityId?: string | null;
   warehouseId?: string | null;
   yardId?: string | null;
   zoneId?: string | null;
   freeDays: number;
+  /** Truck detention only: grace window in hours (default 3). */
+  freeHours?: number | null;
   ratePerDay: number;
   tiers?: FeeRuleTier[];
   currency: string;
@@ -818,6 +826,16 @@ export interface FeePreview {
   billableUnits: number;
   amount: number;
   tiers?: FeePreviewTier[];
+  /** Truck detention: per-vehicle-type breakdown. */
+  groups?: Array<{
+    vehicleType: string | null;
+    truckCount: number;
+    chargeableDays: number;
+    ratePerDay: number;
+    amount: number;
+    ruleId: string | null;
+    ruleName: string | null;
+  }>;
 }
 
 export interface AllocationPreviewResult {
diff --git a/apps/edr-freight-web/portal/src/components/customer-actions/deriveContractCustomerAction.ts b/apps/edr-freight-web/portal/src/components/customer-actions/deriveContractCustomerAction.ts
index 4de7d2545..5d9a53c91 100644
--- a/apps/edr-freight-web/portal/src/components/customer-actions/deriveContractCustomerAction.ts
+++ b/apps/edr-freight-web/portal/src/components/customer-actions/deriveContractCustomerAction.ts
@@ -117,6 +117,18 @@ export function deriveContractCustomerAction(
     };
   }
 
+  // Saved-but-not-submitted contract — send the customer back into the wizard to
+  // finish editing and submit it for review.
+  if (contract.status === "DRAFT" || contract.status === "RENEWAL_DRAFT") {
+    return {
+      type: "navigate",
+      label: "Continue draft",
+      to: `/contracts/${id}/edit`,
+      primary: true,
+      icon: PencilLine,
+    };
+  }
+
   const payable = findPayableBookingForContract(id, bookings);
   if (payable) {
     return {
diff --git a/apps/edr-freight-web/portal/src/features/bookingWindows/useBookingWindowSocket.ts b/apps/edr-freight-web/portal/src/features/bookingWindows/useBookingWindowSocket.ts
index 5b91af82e..6df836357 100644
--- a/apps/edr-freight-web/portal/src/features/bookingWindows/useBookingWindowSocket.ts
+++ b/apps/edr-freight-web/portal/src/features/bookingWindows/useBookingWindowSocket.ts
@@ -8,6 +8,7 @@ import { useEffect } from "react";
 import { io } from "socket.io-client";
 
 import { API_BASE_URL } from "@/constants/apiConfig";
+import type { MyBookingWindow } from "@/services/bookings.service";
 
 function getAuthToken(): string | undefined {
   return document.cookie
@@ -20,11 +21,52 @@ function getAuthToken(): string | undefined {
 // prefix — strip a trailing `/api` if the base URL carries one.
 const SOCKET_ORIGIN = String(API_BASE_URL ?? "").replace(/\/api\/?$/, "");
 
+// Both window lists live under this key prefix (myBookingWindows +
+// contractBookingWindows/*), so one predicate patches every cached list.
+const WINDOW_KEY_PREFIX = ["train-scheduling"] as const;
+const WINDOW_ACTIONS = new Set(["myBookingWindows", "contractBookingWindows"]);
+
+/**
+ * Fold a server phase push onto a cached window row. `isOpenNow` is recomputed
+ * exactly as the server's mapBookingWindowRow does (phase OPEN + status OPEN) so
+ * the live-patched state can never disagree with what a fresh REST fetch returns
+ * on refresh — both come from the same server timestamps, not the client clock.
+ */
+function applyEvent(
+  row: MyBookingWindow,
+  event: BookingWindowPhaseEvent,
+): MyBookingWindow {
+  return {
+    ...row,
+    windowPhase: event.phase,
+    bookingWindowStatus: event.bookingWindowStatus ?? row.bookingWindowStatus,
+    bookingCycleNo: event.bookingCycleNo,
+    isOpenNow:
+      event.phase === "OPEN" && event.bookingWindowStatus === "OPEN",
+    windowOpensAt: event.windowOpensAt,
+    windowClosesAt: event.windowClosesAt,
+    docReviewEndsAt: event.docReviewEndsAt,
+    paymentPhaseEndsAt: event.paymentPhaseEndsAt,
+    departureDate: event.scheduledDepartureDate ?? row.departureDate,
+  };
+}
+
 /**
  * Subscribes to live booking-window pushes. Every phase transition the window
- * engine applies (open, doc review, payment, reopen, done) invalidates the
- * cached window lists, so the home-page "Booking Windows" card flips the
- * moment the backend does — the 60s poll remains only as a fallback.
+ * engine applies (open, doc review, payment, reopen, done) carries the schedule's
+ * full new state; we fold it straight into the cached window lists with
+ * setQueriesData rather than invalidating.
+ *
+ * Why not invalidate: at ~200 concurrent users a namespace-wide broadcast made
+ * every client refetch two heavy window queries on every schedule transition —
+ * an O(users × schedules) stampede that lagged the whole population. Patching the
+ * cache in place means a push costs each client one array map, no network. It
+ * also fixes the refresh-jump: the live state and a post-refresh REST fetch now
+ * derive isOpenNow/phase from the same server fields, so they agree.
+ *
+ * A push for a schedule not present in any cached list (a brand-new window) can't
+ * be patched in — those fall back to a debounced invalidate so the new row still
+ * appears, without the storm.
  */
 export function useBookingWindowSocket(enabled: boolean) {
   const qc = useQueryClient();
@@ -52,19 +94,59 @@ export function useBookingWindowSocket(enabled: boolean) {
       console.debug("[booking-windows] socket disconnected:", reason),
     );
 
+    // Coalesce the "unknown schedule → refetch" fallback so a burst of pushes
+    // for new schedules triggers at most one invalidation per window.
+    let refetchTimer: ReturnType<typeof setTimeout> | null = null;
+    const scheduleRefetch = () => {
+      if (refetchTimer) return;
+      refetchTimer = setTimeout(() => {
+        refetchTimer = null;
+        void qc.invalidateQueries({
+          predicate: (q) => {
+            const [prefix, action] = q.queryKey as unknown[];
+            return prefix === WINDOW_KEY_PREFIX[0] && WINDOW_ACTIONS.has(String(action));
+          },
+        });
+      }, 800);
+    };
+
     socket.on(
       BOOKING_WINDOW_WS_EVENTS.PHASE,
-      (_event: BookingWindowPhaseEvent) => {
-        qc.invalidateQueries({
-          queryKey: ["train-scheduling", "myBookingWindows"],
-        });
-        qc.invalidateQueries({
-          queryKey: ["train-scheduling", "contractBookingWindows"],
-        });
+      (event: BookingWindowPhaseEvent) => {
+        let patchedSomewhere = false;
+
+        qc.setQueriesData<MyBookingWindow[]>(
+          {
+            predicate: (q) => {
+              const [prefix, action] = q.queryKey as unknown[];
+              return (
+                prefix === WINDOW_KEY_PREFIX[0] &&
+                WINDOW_ACTIONS.has(String(action))
+              );
+            },
+          },
+          (rows) => {
+            if (!rows) return rows;
+            let changed = false;
+            const next = rows.map((row) => {
+              if (row.scheduleId !== event.scheduleId) return row;
+              changed = true;
+              patchedSomewhere = true;
+              return applyEvent(row, event);
+            });
+            return changed ? next : rows;
+          },
+        );
+
+        // The schedule wasn't in any cached list — a newly announced window (or a
+        // lane the client hasn't fetched). Fall back to a debounced refetch so it
+        // surfaces, without the per-push stampede that patching avoids.
+        if (!patchedSomewhere) scheduleRefetch();
       },
     );
 
     return () => {
+      if (refetchTimer) clearTimeout(refetchTimer);
       socket.off();
       socket.disconnect();
     };
diff --git a/apps/edr-freight-web/portal/src/pages/MyPortalPage/components/ActivityRow.tsx b/apps/edr-freight-web/portal/src/pages/MyPortalPage/components/ActivityRow.tsx
index a65aa009e..ea06ae3e5 100644
--- a/apps/edr-freight-web/portal/src/pages/MyPortalPage/components/ActivityRow.tsx
+++ b/apps/edr-freight-web/portal/src/pages/MyPortalPage/components/ActivityRow.tsx
@@ -17,13 +17,15 @@ export const ActivityRow = memo(function ActivityRow({
   const verb =
     booking.status === "IN_TRANSIT"
       ? "departed"
-      : booking.status === "COMPLETED"
-        ? "delivered"
-        : booking.status === "PENDING_APPROVAL"
-          ? "quote ready"
-          : booking.status === "SUBMITTED"
-            ? "submitted for review"
-            : "created";
+      : booking.status === "ARRIVED"
+        ? "arrived"
+        : booking.status === "COMPLETED"
+          ? "delivered"
+          : booking.status === "PENDING_APPROVAL"
+            ? "quote ready"
+            : booking.status === "SUBMITTED"
+              ? "submitted for review"
+              : "created";
 
   return (
     <Group
diff --git a/apps/edr-freight-web/portal/src/pages/MyPortalPage/components/UpcomingWindowsSection.tsx b/apps/edr-freight-web/portal/src/pages/MyPortalPage/components/UpcomingWindowsSection.tsx
index 6dcece7ef..391e7665b 100644
--- a/apps/edr-freight-web/portal/src/pages/MyPortalPage/components/UpcomingWindowsSection.tsx
+++ b/apps/edr-freight-web/portal/src/pages/MyPortalPage/components/UpcomingWindowsSection.tsx
@@ -188,16 +188,15 @@ export const UpcomingWindowsSection = memo(function UpcomingWindowsSection({
 }: UpcomingWindowsSectionProps) {
   const [page, setPage] = useState(0);
 
-  // Open lanes first, then by opening time — the ones the customer can act on
-  // lead the carousel.
+  // Order by the train's dispatch (departure) date, nearest first. Open-now
+  // breaks ties on the same departure so an actionable lane leads.
   const sorted = useMemo(
     () =>
       [...windows].sort((a, b) => {
-        const openDiff = Number(b.isOpenNow) - Number(a.isOpenNow);
-        if (openDiff !== 0) return openDiff;
-        const at = a.windowOpensAt ? new Date(a.windowOpensAt).getTime() : Infinity;
-        const bt = b.windowOpensAt ? new Date(b.windowOpensAt).getTime() : Infinity;
-        return at - bt;
+        const da = a.departureDate ? new Date(a.departureDate).getTime() : Infinity;
+        const db = b.departureDate ? new Date(b.departureDate).getTime() : Infinity;
+        if (da !== db) return da - db;
+        return Number(b.isOpenNow) - Number(a.isOpenNow);
       }),
     [windows],
   );
diff --git a/apps/edr-freight-web/portal/src/pages/MyPortalPage/constants.ts b/apps/edr-freight-web/portal/src/pages/MyPortalPage/constants.ts
index 44ec5809e..239c42bac 100644
--- a/apps/edr-freight-web/portal/src/pages/MyPortalPage/constants.ts
+++ b/apps/edr-freight-web/portal/src/pages/MyPortalPage/constants.ts
@@ -26,6 +26,7 @@ export const ACTIVE_STATUSES = [
   "SUBMITTED",
   "PENDING_APPROVAL",
   "IN_TRANSIT",
+  "ARRIVED",
 ];
 
 export interface StageConfig {
@@ -346,6 +347,19 @@ export const STATUS_CONFIG: Record<string, StageConfig> = {
     badgeDot: "edr-green.5",
     action: { label: "Track", kind: "outline", icon: MapPin },
   },
+  ARRIVED: {
+    stage: 3,
+    icon: MapPin,
+    iconColor: "edr-green.7",
+    tile: "edr-soft",
+    hint: "Arrived at destination yard · awaiting release",
+    step: "edr-green.5",
+    badgeLabel: "Arrived",
+    badgeBg: "edr-soft",
+    badgeText: "edr-green.7",
+    badgeDot: "edr-green.5",
+    action: { label: "Track", kind: "outline", icon: MapPin },
+  },
   COMPLETED: {
     stage: 4,
     icon: CheckCircle2,
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 6d274f22f..40994d589 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
@@ -118,7 +118,9 @@ export function ReadonlyBookingView({
   const canAssignCustomerTruck =
     booking.paymentStatus === "PAID" &&
     usesCustomerTruck &&
-    ["PAID", "IN_TRANSIT", "COMPLETED", "TRUCK_ASSIGNED"].includes(status);
+    ["PAID", "IN_TRANSIT", "ARRIVED", "COMPLETED", "TRUCK_ASSIGNED"].includes(
+      status,
+    );
   const showCountdown = canPay && !!booking.paymentDeadline;
   const isExpired = status === "EXPIRED";
   const isPendingConsolidation = status === "PENDING_CONSOLIDATION";
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/StatusHero.tsx b/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/components/StatusHero.tsx
index 127901186..13404f8f6 100644
--- a/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/components/StatusHero.tsx
+++ b/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/components/StatusHero.tsx
@@ -66,10 +66,12 @@ export function StatusHero({
 }) {
   const status = booking.status;
   const stage = resolveStage(booking);
-  // The Arrival stage has no booking status of its own — it lights up from the
-  // train's ARRIVED state, so the headline is overridden here.
+  // Legacy bookings never reach the ARRIVED status — they light up the Arrival
+  // stage from the train's ARRIVED state while staying IN_TRANSIT, so the
+  // headline is overridden here. Bookings with a per-booking journey carry the
+  // ARRIVED status themselves and use its own STATUS_MAP copy.
   const cfg =
-    stage === ARRIVAL_STAGE
+    stage === ARRIVAL_STAGE && STATUS_MAP[status]?.stage !== ARRIVAL_STAGE
       ? {
           title: "Train arrived at destination",
           description:
diff --git a/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/constants.ts b/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/constants.ts
index 2a41a6fa3..4b32a059c 100644
--- a/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/constants.ts
+++ b/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/constants.ts
@@ -54,12 +54,13 @@ export const PROGRESS_STAGES = [
     statuses: ["EXPIRED", "IN_TRANSIT"],
   },
   {
-    // No booking status maps here: the booking stays IN_TRANSIT until
-    // delivery, so this stage lights up from the assigned train's own status
+    // ARRIVED: cargo unloaded at the booking's own destination yard (segment
+    // corridor journeys). Legacy bookings stay IN_TRANSIT until delivery, so
+    // this stage also lights up from the assigned train's own status
     // (trainScheduleStatus === "ARRIVED") — see resolveStage.
     label: "Arrival",
     icon: MapPin,
-    statuses: [],
+    statuses: ["ARRIVED"],
   },
   {
     label: "Complete",
@@ -75,8 +76,10 @@ export const ARRIVAL_STAGE = PROGRESS_STAGES.findIndex(
 
 /**
  * Stage for a booking, factoring in the assigned train's operational status:
- * a booking is stuck at IN_TRANSIT between dispatch and delivery, so once its
- * train has ARRIVED the tracker advances to the Arrival stage.
+ * a booking with per-booking journey data reaches ARRIVED when it is unloaded
+ * at its own destination yard; a legacy booking is stuck at IN_TRANSIT between
+ * dispatch and delivery, so once its train has ARRIVED the tracker advances to
+ * the Arrival stage.
  */
 export function resolveStage(booking: {
   status: string;
@@ -177,6 +180,12 @@ export const STATUS_MAP: Record<
     description: "Your shipment is currently moving through the rail network.",
     stage: 6,
   },
+  ARRIVED: {
+    title: "Arrived at destination",
+    description:
+      "Your cargo has been unloaded at its destination yard and is being prepared for release.",
+    stage: 7,
+  },
   OPERATION_REQUEST_PENDING: {
     title: "Operation request under review",
     description:
diff --git a/apps/edr-freight-web/portal/src/pages/bookings/BookingsListPage.tsx b/apps/edr-freight-web/portal/src/pages/bookings/BookingsListPage.tsx
index 4a7643377..bd68632f7 100644
--- a/apps/edr-freight-web/portal/src/pages/bookings/BookingsListPage.tsx
+++ b/apps/edr-freight-web/portal/src/pages/bookings/BookingsListPage.tsx
@@ -58,6 +58,7 @@ import {
 const TRACKABLE_STATUSES = new Set([
   "PAID",
   "IN_TRANSIT",
+  "ARRIVED",
   "COMPLETED",
   "DELIVERED",
 ]);
@@ -83,7 +84,7 @@ const STATUS_FILTERS = [
     statuses:
       "SELECTED_FOR_BATCH,PNR_GENERATED,PAYMENT_VERIFICATION_IN_PROGRESS,EXPIRED",
   },
-  { key: "transit", label: "In transit", statuses: "PAID,IN_TRANSIT" },
+  { key: "transit", label: "In transit", statuses: "PAID,IN_TRANSIT,ARRIVED" },
   { key: "done", label: "Completed", statuses: "COMPLETED,DELIVERED" },
   {
     key: "closed",
diff --git a/apps/edr-freight-web/portal/src/pages/bookings/tracking/ShipmentTrackingModal.tsx b/apps/edr-freight-web/portal/src/pages/bookings/tracking/ShipmentTrackingModal.tsx
index 64ee63d5e..4282c7e81 100644
--- a/apps/edr-freight-web/portal/src/pages/bookings/tracking/ShipmentTrackingModal.tsx
+++ b/apps/edr-freight-web/portal/src/pages/bookings/tracking/ShipmentTrackingModal.tsx
@@ -6,6 +6,7 @@ import {
   Clock,
   Flag,
   MapPin,
+  PackageCheck,
   PackageX,
   RefreshCw,
   Train,
@@ -15,11 +16,14 @@ import { api } from "@/services/api";
 import { Freight } from "@edr/types";
 
 import {
+  bookingJourneyState,
+  bookingLegRange,
+  bookingShipmentStatusLabel,
   checkpointKindLabel,
   corridorProgress,
   isArrived,
   isDispatched,
-  shipmentStatusLabel,
+  type BookingJourneyState,
 } from "./trackingStages";
 
 const GREEN = "#0EA371";
@@ -70,6 +74,7 @@ export function ShipmentTrackingModal({
         trainNumber={data?.trainNumber ?? null}
         status={data?.scheduleStatus ?? null}
         currentSequenceNo={data?.currentSequenceNo ?? -1}
+        journey={data ? bookingJourneyState(data) : null}
         onClose={onClose}
         onRefresh={() => refetch()}
         refreshing={isFetching}
@@ -95,6 +100,7 @@ export function ShipmentTrackingModal({
         ) : data ? (
           <Stack gap={26}>
             <SummaryBar data={data} />
+            <BookingJourneyLine data={data} />
             <Corridor data={data} />
             <CheckpointFeed data={data} />
           </Stack>
@@ -111,6 +117,7 @@ function Header({
   trainNumber,
   status,
   currentSequenceNo,
+  journey,
   onClose,
   onRefresh,
   refreshing,
@@ -119,6 +126,7 @@ function Header({
   trainNumber: string | null;
   status: Freight.TrainScheduleStatus | null;
   currentSequenceNo: number;
+  journey: BookingJourneyState;
   onClose: () => void;
   onRefresh: () => void;
   refreshing: boolean;
@@ -171,7 +179,11 @@ function Header({
         </Group>
 
         <Group gap={10} align="center" wrap="nowrap">
-          <HeaderStatusPill status={status} currentSequenceNo={currentSequenceNo} />
+          <HeaderStatusPill
+            status={status}
+            currentSequenceNo={currentSequenceNo}
+            journey={journey}
+          />
           <IconButton title="Refresh" onClick={onRefresh} spinning={refreshing}>
             <RefreshCw size={16} />
           </IconButton>
@@ -223,12 +235,17 @@ function IconButton({
 function HeaderStatusPill({
   status,
   currentSequenceNo,
+  journey,
 }: {
   status: Freight.TrainScheduleStatus | null;
   currentSequenceNo: number;
+  journey: BookingJourneyState;
 }) {
-  const arrived = isArrived(status);
-  const moving = isDispatched(status);
+  // The booking's own journey wins: a sub-corridor booking can be unloaded
+  // (arrived) at its own yard while the train is still moving.
+  const arrived = journey === "arrived" || (!journey && isArrived(status));
+  const moving = !arrived && (journey === "in-transit" || isDispatched(status));
+  const label = bookingShipmentStatusLabel(journey, status, currentSequenceNo);
   const bg = arrived
     ? "rgba(14,163,113,0.22)"
     : moving
@@ -254,7 +271,7 @@ function HeaderStatusPill({
         }}
       />
       <Text fz="12px" fw={700} c="#fff">
-        {shipmentStatusLabel(status, currentSequenceNo)}
+        {label}
       </Text>
     </Group>
   );
@@ -263,7 +280,10 @@ function HeaderStatusPill({
 // ── Summary bar (ETA / departure / arrival) ────────────────────────────────────
 
 function SummaryBar({ data }: { data: Freight.IBookingTracking }) {
-  const arrived = isArrived(data.scheduleStatus);
+  const journey = bookingJourneyState(data);
+  // Booking-level arrival (unloaded at its own destination yard) counts as
+  // arrived even while the train itself is still moving down the corridor.
+  const arrived = journey === "arrived" || isArrived(data.scheduleStatus);
   const items: Array<{ label: string; value: string; accent?: boolean }> = [
     {
       label: "Departed",
@@ -271,7 +291,11 @@ function SummaryBar({ data }: { data: Freight.IBookingTracking }) {
     },
     {
       label: arrived ? "Arrived" : "Est. arrival",
-      value: fmtTime(data.actualArrivalAt ?? data.scheduledArrivalAt),
+      value: fmtTime(
+        (journey === "arrived" ? data.arrivedAt : null) ??
+          data.actualArrivalAt ??
+          data.scheduledArrivalAt,
+      ),
       accent: !arrived,
     },
     {
@@ -317,6 +341,66 @@ function SummaryBar({ data }: { data: Freight.IBookingTracking }) {
   );
 }
 
+// ── Per-booking journey line (loaded / unloaded at the booking's own yards) ────
+
+function BookingJourneyLine({ data }: { data: Freight.IBookingTracking }) {
+  if (!data.loadedAt && !data.arrivedAt) return null;
+
+  const stationLabel = (yardId?: string | null) =>
+    data.stations.find((s) => s.yardId === yardId)?.label ?? null;
+  const origin = stationLabel(data.bookingOriginYardId) ?? "origin yard";
+  const destination =
+    stationLabel(data.bookingDestinationYardId) ?? "destination yard";
+
+  return (
+    <Group gap={10} wrap="wrap">
+      {data.loadedAt && (
+        <JourneyChip
+          icon={<PackageCheck size={14} />}
+          text={`Loaded at ${origin}`}
+          time={fmtTime(data.loadedAt)}
+        />
+      )}
+      {data.arrivedAt && (
+        <JourneyChip
+          icon={<CheckCircle2 size={14} />}
+          text={`Arrived at ${destination}`}
+          time={fmtTime(data.arrivedAt)}
+        />
+      )}
+    </Group>
+  );
+}
+
+function JourneyChip({
+  icon,
+  text,
+  time,
+}: {
+  icon: React.ReactNode;
+  text: string;
+  time: string;
+}) {
+  return (
+    <Group
+      gap={7}
+      align="center"
+      wrap="nowrap"
+      px={12}
+      py={7}
+      style={{ borderRadius: 999, background: "#ECF6F1", color: GREEN_DARK }}
+    >
+      {icon}
+      <Text fz="12px" fw={700} c={GREEN_DARK}>
+        {text}
+      </Text>
+      <Text fz="12px" c={MUTED}>
+        · {time}
+      </Text>
+    </Group>
+  );
+}
+
 // ── Corridor: stations + train marker ──────────────────────────────────────────
 
 function Corridor({ data }: { data: Freight.IBookingTracking }) {
@@ -326,6 +410,14 @@ function Corridor({ data }: { data: Freight.IBookingTracking }) {
   const current = data.currentSequenceNo;
   const progress = corridorProgress(stations.length, current, arrived);
 
+  // The booking's own leg on the corridor (sub-corridor bookings ride only a
+  // slice of the train's route). Stations outside the leg render dimmed.
+  const leg = bookingLegRange(
+    stations,
+    data.bookingOriginYardId,
+    data.bookingDestinationYardId,
+  );
+
   // Map sequenceNo → latest checkpoint at that station for captions.
   const checkpointBySeq = new Map<number, Freight.ITrackingCheckpoint>();
   for (const c of data.checkpoints) checkpointBySeq.set(c.sequenceNo, c);
@@ -415,6 +507,7 @@ function Corridor({ data }: { data: Freight.IBookingTracking }) {
             const reached = arrived || (current >= 0 && i <= current);
             const isCurrent = !arrived && i === current;
             const isLast = i === stations.length - 1;
+            const onLeg = !leg || (i >= leg.start && i <= leg.end);
             const cp = checkpointBySeq.get(s.sequenceNo);
             return (
               <StationNode
@@ -424,6 +517,7 @@ function Corridor({ data }: { data: Freight.IBookingTracking }) {
                 isCurrent={isCurrent}
                 isEndpoint={i === 0 || isLast}
                 arrivedHere={isLast && arrived}
+                dimmed={!onLeg}
                 time={cp ? fmtTime(cp.occurredAt) : null}
                 align={i === 0 ? "left" : isLast ? "right" : "center"}
               />
@@ -441,6 +535,7 @@ function StationNode({
   isCurrent,
   isEndpoint,
   arrivedHere,
+  dimmed,
   time,
   align,
 }: {
@@ -449,6 +544,8 @@ function StationNode({
   isCurrent: boolean;
   isEndpoint: boolean;
   arrivedHere: boolean;
+  /** Station lies outside the booking's own leg — render muted. */
+  dimmed: boolean;
   time: string | null;
   align: "left" | "center" | "right";
 }) {
@@ -462,6 +559,7 @@ function StationNode({
         flex: isEndpoint ? "0 0 auto" : 1,
         minWidth: 0,
         maxWidth: 120,
+        opacity: dimmed ? 0.4 : 1,
       }}
     >
       <Box
@@ -488,8 +586,8 @@ function StationNode({
       </Box>
       <Text
         fz="11.5px"
-        fw={reached ? 700 : 600}
-        c={reached ? INK : "#9AA8B5"}
+        fw={!dimmed && reached ? 700 : 600}
+        c={dimmed ? "#9AA8B5" : reached ? INK : "#9AA8B5"}
         mt={8}
         ta={align}
         truncate
diff --git a/apps/edr-freight-web/portal/src/pages/bookings/tracking/trackingStages.ts b/apps/edr-freight-web/portal/src/pages/bookings/tracking/trackingStages.ts
index 4acbcec8a..5fd0e9827 100644
--- a/apps/edr-freight-web/portal/src/pages/bookings/tracking/trackingStages.ts
+++ b/apps/edr-freight-web/portal/src/pages/bookings/tracking/trackingStages.ts
@@ -1,6 +1,6 @@
 import { Freight } from "@edr/types";
 
-const { TrainScheduleStatus } = Freight;
+const { BookingStatus, TrainScheduleStatus } = Freight;
 
 export function isArrived(
   status?: Freight.TrainScheduleStatus | null,
@@ -50,6 +50,65 @@ export function corridorProgress(
   return Math.round((Math.min(currentSequenceNo, lastSeq) / lastSeq) * 100);
 }
 
+// ── Per-booking journey (segment corridor bookings) ───────────────────────────
+
+/**
+ * The booking's own journey state, independent of the train: a sub-corridor
+ * booking is loaded at its own origin yard and unloaded (ARRIVED) at its own
+ * destination yard while the train may keep going. `null` means the booking
+ * has no per-booking journey data yet (legacy bookings) — callers fall back
+ * to the train-schedule status.
+ */
+export type BookingJourneyState = "arrived" | "in-transit" | null;
+
+export function bookingJourneyState(
+  t: Freight.IBookingTracking,
+): BookingJourneyState {
+  const status = t.bookingStatus ?? null;
+  if (
+    t.arrivedAt ||
+    status === BookingStatus.Arrived ||
+    status === BookingStatus.Completed ||
+    status === BookingStatus.Delivered
+  ) {
+    return "arrived";
+  }
+  if (t.loadedAt) return "in-transit";
+  return null;
+}
+
+/**
+ * Header pill label. Prefers the booking's own journey (loaded/unloaded at its
+ * own yards) and falls back to the train-schedule wording for legacy bookings
+ * without per-booking journey data.
+ */
+export function bookingShipmentStatusLabel(
+  journey: BookingJourneyState,
+  scheduleStatus: Freight.TrainScheduleStatus | null,
+  currentSequenceNo: number,
+): string {
+  if (journey === "arrived") return "Arrived";
+  if (journey === "in-transit") return "In transit";
+  return shipmentStatusLabel(scheduleStatus, currentSequenceNo);
+}
+
+/**
+ * Index range [start..end] of the booking's own leg on the corridor, matched
+ * by yardId. Null when the booking rides the full corridor (no leg data) or
+ * either endpoint isn't a station on this train's route.
+ */
+export function bookingLegRange(
+  stations: Freight.ITrackingStation[],
+  originYardId?: string | null,
+  destinationYardId?: string | null,
+): { start: number; end: number } | null {
+  if (!originYardId || !destinationYardId) return null;
+  const start = stations.findIndex((s) => s.yardId === originYardId);
+  const end = stations.findIndex((s) => s.yardId === destinationYardId);
+  if (start < 0 || end < 0) return null;
+  return start <= end ? { start, end } : { start: end, end: start };
+}
+
 /** Caption for a checkpoint kind. */
 export function checkpointKindLabel(kind: Freight.TrainCheckpointKind): string {
   switch (kind) {
diff --git a/apps/edr-freight-web/portal/src/pages/contracts/ContractBookingWindowsSection.tsx b/apps/edr-freight-web/portal/src/pages/contracts/ContractBookingWindowsSection.tsx
new file mode 100644
index 000000000..51125194c
--- /dev/null
+++ b/apps/edr-freight-web/portal/src/pages/contracts/ContractBookingWindowsSection.tsx
@@ -0,0 +1,412 @@
+import { useMemo, useState } from "react";
+import {
+  ActionIcon,
+  Badge,
+  Box,
+  Group,
+  Paper,
+  SimpleGrid,
+  Skeleton,
+  Stack,
+  Text,
+} from "@mantine/core";
+import {
+  ArrowRight,
+  CalendarClock,
+  CheckCircle2,
+  ChevronLeft,
+  ChevronRight,
+  Clock,
+} from "lucide-react";
+import { CountdownTimer } from "@edr/ui-common";
+
+import type { MyBookingWindow } from "@/services/bookings.service";
+import { formatWindowOpensAt, soonestUpcomingWindow } from "./booking-window";
+
+const INK = "#10202F";
+const MUTED = "#6B7C8E";
+const BORDER = "#E6ECF2";
+
+/** All window times are communicated in East Africa Time. */
+const TZ = "Africa/Addis_Ababa";
+/** Cards visible per carousel page. */
+const PER_PAGE = 3;
+
+function fmtDay(iso: string): string {
+  return new Date(iso).toLocaleDateString("en-GB", {
+    weekday: "short",
+    day: "numeric",
+    month: "short",
+    timeZone: TZ,
+  });
+}
+
+function fmtTime(iso: string): string {
+  return new Date(iso).toLocaleTimeString("en-GB", {
+    hour: "2-digit",
+    minute: "2-digit",
+    hour12: false,
+    timeZone: TZ,
+  });
+}
+
+/** "Thu, 10 Jul · 08:00 – 11:00 EAT" (or a phase label when times are unset). */
+function windowLabel(w: MyBookingWindow): string {
+  if (w.windowOpensAt && w.windowClosesAt) {
+    return `${fmtDay(w.windowOpensAt)} · ${fmtTime(w.windowOpensAt)} – ${fmtTime(
+      w.windowClosesAt,
+    )} EAT`;
+  }
+  if (w.windowOpensAt) {
+    return `Opens ${fmtDay(w.windowOpensAt)} · ${fmtTime(w.windowOpensAt)} EAT`;
+  }
+  return (w.windowPhase ?? w.bookingWindowStatus).replace(/_/g, " ");
+}
+
+/**
+ * The countdown for whichever phase the window is currently in, mirroring the
+ * home dashboard's Booking Windows card. `expiredText` names the NEXT step so a
+ * deadline that lapses between refetches announces what comes next rather than
+ * the bare "Expired".
+ */
+function phaseCountdown(
+  w: MyBookingWindow,
+): { label: string; deadline: string; expiredText: string } | null {
+  switch (w.windowPhase) {
+    case "PRE_WINDOW":
+      return w.windowOpensAt
+        ? {
+            label: "Booking opens in",
+            deadline: w.windowOpensAt,
+            expiredText: "Booking opening now…",
+          }
+        : null;
+    case "OPEN":
+      return w.windowClosesAt
+        ? {
+            label: "Window closes in",
+            deadline: w.windowClosesAt,
+            expiredText: "Document review starting…",
+          }
+        : null;
+    case "DOC_REVIEW":
+      return w.docReviewEndsAt
+        ? {
+            label: "Document review ends in",
+            deadline: w.docReviewEndsAt,
+            expiredText: "Payment starting…",
+          }
+        : null;
+    case "PAYMENT":
+      return w.paymentPhaseEndsAt
+        ? {
+            label: "Payment due in",
+            deadline: w.paymentPhaseEndsAt,
+            expiredText: "Payment window closing…",
+          }
+        : null;
+    default:
+      return null;
+  }
+}
+
+/**
+ * Drop windows the SERVER considers finished. Keyed off the server's windowPhase
+ * — never the client clock. The server query already excludes terminal
+ * (DONE / CLOSED_FOR_DAY) and departed rows; comparing `Date.now()` against the
+ * row's timestamps here only re-introduced clock skew, which made a card vanish
+ * on one machine and reappear after refresh. So we trust the phase the server
+ * sends (live-patched over the socket) and let it drive visibility.
+ */
+function isPast(w: MyBookingWindow): boolean {
+  return w.windowPhase === "DONE" || w.windowPhase === "CLOSED_FOR_DAY";
+}
+
+function WindowCard({ w }: { w: MyBookingWindow }) {
+  const cd = phaseCountdown(w);
+  const open = w.isOpenNow;
+  const isImport = w.direction === "IMPORT";
+
+  return (
+    <Box
+      p="md"
+      style={{
+        borderRadius: 14,
+        height: "100%",
+        border: `1px solid ${open ? "#CDEBDD" : BORDER}`,
+        background: open
+          ? "linear-gradient(160deg, #F4FBF7 0%, #FFFFFF 85%)"
+          : "#FFFFFF",
+        boxShadow: open ? "0 2px 10px rgba(10,111,77,0.10)" : "none",
+      }}
+    >
+      <Stack gap={8} h="100%" justify="space-between">
+        <Box>
+          <Group justify="space-between" wrap="nowrap" gap={8}>
+            {w.direction ? (
+              <Badge
+                variant="light"
+                color={isImport ? "blue" : "teal"}
+                radius="sm"
+                size="sm"
+              >
+                {isImport ? "Import" : "Export"}
+              </Badge>
+            ) : (
+              <span />
+            )}
+            <Badge
+              variant={open ? "filled" : "light"}
+              color={open ? "edr-green" : "gray"}
+              radius="sm"
+              size="sm"
+            >
+              {open
+                ? "Open now"
+                : (w.windowPhase ?? w.bookingWindowStatus).replace(/_/g, " ")}
+            </Badge>
+          </Group>
+
+          <Group gap={6} wrap="nowrap" mt={10}>
+            <Text fz={15} fw={700} style={{ color: INK }} truncate>
+              {w.origin ?? "—"}
+            </Text>
+            <ArrowRight size={14} color={MUTED} style={{ flexShrink: 0 }} />
+            <Text fz={15} fw={700} style={{ color: INK }} truncate>
+              {w.destination ?? "—"}
+            </Text>
+          </Group>
+
+          <Group gap={6} wrap="nowrap" mt={8}>
+            <CalendarClock size={13} color={MUTED} style={{ flexShrink: 0 }} />
+            <Text fz={12} style={{ color: MUTED }} truncate>
+              {windowLabel(w)}
+            </Text>
+          </Group>
+          {w.departureDate ? (
+            <Text fz={12} style={{ color: MUTED }}>
+              Departs {fmtDay(w.departureDate)}
+            </Text>
+          ) : null}
+        </Box>
+
+        {cd ? (
+          <Box
+            px={10}
+            py={6}
+            style={{
+              borderRadius: 10,
+              background: open ? "rgba(10,111,77,0.08)" : "#F8FAFC",
+            }}
+          >
+            <CountdownTimer
+              deadline={cd.deadline}
+              label={cd.label}
+              expiredText={cd.expiredText}
+              size="xs"
+            />
+          </Box>
+        ) : null}
+      </Stack>
+    </Box>
+  );
+}
+
+/**
+ * One-line status strip above the cards: green when a window is open right now
+ * (the customer can act), neutral with the next opening time otherwise.
+ */
+function WindowStatusBanner({ windows }: { windows: MyBookingWindow[] }) {
+  const open = windows.find((w) => w.isOpenNow);
+  if (open) {
+    const lane =
+      open.origin && open.destination
+        ? ` on ${open.origin} → ${open.destination}`
+        : "";
+    return (
+      <Group
+        gap={10}
+        wrap="nowrap"
+        px={14}
+        py={10}
+        mb="md"
+        style={{
+          borderRadius: 12,
+          border: "1px solid #CDEBDD",
+          background: "#F4FBF7",
+        }}
+      >
+        <CheckCircle2 size={17} color="#0A6F4D" style={{ flexShrink: 0 }} />
+        <Text fz={13.5} fw={600} c="#0A6F4D">
+          A booking window is open right now{lane} — you can create a shipment
+          booking before it closes.
+        </Text>
+      </Group>
+    );
+  }
+
+  const next = soonestUpcomingWindow(windows);
+  return (
+    <Group
+      gap={10}
+      wrap="nowrap"
+      px={14}
+      py={10}
+      mb="md"
+      style={{
+        borderRadius: 12,
+        border: `1px solid ${BORDER}`,
+        background: "#F8FAFC",
+      }}
+    >
+      <Clock size={17} color={MUTED} style={{ flexShrink: 0 }} />
+      <Text fz={13.5} fw={600} style={{ color: MUTED }}>
+        {next?.windowOpensAt
+          ? `Booking is not open yet — the next window opens ${formatWindowOpensAt(
+              next.windowOpensAt,
+            )} EAT.`
+          : "Booking is not open right now. You'll see the opening time here once a window is announced."}
+      </Text>
+    </Group>
+  );
+}
+
+interface ContractBookingWindowsSectionProps {
+  /** Windows already scoped to this contract's routes/direction by the API. */
+  windows: MyBookingWindow[];
+  isLoading: boolean;
+}
+
+/**
+ * Booking windows on THIS contract's routes only (the API filters by the
+ * contract's route lanes, which also pins the import/export direction) — the
+ * contract-scoped counterpart of the home dashboard's all-lanes Booking Windows
+ * card. Paged three cards at a time; hidden when nothing is announced.
+ */
+export function ContractBookingWindowsSection({
+  windows,
+  isLoading,
+}: ContractBookingWindowsSectionProps) {
+  const [page, setPage] = useState(0);
+
+  const sorted = useMemo(() => {
+    const rows = windows.filter(
+      (w) => w.windowPhase != null && w.windowPhase !== "DONE" && !isPast(w),
+    );
+    // Order by the train's dispatch (departure) date, nearest first — the
+    // shipment leaving soonest leads. Open-now breaks ties on the same departure.
+    return rows.sort((a, b) => {
+      const da = a.departureDate ? new Date(a.departureDate).getTime() : Infinity;
+      const db = b.departureDate ? new Date(b.departureDate).getTime() : Infinity;
+      if (da !== db) return da - db;
+      return Number(b.isOpenNow) - Number(a.isOpenNow);
+    });
+  }, [windows]);
+
+  const pageCount = Math.max(1, Math.ceil(sorted.length / PER_PAGE));
+  const safePage = Math.min(page, pageCount - 1);
+  const visible = sorted.slice(
+    safePage * PER_PAGE,
+    safePage * PER_PAGE + PER_PAGE,
+  );
+
+  return (
+    <Paper withBorder radius="lg" p="lg" style={{ borderColor: BORDER }}>
+      <Group justify="space-between" align="flex-start" mb="md" wrap="nowrap">
+        <Group gap={8} wrap="nowrap">
+          <CalendarClock size={18} color={MUTED} />
+          <Box>
+            <Text fw={700} fz={16} style={{ color: INK }}>
+              Booking windows
+            </Text>
+            <Text fz={13} style={{ color: MUTED }}>
+              Windows on this contract&apos;s routes (EAT)
+            </Text>
+          </Box>
+        </Group>
+
+        {pageCount > 1 ? (
+          <Group gap={8} wrap="nowrap">
+            <ActionIcon
+              variant="default"
+              radius="xl"
+              size="lg"
+              aria-label="Previous windows"
+              disabled={safePage <= 0}
+              onClick={() => setPage((p) => Math.max(0, p - 1))}
+            >
+              <ChevronLeft size={18} />
+            </ActionIcon>
+            <Group gap={5} wrap="nowrap">
+              {Array.from({ length: pageCount }, (_, i) => (
+                <Box
+                  key={i}
+                  onClick={() => setPage(i)}
+                  style={{
+                    width: i === safePage ? 18 : 7,
+                    height: 7,
+                    borderRadius: 999,
+                    cursor: "pointer",
+                    background: i === safePage ? "#0A6F4D" : "#D8E2EB",
+                    transition: "width 200ms ease, background 200ms ease",
+                  }}
+                />
+              ))}
+            </Group>
+            <ActionIcon
+              variant="default"
+              radius="xl"
+              size="lg"
+              aria-label="Next windows"
+              disabled={safePage >= pageCount - 1}
+              onClick={() => setPage((p) => Math.min(pageCount - 1, p + 1))}
+            >
+              <ChevronRight size={18} />
+            </ActionIcon>
+          </Group>
+        ) : null}
+      </Group>
+
+      {isLoading ? (
+        <SimpleGrid cols={{ base: 1, sm: 2, lg: 3 }} spacing="md">
+          {[1, 2, 3].map((i) => (
+            <Skeleton key={i} height={150} radius="md" />
+          ))}
+        </SimpleGrid>
+      ) : sorted.length === 0 ? (
+        <Stack
+          align="center"
+          gap={6}
+          py={28}
+          style={{
+            borderRadius: 12,
+            border: `1px dashed ${BORDER}`,
+            background: "#FBFCFE",
+          }}
+        >
+          <CalendarClock size={22} color={MUTED} />
+          <Text fz={14} fw={600} style={{ color: INK }}>
+            No booking windows announced yet
+          </Text>
+          <Text fz={12.5} ta="center" maw={420} style={{ color: MUTED }}>
+            When a train is scheduled on this contract&apos;s routes, its
+            booking window will appear here with the opening time.
+          </Text>
+        </Stack>
+      ) : (
+        <>
+          <WindowStatusBanner windows={sorted} />
+          <SimpleGrid
+            key={safePage}
+            cols={{ base: 1, sm: 2, lg: 3 }}
+            spacing="md"
+          >
+            {visible.map((w) => (
+              <WindowCard key={`${w.scheduleId}-${w.bookingCycleNo}`} w={w} />
+            ))}
+          </SimpleGrid>
+        </>
+      )}
+    </Paper>
+  );
+}
diff --git a/apps/edr-freight-web/portal/src/pages/contracts/ContractDetailPage.tsx b/apps/edr-freight-web/portal/src/pages/contracts/ContractDetailPage.tsx
index 16225cd02..8f045861c 100644
--- a/apps/edr-freight-web/portal/src/pages/contracts/ContractDetailPage.tsx
+++ b/apps/edr-freight-web/portal/src/pages/contracts/ContractDetailPage.tsx
@@ -64,6 +64,7 @@ import { ClearanceUploadedDocumentsPanel } from "@/components/contracts/Clearanc
 import { formatRateUnit } from "./new-contract-form/unit-rates";
 import { getContractBookingAction } from "./contract-booking-action";
 import { closedWindowMessage, hasOpenWindow } from "./booking-window";
+import { ContractBookingWindowsSection } from "./ContractBookingWindowsSection";
 import {
   BORDER,
   ContractStatusBadge,
@@ -73,10 +74,6 @@ import {
   MUTED,
 } from "./contract-ui";
 
-// Statuses where a customer may create a shipment booking themselves. Reached
-// only after self-clearance is approved by Operations (Path A) or, for DOMESTIC,
-// directly at counter-sign.
-const PATH_A_BOOKABLE = ["FULLY_EXECUTED", "CONTRACT_ACTIVE"];
 // Statuses where the customer uploads clearance documents on the contract. Used
 // by both paths: Path B (customs, GL-reviewed) and Path A self-clearance
 // (non-customs IMPORT/EXPORT, Operations-reviewed).
@@ -204,7 +201,7 @@ export default function ContractDetailPage() {
   // Booking windows for this contract's routes — gates the direct "New shipment
   // booking" entry so the customer only sees it while a window is open.
   // Refetched every minute so "Open now" flips without a manual reload.
-  const { data: bookingWindows = [] } = useQuery({
+  const { data: bookingWindows = [], isLoading: windowsLoading } = useQuery({
     ...api.bookings.getContractBookingWindows.queryOptions({
       input: { contractId: id! },
       refetchInterval: 60_000,
@@ -263,10 +260,14 @@ export default function ContractDetailPage() {
     );
   }
 
-  // Staff returned the contract for changes — send the customer to the full edit
-  // wizard (edit any term + replace documents → resubmit) rather than the
-  // read-only detail.
-  if (contract.status === "CHANGES_REQUESTED") {
+  // Not yet submitted (customer saved a draft) or staff returned the contract for
+  // changes — send the customer to the full edit wizard (edit any term + replace
+  // documents → submit) rather than the read-only detail.
+  if (
+    contract.status === "DRAFT" ||
+    contract.status === "RENEWAL_DRAFT" ||
+    contract.status === "CHANGES_REQUESTED"
+  ) {
     return <Navigate to={`/contracts/${contract.id}/edit`} replace />;
   }
 
@@ -305,9 +306,13 @@ export default function ContractDetailPage() {
   const clearanceFinalized =
     contract.clearanceStatus === "CLEARANCE_READY_FOR_BOOKING" ||
     contract.status === "CLEARANCE_READY_FOR_BOOKING";
-  const canBookShipment =
-    !customsPath && PATH_A_BOOKABLE.includes(contract.status);
   const bookingAction = getContractBookingAction(contract, contractBookings);
+  // Whether the customer may open a new self-service booking. Derived from the
+  // shared booking-action helper so it honours the ONE_TIME single-slot rule:
+  // once a non-terminal booking exists on a ONE_TIME contract there is no free
+  // slot, so the action is "none" and no booking button is shown.
+  const canBookShipment =
+    bookingAction.kind === "book" || bookingAction.kind === "rebook";
   const canRequestShipment = bookingAction.kind === "request";
   // Customs + clearance finalized: GL is preparing the booking — surface a
   // status notice instead of any action.
@@ -511,6 +516,16 @@ export default function ContractDetailPage() {
           </SimpleGrid>
         </Paper>
 
+        {/* Booking windows on this contract's routes/direction only (the API
+            filters by the contract's lanes). Intercity contracts aren't
+            window-gated, so nothing is shown for them. */}
+        {contract.tradeDirection !== "DOMESTIC" && (
+          <ContractBookingWindowsSection
+            windows={bookingWindows}
+            isLoading={windowsLoading}
+          />
+        )}
+
         {/* Tabs: Details · Documents · Bookings (pill style, like the
             backoffice booking-requests page; each tab shows a count badge). */}
         <Tabs
diff --git a/apps/edr-freight-web/portal/src/pages/contracts/ContractsList.tsx b/apps/edr-freight-web/portal/src/pages/contracts/ContractsList.tsx
index 41e77625b..d2bd8b88f 100644
--- a/apps/edr-freight-web/portal/src/pages/contracts/ContractsList.tsx
+++ b/apps/edr-freight-web/portal/src/pages/contracts/ContractsList.tsx
@@ -2,6 +2,7 @@ import { Fragment, useMemo, useState } from "react";
 import { useNavigate } from "react-router-dom";
 import { useQuery } from "@tanstack/react-query";
 import {
+  Badge,
   Box,
   Button,
   Center,
@@ -339,6 +340,7 @@ export default function ContractsList() {
                 <Table.Tr>
                   <Table.Th style={{ width: 44 }} aria-label="Expand" />
                   <Table.Th>Contract</Table.Th>
+                  <Table.Th>Type</Table.Th>
                   <Table.Th>Cargo</Table.Th>
                   <Table.Th>Route</Table.Th>
                   <Table.Th>Trade</Table.Th>
@@ -352,7 +354,7 @@ export default function ContractsList() {
               <Table.Tbody>
                 {isLoading && (
                   <Table.Tr>
-                    <Table.Td colSpan={10}>
+                    <Table.Td colSpan={11}>
                       <Center py={48}>
                         <Loader color="edr-green" size="sm" />
                       </Center>
@@ -362,7 +364,7 @@ export default function ContractsList() {
 
                 {!isLoading && isError && (
                   <Table.Tr>
-                    <Table.Td colSpan={10}>
+                    <Table.Td colSpan={11}>
                       <Center py={48}>
                         <Text fz={13} c="red">
                           Failed to load contracts. Please try again.
@@ -374,7 +376,7 @@ export default function ContractsList() {
 
                 {!isLoading && !isError && rows.length === 0 && (
                   <Table.Tr>
-                    <Table.Td colSpan={10}>
+                    <Table.Td colSpan={11}>
                       <Stack align="center" gap={8} py={48}>
                         <Inbox size={26} color={MUTED} style={{ opacity: 0.5 }} />
                         <Text fz={13} c="dimmed">
@@ -442,10 +444,18 @@ export default function ContractsList() {
                             {c.reference}
                           </Text>
                           <Text fz={12} c="dimmed">
-                            {isGeneral ? "General" : "One-Time"} ·{" "}
                             {isContainer ? "Containerised" : "Bulk"}
                           </Text>
                         </Table.Td>
+                        <Table.Td>
+                          <Badge
+                            variant="light"
+                            color={isGeneral ? "edr-green" : "gray"}
+                            radius="sm"
+                          >
+                            {isGeneral ? "General" : "One-Time"}
+                          </Badge>
+                        </Table.Td>
                         <Table.Td>
                           <Group gap={7} wrap="nowrap" align="center">
                             {isContainer ? (
@@ -533,7 +543,7 @@ export default function ContractsList() {
                       </Table.Tr>
                       {isOpen && (
                         <Table.Tr style={{ background: "#F4FBF8" }}>
-                          <Table.Td colSpan={10} style={{ padding: "6px 20px 18px" }}>
+                          <Table.Td colSpan={11} style={{ padding: "6px 20px 18px" }}>
                             <ContractStepBanner contract={c} />
                           </Table.Td>
                         </Table.Tr>
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 6bd6994f6..c443bf3b9 100644
--- a/apps/edr-freight-web/portal/src/pages/contracts/NewContractPage.tsx
+++ b/apps/edr-freight-web/portal/src/pages/contracts/NewContractPage.tsx
@@ -81,9 +81,10 @@ type PriceModalMode = "submit" | "draft";
 
 /**
  * The contract wizard, used both to create a new contract and — in `edit` mode —
- * to edit & resubmit a contract staff returned with CHANGES_REQUESTED. Edit mode
- * hydrates the form from the saved contract, lets the customer change any term
- * and replace documents, then runs the same update → price → submit flow.
+ * to continue an unsubmitted DRAFT or edit & resubmit a contract staff returned
+ * with CHANGES_REQUESTED. Edit mode hydrates the form from the saved contract,
+ * lets the customer change any term and replace documents, then runs the same
+ * update → price → submit flow.
  */
 export default function NewContractPage({
   mode = "create",
@@ -504,25 +505,20 @@ export default function NewContractPage({
     )!;
 
     const isContainer = data.cargoType === "container";
+    const isGeneral = data.contractKind === "general_contract";
 
     // Cargo scope rows — no quantities (doc §5.4). Container: one row per enabled
-    // size; bulk: a single commodity row.
-    // GENERAL contracts carry a quantity cap (draw-down); ONE_TIME does not.
-    const isGeneral = data.contractKind === "general_contract";
+    // size; bulk: a single commodity row. Both GENERAL and ONE_TIME are uncapped
+    // (quantityCap omitted → NULL): the customer books repeatedly against a
+    // GENERAL contract until its validity expires.
     const cargoScope: Freight.CreateContractCargoScopeDto[] = isContainer
       ? data.enabledContainerSizes.map((size) => ({
           containerSize: size,
-          quantityCap:
-            isGeneral && data.containerSizeCaps[size]
-              ? data.containerSizeCaps[size]
-              : undefined,
         }))
       : [
           {
             cargoTypeId: data.cargoTypePath?.[1] || undefined,
             cargoFreeText: data.cargoFreeText || undefined,
-            quantityCap:
-              isGeneral && data.bulkQuantityCap ? data.bulkQuantityCap : undefined,
           },
         ];
 
@@ -661,7 +657,9 @@ export default function NewContractPage({
           </Title>
           <Text size="sm" c="edr-muted" mt={4}>
             {isEdit
-              ? "Update your contract details and documents, then resubmit it for EDR staff review."
+              ? editContract?.status === "CHANGES_REQUESTED"
+                ? "Update your contract details and documents, then resubmit it for EDR staff review."
+                : "Update your draft contract details and documents, then submit it for EDR staff review."
               : "Define your freight contract — scope, routes, and unit rates. Book shipments against it after signing."}
           </Text>
         </Box>
@@ -684,7 +682,7 @@ export default function NewContractPage({
         onSubmit={(e) => e.preventDefault()}
       >
         <Box flex={1} p="24px">
-          {isEdit && (
+          {isEdit && editContract?.status === "CHANGES_REQUESTED" && (
             <Alert
               color="orange"
               radius="lg"
@@ -693,8 +691,25 @@ export default function NewContractPage({
               title="A reviewer asked for changes"
               mb="lg"
             >
-              Update any contract detail or document that needs to change, then
-              resubmit the contract for review.
+              {editContract?.latestChangeRequestNote ? (
+                <Stack gap={6}>
+                  <Text size="sm" fw={600}>
+                    What the reviewer asked for:
+                  </Text>
+                  <Text
+                    size="sm"
+                    style={{ whiteSpace: "pre-wrap" }}
+                  >
+                    {editContract.latestChangeRequestNote}
+                  </Text>
+                  <Text size="sm" c="dimmed" mt={2}>
+                    Update the details or documents below, then resubmit the
+                    contract for review.
+                  </Text>
+                </Stack>
+              ) : (
+                "Update any contract detail or document that needs to change, then resubmit the contract for review."
+              )}
             </Alert>
           )}
 
diff --git a/apps/edr-freight-web/portal/src/pages/contracts/booking-window.ts b/apps/edr-freight-web/portal/src/pages/contracts/booking-window.ts
index 44b97c741..b7a1e8c60 100644
--- a/apps/edr-freight-web/portal/src/pages/contracts/booking-window.ts
+++ b/apps/edr-freight-web/portal/src/pages/contracts/booking-window.ts
@@ -26,20 +26,22 @@ export function hasOpenWindow(windows: MyBookingWindow[]): boolean {
 }
 
 /**
- * The soonest upcoming (not-yet-open) window with a known opening time, so the
- * customer can be told when to come back. Returns `null` when nothing upcoming
- * carries an opening time.
+ * The next upcoming (not-yet-open) window the customer should come back for —
+ * the one whose train dispatches soonest, so it lines up with the departure-date
+ * ordering of the cards. Returns `null` when nothing upcoming carries an opening
+ * time. (`windowOpensAt` is still required so the banner can name a come-back time.)
  */
 export function soonestUpcomingWindow(
   windows: MyBookingWindow[],
 ): MyBookingWindow | null {
   const upcoming = windows
     .filter((w) => !w.isOpenNow && w.windowOpensAt)
-    .sort(
-      (a, b) =>
-        new Date(a.windowOpensAt!).getTime() -
-        new Date(b.windowOpensAt!).getTime(),
-    );
+    .sort((a, b) => {
+      const da = a.departureDate ? new Date(a.departureDate).getTime() : Infinity;
+      const db = b.departureDate ? new Date(b.departureDate).getTime() : Infinity;
+      if (da !== db) return da - db;
+      return new Date(a.windowOpensAt!).getTime() - new Date(b.windowOpensAt!).getTime();
+    });
   return upcoming[0] ?? null;
 }
 
diff --git a/apps/edr-freight-web/portal/src/pages/contracts/contract-ui.tsx b/apps/edr-freight-web/portal/src/pages/contracts/contract-ui.tsx
index 4d0dd3564..565ca2079 100644
--- a/apps/edr-freight-web/portal/src/pages/contracts/contract-ui.tsx
+++ b/apps/edr-freight-web/portal/src/pages/contracts/contract-ui.tsx
@@ -156,6 +156,7 @@ export const CONTRACT_STATUS_CONFIG: Record<
   PNR_GENERATED: { label: "Payment Reference Ready", ...TONE.warning },
   PAID: { label: "Paid", ...TONE.success },
   IN_TRANSIT: { label: "In Transit", ...TONE.info },
+  ARRIVED: { label: "Arrived", ...TONE.success },
   COMPLETED: { label: "Completed", ...TONE.success },
 };
 
diff --git a/apps/edr-freight-web/portal/src/pages/contracts/new-contract-form/payment-currency-field.tsx b/apps/edr-freight-web/portal/src/pages/contracts/new-contract-form/payment-currency-field.tsx
index 06f67f7fc..d53b64552 100644
--- a/apps/edr-freight-web/portal/src/pages/contracts/new-contract-form/payment-currency-field.tsx
+++ b/apps/edr-freight-web/portal/src/pages/contracts/new-contract-form/payment-currency-field.tsx
@@ -9,23 +9,27 @@ import { fieldStyles } from "./shared";
 
 export function PaymentCurrencyField({
   control,
+  etbOnly = false,
 }: {
   control: Control<ContractFormInputValues, any, ContractFormValues>;
+  /** Intercity (domestic) contracts are priced in ETB only. */
+  etbOnly?: boolean;
 }) {
+  const options = etbOnly
+    ? PAYMENT_CURRENCY_OPTIONS.filter((o) => o.value === "ETB")
+    : PAYMENT_CURRENCY_OPTIONS;
   return (
     <Controller
       name="paymentCurrency"
       control={control}
       render={({ field, fieldState }) => {
-        const selected = PAYMENT_CURRENCY_OPTIONS.find(
-          (o) => o.value === field.value,
-        );
+        const selected = options.find((o) => o.value === field.value);
         return (
           <div>
             <Select
               label="Payment Currency *"
               placeholder="Select currency…"
-              data={PAYMENT_CURRENCY_OPTIONS.map((o) => ({
+              data={options.map((o) => ({
                 value: o.value,
                 label: o.label,
               }))}
diff --git a/apps/edr-freight-web/portal/src/pages/contracts/new-contract-form/schema.ts b/apps/edr-freight-web/portal/src/pages/contracts/new-contract-form/schema.ts
index eac2d36a8..b0a9c0a0d 100644
--- a/apps/edr-freight-web/portal/src/pages/contracts/new-contract-form/schema.ts
+++ b/apps/edr-freight-web/portal/src/pages/contracts/new-contract-form/schema.ts
@@ -129,7 +129,9 @@ export const contractFormSchema = z
     contractType: z.enum(["new", "renewal"], "Select a contract type."),
     previousContractRef: z.string().default(""),
 
-    serviceTypeId: z.string("Select a service type."),
+    serviceTypeId: z
+      .string("Select a service type.")
+      .min(1, "Select a service type."),
     paymentCurrency: z.enum(PAYMENT_CURRENCIES, "Select a payment currency."),
 
     firstMile: z
@@ -220,6 +222,14 @@ export const contractFormSchema = z
     },
   )
   .superRefine((data, ctx) => {
+    // Intercity (domestic) contracts are priced and invoiced in ETB only.
+    if (data.operationType === "intercity" && data.paymentCurrency !== "ETB") {
+      ctx.addIssue({
+        code: "custom",
+        path: ["paymentCurrency"],
+        message: "Intercity contracts are priced in ETB.",
+      });
+    }
     if (data.cargoType === "container") {
       // Container scope: at least one enabled size.
       if (data.enabledContainerSizes.length === 0) {
@@ -252,29 +262,10 @@ export const contractFormSchema = z
         });
       }
     }
-    // GENERAL contracts must carry a real (> 0) quantity cap — an untouched
-    // NumberInput coerces to 0 (see nonNegativeQuantityCap), which blocks the
-    // Cargo & Route step until the customer enters a quantity.
-    if (data.contractKind === "general_contract") {
-      if (data.cargoType === "container") {
-        for (const size of data.enabledContainerSizes) {
-          if (!(data.containerSizeCaps[size] > 0)) {
-            ctx.addIssue({
-              code: "custom",
-              path: ["containerSizeCaps", size],
-              message: `Enter a ${size} quantity greater than 0.`,
-            });
-          }
-        }
-      }
-      if (data.cargoType === "bulk" && !(data.bulkQuantityCap > 0)) {
-        ctx.addIssue({
-          code: "custom",
-          path: ["bulkQuantityCap"],
-          message: "Enter a total quantity greater than 0.",
-        });
-      }
-    }
+    // GENERAL contracts are uncapped: no quantity cap is collected, so the
+    // customer can book repeatedly until the contract's validity expires. The
+    // cap fields default to 0/empty and map to quantityCap = NULL (uncapped) at
+    // the API. No cap validation is applied.
   });
 
 export type ContractFormValues = z.infer<typeof contractFormSchema>;
@@ -286,7 +277,8 @@ export const initialContractFormValues: DeepPartial<ContractFormValues> = {
   previousContractRef: "",
 
   serviceTypeId: "",
-  paymentCurrency: "USD",
+  // No preselected currency — the customer must choose (intercity forces ETB).
+  paymentCurrency: undefined,
   firstMile: { enabled: false, pickUpAddress: "", exactLocation: "", lat: null, lng: null },
   lastMile: { enabled: false, deliveryAddress: "", exactLocation: "", lat: null, lng: null },
   equipmentReturn: "with_return",
diff --git a/apps/edr-freight-web/portal/src/pages/contracts/new-contract-form/step2-service-type.tsx b/apps/edr-freight-web/portal/src/pages/contracts/new-contract-form/step2-service-type.tsx
index 817e6c56e..866104cda 100644
--- a/apps/edr-freight-web/portal/src/pages/contracts/new-contract-form/step2-service-type.tsx
+++ b/apps/edr-freight-web/portal/src/pages/contracts/new-contract-form/step2-service-type.tsx
@@ -336,6 +336,16 @@ export function Step2ServiceType({
     }
   }, [operationType, standaloneServices, form]);
 
+  // Intercity (domestic) contracts are priced in ETB only — force the currency
+  // and let the field render just the ETB option. Also clears a stale USD from
+  // a restored draft or an operation-type switch.
+  const isIntercity = operationType === "intercity";
+  useEffect(() => {
+    if (isIntercity && form.getValues("paymentCurrency") !== "ETB") {
+      form.setValue("paymentCurrency", "ETB", { shouldValidate: true });
+    }
+  }, [isIntercity, form]);
+
   return (
     <Stack gap={18}>
       <Controller
@@ -353,7 +363,7 @@ export function Step2ServiceType({
       />
 
       <Box maw={420}>
-        <PaymentCurrencyField control={form.control} />
+        <PaymentCurrencyField control={form.control} etbOnly={isIntercity} />
       </Box>
 
       {showServiceSections && (
diff --git a/apps/edr-freight-web/portal/src/pages/contracts/new-contract-form/step3-cargo-scope.tsx b/apps/edr-freight-web/portal/src/pages/contracts/new-contract-form/step3-cargo-scope.tsx
index d278c15ea..51b9bcc93 100644
--- a/apps/edr-freight-web/portal/src/pages/contracts/new-contract-form/step3-cargo-scope.tsx
+++ b/apps/edr-freight-web/portal/src/pages/contracts/new-contract-form/step3-cargo-scope.tsx
@@ -5,7 +5,6 @@ import {
   Box,
   Group,
   MultiSelect,
-  NumberInput,
   Select,
   Skeleton,
   Stack,
@@ -57,8 +56,6 @@ export function Step3CargoScope({
   const cargoType = form.watch("cargoType");
   const cargoTypePath = form.watch("cargoTypePath") ?? [];
   const parentId = cargoTypePath[0];
-  const isGeneral = form.watch("contractKind") === "general_contract";
-  const enabledSizes = form.watch("enabledContainerSizes") ?? [];
 
   // Reset the commodity child only when the parent group really changes.
   const prevParentIdRef = useRef<string | undefined>(parentId);
@@ -224,63 +221,9 @@ export function Step3CargoScope({
         </Stack>
       )}
 
-      {/* GENERAL contract quantity cap (draw-down ceiling). */}
-      {isGeneral && (
-        <Box>
-          <StepLabel>Booking quantity cap *</StepLabel>
-          <Text fz={12} c="#6B7C8E" mt={4} mb={12}>
-            Total quantity bookable across all shipments under this contract.
-            Customers / GL can book repeatedly until it is reached. Must be
-            greater than 0.
-          </Text>
-          {cargoType === "container" ? (
-            <Group gap={12} grow align="flex-start">
-              {enabledSizes.length === 0 ? (
-                <Text fz={13} c="dimmed">
-                  Select container sizes above to set their caps.
-                </Text>
-              ) : (
-                enabledSizes.map((size) => (
-                  <Controller
-                    key={size}
-                    name={`containerSizeCaps.${size}`}
-                    control={form.control}
-                    render={({ field, fieldState }) => (
-                      <NumberInput
-                        label={`${size} cap (containers) *`}
-                        placeholder="e.g. 100"
-                        min={0}
-                        value={Number(field.value ?? 0)}
-                        onChange={(v) => field.onChange(Number(v) || 0)}
-                        error={fieldState.error?.message}
-                        radius={10}
-                        styles={fieldStyles}
-                      />
-                    )}
-                  />
-                ))
-              )}
-            </Group>
-          ) : (
-            <Controller
-              name="bulkQuantityCap"
-              control={form.control}
-              render={({ field, fieldState }) => (
-                <NumberInput
-                  label="Total cap (tons / items) *"
-                  placeholder="e.g. 500"
-                  min={0}
-                  value={Number(field.value ?? 0)}
-                  onChange={(v) => field.onChange(Number(v) || 0)}
-                  error={fieldState.error?.message}
-                  radius={10}
-                  styles={fieldStyles}
-                />
-              )}
-            />
-          )}
-        </Box>
-      )}
+      {/* GENERAL contracts are uncapped — no quantity cap is collected. The
+          customer / GL can book repeatedly against the contract until its
+          validity expires (backend stores quantityCap = NULL = uncapped). */}
 
       {/* Shared billing flags. */}
       <Box>
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-passenger-api/package.json b/apps/edr-passenger-api/package.json
index 1501282fe..cdfe68787 100644
--- a/apps/edr-passenger-api/package.json
+++ b/apps/edr-passenger-api/package.json
@@ -31,10 +31,12 @@
     "@nestjs/event-emitter": "^2.0.4",
     "@nestjs/microservices": "^11.1.24",
     "@nestjs/platform-express": "^11.1.19",
+    "@nestjs/platform-socket.io": "^11.1.27",
     "@nestjs/schedule": "^6.1.3",
     "@nestjs/swagger": "^7.4.0",
     "@nestjs/throttler": "^6.5.0",
     "@nestjs/typeorm": "^11.0.1",
+    "@nestjs/websockets": "^11.1.27",
     "@prisma/client": "^6.19.3",
     "@sendgrid/mail": "^8.1.0",
     "@tria-plc/api-common": "file:../../local-packages/tria-plc-api-common-1.4.3.tgz",
@@ -54,6 +56,7 @@
     "qrcode": "^1.5.3",
     "reflect-metadata": "^0.2.2",
     "rxjs": "^7.8.1",
+    "socket.io": "^4.8.3",
     "swagger-ui-express": "^5.0.0",
     "tsconfig-paths": "^4.2.0",
     "typeorm": "^0.3.30",
diff --git a/apps/edr-passenger-api/prisma/migrations/20260707134245_enhanced_support_chat/migration.sql b/apps/edr-passenger-api/prisma/migrations/20260707134245_enhanced_support_chat/migration.sql
new file mode 100644
index 000000000..299a2abf8
--- /dev/null
+++ b/apps/edr-passenger-api/prisma/migrations/20260707134245_enhanced_support_chat/migration.sql
@@ -0,0 +1,19 @@
+-- AlterTable
+ALTER TABLE "SupportConversation" ADD COLUMN     "agentLastReadAt" TIMESTAMP(3),
+ADD COLUMN     "lastMessageAt" TIMESTAMP(3),
+ADD COLUMN     "lastMessagePreview" TEXT,
+ADD COLUMN     "lastMessageSender" "SupportSender",
+ADD COLUMN     "passengerId" TEXT,
+ADD COLUMN     "passengerName" TEXT,
+ADD COLUMN     "subject" TEXT,
+ADD COLUMN     "updatedAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+ADD COLUMN     "userLastReadAt" TIMESTAMP(3);
+
+-- CreateIndex
+CREATE INDEX "SupportConversation_userId_idx" ON "SupportConversation"("userId");
+
+-- CreateIndex
+CREATE INDEX "SupportConversation_status_lastMessageAt_idx" ON "SupportConversation"("status", "lastMessageAt");
+
+-- AddForeignKey
+ALTER TABLE "SupportConversation" ADD CONSTRAINT "SupportConversation_passengerId_fkey" FOREIGN KEY ("passengerId") REFERENCES "Passenger"("id") ON DELETE SET NULL ON UPDATE CASCADE;
diff --git a/apps/edr-passenger-api/prisma/migrations/20260707135233_add_guest_support/migration.sql b/apps/edr-passenger-api/prisma/migrations/20260707135233_add_guest_support/migration.sql
new file mode 100644
index 000000000..a6b1fc9e7
--- /dev/null
+++ b/apps/edr-passenger-api/prisma/migrations/20260707135233_add_guest_support/migration.sql
@@ -0,0 +1,9 @@
+-- AlterTable
+ALTER TABLE "SupportConversation" ADD COLUMN     "guestEmail" TEXT,
+ADD COLUMN     "guestId" TEXT,
+ADD COLUMN     "guestName" TEXT,
+ADD COLUMN     "guestPhone" TEXT,
+ALTER COLUMN "userId" DROP NOT NULL;
+
+-- CreateIndex
+CREATE INDEX "SupportConversation_guestId_idx" ON "SupportConversation"("guestId");
diff --git a/apps/edr-passenger-api/prisma/schema.prisma b/apps/edr-passenger-api/prisma/schema.prisma
index 0cd1756fd..8a4224e73 100644
--- a/apps/edr-passenger-api/prisma/schema.prisma
+++ b/apps/edr-passenger-api/prisma/schema.prisma
@@ -299,6 +299,7 @@ model Passenger {
   travelerProfiles         TravelerProfile[]
   savedRoutes              SavedRoute[]
   packageBookings          PackageBooking[]
+  supportConversations     SupportConversation[]
   @@index([userId])
   @@index([iamUserId])
   @@schema("passenger")
@@ -881,12 +882,29 @@ model FaqArticle {
 }
 
 model SupportConversation {
-  id              String                    @id @default(uuid())
-  userId          String
-  assignedAgentId String?
-  status          SupportConversationStatus @default(OPEN)
-  createdAt       DateTime                  @default(now())
-  messages        SupportMessage[]
+  id                 String                    @id @default(uuid())
+  userId             String?
+  guestId            String?
+  guestName          String?
+  guestEmail         String?
+  guestPhone         String?
+  passengerId        String?
+  passengerName      String?
+  subject            String?
+  assignedAgentId    String?
+  status             SupportConversationStatus @default(OPEN)
+  lastMessageAt      DateTime?
+  lastMessagePreview String?
+  lastMessageSender  SupportSender?
+  userLastReadAt     DateTime?
+  agentLastReadAt    DateTime?
+  createdAt          DateTime                  @default(now())
+  updatedAt          DateTime                  @updatedAt @default(now())
+  messages           SupportMessage[]
+  passenger          Passenger?                @relation(fields: [passengerId], references: [id])
+  @@index([userId])
+  @@index([guestId])
+  @@index([status, lastMessageAt])
   @@schema("passenger")
 }
 
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/auth/passenger-auth.service.ts b/apps/edr-passenger-api/src/modules/auth/passenger-auth.service.ts
index 1784261e5..2b15cdc7c 100644
--- a/apps/edr-passenger-api/src/modules/auth/passenger-auth.service.ts
+++ b/apps/edr-passenger-api/src/modules/auth/passenger-auth.service.ts
@@ -42,11 +42,7 @@ export class PassengerAuthService {
   }
 
   async register(dto: RegisterDto, req: any) {
-    const existing = await this.dataSource.query<{ id: string }[]>(
-      `SELECT id FROM iam.users WHERE email = $1 OR phone_number = $2 LIMIT 1`,
-      [dto.email, dto.phoneNumber],
-    );
-    if (existing.length) throw new ConflictException('Email or phone already registered');
+    await this.clearPendingOrConflict(dto.email, dto.phoneNumber);
 
     const iamAuthService = await this.resolveIamAuthService(req);
 
@@ -101,11 +97,7 @@ export class PassengerAuthService {
     },
     req: any,
   ): Promise<{ iamUserId: string; passengerId: string }> {
-    const existing = await this.dataSource.query<{ id: string }[]>(
-      `SELECT id FROM iam.users WHERE email = $1 OR phone_number = $2 LIMIT 1`,
-      [dto.email, dto.phoneNumber],
-    );
-    if (existing.length) throw new ConflictException('Email or phone already registered');
+    await this.clearPendingOrConflict(dto.email, dto.phoneNumber);
 
     const iamAuthService = await this.resolveIamAuthService(req);
     await iamAuthService.signupWithPassword({
@@ -600,6 +592,32 @@ export class PassengerAuthService {
     return `+${digits}`;
   }
 
+  /**
+   * Pre-signup uniqueness guard. Throws `ConflictException` only when a
+   * *fully-registered* account (`has_set_password = true`) already owns the
+   * email or phone. Abandoned PENDING signups — where the user received the OTP
+   * but never completed `set-password` — are deleted so this fresh attempt can
+   * re-create the account and re-send the code, instead of being blocked with a
+   * 409 forever. Matches `resendRegistrationCode`'s `has_set_password = false`
+   * notion of "still pending".
+   */
+  private async clearPendingOrConflict(email: string, phoneNumber: string): Promise<void> {
+    const matches = await this.dataSource.query<
+      { id: string; email: string; has_set_password: boolean }[]
+    >(
+      `SELECT id, email, has_set_password FROM iam.users WHERE email = $1 OR phone_number = $2`,
+      [email, phoneNumber],
+    );
+    if (!matches.length) return;
+    if (matches.some((u) => u.has_set_password)) {
+      throw new ConflictException('Email or phone already registered');
+    }
+    // Every match is an abandoned pending signup — clean it up so the caller can proceed.
+    for (const u of matches) {
+      await this.compensateIamSignup(u.email);
+    }
+  }
+
   private async compensateIamSignup(email: string): Promise<void> {
     try {
       const rows = await this.dataSource.query<{ id: string }[]>(
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 6e45aeab4..345cfc357 100644
--- a/apps/edr-passenger-api/src/modules/bookings/bookings.dto.ts
+++ b/apps/edr-passenger-api/src/modules/bookings/bookings.dto.ts
@@ -4,7 +4,7 @@ import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
 import { Currency, IdDocumentType } from '@prisma/client';
 
 export class PassengerInputDto {
-  @ApiProperty({ example: 'seat-uuid', description: 'Outbound / leg-1 seat ID (all booking types)' }) @IsString() seatId: string;
+  @ApiPropertyOptional({ example: 'seat-uuid', description: 'Outbound / leg-1 seat ID (all booking types). Omit for free children (package bookings) — backend auto-assigns.' }) @IsOptional() @IsString() seatId?: string;
   @ApiPropertyOptional({ example: 'leg2-seat-uuid', description: '**TRANSIT / ROUND_TRIP_TRANSIT:** Outbound leg-2 seat ID' }) @IsOptional() @IsString() leg2SeatId?: string;
   @ApiPropertyOptional({ example: 'return-seat-uuid', description: '**ROUND_TRIP / ROUND_TRIP_TRANSIT:** Return leg-1 seat ID' }) @IsOptional() @IsString() returnSeatId?: string;
   @ApiPropertyOptional({ example: 'ret-leg2-seat-uuid', description: '**ROUND_TRIP_TRANSIT:** Return leg-2 seat ID' }) @IsOptional() @IsString() returnLeg2SeatId?: string;
@@ -24,11 +24,11 @@ export class PassengerInputDto {
 }
 
 export class RoundTripPassengerDto {
-  @ApiProperty({ description: 'Outbound journey seat ID', example: 'seat-uuid-outbound' }) 
-  @IsString() outboundSeatId: string;
+  @ApiPropertyOptional({ description: 'Outbound journey seat ID', example: 'seat-uuid-outbound' }) 
+  @IsOptional() @IsString() outboundSeatId?: string;
   
-  @ApiProperty({ description: 'Return journey seat ID', example: 'seat-uuid-return' }) 
-  @IsString() returnSeatId: string;
+  @ApiPropertyOptional({ description: 'Return journey seat ID', example: 'seat-uuid-return' }) 
+  @IsOptional() @IsString() returnSeatId?: string;
 
   @ApiPropertyOptional({ description: '**ROUND_TRIP_TRANSIT:** Outbound leg-2 seat ID' })
   @IsOptional() @IsString() outboundLeg2SeatId?: 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..50d953010 100644
--- a/apps/edr-passenger-api/src/modules/bookings/bookings.service.ts
+++ b/apps/edr-passenger-api/src/modules/bookings/bookings.service.ts
@@ -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.
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 c6f27d9c3..c2acaeece 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
@@ -4,8 +4,8 @@ import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
 import { Currency, IdDocumentType } from '@prisma/client';
 
 export class GuestPassengerDto {
-  @ApiProperty({ example: 'seat-uuid', description: 'Outbound / leg-1 seat ID (all booking types)' }) 
-  @IsString() seatId: string;
+  @ApiPropertyOptional({ example: 'seat-uuid', description: 'Outbound / leg-1 seat ID (all booking types). Omit for free children (package bookings) — backend auto-assigns.' }) 
+  @IsOptional() @IsString() seatId?: string;
 
   @ApiPropertyOptional({ example: 'return-seat-uuid', description: '**ROUND_TRIP / ROUND_TRIP_TRANSIT:** Return leg-1 seat ID. Required for ROUND_TRIP and ROUND_TRIP_TRANSIT.' })
   @IsOptional() @IsString() returnSeatId?: string;
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 f4139d842..5d773860c 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)
@@ -260,7 +260,7 @@ export class GuestBookingService {
     await this.createTravelerProfiles(guestPassengerId, passengersData);
 
     // Confirm seats
-    await this.seatsService.confirmSeats(dto.passengers.map(p => p.seatId));
+    await this.seatsService.confirmSeats(dto.passengers.map(p => p.seatId).filter((id): id is string => !!id));
     this.eventEmitter.emit('booking.created', { booking });
 
     return {
@@ -434,7 +434,7 @@ export class GuestBookingService {
     const { guestPassengerId, iamUserId, createdAccount } = await this.resolveGuestPassenger(dto, passengersData[0], req);
 
     // Create booking with outbound seats; return seats confirmed separately
-    const outboundSeatIds = dto.passengers.map(p => p.seatId);
+    const outboundSeatIds = dto.passengers.map(p => p.seatId).filter((id): id is string => !!id);
     const returnSeatIds   = dto.passengers.map(p => p.returnSeatId!);
 
     const booking = await this.prisma.booking.create({
@@ -701,7 +701,7 @@ export class GuestBookingService {
     await this.createTravelerProfiles(guestPassengerId, passengersData);
 
     await Promise.all([
-      this.seatsService.confirmSeats(dto.passengers.map(p => p.seatId)),
+      this.seatsService.confirmSeats(dto.passengers.map(p => p.seatId).filter((id): id is string => !!id)),
       this.seatsService.confirmSeats(dto.passengers.map(p => p.leg2SeatId!)),
     ]);
     this.eventEmitter.emit('booking.created', { booking });
@@ -894,7 +894,7 @@ export class GuestBookingService {
     await this.createTravelerProfiles(guestPassengerId, passengersData);
 
     await Promise.all([
-      this.seatsService.confirmSeats(dto.passengers.map(p => p.seatId)),
+      this.seatsService.confirmSeats(dto.passengers.map(p => p.seatId).filter((id): id is string => !!id)),
       this.seatsService.confirmSeats(dto.passengers.map(p => p.leg2SeatId!)),
       this.seatsService.confirmSeats(dto.passengers.map(p => p.returnSeatId!)),
       this.seatsService.confirmSeats(dto.passengers.map(p => p.returnLeg2SeatId!)),
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..515a00655 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,46 @@ export class FareEngineService {
     });
 
     if (segmentOverride) {
-      // Flat override for this exact segment — baseFareMinor is the total base, not a per-km rate
       baseFarePerPassengerMinor = segmentOverride.baseFareMinor;
       ratePerKmMinor = totalDistanceKm > 0 ? Math.round(baseFarePerPassengerMinor / totalDistanceKm) : 0;
       fareSource = 'SEGMENT_FARE_RULE';
     } else if (fareRule?.tripId) {
-      // Schedule-scoped flat override
       baseFarePerPassengerMinor = fareRule.baseFareMinor;
       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 +157,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);
@@ -162,8 +166,10 @@ 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`,
+      `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 +197,8 @@ export class FareEngineService {
       seatClassName: nationalitySeatClass.name,
       totalDistanceKm,
       ratePerKmMinor,
+      insuranceFactor,
+      usdToEtbRate,
       baseFarePerPassengerMinor,
       premiumPerPassenger,
       insurancePerPassenger,
@@ -323,19 +331,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.service.ts b/apps/edr-passenger-api/src/modules/notifications/notifications.service.ts
index 9a7b4311c..43d1e4d46 100644
--- a/apps/edr-passenger-api/src/modules/notifications/notifications.service.ts
+++ b/apps/edr-passenger-api/src/modules/notifications/notifications.service.ts
@@ -285,7 +285,11 @@ export class NotificationsService {
     const ref = booking?.bookingRef ?? payload.booking.bookingRef;
     const amount = this.formatAmount(booking ?? payload.booking);
     const currency = (booking ?? payload.booking).displayCurrency ?? 'ETB';
-    const ticketUrl = `${process.env.PORTAL_URL ?? 'http://localhost:5174'}/booking/confirmation?ref=${ref}`;
+    // /booking/confirmation only reads from the in-session booking store, so it's a dead
+    // link once opened outside that session (a different device, or later on the same
+    // one) — exactly the case an SMS/email link is for. /booking/detail fetches the
+    // booking fresh from the API by ref, so it works standalone.
+    const ticketUrl = `${process.env.PORTAL_URL ?? 'http://localhost:5174'}/booking/detail?ref=${ref}`;
 
     // IN_APP — always created.
     await this.createInAppNotification(
diff --git a/apps/edr-passenger-api/src/modules/packages/packages.service.ts b/apps/edr-passenger-api/src/modules/packages/packages.service.ts
index a474b1edf..916a0425b 100644
--- a/apps/edr-passenger-api/src/modules/packages/packages.service.ts
+++ b/apps/edr-passenger-api/src/modules/packages/packages.service.ts
@@ -75,7 +75,6 @@ export class PackagesService {
     const maxChildren = adultCount * PKG_CHILDREN_PER_ADULT;
     if (childCount > maxChildren) throw new BadRequestException(`Maximum ${PKG_CHILDREN_PER_ADULT} children per adult (${maxChildren} for ${adultCount} adult${adultCount !== 1 ? 's' : ''}) allowed per package booking`);
 
-    const remaining = tier.availableSeats - tier.bookedSeats;
     const isRoundTrip = !!pkg.returnScheduleId;
     const { adultFareMinor, freeChildren, paidChildren, totalMinor } = calculatePackageFareBreakdown(
       tier.priceMinor, isRoundTrip, adultCount, childCount,
@@ -84,6 +83,10 @@ export class PackagesService {
     // Only adults and paid children need seats; free children travel without a seat
     const seatsNeeded = adultCount + paidChildren;
     const passengerCount = adultCount + childCount;
+    // Re-fetch tier from DB to get accurate live counts
+    const liveTier = await this.prisma.packagePriceTier.findUnique({ where: { id: tierId } });
+    if (!liveTier) throw new NotFoundException('Price tier not found');
+    const remaining = liveTier.availableSeats - liveTier.bookedSeats;
     if (seatsNeeded > remaining)
       throw new BadRequestException(`Only ${remaining} seat(s) remaining in the ${tier.label} tier`);
 
@@ -392,25 +395,29 @@ export class PackagesService {
     if (childCount > maxChildrenBook) throw new BadRequestException(`Maximum ${PKG_CHILDREN_PER_ADULT} children per adult (${maxChildrenBook} for ${adultCount} adult${adultCount !== 1 ? 's' : ''}) allowed per package booking`);
 
     const passengerCount = adultCount + childCount;
-    const remaining = tier.availableSeats - tier.bookedSeats;
-
     const isRoundTrip = !!pkg.returnScheduleId;
     const { adultFareMinor, freeChildren, paidChildren, totalMinor } = calculatePackageFareBreakdown(
       tier.priceMinor, isRoundTrip, adultCount, childCount,
     );
     // Only adults and paid children need seats; free children travel without a seat
     const seatsNeeded = adultCount + paidChildren;
-    if (seatsNeeded > remaining) {
-      throw new BadRequestException(`Only ${remaining} seats remaining in the ${tier.label} tier`);
-    }
     const displayCurrency = (dto.displayCurrency as Currency) ?? Currency.ETB;
     const displayTotalMinor =
       displayCurrency !== Currency.ETB
         ? await this.currencyService.convertAmount(totalMinor, Currency.ETB, displayCurrency)
         : totalMinor;
 
-    const [booking] = await this.prisma.$transaction([
-      this.prisma.packageBooking.create({
+    const [booking] = await this.prisma.$transaction(async (tx) => {
+      // Re-fetch tier inside transaction for race-condition-safe availability check
+      const freshTier = await tx.packagePriceTier.findUnique({ where: { id: dto.priceTierId } });
+      if (!freshTier) throw new NotFoundException('Price tier not found');
+      const remaining = freshTier.availableSeats - freshTier.bookedSeats;
+      if (seatsNeeded > remaining) {
+        throw new BadRequestException(`Only ${remaining} seats remaining in the ${tier.label} tier`);
+      }
+
+      return Promise.all([
+        tx.packageBooking.create({
         data: {
           bookingRef: generateRef(),
           packageId: dto.packageId,
@@ -448,12 +455,16 @@ export class PackagesService {
             },
           },
         },
-      }),
-      this.prisma.packagePriceTier.update({
-        where: { id: dto.priceTierId },
-        data: { bookedSeats: { increment: seatsNeeded } },
-      }),
-    ]);
+        }),
+        tx.packagePriceTier.update({
+          where: { id: dto.priceTierId },
+          data: {
+            bookedSeats: { increment: seatsNeeded },
+            availableSeats: { decrement: seatsNeeded },
+          },
+        }),
+      ]);
+    });
 
     return {
       ...booking,
diff --git a/apps/edr-passenger-api/src/modules/payments/payments.controller.ts b/apps/edr-passenger-api/src/modules/payments/payments.controller.ts
index 5be11434a..2cdbc86e4 100644
--- a/apps/edr-passenger-api/src/modules/payments/payments.controller.ts
+++ b/apps/edr-passenger-api/src/modules/payments/payments.controller.ts
@@ -33,6 +33,7 @@ import {
   PaymentMethodTypeEnum,
   PaymentPlatformDto,
   BookingAmountResponseDto,
+  ForceConfirmDto,
 } from "./payments.dto";
 import { PassengerStaff } from "../../common/passenger-guards";
 import { PASSENGER_PERMS } from "../../seed/passenger-permissions.registry";
@@ -124,6 +125,19 @@ export class PaymentsController {
     return this.service.refund(dto);
   }
 
+  @Post(":bookingId/force-confirm")
+  @PassengerStaff([PASSENGER_PERMS.payments.manageMethods, PASSENGER_PERMS.admin])
+  @ApiBearerAuth("IAM-auth")
+  @ApiOperation({
+    summary: "Force-confirm payment & generate ticket (back-office only)",
+    description:
+      "Marks the payment as SUCCEEDED, confirms the booking, and generates the ticket. " +
+      "Use when a vendor payment completed but the webhook was never delivered. Idempotent.",
+  })
+  forceConfirm(@Param("bookingId") bookingId: string, @Body() dto: ForceConfirmDto) {
+    return this.service.forceConfirmPayment(bookingId, dto);
+  }
+
   @Post("methods")
   @PassengerStaff([PASSENGER_PERMS.payments.manageMethods, PASSENGER_PERMS.admin])
   @ApiBearerAuth("IAM-auth")
diff --git a/apps/edr-passenger-api/src/modules/payments/payments.dto.ts b/apps/edr-passenger-api/src/modules/payments/payments.dto.ts
index 410716b85..8d24091a1 100644
--- a/apps/edr-passenger-api/src/modules/payments/payments.dto.ts
+++ b/apps/edr-passenger-api/src/modules/payments/payments.dto.ts
@@ -142,3 +142,14 @@ export class BookingAmountResponseDto {
   @ApiProperty({ example: 'DJF', description: 'Currency of the returned amount' }) currency: string;
   @ApiProperty({ example: 162.5, description: 'Booking total converted to the requested currency (major units)' }) amount: number;
 }
+
+export class ForceConfirmDto {
+  @ApiPropertyOptional({ description: 'External payment reference / transaction ID from the vendor', example: 'TXN-123456' })
+  @IsOptional() @IsString() paymentReference?: string;
+
+  @ApiPropertyOptional({ enum: PaymentMethodTypeEnum, description: 'Payment method used externally', example: 'TELEBIRR' })
+  @IsOptional() @IsEnum(PaymentMethodTypeEnum) paymentMethod?: PaymentMethodTypeEnum;
+
+  @ApiPropertyOptional({ description: 'Internal notes about why this was force-confirmed', example: 'Vendor confirmed via phone' })
+  @IsOptional() @IsString() notes?: string;
+}
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 e9b512c5e..9e43139c4 100644
--- a/apps/edr-passenger-api/src/modules/payments/payments.service.ts
+++ b/apps/edr-passenger-api/src/modules/payments/payments.service.ts
@@ -21,6 +21,7 @@ import {
   InitiateResponseDto,
   IntentStatusDto,
   PaymentRegionEnum,
+  ForceConfirmDto,
 } from "./payments.dto";
 import { PaymentEventDto, MarkPaidResponseDto } from "./internal-payments.dto";
 import { PaymentClientService } from "./payment-client.service";
@@ -773,6 +774,51 @@ export class PaymentsService {
     return { processed: true, alreadyFinalized };
   }
 
+  async forceConfirmPayment(bookingId: string, dto: ForceConfirmDto = {}): Promise<{ alreadyFinalized: boolean }> {
+    const booking = await this.prisma.booking.findUnique({ where: { id: bookingId } });
+    if (!booking) throw new NotFoundException('Booking not found');
+
+    const resolvedMethod = dto.paymentMethod
+      ? (dto.paymentMethod as unknown as PaymentMethodType)
+      : PaymentMethodType.TELEBIRR;
+
+    let intent = await this.prisma.paymentIntent.findUnique({ where: { bookingId } });
+    if (!intent) {
+      intent = await this.prisma.paymentIntent.create({
+        data: {
+          bookingId,
+          amountMinor: booking.totalMinor,
+          currency: booking.currency,
+          method: resolvedMethod,
+          status: PaymentIntentStatus.PROCESSING,
+          providerRef: `FORCE-${Date.now()}`,
+          providerTxnId: dto.paymentReference ?? null,
+          failureMessage: dto.notes ?? null,
+        },
+      });
+    } else {
+      // Update method/reference/notes regardless of current status
+      const updateData: any = {};
+      if (dto.paymentReference) updateData.providerTxnId = dto.paymentReference;
+      if (dto.paymentMethod) updateData.method = resolvedMethod;
+      if (dto.notes) updateData.failureMessage = dto.notes;
+      if (intent.status === PaymentIntentStatus.CANCELLED || intent.status === PaymentIntentStatus.FAILED) {
+        updateData.status = PaymentIntentStatus.PROCESSING;
+      }
+      if (Object.keys(updateData).length) {
+        intent = await this.prisma.paymentIntent.update({
+          where: { id: intent.id },
+          data: updateData,
+        });
+      }
+    }
+
+    return this.finalizePaymentSuccess({
+      intentId: intent.id,
+      providerTxnId: dto.paymentReference ?? intent.providerTxnId ?? undefined,
+    });
+  }
+
   async markPaymentFailed(input: {
     intentId: string;
     failureCode?: string;
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 2942625ca..a02c7b7e3 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(
@@ -64,7 +70,7 @@ export class SearchService {
 
     const outbound = [...direct, ...transit];
 
-    if (outbound.length === 0) {
+    if (outbound.length === 0 && dto.journeyType !== 'ROUND_TRIP') {
       const alternativesOutbound = await this.searchAlternatives(
         dto.originStationId,
         dto.destinationStationId,
@@ -74,7 +80,7 @@ export class SearchService {
         dto.nationality,
       );
       return {
-        journeyType: dto.journeyType === 'ROUND_TRIP' ? 'ROUND_TRIP' : 'ONE_WAY',
+        journeyType: 'ONE_WAY',
         outbound: [],
         alternativeOutbound: alternativesOutbound,
         requestedDate: dto.date,
@@ -110,19 +116,29 @@ export class SearchService {
         new Date(s.departureAt ?? s.leg1?.departureAt).getTime() > latestOutboundArrival
       );
 
-      if (inbound.length === 0) {
-        const alternativeInbound = await this.searchAlternatives(
-          dto.destinationStationId,
-          dto.originStationId,
-          dto.returnDate ?? dto.date,
-          dto.adultCount,
-          dto.childCount,
-          dto.nationality,
-        );
-        return { journeyType: 'ROUND_TRIP', outbound, inbound: [], alternativeInbound };
+      const returnDate = dto.returnDate ?? dto.date;
+
+      if (outbound.length === 0 || inbound.length === 0) {
+        const [alternativeOutbound, alternativeInbound] = await Promise.all([
+          outbound.length === 0
+            ? this.searchAlternatives(dto.originStationId, dto.destinationStationId, dto.date, dto.adultCount, dto.childCount, dto.nationality)
+            : Promise.resolve([]),
+          inbound.length === 0
+            ? this.searchAlternatives(dto.destinationStationId, dto.originStationId, returnDate, dto.adultCount, dto.childCount, dto.nationality)
+            : Promise.resolve([]),
+        ]);
+        return {
+          journeyType: 'ROUND_TRIP',
+          outbound,
+          inbound,
+          alternativeOutbound,
+          alternativeInbound,
+          requestedDate: dto.date,
+          requestedReturnDate: returnDate,
+        };
       }
 
-      return { journeyType: 'ROUND_TRIP', outbound, inbound };
+      return { journeyType: 'ROUND_TRIP', outbound, inbound, requestedDate: dto.date, requestedReturnDate: returnDate };
     }
 
     return { journeyType: 'ONE_WAY', outbound };
@@ -156,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' },
@@ -173,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(
@@ -190,12 +207,17 @@ 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 earliest = new Date(Math.max((date < now ? now : date).getTime(), cutoffThreshold.getTime()));
+
     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,
     });
@@ -205,7 +227,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 ─────────────────────────────────────────────────────────
@@ -231,26 +253,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;
 
@@ -344,6 +371,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/seats/seats.controller.ts b/apps/edr-passenger-api/src/modules/seats/seats.controller.ts
index 4a9783101..fa233f45c 100644
--- a/apps/edr-passenger-api/src/modules/seats/seats.controller.ts
+++ b/apps/edr-passenger-api/src/modules/seats/seats.controller.ts
@@ -19,7 +19,7 @@ import {
   ApiResponse,
 } from "@nestjs/swagger";
 import { SeatsService } from "./seats.service";
-import { HoldSeatsDto } from "./seats.dto";
+import { HoldSeatsDto, ReleaseHoldDto } from "./seats.dto";
 import { JwtGuard } from "../../common/jwt.guard";
 import { IamGuard } from "../../common/iam-adapter";
 
@@ -182,6 +182,27 @@ This makes it clear which segment of the route each seat is held for, enabling s
     return this.service.releaseHold(holdId);
   }
 
+  @Post("release")
+  @SetMetadata('isPublic', true)
+  @ApiOperation({
+    summary: "Release a seat hold by holdId (portal-server use only)",
+    description:
+      "Frees a previously-created hold's seats immediately instead of waiting for it to " +
+      "expire — used when a guest or logged-in user changes their seat selection, so the " +
+      "stale hold doesn't linger and block that seat for other travellers.\n\n" +
+      "This is a public endpoint (no JWT), like POST /seats/hold, since guest sessions have " +
+      "no login to authenticate with. It must ONLY ever be called from the passenger portal's " +
+      "own Next.js server (a server-side route handler), never directly from browser code — " +
+      "calling it straight from client JS would let anyone script mass hold-cancellation " +
+      "against other travellers' in-progress seat selections. The portal's server-side proxy " +
+      "is what keeps this endpoint's existence out of the browser's network requests.",
+  })
+  @ApiResponse({ status: 200, description: "Hold released" })
+  @ApiResponse({ status: 404, description: "Hold not found" })
+  releaseSeatById(@Body() dto: ReleaseHoldDto) {
+    return this.service.releaseHold(dto.holdId);
+  }
+
   // ── Seat Block / Unblock ───────────────────────────────────────────────────
   @Post(":seatId/block")
   @UseGuards(IamGuard)
diff --git a/apps/edr-passenger-api/src/modules/seats/seats.dto.ts b/apps/edr-passenger-api/src/modules/seats/seats.dto.ts
index 23c3b3d46..87d47588e 100644
--- a/apps/edr-passenger-api/src/modules/seats/seats.dto.ts
+++ b/apps/edr-passenger-api/src/modules/seats/seats.dto.ts
@@ -48,3 +48,8 @@ export class HoldSeatsDto {
   @Type(() => PassengerSeatDto)
   passengers: PassengerSeatDto[];
 }
+
+export class ReleaseHoldDto {
+  @ApiProperty({ example: 'hold-uuid', description: 'SeatHold UUID to release' })
+  @IsString() holdId: string;
+}
diff --git a/apps/edr-passenger-api/src/modules/seats/seats.service.ts b/apps/edr-passenger-api/src/modules/seats/seats.service.ts
index 495c394ee..b26dcb763 100644
--- a/apps/edr-passenger-api/src/modules/seats/seats.service.ts
+++ b/apps/edr-passenger-api/src/modules/seats/seats.service.ts
@@ -90,6 +90,7 @@ export class SeatsService {
           label:          a.coach.number,
           mode:           a.coach.status,
           name:           `Coach ${a.coach.number}`,
+          coachTypeId:    a.coach.coachType?.id ?? null,
           coachTypeName,
           isBedCoach,
           bedCategory,
@@ -665,6 +666,7 @@ export class SeatsService {
 
       return {
         coachId: a.coach.id,
+        coachTypeId: a.coach.coachType?.id ?? null,
         coachNumber: a.coach.number,
         positionNumber: a.positionNumber,
         coachTypeName: a.coach.coachType?.name ?? '',
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 c13b3cd33..4404c3ea8 100644
--- a/apps/edr-passenger-api/src/modules/support/support.controller.ts
+++ b/apps/edr-passenger-api/src/modules/support/support.controller.ts
@@ -1,15 +1,241 @@
-import { Body, Controller, Get, Param, Post, UseGuards } from '@nestjs/common';
+import {
+  Body,
+  Controller,
+  Get,
+  Param,
+  Patch,
+  Post,
+  Query,
+  Req,
+  UnauthorizedException,
+  UseGuards,
+} from '@nestjs/common';
 import { ApiTags, ApiOperation, ApiBearerAuth } from '@nestjs/swagger';
+import { IsPublic } from '@tria-plc/api-common/modules/auth/decorators/public.decorator';
 import { SupportService } from './support.service';
 import { JwtGuard } from '../../common/jwt.guard';
+import {
+  CreateConversationDto,
+  CreateGuestConversationDto,
+  DeviceIdBodyDto,
+  DeviceSendMessageDto,
+  GuestIdBodyDto,
+  GuestSendMessageDto,
+  ListConversationsQueryDto,
+  SendMessageDto,
+  UpdateStatusDto,
+} from './support.dto';
+
+function userId(req: any): string {
+  const id = req?.user?.id ?? req?.user?.sub;
+  if (!id) throw new UnauthorizedException();
+  return id;
+}
 
 @ApiTags('Support')
 @Controller('support')
 export class SupportController {
   constructor(private service: SupportService) {}
-  @Get('faq')                                @ApiOperation({ summary: 'Get FAQ categories' })                    getFaqCategories() { return this.service.getFaqCategories(); }
-  @Get('faq/:categoryId/articles')           @ApiOperation({ summary: 'Get FAQ articles for a category' })       getFaqArticles(@Param('categoryId') id: string) { return this.service.getFaqArticles(id); }
-  @Post('conversations') @UseGuards(JwtGuard) @ApiBearerAuth('JWT-auth') @ApiOperation({ summary: 'Start a support conversation' }) startConversation(@Body('userId') userId: string) { return this.service.startConversation(userId); }
-  @Post('conversations/:id/messages') @UseGuards(JwtGuard) @ApiBearerAuth('JWT-auth') @ApiOperation({ summary: 'Send a message in a conversation' }) sendMessage(@Param('id') id: string, @Body() body: { sender: 'USER' | 'BOT' | 'AGENT'; text: string }) { return this.service.sendMessage(id, body.sender, body.text); }
-  @Get('conversations/:id') @UseGuards(JwtGuard) @ApiBearerAuth('JWT-auth') @ApiOperation({ summary: 'Get conversation with messages' }) getConversation(@Param('id') id: string) { return this.service.getConversation(id); }
+
+  // ---- FAQ (public) ------------------------------------------------------
+
+  @Get('faq')
+  @IsPublic()
+  @ApiOperation({ summary: 'Get FAQ categories' })
+  getFaqCategories() {
+    return this.service.getFaqCategories();
+  }
+
+  @Get('faq/:categoryId/articles')
+  @IsPublic()
+  @ApiOperation({ summary: 'Get FAQ articles for a category' })
+  getFaqArticles(@Param('categoryId') id: string) {
+    return this.service.getFaqArticles(id);
+  }
+
+  // ---- customer: authenticated passenger --------------------------------
+
+  @Post('conversations')
+  @UseGuards(JwtGuard)
+  @ApiBearerAuth('JWT-auth')
+  @ApiOperation({ summary: 'Open a new support conversation' })
+  createConversation(@Req() req: any, @Body() body: CreateConversationDto) {
+    return this.service.createConversation(userId(req), body);
+  }
+
+  @Get('conversations')
+  @UseGuards(JwtGuard)
+  @ApiBearerAuth('JWT-auth')
+  @ApiOperation({ summary: 'List my support conversations' })
+  listMine(@Req() req: any, @Query() query: ListConversationsQueryDto) {
+    return this.service.listForCustomer({ iamUserId: userId(req) }, query);
+  }
+
+  @Get('conversations/:id/messages')
+  @UseGuards(JwtGuard)
+  @ApiBearerAuth('JWT-auth')
+  @ApiOperation({ summary: 'List messages in one of my conversations' })
+  messages(@Req() req: any, @Param('id') id: string) {
+    return this.service.getMessages(id, { iamUserId: userId(req) });
+  }
+
+  @Post('conversations/:id/messages')
+  @UseGuards(JwtGuard)
+  @ApiBearerAuth('JWT-auth')
+  @ApiOperation({ summary: 'Send a message as the customer' })
+  send(@Req() req: any, @Param('id') id: string, @Body() body: SendMessageDto) {
+    return this.service.sendMessage(id, 'USER', body.text, {
+      iamUserId: userId(req),
+    });
+  }
+
+  @Post('conversations/:id/read')
+  @UseGuards(JwtGuard)
+  @ApiBearerAuth('JWT-auth')
+  @ApiOperation({ summary: 'Mark a conversation read (customer side)' })
+  read(@Req() req: any, @Param('id') id: string) {
+    return this.service.markRead(id, 'USER', { iamUserId: userId(req) });
+  }
+
+  @Get('unread-count')
+  @UseGuards(JwtGuard)
+  @ApiBearerAuth('JWT-auth')
+  @ApiOperation({ summary: 'Count my unread support conversations' })
+  unread(@Req() req: any) {
+    return this.service.unreadCount('USER', { iamUserId: userId(req) });
+  }
+
+  // ---- 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).
+
+  @Post('guest/conversations')
+  @IsPublic()
+  @ApiOperation({ summary: 'Open a support conversation as a guest' })
+  guestCreate(@Body() body: CreateGuestConversationDto) {
+    return this.service.createGuestConversation(body);
+  }
+
+  @Get('guest/conversations')
+  @IsPublic()
+  @ApiOperation({ summary: 'List a guest\'s conversations' })
+  guestList(
+    @Query('guestId') guestId: string,
+    @Query() query: ListConversationsQueryDto,
+  ) {
+    return this.service.listForCustomer({ guestId }, query);
+  }
+
+  @Get('guest/conversations/:id/messages')
+  @IsPublic()
+  @ApiOperation({ summary: 'List messages in a guest conversation' })
+  guestMessages(@Param('id') id: string, @Query('guestId') guestId: string) {
+    return this.service.getMessages(id, { guestId });
+  }
+
+  @Post('guest/conversations/:id/messages')
+  @IsPublic()
+  @ApiOperation({ summary: 'Send a message as a guest' })
+  guestSend(@Param('id') id: string, @Body() body: GuestSendMessageDto) {
+    return this.service.sendMessage(id, 'USER', body.text, {
+      guestId: body.guestId,
+    });
+  }
+
+  @Post('guest/conversations/:id/read')
+  @IsPublic()
+  @ApiOperation({ summary: 'Mark a guest conversation read' })
+  guestRead(@Param('id') id: string, @Body() body: GuestIdBodyDto) {
+    return this.service.markRead(id, 'USER', { guestId: body.guestId });
+  }
+
+  @Get('guest/unread-count')
+  @IsPublic()
+  @ApiOperation({ summary: 'Count a guest\'s unread conversations' })
+  guestUnread(@Query('guestId') guestId: string) {
+    return this.service.unreadCount('USER', { guestId });
+  }
+
+  // ---- agent (backoffice) ------------------------------------------------
+  // TODO: gate agent routes with a staff permission once passenger RBAC is wired.
+
+  @Get('agent/conversations')
+  @UseGuards(JwtGuard)
+  @ApiBearerAuth('JWT-auth')
+  @ApiOperation({ summary: 'List all support conversations (shared inbox)' })
+  agentList(@Query() query: ListConversationsQueryDto) {
+    return this.service.listForAgents(query);
+  }
+
+  @Get('agent/conversations/:id/messages')
+  @UseGuards(JwtGuard)
+  @ApiBearerAuth('JWT-auth')
+  @ApiOperation({ summary: 'List messages in a conversation' })
+  agentMessages(@Param('id') id: string) {
+    return this.service.getMessages(id);
+  }
+
+  @Post('agent/conversations/:id/messages')
+  @UseGuards(JwtGuard)
+  @ApiBearerAuth('JWT-auth')
+  @ApiOperation({ summary: 'Reply as an agent' })
+  agentSend(@Param('id') id: string, @Body() body: SendMessageDto) {
+    return this.service.sendMessage(id, 'AGENT', body.text);
+  }
+
+  @Patch('agent/conversations/:id/status')
+  @UseGuards(JwtGuard)
+  @ApiBearerAuth('JWT-auth')
+  @ApiOperation({ summary: "Change a conversation's status" })
+  agentStatus(@Param('id') id: string, @Body() body: UpdateStatusDto) {
+    return this.service.setStatus(id, body.status);
+  }
+
+  @Post('agent/conversations/:id/read')
+  @UseGuards(JwtGuard)
+  @ApiBearerAuth('JWT-auth')
+  @ApiOperation({ summary: 'Mark a conversation read (agent side)' })
+  agentRead(@Param('id') id: string) {
+    return this.service.markRead(id, 'AGENT');
+  }
+
+  @Get('agent/unread-count')
+  @UseGuards(JwtGuard)
+  @ApiBearerAuth('JWT-auth')
+  @ApiOperation({ summary: 'Count unread conversations (agent side)' })
+  agentUnread() {
+    return this.service.unreadCount('AGENT');
+  }
 }
diff --git a/apps/edr-passenger-api/src/modules/support/support.dto.ts b/apps/edr-passenger-api/src/modules/support/support.dto.ts
new file mode 100644
index 000000000..a60ac607e
--- /dev/null
+++ b/apps/edr-passenger-api/src/modules/support/support.dto.ts
@@ -0,0 +1,147 @@
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+import { Type } from 'class-transformer';
+import {
+  IsEmail,
+  IsEnum,
+  IsInt,
+  IsOptional,
+  IsString,
+  Length,
+  Max,
+  MaxLength,
+  Min,
+  MinLength,
+} from 'class-validator';
+
+export enum SupportStatusDto {
+  OPEN = 'OPEN',
+  RESOLVED = 'RESOLVED',
+  CLOSED = 'CLOSED',
+}
+
+export class CreateConversationDto {
+  @ApiProperty({ description: 'Short subject / topic of the request.' })
+  @IsString()
+  @Length(3, 200)
+  subject!: string;
+
+  @ApiProperty({ description: 'The first message body.' })
+  @IsString()
+  @MinLength(1)
+  @MaxLength(4000)
+  initialMessage!: string;
+}
+
+export class SendMessageDto {
+  @ApiProperty({ description: 'Message text.' })
+  @IsString()
+  @MinLength(1)
+  @MaxLength(4000)
+  text!: string;
+}
+
+export class CreateGuestConversationDto {
+  @ApiProperty({ description: 'Client-generated anonymous id (localStorage).' })
+  @IsString()
+  @Length(8, 120)
+  guestId!: string;
+
+  @ApiProperty({ description: 'Guest full name.' })
+  @IsString()
+  @Length(1, 120)
+  name!: string;
+
+  @ApiProperty({ description: 'Guest email for follow-up.' })
+  @IsEmail()
+  email!: string;
+
+  @ApiPropertyOptional({ description: 'Guest phone (optional).' })
+  @IsOptional()
+  @IsString()
+  @MaxLength(40)
+  phone?: string;
+
+  @ApiProperty()
+  @IsString()
+  @Length(3, 200)
+  subject!: string;
+
+  @ApiProperty()
+  @IsString()
+  @MinLength(1)
+  @MaxLength(4000)
+  initialMessage!: string;
+}
+
+export class GuestSendMessageDto {
+  @ApiProperty({ description: 'The guest id that owns the conversation.' })
+  @IsString()
+  @Length(8, 120)
+  guestId!: string;
+
+  @ApiProperty({ description: 'Message text.' })
+  @IsString()
+  @MinLength(1)
+  @MaxLength(4000)
+  text!: string;
+}
+
+export class GuestIdBodyDto {
+  @ApiProperty()
+  @IsString()
+  @Length(8, 120)
+  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)
+  status!: SupportStatusDto;
+}
+
+export class ListConversationsQueryDto {
+  @ApiPropertyOptional({ enum: SupportStatusDto })
+  @IsOptional()
+  @IsEnum(SupportStatusDto)
+  status?: SupportStatusDto;
+
+  @ApiPropertyOptional({ description: 'Search subject / passenger name.' })
+  @IsOptional()
+  @IsString()
+  search?: string;
+
+  @ApiPropertyOptional({ minimum: 1, default: 1 })
+  @IsOptional()
+  @Type(() => Number)
+  @IsInt()
+  @Min(1)
+  page?: number;
+
+  @ApiPropertyOptional({ minimum: 1, maximum: 100, default: 100 })
+  @IsOptional()
+  @Type(() => Number)
+  @IsInt()
+  @Min(1)
+  @Max(100)
+  limit?: number;
+}
diff --git a/apps/edr-passenger-api/src/modules/support/support.gateway.ts b/apps/edr-passenger-api/src/modules/support/support.gateway.ts
new file mode 100644
index 000000000..c5b65497b
--- /dev/null
+++ b/apps/edr-passenger-api/src/modules/support/support.gateway.ts
@@ -0,0 +1,130 @@
+import { Logger } from '@nestjs/common';
+import {
+  OnGatewayConnection,
+  WebSocketGateway,
+  WebSocketServer,
+} from '@nestjs/websockets';
+import { Server, Socket } from 'socket.io';
+import { Passenger as PassengerTypes } from '@edr/types';
+
+import { WsAuthService } from './ws-auth.service';
+
+/**
+ * Server → client push for passenger support chat. Clients only *listen* (no
+ * `@SubscribeMessage`); the handshake is authenticated in `handleConnection`.
+ * Each socket joins a room based on its side:
+ *  - backoffice staff → the shared `backoffice` room (see every conversation).
+ *  - passengers        → their `user:<iamUserId>` room (their own tickets only).
+ *
+ * Side is decided by the presence of a `Passenger` row for the IAM user id
+ * (staff have none). A message is emitted to BOTH the owner's room and the
+ * backoffice room so the customer thread, the sender's echo, and every agent's
+ * inbox update live.
+ */
+@WebSocketGateway({
+  namespace: PassengerTypes.PASSENGER_SUPPORT_WS_NAMESPACE,
+  cors: { origin: true, credentials: true },
+})
+export class SupportGateway implements OnGatewayConnection {
+  private readonly logger = new Logger(SupportGateway.name);
+
+  private static readonly BACKOFFICE_ROOM = 'backoffice';
+
+  @WebSocketServer()
+  private readonly server!: Server;
+
+  constructor(private readonly wsAuth: WsAuthService) {}
+
+  async handleConnection(socket: Socket): Promise<void> {
+    const userId = await this.wsAuth.resolveUserId(this.extractToken(socket));
+
+    // 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;
+      socket.data.side = 'AGENT';
+      await socket.join(SupportGateway.BACKOFFICE_ROOM);
+      socket.emit('support:hello', {
+        side: 'AGENT',
+        room: SupportGateway.BACKOFFICE_ROOM,
+        userId,
+      });
+      this.logger.debug(`support socket ${socket.id} → AGENT (backoffice)`);
+      return;
+    }
+
+    // Guest: no valid token, but a client-generated guestId scopes the room.
+    // Anyone holding the guestId can see that thread (no account = weaker
+    // ownership) — an accepted MVP trade-off for guest support.
+    const guestId = this.extractGuestId(socket);
+    if (guestId) {
+      socket.data.guestId = guestId;
+      socket.data.side = 'USER';
+      await socket.join(`guest:${guestId}`);
+      return;
+    }
+
+    this.logger.debug(`Rejected passenger-support handshake ${socket.id}`);
+    socket.disconnect(true);
+  }
+
+  /** Push a new message + updated conversation to the owner + backoffice rooms. */
+  emitMessage(
+    ownerRoom: string | null,
+    conversation: PassengerTypes.PassengerSupportConversationDto,
+    message: PassengerTypes.PassengerSupportMessageDto,
+  ): void {
+    const payload = { conversation, message };
+    for (const room of this.targetRooms(ownerRoom)) {
+      const to = this.server.to(room);
+      to.emit(PassengerTypes.PASSENGER_SUPPORT_WS_EVENTS.MESSAGE_NEW, payload);
+      to.emit(
+        PassengerTypes.PASSENGER_SUPPORT_WS_EVENTS.CONVERSATION_UPDATED,
+        conversation,
+      );
+    }
+  }
+
+  /** Push a conversation metadata change (e.g. status) to both rooms. */
+  emitConversationUpdated(
+    ownerRoom: string | null,
+    conversation: PassengerTypes.PassengerSupportConversationDto,
+  ): void {
+    for (const room of this.targetRooms(ownerRoom)) {
+      this.server
+        .to(room)
+        .emit(
+          PassengerTypes.PASSENGER_SUPPORT_WS_EVENTS.CONVERSATION_UPDATED,
+          conversation,
+        );
+    }
+  }
+
+  private targetRooms(ownerRoom: string | null): string[] {
+    const rooms = [SupportGateway.BACKOFFICE_ROOM];
+    if (ownerRoom) rooms.push(ownerRoom);
+    return rooms;
+  }
+
+  private extractGuestId(socket: Socket): string | undefined {
+    const authGuest = socket.handshake.auth?.guestId as string | undefined;
+    if (authGuest) return authGuest;
+    const queryGuest = socket.handshake.query?.guestId;
+    if (typeof queryGuest === 'string') return queryGuest;
+    return undefined;
+  }
+
+  private extractToken(socket: Socket): string | undefined {
+    const authToken = socket.handshake.auth?.token as string | undefined;
+    if (authToken) return authToken;
+
+    const queryToken = socket.handshake.query?.token;
+    if (typeof queryToken === 'string') return queryToken;
+
+    const header = socket.handshake.headers?.authorization;
+    if (header?.startsWith('Bearer ')) return header.slice(7);
+
+    return undefined;
+  }
+}
diff --git a/apps/edr-passenger-api/src/modules/support/support.module.ts b/apps/edr-passenger-api/src/modules/support/support.module.ts
index 17f139a07..136fcf196 100644
--- a/apps/edr-passenger-api/src/modules/support/support.module.ts
+++ b/apps/edr-passenger-api/src/modules/support/support.module.ts
@@ -1,6 +1,17 @@
 import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { Session } from '@tria-plc/iamapi-common/entities/iam/user/session.entity';
+
 import { SupportController } from './support.controller';
 import { SupportService } from './support.service';
+import { SupportGateway } from './support.gateway';
+import { WsAuthService } from './ws-auth.service';
 
-@Module({ controllers: [SupportController], providers: [SupportService] })
+@Module({
+  // Session is served by the app's default TypeORM DataSource (IAM schema) —
+  // used by WsAuthService to authenticate WebSocket handshakes.
+  imports: [TypeOrmModule.forFeature([Session])],
+  controllers: [SupportController],
+  providers: [SupportService, SupportGateway, WsAuthService],
+})
 export class SupportModule {}
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 dd155bff8..77f701bf2 100644
--- a/apps/edr-passenger-api/src/modules/support/support.service.ts
+++ b/apps/edr-passenger-api/src/modules/support/support.service.ts
@@ -1,35 +1,474 @@
-import { Injectable, NotFoundException } from '@nestjs/common';
+import {
+  ForbiddenException,
+  Injectable,
+  NotFoundException,
+} from '@nestjs/common';
+import { Passenger as T } from '@edr/types';
 import { PrismaService } from '../../common/prisma.service';
+import { SupportGateway } from './support.gateway';
+
+type Side = 'USER' | 'AGENT';
+type PrismaSender = 'USER' | 'BOT' | 'AGENT';
+type PrismaStatus = 'OPEN' | 'RESOLVED' | 'CLOSED';
+
+/** Who the caller is on the customer side: an authed passenger or a guest. */
+export interface CustomerOwner {
+  iamUserId?: string | null;
+  guestId?: string | null;
+}
+
+interface ListQuery {
+  status?: PrismaStatus;
+  search?: string;
+  page?: number;
+  limit?: number;
+}
+
+type ConversationRow = {
+  id: string;
+  userId: string | null;
+  guestId: string | null;
+  guestName: string | null;
+  guestEmail: string | null;
+  guestPhone: string | null;
+  passengerId: string | null;
+  passengerName: string | null;
+  subject: string | null;
+  status: PrismaStatus;
+  assignedAgentId: string | null;
+  lastMessageAt: Date | null;
+  lastMessagePreview: string | null;
+  lastMessageSender: PrismaSender | null;
+  userLastReadAt: Date | null;
+  agentLastReadAt: Date | null;
+  createdAt: Date;
+  updatedAt: Date;
+};
 
 @Injectable()
 export class SupportService {
-  constructor(private prisma: PrismaService) {}
+  constructor(
+    private prisma: PrismaService,
+    private gateway: SupportGateway,
+  ) {}
 
-  getFaqCategories() { return this.prisma.faqCategory.findMany({ include: { _count: { select: { articles: true } } } }); }
+  // ---- FAQ (unchanged) ---------------------------------------------------
 
-  getFaqArticles(categoryId: string) { return this.prisma.faqArticle.findMany({ where: { categoryId }, orderBy: { rank: 'asc' } }); }
-
-  startConversation(userId: string) { return this.prisma.supportConversation.create({ data: { userId } }); }
-
-  async sendMessage(conversationId: string, sender: 'USER' | 'BOT' | 'AGENT', text: string) {
-    const conv = await this.prisma.supportConversation.findUnique({ where: { id: conversationId } });
-    if (!conv) throw new NotFoundException('Conversation not found');
-    const message = await this.prisma.supportMessage.create({ data: { conversationId, sender, text } });
-    if (sender === 'USER') await this.prisma.supportMessage.create({ data: { conversationId, sender: 'BOT', text: this.getBotReply(text) } });
-    return message;
+  getFaqCategories() {
+    return this.prisma.faqCategory.findMany({
+      include: { _count: { select: { articles: true } } },
+    });
   }
 
-  async getConversation(conversationId: string) {
-    const conv = await this.prisma.supportConversation.findUnique({ where: { id: conversationId }, include: { messages: { orderBy: { createdAt: 'asc' } } } });
-    if (!conv) throw new NotFoundException('Conversation not found');
-    return conv;
+  getFaqArticles(categoryId: string) {
+    return this.prisma.faqArticle.findMany({
+      where: { categoryId },
+      orderBy: { rank: 'asc' },
+    });
   }
 
-  private getBotReply(text: string): string {
-    const lower = text.toLowerCase();
-    if (lower.includes('cancel') || lower.includes('refund')) return 'To cancel or refund, go to Bookings and select the booking. Refunds are processed within 3-5 business days.';
-    if (lower.includes('miss') || lower.includes('missed')) return 'If you missed your train, please check the Disruptions section for alternative options.';
-    if (lower.includes('seat')) return 'You can select or change seats during booking. Seat changes after confirmation may incur a fee.';
-    return 'Thank you for contacting EDR support. An agent will assist you shortly.';
+  // ---- customer: authed passenger ---------------------------------------
+
+  async createConversation(
+    iamUserId: string,
+    input: { subject: string; initialMessage: string },
+  ): Promise<T.PassengerSupportConversationDto> {
+    const passenger = await this.prisma.passenger.findUnique({
+      where: { iamUserId },
+      include: { user: { select: { fullName: true } } },
+    });
+    const conversation = (await this.prisma.supportConversation.create({
+      data: {
+        userId: iamUserId,
+        passengerId: passenger?.id ?? null,
+        passengerName: passenger?.user?.fullName ?? null,
+        subject: input.subject,
+        status: 'OPEN',
+      },
+    })) as ConversationRow;
+    return this.firstMessage(conversation, input.initialMessage);
+  }
+
+  // ---- customer: guest (unauthenticated) --------------------------------
+
+  async createGuestConversation(input: {
+    guestId: string;
+    name: string;
+    email: string;
+    phone?: string;
+    subject: string;
+    initialMessage: string;
+  }): Promise<T.PassengerSupportConversationDto> {
+    const conversation = (await this.prisma.supportConversation.create({
+      data: {
+        guestId: input.guestId,
+        guestName: input.name,
+        guestEmail: input.email,
+        guestPhone: input.phone ?? null,
+        passengerName: input.name, // uniform display name for the agent inbox
+        subject: input.subject,
+        status: 'OPEN',
+      },
+    })) as ConversationRow;
+    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,
+  ): Promise<T.PassengerSupportConversationListResult> {
+    const scope = this.ownerScope(owner);
+    const where = { ...this.listWhere(query), ...scope };
+    const rows = (await this.prisma.supportConversation.findMany({
+      where,
+      orderBy: [{ lastMessageAt: 'desc' }, { createdAt: 'desc' }],
+      take: query.limit ?? 100,
+      skip: ((query.page ?? 1) - 1) * (query.limit ?? 100),
+    })) as ConversationRow[];
+    const count = await this.prisma.supportConversation.count({ where });
+    return this.buildListResult(rows, count, 'USER');
+  }
+
+  // ---- agent (backoffice) ------------------------------------------------
+
+  async listForAgents(
+    query: ListQuery,
+  ): Promise<T.PassengerSupportConversationListResult> {
+    const where = this.listWhere(query);
+    const rows = (await this.prisma.supportConversation.findMany({
+      where,
+      orderBy: [{ lastMessageAt: 'desc' }, { createdAt: 'desc' }],
+      take: query.limit ?? 100,
+      skip: ((query.page ?? 1) - 1) * (query.limit ?? 100),
+    })) as ConversationRow[];
+    const count = await this.prisma.supportConversation.count({ where });
+    return this.buildListResult(rows, count, 'AGENT');
+  }
+
+  async setStatus(
+    conversationId: string,
+    status: PrismaStatus,
+  ): Promise<T.PassengerSupportConversationDto> {
+    await this.requireConversation(conversationId);
+    const updated = (await this.prisma.supportConversation.update({
+      where: { id: conversationId },
+      data: { status },
+    })) as ConversationRow;
+    const dto = this.toConversationDto(updated, 0);
+    this.gateway.emitConversationUpdated(this.ownerRoom(updated), dto);
+    return dto;
+  }
+
+  // ---- shared ------------------------------------------------------------
+
+  async getMessages(
+    conversationId: string,
+    asCustomer?: CustomerOwner,
+  ): Promise<T.PassengerSupportMessageDto[]> {
+    const conversation = await this.requireConversation(conversationId);
+    if (asCustomer) this.assertOwns(conversation, asCustomer);
+    const rows = await this.prisma.supportMessage.findMany({
+      where: { conversationId },
+      orderBy: { createdAt: 'asc' },
+    });
+    return rows.map((m) => this.toMessageDto(m));
+  }
+
+  async sendMessage(
+    conversationId: string,
+    sender: Side,
+    text: string,
+    asCustomer?: CustomerOwner,
+  ): Promise<T.PassengerSupportMessageDto> {
+    const conversation = await this.requireConversation(conversationId);
+    if (sender === 'USER') {
+      this.assertOwns(conversation, asCustomer ?? {});
+    }
+    const updated = await this.appendMessage(conversation, sender, text);
+    const last = updated.messages[updated.messages.length - 1];
+    return this.toMessageDto(last);
+  }
+
+  async markRead(
+    conversationId: string,
+    side: Side,
+    asCustomer?: CustomerOwner,
+  ): Promise<{ unreadCount: number }> {
+    const conversation = await this.requireConversation(conversationId);
+    if (side === 'USER') {
+      this.assertOwns(conversation, asCustomer ?? {});
+      await this.prisma.supportConversation.update({
+        where: { id: conversationId },
+        data: { userLastReadAt: new Date() },
+      });
+      return this.unreadCount('USER', asCustomer);
+    }
+    await this.prisma.supportConversation.update({
+      where: { id: conversationId },
+      data: { agentLastReadAt: new Date() },
+    });
+    return this.unreadCount('AGENT');
+  }
+
+  async unreadCount(
+    side: Side,
+    owner?: CustomerOwner,
+  ): Promise<{ unreadCount: number }> {
+    const rows = (await this.prisma.supportConversation.findMany({
+      where: side === 'USER' ? this.ownerScope(owner ?? {}) : {},
+      select: { id: true, userLastReadAt: true, agentLastReadAt: true },
+    })) as Array<{
+      id: string;
+      userLastReadAt: Date | null;
+      agentLastReadAt: Date | null;
+    }>;
+    const map = await this.computeUnread(rows, side);
+    let unreadCount = 0;
+    for (const n of map.values()) if (n > 0) unreadCount++;
+    return { unreadCount };
+  }
+
+  // ---- internals ---------------------------------------------------------
+
+  private async firstMessage(
+    conversation: ConversationRow,
+    text: string,
+  ): Promise<T.PassengerSupportConversationDto> {
+    const { conversation: updated } = await this.appendMessageRaw(
+      conversation,
+      'USER',
+      text,
+    );
+    return this.toConversationDto(updated, 0);
+  }
+
+  private async appendMessage(
+    conversation: ConversationRow,
+    sender: PrismaSender,
+    text: string,
+  ) {
+    const { conversation: updated } = await this.appendMessageRaw(
+      conversation,
+      sender,
+      text,
+    );
+    return updated as ConversationRow & { messages: any[] };
+  }
+
+  /** Persist a message, bump the conversation's denormalized fields, emit live. */
+  private async appendMessageRaw(
+    conversation: ConversationRow,
+    sender: PrismaSender,
+    text: string,
+  ): Promise<{ conversation: ConversationRow & { messages: any[] }; message: any }> {
+    const message = await this.prisma.supportMessage.create({
+      data: { conversationId: conversation.id, sender, text },
+    });
+    const updated = (await this.prisma.supportConversation.update({
+      where: { id: conversation.id },
+      data: {
+        lastMessageAt: message.createdAt,
+        lastMessagePreview: text.slice(0, 280),
+        lastMessageSender: sender,
+      },
+      include: { messages: { orderBy: { createdAt: 'asc' } } },
+    })) as ConversationRow & { messages: any[] };
+
+    const dto = this.toConversationDto(updated, 0);
+    this.gateway.emitMessage(this.ownerRoom(updated), dto, this.toMessageDto(message));
+    return { conversation: updated, message };
+  }
+
+  private async buildListResult(
+    rows: ConversationRow[],
+    count: number,
+    side: Side,
+  ): Promise<T.PassengerSupportConversationListResult> {
+    const unreadMap = await this.computeUnread(rows, side);
+    const items = rows.map((r) =>
+      this.toConversationDto(r, unreadMap.get(r.id) ?? 0),
+    );
+    let unreadCount = 0;
+    for (const n of unreadMap.values()) if (n > 0) unreadCount++;
+    return { items, count, unreadCount };
+  }
+
+  private async computeUnread(
+    rows: Array<{
+      id: string;
+      userLastReadAt: Date | null;
+      agentLastReadAt: Date | null;
+    }>,
+    side: Side,
+  ): Promise<Map<string, number>> {
+    const map = new Map<string, number>();
+    if (rows.length === 0) return map;
+    const otherSender: PrismaSender = side === 'USER' ? 'AGENT' : 'USER';
+    const ids = rows.map((r) => r.id);
+    const msgs = await this.prisma.supportMessage.findMany({
+      where: { conversationId: { in: ids }, sender: otherSender },
+      select: { conversationId: true, createdAt: true },
+    });
+    const cursorById = new Map(
+      rows.map((r) => [
+        r.id,
+        side === 'USER' ? r.userLastReadAt : r.agentLastReadAt,
+      ]),
+    );
+    for (const m of msgs) {
+      const cursor = cursorById.get(m.conversationId) ?? null;
+      if (!cursor || m.createdAt > cursor) {
+        map.set(m.conversationId, (map.get(m.conversationId) ?? 0) + 1);
+      }
+    }
+    return map;
+  }
+
+  private listWhere(query: ListQuery) {
+    const where: Record<string, unknown> = {};
+    if (query.status) where.status = query.status;
+    if (query.search?.trim()) {
+      const contains = query.search.trim();
+      where.OR = [
+        { subject: { contains, mode: 'insensitive' } },
+        { passengerName: { contains, mode: 'insensitive' } },
+        { guestEmail: { contains, mode: 'insensitive' } },
+      ];
+    }
+    return where;
+  }
+
+  /** Prisma where-fragment scoping to the calling customer (authed or guest). */
+  private ownerScope(owner: CustomerOwner): Record<string, unknown> {
+    if (owner.iamUserId) return { userId: owner.iamUserId };
+    if (owner.guestId) return { guestId: owner.guestId };
+    // No identity ⇒ match nothing.
+    return { id: '__none__' };
+  }
+
+  private assertOwns(conversation: ConversationRow, owner: CustomerOwner): void {
+    const ok =
+      (owner.iamUserId && conversation.userId === owner.iamUserId) ||
+      (owner.guestId && conversation.guestId === owner.guestId);
+    if (!ok) {
+      throw new ForbiddenException('This conversation belongs to someone else.');
+    }
+  }
+
+  private ownerRoom(c: ConversationRow): string | null {
+    if (c.guestId) return `guest:${c.guestId}`;
+    if (c.userId) return `user:${c.userId}`;
+    return null;
+  }
+
+  private async requireConversation(id: string): Promise<ConversationRow> {
+    const conversation = (await this.prisma.supportConversation.findUnique({
+      where: { id },
+    })) as ConversationRow | null;
+    if (!conversation) throw new NotFoundException('Conversation not found');
+    return conversation;
+  }
+
+  private toConversationDto(
+    c: ConversationRow,
+    unreadCount: number,
+  ): T.PassengerSupportConversationDto {
+    return {
+      id: c.id,
+      userId: c.userId,
+      guestId: c.guestId,
+      guestEmail: c.guestEmail,
+      guestPhone: c.guestPhone,
+      passengerId: c.passengerId,
+      passengerName: c.passengerName ?? c.guestName ?? null,
+      subject: c.subject,
+      status: c.status as T.PassengerSupportStatus,
+      assignedAgentId: c.assignedAgentId,
+      lastMessageAt: c.lastMessageAt ? c.lastMessageAt.toISOString() : null,
+      lastMessagePreview: c.lastMessagePreview,
+      lastMessageSender: this.toDtoSender(c.lastMessageSender),
+      unreadCount,
+      createdAt: c.createdAt.toISOString(),
+      updatedAt: c.updatedAt.toISOString(),
+    };
+  }
+
+  private toMessageDto(m: {
+    id: string;
+    conversationId: string;
+    sender: PrismaSender;
+    text: string;
+    createdAt: Date;
+  }): T.PassengerSupportMessageDto {
+    return {
+      id: m.id,
+      conversationId: m.conversationId,
+      sender: this.toDtoSender(m.sender) ?? T.PassengerSupportSender.AGENT,
+      text: m.text,
+      createdAt: m.createdAt.toISOString(),
+    };
+  }
+
+  /** Legacy BOT messages are surfaced as AGENT to the UI. */
+  private toDtoSender(s: PrismaSender | null): T.PassengerSupportSender | null {
+    if (!s) return null;
+    return s === 'USER'
+      ? T.PassengerSupportSender.USER
+      : T.PassengerSupportSender.AGENT;
   }
 }
diff --git a/apps/edr-passenger-api/src/modules/support/ws-auth.service.ts b/apps/edr-passenger-api/src/modules/support/ws-auth.service.ts
new file mode 100644
index 000000000..2b1ad8b6b
--- /dev/null
+++ b/apps/edr-passenger-api/src/modules/support/ws-auth.service.ts
@@ -0,0 +1,48 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+
+import { verifyToken } from '@tria-plc/api-common/utils/token';
+import { ESessionStatus } from '@tria-plc/api-common/utils/enums/user.enum';
+import { Session } from '@tria-plc/iamapi-common/entities/iam/user/session.entity';
+
+/**
+ * Authenticates a WebSocket handshake by mirroring the HTTP JwtGuard: the access
+ * token payload is only a *session* pointer (`{ id: <sessionId> }`), not the
+ * user — so we verify the signature (`verifyToken`), then load the IAM session
+ * and require it to be ACTIVE and unexpired, and read the real user id out of
+ * `session.userInfo`. The `Session` entity is served by the app's default
+ * TypeORM DataSource (the same one the shared JwtGuard queries for `iam.sessions`).
+ *
+ * Returns the IAM user id, or null for any invalid/expired/revoked/malformed token.
+ */
+@Injectable()
+export class WsAuthService {
+  private readonly logger = new Logger(WsAuthService.name);
+
+  constructor(
+    @InjectRepository(Session)
+    private readonly sessions: Repository<Session>,
+  ) {}
+
+  async resolveUserId(token?: string): Promise<string | null> {
+    if (!token) return null;
+    try {
+      const payload = verifyToken(token) as { id?: string };
+      const sessionId = payload?.id;
+      if (!sessionId) return null;
+
+      const session = await this.sessions.findOne({ where: { id: sessionId } });
+      if (!session) return null;
+      if (session.status !== ESessionStatus.ACTIVE) return null;
+      if (!session.expiryTime || new Date(session.expiryTime) <= new Date()) {
+        return null;
+      }
+
+      return session.userInfo?.id ?? null;
+    } catch (err) {
+      this.logger.debug(`WS auth rejected: ${(err as Error).message}`);
+      return null;
+    }
+  }
+}
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-api/src/modules/tickets/tickets.service.ts b/apps/edr-passenger-api/src/modules/tickets/tickets.service.ts
index e482189d2..4a1f7b36e 100644
--- a/apps/edr-passenger-api/src/modules/tickets/tickets.service.ts
+++ b/apps/edr-passenger-api/src/modules/tickets/tickets.service.ts
@@ -258,8 +258,8 @@ export class TicketsService {
         type: booking.bookingType,
         passenger: passengerName,
         seats: passengerSeats.map(ps => ({
-          seat: ps.seat.seatNumber,
-          coach: ps.seat.coach.number,
+          seat: ps.seat?.seatNumber,
+          coach: ps.seat?.coach?.number,
           leg: ps.leg || 1,
           scheduleId: ps.scheduleId || booking.scheduleId,
         })),
diff --git a/apps/edr-passenger-web/backoffice/package.json b/apps/edr-passenger-web/backoffice/package.json
index 654e19ef9..858fcd781 100644
--- a/apps/edr-passenger-web/backoffice/package.json
+++ b/apps/edr-passenger-web/backoffice/package.json
@@ -21,6 +21,7 @@
     "react": "^18.3.1",
     "react-dom": "^18.3.1",
     "recharts": "^2.12.0",
+    "socket.io-client": "^4.8.3",
     "zustand": "^5.0.0"
   },
   "devDependencies": {
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/bookings/page.tsx b/apps/edr-passenger-web/backoffice/src/app/bookings/page.tsx
index be2785d43..1642f0a14 100644
--- a/apps/edr-passenger-web/backoffice/src/app/bookings/page.tsx
+++ b/apps/edr-passenger-web/backoffice/src/app/bookings/page.tsx
@@ -2,7 +2,7 @@
 
 import { useState } from 'react';
 import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
-import { Download, Eye, Trash2 } from 'lucide-react';
+import { Download, Eye, Trash2, Ticket } from 'lucide-react';
 import DataTable from '@/components/ui/DataTable';
 import Badge from '@/components/ui/Badge';
 import Pagination from '@/components/ui/Pagination';
@@ -35,6 +35,8 @@ function BookingsPageContent() {
   const [extraFilters, setExtraFilters] = useState({ bookingType: '', dateFrom: '', dateTo: '', paymentStatus: '' });
   const [showExtraFilters, setShowExtraFilters] = useState(false);
   const [selectedBooking, setSelectedBooking] = useState<any>(null);
+  const [generateTicketBooking, setGenerateTicketBooking] = useState<any>(null);
+  const [generateTicketForm, setGenerateTicketForm] = useState({ paymentReference: '', paymentMethod: '', notes: '' });
   const [deleteConfirmOpen, setDeleteConfirmOpen] = useState(false);
   const [bookingToDelete, setBookingToDelete] = useState<any>(null);
   const [deleteError, setDeleteError] = useState<string | null>(null);
@@ -63,6 +65,19 @@ function BookingsPageContent() {
     }),
   });
 
+  const forceConfirmMutation = useMutation({
+    mutationFn: ({ bookingId, data }: { bookingId: string; data: { paymentReference?: string; paymentMethod?: string; notes?: string } }) =>
+      bookingsApi.forceConfirm(bookingId, data),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ['bookings'] });
+      setSuccessMessage('Payment confirmed and ticket generated successfully');
+      setTimeout(() => setSuccessMessage(''), 4000);
+      setSelectedBooking(null);
+      setGenerateTicketBooking(null);
+      setGenerateTicketForm({ paymentReference: '', paymentMethod: '', notes: '' });
+    },
+  });
+
   const deleteMutation = useMutation({
     mutationFn: ({ id, cascade }: { id: string; cascade?: boolean }) => apiClient.delete(`/bookings/${id}${cascade ? '?cascade=true' : ''}`),
     onSuccess: () => {
@@ -258,6 +273,7 @@ function BookingsPageContent() {
 
   const actions = [
     { label: 'View Details', onClick: (b: any) => setSelectedBooking(b), variant: 'secondary' as const, icon: Eye },
+    { label: 'Generate Ticket', onClick: (b: any) => { setGenerateTicketForm({ paymentReference: '', paymentMethod: '', notes: '' }); setGenerateTicketBooking(b); }, variant: 'secondary' as const, icon: Ticket, show: (b: any) => !(b.status === 'CONFIRMED' && b.paymentIntent?.status === 'SUCCEEDED') },
     { label: 'Delete', onClick: (b: any) => { setDeleteError(null); setDeleteCascade(false); setDeleteCascadeChecked(false); setBookingToDelete(b); setDeleteConfirmOpen(true); }, variant: 'danger' as const, icon: Trash2 },
   ];
 
@@ -448,6 +464,25 @@ function BookingsPageContent() {
                     <Field label="Display Currency" value={b.displayCurrency || b.currency || 'ETB'} />
                     <Field label="Payment ID" value={b.paymentIntent?.id || '—'} mono truncate />
                   </div>
+                  {b.paymentIntent?.status !== 'SUCCEEDED' && canManage && (
+                    <div className="mt-3 p-3 rounded-lg border border-amber-200 dark:border-amber-800 bg-amber-50 dark:bg-amber-900/20">
+                      <p className="text-xs text-amber-700 dark:text-amber-400 mb-2">
+                        Payment not confirmed by vendor. If you have verified the payment was completed externally, force-confirm to confirm the booking and generate the ticket.
+                      </p>
+                      <ActionButton
+                        variant="secondary"
+                        onClick={() => forceConfirmMutation.mutate({ bookingId: b.id, data: {} })}
+                        disabled={forceConfirmMutation.isPending}
+                      >
+                        {forceConfirmMutation.isPending ? 'Confirming…' : 'Force Confirm & Generate Ticket'}
+                      </ActionButton>
+                      {forceConfirmMutation.isError && (
+                        <p className="text-xs text-red-600 dark:text-red-400 mt-2">
+                          {(() => { const e = forceConfirmMutation.error as any; const m = e?.response?.data?.message; return Array.isArray(m) ? m.join(', ') : m || e?.message || 'Failed to confirm payment'; })()}
+                        </p>
+                      )}
+                    </div>
+                  )}
                 </section>
 
                 {/* Seats / Passengers */}
@@ -517,6 +552,93 @@ function BookingsPageContent() {
         onCascadeChange={(checked) => setDeleteCascadeChecked(checked)}
       />
 
+      {/* Generate Ticket Modal */}
+      <Modal
+        isOpen={!!generateTicketBooking}
+        onClose={() => { setGenerateTicketBooking(null); setGenerateTicketForm({ paymentReference: '', paymentMethod: '', notes: '' }); forceConfirmMutation.reset(); }}
+        title="Generate Ticket"
+        size="md"
+      >
+        {generateTicketBooking && (
+          <div className="space-y-4">
+            <div className="-mx-6 -mt-4 mb-4 px-6 py-4 bg-muted/40 border-b border-muted">
+              <p className="text-xs text-muted-foreground">Booking</p>
+              <p className="font-mono font-bold text-lg">{generateTicketBooking.bookingRef}</p>
+              <p className="text-sm text-muted-foreground">
+                {generateTicketBooking.schedule?.originStation?.name} → {generateTicketBooking.schedule?.destinationStation?.name}
+              </p>
+            </div>
+
+            <div>
+              <label className="label">Payment Reference / Transaction ID</label>
+              <input
+                type="text"
+                className="input"
+                placeholder="e.g. TXN-123456 or vendor receipt number"
+                value={generateTicketForm.paymentReference}
+                onChange={(e) => setGenerateTicketForm(f => ({ ...f, paymentReference: e.target.value }))}
+              />
+            </div>
+
+            <div>
+              <label className="label">Payment Method</label>
+              <select
+                className="input"
+                value={generateTicketForm.paymentMethod}
+                onChange={(e) => setGenerateTicketForm(f => ({ ...f, paymentMethod: e.target.value }))}
+              >
+                <option value="">Select method…</option>
+                <option value="TELEBIRR">Telebirr</option>
+                <option value="CBE_BIRR">CBE Birr</option>
+                <option value="EBIRR">eBirr</option>
+                <option value="WAAFI">Waafi</option>
+                <option value="DMONEY">dMoney</option>
+                <option value="CARD">Card</option>
+                <option value="WALLET">Wallet</option>
+              </select>
+            </div>
+
+            <div>
+              <label className="label">Notes <span className="text-muted-foreground font-normal">(optional)</span></label>
+              <textarea
+                className="input min-h-[72px] resize-none"
+                placeholder="e.g. Customer paid at counter, receipt #123"
+                value={generateTicketForm.notes}
+                onChange={(e) => setGenerateTicketForm(f => ({ ...f, notes: e.target.value }))}
+              />
+            </div>
+
+            {forceConfirmMutation.isError && (
+              <div className="rounded-lg bg-red-50 dark:bg-red-900/20 border border-red-200 dark:border-red-800 p-3 text-sm text-red-700 dark:text-red-400">
+                {(() => { const e = forceConfirmMutation.error as any; const m = e?.response?.data?.message; return Array.isArray(m) ? m.join(', ') : m || e?.message || 'Failed to confirm payment'; })()}
+              </div>
+            )}
+
+            <div className="flex justify-end gap-2 pt-2 border-t border-muted">
+              <ActionButton
+                variant="secondary"
+                onClick={() => { setGenerateTicketBooking(null); setGenerateTicketForm({ paymentReference: '', paymentMethod: '', notes: '' }); forceConfirmMutation.reset(); }}
+              >
+                Cancel
+              </ActionButton>
+              <ActionButton
+                onClick={() => forceConfirmMutation.mutate({
+                  bookingId: generateTicketBooking.id,
+                  data: {
+                    paymentReference: generateTicketForm.paymentReference || undefined,
+                    paymentMethod: generateTicketForm.paymentMethod || undefined,
+                    notes: generateTicketForm.notes || undefined,
+                  },
+                })}
+                disabled={forceConfirmMutation.isPending}
+              >
+                {forceConfirmMutation.isPending ? 'Generating…' : 'Confirm & Generate Ticket'}
+              </ActionButton>
+            </div>
+          </div>
+        )}
+      </Modal>
+
       <Modal isOpen={exportModalOpen} onClose={() => setExportModalOpen(false)} title="Export Bookings" size="md">
         <div className="space-y-4">
           <div className="grid grid-cols-2 gap-4">
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..c6d9af92b 100644
--- a/apps/edr-passenger-web/backoffice/src/app/classes/page.tsx
+++ b/apps/edr-passenger-web/backoffice/src/app/classes/page.tsx
@@ -311,41 +311,25 @@ 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>
+                <p>Total = (Base Fare × Distance) + Insurance</p>
+                <p className="mt-2 text-xs">• Insurance applies per passenger</p>
               </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/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 e6fc3c2e0..413383b7a 100644
--- a/apps/edr-passenger-web/backoffice/src/app/seats/page.tsx
+++ b/apps/edr-passenger-web/backoffice/src/app/seats/page.tsx
@@ -2,13 +2,16 @@
 
 import { useState } from 'react';
 import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query'
-import { seatsApi, schedulesApi, fleetApi } from '@/lib/api';
+import { seatsApi, schedulesApi, fleetApi, routeCoachTemplatesApi } from '@/lib/api';
+import { routesApi } from '@/lib/api/routes';
 import Modal from '@/components/ui/Modal';
 import ActionButton from '@/components/ui/ActionButton'
 import { Armchair, Lock, Unlock, Bed, X, RotateCcw, ChevronDown, Train, Wrench } from 'lucide-react';
 
 export default function SeatsPage() {
+  const [activeTab, setActiveTab] = useState<'route' | 'schedule'>('route');
   const [selectedSchedule, setSelectedSchedule] = useState('');
+  const [selectedRoute, setSelectedRoute] = useState('');
   const [expandedCoaches, setExpandedCoaches] = useState<Set<string>>(new Set());
   const [showBlockModal, setShowBlockModal] = useState(false);
   const [showRemoveModal, setShowRemoveModal] = useState(false);
@@ -39,6 +42,43 @@ export default function SeatsPage() {
     queryFn: () => fleetApi.getCoaches(),
   });
 
+  const { data: routesData } = useQuery({
+    queryKey: ['routes'],
+    queryFn: () => routesApi.getAll(),
+  });
+
+  const { data: routeCoachesData, isLoading: routeCoachesLoading } = useQuery({
+    queryKey: ['routeCoaches', selectedRoute],
+    queryFn: async () => {
+      if (!selectedRoute) return null;
+      const template: any[] = await routeCoachTemplatesApi.get(selectedRoute);
+      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 ?? coach.coachNumber,
+        positionNumber: coach.positionNumber ?? i + 1,
+        seatArrangement: coach.arrangement ?? coach.seatArrangement,
+      }));
+    },
+    enabled: !!selectedRoute,
+  });
+
   const blockMutation = useMutation({
     mutationFn: ({ seatId, reason }: any) => seatsApi.block(seatId, { reason }),
     onSuccess: () => {
@@ -89,7 +129,8 @@ export default function SeatsPage() {
   });
 
   const schedules = schedulesData?.items || schedulesData?.data || [];
-  const coaches = seatMapData?.coaches || [];
+  const routes = routesData?.items || routesData?.data || [];
+  const coaches = activeTab === 'schedule' ? (seatMapData?.coaches || []) : (Array.isArray(routeCoachesData) ? routeCoachesData : []);
 
   const blockCoachMutation = useMutation({
     mutationFn: async ({ coachId, reason }: any) => {
@@ -464,6 +505,9 @@ export default function SeatsPage() {
       return seqA - seqB;
     });
 
+  const activeSelection = activeTab === 'schedule' ? selectedSchedule : selectedRoute;
+  const isLoadingData = activeTab === 'schedule' ? isLoading : routeCoachesLoading;
+
   return (
     <div className="space-y-6">
       <div>
@@ -471,31 +515,62 @@ export default function SeatsPage() {
         <p className="text-muted-foreground mt-1">View and manage seats by coach</p>
       </div>
 
-      {!selectedSchedule ? (
+      {/* Tab switcher */}
+      <div className="flex gap-1 p-1 bg-muted rounded-lg w-fit">
+        
+        <button
+          onClick={() => setActiveTab('route')}
+          className={`px-4 py-2 rounded-md text-sm font-medium transition-colors ${
+            activeTab === 'route'
+              ? 'bg-background text-foreground shadow-sm'
+              : 'text-muted-foreground hover:text-foreground'
+          }`}
+        >
+          By Route
+        </button>
+        <button
+          onClick={() => setActiveTab('schedule')}
+          className={`px-4 py-2 rounded-md text-sm font-medium transition-colors ${
+            activeTab === 'schedule'
+              ? 'bg-background text-foreground shadow-sm'
+              : 'text-muted-foreground hover:text-foreground'
+          }`}
+        >
+          By Schedule
+        </button>
+      </div>
+
+      {!activeSelection ? (
         <div className="card">
-          <label className="label">Select Schedule</label>
-          <select
-            value={selectedSchedule}
-            onChange={(e) => setSelectedSchedule(e.target.value)}
-            className="input"
-          >
-            <option value="">Select a schedule...</option>
-            {schedules.map((schedule: any) => {              
-              const routeName = schedule.route?.name || 'N/A';
-              const date = schedule.departureAt ? new Date(schedule.departureAt).toLocaleDateString() : 'N/A';
-              return (
-                <option key={schedule.id} value={schedule.id}>
-                  {date} - {routeName}
-                </option>
-              );
-            })}
-          </select>
+          {activeTab === 'schedule' ? (
+            <>
+              <label className="label">Select Schedule</label>
+              <select value={selectedSchedule} onChange={(e) => setSelectedSchedule(e.target.value)} className="input">
+                <option value="">Select a schedule...</option>
+                {schedules.map((schedule: any) => {
+                  const routeName = schedule.route?.name || 'N/A';
+                  const date = schedule.departureAt ? new Date(schedule.departureAt).toLocaleDateString() : 'N/A';
+                  return <option key={schedule.id} value={schedule.id}>{date} - {routeName}</option>;
+                })}
+              </select>
+            </>
+          ) : (
+            <>
+              <label className="label">Select Route</label>
+              <select value={selectedRoute} onChange={(e) => setSelectedRoute(e.target.value)} className="input">
+                <option value="">Select a route...</option>
+                {routes.map((route: any) => (
+                  <option key={route.id} value={route.id}>{route.name}</option>
+                ))}
+              </select>
+            </>
+          )}
           <div className="text-center py-12 text-muted-foreground mt-8">
             <Armchair className="h-12 w-12 mx-auto mb-3 opacity-50" />
-            <p>Select a schedule to view seat map</p>
+            <p>Select a {activeTab === 'schedule' ? 'schedule' : 'route'} to view seat map</p>
           </div>
         </div>
-      ) : isLoading ? (
+      ) : isLoadingData ? (
         <div className="card text-center py-12">
           <div className="animate-spin rounded-full h-8 w-8 border-b-2 border-primary mx-auto"></div>
           <p className="text-muted-foreground mt-3">Loading seats...</p>
@@ -503,51 +578,63 @@ export default function SeatsPage() {
       ) : coachesWithSeats.length === 0 ? (
         <div className="space-y-6">
           <div className="card">
-            <label className="label">Select Schedule</label>
-            <select
-              value={selectedSchedule}
-              onChange={(e) => setSelectedSchedule(e.target.value)}
-              className="input"
-            >
-              <option value="">Select a schedule...</option>
-              {schedules.map((schedule: any) => {
-                const trainNumber = schedule.train?.trainNumber || schedule.train?.name || 'N/A';
-                const routeName = schedule.route?.name || 'N/A';
-                const date = schedule.departureAt ? new Date(schedule.departureAt).toLocaleDateString() : 'N/A';
-                return (
-                  <option key={schedule.id} value={schedule.id}>
-                    {trainNumber} - {routeName} - {date}
-                  </option>
-                );
-              })}
-            </select>
+            {activeTab === 'schedule' ? (
+              <>
+                <label className="label">Select Schedule</label>
+                <select value={selectedSchedule} onChange={(e) => setSelectedSchedule(e.target.value)} className="input">
+                  <option value="">Select a schedule...</option>
+                  {schedules.map((schedule: any) => {
+                    const trainNumber = schedule.train?.trainNumber || schedule.train?.name || 'N/A';
+                    const routeName = schedule.route?.name || 'N/A';
+                    const date = schedule.departureAt ? new Date(schedule.departureAt).toLocaleDateString() : 'N/A';
+                    return <option key={schedule.id} value={schedule.id}>{trainNumber} - {routeName} - {date}</option>;
+                  })}
+                </select>
+              </>
+            ) : (
+              <>
+                <label className="label">Select Route</label>
+                <select value={selectedRoute} onChange={(e) => setSelectedRoute(e.target.value)} className="input">
+                  <option value="">Select a route...</option>
+                  {routes.map((route: any) => (
+                    <option key={route.id} value={route.id}>{route.name}</option>
+                  ))}
+                </select>
+              </>
+            )}
           </div>
           <div className="card text-center py-12 text-muted-foreground">
-            <p>No coaches with seats found for this schedule</p>
+            <p>No coaches with seats found for this {activeTab === 'schedule' ? 'schedule' : 'route'}</p>
           </div>
         </div>
       ) : (
         <div className="grid grid-cols-1 lg:grid-cols-2 gap-6">
           <div className="card h-fit sticky top-6 space-y-6">
             <div>
-              <label className="label">Select Schedule</label>
-              <select
-                value={selectedSchedule}
-                onChange={(e) => setSelectedSchedule(e.target.value)}
-                className="input"
-              >
-                <option value="">Select a schedule...</option>
-                {schedules.map((schedule: any) => {
-                  const trainNumber = schedule.train?.trainNumber || schedule.train?.name || 'N/A';
-                  const routeName = schedule.route?.name || 'N/A';
-                  const date = schedule.departureAt ? new Date(schedule.departureAt).toLocaleDateString() : 'N/A';
-                  return (
-                    <option key={schedule.id} value={schedule.id}>
-                      {trainNumber} - {routeName} - {date}
-                    </option>
-                  );
-                })}
-              </select>
+              {activeTab === 'schedule' ? (
+                <>
+                  <label className="label">Select Schedule</label>
+                  <select value={selectedSchedule} onChange={(e) => setSelectedSchedule(e.target.value)} className="input">
+                    <option value="">Select a schedule...</option>
+                    {schedules.map((schedule: any) => {
+                      const trainNumber = schedule.train?.trainNumber || schedule.train?.name || 'N/A';
+                      const routeName = schedule.route?.name || 'N/A';
+                      const date = schedule.departureAt ? new Date(schedule.departureAt).toLocaleDateString() : 'N/A';
+                      return <option key={schedule.id} value={schedule.id}>{trainNumber} - {routeName} - {date}</option>;
+                    })}
+                  </select>
+                </>
+              ) : (
+                <>
+                  <label className="label">Select Route</label>
+                  <select value={selectedRoute} onChange={(e) => setSelectedRoute(e.target.value)} className="input">
+                    <option value="">Select a route...</option>
+                    {routes.map((route: any) => (
+                      <option key={route.id} value={route.id}>{route.name}</option>
+                    ))}
+                  </select>
+                </>
+              )}
             </div>
 
             <div className="space-y-3 pt-4 border-t border-gray-200 dark:border-gray-700">
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 d6ad8fb38..246a6f4f9 100644
--- a/apps/edr-passenger-web/backoffice/src/app/support/page.tsx
+++ b/apps/edr-passenger-web/backoffice/src/app/support/page.tsx
@@ -1,66 +1,362 @@
 'use client';
 
-import { useState } from 'react';
-import { useQuery } from '@tanstack/react-query';
-import { Download } from 'lucide-react';
-import DataTable from '@/components/ui/DataTable';
-import Badge from '@/components/ui/Badge';
-import ActionButton from '@/components/ui/ActionButton';
-import { supportApi } from '@/lib/api';
-import { formatDateTime, formatCurrency } from '@/lib/utils';
+import { Passenger } from '@edr/types';
+import { Headset, Search, Send, User } from 'lucide-react';
+import { useEffect, useMemo, useRef, useState } from 'react';
+
+import {
+  useConversations,
+  useMarkRead,
+  useMessages,
+  useSendMessage,
+  useSetStatus,
+} from '@/features/support/useSupport';
+import { useSupportSocket } from '@/features/support/useSupportSocket';
+
+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',
+};
+
+const FILTERS = ['ALL', 'OPEN', 'RESOLVED', 'CLOSED'] as const;
+
+function formatTime(iso?: string | null): string {
+  if (!iso) return '';
+  const d = new Date(iso);
+  const now = new Date();
+  return d.toDateString() === now.toDateString()
+    ? d.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' })
+    : d.toLocaleDateString([], { month: 'short', day: 'numeric' });
+}
 
 export default function SupportPage() {
-  const [filters, setFilters] = useState({ search: '', status: '' });
+  const [status, setStatus] = useState<(typeof FILTERS)[number]>('ALL');
+  const [search, setSearch] = useState('');
+  const [selectedId, setSelectedId] = useState<string | null>(null);
 
-  const { data, isLoading } = useQuery({
-    queryKey: ['support', filters],
-    queryFn: () => supportApi.getConversations(filters),
-  });
+  const { data, isLoading } = useConversations(
+    status === 'ALL' ? { search } : { status, search },
+  );
+  const items = useMemo(() => data?.items ?? [], [data?.items]);
 
-  const columns = [
-      { key: 'subject', label: 'Subject', render: (conv: any) => conv.subject || 'No Subject' },
-      { key: 'passenger', label: 'Passenger', render: (conv: any) => conv.passenger?.fullName || 'N/A' },
-      { key: 'status', label: 'Status', render: (conv: any) => <Badge variant="status" status={conv.status}>{conv.status}</Badge> },
-      { key: 'createdAt', label: 'Created', render: (conv: any) => formatDateTime(conv.createdAt) },
-    ];
+  useSupportSocket(true);
+
+  const selected = useMemo(
+    () => items.find((c) => c.id === selectedId) ?? null,
+    [items, selectedId],
+  );
 
   return (
-    <div className="space-y-6">
-      <div className="flex items-center justify-between">
+    <div className="space-y-4">
+      <div className="flex items-center gap-3">
+        <span
+          className="flex h-10 w-10 items-center justify-center rounded-lg"
+          style={{ background: 'rgba(20,113,76,0.1)', color: GREEN }}
+        >
+          <Headset size={20} />
+        </span>
         <div>
           <h1 className="text-2xl font-bold text-foreground">Support Center</h1>
-          <p className="text-muted-foreground">Manage customer support conversations</p>
-        </div>
-        <ActionButton icon={Download} variant="secondary">Export</ActionButton>
-      </div>
-
-      <div className="card">
-        <div className="grid grid-cols-1 md:grid-cols-3 gap-4">
-          
-      <div>
-        <label className="label">Search</label>
-        <input type="text" placeholder="Search..." className="input" value={filters.search} onChange={(e) => setFilters({ ...filters, search: e.target.value })} />
-      </div>
-      <div>
-        <label className="label">Status</label>
-        <select className="input" value={filters.status} onChange={(e) => setFilters({ ...filters, status: e.target.value })}>
-          <option value="">All Status</option>
-          <option value="OPEN">Open</option>
-          <option value="IN_PROGRESS">In Progress</option>
-          <option value="RESOLVED">Resolved</option>
-          <option value="CLOSED">Closed</option>
-        </select>
-      </div>
-    
+          <p className="text-sm text-muted-foreground">
+            Shared inbox — respond to passenger requests in real time
+          </p>
         </div>
       </div>
 
-      <DataTable
-        data={data?.items || data || []}
-        columns={columns}
-        loading={isLoading}
-        emptyMessage="No support center found"
-      />
+      <div className="flex h-[calc(100vh-220px)] overflow-hidden rounded-xl border border-border bg-card">
+        {/* Conversation list */}
+        <div className="flex w-[340px] shrink-0 flex-col border-r border-border">
+          <div className="space-y-2 border-b border-border p-3">
+            <div className="relative">
+              <Search
+                size={16}
+                className="absolute left-3 top-2.5 text-muted-foreground"
+              />
+              <input
+                value={search}
+                onChange={(e) => setSearch(e.target.value)}
+                placeholder="Search subject or passenger"
+                className="w-full rounded-lg border border-border bg-background py-2 pl-9 pr-3 text-sm outline-none focus:border-emerald-500"
+              />
+            </div>
+            <div className="flex gap-1">
+              {FILTERS.map((f) => (
+                <button
+                  key={f}
+                  onClick={() => setStatus(f)}
+                  className={`flex-1 rounded-md px-2 py-1 text-xs font-medium capitalize transition ${
+                    status === f
+                      ? 'text-white'
+                      : 'bg-muted text-muted-foreground hover:bg-muted/70'
+                  }`}
+                  style={status === f ? { background: GREEN } : undefined}
+                >
+                  {f.toLowerCase()}
+                </button>
+              ))}
+            </div>
+          </div>
+          <div className="flex-1 overflow-y-auto">
+            {isLoading ? (
+              <div className="p-6 text-center text-sm text-muted-foreground">
+                Loading…
+              </div>
+            ) : items.length === 0 ? (
+              <div className="p-6 text-center text-sm text-muted-foreground">
+                No conversations.
+              </div>
+            ) : (
+              items.map((c) => (
+                <InboxRow
+                  key={c.id}
+                  c={c}
+                  active={c.id === selectedId}
+                  onClick={() => setSelectedId(c.id)}
+                />
+              ))
+            )}
+          </div>
+        </div>
+
+        {/* Thread */}
+        <div className="min-w-0 flex-1">
+          {selected ? (
+            <ConversationThread conversation={selected} />
+          ) : (
+            <div className="flex h-full flex-col items-center justify-center gap-2 text-muted-foreground">
+              <span
+                className="flex h-14 w-14 items-center justify-center rounded-full"
+                style={{ background: 'rgba(20,113,76,0.1)', color: GREEN }}
+              >
+                <Headset size={28} />
+              </span>
+              <p className="text-sm">Select a conversation to start replying.</p>
+            </div>
+          )}
+        </div>
+      </div>
+    </div>
+  );
+}
+
+function InboxRow({
+  c,
+  active,
+  onClick,
+}: {
+  c: ConversationDto;
+  active: boolean;
+  onClick: () => void;
+}) {
+  const unread = c.unreadCount > 0;
+  return (
+    <button
+      onClick={onClick}
+      className={`block w-full border-b border-border px-4 py-3 text-left transition hover:bg-muted/50 ${
+        active ? 'bg-muted/70' : ''
+      }`}
+      style={active ? { borderLeft: `3px solid ${GREEN}` } : { borderLeft: '3px solid transparent' }}
+    >
+      <div className="flex items-center justify-between gap-2">
+        <span
+          className={`truncate text-sm ${
+            unread ? 'font-bold text-foreground' : 'font-semibold text-foreground/90'
+          }`}
+        >
+          {c.subject || 'Support request'}
+        </span>
+        <span className="shrink-0 text-xs text-muted-foreground">
+          {formatTime(c.lastMessageAt)}
+        </span>
+      </div>
+      <p className="mt-0.5 truncate text-xs text-muted-foreground">
+        {c.passengerName || 'Passenger'}
+      </p>
+      <div className="mt-1 flex items-center justify-between gap-2">
+        <span className="truncate text-xs text-muted-foreground">
+          {c.lastMessageSender === 'AGENT' ? 'You: ' : ''}
+          {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 ConversationThread({ conversation }: { conversation: ConversationDto }) {
+  const { data: messages, isLoading } = useMessages(conversation.id);
+  const send = useSendMessage(conversation.id);
+  const setStatus = useSetStatus();
+  const markRead = useMarkRead();
+  const [draft, setDraft] = useState('');
+  const viewport = useRef<HTMLDivElement>(null);
+
+  useEffect(() => {
+    markRead.mutate(conversation.id);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [conversation.id, messages?.length]);
+
+  useEffect(() => {
+    viewport.current?.scrollTo({ top: viewport.current.scrollHeight });
+  }, [messages?.length, conversation.id]);
+
+  const submit = async () => {
+    const text = draft.trim();
+    if (!text) return;
+    setDraft('');
+    await send.mutateAsync(text);
+  };
+
+  const changeStatus = (status: string) =>
+    setStatus.mutate({ id: conversation.id, status });
+
+  return (
+    <div className="flex h-full flex-col">
+      <div className="flex items-center justify-between gap-2 border-b border-border p-4">
+        <div className="min-w-0">
+          <div className="flex items-center gap-2">
+            <span className="truncate font-bold text-foreground">
+              {conversation.subject || 'Conversation'}
+            </span>
+            <span
+              className={`rounded-full px-2 py-0.5 text-[10px] font-medium capitalize ${
+                STATUS_CLASS[conversation.status] ?? ''
+              }`}
+            >
+              {conversation.status.toLowerCase()}
+            </span>
+          </div>
+          <p className="truncate text-xs text-muted-foreground">
+            {conversation.passengerName || 'Passenger'}
+            {conversation.guestId ? ' · Guest' : ''}
+            {conversation.guestEmail ? ` · ${conversation.guestEmail}` : ''}
+            {conversation.guestPhone ? ` · ${conversation.guestPhone}` : ''}
+          </p>
+        </div>
+        <div className="flex shrink-0 gap-2">
+          {conversation.status !== 'OPEN' && (
+            <button
+              onClick={() => changeStatus('OPEN')}
+              className="rounded-md px-3 py-1.5 text-xs font-medium text-white"
+              style={{ background: GREEN }}
+            >
+              Reopen
+            </button>
+          )}
+          {conversation.status === 'OPEN' && (
+            <button
+              onClick={() => changeStatus('RESOLVED')}
+              className="rounded-md bg-blue-600 px-3 py-1.5 text-xs font-medium text-white hover:bg-blue-700"
+            >
+              Resolve
+            </button>
+          )}
+          {conversation.status !== 'CLOSED' && (
+            <button
+              onClick={() => changeStatus('CLOSED')}
+              className="rounded-md bg-muted px-3 py-1.5 text-xs font-medium text-muted-foreground hover:bg-muted/70"
+            >
+              Close
+            </button>
+          )}
+        </div>
+      </div>
+
+      <div ref={viewport} className="flex-1 space-y-3 overflow-y-auto p-4">
+        {isLoading ? (
+          <div className="p-6 text-center text-sm text-muted-foreground">
+            Loading…
+          </div>
+        ) : (
+          (messages ?? []).map((m) => <AgentBubble key={m.id} m={m} />)
+        )}
+      </div>
+
+      <div className="border-t border-border p-3">
+        <div className="flex items-end gap-2">
+          <textarea
+            value={draft}
+            onChange={(e) => setDraft(e.target.value)}
+            onKeyDown={(e) => {
+              if (e.key === 'Enter' && !e.shiftKey) {
+                e.preventDefault();
+                submit();
+              }
+            }}
+            rows={1}
+            placeholder="Type your reply…  (Enter to send, Shift+Enter for newline)"
+            className="max-h-28 flex-1 resize-none rounded-lg border border-border bg-background px-3 py-2 text-sm outline-none focus:border-emerald-500"
+          />
+          <button
+            onClick={submit}
+            disabled={!draft.trim() || send.isPending}
+            className="flex h-9 w-9 shrink-0 items-center justify-center rounded-lg text-white transition hover:opacity-90 disabled:opacity-50"
+            style={{ background: GREEN }}
+            aria-label="Send"
+          >
+            <Send size={18} />
+          </button>
+        </div>
+      </div>
+    </div>
+  );
+}
+
+function AgentBubble({ m }: { m: MessageDto }) {
+  const mine = m.sender === 'AGENT';
+  return (
+    <div className={`flex ${mine ? 'justify-end' : 'justify-start'} items-end gap-2`}>
+      {!mine && (
+        <span className="flex h-7 w-7 items-center justify-center rounded-full bg-muted text-muted-foreground">
+          <User size={14} />
+        </span>
+      )}
+      <div className="max-w-[70%]">
+        <p
+          className={`mb-0.5 text-xs text-muted-foreground ${
+            mine ? 'text-right' : 'text-left'
+          }`}
+        >
+          {mine ? m.authorName || 'You' : m.authorName || 'Passenger'}
+        </p>
+        <div
+          className={`whitespace-pre-wrap break-words rounded-2xl px-3 py-2 text-sm ${
+            mine
+              ? 'rounded-br-sm text-white'
+              : 'rounded-bl-sm bg-muted text-foreground'
+          }`}
+          style={mine ? { background: GREEN } : undefined}
+        >
+          {m.text}
+        </div>
+        <p
+          className={`mt-0.5 text-[10px] text-muted-foreground ${
+            mine ? 'text-right' : 'text-left'
+          }`}
+        >
+          {formatTime(m.createdAt)}
+        </p>
+      </div>
     </div>
   );
 }
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..7b5ff3102 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
@@ -237,16 +237,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">
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/components/layout/Sidebar.tsx b/apps/edr-passenger-web/backoffice/src/components/layout/Sidebar.tsx
index d9ca1da7d..39fd91ca5 100644
--- a/apps/edr-passenger-web/backoffice/src/components/layout/Sidebar.tsx
+++ b/apps/edr-passenger-web/backoffice/src/components/layout/Sidebar.tsx
@@ -104,7 +104,7 @@ const navigationSections: { title: string; items: NavItem[] }[] = [
     title: 'Customer Services',
     items: [
       { name: 'Loyalty Program', href: '/loyalty',       icon: Gift,          permission: PERMS.passengers.view },
-      // { name: 'Support Center',  href: '/support',       icon: MessageSquare, permission: PERMS.bookings.view },
+      { name: 'Support Center',  href: '/support',       icon: MessageSquare, permission: PERMS.bookings.view },
       { name: 'Notifications',   href: '/notifications', icon: Bell,          permission: PERMS.notifications.send },
     ]
   },
diff --git a/apps/edr-passenger-web/backoffice/src/features/support/supportApi.ts b/apps/edr-passenger-web/backoffice/src/features/support/supportApi.ts
new file mode 100644
index 000000000..b6fac65bc
--- /dev/null
+++ b/apps/edr-passenger-web/backoffice/src/features/support/supportApi.ts
@@ -0,0 +1,36 @@
+import type { Passenger } from '@edr/types';
+
+import { apiClient } from '@/lib/api-client';
+
+type ConversationDto = Passenger.PassengerSupportConversationDto;
+type MessageDto = Passenger.PassengerSupportMessageDto;
+type ListResult = Passenger.PassengerSupportConversationListResult;
+
+export interface ListParams {
+  status?: string;
+  search?: string;
+}
+
+/** Passenger backoffice (agent) support-chat REST calls (client unwraps envelope). */
+export const supportApi = {
+  listConversations: (params: ListParams = {}) =>
+    apiClient.get<ListResult>('/support/agent/conversations', { params }),
+  listMessages: (id: string) =>
+    apiClient.get<MessageDto[]>(`/support/agent/conversations/${id}/messages`),
+  sendMessage: (id: string, text: string) =>
+    apiClient.post<MessageDto>(
+      `/support/agent/conversations/${id}/messages`,
+      { text },
+    ),
+  setStatus: (id: string, status: string) =>
+    apiClient.patch<ConversationDto>(
+      `/support/agent/conversations/${id}/status`,
+      { status },
+    ),
+  markRead: (id: string) =>
+    apiClient.post<{ unreadCount: number }>(
+      `/support/agent/conversations/${id}/read`,
+    ),
+  unreadCount: () =>
+    apiClient.get<{ unreadCount: number }>('/support/agent/unread-count'),
+};
diff --git a/apps/edr-passenger-web/backoffice/src/features/support/useSupport.ts b/apps/edr-passenger-web/backoffice/src/features/support/useSupport.ts
new file mode 100644
index 000000000..fbe8e7697
--- /dev/null
+++ b/apps/edr-passenger-web/backoffice/src/features/support/useSupport.ts
@@ -0,0 +1,65 @@
+'use client';
+
+import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
+
+import { supportApi, type ListParams } from './supportApi';
+
+export const SUPPORT_CONVERSATIONS_KEY = ['support', 'conversations'];
+export const SUPPORT_UNREAD_KEY = ['support', 'unread'];
+export const supportMessagesKey = (id: string) => ['support', 'messages', id];
+
+export function useConversations(params: ListParams = {}) {
+  return useQuery({
+    queryKey: [...SUPPORT_CONVERSATIONS_KEY, params],
+    queryFn: () => supportApi.listConversations(params),
+  });
+}
+
+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,
+    queryFn: () => supportApi.unreadCount(),
+    enabled,
+    refetchInterval: 60_000,
+  });
+}
+
+export function useSendMessage(conversationId: string) {
+  const qc = useQueryClient();
+  return useMutation({
+    mutationFn: (text: string) => supportApi.sendMessage(conversationId, text),
+    onSuccess: () => {
+      qc.invalidateQueries({ queryKey: supportMessagesKey(conversationId) });
+      qc.invalidateQueries({ queryKey: SUPPORT_CONVERSATIONS_KEY });
+    },
+  });
+}
+
+export function useSetStatus() {
+  const qc = useQueryClient();
+  return useMutation({
+    mutationFn: ({ id, status }: { id: string; status: string }) =>
+      supportApi.setStatus(id, status),
+    onSuccess: () =>
+      qc.invalidateQueries({ queryKey: SUPPORT_CONVERSATIONS_KEY }),
+  });
+}
+
+export function useMarkRead() {
+  const qc = useQueryClient();
+  return useMutation({
+    mutationFn: (id: string) => supportApi.markRead(id),
+    onSuccess: () => {
+      qc.invalidateQueries({ queryKey: SUPPORT_CONVERSATIONS_KEY });
+      qc.invalidateQueries({ queryKey: SUPPORT_UNREAD_KEY });
+    },
+  });
+}
diff --git a/apps/edr-passenger-web/backoffice/src/features/support/useSupportSocket.ts b/apps/edr-passenger-web/backoffice/src/features/support/useSupportSocket.ts
new file mode 100644
index 000000000..aabeb0ce4
--- /dev/null
+++ b/apps/edr-passenger-web/backoffice/src/features/support/useSupportSocket.ts
@@ -0,0 +1,83 @@
+'use client';
+
+import { Passenger } from '@edr/types';
+import { useQueryClient } from '@tanstack/react-query';
+import { useEffect, useRef } from 'react';
+import { io } from 'socket.io-client';
+
+import {
+  SUPPORT_CONVERSATIONS_KEY,
+  SUPPORT_UNREAD_KEY,
+  supportMessagesKey,
+} from './useSupport';
+
+const SOCKET_ORIGIN = String(
+  process.env.NEXT_PUBLIC_API_URL || 'http://localhost:4000',
+).replace(/\/api\/?$/, '');
+
+/**
+ * Subscribes the signed-in agent to live support pushes for the whole shared
+ * inbox. Any new message / conversation change refreshes the thread, the inbox
+ * list, and the unread badge; `onMessage` fires for optional toasts.
+ */
+export function useSupportSocket(
+  enabled: boolean,
+  onMessage?: (event: Passenger.PassengerSupportMessageEvent) => void,
+) {
+  const qc = useQueryClient();
+  const onMessageRef = useRef(onMessage);
+  onMessageRef.current = onMessage;
+
+  useEffect(() => {
+    if (!enabled || typeof window === 'undefined') return;
+    const token = localStorage.getItem('auth_token');
+    if (!token) return;
+
+    const socket = io(
+      `${SOCKET_ORIGIN}/${Passenger.PASSENGER_SUPPORT_WS_NAMESPACE}`,
+      {
+        auth: { token },
+        // 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) => {
+        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 });
+      qc.invalidateQueries({ queryKey: SUPPORT_UNREAD_KEY });
+    });
+
+    return () => {
+      socket.off();
+      socket.disconnect();
+    };
+  }, [enabled, qc]);
+}
diff --git a/apps/edr-passenger-web/backoffice/src/lib/api/bookings.ts b/apps/edr-passenger-web/backoffice/src/lib/api/bookings.ts
index 9d9dc554f..5035033c0 100644
--- a/apps/edr-passenger-web/backoffice/src/lib/api/bookings.ts
+++ b/apps/edr-passenger-web/backoffice/src/lib/api/bookings.ts
@@ -28,4 +28,7 @@ export const bookingsApi = {
   cancel: (id: string, reason?: string) => {
     return apiClient.post<Booking>(`/bookings/${id}/cancel`, { reason });
   },
+
+  forceConfirm: (bookingId: string, data: { paymentReference?: string; paymentMethod?: string; notes?: string }) =>
+    apiClient.post(`/payments/${bookingId}/force-confirm`, data),
 };
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 f611d3083..7824cef07 100644
--- a/apps/edr-passenger-web/backoffice/src/lib/api/index.ts
+++ b/apps/edr-passenger-web/backoffice/src/lib/api/index.ts
@@ -44,6 +44,8 @@ export const bookingsApi = {
   cancel: (id: string, data?: any) => apiClient.post<any>(`/bookings/${id}/cancel`, data),
   modify: (id: string, data: any) => apiClient.patch<any>(`/bookings/${id}`, data),
   checkUsage: (id: string) => apiClient.get<any>(`/bookings/${id}/usage`),
+  forceConfirm: (bookingId: string, data: { paymentReference?: string; paymentMethod?: string; notes?: string }) =>
+    apiClient.post<any>(`/payments/${bookingId}/force-confirm`, data),
 };
 
 // Passengers API
@@ -115,6 +117,7 @@ export const fleetApi = {
   updateCoach: (id: string, data: any) => apiClient.patch<any>(`/fleet/coaches/${id}`, data),
   deleteCoach: (id: string, cascade?: boolean) => apiClient.delete(`/fleet/coaches/${id}${cascade ? '?cascade=true' : ''}`),
   generateSeatMap: (data: any) => apiClient.post<any>('/fleet/seatmap/generate', data),
+  getCoach: (id: string) => apiClient.get<any>(`/fleet/coaches/${id}`),
 };
 
 // Schedules API
@@ -441,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/package.json b/apps/edr-passenger-web/portal/package.json
index 8323c3bb0..5c6104e94 100644
--- a/apps/edr-passenger-web/portal/package.json
+++ b/apps/edr-passenger-web/portal/package.json
@@ -28,6 +28,7 @@
     "react": "^18.3.1",
     "react-dom": "^18.3.1",
     "react-hook-form": "^7.51.0",
+    "socket.io-client": "^4.8.3",
     "zod": "^3.22.4",
     "zustand": "^5.0.0"
   },
diff --git a/apps/edr-passenger-web/portal/src/app/api/seats/release-hold/route.ts b/apps/edr-passenger-web/portal/src/app/api/seats/release-hold/route.ts
new file mode 100644
index 000000000..c2c1d19a0
--- /dev/null
+++ b/apps/edr-passenger-web/portal/src/app/api/seats/release-hold/route.ts
@@ -0,0 +1,37 @@
+// Server-side proxy for POST /seats/release on the passenger API.
+//
+// The browser calls THIS route (same-origin, /api/seats/release-hold) instead of the
+// backend's public release endpoint directly. Route handlers run on the Next.js server, not
+// in the browser, so the actual backend call — and its URL — never appears in client-side
+// JS or network requests a user could copy and script against other travellers' holds.
+// Keeping this indirection is the whole point: it doesn't add cryptographic protection (the
+// backend endpoint is still public), it just keeps the release capability out of the
+// browser's reach so it can't be trivially discovered and abused from client code.
+
+const API_URL = process.env.NEXT_PUBLIC_API_URL || "http://localhost:4000";
+
+export async function POST(request: Request) {
+  let holdId: string | undefined;
+  try {
+    ({ holdId } = await request.json());
+  } catch {
+    return Response.json({ message: "Invalid JSON body" }, { status: 400 });
+  }
+
+  if (!holdId || typeof holdId !== "string") {
+    return Response.json({ message: "holdId is required" }, { status: 400 });
+  }
+
+  try {
+    const backendResponse = await fetch(`${API_URL}/seats/release`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ holdId }),
+    });
+
+    const data = await backendResponse.json().catch(() => null);
+    return Response.json(data, { status: backendResponse.status });
+  } catch {
+    return Response.json({ message: "Failed to reach booking service" }, { status: 502 });
+  }
+}
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 e77ab70b4..220ecb1b3 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
@@ -102,7 +102,7 @@ export default function ConfirmationPage() {
       const { packageTierPriceMinor } = useBookingStore.getState();
       const isPackageBooking = packageTierPriceMinor != null;
       const adultCount = searchCriteria?.adultCount ?? passengers.filter(p => !isChild(p)).length;
-      const pkgMultiplier = isPackageBooking && isRoundTrip ? 2 : 1;
+      const pkgMultiplier = isPackageBooking ? 2 : 1;
       const pkgAdultFare = isPackageBooking ? packageTierPriceMinor! * pkgMultiplier : 0;
       const pkgChildFare = pkgAdultFare;
 
diff --git a/apps/edr-passenger-web/portal/src/app/booking/detail/page.tsx b/apps/edr-passenger-web/portal/src/app/booking/detail/page.tsx
index 5087b7e4d..a3e7f06fc 100644
--- a/apps/edr-passenger-web/portal/src/app/booking/detail/page.tsx
+++ b/apps/edr-passenger-web/portal/src/app/booking/detail/page.tsx
@@ -5,28 +5,47 @@ import { useSearchParams, useRouter } from 'next/navigation';
 import { useQuery, useMutation } from '@tanstack/react-query';
 import { apiClient } from '@/lib/api-client';
 import { useState } from 'react';
-import { 
-  Clock, 
-  Users, 
-  CheckCircle2, 
+import {
+  Clock,
+  Users,
+  CheckCircle2,
   AlertCircle,
   Download,
   Share2,
   Copy,
   Check,
   CreditCard,
-  Wallet
+  Wallet,
+  Smartphone,
+  Loader2,
+  ChevronLeft,
 } from 'lucide-react';
 import { format } from 'date-fns';
 import { formatTime, getTimePeriod } from '@/utils/format';
+import { formatFare } from '@/utils/fare-utils';
+import { markManageBookingPaymentReturn, consumeManageBookingPaymentReturn } from '@/utils/manage-booking-return';
 import QRCode from 'qrcode.react';
 
+// Same convention as /booking/payment — payment methods are ETB-settled by default;
+// a method only needs a currency conversion when its own currency differs.
+const displayCurrency = 'ETB' as const;
+
+const getIconForMethod = (methodType: string) => {
+  if (methodType.includes('CARD')) return CreditCard;
+  if (methodType.includes('WALLET')) return Wallet;
+  return Smartphone;
+};
+
 function BookingDetailContent() {
   const router = useRouter();
   const searchParams = useSearchParams();
   const bookingRef = searchParams.get('ref') || searchParams.get('bookingRef') || searchParams.get('pnr');
-  
-  const [selectedPaymentMethod, setSelectedPaymentMethod] = useState<string>('');
+
+  // Mirrors /booking/payment's state shape: selectedMethod is the PaymentMethod `type`
+  // (used both for lookup and to decide provider-specific redirect handling), not the id.
+  const [selectedMethod, setSelectedMethod] = useState<string | null>(null);
+  const [selectedMethodCurrency, setSelectedMethodCurrency] = useState<string | null>(null);
+  const [paymentError, setPaymentError] = useState<string | null>(null);
   const [copiedPNR, setCopiedPNR] = useState(false);
   const [isGeneratingVoucher, setIsGeneratingVoucher] = useState(false);
 
@@ -42,40 +61,84 @@ function BookingDetailContent() {
     retry: 1,
   });
 
-  const { data: paymentMethods } = useQuery({
+  const { data: paymentMethods } = useQuery<any[]>({
     queryKey: ['payment-methods'],
     queryFn: () => apiClient.get('/payments/methods'),
     enabled: booking?.status === 'PENDING_PAYMENT' || booking?.status === 'DRAFT',
   });
 
-  const paymentMutation = useMutation({
-    mutationFn: async (paymentData: any) => {
-      const response = await apiClient.post('/payments/intent', paymentData);
+  const selectedPaymentMethod = (paymentMethods || []).find((m: any) => m.type === selectedMethod) || null;
+
+  // Same conversion logic as /booking/payment: only hit the booking-amount-changer API
+  // when the selected method actually settles in a different currency than ETB.
+  const isConversionNeeded = !!selectedMethodCurrency && selectedMethodCurrency !== displayCurrency;
+  const amountCurrency = isConversionNeeded ? selectedMethodCurrency! : displayCurrency;
+
+  const { data: bookingAmountData, isLoading: loadingAmount } = useQuery<{ amount: number; currency: string; booking_id: string }>({
+    queryKey: ['bookingAmount', booking?.id, amountCurrency],
+    queryFn: async () => {
+      const url = `/payments/booking-amount?bookingId=${booking?.id}&currency=${amountCurrency}`;
+      const response: any = await apiClient.get(url);
       return response;
     },
-    onSuccess: async (data: any) => {
-      await apiClient.patch(`/bookings/${booking?.id}/confirm`, {
-        paymentIntentId: data.id,
-        paymentMethod: selectedPaymentMethod,
+    enabled: !!booking?.id && isConversionNeeded,
+  });
+
+  const totalAmountDisplay = isConversionNeeded
+    ? (bookingAmountData != null ? bookingAmountData.amount : null)
+    : ((booking?.totalMinor ?? 0) / 100);
+  const confirmedCurrency = isConversionNeeded ? (bookingAmountData?.currency || amountCurrency) : displayCurrency;
+  const awaitingAmount = isConversionNeeded && loadingAmount && totalAmountDisplay === null;
+
+  const paymentMutation = useMutation({
+    mutationFn: async (data: any) => {
+      return await apiClient.post('/payments/initiate', {
+        bookingId: data.bookingId,
+        method: data.method,
+        paymentMethodId: data.paymentMethodId,
+        platform: 'web',
       });
-      refetch();
+    },
+    onSuccess: async (data: any) => {
+      setPaymentError(null);
+
+      if ((selectedMethod === 'TELEBIRR' || selectedMethod === 'WAAFI') && data?.clientAction?.type === 'REDIRECT') {
+        window.location.href = data.clientAction.url;
+        return;
+      }
+
+      // No redirect needed (e.g. WALLET) — the marker set in handlePayment is now moot.
+      consumeManageBookingPaymentReturn();
+      await refetch();
     },
     onError: (error: any) => {
-      alert(error?.response?.data?.message || 'Payment failed. Please try again.');
+      setPaymentError(
+        error?.response?.data?.message ||
+        error?.message ||
+        'Payment failed. Please try again.',
+      );
     },
   });
 
   const handlePayment = () => {
-    if (!selectedPaymentMethod) {
-      alert('Please select a payment method');
+    if (!selectedMethod || !booking?.id) {
+      setPaymentError('Please select a payment method');
       return;
     }
 
+    if (!selectedPaymentMethod) {
+      setPaymentError('Invalid payment method selected');
+      return;
+    }
+
+    setPaymentError(null);
+    // Flag this as a Manage Booking payment so the gateway's success/failure return page
+    // sends the user back here instead of the new-booking confirmation flow.
+    markManageBookingPaymentReturn(booking.bookingRef);
     paymentMutation.mutate({
-      bookingId: booking?.id,
-      amount: booking?.totalMinor || 0,
-      currency: booking?.currency || 'ETB',
-      paymentMethodId: selectedPaymentMethod,
+      bookingId: booking.id,
+      method: selectedMethod,
+      paymentMethodId: selectedPaymentMethod.id,
     });
   };
 
@@ -163,38 +226,163 @@ function BookingDetailContent() {
     );
   };
 
-  if (isPendingPayment && !isExpired) {
-    return (
-      <div className="min-h-screen bg-gray-50 dark:bg-gray-900 py-6">
-        <div className="container mx-auto px-4">
-          <div className="max-w-5xl mx-auto">
-            
-            <div className="bg-white dark:bg-gray-800 rounded-2xl p-6 mb-6 border border-gray-200 dark:border-gray-700">
-              <div className="flex items-center justify-between mb-4">
-                <div>
-                  <h1 className="text-2xl font-bold text-gray-900 dark:text-white">Complete Payment</h1>
-                  <p className="text-sm text-gray-500 dark:text-gray-400 mt-1">
-                    Booking Reference: <span className="font-mono font-semibold">{booking.bookingRef}</span>
-                  </p>
-                </div>
-                <StatusBadge />
+  // /bookings/:ref returns one row per passenger PER LEG for round trips (leg 1 =
+  // outbound, leg 2 = return) — /booking/payment's fare breakdown, by contrast, shows one
+  // combined row per passenger with an Outbound/Return sub-split. Group leg rows back
+  // together here so both pages present the same per-passenger total, not a doubled list
+  // of half-fare rows.
+  const isRoundTripBooking = booking.bookingType === 'ROUND_TRIP';
+  const farePassengers = (() => {
+    const rows: any[] = booking.passengers || [];
+    if (!isRoundTripBooking) {
+      return rows.map((p) => ({ fullName: p.fullName, category: p.category, fareMinor: p.fareMinor ?? 0 }));
+    }
+    const grouped = new Map<string, { fullName: string; category: string; outboundFareMinor: number; returnFareMinor: number }>();
+    rows.forEach((p) => {
+      const key = `${p.fullName}|${p.dateOfBirth}|${p.category}`;
+      const entry = grouped.get(key) || { fullName: p.fullName, category: p.category, outboundFareMinor: 0, returnFareMinor: 0 };
+      if (p.leg === 2) entry.returnFareMinor = p.fareMinor ?? 0;
+      else entry.outboundFareMinor = p.fareMinor ?? 0;
+      grouped.set(key, entry);
+    });
+    return Array.from(grouped.values()).map((p) => ({
+      fullName: p.fullName,
+      category: p.category,
+      fareMinor: p.outboundFareMinor + p.returnFareMinor,
+      outboundFareMinor: p.outboundFareMinor,
+      returnFareMinor: p.returnFareMinor,
+    }));
+  })();
+
+  // Order summary card — mirrors /booking/payment's OrderSummary: fare breakdown per
+  // passenger, Total with a loading spinner while a currency conversion is in flight, and
+  // a note confirming what will actually be charged once a payment method is selected.
+  const OrderSummary = () => (
+    <div className="card space-y-4">
+      <h2 className="text-base font-bold text-gray-900 dark:text-gray-100 pb-2 border-b border-gray-100 dark:border-gray-800">
+        Order summary
+        <span className="ml-2 text-xs font-normal text-gray-500 dark:text-gray-400">
+          Ref: <span className="font-bold text-gray-900 dark:text-gray-100">{booking.bookingRef}</span>
+        </span>
+      </h2>
+
+      <div className="space-y-2">
+        <h3 className="text-sm font-bold text-gray-900 dark:text-gray-100">Fare breakdown</h3>
+        {farePassengers.map((passenger: any, idx: number) => {
+          const isChildPassenger = passenger.category === 'CHILD';
+          const isFreeChild = isChildPassenger && (passenger.fareMinor ?? 0) === 0;
+          return (
+            <div key={idx} className="border-b border-gray-100 dark:border-gray-800 pb-2 last:border-0">
+              <div className="flex justify-between mb-0.5">
+                <span className="text-sm font-medium text-gray-900 dark:text-gray-100 truncate max-w-[60%]">
+                  {passenger.fullName || `Passenger ${idx + 1}`}
+                  {isChildPassenger && (
+                    <span className={`text-xs font-semibold ml-1 ${isFreeChild ? 'text-green-600' : 'text-blue-600'}`}>
+                      ({isFreeChild ? 'CHILD - FREE' : 'CHILD - FULL FARE'})
+                    </span>
+                  )}
+                </span>
+                <span className="text-sm font-semibold text-gray-900 dark:text-gray-100">
+                  {formatFare(passenger.fareMinor ?? 0, displayCurrency)}
+                </span>
               </div>
-              
-              {booking.createdAt && (
-                <div className="bg-amber-50 dark:bg-amber-900/20 border border-amber-200 dark:border-amber-800 rounded-lg p-3 flex items-center gap-2">
-                  <Clock className="w-5 h-5 text-amber-600 dark:text-amber-400" />
-                  <span className="text-sm text-amber-800 dark:text-amber-300">
-                    Booking created on {format(new Date(booking.createdAt), 'PPpp')}
-                  </span>
+              {isRoundTripBooking && !isFreeChild && (
+                <div className="pl-3 space-y-0.5 text-xs text-gray-500 dark:text-gray-400">
+                  <div className="flex justify-between">
+                    <span>Outbound</span>
+                    <span>{formatFare(passenger.outboundFareMinor ?? 0, displayCurrency)}</span>
+                  </div>
+                  <div className="flex justify-between">
+                    <span>Return</span>
+                    <span>{formatFare(passenger.returnFareMinor ?? 0, displayCurrency)}</span>
+                  </div>
                 </div>
               )}
             </div>
+          );
+        })}
+      </div>
 
-            <div className="grid grid-cols-1 lg:grid-cols-3 gap-6">
-              
-              <div className="lg:col-span-2 space-y-6">
-                
-                <div className="bg-white dark:bg-gray-800 rounded-2xl p-6 border border-gray-200 dark:border-gray-700">
+      <div className="pt-2 border-t-2 border-gray-200 dark:border-gray-700">
+        <div className="flex justify-between items-center">
+          <span className="font-bold text-gray-900 dark:text-gray-100">Total</span>
+          <span className="text-xl font-bold text-primary flex items-center gap-1.5">
+            {awaitingAmount ? (
+              <Loader2 className="w-4 h-4 animate-spin text-primary" />
+            ) : (
+              <>{confirmedCurrency} {(totalAmountDisplay ?? 0).toFixed(2)}</>
+            )}
+          </span>
+        </div>
+        {selectedPaymentMethod && !awaitingAmount && (
+          <p className="text-xs text-gray-500 dark:text-gray-400 text-right mt-1">
+            You will be charged {confirmedCurrency} {(totalAmountDisplay ?? 0).toFixed(2)} via {selectedPaymentMethod.displayName}
+          </p>
+        )}
+      </div>
+
+      {/* Pay + back buttons — desktop sidebar only */}
+      <div className="hidden lg:flex flex-col gap-2 pt-1">
+        {paymentError && (
+          <p className="text-red-600 dark:text-red-400 text-xs">⚠️ {paymentError}</p>
+        )}
+        <button
+          onClick={handlePayment}
+          disabled={!selectedMethod || paymentMutation.isPending || awaitingAmount}
+          className="btn-primary w-full py-3 font-semibold disabled:opacity-50 disabled:cursor-not-allowed"
+        >
+          {paymentMutation.isPending ? (
+            <span className="flex items-center justify-center gap-2">
+              <Loader2 className="w-4 h-4 animate-spin" /> Processing...
+            </span>
+          ) : awaitingAmount ? (
+            <span className="flex items-center justify-center gap-2">
+              <Loader2 className="w-4 h-4 animate-spin" /> Calculating amount...
+            </span>
+          ) : (
+            `Pay ${confirmedCurrency} ${(totalAmountDisplay ?? 0).toFixed(2)}`
+          )}
+        </button>
+        <button onClick={() => router.push('/booking/lookup')} disabled={paymentMutation.isPending} className="btn-secondary w-full flex items-center justify-center gap-2">
+          <ChevronLeft className="w-4 h-4" />
+          Back
+        </button>
+        <p className="text-xs text-gray-500 dark:text-gray-400 text-center pt-1">
+          🔒 Secure & encrypted payment
+        </p>
+      </div>
+    </div>
+  );
+
+  if (isPendingPayment && !isExpired) {
+    return (
+      <div className="min-h-screen bg-gray-50 dark:bg-gray-900 py-6 pb-28 lg:pb-10">
+        <div className="container mx-auto px-4">
+          <div className="max-w-6xl mx-auto">
+            <h1 className="text-2xl font-bold mb-4 text-gray-900 dark:text-gray-100">Complete payment</h1>
+
+            <div className="card mb-4 flex items-start justify-between gap-3">
+              <div>
+                <p className="text-sm text-gray-500 dark:text-gray-400">
+                  Booking Reference: <span className="font-mono font-semibold text-gray-900 dark:text-gray-100">{booking.bookingRef}</span>
+                </p>
+                {booking.createdAt && (
+                  <p className="text-xs text-gray-500 dark:text-gray-400 mt-1 flex items-center gap-1.5">
+                    <Clock className="w-3.5 h-3.5" />
+                    Booking created on {format(new Date(booking.createdAt), 'PPpp')}
+                  </p>
+                )}
+              </div>
+              <StatusBadge />
+            </div>
+
+            {/* Two-column grid — matches /booking/payment's layout */}
+            <div className="lg:grid lg:grid-cols-3 lg:gap-6 lg:items-start">
+
+              {/* Left column — trip/payment method (2/3 width) */}
+              <div className="lg:col-span-2 space-y-4">
+
+                <div className="card">
                   <h2 className="text-lg font-bold text-gray-900 dark:text-white mb-4">Trip Summary</h2>
                   
                   <div className="flex items-center gap-2 mb-4">
@@ -302,43 +490,40 @@ function BookingDetailContent() {
                   </div>
                 </div>
 
-                <div className="bg-white dark:bg-gray-800 rounded-2xl p-6 border border-gray-200 dark:border-gray-700">
-                  <h2 className="text-lg font-bold text-gray-900 dark:text-white mb-4">Select Payment Method</h2>
-                  
+                <div className="card">
+                  <h2 className="text-lg font-bold text-gray-900 dark:text-white mb-4">Select payment method</h2>
+
                   {paymentMethods && Array.isArray(paymentMethods) && paymentMethods.length > 0 ? (
-                    <div className="grid grid-cols-1 sm:grid-cols-2 gap-3">
-                      {paymentMethods.map((method: any) => (
-                        <button
-                          key={method.id}
-                          onClick={() => setSelectedPaymentMethod(method.id)}
-                          className={`p-4 rounded-xl border-2 text-left transition-all ${
-                            selectedPaymentMethod === method.id
-                              ? 'border-primary bg-primary/5 dark:bg-primary/10'
-                              : 'border-gray-200 dark:border-gray-700 hover:border-primary/50'
-                          }`}
-                        >
-                          <div className="flex items-center gap-3">
-                            <div className={`w-10 h-10 rounded-lg flex items-center justify-center ${
-                              selectedPaymentMethod === method.id
-                                ? 'bg-primary/20 dark:bg-primary/30'
-                                : 'bg-gray-100 dark:bg-gray-700'
-                            }`}>
-                              {method.type === 'WALLET' ? (
-                                <Wallet className={`w-5 h-5 ${selectedPaymentMethod === method.id ? 'text-primary' : 'text-gray-600 dark:text-gray-400'}`} />
-                              ) : (
-                                <CreditCard className={`w-5 h-5 ${selectedPaymentMethod === method.id ? 'text-primary' : 'text-gray-600 dark:text-gray-400'}`} />
+                    <div className="space-y-3">
+                      {paymentMethods.map((method: any) => {
+                        const Icon = getIconForMethod(method.type);
+                        const isSelected = selectedMethod === method.type;
+                        return (
+                          <button
+                            key={method.id}
+                            onClick={() => { setSelectedMethod(method.type); setSelectedMethodCurrency(method.currency ?? null); }}
+                            disabled={paymentMutation.isPending || method.enabled === false}
+                            className={`w-full p-4 rounded-xl border-2 transition-all text-left ${
+                              isSelected
+                                ? 'border-primary bg-primary/8 dark:bg-primary/15 shadow-md'
+                                : 'border-gray-200 dark:border-gray-700 bg-white dark:bg-gray-800 hover:border-primary/50'
+                            } ${paymentMutation.isPending || method.enabled === false ? 'opacity-50 cursor-not-allowed' : ''}`}
+                          >
+                            <div className="flex items-center gap-3">
+                              <div className={`w-11 h-11 rounded-lg flex items-center justify-center flex-shrink-0 ${isSelected ? 'bg-primary' : 'bg-gray-100 dark:bg-gray-700'}`}>
+                                <Icon className={`w-5 h-5 ${isSelected ? 'text-white' : 'text-primary'}`} />
+                              </div>
+                              <div className="flex-1 min-w-0">
+                                <p className="font-semibold text-gray-900 dark:text-gray-100">{method.displayName}</p>
+                                <p className="text-xs text-gray-500 dark:text-gray-400">{method.region} · {method.currency}</p>
+                              </div>
+                              {isSelected && (
+                                <CheckCircle2 className="w-5 h-5 text-primary flex-shrink-0" />
                               )}
                             </div>
-                            <div className="flex-1">
-                              <div className="font-semibold text-gray-900 dark:text-white">{method.displayName}</div>
-                              <div className="text-xs text-gray-500 dark:text-gray-400">{method.currency}</div>
-                            </div>
-                            {selectedPaymentMethod === method.id && (
-                              <Check className="w-5 h-5 text-primary" />
-                            )}
-                          </div>
-                        </button>
-                      ))}
+                          </button>
+                        );
+                      })}
                     </div>
                   ) : (
                     <div className="text-center py-8 text-gray-500 dark:text-gray-400">
@@ -347,39 +532,60 @@ function BookingDetailContent() {
                   )}
                 </div>
 
-                <button
-                  onClick={handlePayment}
-                  disabled={!selectedPaymentMethod || paymentMutation.isPending}
-                  className="w-full py-4 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-lg rounded-xl transition-all disabled:opacity-50 disabled:cursor-not-allowed shadow-lg"
-                >
-                  {paymentMutation.isPending ? 'Processing Payment...' : `Pay ${booking.displayCurrency} ${((booking.displayTotalMinor || booking.totalMinor || 0) / 100).toFixed(2)}`}
-                </button>
-              </div>
-
-              <div className="lg:col-span-1">
-                <div className="bg-white dark:bg-gray-800 rounded-2xl p-6 border border-gray-200 dark:border-gray-700 sticky top-6">
-                  <h2 className="text-lg font-bold text-gray-900 dark:text-white mb-4">Order Summary</h2>
-                  
-                  <div className="space-y-3 mb-4">
-                    <div className="flex justify-between text-sm">
-                      <span className="text-gray-600 dark:text-gray-400">Subtotal ({booking.adultCount} Adult{booking.adultCount > 1 ? 's' : ''}{booking.childCount > 0 ? `, ${booking.childCount} Child${booking.childCount > 1 ? 'ren' : ''}` : ''})</span>
-                      <span className="font-semibold text-gray-900 dark:text-white">
-                        {booking.currency} {((booking.totalMinor || 0) / 100).toFixed(2)}
-                      </span>
-                    </div>
-                  </div>
-                  
-                  <div className="border-t border-gray-200 dark:border-gray-700 pt-4 mt-4">
-                    <div className="flex justify-between">
-                      <span className="text-lg font-bold text-gray-900 dark:text-white">Total</span>
-                      <span className="text-2xl font-bold text-primary">
-                        {booking.displayCurrency} {((booking.displayTotalMinor || booking.totalMinor || 0) / 100).toFixed(2)}
-                      </span>
-                    </div>
-                  </div>
+                {/* Order summary inline — mobile only */}
+                <div className="lg:hidden">
+                  <OrderSummary />
                 </div>
               </div>
-            </div>
+
+              {/* Right column — sticky order summary (desktop only) */}
+              <div className="hidden lg:block">
+                <div className="sticky top-6">
+                  <OrderSummary />
+                </div>
+              </div>
+
+            </div>{/* end grid */}
+          </div>
+        </div>
+
+        {/* Mobile sticky bottom bar */}
+        <div className="lg:hidden fixed bottom-0 inset-x-0 bg-white dark:bg-gray-900 border-t border-gray-200 dark:border-gray-700 px-4 py-3 z-40 shadow-lg">
+          <div className="flex items-center justify-between mb-2.5">
+            <span className="text-sm text-gray-600 dark:text-gray-400">Total</span>
+            <span className="text-lg font-bold text-primary flex items-center gap-1.5">
+              {awaitingAmount ? (
+                <Loader2 className="w-3.5 h-3.5 animate-spin" />
+              ) : (
+                <>{confirmedCurrency} {(totalAmountDisplay ?? 0).toFixed(2)}</>
+              )}
+            </span>
+          </div>
+          {paymentError && (
+            <p className="text-red-600 dark:text-red-400 text-xs mb-2">⚠️ {paymentError}</p>
+          )}
+          <div className="flex gap-3">
+            <button onClick={() => router.push('/booking/lookup')} disabled={paymentMutation.isPending} className="btn-secondary flex-1 py-2.5 flex items-center justify-center gap-2">
+              <ChevronLeft className="w-4 h-4" />
+              Back
+            </button>
+            <button
+              onClick={handlePayment}
+              disabled={!selectedMethod || paymentMutation.isPending || awaitingAmount}
+              className="btn-primary flex-1 py-2.5 disabled:opacity-50 disabled:cursor-not-allowed"
+            >
+              {paymentMutation.isPending ? (
+                <span className="flex items-center justify-center gap-1.5">
+                  <Loader2 className="w-4 h-4 animate-spin" /> Processing...
+                </span>
+              ) : awaitingAmount ? (
+                <span className="flex items-center justify-center gap-1.5">
+                  <Loader2 className="w-4 h-4 animate-spin" /> Calculating...
+                </span>
+              ) : (
+                `Pay ${confirmedCurrency} ${(totalAmountDisplay ?? 0).toFixed(2)}`
+              )}
+            </button>
           </div>
         </div>
       </div>
diff --git a/apps/edr-passenger-web/portal/src/app/booking/passengers/page.tsx b/apps/edr-passenger-web/portal/src/app/booking/passengers/page.tsx
index e443ccf07..814a5009e 100644
--- a/apps/edr-passenger-web/portal/src/app/booking/passengers/page.tsx
+++ b/apps/edr-passenger-web/portal/src/app/booking/passengers/page.tsx
@@ -568,9 +568,8 @@ function createFormSchema(adultCount: number) {
       // Contact fields are only collected from — and validated against — adults.
       // Children's phone/email are inherited from the primary adult, not user-entered.
       if (isAdult) {
-        if (!p.email || p.email.trim().length === 0) {
-          ctx.addIssue({ code: z.ZodIssueCode.custom, message: 'Email is required', path: ['passengers', i, 'email'] });
-        } else {
+        // Email is optional — only validate its format when the user actually provides one.
+        if (p.email && p.email.trim().length > 0) {
           const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
           if (!emailRegex.test(p.email)) {
             ctx.addIssue({ code: z.ZodIssueCode.custom, message: 'Invalid email format', path: ['passengers', i, 'email'] });
@@ -1191,7 +1190,7 @@ export default function PassengersPage() {
 
                                 {/* Email */}
                                 <div>
-                                  <label className="block text-sm font-medium mb-1 text-gray-700 dark:text-gray-300">Email *</label>
+                                  <label className="block text-sm font-medium mb-1 text-gray-700 dark:text-gray-300">Email (optional)</label>
                                   <input
                                     type="email"
                                     {...register(`passengers.${index}.email`)}
@@ -1280,7 +1279,7 @@ export default function PassengersPage() {
 
                                 {/* Email */}
                                 <div>
-                                  <label className="block text-sm font-medium mb-1 text-gray-700 dark:text-gray-300">Email *</label>
+                                  <label className="block text-sm font-medium mb-1 text-gray-700 dark:text-gray-300">Email (optional)</label>
                                   <input
                                     type="email"
                                     {...register(`passengers.${index}.email`)}
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 e75f9b36a..33d6a20f6 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
@@ -2,45 +2,33 @@
 
 import { useEffect, useState } from 'react';
 import { useRouter, useSearchParams } from 'next/navigation';
-import { useBookingStore } from '@/lib/booking-store';
 import { usePaymentStore } from '@/lib/payment-store';
-import { apiClient } from '@/lib/api-client';
+import { consumeManageBookingPaymentReturn } from '@/utils/manage-booking-return';
 import { CheckCircle, Loader2 } from 'lucide-react';
 import { Suspense } from 'react';
 
 function DmoneySuccessContent() {
   const router = useRouter();
   const searchParams = useSearchParams();
-  const { bookingId } = useBookingStore();
   const { updateStatus } = usePaymentStore();
   const [status, setStatus] = useState<'processing' | 'done' | 'error'>('processing');
+  const [returnTarget, setReturnTarget] = useState('/booking/confirmation');
 
   // D-Money callback query params (mirrors Telebirr)
-  const orderid      = searchParams.get('orderid')      || '';
-  const trxRef       = searchParams.get('trxRef')       || searchParams.get('outTradeNo') || '';
-  const bookingIdQp  = searchParams.get('bookingId')    || bookingId || '';
+  const orderid = searchParams.get('orderid') || '';
+  const trxRef  = searchParams.get('trxRef')  || searchParams.get('outTradeNo') || '';
 
   useEffect(() => {
-    const confirm = async () => {
-      try {
-        if (bookingIdQp) {
-          await apiClient.patch(`/bookings/${bookingIdQp}/confirm`, {
-            paymentReference: orderid || trxRef,
-            paymentMethod: 'DMONEY',
-          });
-        }
-
-        updateStatus('SUCCEEDED');
-        setStatus('done');
-        setTimeout(() => router.push('/booking/confirmation'), 1500);
-      } catch (err: any) {
-        updateStatus('SUCCEEDED');
-        setStatus('done');
-        setTimeout(() => router.push('/booking/confirmation'), 1500);
-      }
-    };
-
-    confirm();
+    // 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.
+    const manageBookingRef = consumeManageBookingPaymentReturn();
+    const target = manageBookingRef ? `/booking/detail?ref=${encodeURIComponent(manageBookingRef)}` : '/booking/confirmation';
+    setReturnTarget(target);
+    updateStatus('SUCCEEDED');
+    setStatus('done');
+    setTimeout(() => router.push(target), 1500);
   // eslint-disable-next-line react-hooks/exhaustive-deps
   }, []);
 
@@ -61,7 +49,7 @@ function DmoneySuccessContent() {
             <p className="text-sm text-gray-500 dark:text-gray-400 mb-1">Your D-Money payment was received.</p>
             {orderid && <p className="text-xs text-gray-400">Order ID: {orderid}</p>}
             {trxRef && <p className="text-xs text-gray-400">Transaction Ref: {trxRef}</p>}
-            <p className="text-xs text-gray-400 mt-3">Redirecting to your booking confirmation…</p>
+            <p className="text-xs text-gray-400 mt-3">Redirecting…</p>
           </>
         )}
         {status === 'error' && (
@@ -71,8 +59,8 @@ function DmoneySuccessContent() {
             </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>
-            <button onClick={() => router.push('/booking/confirmation')}
-              className="btn-primary w-full">Go to confirmation</button>
+            <button onClick={() => router.push(returnTarget)}
+              className="btn-primary w-full">Continue</button>
           </>
         )}
       </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 0b27dfa87..a95179762 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
@@ -48,9 +48,16 @@ export default function PaymentPage() {
     },
   });
 
-  // Fetch actual booking amount from API when a payment method is selected
-  const amountCurrency = selectedMethodCurrency || displayCurrency;
+  const selectedPaymentMethod = paymentMethods.find(m => m.type === selectedMethod) || null;
 
+  // A payment method only needs a currency conversion when its own currency differs from
+  // the default booking currency (e.g. Waafi settles in USD) — otherwise the reviewed ETB
+  // total already shown on the review page is exact and there's nothing to convert.
+  const isConversionNeeded = !!selectedMethodCurrency && selectedMethodCurrency !== displayCurrency;
+  const amountCurrency = isConversionNeeded ? selectedMethodCurrency! : displayCurrency;
+
+  // Fetch the converted booking amount from the booking-amount-changer API whenever a
+  // currency-specific payment method is selected.
   const { data: bookingAmountData, isLoading: loadingAmount } = useQuery<{ amount: number; currency: string; booking_id: string }>({
     queryKey: ['bookingAmount', bookingId, amountCurrency],
     queryFn: async () => {
@@ -58,7 +65,7 @@ export default function PaymentPage() {
       const response: any = await apiClient.get(url);
       return response;
     },
-    enabled: !!bookingId,
+    enabled: !!bookingId && isConversionNeeded,
   });
 
   // Per-leg subtotals for the journey header — sum each paying passenger's reviewed fare
@@ -71,32 +78,39 @@ export default function PaymentPage() {
     ? (reviewedPassengerFares ?? []).reduce((sum, f) => sum + (f.isFree ? 0 : Math.round(f.fareMinor / 2)), 0)
     : 0;
 
-  // reviewedPassengerFares / reviewedTotalMinor are the single source of truth for display —
-  // they were computed and shown to the user on the review page, so the Total here must match.
-  // The API booking-amount is used only as the charge amount sent to the payment provider.
+  // reviewedPassengerFares / reviewedTotalMinor are the single source of truth for display
+  // in the booking's default currency (ETB) — they were computed and shown to the user on
+  // the review page. But once a payment method with its own currency is selected (e.g.
+  // Waafi/USD), the converted amount from the booking-amount API takes over so the user
+  // sees the actual amount they'll be charged in that currency.
   const reviewedTotal = reviewedTotalMinor ?? (reviewedPassengerFares?.reduce((s, f) => s + f.fareMinor, 0) ?? null);
-  const totalAmountDisplay = reviewedTotal != null ? reviewedTotal / 100 : (bookingAmountData != null ? bookingAmountData.amount : null);
-  const totalAmount = bookingAmountData != null
-    ? Math.round(bookingAmountData.amount * 100)
-    : (reviewedTotal ?? 0);
-  const confirmedCurrency = bookingAmountData?.currency || amountCurrency;
+  const totalAmountDisplay = isConversionNeeded
+    ? (bookingAmountData != null ? bookingAmountData.amount : null)
+    : (reviewedTotal != null ? reviewedTotal / 100 : (bookingAmountData != null ? bookingAmountData.amount : null));
+  const totalAmount = isConversionNeeded
+    ? (bookingAmountData != null ? Math.round(bookingAmountData.amount * 100) : (reviewedTotal ?? 0))
+    : (reviewedTotal ?? (bookingAmountData != null ? Math.round(bookingAmountData.amount * 100) : 0));
+  const confirmedCurrency = isConversionNeeded ? (bookingAmountData?.currency || amountCurrency) : displayCurrency;
 
-  // Show loading spinner only when the API hasn't responded AND we have no review-page
-  // total to fall back on — once reviewedTotalMinor is set the button is always enabled.
-  const awaitingAmount = !isPackage && loadingAmount && totalAmountDisplay === null;
+  // Show loading spinner while the converted amount is still in flight for a
+  // currency-specific method; ETB methods always have the reviewed total instantly.
+  const awaitingAmount = !isPackage && isConversionNeeded && loadingAmount && totalAmountDisplay === null;
 
   useEffect(() => {
-    // Always store the reviewed total (minor, ETB) as the paid amount — it's what was
-    // shown to the user and matches the fare breakdown. The API amount is only used as
-    // the charge sent to the provider (may differ due to currency conversion).
-    if (reviewedTotal != null) {
+    // Once a currency-specific payment method's converted amount has loaded, that's the
+    // real charge amount and currency — store it as the paid amount. Otherwise fall back
+    // to the reviewed ETB total shown on the review page.
+    if (isConversionNeeded && bookingAmountData != null) {
+      setCurrency(confirmedCurrency as 'ETB' | 'DJF' | 'USD');
+      setPaidAmount(Math.round(bookingAmountData.amount * 100));
+    } else if (reviewedTotal != null) {
       setCurrency('ETB');
       setPaidAmount(reviewedTotal);
     } else if (bookingAmountData != null) {
       setCurrency(confirmedCurrency as 'ETB' | 'DJF' | 'USD');
       setPaidAmount(Math.round(bookingAmountData.amount * 100));
     }
-  }, [bookingAmountData, confirmedCurrency, reviewedTotal, setCurrency, setPaidAmount]);
+  }, [isConversionNeeded, bookingAmountData, confirmedCurrency, reviewedTotal, setCurrency, setPaidAmount]);
 
   const paymentMutation = useMutation({
     mutationFn: async (data: any) => {
@@ -145,9 +159,6 @@ export default function PaymentPage() {
     setIsProcessing(true);
     setPaymentError(null);
 
-    // Find the selected payment method to get its ID
-    const selectedPaymentMethod = paymentMethods.find(m => m.type === selectedMethod);
-    
     if (!selectedPaymentMethod) {
       alert("Invalid payment method selected");
       setIsProcessing(false);
@@ -320,6 +331,11 @@ export default function PaymentPage() {
             )}
           </span>
         </div>
+        {selectedPaymentMethod && !awaitingAmount && (
+          <p className="text-xs text-gray-500 dark:text-gray-400 text-right mt-1">
+            You will be charged {confirmedCurrency} {(totalAmountDisplay ?? 0).toFixed(2)} via {selectedPaymentMethod.displayName}
+          </p>
+        )}
       </div>
 
       {/* Pay + back buttons — desktop sidebar only */}
diff --git a/apps/edr-passenger-web/portal/src/app/booking/payment/telebirr/failure/page.tsx b/apps/edr-passenger-web/portal/src/app/booking/payment/telebirr/failure/page.tsx
index 773afc79f..6ea64036b 100644
--- a/apps/edr-passenger-web/portal/src/app/booking/payment/telebirr/failure/page.tsx
+++ b/apps/edr-passenger-web/portal/src/app/booking/payment/telebirr/failure/page.tsx
@@ -2,13 +2,18 @@
 
 import { useSearchParams, useRouter } from 'next/navigation';
 import { usePaymentStore } from '@/lib/payment-store';
-import { useEffect, Suspense } from 'react';
+import { consumeManageBookingPaymentReturn } from '@/utils/manage-booking-return';
+import { useEffect, useState, Suspense } from 'react';
 import { XCircle, Loader2, ChevronLeft } from 'lucide-react';
 
 function TelebirrFailureContent() {
   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');
 
   const merchantOrderId = searchParams.get('merchantOrderId') || '';
   const trxRef     = searchParams.get('trxRef')     || searchParams.get('outTradeNo') || '';
@@ -16,6 +21,10 @@ function TelebirrFailureContent() {
   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
   }, []);
@@ -30,10 +39,10 @@ function TelebirrFailureContent() {
         {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('/booking/review')}
+          <button onClick={() => router.push(backTarget)}
             className="btn-secondary w-full flex items-center justify-center gap-2">
             <ChevronLeft className="w-4 h-4" />
-            Back to Review
+            Back
           </button>
         </div>
       </div>
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 9b190fbf2..1a830cee3 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
@@ -2,45 +2,33 @@
 
 import { useEffect, useState } from 'react';
 import { useRouter, useSearchParams } from 'next/navigation';
-import { useBookingStore } from '@/lib/booking-store';
 import { usePaymentStore } from '@/lib/payment-store';
-import { apiClient } from '@/lib/api-client';
+import { consumeManageBookingPaymentReturn } from '@/utils/manage-booking-return';
 import { CheckCircle, Loader2 } from 'lucide-react';
 import { Suspense } from 'react';
 
 function TelebirrSuccessContent() {
   const router = useRouter();
   const searchParams = useSearchParams();
-  const { bookingId } = useBookingStore();
   const { updateStatus } = usePaymentStore();
   const [status, setStatus] = useState<'processing' | 'done' | 'error'>('processing');
+  const [returnTarget, setReturnTarget] = useState('/booking/confirmation');
 
   // Telebirr callback query params
-  const orderid      = searchParams.get('orderid')      || '';
-  const trxRef       = searchParams.get('trxRef')       || searchParams.get('outTradeNo') || '';
-  const bookingIdQp  = searchParams.get('bookingId')    || bookingId || '';
+  const orderid = searchParams.get('orderid') || '';
+  const trxRef  = searchParams.get('trxRef')  || searchParams.get('outTradeNo') || '';
 
   useEffect(() => {
-    const confirm = async () => {
-      try {
-        if (bookingIdQp) {
-          await apiClient.patch(`/bookings/${bookingIdQp}/confirm`, {
-            paymentReference: orderid || trxRef,
-            paymentMethod: 'TELEBIRR',
-          });
-        }
-
-        updateStatus('SUCCEEDED');
-        setStatus('done');
-        setTimeout(() => router.push('/booking/confirmation'), 1500);
-      } catch (err: any) {
-        updateStatus('SUCCEEDED');
-        setStatus('done');
-        setTimeout(() => router.push('/booking/confirmation'), 1500);
-      }
-    };
-
-    confirm();
+    // 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.
+    const manageBookingRef = consumeManageBookingPaymentReturn();
+    const target = manageBookingRef ? `/booking/detail?ref=${encodeURIComponent(manageBookingRef)}` : '/booking/confirmation';
+    setReturnTarget(target);
+    updateStatus('SUCCEEDED');
+    setStatus('done');
+    setTimeout(() => router.push(target), 1500);
   // eslint-disable-next-line react-hooks/exhaustive-deps
   }, []);
 
@@ -61,7 +49,7 @@ function TelebirrSuccessContent() {
             <p className="text-sm text-gray-500 dark:text-gray-400 mb-1">Your Telebirr payment was received.</p>
             {orderid && <p className="text-xs text-gray-400">Order ID: {orderid}</p>}
             {trxRef && <p className="text-xs text-gray-400">Transaction Ref: {trxRef}</p>}
-            <p className="text-xs text-gray-400 mt-3">Redirecting to your booking confirmation…</p>
+            <p className="text-xs text-gray-400 mt-3">Redirecting…</p>
           </>
         )}
         {status === 'error' && (
@@ -71,8 +59,8 @@ function TelebirrSuccessContent() {
             </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>
-            <button onClick={() => router.push('/booking/confirmation')}
-              className="btn-primary w-full">Go to confirmation</button>
+            <button onClick={() => router.push(returnTarget)}
+              className="btn-primary w-full">Continue</button>
           </>
         )}
       </div>
diff --git a/apps/edr-passenger-web/portal/src/app/booking/payment/waafi/failure/page.tsx b/apps/edr-passenger-web/portal/src/app/booking/payment/waafi/failure/page.tsx
index 6a32c388b..7d5d4566b 100644
--- a/apps/edr-passenger-web/portal/src/app/booking/payment/waafi/failure/page.tsx
+++ b/apps/edr-passenger-web/portal/src/app/booking/payment/waafi/failure/page.tsx
@@ -2,13 +2,18 @@
 
 import { useSearchParams, useRouter } from 'next/navigation';
 import { usePaymentStore } from '@/lib/payment-store';
-import { useEffect, Suspense } from 'react';
+import { consumeManageBookingPaymentReturn } from '@/utils/manage-booking-return';
+import { useEffect, useState, Suspense } from 'react';
 import { XCircle, Loader2, ChevronLeft } from 'lucide-react';
 
 function WaafiFailureContent() {
   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');
 
   const referenceId  = searchParams.get('referenceId')  || '';
   const responseCode = searchParams.get('responseCode') || '';
@@ -17,6 +22,10 @@ function WaafiFailureContent() {
   const state        = searchParams.get('state')        || '';
 
   useEffect(() => {
+    const manageBookingRef = consumeManageBookingPaymentReturn();
+    if (manageBookingRef) {
+      setBackTarget(`/booking/detail?ref=${encodeURIComponent(manageBookingRef)}`);
+    }
     updateStatus('FAILED');
   // eslint-disable-next-line react-hooks/exhaustive-deps
   }, []);
@@ -33,10 +42,10 @@ function WaafiFailureContent() {
           <p className="text-xs text-gray-400 mb-4">Ref: {referenceId || transactionId}</p>
         )}
         <div className="flex flex-col gap-3 mt-4">
-          <button onClick={() => router.push('/booking/review')}
+          <button onClick={() => router.push(backTarget)}
             className="btn-secondary w-full flex items-center justify-center gap-2">
             <ChevronLeft className="w-4 h-4" />
-            Back to Review
+            Back
           </button>
         </div>
       </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 073cd610b..c75a0c390 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
@@ -2,57 +2,32 @@
 
 import { useEffect, useState, Suspense } from 'react';
 import { useRouter, useSearchParams } from 'next/navigation';
-import { useBookingStore } from '@/lib/booking-store';
 import { usePaymentStore } from '@/lib/payment-store';
-import { apiClient } from '@/lib/api-client';
+import { consumeManageBookingPaymentReturn } from '@/utils/manage-booking-return';
 import { CheckCircle, Loader2 } from 'lucide-react';
 
 function WaafiSuccessContent() {
   const router = useRouter();
   const searchParams = useSearchParams();
-  const { bookingId } = useBookingStore();
   const { updateStatus } = usePaymentStore();
   const [status, setStatus] = useState<'processing' | 'done' | 'error'>('processing');
 
   // Waafi callback query params
-  const accountNo    = searchParams.get('accountNo')    || '';
-  const currency     = searchParams.get('currency')     || '';
-  const referenceId  = searchParams.get('referenceId')  || '';
-  const state        = searchParams.get('state')        || '';
+  const referenceId   = searchParams.get('referenceId')   || '';
   const transactionId = searchParams.get('transactionId') || '';
-  const txAmount     = searchParams.get('txAmount')     || '';
-  const timestamp    = searchParams.get('timestamp')    || '';
-  const bookingIdQp  = searchParams.get('bookingId')    || bookingId || '';
+  const txAmount      = searchParams.get('txAmount')       || '';
+  const currency      = searchParams.get('currency')       || '';
 
   useEffect(() => {
-    const confirm = async () => {
-      try {
-        if (bookingIdQp) {
-          await apiClient.patch(`/bookings/${bookingIdQp}/confirm`, {
-            paymentReference: referenceId || transactionId,
-            paymentMethod: 'WAAFI',
-            transactionDetails: {
-              transactionId,
-              accountNo,
-              amount: txAmount,
-              currency,
-              state,
-              timestamp,
-            },
-          });
-        }
-
-        updateStatus('SUCCEEDED');
-        setStatus('done');
-        setTimeout(() => router.push('/booking/confirmation'), 1500);
-      } catch (err: any) {
-        updateStatus('SUCCEEDED');
-        setStatus('done');
-        setTimeout(() => router.push('/booking/confirmation'), 1500);
-      }
-    };
-
-    confirm();
+    // 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.
+    const manageBookingRef = consumeManageBookingPaymentReturn();
+    const target = manageBookingRef ? `/booking/detail?ref=${encodeURIComponent(manageBookingRef)}` : '/booking/confirmation';
+    updateStatus('SUCCEEDED');
+    setStatus('done');
+    setTimeout(() => router.push(target), 1500);
   // eslint-disable-next-line react-hooks/exhaustive-deps
   }, []);
 
@@ -76,7 +51,7 @@ function WaafiSuccessContent() {
             {txAmount && currency && (
               <p className="text-xs text-gray-400">Amount: {txAmount} {currency}</p>
             )}
-            <p className="text-xs text-gray-400 mt-3">Redirecting to your booking confirmation…</p>
+            <p className="text-xs text-gray-400 mt-3">Redirecting…</p>
           </>
         )}
       </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 b94b9ee14..66f91dd60 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,39 +193,68 @@ export default function ResultsPage() {
       outboundSchedules = results.data;
     }
   }
-  
-  // For one-way, check if outbound has results
-  // For round-trip, check if BOTH outbound and inbound have results
+
+  // 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 && inboundSchedules.length > 0)
+    ? outboundSchedules.length > 0 ||
+      alternativeOutbound.length > 0 ||
+      inboundSchedules.length > 0 ||
+      alternativeInbound.length > 0
     : outboundSchedules.length > 0;
 
-  // One-way searches that come back with an empty outbound list may still include
-  // date-shifted alternatives from the API — surface those instead of a dead end.
-  const isOneWayNoOutbound = !isRoundTrip && !!results && outboundSchedules.length === 0;
-  const alternativeOutbound: Schedule[] = isOneWayNoOutbound ? (results.alternativeOutbound || []) : [];
-  const requestedDate: string = (results && results.requestedDate) || searchData.date;
-
-  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;
@@ -183,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,
@@ -198,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 || [],
@@ -209,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;
     }
 
@@ -222,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
@@ -232,118 +314,164 @@ 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 ${
-                          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'
-                        }`}
-                        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>
-                        )}
+                  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 ${
+                        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"
+                      }`}
+                      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>
+                      )}
 
-                        <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"
@@ -363,43 +491,54 @@ 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>
+                    </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 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>
               )}
             </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>
-                )}
-              </div>
-            </div>
+          </div>
         </div>
         <style>{`
           @keyframes drawer-slide-in{from{transform:translateX(100%)}to{transform:translateX(0)}}
@@ -410,44 +549,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>
         )}
@@ -458,20 +622,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">
@@ -493,35 +667,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>
@@ -553,10 +749,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>
@@ -571,18 +767,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>
@@ -590,50 +792,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>
@@ -641,21 +861,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>
@@ -676,9 +904,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>
@@ -687,12 +922,46 @@ export default function ResultsPage() {
   }
 
   if (!hasResults) {
-    // ONE_WAY search with an explicit empty outbound list — surface any date-shifted
-    // alternatives the API suggests instead of a dead-end "no trains found" screen.
+    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">
+                  <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>
+                <p className="text-gray-600 dark:text-gray-400 mb-8">
+                  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>
+              </div>
+            </div>
+          </div>
+        </div>
+      );
+    }
+
     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 (
@@ -704,14 +973,19 @@ export default function ResultsPage() {
                 <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">
                   <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>
@@ -719,13 +993,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>
               )}
@@ -743,11 +1022,17 @@ export default function ResultsPage() {
               <div className="w-20 h-20 bg-gray-100 dark:bg-gray-800 rounded-full flex 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>
@@ -761,37 +1046,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">
@@ -799,11 +1093,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>
@@ -812,11 +1108,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">
@@ -829,7 +1132,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">
@@ -837,12 +1140,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" />
+                          </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>
+                      </div>
+                    )}
                 </div>
               ) : (
                 <div>
@@ -853,20 +1203,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;
@@ -885,17 +1240,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" />
+                          </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>
+                      </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 194b47dff..c5d897a13 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
@@ -47,7 +47,7 @@ function getPassengerIdFromToken(token: string): string | null {
 
 export default function ReviewPage() {
   const router = useRouter();
-  const { selectedSchedule, outboundSchedule, inboundSchedule, passengers, seatHold, setBookingId, setPNR, setReviewedTotal, createAccount, passengerId: storedPassengerId, searchCriteria, packageId, priceTierId, packageTierPriceMinor, packageName } = useBookingStore();
+  const { selectedSchedule, outboundSchedule, inboundSchedule, passengers, seatHold, bookingId, pnr, bookingHoldId, bookingReturnHoldId, reviewedTotalMinor, setBookingId, setPNR, setBookingHoldReference, setReviewedTotal, createAccount, passengerId: storedPassengerId, searchCriteria, packageId, priceTierId, packageTierPriceMinor, packageName } = useBookingStore();
   const { user, isAuthenticated } = useAuthStore();
   const [timeLeft, setTimeLeft] = useState<string>('');
   const [seatDetails, setSeatDetails] = useState<Record<string, string>>({});
@@ -149,6 +149,31 @@ export default function ReviewPage() {
     fetchSeatDetails();
   }, [selectedSchedule?.id, outboundSchedule?.id, inboundSchedule?.id, passengers, isRoundTrip]);
 
+  const isPackageBooking = packageTierPriceMinor !== null || !!packageName;
+  const adultPassengerCount = searchCriteria?.adultCount ?? passengers.filter(p => !isChild(p)).length;
+  const pkgAdultFare = isPackageBooking && packageTierPriceMinor != null ? packageTierPriceMinor * 2 : 0;
+  const pkgChildFare = pkgAdultFare;
+
+  const isPackageChild = (index: number) =>
+    isPackageBooking ? index >= adultPassengerCount : isChild(passengers[index]);
+
+  const isPkgFreeChild = (index: number) => {
+    if (!isPackageBooking) return false;
+    if (!isPackageChild(index)) return false;
+    const childIndex = index - adultPassengerCount;
+    return childIndex < adultPassengerCount;
+  };
+
+  const getPassengerSeatFare = (p: any): number | null => {
+    if (isRoundTrip) {
+      if (p.outboundSeatFareMinor == null && p.inboundSeatFareMinor == null) return null;
+      if (isPackageBooking) return (p.outboundSeatFareMinor ?? 0) * 2;
+      return (p.outboundSeatFareMinor ?? 0) + (p.inboundSeatFareMinor ?? 0);
+    }
+    if (p.seatFareMinor == null) return null;
+    return isPackageBooking ? p.seatFareMinor * 2 : p.seatFareMinor;
+  };
+
   const createBookingMutation = useMutation({
     mutationFn: (data: any) => {
       const endpoint = isAuthenticated ? '/bookings' : '/bookings/guest';
@@ -159,6 +184,11 @@ export default function ReviewPage() {
       const pnrValue = data.pnr || data.bookingReference || data.bookingRef;
       setBookingId(bookingIdValue);
       setPNR(pnrValue);
+      // Remember which hold(s) this booking was created from, so if the user comes back
+      // here (e.g. hitting "back" from the payment gateway) with the same hold still in
+      // the store, we can detect it's the same booking and reuse it instead of creating
+      // another one.
+      setBookingHoldReference(seatHold?.holdId || null, seatHold?.returnHoldId || null);
       const totalAmount = data.totalMinor || data.totalAmount || 0;
       setTimeout(() => {
         if (totalAmount > 0) {
@@ -177,7 +207,21 @@ export default function ReviewPage() {
   const handleConfirm = async () => {
     try {
       const { searchCriteria } = useBookingStore.getState();
-      
+
+      // A booking already exists for the exact hold(s) currently in the store — e.g. the
+      // user was sent to the payment gateway and hit "back". Reuse it instead of creating
+      // a duplicate booking; just resume the payment step.
+      const sameHoldAsExistingBooking =
+        !!bookingId &&
+        !!pnr &&
+        !!seatHold?.holdId &&
+        seatHold.holdId === bookingHoldId &&
+        (isRoundTrip ? (seatHold.returnHoldId || null) === bookingReturnHoldId : true);
+      if (sameHoldAsExistingBooking) {
+        router.push((reviewedTotalMinor ?? 0) > 0 ? '/booking/payment' : '/booking/confirmation');
+        return;
+      }
+
       if (!seatHold?.holdId) {
         alert('Please select seats before continuing.');
         router.push('/booking/seats');
@@ -393,8 +437,9 @@ export default function ReviewPage() {
           ? (isChildPassenger && (i - adultPassengerCount) < adultPassengerCount)
           : (line?.isFree ?? (isChild(p) && isFirstChild(passengers, i)));
         const seatFare = getPassengerSeatFare(p);
+        const pkgFallback = isChildPassenger ? pkgChildFare : pkgAdultFare;
         const fareMinor = isPackageBooking
-          ? (isFreeChild ? 0 : (isChildPassenger ? pkgChildFare : pkgAdultFare))
+          ? (isFreeChild ? 0 : (seatFare ?? pkgFallback))
           : (isFreeChild ? 0 : (seatFare ?? line?.fareMinor ?? 0));
         return { fareMinor, isFree: isFreeChild };
       });
@@ -423,7 +468,7 @@ export default function ReviewPage() {
 
   const fetchFareBreakdown = useCallback(async (scheduleId: string, originStationId: string, destinationStationId: string) => {
     // Package bookings use the stored tier price — no fare calculation needed
-    if (packageTierPriceMinor !== null) return;
+    if (isPackageBooking) return;
 
     try {
       const seatClasses: any[] = await apiClient.get('/seat-classes');
@@ -433,9 +478,6 @@ export default function ReviewPage() {
       const fallbackSeatClassId = seatClasses.find((sc: any) => sc.name === scheduleSeatClassName)?.id || seatClasses[0]?.id;
       if (!fallbackSeatClassId) return;
 
-      // Bed coaches price Upper/Middle/Lower as separate classes, so a passenger's own
-      // assigned berth (captured on the seats page) must resolve its own seatClassId here
-      // — a single shared class can't correctly price passengers in different berths.
       const resolveSeatClassId = (p: any): string => {
         const bedPosition: string | undefined = isRoundTrip ? (p as any).outboundBedPosition : (p as any).bedPosition;
         if (!bedPosition) return fallbackSeatClassId;
@@ -465,7 +507,7 @@ export default function ReviewPage() {
       setFareBreakdown(result);
     } catch (err) {
     }
-  }, [packageTierPriceMinor, passengers, selectedSchedule, outboundSchedule, isRoundTrip, searchCriteria, displayCurrency]);
+  }, [isPackageBooking, passengers, selectedSchedule, outboundSchedule, isRoundTrip, searchCriteria, displayCurrency]);
 
   useEffect(() => {
     if (!searchCriteria?.originStationId || !searchCriteria?.destinationStationId) return;
@@ -474,37 +516,17 @@ export default function ReviewPage() {
     fetchFareBreakdown(scheduleId, searchCriteria.originStationId, searchCriteria.destinationStationId);
   }, [fetchFareBreakdown, isRoundTrip, outboundSchedule?.id, selectedSchedule?.id, searchCriteria?.originStationId, searchCriteria?.destinationStationId]);
 
-  const isPackageBooking = packageTierPriceMinor !== null;
-  // packageTierPriceMinor is the per-adult fare for ONE leg.
-  // Round-trip packages multiply by 2.
-  // First child per adult travels FREE; additional children pay full adult fare.
-  const adultPassengerCount = searchCriteria?.adultCount ?? passengers.filter(p => !isChild(p)).length;
-  const childPassengerCount = searchCriteria?.childCount ?? passengers.filter(p => isChild(p)).length;
-  const pkgRoundTripMultiplier = isPackageBooking && isRoundTrip ? 2 : 1;
-  const pkgAdultFare = isPackageBooking ? packageTierPriceMinor! * pkgRoundTripMultiplier : 0;
-  const pkgPaidChildrenCount = Math.max(0, childPassengerCount - adultPassengerCount);
-  // Paid children pay full adult fare
-  const pkgChildFare = pkgAdultFare; // full fare for paid children
-
   // For package bookings, passengers are initialized without dateOfBirth so isChild() is
   // unreliable. Use the stored adultCount from searchCriteria to determine category by index.
-  const isPackageChild = (index: number) =>
-    isPackageBooking ? index >= adultPassengerCount : isChild(passengers[index]);
-
-  // Per-seat fare captured on the seats page (bed-position-aware, computed locally from
-  // the schedule's own coachTypes/classes) is guaranteed correct for berths, unlike the
-  // backend /search/fare-breakdown call whose seatClassId matching for bed positions can't
-  // be verified here. Prefer it whenever the passenger actually has an assigned seat.
-  const getPassengerSeatFare = (p: any): number | null => {
-    if (isRoundTrip) {
-      if (p.outboundSeatFareMinor == null && p.inboundSeatFareMinor == null) return null;
-      return (p.outboundSeatFareMinor ?? 0) + (p.inboundSeatFareMinor ?? 0);
-    }
-    return p.seatFareMinor ?? null;
-  };
-
   const total = isPackageBooking
-    ? adultPassengerCount * pkgAdultFare + pkgPaidChildrenCount * pkgChildFare
+    ? passengers.reduce((sum, p, i) => {
+        const isChild_ = isPackageChild(i);
+        const isFreeChild = isChild_ && (i - adultPassengerCount) < adultPassengerCount;
+        if (isFreeChild) return sum;
+        const seatFare = getPassengerSeatFare(p);
+        const pkgFallback = isChild_ ? pkgChildFare : pkgAdultFare;
+        return sum + (seatFare ?? pkgFallback);
+      }, 0)
     : passengers.reduce((sum, p, i) => {
         const isChildPassenger = isChild(p);
         const line = fareBreakdown?.passengers?.[i];
@@ -517,16 +539,6 @@ export default function ReviewPage() {
   // Keep computedTotal in sync so handleConfirm can persist it to the store
   useEffect(() => { setComputedTotal(total); }, [total]);
 
-  // For package bookings, determine if a child is free (first per adult) or paid.
-  // Children are ordered after adults in the passengers array (set on package detail page).
-  const isPkgFreeChild = (index: number) => {
-    if (!isPackageBooking) return false;
-    if (!isPackageChild(index)) return false;
-    // childIndex = position among children (0-based)
-    const childIndex = index - adultPassengerCount;
-    return childIndex < adultPassengerCount; // first adultCount children are free
-  };
-
   // Shared fare sidebar — rendered in right column (desktop) and inline (mobile)
   const FareSidebar = () => (
     <div className="card space-y-3">
@@ -541,7 +553,7 @@ export default function ReviewPage() {
           : (line?.isFree ?? (isChild(p) && isFirstChild(passengers, i)));
         const seatFare = getPassengerSeatFare(p);
         const passengerTotal = isPackageBooking
-          ? (isFreeChild ? 0 : (isChildPassenger ? pkgChildFare : pkgAdultFare))
+          ? (isFreeChild ? 0 : (seatFare ?? (isChildPassenger ? pkgChildFare : pkgAdultFare)))
           : (isFreeChild ? 0 : (seatFare ?? line?.fareMinor ?? 0));
 
         return (
@@ -618,9 +630,6 @@ export default function ReviewPage() {
                 <div className="flex items-center gap-2 mb-6 pb-4 border-b border-gray-100 dark:border-gray-800">
                   <div className="w-2 h-2 bg-primary rounded-full" />
                   <h2 className="text-lg font-bold text-gray-900 dark:text-gray-100">Outbound Journey</h2>
-                  <span className="ml-auto text-xs px-2.5 py-1 bg-primary/10 text-primary rounded-full font-semibold">
-                    {outboundSchedule.selectedSeatClass?.replace(/_/g, ' ') || 'Standard'}
-                  </span>
                 </div>
                 
                 {/* Flight-style timeline */}
@@ -695,9 +704,6 @@ export default function ReviewPage() {
                 <div className="flex items-center gap-2 mb-6 pb-4 border-b border-gray-100 dark:border-gray-800">
                   <div className="w-2 h-2 bg-blue-500 rounded-full" />
                   <h2 className="text-lg font-bold text-gray-900 dark:text-gray-100">Return Journey</h2>
-                  <span className="ml-auto text-xs px-2.5 py-1 bg-blue-500/10 text-blue-600 dark:text-blue-400 rounded-full font-semibold">
-                    {inboundSchedule.selectedSeatClass?.replace(/_/g, ' ') || 'Standard'}
-                  </span>
                 </div>
                 
                 {/* Flight-style timeline */}
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..786196731 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}
@@ -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}
@@ -1141,19 +1202,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 hover:border-gray-300 transition-all ${
+                              showNationalityError ? "border-red-400" : "border-gray-200"
+                            }`}
                           >
                             <span className="flex items-center gap-1.5 text-sm font-medium text-gray-900 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 +1459,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 b0a7e8fd8..9ae90c08b 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
@@ -164,6 +164,7 @@ export default function SeatsPage() {
     outboundSchedule,
     inboundSchedule,
     passengers,
+    seatHold,
     setSeatHold,
     setPassengers,
     setSelectedSchedule,
@@ -172,6 +173,12 @@ export default function SeatsPage() {
     searchCriteria,
     bookingId,
     packageName,
+    packageId,
+    priceTierId,
+    packageTierPriceMinor,
+    packageDepartureStationId,
+    packageDepartureStationName,
+    setPackageContext,
   } = useBookingStore();
   // Maps passenger index -> assigned seat id. A passenger can only get a seat while
   // they are the "active" passenger, which prevents bulk/batch selection across passengers.
@@ -197,9 +204,16 @@ export default function SeatsPage() {
     type: "info" as "warning" | "error" | "success" | "info",
     onConfirm: undefined as (() => void) | undefined,
     showCancel: false,
+    confirmText: "OK",
   });
+  const [autoAssigningReturn, setAutoAssigningReturn] = useState(false);
+  // Mobile summary bottom-sheet starts collapsed to a slim bar (badge + Continue button) so
+  // it doesn't cover the seat map — the full passenger list/progress bar only shows once the
+  // user explicitly expands it.
+  const [mobileSummaryExpanded, setMobileSummaryExpanded] = useState(false);
 
   const isRoundTrip = searchCriteria?.tripType === "ROUND_TRIP";
+  const isPackageBooking = !!packageName;
   const currentSchedule =
     isRoundTrip && currentJourneyType === "inbound"
       ? inboundSchedule
@@ -211,6 +225,29 @@ export default function SeatsPage() {
     ? currentJourneyType === "inbound" ? "RETURN" : "OUTBOUND"
     : "ONE_WAY";
 
+  // The hold id/expiry that already covers the CURRENT leg, if any — used to avoid
+  // creating a second, redundant hold when the user navigates back to this page (e.g.
+  // browser back button, or bouncing between passengers/seats) without actually changing
+  // their seat pick.
+  const currentLegHoldId = isRoundTrip && currentJourneyType === "inbound" ? seatHold?.returnHoldId : seatHold?.holdId;
+  const currentLegHoldExpiresAt = isRoundTrip && currentJourneyType === "inbound" ? seatHold?.returnExpiresAt : seatHold?.expiresAt;
+  const isCurrentLegHoldValid =
+    !!currentLegHoldId && (!currentLegHoldExpiresAt || new Date(currentLegHoldExpiresAt).getTime() > Date.now());
+
+  // The seat id(s) already recorded against each passenger for the current leg from a
+  // previous pass through this page (persisted in the store) — the counterpart of the
+  // hold above, so we can tell whether the current on-screen selection actually differs
+  // from what's already held.
+  const previouslyHeldSeatIds = useMemo(
+    () =>
+      passengers.map((p) =>
+        isRoundTrip
+          ? (currentJourneyType === "inbound" ? (p as any).inboundSeatId : (p as any).outboundSeatId)
+          : (p as any).seatId,
+      ),
+    [passengers, isRoundTrip, currentJourneyType],
+  );
+
   // Baseline fare for each leg as it was when this page first loaded — i.e. whatever was
   // picked on the results page ("starting from" price). Captured once and never
   // overwritten, so a later coach-type switch (or just picking a pricier berth) can still
@@ -267,6 +304,35 @@ export default function SeatsPage() {
     [passengers, seatEligibility],
   );
 
+  // If this leg already has a valid (unexpired) hold from a previous pass through this
+  // page — e.g. the user hit "back" from a later step — restore the seat(s) that hold
+  // actually covers instead of leaving the seat map blank and letting them pick (and
+  // hold) another seat on top of it. Runs once per leg; the ref stops it from fighting a
+  // deliberate deselect/re-pick afterwards.
+  const restoredLegRef = useRef<string | null>(null);
+  // Indices whose current passengerSeatMap entry came from the restoration above, not a
+  // deliberate click this visit. A passenger's next click should be treated as their
+  // 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());
+  useEffect(() => {
+    const legKey = `${currentSchedule?.id || ''}-${currentJourneyType}`;
+    if (restoredLegRef.current === legKey) return;
+    restoredLegRef.current = legKey;
+
+    if (!isCurrentLegHoldValid) return;
+
+    const restored: Record<number, string> = {};
+    seatEligibleIndices.forEach((i) => {
+      const seatId = previouslyHeldSeatIds[i];
+      if (seatId) restored[i] = seatId;
+    });
+    if (Object.keys(restored).length > 0) {
+      setPassengerSeatMap(restored);
+      restoredIndicesRef.current = new Set(Object.keys(restored).map(Number));
+    }
+  }, [currentSchedule?.id, currentJourneyType, isCurrentLegHoldValid, seatEligibleIndices, previouslyHeldSeatIds]);
+
   const {
     data: seatMapData,
     isLoading,
@@ -306,8 +372,10 @@ export default function SeatsPage() {
     return raw
       .map((c: any, idx: number) => ({
         id: c.id || c.coachId || String(idx),
+        coachId: c.coachId || c.id || null,
         label: c.label || c.coachNumber || c.name || c.coachTypeName || `Coach ${idx + 1}`,
         type: String(c.type || c.coachType || c.category || c.coachTypeCode || c.coachTypeName || ""),
+        coachTypeName: String(c.coachTypeName || c.type || c.coachType || c.category || ""),
         typeName: c.coachTypeName || c.coachType || c.category || c.type || "",
         coachTypeId: c.coachTypeId ?? c.typeId ?? null,
         remainingSeats: c.remainingSeats ?? c.availableSeats ?? c.available ?? null,
@@ -316,6 +384,22 @@ export default function SeatsPage() {
       .sort((a: any, b: any) => a.sequence - b.sequence);
   }, [trainCoachesData]);
 
+  // Resolve the CoachType UUID for a preview-list coach. The preview API now returns
+  // coachTypeId directly; fall back to cross-referencing the seatmap data for older
+  // API versions that may not include it.
+  const resolveCoachTypeIdFromSeatmap = useCallback((previewCoach: any): string | null => {
+    if (previewCoach.coachTypeId) return previewCoach.coachTypeId;
+    // Fallback: match by label against the current seatmap coaches
+    const previewLabel = previewCoach.label || previewCoach.coachNumber || "";
+    const allSeatmapCoaches: any[] = (seatMapData as any)?.coaches || (seatMapData as any)?.data?.coaches || [];
+    const match = allSeatmapCoaches.find(
+      (c: any) => (c.label || c.coachNumber || "") === previewLabel ||
+                  c.id === previewCoach.coachId ||
+                  c.id === previewCoach.id
+    );
+    return match?.coachTypeId ?? null;
+  }, [seatMapData]);
+
   const isDiningCoachType = (type: string) => /dining|dpc/i.test(type);
 
   // Looks up a coach type's lowest per-adult fare from the coach-type/fare data captured
@@ -343,10 +427,10 @@ export default function SeatsPage() {
   const getSeatFare = useCallback(
     (seat: any): number | null => {
       if (!currentCoachTypeClasses.length) return null;
-      if (seat?.bedPosition) {
+      if (seat?.bedPosition) {        
         const match = currentCoachTypeClasses.find((c: any) =>
           c.name?.toLowerCase().includes(seat.bedPosition),
-        );
+        );        
         if (match) return match.baseFareMinor;
       }
       const regular = currentCoachTypeClasses.find((c: any) => /regular/i.test(c.name || ""));
@@ -363,17 +447,15 @@ export default function SeatsPage() {
   const applyCoachTypeSwitch = (coach: any, matchedType: any) => {
     const newFare = getCoachTypeFare(matchedType.coachTypeId || matchedType.coachId);
     const firstClass = matchedType.classes?.[0];
+    const newCoachTypeId = matchedType.coachTypeId || matchedType.coachId;
     const updatedSchedule = {
       ...(currentSchedule as any),
-      selectedCoachTypeId: matchedType.coachTypeId || matchedType.coachId,
-      selectedCoachTypeCode: matchedType.coachTypeCode,
-      selectedCoachTypeName: matchedType.coachTypeName,
-      selectedSeatClass: firstClass?.name || matchedType.coachTypeName,
-      selectedSeatClassName: firstClass?.name || matchedType.coachTypeName,
-      // review/page.tsx's fare-breakdown request reads THIS field (not
-      // selectedSeatClassName) to resolve the seat class — must stay in sync or the
-      // review page keeps pricing against the coach type the user switched away from.
-      seatClassName: firstClass?.name || matchedType.coachTypeName,
+      selectedCoachTypeId: newCoachTypeId,
+      selectedCoachTypeCode: matchedType.coachTypeCode || coach.type || "",
+      selectedCoachTypeName: matchedType.coachTypeName || coach.coachTypeName || coach.typeName || "",
+      selectedSeatClass: firstClass?.name || matchedType.coachTypeName || coach.coachTypeName || "",
+      selectedSeatClassName: firstClass?.name || matchedType.coachTypeName || coach.coachTypeName || "",
+      seatClassName: firstClass?.name || matchedType.coachTypeName || coach.coachTypeName || "",
       baseFareAdult: newFare ?? (currentSchedule as any)?.baseFareAdult,
       baseFareChild: newFare ?? (currentSchedule as any)?.baseFareChild,
     };
@@ -382,6 +464,11 @@ export default function SeatsPage() {
       setInboundSchedule(updatedSchedule);
     } else if (isRoundTrip) {
       setOutboundSchedule(updatedSchedule);
+      // For package bookings both legs always use the same coach type — mirror the
+      // switch to the inbound schedule so the auto-assign fetches the right seatmap.
+      if (isPackageBooking && inboundSchedule) {
+        setInboundSchedule({ ...(inboundSchedule as any), ...updatedSchedule, id: inboundSchedule.id });
+      }
     } else {
       setSelectedSchedule(updatedSchedule);
     }
@@ -391,6 +478,34 @@ export default function SeatsPage() {
     setSelectedCoach(null);
     setPendingCoachLabel(coach.label);
     setShowCoachPreview(false);
+
+    // The user already confirmed this fare change in the coach-switch modal above — reset
+    // the per-leg baseline to the NEW coach type's fare so the very next seat pick is
+    // compared against it, not the stale pre-switch fare. Without this, picking any seat
+    // right after switching would immediately re-trigger the fare-change modal in
+    // handleSeatClick for a change the user already agreed to.
+    if (newFare != null) {
+      if (isRoundTrip && currentJourneyType === "inbound") {
+        originalFaresRef.current.inbound = newFare;
+      } else if (isRoundTrip) {
+        originalFaresRef.current.outbound = newFare;
+      } else {
+        originalFaresRef.current.oneWay = newFare;
+      }
+    }
+
+    // For package bookings, sync the stored tier price with the new coach type's fare
+    // so the review page totals reflect the switched coach type.
+    if (isPackageBooking && packageId && newFare != null) {
+      setPackageContext(
+        packageId,
+        priceTierId ?? '',
+        newFare,
+        packageName ?? undefined,
+        packageDepartureStationId ?? undefined,
+        packageDepartureStationName ?? undefined,
+      );
+    }
   };
 
   // Same coach type as the one already loaded — no refetch needed, just bring this
@@ -401,12 +516,6 @@ export default function SeatsPage() {
     setShowCoachPreview(false);
   };
 
-  // Coach card click handler for the Train Coach Preview: validates availability, then
-  // immediately loads that coach's seat map (switching coach type if needed) — no price
-  // confirmation here. Individual seats within a coach type/bed coach can still be priced
-  // differently (e.g. Upper/Middle/Lower berths), so the fare confirmation instead happens
-  // at the point of actually picking a seat (see handleSeatClick), once real seat data is
-  // in view.
   const handlePreviewCoachSelect = (coach: any) => {
     if (coach.remainingSeats != null && coach.remainingSeats <= 0) {
       setModalState({
@@ -416,31 +525,71 @@ export default function SeatsPage() {
         type: "warning",
         onConfirm: undefined,
         showCancel: false,
+        confirmText: "OK",
       });
       return;
     }
 
-    const types = (currentSchedule as any)?.coachTypes || [];
-    const matchedType = types.find(
-      (ct: any) =>
-        ct.coachTypeId === coach.coachTypeId ||
-        ct.coachId === coach.coachTypeId ||
-        ct.coachTypeCode === coach.type ||
-        ct.coachTypeName === coach.type,
-    );
-    const isSameType =
-      matchedType &&
-      (matchedType.coachTypeId === coachTypeId || matchedType.coachId === coachTypeId);
+    // Resolve the real CoachType UUID by cross-referencing the seatmap data,
+    // since the preview API (/seats/coaches) returns physical coach IDs, not CoachType UUIDs.
+    const resolvedCoachTypeId = resolveCoachTypeIdFromSeatmap(coach);
 
-    if (!matchedType || isSameType) {
-      // Same coach type — just bring this physical coach's seat map into view.
+    // Same coach type as currently loaded — just scroll to it.
+    // Only trust the resolved UUID; name/code comparisons are unreliable across
+    // different API responses and cause false positives for package bookings.
+    const isSameType = !!resolvedCoachTypeId && resolvedCoachTypeId === coachTypeId;
+
+    if (isSameType) {
       focusCoachInPlace(coach);
       return;
     }
 
-    // Different coach type — switch to it and load its seat map; per-seat fare
-    // confirmation (if any) happens once the user picks an actual seat.
-    applyCoachTypeSwitch(coach, matchedType);
+    // Different coach type — build matchedType from coachTypes array or synthesise.
+    const types = (currentSchedule as any)?.coachTypes || [];
+    const matchedType = types.find(
+      (ct: any) =>
+        (resolvedCoachTypeId && (ct.coachTypeId === resolvedCoachTypeId || ct.coachId === resolvedCoachTypeId)) ||
+        (coach.coachTypeName && ct.coachTypeName === coach.coachTypeName) ||
+        (coach.type && (ct.coachTypeCode === coach.type || ct.coachTypeName === coach.type)),
+    ) ?? {
+      coachTypeId: resolvedCoachTypeId,
+      coachId: resolvedCoachTypeId,
+      coachTypeName: coach.coachTypeName || coach.typeName || coach.type || "",
+      coachTypeCode: coach.type || "",
+      classes: [],
+    };
+
+    const newFare = getCoachTypeFare(matchedType.coachTypeId || matchedType.coachId);
+    const currentFare = originalFareForCurrentLeg ?? (currentSchedule as any)?.baseFareAdult ?? null;
+
+    // Always confirm when switching to a different coach type — show fare difference
+    // if known, or a generic confirmation if fares can't be resolved.
+    if (newFare != null && currentFare != null && newFare !== currentFare) {
+      setModalState({
+        isOpen: true,
+        title: "Fare Will Change",
+        message: `Switching to ${coach.label} (${matchedType.coachTypeName || coach.typeName || ""}) changes the fare to ETB ${(newFare / 100 * (isRoundTrip ? 2 : 1)).toFixed(2)} per adult (currently ETB ${(currentFare / 100 * (isRoundTrip ? 2 : 1)).toFixed(2)}). Continue?`,
+        type: "warning",
+        showCancel: true,
+        confirmText: "Switch Coach",
+        onConfirm: () => applyCoachTypeSwitch(coach, matchedType),
+      });
+      return;
+    }
+
+    // Same fare or fare unknown — still confirm the coach type switch.
+    const coachTypeName = matchedType.coachTypeName || coach.coachTypeName || coach.typeName || "";
+    setModalState({
+      isOpen: true,
+      title: "Switch Coach Type",
+      message: `Switch to ${coach.label}${coachTypeName ? ` (${coachTypeName})` : ""}?${
+        newFare != null ? ` Fare: ETB ${(newFare / 100 * (isRoundTrip ? 2 : 1)).toFixed(2)} per adult.` : " This will have a fare change."
+      }`,
+      type: "info",
+      showCancel: true,
+      confirmText: "Switch Coach",
+      onConfirm: () => applyCoachTypeSwitch(coach, matchedType),
+    });
   };
 
   const holdMutation = useMutation({
@@ -660,6 +809,8 @@ export default function SeatsPage() {
         next[activePassengerIndex] = seatId;
       }
       setPassengerSeatMap(next);
+      // Whatever happens now is a deliberate pick — no longer just a restored hold.
+      restoredIndicesRef.current.delete(activePassengerIndex);
 
       if (!isDeselecting) {
         // Move on to the next passenger who still needs a seat — one passenger at a time
@@ -680,26 +831,48 @@ export default function SeatsPage() {
       );
       if (takenByOther) return;
 
-      const isDeselecting = passengerSeatMap[activePassengerIndex] === seatId;
+      const currentSeatId = passengerSeatMap[activePassengerIndex];
+      // A seat restored from a still-valid hold (see the restore effect above) isn't a
+      // choice this passenger has made THIS visit — their next click is their first real
+      // pick, not a "change", even though the map already has an entry for them.
+      const isRestoredNotYetChosen = restoredIndicesRef.current.has(activePassengerIndex);
+      const isDeselecting = currentSeatId === seatId;
       if (isDeselecting) {
+        restoredIndicesRef.current.delete(activePassengerIndex);
         commitSeatAssignment(seatId);
         return;
       }
 
-      // Bed coaches price Upper/Middle/Lower differently, so picking a seat whose fare
-      // differs from what the user originally selected (e.g. after switching coach type
-      // via the preview, or just picking a pricier berth) — or from another passenger's
-      // already-selected seat — needs a heads-up before it's applied.
+      // A fare-change warning only makes sense when there's an actual prior selection to
+      // change FROM — either this same passenger swapping their own pick for a
+      // differently-priced one, or picking a seat priced differently from another
+      // passenger's already-selected seat this session. A passenger's very first pick has
+      // neither, so it must never trigger this modal, regardless of the coach type's
+      // "starting from" fare.
       const newSeat = validSeats?.find((s: any) => s.id === seatId);
       const newFare = newSeat ? getSeatFare(newSeat) : null;
 
       if (newFare != null) {
         let referenceFare: number | null = null;
-        let referenceLabel = "the fare you originally selected";
+        let referenceLabel = "your previously selected seat";
 
-        if (originalFareForCurrentLeg != null && originalFareForCurrentLeg !== newFare) {
-          referenceFare = originalFareForCurrentLeg;
+        if (isPackageBooking) {
+          // For package bookings, compare against the stored tier price (per leg).
+          const pkgLegFare = packageTierPriceMinor;
+          if (pkgLegFare != null && newFare !== pkgLegFare) {
+            referenceFare = pkgLegFare;
+          }
+        } else if (currentSeatId && !isRestoredNotYetChosen) {
+          // This passenger already has a different seat picked — compare against that
+          // actual, concrete selection.
+          const currentSeat = validSeats?.find((s: any) => s.id === currentSeatId);
+          const currentFare = currentSeat ? getSeatFare(currentSeat) : null;
+          if (currentFare != null && currentFare !== newFare) {
+            referenceFare = currentFare;
+          }
         } else {
+          // First pick for this passenger — only compare against another passenger's
+          // already-selected seat in this session.
           const differingEntry = Object.entries(passengerSeatMap).find(([idx, sid]) => {
             if (Number(idx) === activePassengerIndex) return false;
             const otherSeat = validSeats?.find((s: any) => s.id === sid);
@@ -719,28 +892,91 @@ export default function SeatsPage() {
           const positionLabel = newSeat?.bedPosition
             ? `${newSeat.bedPosition.charAt(0).toUpperCase()}${newSeat.bedPosition.slice(1)} berth`
             : "This seat";
+          const legMultiplier = isRoundTrip ? 2 : 1;
 
           setModalState({
             isOpen: true,
             title: "Fare Will Change",
-            message: `${positionLabel} ${seatLabel} costs ETB ${(newFare / 100).toFixed(2)}, different from ${referenceLabel}. Continue with this selection?`,
+            message: `${positionLabel} ${seatLabel} costs ETB ${(newFare / 100 * legMultiplier).toFixed(2)}, different from ${referenceLabel} (ETB ${(referenceFare / 100 * legMultiplier).toFixed(2)}). Continue with this selection?`,
             type: "warning",
             showCancel: true,
-            onConfirm: () => commitSeatAssignment(seatId),
+            confirmText: "Continue",
+            onConfirm: () => {
+              commitSeatAssignment(seatId);
+              // For package bookings, sync the stored tier price to the selected berth fare
+              // so review/payment/confirmation pages use the correct amount.
+              if (isPackageBooking && packageId) {
+                setPackageContext(
+                  packageId,
+                  priceTierId ?? '',
+                  newFare,
+                  packageName ?? undefined,
+                  packageDepartureStationId ?? undefined,
+                  packageDepartureStationName ?? undefined,
+                );
+              }
+            },
           });
           return;
         }
+
+        // No fare change — but for package bookings still sync the tier price to the
+        // actual berth fare (handles the case where the first seat picked matches the
+        // stored price but we still want it explicitly confirmed).
+        if (isPackageBooking && packageId && newFare !== packageTierPriceMinor) {
+          setPackageContext(
+            packageId,
+            priceTierId ?? '',
+            newFare,
+            packageName ?? undefined,
+            packageDepartureStationId ?? undefined,
+            packageDepartureStationName ?? undefined,
+          );
+        }
       }
 
       commitSeatAssignment(seatId);
     },
-    [passengerSeatMap, activePassengerIndex, validSeats, getSeatFare, originalFareForCurrentLeg, commitSeatAssignment],
+    [passengerSeatMap, activePassengerIndex, validSeats, getSeatFare, commitSeatAssignment, isPackageBooking, packageTierPriceMinor, packageId, priceTierId, packageName, packageDepartureStationId, packageDepartureStationName, setPackageContext, isRoundTrip],
   );
 
   const allSeatsAssigned =
     seatEligibleIndices.length > 0 &&
     seatEligibleIndices.every((i) => !!passengerSeatMap[i]);
 
+  // Only ever hold seats once per leg. If the current on-screen picks are exactly what's
+  // already held (valid, unexpired), skip the API call entirely and reuse that hold — this
+  // is what stops "back, then Continue again" from stacking up a second hold on the same
+  // seats. If the user genuinely picked different seats than what was previously held,
+  // release the stale hold first (best-effort — an already-expired/released hold shouldn't
+  // block picking the new seat(s)) before holding the new selection, so at most one hold for
+  // this leg is ever active at a time — for both guest and authenticated sessions.
+  const ensureLegHold = async (seatIdsForHold: string[]) => {
+    const selectionMatchesExistingHold =
+      isCurrentLegHoldValid &&
+      seatEligibleIndices.every((i) => passengerSeatMap[i] === previouslyHeldSeatIds[i]);
+
+    if (selectionMatchesExistingHold) {
+      return;
+    }
+
+    if (isCurrentLegHoldValid && currentLegHoldId) {
+      try {
+        // Routed through the portal's own server-side proxy (not called on the backend
+        // directly) so the release capability never appears in client-side network calls.
+        await fetch("/api/seats/release-hold", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ holdId: currentLegHoldId }),
+        });
+      } catch {
+        // Best-effort — an expired/already-released hold shouldn't block picking the new seat(s).
+      }
+    }
+
+    await holdMutation.mutateAsync(seatIdsForHold);
+  };
+
   const handleContinue = async () => {
     if (!allSeatsAssigned) return;
     // Indexed by original passenger position — holes for passengers who share a seat
@@ -751,7 +987,7 @@ export default function SeatsPage() {
 
     if (isRoundTrip && currentJourneyType === "outbound") {
       try {
-        await holdMutation.mutateAsync(seatIdsForHold);
+        await ensureLegHold(seatIdsForHold);
         const updatedPassengers = passengers.map((p, i) => {
           const seatData = validSeats?.find((s: any) => s.id === seatIds[i]);
           return {
@@ -764,6 +1000,152 @@ export default function SeatsPage() {
           };
         });
         setPassengers(updatedPassengers);
+
+        if (isPackageBooking && inboundSchedule) {
+          setAutoAssigningReturn(true);
+          try {
+            // Package bookings always use the same coach type for both legs — use the
+            // outbound's (just-confirmed) coachTypeId so a prior coach-type switch is
+            // reflected in the inbound seatmap fetch even if inboundSchedule wasn't updated.
+            const inboundCoachTypeId = (currentSchedule as any)?.selectedCoachTypeId || (inboundSchedule as any).selectedCoachTypeId;
+            const inboundOriginId = (inboundSchedule as any).originStationId || searchCriteria?.destinationStationId;
+            const inboundDestId = (inboundSchedule as any).destinationStationId || searchCriteria?.originStationId;
+
+            // Fetch the full outbound seatmap to resolve seat number/bedPosition by ID —
+            // validSeats only holds the currently-expanded coach and may be empty.
+            const outboundCoachTypeId = (currentSchedule as any)?.selectedCoachTypeId;
+            const outboundOriginId = (currentSchedule as any)?.originStationId || searchCriteria?.originStationId;
+            const outboundDestId = (currentSchedule as any)?.destinationStationId || searchCriteria?.destinationStationId;
+            const outboundMapData: any = await apiClient.get(
+              `/seats/seatmap/${currentSchedule?.id}?coachTypeId=${outboundCoachTypeId}&journeyDirection=OUTBOUND${outboundOriginId ? `&originStationId=${outboundOriginId}` : ''}${outboundDestId ? `&destinationStationId=${outboundDestId}` : ''}`
+            );
+            const outboundCoaches: any[] = (outboundMapData as any)?.coaches || (outboundMapData as any)?.data?.coaches || [];
+            const allOutboundSeats: any[] = [];
+            outboundCoaches.forEach((c: any) => {
+              if (c.rooms?.length > 0) {
+                c.rooms.forEach((r: any) => r.beds?.forEach((b: any) => allOutboundSeats.push(b)));
+              } else {
+                (c.seats || []).forEach((s: any) => allOutboundSeats.push(s));
+              }
+            });
+
+            const inboundMapData: any = await apiClient.get(
+              `/seats/seatmap/${inboundSchedule.id}?coachTypeId=${inboundCoachTypeId}&journeyDirection=RETURN${inboundOriginId ? `&originStationId=${inboundOriginId}` : ''}${inboundDestId ? `&destinationStationId=${inboundDestId}` : ''}`
+            );
+            const inboundCoaches: any[] = (inboundMapData as any)?.coaches || (inboundMapData as any)?.data?.coaches || [];
+
+            const allInboundSeats: any[] = [];
+            inboundCoaches.forEach((c: any) => {
+              const coachLabel = c.label || c.name || c.coachNumber || '';
+              if (c.rooms?.length > 0) {
+                c.rooms.forEach((r: any) => r.beds?.forEach((b: any) => allInboundSeats.push({ ...b, _coachLabel: coachLabel })));
+              } else {
+                (c.seats || []).forEach((s: any) => allInboundSeats.push({ ...s, _coachLabel: coachLabel }));
+              }
+            });
+
+            const claimedIds = new Set<string>();
+            const inboundSeatMap: Record<number, string> = {};
+
+            for (const i of seatEligibleIndices) {
+              // Resolve outbound seat from the full seatmap fetch (not validSeats which
+              // only holds the currently-expanded coach and is often empty).
+              const outboundSeat = allOutboundSeats.find((s: any) => s.id === seatIds[i]);
+              const outboundBase = outboundSeat ? (outboundSeat.number || outboundSeat.label || outboundSeat.seatNumber || '') : '';
+              const outboundBedPos: string | null = outboundSeat?.bedPosition || null;
+
+              // Priority 1: exact same seat number + same bed position
+              // Priority 2: same bed position, any available seat
+              // Priority 3: any available seat (fallback)
+              const match =
+                allInboundSeats.find((s: any) => s.status === 'AVAILABLE' && !claimedIds.has(s.id) && (s.number || s.label || s.seatNumber || '') === outboundBase && (!outboundBedPos || s.bedPosition === outboundBedPos)) ||
+                allInboundSeats.find((s: any) => s.status === 'AVAILABLE' && !claimedIds.has(s.id) && outboundBedPos && s.bedPosition === outboundBedPos) ||
+                allInboundSeats.find((s: any) => s.status === 'AVAILABLE' && !claimedIds.has(s.id));
+
+              if (match) {
+                inboundSeatMap[i] = match.id;
+                claimedIds.add(match.id);
+              }
+            }
+
+            if (claimedIds.size < seatEligibleIndices.length) {
+              // Not enough inbound seats found — fall through to manual inbound selection
+              setAutoAssigningReturn(false);
+              setCurrentJourneyType("inbound");
+              setPassengerSeatMap({});
+              setActivePassengerIndex(seatEligibleIndices[0] ?? 0);
+              setSelectedCoach(null);
+              return;
+            }
+
+            // Hold inbound seats directly — holdMutation reads currentJourneyType
+            // which is still "outbound" at this point, so we call the API directly.
+            const inboundHoldData: any = await apiClient.post('/seats/hold', {
+              scheduleId: inboundSchedule.id,
+              originStationId: inboundOriginId,
+              destinationStationId: inboundDestId,
+              journeyDirection: 'RETURN',
+              passengers: seatEligibleIndices.map((i, offset) => ({
+                passengerId: `temp-${Date.now()}-${offset}`,
+                seatId: inboundSeatMap[i],
+              })),
+            });
+
+            const currentHold = useBookingStore.getState().seatHold;
+            setSeatHold({
+              holdId: currentHold?.holdId || '',
+              expiresAt: currentHold?.expiresAt || '',
+              returnHoldId: inboundHoldData.holdId || inboundHoldData.id,
+              returnExpiresAt: inboundHoldData.expiresAt,
+            });
+
+            const withInbound = updatedPassengers.map((p, i) => {
+              const inboundSeatId = inboundSeatMap[i];
+              const inboundSeatData = inboundSeatId ? allInboundSeats.find((s: any) => s.id === inboundSeatId) : undefined;
+              return {
+                ...p,
+                inboundSeatId,
+                inboundSeatNumber: inboundSeatData ? buildSeatLabel(inboundSeatData) : '',
+                inboundCoachNumber: inboundSeatData?._coachLabel || '',
+                inboundSeatFareMinor: undefined,
+                inboundBedPosition: inboundSeatData?.bedPosition || undefined,
+              };
+            });
+            setPassengers(withInbound);
+
+            // Update the stored tier price with the actual berth fare so the review page
+            // reflects the correct price when the user picks Upper/Middle/Lower berths
+            // (which are priced differently within the same coach type).
+            if (packageId) {
+              const firstEligibleIdx = seatEligibleIndices[0];
+              const outboundSeat = firstEligibleIdx != null
+                ? allOutboundSeats.find((s: any) => s.id === seatIds[firstEligibleIdx])
+                : null;
+              const berthFare = outboundSeat ? getSeatFare(outboundSeat) : null;
+              if (berthFare != null) {
+                setPackageContext(
+                  packageId,
+                  priceTierId ?? '',
+                  berthFare,
+                  packageName ?? undefined,
+                  packageDepartureStationId ?? undefined,
+                  packageDepartureStationName ?? undefined,
+                );
+              }
+            }
+
+            router.push('/booking/review');
+            return;
+          } catch {
+            // Auto-assign failed — fall through to manual inbound selection
+            setAutoAssigningReturn(false);
+            setCurrentJourneyType("inbound");
+            setPassengerSeatMap({});
+            setActivePassengerIndex(seatEligibleIndices[0] ?? 0);
+            setSelectedCoach(null);
+            return;
+          }
+        }
       } catch (error: any) {
         setModalState({
           isOpen: true,
@@ -774,6 +1156,7 @@ export default function SeatsPage() {
           type: "error",
           onConfirm: undefined,
           showCancel: false,
+          confirmText: "OK",
         });
         return;
       }
@@ -785,7 +1168,7 @@ export default function SeatsPage() {
     }
 
     try {
-      await holdMutation.mutateAsync(seatIdsForHold);
+      await ensureLegHold(seatIdsForHold);
       const updatedPassengers = passengers.map((p, i) => {
         const seatData = validSeats?.find((s: any) => s.id === seatIds[i]);
         if (isRoundTrip && currentJourneyType === "inbound") {
@@ -808,6 +1191,26 @@ export default function SeatsPage() {
         };
       });
       setPassengers(updatedPassengers);
+
+      // For one-way package bookings, sync the stored tier price with the actual berth
+      // fare so review/payment/confirmation pages reflect the correct amount.
+      if (!isRoundTrip && isPackageBooking && packageId) {
+        const firstEligibleIdx = seatEligibleIndices[0];
+        const firstSeatData = firstEligibleIdx != null
+          ? validSeats?.find((s: any) => s.id === seatIds[firstEligibleIdx])
+          : null;
+        const berthFare = firstSeatData ? getSeatFare(firstSeatData) : null;
+        if (berthFare != null) {
+          setPackageContext(
+            packageId,
+            priceTierId ?? '',
+            berthFare,
+            packageName ?? undefined,
+            packageDepartureStationId ?? undefined,
+            packageDepartureStationName ?? undefined,
+          );
+        }
+      }
     } catch (error: any) {
       setModalState({
         isOpen: true,
@@ -818,6 +1221,7 @@ export default function SeatsPage() {
         type: "error",
         onConfirm: undefined,
         showCancel: false,
+        confirmText: "OK",
       });
       return;
     }
@@ -841,6 +1245,7 @@ export default function SeatsPage() {
         type: "warning",
         onConfirm: undefined,
         showCancel: false,
+        confirmText: "OK",
       });
       return;
     }
@@ -1323,7 +1728,9 @@ export default function SeatsPage() {
             const isCurrentType =
               !!coachTypeId &&
               (coach.coachTypeId === coachTypeId ||
+                coach.coachId === coachTypeId ||
                 coach.type === (currentSchedule as any)?.selectedCoachTypeCode ||
+                coach.coachTypeName === (currentSchedule as any)?.selectedCoachTypeName ||
                 coach.type === (currentSchedule as any)?.selectedCoachTypeName);
             return (
               <div key={coach.id}>
@@ -1386,23 +1793,29 @@ export default function SeatsPage() {
     </>
   );
 
-  // Summary card content — shared between sidebar and mobile modal
-  const SummaryContent = () => (
+  // Summary content, split into pieces so the mobile bottom-sheet can show a compact
+  // header + always-reachable Continue button by default, and only reveal the full
+  // passenger list (SummaryDetails) when the user explicitly expands it — otherwise it
+  // permanently covers most of the seat map on small screens.
+  const SummaryHeader = () => (
+    <div className="flex items-center justify-between mb-1">
+      <h3 className="font-bold text-gray-900 dark:text-white">
+        Selection Summary
+      </h3>
+      <span
+        className={`text-xs font-semibold px-2 py-0.5 rounded-full ${
+          allSeatsAssigned
+            ? "bg-green-100 text-green-700 dark:bg-green-900/30 dark:text-green-400"
+            : "bg-amber-100 text-amber-700 dark:bg-amber-900/30 dark:text-amber-400"
+        }`}
+      >
+        {assignedCount}/{seatEligibleIndices.length} selected
+      </span>
+    </div>
+  );
+
+  const SummaryDetails = () => (
     <>
-      <div className="flex items-center justify-between mb-1">
-        <h3 className="font-bold text-gray-900 dark:text-white">
-          Selection Summary
-        </h3>
-        <span
-          className={`text-xs font-semibold px-2 py-0.5 rounded-full ${
-            allSeatsAssigned
-              ? "bg-green-100 text-green-700 dark:bg-green-900/30 dark:text-green-400"
-              : "bg-amber-100 text-amber-700 dark:bg-amber-900/30 dark:text-amber-400"
-          }`}
-        >
-          {assignedCount}/{seatEligibleIndices.length} selected
-        </span>
-      </div>
       <p className="text-xs text-gray-500 dark:text-gray-400 mb-4">
         {allSeatsAssigned
           ? "All seats selected — ready to continue"
@@ -1448,6 +1861,9 @@ export default function SeatsPage() {
             ? validSeats?.find((s: any) => s.id === assignedSeatId)
             : null;
           const seatLabel = assignedSeat ? buildSeatLabel(assignedSeat) : "";
+          const seatFare = assignedSeat
+            ? (getSeatFare(assignedSeat) ?? (isPackageBooking ? packageTierPriceMinor ?? null : null))
+            : isPackageBooking && assignedSeatId ? (packageTierPriceMinor ?? null) : null;
           const isActive = i === activePassengerIndex;
           const isClickable = i <= maxSelectableIndex;
           return (
@@ -1489,36 +1905,67 @@ export default function SeatsPage() {
                   )}
                 </div>
               </div>
-              <span
-                className={`text-sm font-semibold flex-shrink-0 ${
-                  assignedSeat ? "text-[rgb(20,113,76)]" : "text-gray-400"
-                }`}
-              >
-                {assignedSeat ? `Seat ${seatLabel}` : "Not Assigned"}
-              </span>
+              <div className="flex flex-col items-end flex-shrink-0">
+                <span
+                  className={`text-sm font-semibold ${
+                    assignedSeat ? "text-[rgb(20,113,76)]" : "text-gray-400"
+                  }`}
+                >
+                  {assignedSeat ? `Seat ${seatLabel}` : "Not Assigned"}
+                </span>
+                {assignedSeat && seatFare != null && (
+                  <span className="text-[11px] text-gray-500 dark:text-gray-400">
+                    ETB {(seatFare / 100 * (isPackageBooking ? 2 : 1)).toFixed(2)}
+                  </span>
+                )}
+              </div>
             </button>
           );
         })}
       </div>
+    </>
+  );
 
-      <button
-        onClick={handleContinue}
-        disabled={!allSeatsAssigned || holdMutation.isPending}
-        className="w-full py-3 bg-[rgb(20,113,76)] hover:bg-[rgb(16,89,60)] disabled:opacity-40 disabled:cursor-not-allowed text-white font-bold text-sm rounded-xl transition-all shadow-lg"
-      >
-        {holdMutation.isPending
+  const SummaryContinueButton = () => (
+    <button
+      onClick={handleContinue}
+      disabled={!allSeatsAssigned || holdMutation.isPending || autoAssigningReturn}
+      className="w-full py-2.5 bg-[rgb(20,113,76)] hover:bg-[rgb(16,89,60)] disabled:opacity-40 disabled:cursor-not-allowed text-white font-bold text-sm rounded-xl transition-all shadow-lg"
+    >
+      {autoAssigningReturn
+        ? "Assigning return seats..."
+        : holdMutation.isPending
           ? "Holding seats..."
-          : isRoundTrip && currentJourneyType === "outbound"
+          : isRoundTrip && currentJourneyType === "outbound" && !isPackageBooking
             ? "Continue to Return Seats"
             : "Continue"}
-      </button>
-      <button
-        onClick={handleAutoAssign}
-        disabled={holdMutation.isPending || allSeatsAssigned}
-        className="w-full mt-2 py-2.5 bg-gray-100 dark:bg-gray-700 hover:bg-gray-200 dark:hover:bg-gray-600 disabled:opacity-40 text-gray-700 dark:text-gray-300 font-semibold text-sm rounded-xl transition-all"
-      >
-        Auto Assign Seats
-      </button>
+    </button>
+  );
+
+  const SummaryAutoAssignButton = () => (
+    <button
+      onClick={handleAutoAssign}
+      disabled={holdMutation.isPending || allSeatsAssigned}
+      className="w-full mt-2 py-2.5 bg-gray-100 dark:bg-gray-700 hover:bg-gray-200 dark:hover:bg-gray-600 disabled:opacity-40 text-gray-700 dark:text-gray-300 font-semibold text-sm rounded-xl transition-all"
+    >
+      Auto Assign Seats
+    </button>
+  );
+
+  const SummaryActions = () => (
+    <>
+      <SummaryContinueButton />
+      <SummaryAutoAssignButton />
+    </>
+  );
+
+  // Full summary card — used as-is in the desktop sidebar, which has room to show
+  // everything at once.
+  const SummaryContent = () => (
+    <>
+      <SummaryHeader />
+      <SummaryDetails />
+      <SummaryActions />
     </>
   );
 
@@ -1526,13 +1973,13 @@ export default function SeatsPage() {
     <>
       <CustomModal
         isOpen={modalState.isOpen}
-        onClose={() => setModalState({ ...modalState, isOpen: false })}
+        onClose={() => setModalState((prev) => ({ ...prev, isOpen: false }))}
         title={modalState.title}
         message={modalState.message}
         type={modalState.type}
         onConfirm={modalState.onConfirm}
         showCancel={modalState.showCancel}
-        confirmText={modalState.showCancel ? "Switch Coach" : "OK"}
+        confirmText={modalState.confirmText}
       />
 
       {/* Train Coach Preview */}
@@ -1561,7 +2008,7 @@ export default function SeatsPage() {
 
           {/* Desktop: right-side panel, no backdrop — seat selection stays fully usable */}
           <div
-            className="hidden lg:flex fixed inset-y-0 right-0 z-[120] w-[380px] bg-white dark:bg-gray-900 shadow-2xl border-l border-gray-200 dark:border-gray-700 flex-col"
+            className="hidden lg:flex fixed inset-y-0 right-0 z-[90] w-[380px] bg-white dark:bg-gray-900 shadow-2xl border-l border-gray-200 dark:border-gray-700 flex-col"
             style={{ animation: "drawer-slide-in 0.25s cubic-bezier(0.32,0.72,0,1)" }}
           >
             <div className="flex items-center justify-between px-5 py-4 border-b border-gray-100 dark:border-gray-800 flex-shrink-0">
@@ -1586,15 +2033,41 @@ export default function SeatsPage() {
         </>
       )}
 
-      {/* Mobile summary bottom-sheet — always visible so the active passenger is clear */}
+      {/* Mobile summary bottom-sheet — collapsed to a single slim row by default so it
+          barely dents the seat map; tap it to expand the full passenger list + auto-assign.
+          The Continue button always stays visible either way. */}
       <div
-        className="fixed inset-x-0 bottom-0 z-50 lg:hidden bg-white dark:bg-gray-900 rounded-t-2xl shadow-2xl p-5 max-h-[70vh] overflow-y-auto"
+        className={`fixed inset-x-0 bottom-0 z-50 lg:hidden bg-white dark:bg-gray-900 rounded-t-2xl shadow-2xl overflow-hidden flex flex-col ${
+          mobileSummaryExpanded ? "max-h-[70vh]" : ""
+        }`}
         style={{
           animation: "seats-slide-up 0.25s cubic-bezier(0.32,0.72,0,1)",
         }}
       >
-        <div className="w-10 h-1 bg-gray-300 dark:bg-gray-600 rounded-full mx-auto mb-4" />
-        <SummaryContent />
+        <button
+          type="button"
+          onClick={() => setMobileSummaryExpanded((v) => !v)}
+          className="w-full flex items-center justify-between px-5 py-2.5 flex-shrink-0"
+          aria-label={mobileSummaryExpanded ? "Collapse seat selection summary" : "Expand seat selection summary"}
+        >
+          <span className="text-sm font-semibold text-gray-900 dark:text-white">
+            {assignedCount}/{seatEligibleIndices.length} seats selected
+          </span>
+          <ChevronDown
+            className={`w-4 h-4 text-gray-400 transition-transform ${mobileSummaryExpanded ? "rotate-180" : ""}`}
+          />
+        </button>
+
+        {mobileSummaryExpanded && (
+          <div className="px-5 overflow-y-auto flex-1 min-h-0">
+            <SummaryDetails />
+            <SummaryAutoAssignButton />
+          </div>
+        )}
+
+        <div className="px-5 pb-4 pt-2 flex-shrink-0 border-t border-gray-100 dark:border-gray-800">
+          <SummaryContinueButton />
+        </div>
       </div>
       <style>{`@keyframes seats-slide-up{from{transform:translateY(100%)}to{transform:translateY(0)}}`}</style>
 
@@ -1612,11 +2085,13 @@ export default function SeatsPage() {
               </button>
               <div className="text-center">
                 <h1 className="text-base font-bold text-gray-900 dark:text-white">
-                  {isRoundTrip
-                    ? currentJourneyType === "outbound"
-                      ? packageName ? `Select Outbound Seats for ${packageName}` : "Select Outbound Seats"
-                      : packageName ? `Select Return Seats for ${packageName}` : "Select Return Seats"
-                    : "Select Seats"}
+                  {isPackageBooking
+                    ? `Select Seats for ${packageName}`
+                    : isRoundTrip
+                      ? currentJourneyType === "outbound"
+                        ? "Select Outbound Seats"
+                        : "Select Return Seats"
+                      : "Select Seats"}
                 </h1>
                 {!allSeatsAssigned && (
                   <p className="text-xs text-gray-500 dark:text-gray-400">
@@ -1912,8 +2387,9 @@ export default function SeatsPage() {
               </div>
             </div>
 
-            {/* Mobile spacer so bottom-sheet doesn't cover last seat */}
-            <div className="h-48 lg:hidden" />
+            {/* Mobile spacer so the bottom-sheet doesn't cover the last seat — sized to
+                match the sheet's current (collapsed/expanded) height. */}
+            <div className={`lg:hidden ${mobileSummaryExpanded ? "h-[70vh]" : "h-24"}`} />
           </div>
         </div>
       </div>
diff --git a/apps/edr-passenger-web/portal/src/app/go/page.tsx b/apps/edr-passenger-web/portal/src/app/go/page.tsx
index 255b3980a..d9f6f583f 100644
--- a/apps/edr-passenger-web/portal/src/app/go/page.tsx
+++ b/apps/edr-passenger-web/portal/src/app/go/page.tsx
@@ -2,9 +2,25 @@
 
 import { Suspense, useEffect, useMemo } from "react";
 import { useSearchParams } from "next/navigation";
-import { Loader2, ShieldAlert, ExternalLink } from "lucide-react";
-
 
+/**
+ * /go — payment redirect bounce page for D-Money web checkout.
+ *
+ * The redirect is done CLIENT-SIDE on purpose: the navigation must originate
+ * from the loaded https://edrpassenger.triaplc.com/go document so the browser
+ * sends `Referer: https://edrpassenger.triaplc.com` to D-Money. D-Money only
+ * whitelists that origin, so a server-side 307 (whose referrer on the redirect
+ * hop is browser-dependent and can be stripped) must NOT be used here.
+ *
+ * It fires immediately (no delay) and paints a bare white full-screen cover
+ * above the sticky header (z-[60]) — no portal chrome, no text on the happy
+ * path. A short message shows only when the link is missing/untrusted.
+ *
+ * `?url=` MUST be percent-encoded by the caller (Uri.encodeComponent() in the
+ * Flutter app / encodeURIComponent() on web); otherwise the query parser
+ * truncates the D-Money URL at its first `&` and merch_code/sign are lost.
+ * See scripts/test-go-redirect.mjs.
+ */
 
 const ALLOWED_HOSTS = (
   process.env.NEXT_PUBLIC_DMONEY_ALLOWED_HOSTS ?? "d-money.dj"
@@ -29,8 +45,6 @@ function isTrustedDMoneyUrl(raw: string | null): raw is string {
   );
 }
 
-const REDIRECT_DELAY_MS = 1000;
-
 function RedirectView() {
   const searchParams = useSearchParams();
   const raw = searchParams.get("url");
@@ -38,63 +52,27 @@ function RedirectView() {
 
   useEffect(() => {
     if (!target) return;
-    const timer = setTimeout(() => {
-
-      window.location.replace(target);
-    }, REDIRECT_DELAY_MS);
-    return () => clearTimeout(timer);
+    // Navigate from this document so the D-Money request carries
+    // Referer: https://edrpassenger.triaplc.com (the origin D-Money whitelists).
+    window.location.replace(target);
   }, [target]);
 
-  if (!target) {
-    return (
-      <div className="w-full max-w-sm text-center">
-        <div className="mx-auto mb-5 flex h-16 w-16 items-center justify-center rounded-full bg-red-100">
-          <ShieldAlert className="h-8 w-8 text-red-600" />
-        </div>
-        <h1 className="mb-2 text-xl font-bold text-gray-900">
-          Can&apos;t continue
-        </h1>
-        <p className="text-sm text-gray-500">
-          This link is missing a valid D-Money checkout address or points to an
-          untrusted destination. Please start the payment again from the app.
-        </p>
-      </div>
-    );
-  }
-
   return (
-    <div className="w-full max-w-sm text-center">
-      <div className="mx-auto mb-5 flex h-16 w-16 items-center justify-center rounded-full bg-primary/10">
-        <Loader2 className="h-8 w-8 animate-spin text-primary" />
-      </div>
-      <h1 className="mb-2 text-xl font-bold text-gray-900">
-        Redirecting to D-Money
-      </h1>
-      <p className="text-sm text-gray-500">
-        Taking you to the secure D-Money checkout to complete your payment…
-      </p>
-
-      <a
-        href={target}
-        className="mt-6 inline-flex items-center justify-center gap-2 text-sm font-medium text-primary hover:underline"
-      >
-        Continue to D-Money
-        <ExternalLink className="h-4 w-4" />
-      </a>
+    <div className="fixed inset-0 z-[100] flex items-center justify-center bg-white px-6 text-center">
+      {!target && (
+        <p className="text-sm text-gray-500">
+          This payment link is invalid or has expired. Please start the payment
+          again from the app.
+        </p>
+      )}
     </div>
   );
 }
 
 export default function GoPage() {
   return (
-    <div className="fixed inset-0 z-50 flex items-center justify-center bg-white px-4">
-      <Suspense
-        fallback={
-          <Loader2 className="h-8 w-8 animate-spin text-primary" aria-label="Loading" />
-        }
-      >
-        <RedirectView />
-      </Suspense>
-    </div>
+    <Suspense fallback={<div className="fixed inset-0 z-[100] bg-white" />}>
+      <RedirectView />
+    </Suspense>
   );
 }
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/app/layout.tsx b/apps/edr-passenger-web/portal/src/app/layout.tsx
index d38f63ca2..3c18f1c13 100644
--- a/apps/edr-passenger-web/portal/src/app/layout.tsx
+++ b/apps/edr-passenger-web/portal/src/app/layout.tsx
@@ -5,6 +5,7 @@ import { Providers } from './providers';
 import AppHeader from '@/components/AppHeader';
 import { Footer } from '@/components/Footer';
 import { LoadingIndicator } from '@/components/LoadingIndicator';
+import SupportWidget from '@/features/support/SupportWidget';
 
 export const metadata: Metadata = {
   title: 'EDR Passenger Portal - Book your train journey',
@@ -51,6 +52,7 @@ export default function RootLayout({
             {children}
           </main>
           <Footer />
+          <SupportWidget />
         </Providers>
       </body>
     </html>
diff --git a/apps/edr-passenger-web/portal/src/app/packages/[id]/page.tsx b/apps/edr-passenger-web/portal/src/app/packages/[id]/page.tsx
index 3e4dc04df..32e3f1178 100644
--- a/apps/edr-passenger-web/portal/src/app/packages/[id]/page.tsx
+++ b/apps/edr-passenger-web/portal/src/app/packages/[id]/page.tsx
@@ -365,6 +365,7 @@ const PKG_CHILDREN_PER_ADULT = 5;
 
 function PassengerCountModal({
   tier,
+  minPriceMinor,
   onClose,
   onConfirm,
   loading,
@@ -373,6 +374,7 @@ function PassengerCountModal({
   stations,
 }: {
   tier: PriceTier;
+  minPriceMinor: number;
   onClose: () => void;
   onConfirm: (adultCount: number, childCount: number, departureStationId: string, departureStationName: string) => void;
   loading: boolean;
@@ -389,7 +391,7 @@ function PassengerCountModal({
   const freeChildren = Math.min(childCount, adultCount);
   const paidChildren = Math.max(0, childCount - adultCount);
   // Only paid children need seats; free children share with an adult
-  const totalMinor = (adultCount * tier.priceMinor + paidChildren * tier.priceMinor) * priceMultiplier;
+  const totalMinor = (adultCount * minPriceMinor + paidChildren * minPriceMinor) * priceMultiplier;
 
   return (
     <>
@@ -406,7 +408,7 @@ function PassengerCountModal({
           <div className="px-6 py-3 bg-primary/5 border-b border-primary/10">
             <p className="text-xs text-gray-400 uppercase tracking-wide font-semibold">Coach type</p>
             <p className="text-sm font-bold text-gray-900 dark:text-white mt-0.5">{tier.seatClass?.coachType?.type ? formatCoachTypeLabel(tier.seatClass.coachType.type) : tier.label.trim()}</p>
-            <p className="text-xs text-gray-400 mt-0.5">{remaining} seats remaining · prices from {formatPrice(tier.priceMinor * priceMultiplier, tier.currency)} per adult · 1st child per adult free (no seat)</p>
+            <p className="text-xs text-gray-400 mt-0.5">{remaining} seats remaining · from {formatPrice(minPriceMinor * priceMultiplier, tier.currency)} per adult · 1st child per adult free (no seat)</p>
           </div>
 
           <div className="px-6 py-5 space-y-4">
@@ -442,7 +444,7 @@ function PassengerCountModal({
               </div>
             )}
             <div className="flex items-center justify-between pt-2 border-t border-gray-100 dark:border-gray-800">
-              <span className="text-sm text-gray-500">Total{priceMultiplier === 2 ? ' (round-trip)' : ''}</span>
+              <span className="text-sm text-gray-500">Total{priceMultiplier === 2 ? ' (round-trip) from:' : ''}</span>
               <span className="text-base font-extrabold text-primary">{formatPrice(totalMinor, tier.currency)}</span>
             </div>
 
@@ -557,6 +559,15 @@ export default function PackageDetailPage() {
         selectedSeatClassName: ctx.seatClassName ?? "",
         seatClassName: ctx.seatClassName ?? "",
         selectedCoachTypeId: ctx.coachTypeId ?? "",
+        selectedCoachTypeCode: ctx.coachTypeCode ?? "",
+        selectedCoachTypeName: ctx.coachTypeName ?? "",
+        coachTypes: Array.isArray(ctx.coachTypes) ? ctx.coachTypes : groups.map((g) => ({
+          coachId: g.coachTypeId,
+          coachTypeId: g.coachTypeId,
+          coachTypeName: g.coachTypeName,
+          coachTypeCode: g.coachTypeCode,
+          classes: g.tiers.map((t) => ({ name: t.label, baseFareMinor: t.priceMinor })),
+        })),
       });
 
       const outboundSched = toSchedule(ctx.outboundSchedule);
@@ -648,6 +659,7 @@ export default function PackageDetailPage() {
       {passengerModalOpen && representativeTier && (
         <PassengerCountModal
           tier={representativeTier}
+          minPriceMinor={selectedGroup?.minPrice ?? representativeTier.priceMinor}
           onClose={() => { setPassengerModalOpen(false); setBookingContextError(null); }}
           onConfirm={handleBookNow}
           loading={bookingContextLoading}
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..c51dc6158 100644
--- a/apps/edr-passenger-web/portal/src/components/SearchWidget.tsx
+++ b/apps/edr-passenger-web/portal/src/components/SearchWidget.tsx
@@ -8,8 +8,22 @@ 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';
+
+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;
+}
 import ModernDatePicker from '@/components/ModernDatePicker';
 
 const searchSchema = z.object({
@@ -36,18 +50,104 @@ 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);
+  }, []);
+
+  const dark = useDarkMode();
+
+  return (
+    <div ref={ref} className="relative">
+      <button
+        type="button"
+        disabled={disabled}
+        onClick={() => !disabled && setOpen((o) => !o)}
+        className={`w-full ${icon ? 'pl-11' : 'pl-4'} 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
+          bg-white dark:bg-gray-800
+          disabled:opacity-60 disabled:cursor-not-allowed
+          ${error ? 'border-red-500' : 'border-gray-300 dark:border-gray-600'}
+          transition-colors`}
+        style={{ color: dark ? '#ffffff' : '#111827' }}
+      >
+        {icon && <span className="absolute left-3 top-1/2 -translate-y-1/2">{icon}</span>}
+        <span style={{ color: selected ? (dark ? '#ffffff' : '#111827') : (dark ? '#6b7280' : '#9ca3af') }}>
+          {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-400 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-60 overflow-y-auto">
+            {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'
+                  }`}
+              >
+                {opt.label}
+              </button>
+            ))}
+          </div>
+        </>
+      )}
+    </div>
+  );
+}
+
 export function SearchWidget({ fullWidth = false, onSearch }: SearchWidgetProps) {
   const router = useRouter();
   const setSearchCriteria = useBookingStore((s) => s.setSearchCriteria);
   const [isPassengerOpen, setIsPassengerOpen] = useState(false);
+  const dark = useDarkMode();
 
   const { data: stations, isLoading } = useQuery<Station[]>({
     queryKey: ['stations'],
     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 +163,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 +189,114 @@ 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 flex items-center justify-between hover:border-primary transition-colors"
+                style={{ color: dark ? '#ffffff' : '#111827' }}
               >
-                <span className="flex items-center gap-2">
+                <span className="flex items-center gap-2" style={{ color: 'inherit' }}>
                   <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">
+                    <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 +306,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
new file mode 100644
index 000000000..24b6b82fd
--- /dev/null
+++ b/apps/edr-passenger-web/portal/src/features/support/SupportPanel.tsx
@@ -0,0 +1,155 @@
+'use client';
+
+import { Passenger } from '@edr/types';
+import { Headset, Send, X } from 'lucide-react';
+import { useEffect, useRef, useState } from 'react';
+
+import { useMarkRead, useSendMessage, useThread } from './useSupport';
+
+const GREEN = 'rgb(20 113 76)';
+type MessageDto = Passenger.PassengerSupportMessageDto;
+
+function formatTime(iso?: string | null): string {
+  if (!iso) return '';
+  const d = new Date(iso);
+  const now = new Date();
+  return d.toDateString() === now.toDateString()
+    ? d.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' })
+    : d.toLocaleDateString([], { month: 'short', day: 'numeric' });
+}
+
+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(() => {
+    markRead.mutate();
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [messages.length]);
+
+  useEffect(() => {
+    viewport.current?.scrollTo({ top: viewport.current.scrollHeight });
+  }, [messages.length]);
+
+  const submit = async () => {
+    const text = draft.trim();
+    if (!text) return;
+    setDraft('');
+    await send.mutateAsync(text);
+  };
+
+  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">
+      {/* 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} />)
+        )}
+      </div>
+
+      {/* Composer */}
+      <div className="border-t border-gray-100 p-3 dark:border-slate-700">
+        <div className="flex items-end gap-2">
+          <textarea
+            value={draft}
+            onChange={(e) => setDraft(e.target.value)}
+            onKeyDown={(e) => {
+              if (e.key === 'Enter' && !e.shiftKey) {
+                e.preventDefault();
+                submit();
+              }
+            }}
+            rows={1}
+            placeholder="Type a message…"
+            className="max-h-24 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"
+          />
+          <button
+            onClick={submit}
+            disabled={!draft.trim() || send.isPending}
+            className="flex h-9 w-9 shrink-0 items-center justify-center rounded-lg text-white transition hover:opacity-90 disabled:opacity-50"
+            style={{ background: GREEN }}
+            aria-label="Send"
+          >
+            <Send size={18} />
+          </button>
+        </div>
+      </div>
+    </div>
+  );
+}
+
+function MessageBubble({ m }: { m: MessageDto }) {
+  const mine = m.sender === 'USER';
+  return (
+    <div className={`flex ${mine ? 'justify-end' : 'justify-start'}`}>
+      <div className="max-w-[78%]">
+        {!mine && (
+          <p className="mb-0.5 ml-1 text-xs text-gray-400">
+            {m.authorName || 'Support agent'}
+          </p>
+        )}
+        <div
+          className={`whitespace-pre-wrap break-words rounded-2xl px-3 py-2 text-sm ${
+            mine
+              ? 'rounded-br-sm text-white'
+              : 'rounded-bl-sm bg-gray-100 text-gray-800 dark:bg-slate-800 dark:text-slate-100'
+          }`}
+          style={mine ? { background: GREEN } : undefined}
+        >
+          {m.text}
+        </div>
+        <p
+          className={`mt-0.5 text-[10px] text-gray-400 ${
+            mine ? 'text-right' : 'text-left'
+          }`}
+        >
+          {formatTime(m.createdAt)}
+        </p>
+      </div>
+    </div>
+  );
+}
+
+export default SupportPanel;
diff --git a/apps/edr-passenger-web/portal/src/features/support/SupportWidget.tsx b/apps/edr-passenger-web/portal/src/features/support/SupportWidget.tsx
new file mode 100644
index 000000000..2b46a97b6
--- /dev/null
+++ b/apps/edr-passenger-web/portal/src/features/support/SupportWidget.tsx
@@ -0,0 +1,46 @@
+'use client';
+
+import { Headset, MessageCircle } from 'lucide-react';
+import { useState } from 'react';
+
+import { SupportPanel } from './SupportPanel';
+import { useUnreadCount } from './useSupport';
+import { useSupportSocket } from './useSupportSocket';
+
+const GREEN = 'rgb(20 113 76)';
+
+/**
+ * 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 [open, setOpen] = useState(false);
+  const { data } = useUnreadCount(true);
+  const unread = data?.unreadCount ?? 0;
+
+  useSupportSocket(true);
+
+  return (
+    <div className="fixed bottom-6 right-6 z-[100] flex flex-col items-end gap-3">
+      {open && <SupportPanel onClose={() => setOpen(false)} />}
+      {!open && (
+        <button
+          onClick={() => setOpen(true)}
+          aria-label="Open support chat"
+          className="relative flex h-14 w-14 items-center justify-center rounded-full text-white shadow-lg transition hover:scale-105"
+          style={{ background: GREEN, boxShadow: '0 8px 24px rgba(20,113,76,0.4)' }}
+        >
+          {unread > 0 ? <Headset size={26} /> : <MessageCircle size={26} />}
+          {unread > 0 && (
+            <span className="absolute -right-1 -top-1 flex h-5 min-w-5 items-center justify-center rounded-full border-2 border-white bg-red-500 px-1 text-xs font-bold text-white">
+              {unread > 9 ? '9+' : unread}
+            </span>
+          )}
+        </button>
+      )}
+    </div>
+  );
+}
+
+export default SupportWidget;
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/supportApi.ts b/apps/edr-passenger-web/portal/src/features/support/supportApi.ts
new file mode 100644
index 000000000..c33eef760
--- /dev/null
+++ b/apps/edr-passenger-web/portal/src/features/support/supportApi.ts
@@ -0,0 +1,29 @@
+import type { Passenger } from '@edr/types';
+
+import { apiClient } from '@/lib/api-client';
+import { getDeviceId } from './deviceIdentity';
+
+type ThreadDto = Passenger.PassengerSupportThreadDto;
+type MessageDto = Passenger.PassengerSupportMessageDto;
+
+/**
+ * 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 = {
+  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 }> =>
+    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
new file mode 100644
index 000000000..14b8518c8
--- /dev/null
+++ b/apps/edr-passenger-web/portal/src/features/support/useSupport.ts
@@ -0,0 +1,48 @@
+'use client';
+
+import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
+
+import { supportApi } from './supportApi';
+
+export const SUPPORT_THREAD_KEY = ['support', 'thread'];
+export const SUPPORT_UNREAD_KEY = ['support', 'unread'];
+
+/** The device's single support thread (conversation + messages). */
+export function useThread(enabled = true) {
+  return useQuery({
+    queryKey: SUPPORT_THREAD_KEY,
+    queryFn: () => supportApi.getThread(),
+    enabled,
+  });
+}
+
+export function useUnreadCount(enabled = true) {
+  return useQuery({
+    queryKey: SUPPORT_UNREAD_KEY,
+    queryFn: () => supportApi.unreadCount(),
+    enabled,
+    refetchInterval: 60_000,
+  });
+}
+
+export function useSendMessage() {
+  const qc = useQueryClient();
+  return useMutation({
+    mutationFn: (text: string) => supportApi.sendMessage(text),
+    onSuccess: () => {
+      qc.invalidateQueries({ queryKey: SUPPORT_THREAD_KEY });
+      qc.invalidateQueries({ queryKey: SUPPORT_UNREAD_KEY });
+    },
+  });
+}
+
+export function useMarkRead() {
+  const qc = useQueryClient();
+  return useMutation({
+    mutationFn: () => supportApi.markRead(),
+    onSuccess: () => {
+      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
new file mode 100644
index 000000000..1bd21b7b8
--- /dev/null
+++ b/apps/edr-passenger-web/portal/src/features/support/useSupportSocket.ts
@@ -0,0 +1,48 @@
+'use client';
+
+import { Passenger } from '@edr/types';
+import { useQueryClient } from '@tanstack/react-query';
+import { useEffect } from 'react';
+import { io } from 'socket.io-client';
+
+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 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) {
+  const qc = useQueryClient();
+
+  useEffect(() => {
+    if (!enabled || typeof window === 'undefined') return;
+    const socket = io(
+      `${SOCKET_ORIGIN}/${Passenger.PASSENGER_SUPPORT_WS_NAMESPACE}`,
+      {
+        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,
+      },
+    );
+
+    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();
+      socket.disconnect();
+    };
+  }, [enabled, qc]);
+}
diff --git a/apps/edr-passenger-web/portal/src/lib/api-client.ts b/apps/edr-passenger-web/portal/src/lib/api-client.ts
index 471218532..242480929 100644
--- a/apps/edr-passenger-web/portal/src/lib/api-client.ts
+++ b/apps/edr-passenger-web/portal/src/lib/api-client.ts
@@ -1,6 +1,6 @@
-import axios, { AxiosInstance, AxiosRequestConfig } from 'axios';
+import axios, { AxiosInstance, AxiosRequestConfig } from "axios";
 
-const API_URL = process.env.NEXT_PUBLIC_API_URL || 'http://localhost:4000';
+const API_URL = process.env.NEXT_PUBLIC_API_URL || "http://localhost:4000";
 
 class ApiClient {
   private client: AxiosInstance;
@@ -9,13 +9,16 @@ class ApiClient {
     this.client = axios.create({
       baseURL: API_URL,
       headers: {
-        'Content-Type': 'application/json',
+        "Content-Type": "application/json",
       },
     });
 
     this.client.interceptors.request.use((config) => {
-      const token = typeof window !== 'undefined' ? localStorage.getItem('auth_token') : null;
-      if (token && token !== 'null' && token !== 'undefined') {
+      const token =
+        typeof window !== "undefined"
+          ? localStorage.getItem("auth_token")
+          : null;
+      if (token && token !== "null" && token !== "undefined") {
         config.headers.Authorization = `Bearer ${token}`;
       }
       return config;
@@ -25,22 +28,28 @@ class ApiClient {
     // there just means the user canceled/closed the Fayda popup without completing it (no
     // valid verification session) — that should surface as an inline error on the page,
     // not force-clear the session and redirect to /login out from under them.
-    const PUBLIC_PREFIXES = ['/config/', '/auth/login', '/auth/register', '/passengers/me', '/fayda/verification'];
+    const PUBLIC_PREFIXES = [
+      "/config/",
+      "/auth/login",
+      "/auth/register",
+      "/passengers/me",
+      "/fayda/verification",
+    ];
 
     this.client.interceptors.response.use(
       (response) => response,
       (error) => {
         if (error.response?.status === 401) {
-          const url: string = error.config?.url || '';
+          const url: string = error.config?.url || "";
           const isPublic = PUBLIC_PREFIXES.some((p) => url.includes(p));
-          if (!isPublic && typeof window !== 'undefined') {
-            localStorage.removeItem('auth_token');
-            localStorage.removeItem('auth_user');
-            window.location.href = '/login';
+          if (!isPublic && typeof window !== "undefined") {
+            localStorage.removeItem("auth_token");
+            localStorage.removeItem("auth_user");
+            // window.location.href = '/login';
           }
         }
         return Promise.reject(error);
-      }
+      },
     );
   }
 
@@ -50,17 +59,29 @@ class ApiClient {
     return response.data?.data || response.data;
   }
 
-  async post<T>(url: string, data?: any, config?: AxiosRequestConfig): Promise<T> {
+  async post<T>(
+    url: string,
+    data?: any,
+    config?: AxiosRequestConfig,
+  ): Promise<T> {
     const response = await this.client.post<any>(url, data, config);
     return response.data?.data || response.data;
   }
 
-  async put<T>(url: string, data?: any, config?: AxiosRequestConfig): Promise<T> {
+  async put<T>(
+    url: string,
+    data?: any,
+    config?: AxiosRequestConfig,
+  ): Promise<T> {
     const response = await this.client.put<T>(url, data, config);
     return response.data;
   }
 
-  async patch<T>(url: string, data?: any, config?: AxiosRequestConfig): Promise<T> {
+  async patch<T>(
+    url: string,
+    data?: any,
+    config?: AxiosRequestConfig,
+  ): Promise<T> {
     const response = await this.client.patch<T>(url, data, config);
     return response.data;
   }
diff --git a/apps/edr-passenger-web/portal/src/lib/booking-store.ts b/apps/edr-passenger-web/portal/src/lib/booking-store.ts
index 0972e0881..e5d1d83aa 100644
--- a/apps/edr-passenger-web/portal/src/lib/booking-store.ts
+++ b/apps/edr-passenger-web/portal/src/lib/booking-store.ts
@@ -109,6 +109,11 @@ interface BookingState {
   seatHold: SeatHold | null;
   bookingId: string | null;
   pnr: string | null;
+  // The hold id(s) the current bookingId was actually created with — lets the review
+  // page detect "user came back from the payment gateway with the same booking still
+  // valid" and reuse it instead of creating a duplicate booking.
+  bookingHoldId: string | null;
+  bookingReturnHoldId: string | null;
   selectedPaymentMethod: string | null;
   createAccount: boolean;
   passengerId: string | null;
@@ -133,6 +138,7 @@ interface BookingState {
   setSeatHold: (hold: SeatHold | null) => void;
   setBookingId: (id: string) => void;
   setPNR: (pnr: string) => void;
+  setBookingHoldReference: (holdId: string | null, returnHoldId?: string | null) => void;
   setPaymentMethod: (method: string) => void;
   setCreateAccount: (create: boolean) => void;
   setPassengerId: (id: string | null) => void;
@@ -151,6 +157,8 @@ export const useBookingStore = create<BookingState>()(persist(
       seatHold: null,
       bookingId: null,
       pnr: null,
+      bookingHoldId: null,
+      bookingReturnHoldId: null,
       selectedPaymentMethod: null,
       createAccount: false,
       passengerId: null,
@@ -172,6 +180,7 @@ export const useBookingStore = create<BookingState>()(persist(
       setSeatHold: (hold) => set({ seatHold: hold }),
       setBookingId: (id) => set({ bookingId: id }),
       setPNR: (pnr) => set({ pnr }),
+      setBookingHoldReference: (holdId, returnHoldId) => set({ bookingHoldId: holdId, bookingReturnHoldId: returnHoldId ?? null }),
       setPaymentMethod: (method) => set({ selectedPaymentMethod: method }),
       setCreateAccount: (create) => set({ createAccount: create }),
       setPassengerId: (id) => set({ passengerId: id }),
@@ -185,6 +194,8 @@ export const useBookingStore = create<BookingState>()(persist(
         seatHold: null,
         bookingId: null,
         pnr: null,
+        bookingHoldId: null,
+        bookingReturnHoldId: null,
         selectedPaymentMethod: null,
         createAccount: false,
         passengerId: null,
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 37f421d71..9d15af7d8 100644
--- a/apps/edr-passenger-web/portal/src/lib/generate-voucher.ts
+++ b/apps/edr-passenger-web/portal/src/lib/generate-voucher.ts
@@ -1,5 +1,4 @@
 import jsPDF from 'jspdf';
-import autoTable from 'jspdf-autotable';
 import QRCode from 'qrcode';
 
 interface ScheduleInfo {
@@ -30,12 +29,24 @@ interface PassengerVoucherData {
   createdAt: string;
 }
 
-// ─── shared drawing helpers ───────────────────────────────────────────────────
+// ─── palette ───────────────────────────────────────────────────────────────
+// A restrained, mostly-neutral palette (ink / slate / hairline / surface) with the
+// brand green reserved for the few elements that should draw the eye — the PNR,
+// times, and the fare — rather than tinting large areas of the page.
 
-const PRIMARY = [20, 113, 76] as const;
-const DARK    = [51,  51,  51] as const;
-const MED     = [102, 102, 102] as const;
-const LIGHT   = [200, 200, 200] as const;
+const BRAND        = [20, 113, 76]  as const; // brand green — accents only
+const BRAND_SOFT    = [235, 245, 240] as const; // pale green tint for subtle fills
+const INK          = [24, 28, 33]   as const; // headings, high-emphasis text
+const BODY         = [71, 85, 105]  as const; // slate-600 — body text
+const MUTED        = [148, 163, 184] as const; // slate-400 — labels/captions
+const HAIRLINE     = [226, 232, 240] as const; // slate-200 — borders/dividers
+const SURFACE      = [250, 250, 251] as const; // near-white card fill
+const SUCCESS      = [21, 128, 61]  as const; // green-700
+const AMBER_TEXT   = [146, 64, 14]  as const; // amber-800
+const AMBER_FILL   = [255, 251, 235] as const; // amber-50
+const AMBER_BORDER = [251, 191, 36]  as const; // amber-400
+
+const PAGE_MARGIN = 18;
 
 // ─── QR code ───────────────────────────────────────────────────────────────
 // Encodes everything a gate scanner needs to verify this specific ticket without
@@ -63,7 +74,7 @@ async function generateTicketQrDataUrl(data: PassengerVoucherData): Promise<stri
       width: 240,
       margin: 0,
       errorCorrectionLevel: 'M',
-      color: { dark: '#0f172a', light: '#ffffff' },
+      color: { dark: '#181c21', light: '#ffffff' },
     });
   } catch (error) {
     console.error('Failed to generate ticket QR code:', error);
@@ -71,11 +82,30 @@ async function generateTicketQrDataUrl(data: PassengerVoucherData): Promise<stri
   }
 }
 
+// ─── shared drawing helpers ───────────────────────────────────────────────────
+
+function label(doc: jsPDF, text: string, x: number, y: number, opts?: { align?: 'left' | 'right' | 'center'; color?: readonly [number, number, number] }): void {
+  doc.setFont('helvetica', 'normal');
+  doc.setFontSize(7.5);
+  const c = opts?.color ?? MUTED;
+  doc.setTextColor(c[0], c[1], c[2]);
+  doc.text(text.toUpperCase(), x, y, { align: opts?.align ?? 'left', charSpace: 0.3 });
+}
+
+function hairline(doc: jsPDF, x1: number, y: number, x2: number): void {
+  doc.setDrawColor(...HAIRLINE);
+  doc.setLineWidth(0.25);
+  doc.line(x1, y, x2, y);
+}
+
+// ─── header ────────────────────────────────────────────────────────────────
+
 async function drawHeader(doc: jsPDF, margin: number): Promise<number> {
   const pageWidth = doc.internal.pageSize.getWidth();
+  const bandHeight = 24;
 
-  doc.setFillColor(...PRIMARY);
-  doc.rect(0, 0, pageWidth, 30, 'F');
+  doc.setFillColor(...BRAND);
+  doc.rect(0, 0, pageWidth, bandHeight, 'F');
 
   try {
     const logoImg  = await fetch('/edr-logo.png');
@@ -87,206 +117,243 @@ async function drawHeader(doc: jsPDF, margin: number): Promise<number> {
     });
     const img = new Image();
     await new Promise((resolve) => { img.onload = resolve; img.src = logoDataUrl; });
-    const logoH = 18;
+    const logoH = 13;
     const logoW = (img.width / img.height) * logoH;
-    doc.addImage(logoDataUrl, 'PNG', margin, 6, logoW, logoH);
+    const textX = margin + logoW + 5;
+    doc.addImage(logoDataUrl, 'PNG', margin, (bandHeight - logoH) / 2, logoW, logoH);
     doc.setTextColor(255, 255, 255);
-    doc.setFontSize(18); doc.setFont('helvetica', 'bold');
-    doc.text('ETHIO-DJIBOUTI RAILWAY', margin + logoW + 5, 14);
-    doc.setFontSize(9);  doc.setFont('helvetica', 'normal');
-    doc.text('Premium Travel Experience', margin + logoW + 5, 20);
+    doc.setFontSize(13); doc.setFont('helvetica', 'bold');
+    doc.text('ETHIO-DJIBOUTI RAILWAY', textX, bandHeight / 2 - 1);
+    doc.setFontSize(7.5); doc.setFont('helvetica', 'normal');
+    doc.setTextColor(230, 240, 236);
+    doc.text('E-TICKET  ·  BOARDING VOUCHER', textX, bandHeight / 2 + 5, { charSpace: 0.4 });
   } catch {
     doc.setTextColor(255, 255, 255);
-    doc.setFontSize(22); doc.setFont('helvetica', 'bold');
-    doc.text('ETHIO-DJIBOUTI RAILWAY', pageWidth / 2, 13, { align: 'center' });
-    doc.setFontSize(9);  doc.setFont('helvetica', 'normal');
-    doc.text('Premium Travel Experience', pageWidth / 2, 20, { align: 'center' });
+    doc.setFontSize(15); doc.setFont('helvetica', 'bold');
+    doc.text('ETHIO-DJIBOUTI RAILWAY', pageWidth / 2, bandHeight / 2 - 1, { align: 'center' });
+    doc.setFontSize(7.5); doc.setFont('helvetica', 'normal');
+    doc.setTextColor(230, 240, 236);
+    doc.text('E-TICKET  ·  BOARDING VOUCHER', pageWidth / 2, bandHeight / 2 + 5, { align: 'center', charSpace: 0.4 });
   }
-  return 40;
+  return bandHeight + 16;
 }
 
-function drawStatusBadge(doc: jsPDF, status: string, y: number, pageWidth: number): number {
-  const label = (status === 'TICKETED' || status === 'CONFIRMED') ? 'CONFIRMED' : status;
-  const color = (status === 'TICKETED' || status === 'CONFIRMED') ? [34, 197, 94] : [234, 179, 8];
+// ─── status pill ───────────────────────────────────────────────────────────
+
+function drawStatusPill(doc: jsPDF, status: string, x: number, y: number, align: 'left' | 'right' = 'right'): void {
+  const isConfirmed = status === 'TICKETED' || status === 'CONFIRMED';
+  const text = isConfirmed ? 'CONFIRMED' : status;
+  const color = isConfirmed ? SUCCESS : [180, 83, 9] as const;
+
+  doc.setFontSize(7.5); doc.setFont('helvetica', 'bold');
+  const textWidth = doc.getTextWidth(text.toUpperCase());
+  const padX = 3.5;
+  const pillH = 5.5;
+  const pillW = textWidth + padX * 2;
+  const pillX = align === 'right' ? x - pillW : x;
+
   doc.setFillColor(color[0], color[1], color[2]);
-  doc.rect(pageWidth / 2 - 22, y - 4, 44, 8, 'F');
+  doc.roundedRect(pillX, y, pillW, pillH, pillH / 2, pillH / 2, 'F');
   doc.setTextColor(255, 255, 255);
-  doc.setFontSize(9); doc.setFont('helvetica', 'bold');
-  doc.text(label, pageWidth / 2, y + 1, { align: 'center' });
-  return y + 12;
+  doc.text(text.toUpperCase(), pillX + pillW / 2, y + pillH / 2 + 1.4, { align: 'center', charSpace: 0.3 });
 }
 
-function drawBookingRefBox(doc: jsPDF, bookingRef: string, ticketNumber: string, qrDataUrl: string | null, y: number, margin: number, pageWidth: number): number {
-  const boxHeight = 32;
-  const qrSize = 24;
-  const qrPad = 3;
-  const qrBlockWidth = qrDataUrl ? qrSize + qrPad * 2 + 5 : 0;
+// ─── hero card: PNR + ticket number + QR ──────────────────────────────────
 
-  doc.setFillColor(245, 245, 245);
-  doc.roundedRect(margin, y, pageWidth - margin * 2, boxHeight, 2, 2, 'F');
+function drawTicketHero(doc: jsPDF, bookingRef: string, ticketNumber: string, status: string, qrDataUrl: string | null, y: number, margin: number, pageWidth: number): number {
+  const cardH = 32;
+  const qrSize = 22;
+  const qrPad = 2.5;
+  const cardSize = qrSize + qrPad * 2;
 
-  // Booking reference (top-left)
-  doc.setTextColor(...MED); doc.setFontSize(8); doc.setFont('helvetica', 'normal');
-  doc.text('BOOKING REFERENCE', margin + 5, y + 8);
-  doc.setTextColor(...PRIMARY); doc.setFontSize(18); doc.setFont('helvetica', 'bold');
-  doc.text(bookingRef, margin + 5, y + 18);
+  doc.setFillColor(...SURFACE);
+  doc.setDrawColor(...HAIRLINE);
+  doc.setLineWidth(0.3);
+  doc.roundedRect(margin, y, pageWidth - margin * 2, cardH, 3, 3, 'FD');
 
-  // Ticket number, stacked below — leaves room on the right for the QR block
-  const textRightBound = pageWidth - margin - qrBlockWidth - 5;
-  doc.setTextColor(...MED); doc.setFontSize(8); doc.setFont('helvetica', 'normal');
-  doc.text('TICKET NUMBER', textRightBound, y + 8, { align: 'right' });
-  doc.setTextColor(...DARK); doc.setFontSize(11); doc.setFont('helvetica', 'bold');
-  doc.text(ticketNumber, textRightBound, y + 16, { align: 'right' });
+  const padX = 7;
+  drawStatusPill(doc, status, pageWidth - margin - padX, y + 5.5, 'right');
+
+  label(doc, 'Booking reference', margin + padX, y + 12);
+  doc.setTextColor(...INK); doc.setFontSize(21); doc.setFont('helvetica', 'bold');
+  doc.text(bookingRef, margin + padX, y + 23, { charSpace: 0.6 });
+
+  label(doc, 'Ticket no.', margin + padX, y + 28.5);
+  doc.setTextColor(...BODY); doc.setFontSize(9); doc.setFont('helvetica', 'normal');
+  doc.text(ticketNumber, margin + padX + 22, y + 28.7);
 
-  // QR code — clean white card with a thin border, right-aligned in the box
   if (qrDataUrl) {
-    const cardSize = qrSize + qrPad * 2;
     const cardX = pageWidth - margin - cardSize - 3;
-    const cardY = y + (boxHeight - cardSize) / 2;
+    const cardY = y + (cardH - cardSize) / 2;
     doc.setFillColor(255, 255, 255);
-    doc.setDrawColor(...LIGHT);
-    doc.setLineWidth(0.4);
+    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);
   }
 
-  return y + boxHeight + 6;
+  return y + cardH + 10;
 }
 
-function drawJourneyLeg(doc: jsPDF, schedule: ScheduleInfo, label: string | null, y: number, margin: number, pageWidth: number): number {
-  doc.setTextColor(...DARK); doc.setFontSize(11); doc.setFont('helvetica', 'bold');
-  doc.text(label ? `JOURNEY DETAILS — ${label.toUpperCase()}` : 'JOURNEY DETAILS', margin, y);
-  y += 7;
+// ─── journey card ──────────────────────────────────────────────────────────
 
-  doc.setDrawColor(...LIGHT); doc.setLineWidth(0.5);
-  doc.rect(margin, y, pageWidth - margin * 2, 40);
+function drawJourneyLeg(doc: jsPDF, schedule: ScheduleInfo, legLabel: string | null, y: number, margin: number, pageWidth: number): number {
+  const cardW = pageWidth - margin * 2;
+  const routeH = 30;
+  const trainRowH = 9;
+  const cardH = routeH + trainRowH;
 
-  // Origin
-  doc.setFontSize(8);  doc.setTextColor(...MED); doc.setFont('helvetica', 'normal');
-  doc.text('FROM', margin + 5, y + 6);
-  doc.setFontSize(15); doc.setTextColor(...DARK); doc.setFont('helvetica', 'bold');
-  doc.text(schedule.origin.code, margin + 5, y + 14);
-  doc.setFontSize(9);  doc.setFont('helvetica', 'normal');
-  doc.text(schedule.origin.name, margin + 5, y + 20);
-  doc.setFontSize(8);  doc.setTextColor(...MED);
-  doc.text(schedule.origin.city, margin + 5, y + 25);
+  doc.setDrawColor(...HAIRLINE);
+  doc.setLineWidth(0.3);
+  doc.roundedRect(margin, y, cardW, cardH, 3, 3, 'D');
 
-  const dep = new Date(schedule.departureAt);
-  doc.setFontSize(13); doc.setTextColor(...PRIMARY); doc.setFont('helvetica', 'bold');
-  doc.text(dep.toLocaleTimeString('en-US', { hour: 'numeric', minute: '2-digit', hour12: true }), margin + 5, y + 33);
-  doc.setFontSize(7);  doc.setTextColor(...MED); doc.setFont('helvetica', 'normal');
-  doc.text(dep.toLocaleDateString('en-US', { weekday: 'short', month: 'short', day: 'numeric', year: 'numeric' }), margin + 5, y + 38);
-
-  // Arrow
-  doc.setDrawColor(...PRIMARY); doc.setLineWidth(0.8);
-  const ax = pageWidth / 2, ay = y + 20;
-  doc.line(ax - 10, ay, ax + 10, ay);
-  doc.line(ax + 10, ay, ax + 7, ay - 2);
-  doc.line(ax + 10, ay, ax + 7, ay + 2);
-
-  // Destination
-  const dx = pageWidth - margin - 50;
-  doc.setFontSize(8);  doc.setTextColor(...MED); doc.setFont('helvetica', 'normal');
-  doc.text('TO', dx, y + 6);
-  doc.setFontSize(15); doc.setTextColor(...DARK); doc.setFont('helvetica', 'bold');
-  doc.text(schedule.destination.code, dx, y + 14);
-  doc.setFontSize(9);  doc.setFont('helvetica', 'normal');
-  doc.text(schedule.destination.name, dx, y + 20);
-  doc.setFontSize(8);  doc.setTextColor(...MED);
-  doc.text(schedule.destination.city, dx, y + 25);
-
-  const arr = new Date(schedule.arrivalAt);
-  doc.setFontSize(13); doc.setTextColor(...PRIMARY); doc.setFont('helvetica', 'bold');
-  doc.text(arr.toLocaleTimeString('en-US', { hour: 'numeric', minute: '2-digit', hour12: true }), dx, y + 33);
-  doc.setFontSize(7);  doc.setTextColor(...MED); doc.setFont('helvetica', 'normal');
-  doc.text(arr.toLocaleDateString('en-US', { weekday: 'short', month: 'short', day: 'numeric', year: 'numeric' }), dx, y + 38);
-
-  y += 47;
-
-  // Train info bar
-  doc.setFillColor(248, 248, 248);
-  doc.rect(margin, y, pageWidth - margin * 2, 12, 'F');
-  doc.setFontSize(8);  doc.setTextColor(...MED); doc.setFont('helvetica', 'normal');
-  doc.text('TRAIN', margin + 5, y + 5);
-  doc.setTextColor(...DARK); doc.setFont('helvetica', 'bold');
-  doc.text(schedule.trainNumber + (schedule.trainName ? ` — ${schedule.trainName}` : ''), margin + 20, y + 9);
-  if (schedule.seatClass) {
-    doc.setFont('helvetica', 'normal'); doc.setTextColor(...MED);
-    doc.text(schedule.seatClass, pageWidth - margin - 5, y + 9, { align: 'right' });
+  if (legLabel) {
+    doc.setFillColor(...BRAND);
+    doc.roundedRect(margin + 6, y - 3, doc.getTextWidth(legLabel.toUpperCase()) + 7, 6, 3, 3, 'F');
+    doc.setTextColor(255, 255, 255); doc.setFontSize(7.5); doc.setFont('helvetica', 'bold');
+    doc.text(legLabel.toUpperCase(), margin + 6 + (doc.getTextWidth(legLabel.toUpperCase()) + 7) / 2, y, { align: 'center', charSpace: 0.3 });
   }
 
-  return y + 18;
+  const padX = 8;
+  const topY = y + (legLabel ? 12 : 8);
+
+  // Origin block
+  label(doc, 'From', margin + padX, topY);
+  doc.setTextColor(...INK); doc.setFontSize(16); doc.setFont('helvetica', 'bold');
+  doc.text(schedule.origin.code, margin + padX, topY + 8);
+  doc.setTextColor(...BODY); doc.setFontSize(8.5); doc.setFont('helvetica', 'normal');
+  doc.text(schedule.origin.city || schedule.origin.name, margin + padX, topY + 13);
+
+  const dep = new Date(schedule.departureAt);
+  doc.setTextColor(...BRAND); doc.setFontSize(11.5); doc.setFont('helvetica', 'bold');
+  doc.text(dep.toLocaleTimeString('en-US', { hour: 'numeric', minute: '2-digit', hour12: true }), margin + padX, topY + 20.5);
+  doc.setTextColor(...MUTED); doc.setFontSize(7); doc.setFont('helvetica', 'normal');
+  doc.text(dep.toLocaleDateString('en-US', { weekday: 'short', month: 'short', day: 'numeric' }), margin + padX, topY + 25);
+
+  // Destination block (right-aligned)
+  const dx = pageWidth - margin - padX;
+  label(doc, 'To', dx, topY, { align: 'right' });
+  doc.setTextColor(...INK); doc.setFontSize(16); doc.setFont('helvetica', 'bold');
+  doc.text(schedule.destination.code, dx, topY + 8, { align: 'right' });
+  doc.setTextColor(...BODY); doc.setFontSize(8.5); doc.setFont('helvetica', 'normal');
+  doc.text(schedule.destination.city || schedule.destination.name, dx, topY + 13, { align: 'right' });
+
+  const arr = new Date(schedule.arrivalAt);
+  doc.setTextColor(...BRAND); doc.setFontSize(11.5); doc.setFont('helvetica', 'bold');
+  doc.text(arr.toLocaleTimeString('en-US', { hour: 'numeric', minute: '2-digit', hour12: true }), dx, topY + 20.5, { align: 'right' });
+  doc.setTextColor(...MUTED); doc.setFontSize(7); doc.setFont('helvetica', 'normal');
+  doc.text(arr.toLocaleDateString('en-US', { weekday: 'short', month: 'short', day: 'numeric' }), dx, topY + 25, { align: 'right' });
+
+  // Dashed route line with endpoint markers, connecting the two blocks
+  const lineY = topY + 8.5;
+  const lineX1 = margin + padX + 24;
+  const lineX2 = dx - 24;
+  doc.setDrawColor(...HAIRLINE);
+  doc.setLineWidth(0.5);
+  doc.setLineDashPattern([1, 1.2], 0);
+  doc.line(lineX1, lineY, lineX2, lineY);
+  doc.setLineDashPattern([], 0);
+  doc.setFillColor(...BRAND);
+  doc.circle(lineX1, lineY, 0.9, 'F');
+  doc.circle(lineX2, lineY, 0.9, 'F');
+
+  // Train info sub-row
+  const rowY = y + routeH;
+  hairline(doc, margin, rowY, margin + cardW);
+  doc.setFontSize(8); doc.setTextColor(...MUTED); doc.setFont('helvetica', 'normal');
+  doc.text('TRAIN', margin + padX, rowY + 6, { charSpace: 0.3 });
+  doc.setTextColor(...INK); doc.setFont('helvetica', 'bold');
+  doc.text(schedule.trainNumber + (schedule.trainName ? `  ·  ${schedule.trainName}` : ''), margin + padX + 15, rowY + 6);
+  if (schedule.seatClass) {
+    doc.setFont('helvetica', 'normal'); doc.setTextColor(...BODY);
+    doc.text(schedule.seatClass, pageWidth - margin - padX, rowY + 6, { align: 'right' });
+  }
+
+  return y + cardH + 8;
 }
 
-function drawPassengerDetails(doc: jsPDF, data: PassengerVoucherData, y: number, margin: number): number {
-  doc.setTextColor(...DARK); doc.setFontSize(11); doc.setFont('helvetica', 'bold');
-  doc.text('PASSENGER DETAILS', margin, y);
+// ─── passenger details ─────────────────────────────────────────────────────
+
+function drawPassengerDetails(doc: jsPDF, data: PassengerVoucherData, y: number, margin: number, pageWidth: number): number {
+  label(doc, 'Passenger details', margin, y);
   y += 7;
 
   const rows: [string, string][] = [
-    ['Full Name',   data.passengerName || '—'],
-    ['Date of Birth', data.dateOfBirth ? new Date(data.dateOfBirth).toLocaleDateString('en-US', { year: 'numeric', month: 'long', day: 'numeric' }) : '—'],
+    ['Full name', data.passengerName || '—'],
+    ['Date of birth', data.dateOfBirth ? new Date(data.dateOfBirth).toLocaleDateString('en-US', { year: 'numeric', month: 'long', day: 'numeric' }) : '—'],
     ['Nationality', data.nationality || '—'],
   ];
-
   if (data.isRoundTrip) {
-    rows.push(['Outbound Seat', data.outboundSeatNumber || '—']);
-    rows.push(['Return Seat',   data.inboundSeatNumber  || '—']);
+    rows.push(['Outbound seat', data.outboundSeatNumber || '—']);
+    rows.push(['Return seat', data.inboundSeatNumber || '—']);
   } else {
     rows.push(['Seat', data.seatNumber || '—']);
   }
 
-  autoTable(doc, {
-    startY: y,
-    body: rows,
-    theme: 'plain',
-    styles: { fontSize: 9, cellPadding: 3 },
-    columnStyles: {
-      0: { fontStyle: 'bold', textColor: [MED[0], MED[1], MED[2]], cellWidth: 45 },
-      1: { textColor: [DARK[0], DARK[1], DARK[2]] },
-    },
-    alternateRowStyles: { fillColor: [248, 248, 248] },
-    margin: { left: margin, right: margin },
+  const rowH = 8;
+  rows.forEach(([k, v], i) => {
+    const rowY = y + i * rowH;
+    doc.setFontSize(8.5); doc.setTextColor(...MUTED); doc.setFont('helvetica', 'normal');
+    doc.text(k.toUpperCase(), margin, rowY + 5, { charSpace: 0.2 });
+    doc.setFontSize(9.5); doc.setTextColor(...INK); doc.setFont('helvetica', 'bold');
+    doc.text(v, pageWidth - margin, rowY + 5, { align: 'right' });
+    if (i < rows.length - 1) hairline(doc, margin, rowY + rowH, pageWidth - margin);
   });
 
-  return (doc as any).lastAutoTable.finalY + 8;
+  return y + rows.length * rowH + 6;
 }
 
+// ─── fare summary ──────────────────────────────────────────────────────────
+
 function drawFareSummary(doc: jsPDF, fareMinor: number, currency: string, y: number, margin: number, pageWidth: number): number {
-  doc.setFillColor(248, 248, 248);
-  doc.rect(margin, y, pageWidth - margin * 2, 20, 'F');
-  doc.setFontSize(9);  doc.setTextColor(...MED); doc.setFont('helvetica', 'normal');
-  doc.text('Fare', margin + 5, y + 7);
-  doc.setFontSize(15); doc.setTextColor(...PRIMARY); doc.setFont('helvetica', 'bold');
-  doc.text(`${currency} ${(fareMinor / 100).toFixed(2)}`, pageWidth - margin - 5, y + 7, { align: 'right' });
-  doc.setFontSize(9);  doc.setTextColor(34, 197, 94); doc.setFont('helvetica', 'bold');
-  doc.text('✓ PAID', margin + 5, y + 15);
-  return y + 26;
+  const cardH = 20;
+  doc.setFillColor(...BRAND_SOFT);
+  doc.roundedRect(margin, y, pageWidth - margin * 2, cardH, 3, 3, 'F');
+
+  const padX = 7;
+  label(doc, 'Total fare paid', margin + padX, y + 8, { color: BODY });
+  doc.setFontSize(7.5); doc.setFont('helvetica', 'bold'); doc.setTextColor(...SUCCESS);
+  doc.text('✓ PAID', margin + padX, y + 15);
+
+  doc.setTextColor(...BRAND); doc.setFontSize(16); doc.setFont('helvetica', 'bold');
+  doc.text(`${currency} ${(fareMinor / 100).toFixed(2)}`, pageWidth - margin - padX, y + 13, { align: 'right' });
+
+  return y + cardH + 8;
 }
 
+// ─── instructions ──────────────────────────────────────────────────────────
+
 function drawInstructions(doc: jsPDF, y: number, margin: number, pageWidth: number): number {
-  doc.setFillColor(252, 211, 77);
-  doc.rect(margin, y, pageWidth - margin * 2, 18, 'F');
-  doc.setFontSize(9);  doc.setTextColor(...DARK); doc.setFont('helvetica', 'bold');
-  doc.text('⚠  IMPORTANT INSTRUCTIONS', margin + 5, y + 6);
+  const cardH = 17;
+  const barW = 1.4;
+
+  doc.setFillColor(...AMBER_FILL);
+  doc.roundedRect(margin, y, pageWidth - margin * 2, cardH, 2, 2, 'F');
+  doc.setFillColor(...AMBER_BORDER);
+  doc.rect(margin, y, barW, cardH, 'F');
+
+  const padX = 6;
+  doc.setFontSize(8); doc.setTextColor(...AMBER_TEXT); doc.setFont('helvetica', 'bold');
+  doc.text('BEFORE YOU TRAVEL', margin + padX, y + 6, { charSpace: 0.3 });
   doc.setFont('helvetica', 'normal'); doc.setFontSize(8);
-  doc.text('• Present this voucher at the terminal for boarding', margin + 5, y + 11);
-  doc.text('• Arrive at least 30 minutes before departure', margin + 5, y + 15);
-  return y + 24;
+  doc.text('Present this voucher (printed or on your phone) at the terminal for boarding.', margin + padX, y + 11);
+  doc.text('Please arrive at least 30 minutes before scheduled departure.', margin + padX, y + 15);
+
+  return y + cardH + 6;
 }
 
+// ─── footer ────────────────────────────────────────────────────────────────
+
 function drawFooter(doc: jsPDF, createdAt: string): void {
   const pageWidth  = doc.internal.pageSize.getWidth();
   const pageHeight = doc.internal.pageSize.getHeight();
-  const footerY    = pageHeight - 22;
+  const footerY    = pageHeight - 20;
 
-  doc.setDrawColor(...LIGHT);
-  doc.line(15, footerY, pageWidth - 15, footerY);
-  doc.setFontSize(8); doc.setTextColor(...MED); doc.setFont('helvetica', 'normal');
-  doc.text('Support: support@edr.com | +251-11-XXX-XXXX', pageWidth / 2, footerY + 5, { align: 'center' });
-  doc.text('Terms & Conditions apply. Visit www.edr.com for details.', pageWidth / 2, footerY + 9, { align: 'center' });
-  doc.setFontSize(7);
-  doc.text(`Generated: ${new Date(createdAt).toLocaleString('en-US')}`, pageWidth / 2, footerY + 13, { align: 'center' });
+  hairline(doc, PAGE_MARGIN, footerY, pageWidth - PAGE_MARGIN);
+  doc.setFontSize(7.5); doc.setTextColor(...MUTED); doc.setFont('helvetica', 'normal');
+  doc.text('support@edr.com   ·   +251-11-XXX-XXXX   ·   www.edr.com', pageWidth / 2, footerY + 6, { align: 'center' });
+  doc.setFontSize(6.5);
+  doc.text(`Issued ${new Date(createdAt).toLocaleString('en-US')}`, pageWidth / 2, footerY + 10.5, { align: 'center' });
 }
 
 // ─── public API ──────────────────────────────────────────────────────────────
@@ -295,25 +362,22 @@ function drawFooter(doc: jsPDF, createdAt: string): void {
 export const generatePassengerVoucherPDF = async (data: PassengerVoucherData): Promise<void> => {
   const doc    = new jsPDF({ orientation: 'portrait', unit: 'mm', format: 'a4' });
   const pageW  = doc.internal.pageSize.getWidth();
-  const margin = 15;
+  const margin = PAGE_MARGIN;
 
   let y = await drawHeader(doc, margin);
   const qrDataUrl = await generateTicketQrDataUrl(data);
 
-  // Title
-  doc.setTextColor(...DARK); doc.setFontSize(18); doc.setFont('helvetica', 'bold');
-  doc.text('PASSENGER VOUCHER', pageW / 2, y, { align: 'center' });
-  y += 10;
+  y = drawTicketHero(doc, data.bookingRef, data.ticketNumber, data.status, qrDataUrl, y, margin, pageW);
 
-  y = drawStatusBadge(doc, data.status, y, pageW);
-  y = drawBookingRefBox(doc, data.bookingRef, data.ticketNumber, qrDataUrl, y, margin, pageW);
+  label(doc, 'Journey details', margin, y);
+  y += 7;
   y = drawJourneyLeg(doc, data.outboundSchedule, data.isRoundTrip ? 'Outbound' : null, y, margin, pageW);
 
   if (data.isRoundTrip && data.inboundSchedule) {
     y = drawJourneyLeg(doc, data.inboundSchedule, 'Return', y, margin, pageW);
   }
 
-  y = drawPassengerDetails(doc, data, y, margin);
+  y = drawPassengerDetails(doc, data, y, margin, pageW);
   y = drawFareSummary(doc, data.fareMinor, data.currency, y, margin, pageW);
   drawInstructions(doc, y, margin, pageW);
   drawFooter(doc, data.createdAt);
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-passenger-web/portal/src/utils/manage-booking-return.ts b/apps/edr-passenger-web/portal/src/utils/manage-booking-return.ts
new file mode 100644
index 000000000..14d82415c
--- /dev/null
+++ b/apps/edr-passenger-web/portal/src/utils/manage-booking-return.ts
@@ -0,0 +1,24 @@
+// Payment gateway return URLs (Telebirr/Waafi/D-Money success & failure pages) are fixed,
+// app-wide URLs configured once in the payment provider — they can't carry a per-request
+// query param telling the return page which flow initiated payment. The normal
+// results -> seats -> review -> payment flow always ends at /booking/confirmation, which
+// reads its data from useBookingStore. But paying for an existing booking from the
+// Manage Booking page (/booking/detail) doesn't populate that store, so returning to
+// /booking/confirmation there would render blank/broken.
+//
+// This marker records "the last payment was initiated from Manage Booking for booking
+// ref X" right before redirecting to the gateway, so the return page can send the user
+// back to that booking's detail view instead. It's consumed (read + cleared) exactly once.
+const STORAGE_KEY = 'edr_manage_booking_payment_ref';
+
+export function markManageBookingPaymentReturn(bookingRef: string) {
+  if (typeof window === 'undefined' || !bookingRef) return;
+  localStorage.setItem(STORAGE_KEY, bookingRef);
+}
+
+export function consumeManageBookingPaymentReturn(): string | null {
+  if (typeof window === 'undefined') return null;
+  const ref = localStorage.getItem(STORAGE_KEY);
+  if (ref) localStorage.removeItem(STORAGE_KEY);
+  return ref;
+}
diff --git a/docker-compose.yaml b/docker-compose.yaml
index cc6dcd1e3..863c1b5e2 100644
--- a/docker-compose.yaml
+++ b/docker-compose.yaml
@@ -16,6 +16,8 @@ services:
         - npmrc
     ports:
       - "${FREIGHT_API_PORT:-3001}:${FREIGHT_API_PORT:-3001}"
+      # GT06 GPS tracker TCP ingestion (raw TCP — must be reachable by tracker SIMs).
+      - "${GT06_TCP_PORT:-5023}:${GT06_TCP_PORT:-5023}"
     env_file:
       - apps/edr-freight-api/.env
     extra_hosts:
@@ -52,6 +54,7 @@ services:
         VITE_API_URL: ${VITE_API_URL:-}
         VITE_BASE_API_URL: ${VITE_BASE_API_URL:-}
         VITE_USER_MANAGEMENT_BASE: ${VITE_USER_MANAGEMENT_BASE:-}
+        VITE_GOOGLE_MAPS_API_KEY: ${VITE_GOOGLE_MAPS_API_KEY:-}
       secrets:
         - npmrc
     ports:
@@ -66,6 +69,7 @@ services:
         VITE_API_URL: ${VITE_API_URL:-}
         VITE_BASE_API_URL: ${VITE_BASE_API_URL:-}
         VITE_USER_MANAGEMENT_BASE: ${VITE_USER_MANAGEMENT_BASE:-}
+        VITE_GOOGLE_MAPS_API_KEY: ${VITE_GOOGLE_MAPS_API_KEY:-}
       secrets:
         - npmrc
     ports:
diff --git a/infrastructure/docker/Dockerfile.web b/infrastructure/docker/Dockerfile.web
index d5f77061e..6ef9231f0 100644
--- a/infrastructure/docker/Dockerfile.web
+++ b/infrastructure/docker/Dockerfile.web
@@ -27,10 +27,12 @@ ARG VITE_API_URL
 ARG VITE_BASE_API_URL
 ARG VITE_USER_MANAGEMENT_BASE
 ARG NEXT_PUBLIC_API_URL
+ARG VITE_GOOGLE_MAPS_API_KEY
 ENV VITE_API_URL=${VITE_API_URL}
 ENV VITE_BASE_API_URL=${VITE_BASE_API_URL}
 ENV VITE_USER_MANAGEMENT_BASE=${VITE_USER_MANAGEMENT_BASE}
 ENV NEXT_PUBLIC_API_URL=${NEXT_PUBLIC_API_URL}
+ENV VITE_GOOGLE_MAPS_API_KEY=${VITE_GOOGLE_MAPS_API_KEY}
 
 RUN if [ -z "$VITE_API_URL" ] || [ -z "$VITE_BASE_API_URL" ] || [ -z "$VITE_USER_MANAGEMENT_BASE" ]; then \
       echo "ERROR: VITE_API_URL, VITE_BASE_API_URL, and VITE_USER_MANAGEMENT_BASE must all be set" && \
diff --git a/packages/payment-providers/src/providers/telebirr/telebirr.provider.ts b/packages/payment-providers/src/providers/telebirr/telebirr.provider.ts
index ae24834c1..d732a51e3 100644
--- a/packages/payment-providers/src/providers/telebirr/telebirr.provider.ts
+++ b/packages/payment-providers/src/providers/telebirr/telebirr.provider.ts
@@ -352,7 +352,7 @@ export class TelebirrProvider implements PaymentProvider {
     return this.config.get<string>("telebirr.timeoutExpress") ?? "15m";
   }
   private get privateKey(): string {
-    return `-----BEGIN PRIVATE KEY-----\nMIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQC/ZcoOng1sJZ4CegopQVCw3HYqqVRLEudgT+dDpS8fRVy7zBgqZunju2VRCQuHeWs7yWgc9QGd4/8kRSLY+jlvKNeZ60yWcqEY+eKyQMmcjOz2Sn41fcVNgF+HV3DGiV4b23B6BCMjnpEFIb9d99/TsjsFSc7gCPgfl2yWDxE/Y1B2tVE6op2qd63YsMVFQGdre/CQYvFJENpQaBLMq4hHyBDgluUXlF0uA1X7UM0ZjbFC6ZIB/Hn1+pl5Ua8dKYrkVaecolmJT/s7c/+/1JeN+ja8luBoONsoODt2mTeVJHLF9Y3oh5rI+IY8HukIZJ1U6O7/JcjH3aRJTZagXUS9AgMBAAECggEBALBIBx8JcWFfEDZFwuAWeUQ7+VX3mVx/770kOuNx24HYt718D/HV0avfKETHqOfA7AQnz42EF1Yd7Rux1ZO0e3unSVRJhMO4linT1XjJ9ScMISAColWQHk3wY4va/FLPqG7N4L1w3BBtdjIc0A2zRGLNcFDBlxl/CVDHfcqD3CXdLukm/friX6TvnrbTyfAFicYgu0+UtDvfxTL3pRL3u3WTkDvnFK5YXhoazLctNOFrNiiIpCW6dJ7WRYRXuXhz7C0rENHyBtJ0zura1WD5oDbRZ8ON4v1KV4QofWiTFXJpbDgZdEeJJmFmt5HIi+Ny3P5n31WwZpRMHGeHrV23//0CgYEA+2/gYjYWOW3JgMDLX7r8fGPTo1ljkOUHuH98H/a/lE3wnnKKx+2ngRNZX4RfvNG4LLeWTz9plxR2RAqqOTbX8fj/NA/sS4mru9zvzMY1925FcX3WsWKBgKlLryl0vPScq4ejMLSCmypGz4VgLMYZqT4NYIkU2Lo1G1MiDoLy0CcCgYEAwt77exynUhM7AlyjhAA2wSINXLKsdFFF1u976x9kVhOfmbAutfMJPEQWb2WXaOJQMvMpgg2rU5aVsyEcuHsRH/2zatrxrGqLqgxaiqPz4ELINIh1iYK/hdRpr1vATHoebOv1wt8/9qxITNKtQTgQbqYci3KV1lPsOrBAB5S57nsCgYAvw+cagS/jpQmcngOEoh8I+mXgKEET64517DIGWHe4kr3dO+FFbc5eZPCbhqgxVJ3qUM4LK/7BJq/46RXBXLvVSfohR80Z5INtYuFjQ1xJLveeQcuhUxdK+95W3kdBBi8lHtVPkVsmYvekwK+ukcuaLSGZbzE4otcn47kajKHYDQKBgDbQyIbJ+ZsRw8CXVHu2H7DWJlIUBIS3s+CQ/xeVfgDkhjmSIKGX2to0AOeW+S9MseiTE/L8a1wY+MUppE2UeK26DLUbH24zjlPoI7PqCJjl0DFOzVlACSXZKV1lfsNEeriC61/EstZtgezyOkAlSCIH4fGr6tAeTU349Bnt0RtvAoGBAObgxjeH6JGpdLz1BbMj8xUHuYQkbxNeIPhH29CySn0vfhwg9VxAtIoOhvZeCfnsCRTj9OZjepCeUqDiDSoFznglrKhfeKUndHjvg+9kiae92iI6qJudPCHMNwP8wMSphkxUqnXFR3lr9A765GA980818UWZdrhrjLKtIIZdh+X1\n-----END PRIVATE KEY-----`
+    return this.config.get<string>("telebirr.privateKey") ?? "";
   }
   private get publicKey(): string {
     return this.config.get<string>("telebirr.publicKey") ?? "";
diff --git a/packages/types/src/freight/contracts.ts b/packages/types/src/freight/contracts.ts
index bf2778575..c6b97fab1 100644
--- a/packages/types/src/freight/contracts.ts
+++ b/packages/types/src/freight/contracts.ts
@@ -561,6 +561,12 @@ export interface IContract extends BaseEntity {
   expiresAt?: string | null;
 
   status: ContractStatus;
+  /**
+   * Body of the latest staff CHANGES_REQUESTED review note (detail response
+   * only, when status is CHANGES_REQUESTED). Lets the portal show the customer
+   * exactly what to fix before resubmitting.
+   */
+  latestChangeRequestNote?: string | null;
   clearanceStatus: ContractClearanceStatus;
   clearanceCycleNumber: number;
   /**
diff --git a/packages/types/src/freight/index.ts b/packages/types/src/freight/index.ts
index c51d838e1..7817e0a31 100644
--- a/packages/types/src/freight/index.ts
+++ b/packages/types/src/freight/index.ts
@@ -87,6 +87,8 @@ export enum BookingStatus {
   Expired = "EXPIRED",
   Paid = "PAID",
   InTransit = "IN_TRANSIT",
+  /** Unloaded at the booking's own destination yard (may precede the train's final arrival). */
+  Arrived = "ARRIVED",
   Completed = "COMPLETED",
   Delivered = "DELIVERED",
   Rejected = "REJECTED",
@@ -255,6 +257,28 @@ export interface ITrainCheckpointEvent extends BaseEntity {
   recordedByUserId?: string | null;
 }
 
+/** Why a physical wagon moved between yards — the wagon_movements ledger kind. */
+export enum WagonMovementKind {
+  /** Carried a booking's cargo for its leg (board yard → alight yard). */
+  Loaded = "LOADED",
+  /** Rode a train empty to reposition for later use. */
+  EmptyReposition = "EMPTY_REPOSITION",
+  /** Staff manually corrected/updated the wagon's yard. */
+  Manual = "MANUAL",
+}
+
+export interface IWagonMovement extends BaseEntity {
+  wagonId: string;
+  fromYardId?: string | null;
+  toYardId: string;
+  trainScheduleId?: string | null;
+  bookingId?: string | null;
+  kind: WagonMovementKind;
+  movedByUserId?: string | null;
+  occurredAt: string;
+  note?: string | null;
+}
+
 export enum BulkPricingUnit {
   PerWagon = "PER_WAGON",
   PerTon = "PER_TON",
@@ -393,12 +417,22 @@ export interface IBookingTracking {
   /** Planned departure/arrival from the schedule, used as ETA hints. */
   scheduledDepartureAt: string | null;
   scheduledArrivalAt: string | null;
+  // ── Per-booking journey (segment corridor bookings) ─────────────────────
+  /** The booking's own status — the journey is per booking, not per train. */
+  bookingStatus?: string | null;
+  /** The leg this booking rides: its own origin/destination yards. */
+  bookingOriginYardId?: string | null;
+  bookingDestinationYardId?: string | null;
+  /** Operator-confirmed load at the booking's origin yard (per-booking dispatch). */
+  loadedAt?: string | null;
+  /** Operator-confirmed unload at the booking's destination yard (per-booking arrival). */
+  arrivedAt?: string | null;
 }
 
 export interface IYard extends BaseEntity {
   code: string;
   label: string;
-  country: string;
+  country: `${YardCountry}`;
   isActive: boolean;
   displayOrder: number;
 }
@@ -729,7 +763,6 @@ export interface BookingReferenceService {
   includesFirstMile: boolean;
   includesLastMile: boolean;
   includesCustoms: boolean;
-  priorityBonusPoints: number;
   isActive: boolean;
   displayOrder: number;
   createdAt: string;
diff --git a/packages/types/src/passenger/index.ts b/packages/types/src/passenger/index.ts
index 667c53318..e7f0d8ccd 100644
--- a/packages/types/src/passenger/index.ts
+++ b/packages/types/src/passenger/index.ts
@@ -1,5 +1,7 @@
 import type { BaseEntity } from "../common";
 
+export * from "./support-chat";
+
 export enum TicketStatus {
   Reserved = "RESERVED",
   Confirmed = "CONFIRMED",
diff --git a/packages/types/src/passenger/support-chat.ts b/packages/types/src/passenger/support-chat.ts
new file mode 100644
index 000000000..254b64e55
--- /dev/null
+++ b/packages/types/src/passenger/support-chat.ts
@@ -0,0 +1,109 @@
+/**
+ * Shared contracts for the passenger in-app customer-support chat.
+ *
+ * Unlike freight (company-scoped), a passenger conversation ("ticket") belongs to a
+ * single **individual passenger** (keyed by their IAM user id). Backoffice agents
+ * work a shared inbox (no assignment). Messages are text-only for the MVP.
+ *
+ * These are the wire (JSON) shapes — dates are ISO strings — plus the frozen
+ * Socket.IO event/namespace constants shared by the gateway (emitter) and both
+ * passenger web apps (subscribers).
+ */
+
+/** Lifecycle of a support conversation. Mirrors the Prisma `SupportConversationStatus`. */
+export enum PassengerSupportStatus {
+  OPEN = "OPEN",
+  RESOLVED = "RESOLVED",
+  CLOSED = "CLOSED",
+}
+
+/** Author of a message. The Prisma `SupportSender` also has `BOT` (legacy, unused here). */
+export enum PassengerSupportSender {
+  USER = "USER",
+  AGENT = "AGENT",
+}
+
+/** A single chat message on the wire. */
+export interface PassengerSupportMessageDto {
+  id: string;
+  conversationId: string;
+  sender: PassengerSupportSender;
+  /** Display name of the author, best-effort. */
+  authorName?: string | null;
+  text: string;
+  createdAt: string;
+}
+
+/** A conversation ("ticket") on the wire, with denormalized last-message fields. */
+export interface PassengerSupportConversationDto {
+  id: string;
+  /** Set for authenticated passengers; null for guest conversations. */
+  userId?: string | null;
+  /** Set for guest (unauthenticated) conversations. */
+  guestId?: string | null;
+  guestEmail?: string | null;
+  guestPhone?: string | null;
+  passengerId?: string | null;
+  /** Display name — passenger's name for authed, guest's name for guests. */
+  passengerName?: string | null;
+  subject?: string | null;
+  status: PassengerSupportStatus;
+  assignedAgentId?: string | null;
+  lastMessageAt?: string | null;
+  lastMessagePreview?: string | null;
+  lastMessageSender?: PassengerSupportSender | null;
+  /** Unread count for the caller's side (messages from the other sender after their cursor). */
+  unreadCount: number;
+  createdAt: string;
+  updatedAt: string;
+}
+
+/** Customer opens a new ticket: subject + first message. */
+export interface CreatePassengerSupportConversationDto {
+  subject: string;
+  initialMessage: string;
+}
+
+/** Guest (unauthenticated) opens a ticket: identity + contact captured up front. */
+export interface CreateGuestSupportConversationDto {
+  guestId: string;
+  name: string;
+  email: string;
+  phone?: string;
+  subject: string;
+  initialMessage: string;
+}
+
+/** Post a message into an existing conversation. */
+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[];
+  count: number;
+  /** Total unread conversations for the caller's side (badge source). */
+  unreadCount: number;
+}
+
+/** Socket.io event names pushed server → client on the passenger support namespace. */
+export const PASSENGER_SUPPORT_WS_EVENTS = {
+  MESSAGE_NEW: "passenger-support:message-new",
+  CONVERSATION_UPDATED: "passenger-support:conversation-updated",
+} as const;
+
+/** Socket.io namespace the passenger support gateway listens on. */
+export const PASSENGER_SUPPORT_WS_NAMESPACE = "passenger-support-chat";
+
+/** Payload for {@link PASSENGER_SUPPORT_WS_EVENTS.MESSAGE_NEW}. */
+export interface PassengerSupportMessageEvent {
+  conversation: PassengerSupportConversationDto;
+  message: PassengerSupportMessageDto;
+}
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 653fe803c..069d12c32 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -247,6 +247,9 @@ importers:
       '@tria-plc/iamui':
         specifier: file:../../../local-packages/tria-plc-iamui-0.1.1.tgz
         version: file:local-packages/tria-plc-iamui-0.1.1.tgz(0ce39b7e349029277dcd938d06eeb0f7)
+      '@vis.gl/react-google-maps':
+        specifier: ^1.8.3
+        version: 1.8.3(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
       axios:
         specifier: ^1.7.7
         version: 1.17.0
@@ -308,6 +311,9 @@ importers:
       '@tailwindcss/vite':
         specifier: ^4.3.0
         version: 4.3.0(vite@5.4.21(@types/node@24.13.1)(lightningcss@1.32.0)(terser@5.48.0))
+      '@types/google.maps':
+        specifier: ^3.65.2
+        version: 3.65.2
       '@types/react':
         specifier: ^18.3.11
         version: 18.3.31
@@ -495,6 +501,9 @@ importers:
       '@nestjs/platform-express':
         specifier: ^11.1.19
         version: 11.1.24(@nestjs/common@11.1.24(class-transformer@0.5.1)(class-validator@0.14.4)(reflect-metadata@0.2.2)(rxjs@7.8.2))(@nestjs/core@11.1.24)
+      '@nestjs/platform-socket.io':
+        specifier: ^11.1.27
+        version: 11.1.27(@nestjs/common@11.1.24(class-transformer@0.5.1)(class-validator@0.14.4)(reflect-metadata@0.2.2)(rxjs@7.8.2))(@nestjs/websockets@11.1.27)(rxjs@7.8.2)
       '@nestjs/schedule':
         specifier: ^6.1.3
         version: 6.1.3(@nestjs/common@11.1.24(class-transformer@0.5.1)(class-validator@0.14.4)(reflect-metadata@0.2.2)(rxjs@7.8.2))(@nestjs/core@11.1.24)
@@ -507,6 +516,9 @@ importers:
       '@nestjs/typeorm':
         specifier: ^11.0.1
         version: 11.0.1(@nestjs/common@11.1.24(class-transformer@0.5.1)(class-validator@0.14.4)(reflect-metadata@0.2.2)(rxjs@7.8.2))(@nestjs/core@11.1.24)(reflect-metadata@0.2.2)(rxjs@7.8.2)(typeorm@0.3.30(babel-plugin-macros@3.1.0)(pg@8.21.0)(ts-node@10.9.2(@types/node@20.19.42)(typescript@5.9.3)))
+      '@nestjs/websockets':
+        specifier: ^11.1.27
+        version: 11.1.27(@nestjs/common@11.1.24(class-transformer@0.5.1)(class-validator@0.14.4)(reflect-metadata@0.2.2)(rxjs@7.8.2))(@nestjs/core@11.1.24)(@nestjs/platform-socket.io@11.1.27)(reflect-metadata@0.2.2)(rxjs@7.8.2)
       '@prisma/client':
         specifier: ^6.19.3
         version: 6.19.3(prisma@6.19.3(typescript@5.9.3))(typescript@5.9.3)
@@ -564,6 +576,9 @@ importers:
       rxjs:
         specifier: ^7.8.1
         version: 7.8.2
+      socket.io:
+        specifier: ^4.8.3
+        version: 4.8.3
       swagger-ui-express:
         specifier: ^5.0.0
         version: 5.0.1(express@4.22.2)
@@ -667,6 +682,9 @@ importers:
       recharts:
         specifier: ^2.12.0
         version: 2.15.4(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
+      socket.io-client:
+        specifier: ^4.8.3
+        version: 4.8.3
       zustand:
         specifier: ^5.0.0
         version: 5.0.14(@types/react@18.3.31)(immer@11.1.8)(react@18.3.1)(use-sync-external-store@1.6.0(react@18.3.1))
@@ -752,6 +770,9 @@ importers:
       react-hook-form:
         specifier: ^7.51.0
         version: 7.77.0(react@18.3.1)
+      socket.io-client:
+        specifier: ^4.8.3
+        version: 4.8.3
       zod:
         specifier: ^3.22.4
         version: 3.25.76