diff --git a/apps/edr-freight-api/src/app.module.ts b/apps/edr-freight-api/src/app.module.ts
index 2bee84923..72a5952d7 100644
--- a/apps/edr-freight-api/src/app.module.ts
+++ b/apps/edr-freight-api/src/app.module.ts
@@ -53,23 +53,23 @@ import {
 } 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";
+// Disabled seeds — imports commented out with their provider/injection/run below.
+// import { DemoUsersSeeder } from "./seed/demo-users.seeder";
+// import { FreightStaffUsersSeeder } from "./seed/freight-staff-users.seeder";
 import { PaymentModule } from "./modules/payment/payment.module";
-import { PricingDataSeeder } from "./seed/pricing-data.seeder";
+// import { PricingDataSeeder } from "./seed/pricing-data.seeder";
 import { FileUploadSettingsSeeder } from "./seed/file-upload-settings.seeder";
-import { IndodeFacilitySeeder } from "./seed/indode-facility.seeder";
-import { Batch14TestDataSeeder } from "./seed/batch1-4-test-data.seeder";
-import { Batch5TestDataSeeder } from "./seed/batch5-test-data.seeder";
-import { Batch7TestDataSeeder } from "./seed/batch7-test-data.seeder";
-import { Batch8TestDataSeeder } from "./seed/batch8-test-data.seeder";
-import { WarehouseDemoSeeder } from "./seed/warehouse-demo.seeder";
-import { ExportDjiboutiInterchangeDemoSeeder } from "./seed/export-djibouti-interchange-demo.seeder";
-import { MarshallingDemoTrainsSeeder } from "./seed/marshalling-demo-trains.seeder";
+// import { IndodeFacilitySeeder } from "./seed/indode-facility.seeder";
+// import { Batch14TestDataSeeder } from "./seed/batch1-4-test-data.seeder";
+// import { Batch5TestDataSeeder } from "./seed/batch5-test-data.seeder";
+// import { Batch7TestDataSeeder } from "./seed/batch7-test-data.seeder";
+// import { Batch8TestDataSeeder } from "./seed/batch8-test-data.seeder";
+// import { WarehouseDemoSeeder } from "./seed/warehouse-demo.seeder";
+// import { ExportDjiboutiInterchangeDemoSeeder } from "./seed/export-djibouti-interchange-demo.seeder";
+// import { MarshallingDemoTrainsSeeder } from "./seed/marshalling-demo-trains.seeder";
 import { FreightPermissionKeyMigrationSeeder } from "./seed/freight-permission-key-migration.seeder";
-import { DemoFreightDataSeeder } from "./seed/demo-freight-data.seeder";
-import { GovCompaniesSeeder } from "./seed/gov-companies.seeder";
-import { EdrTruckFleetSeeder } from "./seed/edr-truck-fleet.seeder";
+// import { DemoFreightDataSeeder } from "./seed/demo-freight-data.seeder";
+// import { GovCompaniesSeeder } from "./seed/gov-companies.seeder";
 import { ApprovedFirstLastMileDemoBookingsSeeder } from "./seed/approved-first-lastmile-demo-bookings.seeder";
 import { PaidImportExportMileDemoSeeder } from "./seed/paid-import-export-mile-demo.seeder";
 //New Trains, Wagons, Container and Cargo management modules
@@ -195,22 +195,22 @@ import { LoggerMiddleware } from "./logger.middleware";
   providers: [
     EdrOrgSeeder,
     FreightPositionsSeeder,
-    DemoUsersSeeder,
-    FreightStaffUsersSeeder,
-    PricingDataSeeder,
     FileUploadSettingsSeeder,
     FreightPermissionKeyMigrationSeeder,
-    DemoFreightDataSeeder,
-    GovCompaniesSeeder,
-    EdrTruckFleetSeeder,
-    IndodeFacilitySeeder,
-    Batch14TestDataSeeder,
-    Batch5TestDataSeeder,
-    Batch7TestDataSeeder,
-    Batch8TestDataSeeder,
-    WarehouseDemoSeeder,
-    ExportDjiboutiInterchangeDemoSeeder,
-    MarshallingDemoTrainsSeeder,
+    // Disabled seeds — providers commented out (imports/injection/run too):
+    // DemoUsersSeeder,
+    // FreightStaffUsersSeeder,
+    // PricingDataSeeder,
+    // DemoFreightDataSeeder,
+    // GovCompaniesSeeder,
+    // IndodeFacilitySeeder,
+    // Batch14TestDataSeeder,
+    // Batch5TestDataSeeder,
+    // Batch7TestDataSeeder,
+    // Batch8TestDataSeeder,
+    // WarehouseDemoSeeder,
+    // ExportDjiboutiInterchangeDemoSeeder,
+    // MarshallingDemoTrainsSeeder,
     ApprovedFirstLastMileDemoBookingsSeeder,
     PaidImportExportMileDemoSeeder,
   ],
@@ -220,53 +220,66 @@ export class AppModule implements OnApplicationBootstrap {
     private readonly seeder: DataSeeder,
     private readonly edrOrgSeeder: EdrOrgSeeder,
     private readonly freightPositionsSeeder: FreightPositionsSeeder,
-    private readonly demoUsersSeeder: DemoUsersSeeder,
-    private readonly freightStaffUsersSeeder: FreightStaffUsersSeeder,
-    private readonly pricingDataSeeder: PricingDataSeeder,
     private readonly fileUploadSettingsSeeder: FileUploadSettingsSeeder,
-    private readonly indodeFacilitySeeder: IndodeFacilitySeeder,
-    private readonly batch14TestDataSeeder: Batch14TestDataSeeder,
-    private readonly batch5TestDataSeeder: Batch5TestDataSeeder,
-    private readonly batch7TestDataSeeder: Batch7TestDataSeeder,
-    private readonly batch8TestDataSeeder: Batch8TestDataSeeder,
-    private readonly warehouseDemoSeeder: WarehouseDemoSeeder,
-    private readonly exportDjiboutiInterchangeDemoSeeder: ExportDjiboutiInterchangeDemoSeeder,
-    private readonly marshallingDemoTrainsSeeder: MarshallingDemoTrainsSeeder,
     private readonly freightPermissionKeyMigrationSeeder: FreightPermissionKeyMigrationSeeder,
-    private readonly demoFreightDataSeeder: DemoFreightDataSeeder,
-    private readonly govCompaniesSeeder: GovCompaniesSeeder,
-    private readonly edrTruckFleetSeeder: EdrTruckFleetSeeder,
+    // Disabled seeds — injections commented out (imports/provider/run too):
+    // private readonly demoUsersSeeder: DemoUsersSeeder,
+    // private readonly freightStaffUsersSeeder: FreightStaffUsersSeeder,
+    // private readonly pricingDataSeeder: PricingDataSeeder,
+    // private readonly indodeFacilitySeeder: IndodeFacilitySeeder,
+    // private readonly batch14TestDataSeeder: Batch14TestDataSeeder,
+    // private readonly batch5TestDataSeeder: Batch5TestDataSeeder,
+    // private readonly batch7TestDataSeeder: Batch7TestDataSeeder,
+    // private readonly batch8TestDataSeeder: Batch8TestDataSeeder,
+    // private readonly warehouseDemoSeeder: WarehouseDemoSeeder,
+    // private readonly exportDjiboutiInterchangeDemoSeeder: ExportDjiboutiInterchangeDemoSeeder,
+    // private readonly marshallingDemoTrainsSeeder: MarshallingDemoTrainsSeeder,
+    // private readonly demoFreightDataSeeder: DemoFreightDataSeeder,
+    // private readonly govCompaniesSeeder: GovCompaniesSeeder,
   ) { }
 
   async onApplicationBootstrap() {
+    // ── Enabled: permissions + file-upload settings (+ dropdown settings) only ──
+    // Everything else below is intentionally disabled. Seeders stay registered
+    // as providers and injected; only their .run() calls are commented out, so
+    // re-enabling any of them is a one-line uncomment.
+
+    // Permissions foundation — keep enabled:
+    //   freightPermissionKeyMigration → renames legacy permission keys
+    //   seeder (IAM DataSeeder)       → seeds the IAM app, roles, permissions
+    //   edrOrgSeeder                  → seeds org/unit + the Permission catalog
+    //   freightPositionsSeeder        → seeds Position + PositionPermission rows
+    //                                   (depends on edrOrgSeeder, must run after)
     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();
+
+    // File upload settings — keep enabled.
     await this.fileUploadSettingsSeeder.run();
-    await this.indodeFacilitySeeder.run();
-    await this.batch14TestDataSeeder.run();
-    await this.batch5TestDataSeeder.run();
-    await this.batch7TestDataSeeder.run();
-    await this.batch8TestDataSeeder.run();
-    await this.warehouseDemoSeeder.run();
-    await this.exportDjiboutiInterchangeDemoSeeder.run();
-    await this.marshallingDemoTrainsSeeder.run();
-    // Idempotent demo data: ≥100 wagons/type, approval chains, 4 staff users.
-    // Each block self-guards on an empty-table check, so this is safe every boot.
-    // Demo data seeds (DemoBookingsSeeder, PricingDataSeeder,
-    // FileUploadSettingsSeeder) are intentionally disabled — they stay
-    // registered as providers but are not run. Re-inject + call .run() to enable.
-    // demoFreightDataSeeder now seeds ONLY the 4 staff users (wagons + approval
-    // rules are disabled inside the seeder). Kept running for the staff users.
-    await this.demoFreightDataSeeder.run();
-    // Government entities (with importer/exporter profiles) that government
-    // bookings bill to. Idempotent — keyed by fixed IDs.
-    await this.govCompaniesSeeder.run();
-    await this.edrTruckFleetSeeder.run();
+
+    // Dropdown settings are not seeded on boot; run them with
+    // `pnpm seed:dropdown-settings` (src/scripts/seed-dropdown-settings.ts).
+
+    // ── Disabled: demo / test / reference data seeds ──
+    // Uncomment a line to re-enable that seed.
+    // await this.demoUsersSeeder.run();
+    // await this.freightStaffUsersSeeder.run();
+    // await this.pricingDataSeeder.run();
+    // await this.indodeFacilitySeeder.run();
+    // await this.batch14TestDataSeeder.run();
+    // await this.batch5TestDataSeeder.run();
+    // await this.batch7TestDataSeeder.run();
+    // await this.batch8TestDataSeeder.run();
+    // await this.warehouseDemoSeeder.run();
+    // await this.exportDjiboutiInterchangeDemoSeeder.run();
+    // await this.marshallingDemoTrainsSeeder.run();
+    // demoFreightDataSeeder seeds ONLY the 4 staff users (wagons + approval
+    // rules are already disabled inside the seeder).
+    // await this.demoFreightDataSeeder.run();
+    // Government entities (importer/exporter profiles) that government bookings
+    // bill to. Idempotent — keyed by fixed IDs.
+    // await this.govCompaniesSeeder.run();
   }
 
   configure(consumer: MiddlewareConsumer) {
diff --git a/apps/edr-freight-api/src/common/booking-guards.ts b/apps/edr-freight-api/src/common/booking-guards.ts
index 7eae4e94d..9769a7f18 100644
--- a/apps/edr-freight-api/src/common/booking-guards.ts
+++ b/apps/edr-freight-api/src/common/booking-guards.ts
@@ -26,6 +26,18 @@ export const FleetView = () => BookingStaff(FREIGHT_PERMS.fleet.view);
 
 export const FleetManage = () => BookingStaff(FREIGHT_PERMS.fleet.manage);
 
+/** Requester creates a wagon-transfer request (count-only, no wagon picks). */
+export const WagonTransferRequest = () =>
+  BookingStaff(FREIGHT_PERMS.wagons.transferRequest);
+
+/** OCC fulfils a wagon-transfer request — picks the wagons and executes the move. */
+export const WagonTransferFulfill = () =>
+  BookingStaff(FREIGHT_PERMS.wagons.transferFulfill);
+
+/** Admin: read every staffer's wagon-transfer history (not just one's own). */
+export const WagonTransferHistoryAll = () =>
+  BookingStaff(FREIGHT_PERMS.wagons.transferHistoryAll);
+
 /** Org-administration endpoints (user mgmt, billing config, company CRUD, settings). */
 export const FreightAdmin = () => BookingStaff(FREIGHT_PERMS.admin);
 
diff --git a/apps/edr-freight-api/src/migrations/2130000000000-AddHandoverSignerName.ts b/apps/edr-freight-api/src/migrations/2130000000000-AddHandoverSignerName.ts
new file mode 100644
index 000000000..4e4c5f5fc
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/2130000000000-AddHandoverSignerName.ts
@@ -0,0 +1,23 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+/**
+ * The person who signs off a handover must record their full name (a signature
+ * is optional, especially for self-haul). Stored per handover record.
+ */
+export class AddHandoverSignerName2130000000000 implements MigrationInterface {
+  name = "AddHandoverSignerName2130000000000";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      ALTER TABLE freight.booking_handovers
+        ADD COLUMN IF NOT EXISTS signer_name varchar(160)
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      ALTER TABLE freight.booking_handovers
+        DROP COLUMN IF EXISTS signer_name
+    `);
+  }
+}
diff --git a/apps/edr-freight-api/src/migrations/2140000000000-CreateAccrualAcks.ts b/apps/edr-freight-api/src/migrations/2140000000000-CreateAccrualAcks.ts
new file mode 100644
index 000000000..5e13a6e3d
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/2140000000000-CreateAccrualAcks.ts
@@ -0,0 +1,29 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+/**
+ * Accrual alert acknowledgements: ops can mark an in-warehouse item's fee
+ * accrual as reviewed (optionally snoozed until a date) so it stops nudging and
+ * drops down the accrual dashboard. One row per inventory item.
+ */
+export class CreateAccrualAcks2140000000000 implements MigrationInterface {
+  name = "CreateAccrualAcks2140000000000";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      CREATE TABLE IF NOT EXISTS freight.warehouse_accrual_acks (
+        id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+        inventory_id uuid NOT NULL UNIQUE,
+        acknowledged_by uuid,
+        acknowledged_at timestamptz NOT NULL DEFAULT now(),
+        snooze_until timestamptz,
+        note text,
+        created_at timestamptz NOT NULL DEFAULT now(),
+        updated_at timestamptz NOT NULL DEFAULT now()
+      )
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`DROP TABLE IF EXISTS freight.warehouse_accrual_acks`);
+  }
+}
diff --git a/apps/edr-freight-api/src/migrations/2150000000000-TrainBuilder.ts b/apps/edr-freight-api/src/migrations/2150000000000-TrainBuilder.ts
new file mode 100644
index 000000000..24fa50feb
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/2150000000000-TrainBuilder.ts
@@ -0,0 +1,105 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+/**
+ * Train Builder: a `Train` becomes a first-class buildable consist — a coded
+ * train (e.g. 81001) assembled in one yard from 2+ locomotives and ordered
+ * wagons, then reused by scheduling ("schedule the train" instead of picking
+ * locomotives per departure).
+ *
+ * - `freight.train_locomotives` — link table train ⇄ locomotive with an order
+ *   index (mirrors `train_set_locomotives`).
+ * - `trains.current_yard_id` — yard the train sits in; wagons/locomotives may
+ *   only be attached from this yard.
+ * - `train_sets.train_id` — which built train an operational set was formed
+ *   from, so schedules can surface the train code and the lifecycle can sync
+ *   the train's status/yard on dispatch/arrival/cancel.
+ *
+ * NOTE: the shared dev DB has no applied migration history, so this is also
+ * hand-applied there. IF NOT EXISTS keeps that idempotent.
+ */
+export class TrainBuilder2150000000000 implements MigrationInterface {
+  name = 'TrainBuilder2150000000000';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      CREATE TABLE IF NOT EXISTS freight.train_locomotives (
+        id uuid NOT NULL DEFAULT uuid_generate_v4(),
+        train_id uuid NOT NULL,
+        locomotive_id uuid NOT NULL,
+        sequence_no int NOT NULL DEFAULT 0,
+        created_at timestamptz NOT NULL DEFAULT now(),
+        updated_at timestamptz NOT NULL DEFAULT now(),
+        deleted_at timestamptz,
+        CONSTRAINT "PK_train_locomotives" PRIMARY KEY (id),
+        CONSTRAINT "FK_train_locomotives_train" FOREIGN KEY (train_id)
+          REFERENCES freight.trains (id) ON DELETE CASCADE,
+        CONSTRAINT "FK_train_locomotives_locomotive" FOREIGN KEY (locomotive_id)
+          REFERENCES freight.locomotives (id)
+      );
+    `);
+
+    await queryRunner.query(`
+      CREATE UNIQUE INDEX IF NOT EXISTS "UQ_train_locomotives_train_loco"
+        ON freight.train_locomotives (train_id, locomotive_id);
+    `);
+
+    await queryRunner.query(`
+      ALTER TABLE freight.trains
+        ADD COLUMN IF NOT EXISTS current_yard_id uuid;
+    `);
+    await queryRunner.query(`
+      DO $$
+      BEGIN
+        IF NOT EXISTS (
+          SELECT 1 FROM pg_constraint WHERE conname = 'FK_trains_current_yard'
+        ) THEN
+          ALTER TABLE freight.trains
+            ADD CONSTRAINT "FK_trains_current_yard" FOREIGN KEY (current_yard_id)
+              REFERENCES freight.yards (id) ON DELETE SET NULL;
+        END IF;
+      END $$;
+    `);
+    await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS "IDX_trains_current_yard_id"
+        ON freight.trains (current_yard_id);
+    `);
+
+    await queryRunner.query(`
+      ALTER TABLE freight.train_sets
+        ADD COLUMN IF NOT EXISTS train_id uuid;
+    `);
+    await queryRunner.query(`
+      DO $$
+      BEGIN
+        IF NOT EXISTS (
+          SELECT 1 FROM pg_constraint WHERE conname = 'FK_train_sets_train'
+        ) THEN
+          ALTER TABLE freight.train_sets
+            ADD CONSTRAINT "FK_train_sets_train" FOREIGN KEY (train_id)
+              REFERENCES freight.trains (id) ON DELETE SET NULL;
+        END IF;
+      END $$;
+    `);
+    await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS "IDX_train_sets_train_id"
+        ON freight.train_sets (train_id);
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`DROP INDEX IF EXISTS freight."IDX_train_sets_train_id";`);
+    await queryRunner.query(`
+      ALTER TABLE freight.train_sets
+        DROP CONSTRAINT IF EXISTS "FK_train_sets_train",
+        DROP COLUMN IF EXISTS train_id;
+    `);
+    await queryRunner.query(`DROP INDEX IF EXISTS freight."IDX_trains_current_yard_id";`);
+    await queryRunner.query(`
+      ALTER TABLE freight.trains
+        DROP CONSTRAINT IF EXISTS "FK_trains_current_yard",
+        DROP COLUMN IF EXISTS current_yard_id;
+    `);
+    await queryRunner.query(`DROP INDEX IF EXISTS freight."UQ_train_locomotives_train_loco";`);
+    await queryRunner.query(`DROP TABLE IF EXISTS freight.train_locomotives;`);
+  }
+}
diff --git a/apps/edr-freight-api/src/migrations/2160000000000-MultiWagonTypePerCargoAndContainer.ts b/apps/edr-freight-api/src/migrations/2160000000000-MultiWagonTypePerCargoAndContainer.ts
new file mode 100644
index 000000000..0fc391904
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/2160000000000-MultiWagonTypePerCargoAndContainer.ts
@@ -0,0 +1,119 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+/**
+ * A container type / cargo type can now be carried by SEVERAL wagon types
+ * (e.g. a 20ft container rides NX70 or NW5). Replaces the single
+ * `wagon_type_id` FK on both tables with proper link tables; train scheduling
+ * resolves the wagon type from the list, picking whichever type the schedule's
+ * built train (or the yard) actually has.
+ *
+ * Backfills one link row from each existing `wagon_type_id`, then drops the
+ * old column — the single-FK field is removed from the API and UI entirely.
+ *
+ * NOTE: the shared dev DB has no applied migration history, so this is also
+ * hand-applied there. IF NOT EXISTS keeps that idempotent.
+ */
+export class MultiWagonTypePerCargoAndContainer2160000000000 implements MigrationInterface {
+  name = 'MultiWagonTypePerCargoAndContainer2160000000000';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      CREATE TABLE IF NOT EXISTS freight.container_type_wagon_types (
+        container_type_id uuid NOT NULL,
+        wagon_type_id uuid NOT NULL,
+        CONSTRAINT "PK_container_type_wagon_types" PRIMARY KEY (container_type_id, wagon_type_id),
+        CONSTRAINT "FK_ctwt_container_type" FOREIGN KEY (container_type_id)
+          REFERENCES freight.container_types (id) ON DELETE CASCADE,
+        CONSTRAINT "FK_ctwt_wagon_type" FOREIGN KEY (wagon_type_id)
+          REFERENCES freight.wagon_types (id) ON DELETE RESTRICT
+      );
+    `);
+    await queryRunner.query(`
+      CREATE TABLE IF NOT EXISTS freight.cargo_type_wagon_types (
+        cargo_type_id uuid NOT NULL,
+        wagon_type_id uuid NOT NULL,
+        CONSTRAINT "PK_cargo_type_wagon_types" PRIMARY KEY (cargo_type_id, wagon_type_id),
+        CONSTRAINT "FK_cgwt_cargo_type" FOREIGN KEY (cargo_type_id)
+          REFERENCES freight.cargo_types (id) ON DELETE CASCADE,
+        CONSTRAINT "FK_cgwt_wagon_type" FOREIGN KEY (wagon_type_id)
+          REFERENCES freight.wagon_types (id) ON DELETE RESTRICT
+      );
+    `);
+
+    // Backfill from the old single FK (column may already be gone on re-run).
+    await queryRunner.query(`
+      DO $$
+      BEGIN
+        IF EXISTS (
+          SELECT 1 FROM information_schema.columns
+          WHERE table_schema = 'freight' AND table_name = 'container_types'
+            AND column_name = 'wagon_type_id'
+        ) THEN
+          INSERT INTO freight.container_type_wagon_types (container_type_id, wagon_type_id)
+          SELECT ct.id, ct.wagon_type_id
+            FROM freight.container_types ct
+           WHERE ct.wagon_type_id IS NOT NULL
+          ON CONFLICT DO NOTHING;
+        END IF;
+      END $$;
+    `);
+    await queryRunner.query(`
+      DO $$
+      BEGIN
+        IF EXISTS (
+          SELECT 1 FROM information_schema.columns
+          WHERE table_schema = 'freight' AND table_name = 'cargo_types'
+            AND column_name = 'wagon_type_id'
+        ) THEN
+          INSERT INTO freight.cargo_type_wagon_types (cargo_type_id, wagon_type_id)
+          SELECT cg.id, cg.wagon_type_id
+            FROM freight.cargo_types cg
+           WHERE cg.wagon_type_id IS NOT NULL
+          ON CONFLICT DO NOTHING;
+        END IF;
+      END $$;
+    `);
+
+    // Old single-FK column is fully retired (API + UI now use the lists).
+    await queryRunner.query(`
+      ALTER TABLE freight.container_types DROP COLUMN IF EXISTS wagon_type_id;
+    `);
+    await queryRunner.query(`
+      ALTER TABLE freight.cargo_types DROP COLUMN IF EXISTS wagon_type_id;
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      ALTER TABLE freight.container_types ADD COLUMN IF NOT EXISTS wagon_type_id uuid
+        REFERENCES freight.wagon_types (id) ON DELETE RESTRICT;
+    `);
+    await queryRunner.query(`
+      ALTER TABLE freight.cargo_types ADD COLUMN IF NOT EXISTS wagon_type_id uuid
+        REFERENCES freight.wagon_types (id) ON DELETE RESTRICT;
+    `);
+    // Restore the first linked wagon type per row, then drop the link tables.
+    await queryRunner.query(`
+      UPDATE freight.container_types ct
+         SET wagon_type_id = link.wagon_type_id
+        FROM (
+          SELECT DISTINCT ON (container_type_id) container_type_id, wagon_type_id
+            FROM freight.container_type_wagon_types
+           ORDER BY container_type_id, wagon_type_id
+        ) link
+       WHERE link.container_type_id = ct.id;
+    `);
+    await queryRunner.query(`
+      UPDATE freight.cargo_types cg
+         SET wagon_type_id = link.wagon_type_id
+        FROM (
+          SELECT DISTINCT ON (cargo_type_id) cargo_type_id, wagon_type_id
+            FROM freight.cargo_type_wagon_types
+           ORDER BY cargo_type_id, wagon_type_id
+        ) link
+       WHERE link.cargo_type_id = cg.id;
+    `);
+    await queryRunner.query(`DROP TABLE IF EXISTS freight.container_type_wagon_types;`);
+    await queryRunner.query(`DROP TABLE IF EXISTS freight.cargo_type_wagon_types;`);
+  }
+}
diff --git a/apps/edr-freight-api/src/migrations/2170000000000-CreateWagonTransferRequests.ts b/apps/edr-freight-api/src/migrations/2170000000000-CreateWagonTransferRequests.ts
new file mode 100644
index 000000000..2b73eaa0c
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/2170000000000-CreateWagonTransferRequests.ts
@@ -0,0 +1,51 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+/**
+ * Two-person wagon-transfer request queue. A requester records a count-only
+ * request (N wagons of a type, from yard → to yard); OCC staff later pick the
+ * physical wagons and execute the move. Replaces the single-step instant
+ * bulk-transfer as the customer-facing yard-to-yard relocation path.
+ */
+export class CreateWagonTransferRequests2170000000000
+  implements MigrationInterface
+{
+  name = 'CreateWagonTransferRequests2170000000000';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      CREATE TABLE IF NOT EXISTS freight.wagon_transfer_requests (
+        id                    uuid        NOT NULL DEFAULT gen_random_uuid(),
+        from_yard_id          uuid        NOT NULL,
+        to_yard_id            uuid        NOT NULL,
+        wagon_type_id         uuid        NOT NULL,
+        quantity              integer     NOT NULL,
+        status                varchar(20) NOT NULL DEFAULT 'PENDING',
+        requested_by_user_id  uuid        NULL,
+        fulfilled_by_user_id  uuid        NULL,
+        fulfilled_at          timestamptz NULL,
+        note                  text        NULL,
+        created_at            timestamptz NOT NULL DEFAULT now(),
+        updated_at            timestamptz NOT NULL DEFAULT now(),
+        deleted_at            timestamptz NULL,
+        CONSTRAINT pk_wagon_transfer_requests PRIMARY KEY (id),
+        CONSTRAINT fk_wtr_from_yard    FOREIGN KEY (from_yard_id)  REFERENCES freight.yards (id),
+        CONSTRAINT fk_wtr_to_yard      FOREIGN KEY (to_yard_id)    REFERENCES freight.yards (id),
+        CONSTRAINT fk_wtr_wagon_type   FOREIGN KEY (wagon_type_id) REFERENCES freight.wagon_types (id),
+        CONSTRAINT chk_wtr_quantity    CHECK (quantity > 0)
+      )
+    `);
+    await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS idx_wtr_status_from_yard
+        ON freight.wagon_transfer_requests (status, from_yard_id)
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `DROP INDEX IF EXISTS freight.idx_wtr_status_from_yard`,
+    );
+    await queryRunner.query(
+      `DROP TABLE IF EXISTS freight.wagon_transfer_requests`,
+    );
+  }
+}
diff --git a/apps/edr-freight-api/src/migrations/2170000000000-ScheduleWagonAdjustmentLogs.ts b/apps/edr-freight-api/src/migrations/2170000000000-ScheduleWagonAdjustmentLogs.ts
new file mode 100644
index 000000000..7fecfccbb
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/2170000000000-ScheduleWagonAdjustmentLogs.ts
@@ -0,0 +1,50 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+/**
+ * Consist adjustments from a schedule: staff can trim free wagons off a built
+ * train when their tare pushes gross weight over the locomotives' pull limit
+ * (incl. overage tolerance), or couple extra yard wagons on while weight and
+ * length headroom remain. Each add/remove is logged here so the schedule keeps
+ * an auditable history; the built train itself is updated in place.
+ *
+ * Plain columns (no FKs) so the history survives wagon/train deletion.
+ *
+ * NOTE: the shared dev DB has no applied migration history, so this is also
+ * hand-applied there. IF NOT EXISTS keeps that idempotent.
+ */
+export class ScheduleWagonAdjustmentLogs2170000000000 implements MigrationInterface {
+  name = 'ScheduleWagonAdjustmentLogs2170000000000';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      CREATE TABLE IF NOT EXISTS freight.schedule_wagon_adjustment_logs (
+        id uuid NOT NULL DEFAULT uuid_generate_v4(),
+        train_schedule_id uuid NOT NULL,
+        train_id uuid NOT NULL,
+        action varchar(10) NOT NULL,
+        wagon_id uuid NOT NULL,
+        wagon_number varchar(50) NOT NULL,
+        adjusted_by_user_id uuid,
+        occurred_at timestamptz NOT NULL DEFAULT now(),
+        created_at timestamptz NOT NULL DEFAULT now(),
+        updated_at timestamptz NOT NULL DEFAULT now(),
+        deleted_at timestamptz,
+        CONSTRAINT "PK_schedule_wagon_adjustment_logs" PRIMARY KEY (id)
+      );
+    `);
+    await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS "IDX_swal_train_schedule_id"
+        ON freight.schedule_wagon_adjustment_logs (train_schedule_id);
+    `);
+    await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS "IDX_swal_train_id"
+        ON freight.schedule_wagon_adjustment_logs (train_id);
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`DROP INDEX IF EXISTS freight."IDX_swal_train_id";`);
+    await queryRunner.query(`DROP INDEX IF EXISTS freight."IDX_swal_train_schedule_id";`);
+    await queryRunner.query(`DROP TABLE IF EXISTS freight.schedule_wagon_adjustment_logs;`);
+  }
+}
diff --git a/apps/edr-freight-api/src/migrations/2180000000000-LinkWagonMovementToTransferRequest.ts b/apps/edr-freight-api/src/migrations/2180000000000-LinkWagonMovementToTransferRequest.ts
new file mode 100644
index 000000000..3f10fa874
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/2180000000000-LinkWagonMovementToTransferRequest.ts
@@ -0,0 +1,54 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+/**
+ * Link each physical wagon move back to the transfer request that drove it, so
+ * the history can show "Request S→K, 3× NX70 → wagons W101, W102, W103".
+ * Nullable — legacy moves and non-request manual corrections carry no request.
+ * Also indexes `moved_by_user_id` for the per-user history queries.
+ */
+export class LinkWagonMovementToTransferRequest2180000000000
+  implements MigrationInterface
+{
+  name = 'LinkWagonMovementToTransferRequest2180000000000';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      ALTER TABLE freight.wagon_movements
+        ADD COLUMN IF NOT EXISTS transfer_request_id uuid NULL
+    `);
+    await queryRunner.query(`
+      DO $$
+      BEGIN
+        IF NOT EXISTS (
+          SELECT 1 FROM pg_constraint WHERE conname = 'fk_wm_transfer_request'
+        ) THEN
+          ALTER TABLE freight.wagon_movements
+            ADD CONSTRAINT fk_wm_transfer_request
+            FOREIGN KEY (transfer_request_id)
+            REFERENCES freight.wagon_transfer_requests (id) ON DELETE SET NULL;
+        END IF;
+      END $$;
+    `);
+    await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS idx_wm_transfer_request
+        ON freight.wagon_movements (transfer_request_id)
+    `);
+    await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS idx_wm_moved_by
+        ON freight.wagon_movements (moved_by_user_id)
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`DROP INDEX IF EXISTS freight.idx_wm_moved_by`);
+    await queryRunner.query(`DROP INDEX IF EXISTS freight.idx_wm_transfer_request`);
+    await queryRunner.query(`
+      ALTER TABLE freight.wagon_movements
+        DROP CONSTRAINT IF EXISTS fk_wm_transfer_request
+    `);
+    await queryRunner.query(`
+      ALTER TABLE freight.wagon_movements
+        DROP COLUMN IF EXISTS transfer_request_id
+    `);
+  }
+}
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 6a04014a7..317066cc4 100644
--- a/apps/edr-freight-api/src/modules/bookings/bookings.repository.ts
+++ b/apps/edr-freight-api/src/modules/bookings/bookings.repository.ts
@@ -1255,10 +1255,11 @@ export class BookingsRepository extends BaseRepository<Booking> {
         destinationYard: true,
         // units carry the real per-container numbers entered at booking time —
         // the wagon plan shows those instead of generated placeholders.
-        // containerType.wagonType + cargoType.wagonType drive wagon-type
-        // resolution during scheduling (FK, not the old load-type string map).
-        bookingContainers: { containerType: { wagonType: true }, units: true },
-        cargoType: { wagonType: true },
+        // containerType.wagonTypes + cargoType.wagonTypes drive wagon-type
+        // resolution during scheduling (many-to-many lists — the plan mixes
+        // wagon types within one consist).
+        bookingContainers: { containerType: { wagonTypes: true }, units: true },
+        cargoType: { wagonTypes: true },
       },
       order: { priorityScore: 'DESC', createdAt: 'ASC' },
     });
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 b61d0078d..f366faa96 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
@@ -328,18 +328,21 @@ export class CustomerTruckService {
     if (assignment.departedAt) {
       throw new ConflictException('This truck has already left — its load is locked');
     }
-    // Containers can only be loaded after the truck has physically arrived at the
-    // warehouse (arrival weighing recorded). Assignment alone is just planning.
-    if (!assignment.arrivedAt) {
-      throw new BadRequestException(
-        'Record the truck arrival before loading — containers can only be loaded onto an arrived truck',
-      );
-    }
+    // Loading a truck at the warehouse implies it is physically present, so a
+    // truck that is still only assigned (not yet marked arrived) is auto-arrived
+    // here rather than blocking the operator — the real gross is weighed on
+    // departure anyway.
+    const needsArrival = !assignment.arrivedAt;
 
     const requested = (dto.containerNumbers ?? []).map((n) => n.trim().toUpperCase());
     if (!requested.length) {
       throw new BadRequestException('Select at least one container to load onto the truck');
     }
+    // Capacity is size-based: a truck carries at most 2 containers, and a 40ft
+    // container fills the truck (max 1) — mirror the addTruck/updateTruck rule.
+    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)) {
@@ -352,6 +355,12 @@ export class CustomerTruckService {
         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 — load only 1 container onto this truck',
+      );
+    }
 
     const grossTons = await this.vgmTonsForContainers(bookingId, requested);
     await this.dataSource.transaction(async (manager) => {
@@ -371,9 +380,20 @@ export class CustomerTruckService {
       );
       // Provisional gross (tonnes) from the loaded containers' VGM — overridden
       // by the weighed gross on departure. (Column is *_kg but holds tonnes.)
+      // Auto-stamp arrival if the truck was still only assigned.
       await manager.getRepository(CustomerTruckAssignment).update(assignmentId, {
         grossWeightKg: grossTons,
+        ...(needsArrival ? { arrivedAt: new Date() } : {}),
       });
+      if (needsArrival) {
+        await manager.query(
+          `UPDATE freight.bookings
+              SET customer_truck_arrived_at = COALESCE(customer_truck_arrived_at, NOW()),
+                  updated_at = NOW()
+            WHERE id = $1`,
+          [bookingId],
+        );
+      }
     });
     return this.listTrucks(bookingId);
   }
diff --git a/apps/edr-freight-api/src/modules/bookings/dto/load-customer-truck.dto.ts b/apps/edr-freight-api/src/modules/bookings/dto/load-customer-truck.dto.ts
index 11c80f687..1386e5bd4 100644
--- a/apps/edr-freight-api/src/modules/bookings/dto/load-customer-truck.dto.ts
+++ b/apps/edr-freight-api/src/modules/bookings/dto/load-customer-truck.dto.ts
@@ -1,9 +1,11 @@
-import { ArrayMinSize, ArrayUnique, IsArray, Matches } from 'class-validator';
+import { ArrayMaxSize, ArrayMinSize, ArrayUnique, IsArray, Matches } from 'class-validator';
 
 /** Containers loaded onto a truck at Truck_dispatch (after arrival, before it leaves). */
 export class LoadCustomerTruckDto {
   @IsArray()
   @ArrayMinSize(1)
+  // A truck carries at most 2 containers (two 20ft, or one 40ft).
+  @ArrayMaxSize(2)
   @ArrayUnique()
   @Matches(/^[A-Z]{4}\d{7}$/, {
     each: true,
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 abee4d53d..fa7ee59ec 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
@@ -67,6 +67,12 @@ export class LastMileController {
     return this.lastMileService.findById(id);
   }
 
+  @Get('booking/:bookingId/arrival-trucks')
+  @ApiOperation({ summary: "Assigned EDR last-mile trucks for a booking (arrival/exit weighing prefill)" })
+  arrivalTrucks(@Param('bookingId', ParseUUIDPipe) bookingId: string) {
+    return this.lastMileService.arrivalTrucksForBooking(bookingId);
+  }
+
   @Post('accept/:reference')
   @BookingStaff(FREIGHT_PERMS.lastMile.accept)
   @ApiOperation({ summary: 'Accept a paid booking and create a last-mile leg' })
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 999137e6e..1ee31c63a 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
@@ -256,7 +256,95 @@ export class LastMileService {
     return this.findById(id);
   }
 
+  /**
+   * The EDR last-mile trucks assigned to a booking, joined with driver details,
+   * shaped for the arrival/exit weighing prefill (plate, driver, type, container).
+   * Returns [] when the booking has no last-mile truck assigned. Lets the
+   * warehouse arrival/load modals surface an assigned EDR truck the same way the
+   * self-haul customer trucks are surfaced.
+   */
+  async arrivalTrucksForBooking(bookingId: string): Promise<
+    Array<{
+      vehicleId: string;
+      truckPlateNumber: string | null;
+      trailerPlateNumber: string | null;
+      driverName: string | null;
+      driverLicense: string | null;
+      driverPhone: string | null;
+      truckType: string | null;
+      containerNumber: string | null;
+    }>
+  > {
+    const [lm] = await this.lastMileRepository.findAll({
+      where: { bookingId },
+      relations: { vehicle: true, vehicleAssignments: { vehicle: true } },
+      take: 1,
+    });
+    if (!lm) return [];
+
+    // Prefer the multi-truck junction; fall back to the legacy single vehicle.
+    const sources = lm.vehicleAssignments?.length
+      ? lm.vehicleAssignments.map((va) => ({
+          vehicle: va.vehicle,
+          containerNumber: va.containerNumber ?? null,
+        }))
+      : lm.vehicle
+        ? [{ vehicle: lm.vehicle, containerNumber: null }]
+        : [];
+
+    const out: Array<{
+      vehicleId: string;
+      truckPlateNumber: string | null;
+      trailerPlateNumber: string | null;
+      driverName: string | null;
+      driverLicense: string | null;
+      driverPhone: string | null;
+      truckType: string | null;
+      containerNumber: string | null;
+    }> = [];
+    for (const { vehicle, containerNumber } of sources) {
+      if (!vehicle) continue;
+      let driverName = vehicle.assignedDriverName ?? null;
+      let driverLicense: string | null = null;
+      let driverPhone: string | null = null;
+      if (vehicle.assignedDriverId) {
+        try {
+          const d = await this.driversService.findById(vehicle.assignedDriverId);
+          driverName = driverName || `${d.firstName ?? ''} ${d.lastName ?? ''}`.trim() || null;
+          driverLicense = d.licenseNumber ?? null;
+          driverPhone = d.phoneNumber ?? null;
+        } catch {
+          /* driver lookup is best-effort — plate still prefills */
+        }
+      }
+      out.push({
+        vehicleId: vehicle.id,
+        truckPlateNumber: vehicle.powerPlateNo || vehicle.plateNumber || null,
+        trailerPlateNumber: vehicle.trailerPlateNo || null,
+        driverName,
+        driverLicense,
+        driverPhone,
+        truckType: vehicle.vehicleType || null,
+        containerNumber,
+      });
+    }
+    return out;
+  }
+
   async create(dto: CreateLastMileDto): Promise<LastMile> {
+    // Idempotent: a booking gets exactly one last-mile record. Extra trucks live
+    // inside that record (vehicleAssignments), never as additional rows — so if a
+    // last-mile already exists for this booking, return it instead of inserting a
+    // duplicate delivery row (which is what made the same booking appear twice in
+    // the Assign-Mile list).
+    const [existing] = await this.lastMileRepository.findAll({
+      where: { bookingId: dto.bookingId },
+      take: 1,
+    });
+    if (existing) {
+      return existing;
+    }
+
     const record = await this.lastMileRepository.create({
       bookingId: dto.bookingId,
       status: dto.status ?? 'READY_TO_TRANSIT',
@@ -318,6 +406,17 @@ export class LastMileService {
       }
     }
 
+    // A last-mile truck must have a driver before it can be assigned (same rule
+    // as setVehicles) — block driverless single-vehicle (re)assignment too.
+    if (dto.vehicleId && dto.vehicleId !== existing.vehicleId) {
+      const vehicle = await this.vehiclesService.findById(dto.vehicleId);
+      if (!vehicle?.assignedDriverId) {
+        throw new BadRequestException(
+          `Truck ${vehicle?.plateNumber ?? dto.vehicleId} has no assigned driver — assign a driver to the truck before adding it to this last-mile delivery`,
+        );
+      }
+    }
+
     const dtoAny = dto as any;
     const updated = await this.lastMileRepository.update(id, {
       ...(dto.bookingId !== undefined ? { bookingId: dto.bookingId } : {}),
@@ -478,6 +577,17 @@ export class LastMileService {
     )];
     const added = desired.filter((v) => !junctionSet.has(v));
     const removed = releaseIds.filter((v) => !desiredSet.has(v));
+
+    // A last-mile truck must have a driver before it can be assigned — a delivery
+    // can't run driverless, and the arrival/exit weighing needs the driver.
+    for (const vehicleId of added) {
+      const vehicle = await this.vehiclesService.findById(vehicleId);
+      if (!vehicle?.assignedDriverId) {
+        throw new BadRequestException(
+          `Truck ${vehicle?.plateNumber ?? vehicleId} has no assigned driver — assign a driver to the truck before adding it to this last-mile delivery`,
+        );
+      }
+    }
     // Vehicles that stay but whose container number changed.
     const changed = current.filter(
       (a) =>
diff --git a/apps/edr-freight-api/src/modules/rule-engine/dto/create-cargo-type.dto.ts b/apps/edr-freight-api/src/modules/rule-engine/dto/create-cargo-type.dto.ts
index 76db7fa78..c2c034c18 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/dto/create-cargo-type.dto.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/dto/create-cargo-type.dto.ts
@@ -1,6 +1,6 @@
 import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
 import { CargoUnitOfMeasure } from '@edr/types';
-import { IsBoolean, IsEnum, IsInt, IsOptional, IsString, IsUUID, MaxLength, Min } from 'class-validator';
+import { IsArray, IsBoolean, IsEnum, IsInt, IsOptional, IsString, IsUUID, MaxLength, Min } from 'class-validator';
 
 export class CreateCargoTypeDto {
   @ApiProperty({ description: 'Cargo type display name', maxLength: 255 })
@@ -22,12 +22,15 @@ export class CreateCargoTypeDto {
   parentGroupId?: string;
 
   @ApiPropertyOptional({
+    type: [String],
+    format: 'uuid',
     description:
-      'Wagon type used to carry this (bulk) cargo. Drives train scheduling wagon-type resolution; required for bulk commodities that are scheduled.',
+      'Wagon types that can carry this (bulk) cargo. Drives train scheduling wagon-type resolution; at least one is required for bulk commodities that are scheduled.',
   })
   @IsOptional()
-  @IsUUID('4')
-  wagonTypeId?: string | null;
+  @IsArray()
+  @IsUUID('4', { each: true })
+  wagonTypeIds?: string[];
 
   @ApiPropertyOptional({ default: false })
   @IsOptional()
diff --git a/apps/edr-freight-api/src/modules/rule-engine/dto/create-container-type.dto.ts b/apps/edr-freight-api/src/modules/rule-engine/dto/create-container-type.dto.ts
index e0baf7251..a01ba4b5b 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/dto/create-container-type.dto.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/dto/create-container-type.dto.ts
@@ -1,6 +1,6 @@
 import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
 import { Transform } from 'class-transformer';
-import { IsBoolean, IsInt, IsNumber, IsOptional, IsString, IsUUID, Max, MaxLength, Min } from 'class-validator';
+import { IsArray, IsBoolean, IsInt, IsNumber, IsOptional, IsString, IsUUID, Max, MaxLength, Min } from 'class-validator';
 
 export class CreateContainerTypeDto {
   @ApiProperty({ description: 'Customer-facing label, e.g. "20ft Dry Container"', maxLength: 100 })
@@ -31,12 +31,15 @@ export class CreateContainerTypeDto {
   isOpenTop?: boolean;
 
   @ApiPropertyOptional({
+    type: [String],
+    format: 'uuid',
     description:
-      'Wagon type used to carry this container. Drives train scheduling wagon-type resolution; required when this container type is scheduled.',
+      'Wagon types that can carry this container. Drives train scheduling wagon-type resolution; at least one is required when this container type is scheduled.',
   })
   @IsOptional()
-  @IsUUID('4')
-  wagonTypeId?: string | null;
+  @IsArray()
+  @IsUUID('4', { each: true })
+  wagonTypeIds?: string[];
 
   @ApiPropertyOptional({ default: true })
   @IsOptional()
diff --git a/apps/edr-freight-api/src/modules/rule-engine/entities/cargo-type.entity.ts b/apps/edr-freight-api/src/modules/rule-engine/entities/cargo-type.entity.ts
index ac8a2ea24..7396595d1 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/entities/cargo-type.entity.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/entities/cargo-type.entity.ts
@@ -1,13 +1,21 @@
 import { BaseEntity } from '@edr/api-common';
 import { CargoUnitOfMeasure } from '@edr/types';
-import { Column, Entity, Index, JoinColumn, ManyToOne, OneToMany } from 'typeorm';
+import {
+  Column,
+  Entity,
+  Index,
+  JoinColumn,
+  JoinTable,
+  ManyToMany,
+  ManyToOne,
+  OneToMany,
+} from 'typeorm';
 import { WagonType } from '../../wagon-types/entities/wagon-type.entity';
 
 @Entity({ schema: 'freight', name: 'cargo_types' })
 @Index(['isActive'])
 @Index(['displayOrder'])
 @Index(['parentGroupId'])
-@Index(['wagonTypeId'])
 @Index(['code'])
 export class CargoType extends BaseEntity {
   @Column({ name: 'code', type: 'varchar', length: 50, unique: true, default: '' })
@@ -28,17 +36,19 @@ export class CargoType extends BaseEntity {
   unitOfMeasure?: CargoUnitOfMeasure | null;
 
   /**
-   * Wagon type that carries this (bulk) cargo. Replaces the former hardcoded
-   * cargo-code → wagon-code map: train scheduling resolves the bulk wagon type
-   * through this FK. Nullable — grouping rows and container/legacy cargo never
-   * carry it; scheduling throws if a scheduled bulk cargo type leaves it unset.
+   * Wagon types that can carry this (bulk) cargo. Train scheduling resolves the
+   * bulk wagon type through this list, picking whichever type the schedule's
+   * train (or yard) actually has. Grouping rows and container/legacy cargo
+   * leave it empty; scheduling throws if a scheduled bulk cargo type has none.
    */
-  @Column({ name: 'wagon_type_id', type: 'uuid', nullable: true })
-  wagonTypeId?: string | null;
-
-  @ManyToOne(() => WagonType, { nullable: true, onDelete: 'RESTRICT' })
-  @JoinColumn({ name: 'wagon_type_id' })
-  wagonType?: WagonType | null;
+  @ManyToMany(() => WagonType)
+  @JoinTable({
+    name: 'cargo_type_wagon_types',
+    schema: 'freight',
+    joinColumn: { name: 'cargo_type_id', referencedColumnName: 'id' },
+    inverseJoinColumn: { name: 'wagon_type_id', referencedColumnName: 'id' },
+  })
+  wagonTypes?: WagonType[];
 
   @Column({ name: 'requires_director_approval', type: 'boolean', default: false })
   requiresDirectorApproval!: boolean;
diff --git a/apps/edr-freight-api/src/modules/rule-engine/entities/container-type.entity.ts b/apps/edr-freight-api/src/modules/rule-engine/entities/container-type.entity.ts
index f7cbeed99..2347426ca 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/entities/container-type.entity.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/entities/container-type.entity.ts
@@ -1,12 +1,11 @@
 import { BaseEntity } from '@edr/api-common';
-import { Column, Entity, Index, JoinColumn, ManyToOne, OneToMany } from 'typeorm';
+import { Column, Entity, Index, JoinTable, ManyToMany, OneToMany } from 'typeorm';
 import { WeightLimitRule } from './weight-limit-rule.entity';
 import { WagonType } from '../../wagon-types/entities/wagon-type.entity';
 
 @Entity({ schema: 'freight', name: 'container_types' })
 @Index(['code'])
 @Index(['isActive'])
-@Index(['wagonTypeId'])
 export class ContainerType extends BaseEntity {
   @Column({ name: 'code', type: 'varchar', length: 20, unique: true })
   code!: string;
@@ -27,17 +26,19 @@ export class ContainerType extends BaseEntity {
   isOpenTop!: boolean;
 
   /**
-   * Wagon type that carries this container. Replaces the former hardcoded
-   * container wagon-code default (NW5): train scheduling resolves the container
-   * wagon type through this FK. Nullable; scheduling throws if a scheduled
-   * container type leaves it unset.
+   * Wagon types that can carry this container (e.g. a 20ft rides NX70 or NW5).
+   * Train scheduling resolves the container wagon type through this list,
+   * picking whichever type the schedule's train (or yard) actually has.
+   * Scheduling throws if a scheduled container type has none configured.
    */
-  @Column({ name: 'wagon_type_id', type: 'uuid', nullable: true })
-  wagonTypeId?: string | null;
-
-  @ManyToOne(() => WagonType, { nullable: true, onDelete: 'RESTRICT' })
-  @JoinColumn({ name: 'wagon_type_id' })
-  wagonType?: WagonType | null;
+  @ManyToMany(() => WagonType)
+  @JoinTable({
+    name: 'container_type_wagon_types',
+    schema: 'freight',
+    joinColumn: { name: 'container_type_id', referencedColumnName: 'id' },
+    inverseJoinColumn: { name: 'wagon_type_id', referencedColumnName: 'id' },
+  })
+  wagonTypes?: WagonType[];
 
   @Column({ name: 'is_active', type: 'boolean', default: true })
   isActive!: boolean;
diff --git a/apps/edr-freight-api/src/modules/rule-engine/repositories/cargo-types.repository.ts b/apps/edr-freight-api/src/modules/rule-engine/repositories/cargo-types.repository.ts
index 8e4be5a3b..4df961aaa 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/repositories/cargo-types.repository.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/repositories/cargo-types.repository.ts
@@ -15,7 +15,7 @@ export class CargoTypesRepository implements ICargoTypesRepository {
   }
 
   findById(id: string): Promise<CargoType | null> {
-    return this.repo.findOne({ where: { id }, relations: { parent: true } });
+    return this.repo.findOne({ where: { id }, relations: { parent: true, wagonTypes: true } });
   }
 
   findByCode(code: string): Promise<CargoType | null> {
@@ -35,6 +35,7 @@ export class CargoTypesRepository implements ICargoTypesRepository {
     const qb = this.repo
       .createQueryBuilder('cargoType')
       .leftJoinAndSelect('cargoType.parent', 'parent')
+      .leftJoinAndSelect('cargoType.wagonTypes', 'wagonType')
       .orderBy(`cargoType.${query.sortBy ?? 'displayOrder'}`, query.sortOrder ?? 'ASC');
 
     if (query.isActive !== undefined) {
@@ -63,7 +64,18 @@ export class CargoTypesRepository implements ICargoTypesRepository {
   }
 
   async update(id: string, data: Partial<CargoType>): Promise<CargoType | null> {
-    await this.repo.update(id, data as never);
+    // Relation lists can't ride a column UPDATE — sync them via entity save.
+    const { wagonTypes, ...columns } = data;
+    if (Object.keys(columns).length) {
+      await this.repo.update(id, columns as never);
+    }
+    if (wagonTypes) {
+      const entity = await this.repo.findOne({ where: { id } });
+      if (entity) {
+        entity.wagonTypes = wagonTypes;
+        await this.repo.save(entity);
+      }
+    }
     return this.findById(id);
   }
 
diff --git a/apps/edr-freight-api/src/modules/rule-engine/repositories/container-types.repository.ts b/apps/edr-freight-api/src/modules/rule-engine/repositories/container-types.repository.ts
index ff5a3f994..cc65bf546 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/repositories/container-types.repository.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/repositories/container-types.repository.ts
@@ -15,7 +15,7 @@ export class ContainerTypesRepository implements IContainerTypesRepository {
   }
 
   findById(id: string): Promise<ContainerType | null> {
-    return this.repo.findOne({ where: { id } });
+    return this.repo.findOne({ where: { id }, relations: { wagonTypes: true } });
   }
 
   findByCode(code: string): Promise<ContainerType | null> {
@@ -34,6 +34,7 @@ export class ContainerTypesRepository implements IContainerTypesRepository {
   findPaged(query: ListContainerTypesQueryDto): Promise<PaginatedResponse<ContainerType>> {
     const qb = this.repo
       .createQueryBuilder('containerType')
+      .leftJoinAndSelect('containerType.wagonTypes', 'wagonType')
       .orderBy(`containerType.${query.sortBy ?? 'displayOrder'}`, query.sortOrder ?? 'ASC');
 
     if (query.isActive !== undefined) {
@@ -54,7 +55,18 @@ export class ContainerTypesRepository implements IContainerTypesRepository {
   }
 
   async update(id: string, data: Partial<ContainerType>): Promise<ContainerType | null> {
-    await this.repo.update(id, data as never);
+    // Relation lists can't ride a column UPDATE — sync them via entity save.
+    const { wagonTypes, ...columns } = data;
+    if (Object.keys(columns).length) {
+      await this.repo.update(id, columns as never);
+    }
+    if (wagonTypes) {
+      const entity = await this.repo.findOne({ where: { id } });
+      if (entity) {
+        entity.wagonTypes = wagonTypes;
+        await this.repo.save(entity);
+      }
+    }
     return this.findById(id);
   }
 
diff --git a/apps/edr-freight-api/src/modules/rule-engine/services/cargo-types.service.ts b/apps/edr-freight-api/src/modules/rule-engine/services/cargo-types.service.ts
index 941d35f2f..8a72cf1f8 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/services/cargo-types.service.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/services/cargo-types.service.ts
@@ -6,6 +6,7 @@ import { ListCargoTypesQueryDto } from '../dto/list-rule-engine-query.dto';
 import { ReorderItemsDto } from '../dto/reorder-items.dto';
 import { UpdateCargoTypeDto } from '../dto/update-cargo-type.dto';
 import { CargoType } from '../entities/cargo-type.entity';
+import { WagonType } from '../../wagon-types/entities/wagon-type.entity';
 import {
   CARGO_TYPES_REPOSITORY,
   ICargoTypesRepository,
@@ -59,7 +60,8 @@ export class CargoTypesService {
       requiresDirectorApproval: dto.requiresDirectorApproval ?? false,
       isActive: dto.isActive ?? true,
       unitOfMeasure: dto.unitOfMeasure ?? null,
-      wagonTypeId: dto.wagonTypeId ?? null,
+      // Join rows are written by the save (RESTRICT FK rejects unknown ids).
+      wagonTypes: (dto.wagonTypeIds ?? []).map((id) => ({ id }) as WagonType),
       displayOrder,
     });
   }
@@ -72,7 +74,13 @@ export class CargoTypesService {
       const parent = await this.repository.findById(dto.parentGroupId);
       if (!parent) throw new NotFoundException(`Parent cargo type ${dto.parentGroupId} not found`);
     }
-    const updated = await this.repository.update(id, dto);
+    const { wagonTypeIds, insertAfterId: _insertAfterId, ...columns } = dto;
+    const updated = await this.repository.update(id, {
+      ...columns,
+      ...(wagonTypeIds
+        ? { wagonTypes: wagonTypeIds.map((wagonTypeId) => ({ id: wagonTypeId }) as WagonType) }
+        : {}),
+    });
     if (!updated) throw new NotFoundException(`Cargo type ${id} not found`);
     return updated;
   }
diff --git a/apps/edr-freight-api/src/modules/rule-engine/services/container-types.service.ts b/apps/edr-freight-api/src/modules/rule-engine/services/container-types.service.ts
index da641afe0..42ce389e1 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/services/container-types.service.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/services/container-types.service.ts
@@ -6,6 +6,7 @@ import { ListContainerTypesQueryDto } from '../dto/list-rule-engine-query.dto';
 import { ReorderItemsDto } from '../dto/reorder-items.dto';
 import { UpdateContainerTypeDto } from '../dto/update-container-type.dto';
 import { ContainerType } from '../entities/container-type.entity';
+import { WagonType } from '../../wagon-types/entities/wagon-type.entity';
 import {
   CONTAINER_TYPES_REPOSITORY,
   IContainerTypesRepository,
@@ -51,7 +52,8 @@ export class ContainerTypesService {
       isReefer: dto.isReefer ?? false,
       isOpenTop: dto.isOpenTop ?? false,
       isActive: dto.isActive ?? true,
-      wagonTypeId: dto.wagonTypeId ?? null,
+      // Join rows are written by the save (RESTRICT FK rejects unknown ids).
+      wagonTypes: (dto.wagonTypeIds ?? []).map((id) => ({ id }) as WagonType),
       displayOrder,
     });
   }
@@ -59,7 +61,13 @@ export class ContainerTypesService {
   /** Update an existing container type. */
   async update(id: string, dto: UpdateContainerTypeDto): Promise<ContainerType> {
     await this.findById(id);
-    const updated = await this.repository.update(id, dto);
+    const { wagonTypeIds, insertAfterId: _insertAfterId, ...columns } = dto;
+    const updated = await this.repository.update(id, {
+      ...columns,
+      ...(wagonTypeIds
+        ? { wagonTypes: wagonTypeIds.map((wagonTypeId) => ({ id: wagonTypeId }) as WagonType) }
+        : {}),
+    });
     if (!updated) throw new NotFoundException(`Container type ${id} not found`);
     return updated;
   }
diff --git a/apps/edr-freight-api/src/modules/train-schedules/entities/schedule-wagon-adjustment-log.entity.ts b/apps/edr-freight-api/src/modules/train-schedules/entities/schedule-wagon-adjustment-log.entity.ts
new file mode 100644
index 000000000..485d29452
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/train-schedules/entities/schedule-wagon-adjustment-log.entity.ts
@@ -0,0 +1,38 @@
+import { BaseEntity } from '@edr/api-common';
+import { Column, Entity, Index } from 'typeorm';
+
+export const WAGON_ADJUSTMENT_ACTIONS = ['ADD', 'REMOVE'] as const;
+export type WagonAdjustmentAction = (typeof WAGON_ADJUSTMENT_ACTIONS)[number];
+
+/**
+ * History row for a consist adjustment made from a schedule: staff coupled a
+ * wagon onto (ADD) or detached one from (REMOVE) the schedule's built train —
+ * e.g. trimming free wagons whose tare pushed gross weight over the
+ * locomotives' pull limit. Plain columns (no FK relations) so the history
+ * survives the wagon or train being deleted later.
+ */
+@Entity({ schema: 'freight', name: 'schedule_wagon_adjustment_logs' })
+@Index(['trainScheduleId'])
+@Index(['trainId'])
+export class ScheduleWagonAdjustmentLog extends BaseEntity {
+  @Column({ name: 'train_schedule_id', type: 'uuid' })
+  trainScheduleId!: string;
+
+  @Column({ name: 'train_id', type: 'uuid' })
+  trainId!: string;
+
+  @Column({ name: 'action', type: 'varchar', length: 10 })
+  action!: WagonAdjustmentAction;
+
+  @Column({ name: 'wagon_id', type: 'uuid' })
+  wagonId!: string;
+
+  @Column({ name: 'wagon_number', type: 'varchar', length: 50 })
+  wagonNumber!: string;
+
+  @Column({ name: 'adjusted_by_user_id', type: 'uuid', nullable: true })
+  adjustedByUserId!: string | null;
+
+  @Column({ name: 'occurred_at', type: 'timestamptz', default: () => 'now()' })
+  occurredAt!: Date;
+}
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 f32f2094e..8e40c0384 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
@@ -29,6 +29,7 @@ export class TrainSchedulesRepository extends BaseRepository<TrainSchedule> {
         trainSet: {
           locomotive: true,
           locomotives: { locomotive: true },
+          train: true,
           wagons: {
             wagonType: true,
             physicalWagon: true,
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 a87b22c3e..c8e254141 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
@@ -886,7 +886,7 @@ describe('BookingBatchService — wagonsFor', () => {
     };
 
     it('charges a bulk booking the tare of ITS wagon type, not the representative', () => {
-      const booking = bulk(2100, { cargoType: { wagonTypeId: 'pw2-id' } });
+      const booking = bulk(2100, { cargoType: { wagonTypes: [{ id: 'pw2-id' }] } });
       const need = service.needFor(booking, dimsWithTypes);
       expect(need.wagons).toBe(30);
       expect(need.weightTons).toBe(2856); // 2100 + 30 × 25.2 — matches allocation
@@ -905,7 +905,7 @@ describe('BookingBatchService — wagonsFor', () => {
           {
             quantity: 2,
             wagonsRequired: 2,
-            containerType: { wagonsPerUnit: 1, sizeFt: 40, wagonTypeId: 'pw2-id' },
+            containerType: { wagonsPerUnit: 1, sizeFt: 40, wagonTypes: [{ id: 'pw2-id' }] },
           },
         ],
       };
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 1c829b4ce..e51d4ad23 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
@@ -208,6 +208,8 @@ export interface BatchBoardScheduleDetail {
   docReviewEndsAt: string | null;
   paymentPhaseEndsAt: string | null;
   bookingCycleNo: number;
+  /** Built train (Train Builder) behind this departure, when scheduled by train. */
+  train: BatchBoardSchedule["train"];
   locomotive: BatchBoardSchedule["locomotive"];
   capacity: BatchBoardSchedule["capacity"];
   counts: BatchBoardSchedule["counts"];
@@ -235,6 +237,12 @@ export interface BatchBoardSchedule {
   docReviewEndsAt: string | null;
   paymentPhaseEndsAt: string | null;
   bookingCycleNo: number;
+  /** Built train (Train Builder) behind this departure, when scheduled by train. */
+  train: {
+    id: string;
+    code: string;
+    trainName: string | null;
+  } | null;
   locomotive: {
     code: string;
     name: string | null;
@@ -877,7 +885,7 @@ export class BookingBatchService implements OnModuleInit {
     const [schedules, total] = await this.trainSchedulesRepository.findAndCount({
       where,
       relations: {
-        trainSet: { locomotive: true },
+        trainSet: { locomotive: true, train: true },
         originStation: true,
         destinationStation: true,
         // Yards supply the route's display name for `routeName` below;
@@ -1128,6 +1136,13 @@ export class BookingBatchService implements OnModuleInit {
         ? s.paymentPhaseEndsAt.toISOString()
         : null,
       bookingCycleNo: s.bookingCycleNo ?? 0,
+      train: s.trainSet?.train
+        ? {
+          id: s.trainSet.train.id,
+          code: s.trainSet.train.code,
+          trainName: s.trainSet.train.trainName ?? null,
+        }
+        : null,
       locomotive: loco
         ? {
           code: loco.code,
@@ -1247,6 +1262,13 @@ export class BookingBatchService implements OnModuleInit {
         ? s.paymentPhaseEndsAt.toISOString()
         : null,
       bookingCycleNo: s.bookingCycleNo ?? 0,
+      train: s.trainSet?.train
+        ? {
+          id: s.trainSet.train.id,
+          code: s.trainSet.train.code,
+          trainName: s.trainSet.train.trainName ?? null,
+        }
+        : null,
       locomotive: loco
         ? {
           code: loco.code,
@@ -2913,21 +2935,23 @@ export class BookingBatchService implements OnModuleInit {
 
   /**
    * Dimensions of the wagon type THIS booking rides: bulk resolves through its
-   * cargo type's wagon_type_id, container through the first container line's
-   * type — the same FK resolution `resolveWagonType` applies when the paid
-   * booking is allocated. Board/fill math measured on a representative wagon
-   * while allocation validated the real one let a selected batch flunk the
-   * post-payment gross-weight check; sharing the resolution closes that gap.
-   * Falls back to the representative dims when the FK or relation is absent.
+   * cargo type's allowed wagon-type list, container through the first container
+   * line's — the same list resolution the scheduling planner applies when the
+   * paid booking is allocated. Board/fill math measured on a representative
+   * wagon while allocation validated the real one let a selected batch flunk
+   * the post-payment gross-weight check; sharing the resolution closes that
+   * gap. Uses the first configured type (the fill engine has no train context);
+   * falls back to the representative dims when the list or relation is absent.
    */
   private dimsFor(booking: Booking, wagonDims: WagonDims): PerWagonDims {
     const fallback =
       booking.freightType === "BULK" ? wagonDims.bulk : wagonDims.container;
     const wagonTypeId =
       booking.freightType === "BULK"
-        ? booking.cargoType?.wagonTypeId
+        ? booking.cargoType?.wagonTypes?.[0]?.id
         : (booking.bookingContainers ?? [])
-            .map((line) => line.containerType?.wagonTypeId)
+            .flatMap((line) => line.containerType?.wagonTypes ?? [])
+            .map((wagonType) => wagonType.id)
             .find((id): id is string => Boolean(id));
     const dims = wagonTypeId ? wagonDims.byWagonTypeId.get(wagonTypeId) : undefined;
     if (!dims) return fallback;
diff --git a/apps/edr-freight-api/src/modules/train-scheduling/dto/adjust-schedule-consist.dto.ts b/apps/edr-freight-api/src/modules/train-scheduling/dto/adjust-schedule-consist.dto.ts
new file mode 100644
index 000000000..e031bf9f0
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/train-scheduling/dto/adjust-schedule-consist.dto.ts
@@ -0,0 +1,26 @@
+import { ApiPropertyOptional } from '@nestjs/swagger';
+import { IsArray, IsOptional, IsUUID } from 'class-validator';
+
+export class AdjustScheduleConsistDto {
+  @ApiPropertyOptional({
+    type: [String],
+    format: 'uuid',
+    description:
+      "AVAILABLE wagons from the train's current yard to couple onto the built train (blocked when they push gross weight or length past the locomotive limits incl. tolerance).",
+  })
+  @IsOptional()
+  @IsArray()
+  @IsUUID('all', { each: true })
+  addWagonIds?: string[];
+
+  @ApiPropertyOptional({
+    type: [String],
+    format: 'uuid',
+    description:
+      'Free (unloaded) wagons to detach permanently from the built train — e.g. trimming tare when gross weight exceeds the pull limit.',
+  })
+  @IsOptional()
+  @IsArray()
+  @IsUUID('all', { each: true })
+  removeWagonIds?: string[];
+}
diff --git a/apps/edr-freight-api/src/modules/train-scheduling/dto/available-trains-query.dto.ts b/apps/edr-freight-api/src/modules/train-scheduling/dto/available-trains-query.dto.ts
new file mode 100644
index 000000000..7ef63e9db
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/train-scheduling/dto/available-trains-query.dto.ts
@@ -0,0 +1,8 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { IsUUID } from 'class-validator';
+
+export class AvailableTrainsQueryDto {
+  @ApiProperty({ format: 'uuid' })
+  @IsUUID()
+  routeId!: string;
+}
diff --git a/apps/edr-freight-api/src/modules/train-scheduling/dto/create-container-train-schedule.dto.ts b/apps/edr-freight-api/src/modules/train-scheduling/dto/create-container-train-schedule.dto.ts
index 60aab2862..5b3e93ba7 100644
--- a/apps/edr-freight-api/src/modules/train-scheduling/dto/create-container-train-schedule.dto.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/dto/create-container-train-schedule.dto.ts
@@ -20,15 +20,26 @@ export class CreateContainerTrainScheduleDto {
   @IsDateString()
   scheduleDate!: string;
 
-  @ApiProperty({
+  @ApiPropertyOptional({
+    format: 'uuid',
+    description:
+      'Built train (Train Builder) to run this departure — its locomotive set is used. Provide either trainId or locomotiveIds.',
+  })
+  @IsOptional()
+  @IsUUID()
+  trainId?: string;
+
+  @ApiPropertyOptional({
     type: [String],
     format: 'uuid',
-    description: 'Locomotives pulling the train (minimum 2 — front and back)',
+    description:
+      'Hand-picked locomotives pulling the train (minimum 2 — front and back). Ignored when trainId is provided.',
   })
+  @IsOptional()
   @IsArray()
   @ArrayMinSize(2, { message: 'A train must be pulled by at least two locomotives' })
   @IsUUID('all', { each: true })
-  locomotiveIds!: string[];
+  locomotiveIds?: string[];
 
   @ApiPropertyOptional({ description: 'Maximum total booking weight allowed on this train' })
   @IsOptional()
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 4196e0972..c6e22589f 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
@@ -39,6 +39,8 @@ import {
   UploadImportDjiboutiDocumentDto,
 } from "./dto/import-djibouti-operation.dto";
 import { AvailableLocomotivesQueryDto } from "./dto/available-locomotives-query.dto";
+import { AdjustScheduleConsistDto } from "./dto/adjust-schedule-consist.dto";
+import { AvailableTrainsQueryDto } from "./dto/available-trains-query.dto";
 import { BatchBoardQueryDto } from "./dto/batch-board-query.dto";
 import { BookableSchedulesQueryDto } from "./dto/bookable-schedules-query.dto";
 import { ListTrainSchedulesQueryDto } from "./dto/list-train-schedules-query.dto";
@@ -153,6 +155,46 @@ export class TrainSchedulingController {
     );
   }
 
+  @Get("available-trains")
+  @TrainSchedulingView()
+  @ApiOperation({
+    summary:
+      "List built trains (Train Builder) schedulable on a route, annotated with yard position and future runs",
+  })
+  getAvailableTrains(@Query() query: AvailableTrainsQueryDto) {
+    return this.trainSchedulingService.getAvailableTrainsForRoute(
+      query.routeId,
+    );
+  }
+
+  @Get("schedules/:id/consist")
+  @TrainSchedulingView()
+  @ApiOperation({
+    summary:
+      "Built-train consist snapshot for a schedule: gross weight/length vs locomotive limits (incl. tolerance), trimmable + addable wagons, adjustment history",
+  })
+  getScheduleConsist(@Param("id", ParseUUIDPipe) id: string) {
+    return this.trainSchedulingService.getScheduleConsist(id);
+  }
+
+  @Post("schedules/:id/adjust-consist")
+  @TrainSchedulingManage()
+  @ApiOperation({
+    summary:
+      "Permanently trim free wagons off / couple yard wagons onto the schedule's built train (weight & length limits incl. tolerance enforced, every change logged)",
+  })
+  adjustScheduleConsist(
+    @Param("id", ParseUUIDPipe) id: string,
+    @Body() dto: AdjustScheduleConsistDto,
+    @CurrentUser() user: AuthUserPayload,
+  ) {
+    return this.trainSchedulingService.adjustScheduleConsist(
+      id,
+      dto,
+      resolveAuthUserId(user),
+    );
+  }
+
   @Get("bookable-schedules")
   // No staff guard: customers hit this while creating a booking to find OPEN
   // same-route schedules. Do not attach train_scheduling permissions here.
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 e97b3de56..c4f2e7d6d 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
@@ -72,7 +72,7 @@ const makeBooking = (
       wagonsRequired,
       vgmPerUnitTons: weight / quantity,
       isOverweight: false,
-      containerType: { code: containerCode, label: containerCode, wagonTypeId: nw5.id },
+      containerType: { id: 'ct-1', code: containerCode, label: containerCode, wagonTypes: [nw5] },
     },
   ],
   ...extra,
@@ -80,7 +80,7 @@ const makeBooking = (
 
 describe('TrainSchedulingService', () => {
   let service: TrainSchedulingService;
-  let dataSource: { getRepository: jest.Mock; transaction: jest.Mock };
+  let dataSource: { getRepository: jest.Mock; transaction: jest.Mock; query: jest.Mock };
   let bookingsRepository: Record<string, jest.Mock>;
   let locomotivesRepository: { findById: jest.Mock; findAll: jest.Mock };
   let wagonTypesRepository: { findAll: jest.Mock };
@@ -91,7 +91,12 @@ describe('TrainSchedulingService', () => {
   let wagonAllocationBulkLoadsRepository: Record<string, jest.Mock>;
 
   beforeEach(() => {
-    dataSource = { getRepository: jest.fn(), transaction: jest.fn() };
+    dataSource = {
+      getRepository: jest.fn(),
+      transaction: jest.fn(),
+      // Raw-SQL helper lookups (e.g. builtTrainIdOfSchedule) default to "no rows".
+      query: jest.fn().mockResolvedValue([]),
+    };
     bookingsRepository = {
       findEligibleForScheduling: jest.fn(),
       findByIdsForScheduling: jest.fn(),
@@ -259,8 +264,10 @@ describe('TrainSchedulingService', () => {
 
     expect(result.valid).toBe(true);
     expect(result.violations).toEqual([]);
-    expect(result.summary.wagonsNeeded).toBe(45);
-    expect(result.wagonPlan).toHaveLength(45);
+    // TEU packing: 20 + 15 wagons of 40ft plus 10×20ft at two per wagon (5) —
+    // the planner packs by container size, not the stored per-line fallback.
+    expect(result.summary.wagonsNeeded).toBe(40);
+    expect(result.wagonPlan).toHaveLength(40);
   });
 
   it('returns soft hold warnings without forceAssign', async () => {
@@ -293,7 +300,7 @@ describe('TrainSchedulingService', () => {
             wagonsRequired: 80,
             vgmPerUnitTons: 45,
             isOverweight: true,
-            containerType: { code: '40FT', label: '40FT', wagonTypeId: nw5.id },
+            containerType: { id: 'ct-1', code: '40FT', label: '40FT', wagonTypes: [nw5] },
           },
         ],
       }),
@@ -655,10 +662,12 @@ describe('TrainSchedulingService', () => {
       destinationStationId: 'yard-djibouti',
     });
 
-    expect(result.valid).toBe(false);
-    expect(
-      result.violations.some((v) => v.includes('available at yard') && v.includes('NW5')),
-    ).toBe(true);
+    // List-based planner: a booking with no plannable wagon at the yard is
+    // DEFERRED with the wagon-type reason (assign still hard-fails when no
+    // booking fits), instead of surfacing a phantom-slot violation.
+    expect(result.valid).toBe(true);
+    expect(result.wagonPlan).toHaveLength(0);
+    expect(result.deferredBookings.some((d) => d.reason.includes('NW5'))).toBe(true);
   });
 
   it('assignBookingsToSchedule rejects when physical wagons cannot be pinned', async () => {
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 9e82bca33..04583c777 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
@@ -1,5 +1,6 @@
 import {
   AllocationLoadType,
+  Freight,
   LoadingStatus,
   SchedulingStatus,
   TrainCheckpointKind,
@@ -24,6 +25,7 @@ import {
   FindOptionsWhere,
   ILike,
   In,
+  IsNull,
   Not,
   QueryFailedError,
   Raw,
@@ -43,9 +45,11 @@ 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 { Train } from '../trains/entities/train.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';
+import { ScheduleWagonAdjustmentLog } from '../train-schedules/entities/schedule-wagon-adjustment-log.entity';
 import { TrainScheduleBooking } from '../train-schedules/entities/train-schedule-booking.entity';
 import { TrainSchedule } from '../train-schedules/entities/train-schedule.entity';
 import { WagonAllocationContainerItem } from '../train-schedules/entities/wagon-allocation-container-item.entity';
@@ -59,6 +63,7 @@ import { WagonBookingAllocationsRepository } from '../train-schedules/wagon-book
 import { WagonType } from '../wagon-types/entities/wagon-type.entity';
 import { WagonTypesRepository } from '../wagon-types/wagon-types.repository';
 import { Wagon } from '../wagons/entities/wagon.entity';
+import { AdjustScheduleConsistDto } from './dto/adjust-schedule-consist.dto';
 import { AssignBookingsDto } from './dto/assign-bookings.dto';
 import { CreateContainerTrainScheduleDto } from './dto/create-container-train-schedule.dto';
 import { GetEligibleBookingsDto } from './dto/get-eligible-bookings.dto';
@@ -90,9 +95,7 @@ import { type BookingWindowConfig } from './booking-window.config';
 import { BookingWindowGateway } from './booking-window.gateway';
 import { BookingNotifierService } from './booking-notifier.service';
 import {
-  buildCappedWagonPlan,
   computeFleetAvailability,
-  selectBookingsWithinFleetCap,
   summarizeFleetWarnings,
   totalAssignedWeight,
   wagonsRequiredForBooking,
@@ -100,9 +103,12 @@ import {
   type FleetAvailabilityRow,
 } from './fleet-plan.util';
 import {
-  buildBulkWagonPlan,
-  buildContainerWagonPlan,
-  buildMixedWagonPlan,
+  planWagonsWithStock,
+  unboundedStock,
+  type AllowedWagonTypeMap,
+  type WagonStock,
+} from './wagon-plan-flex.util';
+import {
   expandBookingContainerUnits,
   getContainerSlotSequenceNos,
   roundTons,
@@ -110,7 +116,6 @@ import {
   type TrainLimitConfig,
   validateContainerPlacements,
   validateMixedTrainLimits,
-  validateTrainLimits,
   type ContainerPlacementInput,
   type WagonPlanSlot,
 } from './wagon-plan.util';
@@ -280,6 +285,8 @@ interface BookingWindowRow {
   origin_code: string | null;
   destination_label: string | null;
   destination_code: string | null;
+  /** Full ordered corridor (origin → milestones → destination) from the schedule's route. */
+  route_stations: string[] | null;
 }
 
 @Injectable()
@@ -291,7 +298,9 @@ export class TrainSchedulingService {
     private readonly dataSource: DataSource,
     private readonly bookingsRepository: BookingsRepository,
     private readonly locomotivesRepository: LocomotivesRepository,
-    private readonly wagonTypesRepository: WagonTypesRepository,
+    // Kept in the DI signature for constructor-arity stability (specs mock it);
+    // wagon-type resolution now flows through the config lists on the bookings.
+    _wagonTypesRepository: WagonTypesRepository,
     private readonly trainSchedulesRepository: TrainSchedulesRepository,
     private readonly trainScheduleBookingsRepository: TrainScheduleBookingsRepository,
     private readonly wagonBookingAllocationsRepository: WagonBookingAllocationsRepository,
@@ -980,12 +989,52 @@ export class TrainSchedulingService {
   async createContainerTrainSchedule(dto: CreateContainerTrainScheduleDto) {
     const route = await this.getSchedulableRoute(dto.routeId);
 
-    const locomotiveIds = [...new Set(dto.locomotiveIds)];
-    if (locomotiveIds.length < 2) {
-      throw new BadRequestException('A train must be pulled by at least two locomotives');
+    const scheduleWarnings: string[] = [];
+
+    // The pulling set comes either from a built train (Train Builder) or from
+    // hand-picked locomotive ids (legacy path). A built train also links the
+    // schedule's train set back to it (`train_sets.train_id`) so its lifecycle
+    // and yard follow the schedule.
+    let builtTrain: Train | null = null;
+    let locomotiveIds: string[];
+    if (dto.trainId) {
+      builtTrain = await this.dataSource.getRepository(Train).findOne({
+        where: { id: dto.trainId },
+        relations: { locomotives: true },
+        order: { locomotives: { sequenceNo: 'ASC' } },
+      });
+      if (!builtTrain) {
+        throw new NotFoundException(`Train ${dto.trainId} not found`);
+      }
+      if (
+        builtTrain.status === Freight.TrainStatus.OutOfService ||
+        builtTrain.status === Freight.TrainStatus.UnderMaintenance
+      ) {
+        throw new ConflictException(
+          `Train ${builtTrain.code} is ${builtTrain.status.toLowerCase().replace(/_/g, ' ')}`,
+        );
+      }
+      locomotiveIds = (builtTrain.locomotives ?? [])
+        .slice()
+        .sort((a, b) => a.sequenceNo - b.sequenceNo)
+        .map((link) => link.locomotiveId);
+      if (locomotiveIds.length < 2) {
+        throw new BadRequestException(
+          `Train ${builtTrain.code} has fewer than two locomotives; rebuild it before scheduling`,
+        );
+      }
+      if (builtTrain.currentYardId !== route.originYardId) {
+        scheduleWarnings.push(
+          `Train ${builtTrain.code} is not at the origin yard yet; it must arrive before this departure dispatches`,
+        );
+      }
+    } else {
+      locomotiveIds = [...new Set(dto.locomotiveIds ?? [])];
+      if (locomotiveIds.length < 2) {
+        throw new BadRequestException('A train must be pulled by at least two locomotives');
+      }
     }
 
-    const scheduleWarnings: string[] = [];
     const createdScheduleId = await this.dataSource.transaction(async (manager) => {
       // Lock every locomotive. Advance scheduling is allowed: a locomotive may sit on
       // multiple future schedules and does not need to be at the origin yard yet — staff
@@ -1020,7 +1069,11 @@ export class TrainSchedulingService {
       // getSchedulableRoute already rejected DOMESTIC (intercity).
       const direction = this.resolveRouteDirection(route);
 
-      const trainSet = await this.buildEmptyTrainSet(manager, lockedLocomotives);
+      const trainSet = await this.buildEmptyTrainSet(
+        manager,
+        lockedLocomotives,
+        builtTrain?.id ?? null,
+      );
       // Effective capacity is capped by the weakest locomotive in the set.
       const limitLoco = minLocomotiveLimits(lockedLocomotives) ?? undefined;
       const departure = new Date(dto.scheduleDate);
@@ -1089,8 +1142,16 @@ export class TrainSchedulingService {
           ? this.groupWindowFieldsFrom(groupAnchor, departure)
           : computedTimes),
       };
-      const maxWagons = (await this.resolveTrainLimitConfig(dto, limitLoco))
-        .maxWagonsPerTrain;
+      // A built train's own consist is the schedule's capacity: full when all
+      // its wagons are allocated. Trains built without wagons yet fall back to
+      // the configured limit.
+      const builtTrainWagonCount = builtTrain
+        ? await manager.getRepository(Wagon).count({ where: { trainId: builtTrain.id } })
+        : 0;
+      const maxWagons =
+        builtTrainWagonCount > 0
+          ? builtTrainWagonCount
+          : (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) =>
@@ -1109,6 +1170,9 @@ export class TrainSchedulingService {
       );
       // Locomotives stay in their current status until dispatch — advance scheduling
       // must not block the locomotive from serving earlier trains.
+      if (builtTrain) {
+        await this.syncBuiltTrainAfterScheduleChange(manager, builtTrain.id);
+      }
       return saved.id;
     });
 
@@ -1255,7 +1319,7 @@ export class TrainSchedulingService {
       });
     }
 
-    const { bookings, wagonType, wagonPlan, warnings, deferredBookings } = validation;
+    const { bookings, wagonPlan, warnings, deferredBookings } = validation;
     const totalWeightTons = validation.summary.totalWeightTons;
     const totalLengthMeters = validation.summary.totalLengthMeters;
 
@@ -1270,9 +1334,29 @@ export class TrainSchedulingService {
       limitLoco.maxPullWeightTons + (Number(limitLoco.overageToleranceTons) || 0);
     const lengthCapWithOverage =
       limitLoco.maxTrainLengthMeters + (Number(limitLoco.overageToleranceMeters) || 0);
-    if (!dto.forceAssign && weightCapWithOverage < totalWeightTons) {
+    // The locomotives pull GROSS weight: the customers' cargo plus wagon tare.
+    // A built train hauls EVERY coupled wagon's tare — empty ones included —
+    // so train-bound schedules count the full consist, not just planned slots.
+    const consistWagons = schedule.trainSet?.trainId
+      ? await this.dataSource.getRepository(Wagon).find({
+          where: { trainId: schedule.trainSet.trainId },
+          relations: { wagonType: true },
+        })
+      : null;
+    const planTareTons = consistWagons
+      ? roundTons(
+          consistWagons.reduce(
+            (sum, wagon) => sum + Number(wagon.wagonType?.tareWeightTons ?? 0),
+            0,
+          ),
+        )
+      : roundTons(
+          wagonPlan.reduce((sum, slot) => sum + Number(slot.tareWeightTons ?? 0), 0),
+        );
+    const grossWeightTons = roundTons(totalWeightTons + planTareTons);
+    if (!dto.forceAssign && weightCapWithOverage < grossWeightTons) {
       throw new BadRequestException(
-        `Train set locomotives cannot pull ${totalWeightTons}T`,
+        `Train set locomotives cannot pull ${grossWeightTons}T gross (${totalWeightTons}T cargo + ${planTareTons}T wagon tare)`,
       );
     }
     if (!dto.forceAssign && lengthCapWithOverage < totalLengthMeters) {
@@ -1313,7 +1397,6 @@ export class TrainSchedulingService {
       const savedWagons = await this.persistTrainSetWagons(
         manager,
         trainSetId,
-        wagonType,
         wagonPlan,
       );
 
@@ -1782,6 +1865,10 @@ export class TrainSchedulingService {
       if (schedule.trainSetId) {
         await manager.getRepository(TrainSet).update(schedule.trainSetId, { status: 'DISPATCHED' });
       }
+      // A built train follows its schedule out: IN_SERVICE until arrival.
+      if (schedule.trainSet?.trainId) {
+        await this.syncBuiltTrainAfterScheduleChange(manager, schedule.trainSet.trainId);
+      }
       // The train is out — every pinned wagon is ASSIGNED to this schedule and
       // stays pinned so no other schedule can pick it while it's rolling.
       const dispatchedPhysicalIds = (schedule.trainSet?.wagons ?? [])
@@ -2862,6 +2949,15 @@ export class TrainSchedulingService {
           status: 'COMPLETED',
         });
       }
+      // A built train arrives with its schedule: settle it at the destination
+      // yard and re-derive its status (AVAILABLE, or SCHEDULED if more runs wait).
+      if (schedule.trainSet?.trainId) {
+        await this.syncBuiltTrainAfterScheduleChange(
+          manager,
+          schedule.trainSet.trainId,
+          schedule.destinationStationId,
+        );
+      }
 
       // Per-booking journey: bookings destined for the FINAL yard that the
       // operator didn't unload individually get their arrival stamped now as a
@@ -2894,7 +2990,9 @@ export class TrainSchedulingService {
         await manager.getRepository(Wagon).update(wagon.id, {
           currentTrainScheduleId: null,
           trainSetWagonId: null,
-          status: WagonStatus.Available,
+          // A wagon that belongs to a built train stays coupled to it (ASSIGNED);
+          // only loose wagons return to the open AVAILABLE pool.
+          status: wagon.trainId ? WagonStatus.Assigned : WagonStatus.Available,
           currentYardId: settleYardId,
         });
         // Ledger: the wagon rode this schedule to its settle yard.
@@ -2987,7 +3085,7 @@ export class TrainSchedulingService {
     const [schedules, total] = await this.trainSchedulesRepository.findAndCount({
       where,
       relations: {
-        trainSet: { locomotive: true, locomotives: { locomotive: true } },
+        trainSet: { locomotive: true, locomotives: { locomotive: true }, train: true },
         // Yards carry the route's display name used by mapScheduleListItem;
         // milestones (with yards) let it show the full corridor path.
         route: { originYard: true, destinationYard: true, milestones: { yard: true } },
@@ -3038,6 +3136,11 @@ export class TrainSchedulingService {
       if (schedule.trainSetId) {
         await manager.getRepository(TrainSet).update(schedule.trainSetId, { status: 'CANCELLED' });
       }
+      // Cancelled run: the built train never left — re-derive its status
+      // (back to AVAILABLE unless other runs still reference it).
+      if (schedule.trainSet?.trainId) {
+        await this.syncBuiltTrainAfterScheduleChange(manager, schedule.trainSet.trainId);
+      }
       // Locomotives are only ASSIGNED while out on a dispatched train. Release ours,
       // but never stomp a locomotive that is currently pulling another dispatched train.
       const cancelledLocoIds = this.locomotivesOfTrainSet(schedule.trainSet).map((l) => l.id);
@@ -3059,7 +3162,11 @@ export class TrainSchedulingService {
           await manager.getRepository(Wagon).update(wagon.physicalWagonId, {
             currentTrainScheduleId: null,
             trainSetWagonId: null,
-            status: WagonStatus.Available,
+            // Built-train wagons stay coupled to their train (ASSIGNED); loose
+            // wagons return to the open AVAILABLE pool.
+            status: wagon.physicalWagon?.trainId
+              ? WagonStatus.Assigned
+              : WagonStatus.Available,
             // A cancelled train never left — its wagons stay/return at the origin
             // yard, free to be re-pinned onto another schedule from there.
             currentYardId: schedule.originStationId,
@@ -3194,92 +3301,65 @@ export class TrainSchedulingService {
       }
     }
 
-    let wagonType: WagonType;
-    let containerWagonType: WagonType;
-    let bulkWagonType: WagonType;
-    let demandPlan: WagonPlanSlot[];
-    let fittingBookings = bookings;
-    let deferredBookings: DeferredBookingRow[] = [];
-    let fleetAvailability: FleetAvailabilityRow[] = [];
+    // Wagon-type resolution is list-based: each container/cargo type carries
+    // the wagon types that can haul it, and the plan mixes wagon types within
+    // one consist. A schedule created from a built train (Train Builder) plans
+    // against ONLY that train's own wagons — full when every consist wagon is
+    // allocated; legacy schedules plan against the boarding yards' pool.
+    const allowed = await this.loadAllowedWagonTypes(bookings);
+    const builtTrainId = await this.builtTrainIdOfSchedule(targetScheduleId);
 
-    if (resolvedMode === 'MIXED') {
-      const containerBookings = bookings.filter((b) => b.freightType === 'CONTAINER');
-      const bulkBookings = bookings.filter((b) => b.freightType === 'BULK');
-      containerWagonType = await this.resolveWagonType('CONTAINER', bookingIds);
-      bulkWagonType = await this.resolveWagonType('BULK', bookingIds);
-      wagonType = containerWagonType;
-      demandPlan = buildMixedWagonPlan(
-        containerBookings,
-        bulkBookings,
-        containerWagonType,
-        bulkWagonType,
-      );
-    } else {
-      wagonType = await this.resolveWagonType(resolvedMode, bookingIds);
-      containerWagonType = wagonType;
-      bulkWagonType = wagonType;
-      demandPlan =
-        resolvedMode === 'CONTAINER'
-          ? buildContainerWagonPlan(bookings, wagonType)
-          : buildBulkWagonPlan(bookings, wagonType);
-    }
+    // Pure demand (unbounded stock) drives the availability report rows.
+    const demandPlan = planWagonsWithStock({
+      bookings,
+      allowed,
+      stock: unboundedStock(allowed),
+    }).plan;
 
     const originYardId = dto.originStationId;
-    // 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);
+    let stock: WagonStock;
+    if (builtTrainId) {
+      stock = await this.builtTrainStock(builtTrainId);
+    } else {
+      // 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 remainingByTypeId = new Map<string, number>();
+      const codesByTypeId = new Map<string, string>();
+      for (const rows of fleetCountsByYard) {
+        for (const row of rows) {
+          remainingByTypeId.set(
+            row.wagonTypeId,
+            (remainingByTypeId.get(row.wagonTypeId) ?? 0) + row.available,
+          );
+          codesByTypeId.set(row.wagonTypeId, row.wagonTypeCode);
+        }
       }
+      stock = { mode: 'YARD', remainingByTypeId, codesByTypeId };
     }
-    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(
+
+    const planned = planWagonsWithStock({ bookings, allowed, stock });
+    violations.push(...planned.configIssues);
+    const fittingBookings = planned.fitting;
+    const deferredBookings: DeferredBookingRow[] = planned.deferred;
+    const wagonPlan = planned.plan;
+
+    const fleetAvailability: FleetAvailabilityRow[] = computeFleetAvailability(
       demandPlan,
-      fleetByTypeId,
-      new Map(fleetCounts.map((row) => [row.wagonTypeId, row.wagonTypeCode])),
+      stock.remainingByTypeId,
+      stock.codesByTypeId,
     );
-
-    const selection = selectBookingsWithinFleetCap(
-      bookings,
-      fleetByTypeId,
-      (booking) =>
-        booking.freightType === 'BULK' ? bulkWagonType.id : containerWagonType.id,
-      Number(bulkWagonType.capacityTons),
-    );
-    fittingBookings = selection.fitting;
-    deferredBookings = selection.deferred;
     warnings.push(...summarizeFleetWarnings(fleetAvailability, deferredBookings));
-
-    const wagonPlan = buildCappedWagonPlan({
-      bookings: fittingBookings,
-      resolvedMode,
-      containerWagonType,
-      bulkWagonType,
-    });
     this.stampSlotLegs(
       wagonPlan,
       fittingBookings,
@@ -3307,40 +3387,34 @@ export class TrainSchedulingService {
     const pushLimit = (issues: string[]) =>
       forceAssign ? warnings.push(...issues) : violations.push(...issues);
 
-    if (resolvedMode === 'MIXED') {
-      pushLimit(
-        validateMixedTrainLimits(wagonPlan, [containerWagonType, bulkWagonType], trainLimits),
+    // The plan can mix wagon types, so limit math always runs against the
+    // distinct types actually planned (shortest length drives the wagon-count
+    // fallback — validateMixedTrainLimits generalizes the single-type check).
+    const plannedWagonTypes = [
+      ...new Map(
+        wagonPlan.map((slot) => [slot.wagonTypeId, { lengthMeters: slot.lengthMeters }]),
+      ).values(),
+    ];
+    pushLimit(
+      validateMixedTrainLimits(
+        wagonPlan,
+        plannedWagonTypes.length ? plannedWagonTypes : [{ lengthMeters: 14 }],
+        trainLimits,
+      ),
+    );
+    if (requireContainerPlacements && resolvedMode !== 'BULK') {
+      const containerBookings = fittingBookings.filter((b) => b.freightType === 'CONTAINER');
+      violations.push(
+        ...validateContainerPlacements(
+          containerBookings,
+          wagonPlan,
+          containerPlacements,
+          placementRules,
+        ),
+      );
+      violations.push(
+        ...(await this.validateFleetContainers(containerPlacements, containerBookings)),
       );
-      if (requireContainerPlacements) {
-        const containerBookings = fittingBookings.filter((b) => b.freightType === 'CONTAINER');
-        violations.push(
-          ...validateContainerPlacements(
-            containerBookings,
-            wagonPlan,
-            containerPlacements,
-            placementRules,
-          ),
-        );
-        violations.push(
-          ...(await this.validateFleetContainers(containerPlacements, containerBookings)),
-        );
-      }
-    } else {
-      pushLimit(validateTrainLimits(wagonPlan, wagonType, trainLimits));
-
-      if (requireContainerPlacements && resolvedMode === 'CONTAINER') {
-        violations.push(
-          ...validateContainerPlacements(
-            fittingBookings,
-            wagonPlan,
-            containerPlacements,
-            placementRules,
-          ),
-        );
-        violations.push(
-          ...(await this.validateFleetContainers(containerPlacements, fittingBookings)),
-        );
-      }
     }
 
     const totalWeightTons = totalAssignedWeight(fittingBookings);
@@ -3405,20 +3479,21 @@ export class TrainSchedulingService {
       }
     }
 
+    const plannedTypeCodes = [...new Set(wagonPlan.map((slot) => slot.wagonTypeCode))];
+
     return {
       valid: violations.length === 0,
       violations,
       warnings,
       bookings: fittingBookings,
-      wagonType,
       wagonPlan,
       fleetAvailability,
       deferredBookings,
       summary: {
         totalBookings: fittingBookings.length,
         totalWeightTons,
-        wagonType:
-          resolvedMode === 'MIXED' ? 'MIXED' : wagonType.code,
+        // Human-readable wagon type(s) of the plan — mixed consists list all.
+        wagonType: plannedTypeCodes.join('/') || 'NONE',
         wagonsNeeded: wagonPlan.length,
         totalLengthMeters,
         freightMode: resolvedMode,
@@ -3576,23 +3651,51 @@ export class TrainSchedulingService {
     ];
   }
 
+  /**
+   * Built train (Train Builder) behind a schedule's train set, if the schedule
+   * was created by picking a train instead of loose locomotives.
+   */
+  private async builtTrainIdOfSchedule(
+    scheduleId: string | undefined,
+    manager?: EntityManager,
+  ): Promise<string | null> {
+    if (!scheduleId) return null;
+    const runner = manager ?? this.dataSource;
+    const rows: { train_id: string | null }[] = await runner.query(
+      `SELECT tset.train_id
+         FROM freight.train_schedules ts
+         JOIN freight.train_sets tset ON tset.id = ts.train_set_id
+        WHERE ts.id = $1`,
+      [scheduleId],
+    );
+    return rows[0]?.train_id ?? null;
+  }
+
   private async countFleetAvailability(
     originYardId: string,
     targetScheduleId?: string,
   ): Promise<Array<{ wagonTypeId: string; wagonTypeCode: string; available: number }>> {
-    const [wagons, wagonTypes] = await Promise.all([
+    const [wagons, wagonTypes, builtTrainId] = await Promise.all([
       this.dataSource.getRepository(Wagon).find(),
       this.dataSource.getRepository(WagonType).find(),
+      this.builtTrainIdOfSchedule(targetScheduleId),
     ]);
     const typeCodeById = new Map(wagonTypes.map((type) => [type.id, type.code]));
     const counts = new Map<string, { code: string; available: number }>();
 
     for (const wagon of wagons) {
-      const pinnedOnTarget = targetScheduleId
-        ? wagon.currentTrainScheduleId === targetScheduleId
-        : false;
-      if (wagon.status !== WagonStatus.Available && !pinnedOnTarget) continue;
-      if (wagon.currentYardId !== originYardId) continue;
+      // Train-bound schedule: the built train's own consist IS the fleet — only
+      // its wagons count (wherever they currently sit; they travel with the
+      // train), and loose yard wagons never do.
+      if (builtTrainId) {
+        if (wagon.trainId !== builtTrainId) continue;
+      } else {
+        const pinnedOnTarget = targetScheduleId
+          ? wagon.currentTrainScheduleId === targetScheduleId
+          : false;
+        if (wagon.status !== WagonStatus.Available && !pinnedOnTarget) continue;
+        if (wagon.currentYardId !== originYardId) continue;
+      }
 
       const typeId = wagon.wagonTypeId;
       const code = typeCodeById.get(typeId) ?? typeId;
@@ -3651,10 +3754,16 @@ export class TrainSchedulingService {
 
   private async releasePinnedWagonsForTrainSet(manager: EntityManager, trainSetId: string) {
     const slots = await manager.getRepository(TrainSetWagon).find({ where: { trainSetId } });
-    for (const slot of slots) {
-      if (!slot.physicalWagonId) continue;
-      await manager.getRepository(Wagon).update(slot.physicalWagonId, {
-        status: WagonStatus.Available,
+    const physicalIds = slots
+      .map((slot) => slot.physicalWagonId)
+      .filter((id): id is string => Boolean(id));
+    if (!physicalIds.length) return;
+    const wagons = await manager.getRepository(Wagon).find({ where: { id: In(physicalIds) } });
+    for (const wagon of wagons) {
+      await manager.getRepository(Wagon).update(wagon.id, {
+        // Built-train wagons stay coupled to their train (ASSIGNED); loose
+        // wagons return to the open AVAILABLE pool.
+        status: wagon.trainId ? WagonStatus.Assigned : WagonStatus.Available,
         trainSetWagonId: null,
         currentTrainScheduleId: null,
       });
@@ -3669,6 +3778,7 @@ export class TrainSchedulingService {
   ) {
     const wagons = await manager.getRepository(Wagon).find();
     const wagonTypes = await manager.getRepository(WagonType).find();
+    const builtTrainId = await this.builtTrainIdOfSchedule(scheduleId, manager);
     const typeCodeById = new Map(wagonTypes.map((wt) => [wt.id, wt.code]));
 
     const planSlots = [...slots]
@@ -3686,6 +3796,7 @@ export class TrainSchedulingService {
       wagons,
       scheduleId,
       originYardId,
+      builtTrainId,
     );
     if (unpinnable.length) {
       throw new BadRequestException({
@@ -3702,6 +3813,7 @@ export class TrainSchedulingService {
         scheduleId,
         originYardId,
         assignedPhysicalIds,
+        builtTrainId,
       );
       if (!physical) continue;
 
@@ -3726,7 +3838,10 @@ export class TrainSchedulingService {
   ): Promise<string[]> {
     if (!wagonPlan.length) return [];
 
-    const wagons = await this.dataSource.getRepository(Wagon).find();
+    const [wagons, builtTrainId] = await Promise.all([
+      this.dataSource.getRepository(Wagon).find(),
+      this.builtTrainIdOfSchedule(targetScheduleId),
+    ]);
     return this.findUnpinnableWagonSlots(
       wagonPlan.map((slot) => ({
         sequenceNo: slot.sequenceNo,
@@ -3737,6 +3852,7 @@ export class TrainSchedulingService {
       wagons,
       targetScheduleId,
       originYardId,
+      builtTrainId,
     );
   }
 
@@ -3750,6 +3866,7 @@ export class TrainSchedulingService {
     wagons: Wagon[],
     scheduleId: string | undefined,
     originYardId: string,
+    builtTrainId: string | null = null,
   ): string[] {
     const violations: string[] = [];
     const assignedPhysicalIds = new Set<string>();
@@ -3761,6 +3878,7 @@ export class TrainSchedulingService {
         scheduleId,
         originYardId,
         assignedPhysicalIds,
+        builtTrainId,
       );
       if (!physical) {
         violations.push(
@@ -3785,6 +3903,7 @@ export class TrainSchedulingService {
     scheduleId: string | undefined,
     originYardId: string,
     assignedPhysicalIds: Set<string>,
+    builtTrainId: string | null = null,
   ): Wagon | undefined {
     const usable = (wagon: Wagon): boolean => {
       if (wagon.wagonTypeId !== slot.wagonTypeId) return false;
@@ -3794,6 +3913,17 @@ export class TrainSchedulingService {
         : false;
       return wagon.status === WagonStatus.Available || pinnedOnSchedule;
     };
+    // Train-bound schedule: ONLY the built train's own wagons may be pinned —
+    // wherever they currently sit (they travel with the train), never a loose
+    // yard wagon.
+    if (builtTrainId) {
+      return wagons.find(
+        (w) =>
+          w.trainId === builtTrainId &&
+          w.wagonTypeId === slot.wagonTypeId &&
+          !assignedPhysicalIds.has(w.id),
+      );
+    }
     // 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) {
@@ -3866,61 +3996,54 @@ export class TrainSchedulingService {
    * when the relevant type has no wagon type configured — scheduling is blocked
    * until an admin assigns one on the cargo-type / container-type config screen.
    */
-  private async resolveWagonType(
-    freightType: 'CONTAINER' | 'BULK',
-    bookingIds: string[],
-  ): Promise<WagonType> {
-    const bookings = await this.bookingsRepository.findByIdsForScheduling(bookingIds);
+  /**
+   * Wagon types allowed to carry each container/cargo type on these bookings.
+   * The many-to-many configuration lists (active wagon types only), keyed by
+   * type id — the flexible planner mixes wagon types within one consist.
+   * Bookings must arrive from findByIdsForScheduling so the `wagonTypes`
+   * relations are loaded.
+   */
+  private loadAllowedWagonTypes(bookings: Booking[]): AllowedWagonTypeMap {
+    const byContainerTypeId = new Map<string, WagonType[]>();
+    const byCargoTypeId = new Map<string, WagonType[]>();
+    const active = (list?: WagonType[] | null) =>
+      (list ?? []).filter((wt) => wt.isActive !== false);
 
-    if (freightType === 'CONTAINER') {
-      // First container type present on the batch drives the container wagon
-      // type (matches the prior single-wagon-type-per-consist behavior).
-      const containerType = bookings
-        .flatMap((b) => b.bookingContainers ?? [])
-        .map((line) => line.containerType)
-        .find((ct): ct is NonNullable<typeof ct> => Boolean(ct));
-      if (!containerType) {
-        throw new BadRequestException('No container type found on the container booking(s)');
+    for (const booking of bookings) {
+      for (const line of booking.bookingContainers ?? []) {
+        const containerType = line.containerType;
+        if (containerType && !byContainerTypeId.has(containerType.id)) {
+          byContainerTypeId.set(containerType.id, active(containerType.wagonTypes));
+        }
+      }
+      const cargoType = booking.cargoType;
+      if (cargoType && !byCargoTypeId.has(cargoType.id)) {
+        byCargoTypeId.set(cargoType.id, active(cargoType.wagonTypes));
       }
-      const wagonType = await this.loadWagonTypeForType(
-        containerType.wagonTypeId ?? null,
-        `Container type "${containerType.label ?? containerType.code}"`,
-      );
-      return wagonType;
     }
-
-    const cargoType = bookings.map((b) => b.cargoType).find((ct) => Boolean(ct));
-    if (!cargoType) {
-      throw new BadRequestException('No cargo type found on the bulk booking(s)');
-    }
-    return this.loadWagonTypeForType(
-      cargoType.wagonTypeId ?? null,
-      `Cargo type "${cargoType.cargoTypeName ?? cargoType.code}"`,
-    );
+    return { byContainerTypeId, byCargoTypeId };
   }
 
   /**
-   * Load an active wagon type by FK id, throwing a clear error when the id is
-   * unset (type not configured) or points at a missing/inactive wagon type.
+   * TRAIN-mode wagon stock: the built train's own consist, grouped by wagon
+   * type. This is the whole plannable pool for its schedules — the plan is
+   * full when every consist wagon is allocated.
    */
-  private async loadWagonTypeForType(
-    wagonTypeId: string | null,
-    typeLabel: string,
-  ): Promise<WagonType> {
-    if (!wagonTypeId) {
-      throw new BadRequestException(
-        `${typeLabel} has no wagon type configured — set one on its configuration before scheduling.`,
-      );
-    }
-    const [wagonType] = await this.wagonTypesRepository.findAll({
-      where: { id: wagonTypeId, isActive: true },
+  private async builtTrainStock(builtTrainId: string): Promise<WagonStock> {
+    const wagons = await this.dataSource.getRepository(Wagon).find({
+      where: { trainId: builtTrainId },
+      relations: { wagonType: true },
     });
-    if (!wagonType) {
-      throw new NotFoundException(
-        `${typeLabel} references wagon type ${wagonTypeId}, which was not found or is inactive.`,
+    const remainingByTypeId = new Map<string, number>();
+    const codesByTypeId = new Map<string, string>();
+    for (const wagon of wagons) {
+      remainingByTypeId.set(
+        wagon.wagonTypeId,
+        (remainingByTypeId.get(wagon.wagonTypeId) ?? 0) + 1,
       );
+      if (wagon.wagonType) codesByTypeId.set(wagon.wagonTypeId, wagon.wagonType.code);
     }
-    return wagonType;
+    return { mode: 'TRAIN', remainingByTypeId, codesByTypeId };
   }
 
   /**
@@ -3962,13 +4085,12 @@ export class TrainSchedulingService {
   private async persistTrainSetWagons(
     manager: EntityManager,
     trainSetId: string,
-    wagonType: WagonType,
     wagonPlan: WagonPlanSlot[],
   ) {
     const wagons = wagonPlan.map((slot) =>
       manager.getRepository(TrainSetWagon).create({
         trainSetId,
-        wagonTypeId: slot.wagonTypeId ?? wagonType.id,
+        wagonTypeId: slot.wagonTypeId,
         sequenceNo: slot.sequenceNo,
         capacityTons: slot.capacityTons,
         lengthMeters: slot.lengthMeters,
@@ -4198,11 +4320,17 @@ export class TrainSchedulingService {
     return locomotive;
   }
 
-  private async buildEmptyTrainSet(manager: EntityManager, locomotives: Locomotive[]) {
+  private async buildEmptyTrainSet(
+    manager: EntityManager,
+    locomotives: Locomotive[],
+    builtTrainId: string | null = null,
+  ) {
     const [primary] = locomotives;
     const trainSet = manager.getRepository(TrainSet).create({
       // `locomotiveId` retained as the primary locomotive for single-loco read paths.
       locomotiveId: primary.id,
+      // Built fleet train this set was formed from (Train Builder), if any.
+      trainId: builtTrainId,
       totalWeightTons: 0,
       totalLengthMeters: 0,
       wagonCount: 0,
@@ -4358,6 +4486,14 @@ export class TrainSchedulingService {
       origin: schedule.originStation?.label ?? schedule.originStation?.code ?? null,
       destination:
         schedule.destinationStation?.label ?? schedule.destinationStation?.code ?? null,
+      // Built train (Train Builder) behind this departure, when scheduled by train.
+      train: schedule.trainSet?.train
+        ? {
+            id: schedule.trainSet.train.id,
+            code: schedule.trainSet.train.code,
+            trainName: schedule.trainSet.train.trainName ?? null,
+          }
+        : null,
       locomotive: schedule.trainSet?.locomotive
         ? {
             id: schedule.trainSet.locomotive.id,
@@ -4431,6 +4567,441 @@ export class TrainSchedulingService {
     }));
   }
 
+  /**
+   * All schedulable built trains (Train Builder), annotated for the
+   * schedule-creation picker. Mirrors the locomotive picker's advance-scheduling
+   * philosophy: nothing serviceable is filtered out — staff see the status,
+   * whether the train sits at the origin yard yet, and its future schedules.
+   * Trains with fewer than two locomotives are omitted (never schedulable).
+   */
+  async getAvailableTrainsForRoute(routeId: string) {
+    const route = await this.getSchedulableRoute(routeId);
+
+    const trains = await this.dataSource.getRepository(Train).find({
+      where: {
+        status: Not(
+          In([Freight.TrainStatus.OutOfService, Freight.TrainStatus.UnderMaintenance]),
+        ),
+      },
+      relations: {
+        currentYard: true,
+        locomotives: { locomotive: true },
+        wagons: { wagonType: true },
+      },
+      order: { code: 'ASC', locomotives: { sequenceNo: 'ASC' } },
+    });
+
+    const counts: { train_id: string; future_count: string }[] = trains.length
+      ? await this.dataSource.query(
+          `SELECT tset.train_id, COUNT(DISTINCT ts.id) AS future_count
+             FROM freight.train_schedules ts
+             JOIN freight.train_sets tset ON tset.id = ts.train_set_id
+            WHERE ts.status IN ('DRAFT', 'SCHEDULED')
+              AND ts.deleted_at IS NULL
+              AND tset.train_id = ANY($1)
+            GROUP BY tset.train_id`,
+          [trains.map((t) => t.id)],
+        )
+      : [];
+    const futureCounts = new Map(counts.map((c) => [c.train_id, Number(c.future_count)]));
+
+    return trains
+      .filter((train) => (train.locomotives ?? []).length >= 2)
+      .map((train) => {
+        const wagons = train.wagons ?? [];
+        return {
+          id: train.id,
+          code: train.code,
+          trainName: train.trainName ?? null,
+          status: train.status,
+          currentYardId: train.currentYardId ?? null,
+          currentYard: train.currentYard
+            ? {
+                id: train.currentYard.id,
+                code: train.currentYard.code,
+                label: train.currentYard.label,
+              }
+            : null,
+          locomotives: (train.locomotives ?? [])
+            .filter((link) => link.locomotive)
+            .map((link) => ({
+              id: link.locomotive!.id,
+              code: link.locomotive!.code,
+              name: link.locomotive!.name ?? null,
+            })),
+          wagonCount: wagons.length,
+          totalTareTons: roundTons(
+            wagons.reduce((sum, w) => sum + (Number(w.wagonType?.tareWeightTons) || 0), 0),
+          ),
+          totalLengthMeters: roundTons(
+            wagons.reduce((sum, w) => sum + (Number(w.wagonType?.lengthMeters) || 0), 0),
+          ),
+          maxPullWeightTons: roundTons(Number(train.capacityTons)),
+          atOriginYard: train.currentYardId === route.originYardId,
+          futureScheduleCount: futureCounts.get(train.id) ?? 0,
+        };
+      });
+  }
+
+  /**
+   * Consist snapshot for the adjust-consist UI: the built train's wagons with
+   * loaded/removable flags, gross weight (cargo + FULL consist tare) and length
+   * against the locomotive limits incl. overage tolerance, addable yard wagons,
+   * and the adjustment history.
+   */
+  async getScheduleConsist(scheduleId: string) {
+    const schedule = await this.trainSchedulesRepository.findByIdWithFullGraph(scheduleId);
+    if (!schedule) throw new NotFoundException(`Train schedule ${scheduleId} not found`);
+    const builtTrain = schedule.trainSet?.train;
+    if (!builtTrain) {
+      throw new BadRequestException(
+        'This schedule was not created from a built train — its consist cannot be adjusted here',
+      );
+    }
+
+    const wagons = await this.dataSource.getRepository(Wagon).find({
+      where: { trainId: builtTrain.id },
+      relations: { wagonType: true },
+      order: { sequenceNumber: 'ASC' },
+    });
+    const addableWagons = await this.dataSource.getRepository(Wagon).find({
+      where: {
+        trainId: IsNull(),
+        status: WagonStatus.Available,
+        currentYardId: builtTrain.currentYardId ?? undefined,
+      },
+      relations: { wagonType: true },
+      order: { wagonNumber: 'ASC' },
+    });
+    const adjustments = await this.dataSource
+      .getRepository(ScheduleWagonAdjustmentLog)
+      .find({ where: { trainScheduleId: scheduleId }, order: { occurredAt: 'DESC' }, take: 30 });
+
+    // Slots with cargo aboard — their physical wagons are "loaded" and can
+    // never be trimmed.
+    const loadedWagonIds = new Set(
+      (schedule.trainSet?.wagons ?? [])
+        .filter((slot) => slot.physicalWagonId && (slot.allocations?.length ?? 0) > 0)
+        .map((slot) => slot.physicalWagonId as string),
+    );
+
+    const limits = minLocomotiveLimits(this.locomotivesOfTrainSet(schedule.trainSet));
+    const maxPullWeightTons = roundTons(Number(limits?.maxPullWeightTons ?? 0));
+    const overageToleranceTons = roundTons(Number(limits?.overageToleranceTons) || 0);
+    const maxTrainLengthMeters = roundTons(Number(limits?.maxTrainLengthMeters ?? 0));
+    const overageToleranceMeters = roundTons(Number(limits?.overageToleranceMeters) || 0);
+
+    const cargoTons = roundTons(Number(schedule.trainSet?.totalWeightTons ?? 0));
+    const consistTareTons = roundTons(
+      wagons.reduce((sum, w) => sum + Number(w.wagonType?.tareWeightTons ?? 0), 0),
+    );
+    const consistLengthMeters = roundTons(
+      wagons.reduce((sum, w) => sum + Number(w.wagonType?.lengthMeters ?? 0), 0),
+    );
+
+    const mapWagon = (wagon: Wagon) => ({
+      id: wagon.id,
+      wagonNumber: wagon.wagonNumber,
+      sequenceNumber: wagon.sequenceNumber,
+      wagonType: wagon.wagonType
+        ? {
+            id: wagon.wagonType.id,
+            code: wagon.wagonType.code,
+            tareWeightTons: roundTons(Number(wagon.wagonType.tareWeightTons ?? 0)),
+            capacityTons: roundTons(Number(wagon.wagonType.capacityTons ?? 0)),
+            lengthMeters: roundTons(Number(wagon.wagonType.lengthMeters ?? 0)),
+          }
+        : null,
+    });
+
+    return {
+      schedule: { id: schedule.id, reference: schedule.reference ?? null, status: schedule.status },
+      train: {
+        id: builtTrain.id,
+        code: builtTrain.code,
+        trainName: builtTrain.trainName ?? null,
+        currentYardId: builtTrain.currentYardId ?? null,
+      },
+      limits: {
+        maxPullWeightTons,
+        overageToleranceTons,
+        pullCapTons: roundTons(maxPullWeightTons + overageToleranceTons),
+        maxTrainLengthMeters,
+        overageToleranceMeters,
+        lengthCapMeters: roundTons(maxTrainLengthMeters + overageToleranceMeters),
+      },
+      totals: {
+        wagonCount: wagons.length,
+        cargoTons,
+        consistTareTons,
+        grossTons: roundTons(cargoTons + consistTareTons),
+        consistLengthMeters,
+      },
+      wagons: wagons.map((wagon) => ({
+        ...mapWagon(wagon),
+        loaded: loadedWagonIds.has(wagon.id),
+        // Free = not pinned to any run; only free wagons can be trimmed.
+        removable: wagon.currentTrainScheduleId == null && !loadedWagonIds.has(wagon.id),
+      })),
+      addableWagons: addableWagons.map(mapWagon),
+      adjustments: adjustments.map((log) => ({
+        id: log.id,
+        action: log.action,
+        wagonId: log.wagonId,
+        wagonNumber: log.wagonNumber,
+        adjustedByUserId: log.adjustedByUserId,
+        occurredAt: log.occurredAt,
+      })),
+      editable: ['DRAFT', 'SCHEDULED'].includes(schedule.status),
+    };
+  }
+
+  /**
+   * Permanently adjust the built train's consist from a schedule: trim free
+   * wagons (their tare no longer rides — the usual fix when gross weight beats
+   * the pull limit) and/or couple extra AVAILABLE yard wagons while weight and
+   * length headroom remain (limits incl. overage tolerance). The built train
+   * updates in place, the schedule's wagon cap follows, and every change is
+   * logged for the schedule's history.
+   */
+  async adjustScheduleConsist(
+    scheduleId: string,
+    dto: AdjustScheduleConsistDto,
+    userId?: string | null,
+  ) {
+    const addWagonIds = [...new Set(dto.addWagonIds ?? [])];
+    const removeWagonIds = [...new Set(dto.removeWagonIds ?? [])];
+    if (!addWagonIds.length && !removeWagonIds.length) {
+      throw new BadRequestException('Nothing to adjust — pass wagons to add and/or remove');
+    }
+    const overlap = addWagonIds.filter((id) => removeWagonIds.includes(id));
+    if (overlap.length) {
+      throw new BadRequestException('A wagon cannot be added and removed in the same adjustment');
+    }
+
+    const schedule = await this.trainSchedulesRepository.findByIdWithFullGraph(scheduleId);
+    if (!schedule) throw new NotFoundException(`Train schedule ${scheduleId} not found`);
+    if (!['DRAFT', 'SCHEDULED'].includes(schedule.status)) {
+      throw new BadRequestException(
+        'The consist is frozen once the train is dispatched — adjust before departure',
+      );
+    }
+    const builtTrainRef = schedule.trainSet?.train;
+    if (!builtTrainRef) {
+      throw new BadRequestException(
+        'This schedule was not created from a built train — its consist cannot be adjusted here',
+      );
+    }
+    const loadedWagonIds = new Set(
+      (schedule.trainSet?.wagons ?? [])
+        .filter((slot) => slot.physicalWagonId && (slot.allocations?.length ?? 0) > 0)
+        .map((slot) => slot.physicalWagonId as string),
+    );
+    const limits = minLocomotiveLimits(this.locomotivesOfTrainSet(schedule.trainSet));
+    const pullCapTons = roundTons(
+      Number(limits?.maxPullWeightTons ?? 0) + (Number(limits?.overageToleranceTons) || 0),
+    );
+    const lengthCapMeters = roundTons(
+      Number(limits?.maxTrainLengthMeters ?? 0) + (Number(limits?.overageToleranceMeters) || 0),
+    );
+
+    await this.dataSource.transaction(async (manager) => {
+      const train = await manager.getRepository(Train).findOne({
+        where: { id: builtTrainRef.id },
+        lock: { mode: 'pessimistic_write' },
+      });
+      if (!train) throw new NotFoundException(`Train ${builtTrainRef.id} not found`);
+
+      const consist = await manager.getRepository(Wagon).find({
+        where: { trainId: train.id },
+        relations: { wagonType: true },
+        order: { sequenceNumber: 'ASC' },
+      });
+      const consistById = new Map(consist.map((w) => [w.id, w]));
+
+      // --- validate removals: must be coupled and free (no cargo, no pin) ---
+      const removed: Wagon[] = [];
+      for (const wagonId of removeWagonIds) {
+        const wagon = consistById.get(wagonId);
+        if (!wagon) {
+          throw new NotFoundException(`Wagon ${wagonId} is not coupled to train ${train.code}`);
+        }
+        if (loadedWagonIds.has(wagon.id) || wagon.currentTrainScheduleId != null) {
+          throw new ConflictException(
+            `Wagon ${wagon.wagonNumber} is loaded/pinned on a schedule and cannot be trimmed`,
+          );
+        }
+        removed.push(wagon);
+      }
+
+      // --- validate additions: AVAILABLE, loose, standing in the train's yard ---
+      const added: Wagon[] = [];
+      for (const wagonId of addWagonIds) {
+        const wagon = await manager.getRepository(Wagon).findOne({
+          where: { id: wagonId },
+          relations: { wagonType: true },
+          lock: { mode: 'pessimistic_write' },
+        });
+        if (!wagon) throw new NotFoundException(`Wagon ${wagonId} not found`);
+        if (wagon.trainId) {
+          throw new ConflictException(`Wagon ${wagon.wagonNumber} is already on a train`);
+        }
+        if (wagon.status !== WagonStatus.Available) {
+          throw new ConflictException(
+            `Wagon ${wagon.wagonNumber} is not available (${wagon.status})`,
+          );
+        }
+        if (wagon.currentYardId !== train.currentYardId) {
+          throw new BadRequestException(
+            `Wagon ${wagon.wagonNumber} is not in the train's yard — only wagons in the same yard can be coupled`,
+          );
+        }
+        added.push(wagon);
+      }
+
+      // --- headroom check (only additions can push the train over a cap) ---
+      const removedIds = new Set(removed.map((w) => w.id));
+      const finalConsist = [...consist.filter((w) => !removedIds.has(w.id)), ...added];
+      const tareOf = (w: Wagon) => Number(w.wagonType?.tareWeightTons ?? 0);
+      const lengthOf = (w: Wagon) => Number(w.wagonType?.lengthMeters ?? 0);
+      const finalTareTons = roundTons(finalConsist.reduce((s, w) => s + tareOf(w), 0));
+      const finalLengthMeters = roundTons(finalConsist.reduce((s, w) => s + lengthOf(w), 0));
+      const cargoTons = roundTons(Number(schedule.trainSet?.totalWeightTons ?? 0));
+      const finalGrossTons = roundTons(cargoTons + finalTareTons);
+      if (added.length && pullCapTons > 0 && finalGrossTons > pullCapTons) {
+        throw new BadRequestException(
+          `Adding these wagons puts gross weight at ${finalGrossTons}T (${cargoTons}T cargo + ${finalTareTons}T tare), over the locomotives' ${pullCapTons}T limit incl. tolerance`,
+        );
+      }
+      if (added.length && lengthCapMeters > 0 && finalLengthMeters > lengthCapMeters) {
+        throw new BadRequestException(
+          `Adding these wagons puts consist length at ${finalLengthMeters}m, over the locomotives' ${lengthCapMeters}m limit incl. tolerance`,
+        );
+      }
+
+      // --- apply: detach trims, couple additions, compact the sequence ---
+      for (const wagon of removed) {
+        await manager.getRepository(Wagon).update(wagon.id, {
+          trainId: null,
+          sequenceNumber: null,
+          status: WagonStatus.Available,
+        });
+      }
+      const remaining = consist.filter((w) => !removedIds.has(w.id));
+      for (let i = 0; i < remaining.length; i++) {
+        if (remaining[i].sequenceNumber !== i + 1) {
+          await manager.getRepository(Wagon).update(remaining[i].id, { sequenceNumber: i + 1 });
+        }
+      }
+      let sequence = remaining.length;
+      for (const wagon of added) {
+        sequence += 1;
+        await manager.getRepository(Wagon).update(wagon.id, {
+          trainId: train.id,
+          sequenceNumber: sequence,
+          status: WagonStatus.Assigned,
+        });
+      }
+
+      // The schedule is full when every consist wagon is allocated.
+      await manager
+        .getRepository(TrainSchedule)
+        .update(scheduleId, { maxWagons: finalConsist.length });
+
+      const logRepo = manager.getRepository(ScheduleWagonAdjustmentLog);
+      const now = new Date();
+      await logRepo.save(
+        [
+          ...removed.map((wagon) => ({ action: 'REMOVE' as const, wagon })),
+          ...added.map((wagon) => ({ action: 'ADD' as const, wagon })),
+        ].map(({ action, wagon }) =>
+          logRepo.create({
+            trainScheduleId: scheduleId,
+            trainId: train.id,
+            action,
+            wagonId: wagon.id,
+            wagonNumber: wagon.wagonNumber,
+            adjustedByUserId: userId ?? null,
+            occurredAt: now,
+          }),
+        ),
+      );
+    });
+
+    return this.getScheduleConsist(scheduleId);
+  }
+
+  /**
+   * Re-derive a built train's lifecycle status from its schedules after one of
+   * them changes: any DISPATCHED schedule → IN_SERVICE; any DRAFT/SCHEDULED →
+   * SCHEDULED; otherwise AVAILABLE. `moveToYardId` relocates the train (arrival
+   * at destination). Manually parked trains (UNDER_MAINTENANCE / OUT_OF_SERVICE)
+   * keep their status — staff own that flag, not the scheduler.
+   */
+  private async syncBuiltTrainAfterScheduleChange(
+    manager: EntityManager,
+    trainId: string,
+    moveToYardId?: string | null,
+  ): Promise<void> {
+    const train = await manager.getRepository(Train).findOne({ where: { id: trainId } });
+    if (!train) return;
+
+    const yardPatch = moveToYardId ? { currentYardId: moveToYardId } : {};
+    const managed = [
+      Freight.TrainStatus.Available,
+      Freight.TrainStatus.Scheduled,
+      Freight.TrainStatus.InService,
+    ];
+    if (!managed.includes(train.status)) {
+      if (moveToYardId) await manager.getRepository(Train).update(trainId, yardPatch);
+      return;
+    }
+
+    const rows: { status: string }[] = await manager.query(
+      `SELECT DISTINCT ts.status
+         FROM freight.train_schedules ts
+         JOIN freight.train_sets tset ON tset.id = ts.train_set_id
+        WHERE tset.train_id = $1
+          AND ts.deleted_at IS NULL
+          AND ts.status IN ('DRAFT', 'SCHEDULED', 'DISPATCHED')`,
+      [trainId],
+    );
+    const statuses = new Set(rows.map((r) => r.status));
+    const next = statuses.has('DISPATCHED')
+      ? Freight.TrainStatus.InService
+      : statuses.size
+        ? Freight.TrainStatus.Scheduled
+        : Freight.TrainStatus.Available;
+    await manager.getRepository(Train).update(trainId, { status: next, ...yardPatch });
+  }
+
+  /**
+   * A contract_route (`cr`) serves a schedule (`ts`) when its yard pair is a
+   * FORWARD sub-leg of the schedule's corridor — both yards sit on `ts.route`'s
+   * milestones with the destination stop AFTER the origin stop — OR (routes with
+   * no milestones recorded) the pair equals the schedule's own endpoints. This
+   * mirrors the sub-leg matching the create-booking path already does
+   * (`getBookableScheduleEntities`), so a through train (Djibouti → Kality →
+   * Dire) is announced and bookable for every leg it actually serves
+   * (Djibouti → Kality, Djibouti → Dire, Kality → Dire) — not only its two
+   * endpoints. Static SQL fragment (no user input) interpolated into the window
+   * queries below; `ts` and `cr` must be the schedule and contract_route aliases.
+   */
+  private readonly CONTRACT_ROUTE_SERVES_SCHEDULE = `(
+                EXISTS (
+                  SELECT 1
+                    FROM freight.route_milestones mo
+                    JOIN freight.route_milestones md
+                      ON md.route_id = mo.route_id
+                     AND md.sequence_no > mo.sequence_no
+                   WHERE mo.route_id = ts.route_id
+                     AND mo.yard_id = cr.origin_yard_id
+                     AND md.yard_id = cr.destination_yard_id
+                )
+                OR (cr.origin_yard_id = ts.origin_station_id
+                    AND cr.destination_yard_id = ts.destination_station_id)
+              )`;
+
   /**
    * Upcoming/open booking windows announced on the portal home "booking
    * windows" section. ALL window-engine schedules (IMPORT cycle / EXPORT lead)
@@ -4441,6 +5012,8 @@ export class TrainSchedulingService {
    * LEFT-JOINed in so the row carries `contractId`/`contractKind` (enabling
    * "Book now"); customers with no covering contract still see the window with a
    * null contract, and the portal routes them to the contract list to get one.
+   * A contract covering any FORWARD sub-leg of the corridor counts as covering
+   * the lane (see `CONTRACT_ROUTE_SERVES_SCHEDULE`).
    */
   async getBookingWindowsForCompany(companyId: string | null) {
     const rows: Array<BookingWindowRow> = await this.dataSource.query(
@@ -4459,12 +5032,15 @@ export class TrainSchedulingService {
               ts.booking_cycle_no,
               ts.scheduled_departure_date,
               oy.label AS origin_label, oy.code AS origin_code,
-              dy.label AS destination_label, dy.code AS destination_code
+              dy.label AS destination_label, dy.code AS destination_code,
+              (SELECT array_agg(COALESCE(rmy.label, rmy.code) ORDER BY rm.sequence_no)
+                 FROM freight.route_milestones rm
+                 JOIN freight.yards rmy ON rmy.id = rm.yard_id
+                WHERE rm.route_id = ts.route_id) AS route_stations
          FROM freight.train_schedules ts
          LEFT JOIN freight.contract_routes cr
-           ON cr.origin_yard_id = ts.origin_station_id
-          AND cr.destination_yard_id = ts.destination_station_id
-          AND cr.deleted_at IS NULL
+           ON cr.deleted_at IS NULL
+          AND ${this.CONTRACT_ROUTE_SERVES_SCHEDULE}
          LEFT JOIN freight.contracts c
            ON c.id = cr.contract_id
           AND c.company_id = $1
@@ -4512,13 +5088,16 @@ export class TrainSchedulingService {
               ts.booking_cycle_no,
               ts.scheduled_departure_date,
               oy.label AS origin_label, oy.code AS origin_code,
-              dy.label AS destination_label, dy.code AS destination_code
+              dy.label AS destination_label, dy.code AS destination_code,
+              (SELECT array_agg(COALESCE(rmy.label, rmy.code) ORDER BY rm.sequence_no)
+                 FROM freight.route_milestones rm
+                 JOIN freight.yards rmy ON rmy.id = rm.yard_id
+                WHERE rm.route_id = ts.route_id) AS route_stations
          FROM freight.train_schedules ts
          JOIN freight.contract_routes cr
-           ON cr.origin_yard_id = ts.origin_station_id
-          AND cr.destination_yard_id = ts.destination_station_id
-          AND cr.contract_id = $1
+           ON cr.contract_id = $1
           AND cr.deleted_at IS NULL
+          AND ${this.CONTRACT_ROUTE_SERVES_SCHEDULE}
          JOIN freight.contracts c
            ON c.id = cr.contract_id
           AND c.deleted_at IS NULL
@@ -4559,7 +5138,11 @@ export class TrainSchedulingService {
               ts.booking_cycle_no,
               ts.scheduled_departure_date,
               oy.label AS origin_label, oy.code AS origin_code,
-              dy.label AS destination_label, dy.code AS destination_code
+              dy.label AS destination_label, dy.code AS destination_code,
+              (SELECT array_agg(COALESCE(rmy.label, rmy.code) ORDER BY rm.sequence_no)
+                 FROM freight.route_milestones rm
+                 JOIN freight.yards rmy ON rmy.id = rm.yard_id
+                WHERE rm.route_id = ts.route_id) AS route_stations
          FROM freight.train_schedules ts
          LEFT JOIN freight.yards oy ON oy.id = ts.origin_station_id
          LEFT JOIN freight.yards dy ON dy.id = ts.destination_station_id
@@ -4581,6 +5164,17 @@ export class TrainSchedulingService {
   }
 
   private mapBookingWindowRow(r: BookingWindowRow) {
+    const origin = r.origin_label ?? r.origin_code ?? null;
+    const destination = r.destination_label ?? r.destination_code ?? null;
+    // Full corridor from the route's milestones (origin → stops → destination).
+    // Falls back to the schedule's origin/destination when no milestones exist.
+    const milestoneStops = (r.route_stations ?? []).filter(
+      (s): s is string => Boolean(s),
+    );
+    const routeStations =
+      milestoneStops.length >= 2
+        ? milestoneStops
+        : [origin, destination].filter((s): s is string => Boolean(s));
     return {
       scheduleId: r.schedule_id,
       reference: r.reference ?? null,
@@ -4596,8 +5190,9 @@ export class TrainSchedulingService {
       bookingWindowStatus: r.booking_window_status,
       bookingCycleNo: r.booking_cycle_no,
       departureDate: r.scheduled_departure_date,
-      origin: r.origin_label ?? r.origin_code ?? null,
-      destination: r.destination_label ?? r.destination_code ?? null,
+      origin,
+      destination,
+      routeStations,
     };
   }
 
@@ -4622,7 +5217,7 @@ export class TrainSchedulingService {
         bookingWindowStatus: 'OPEN',
       },
       relations: {
-        trainSet: { locomotive: true, locomotives: { locomotive: true } },
+        trainSet: { locomotive: true, locomotives: { locomotive: true }, train: true },
         route: { milestones: true },
         originStation: true,
         destinationStation: true,
@@ -4939,6 +5534,14 @@ export class TrainSchedulingService {
       actualDepartureAt: schedule.actualDepartureAt ?? null,
       originStation: schedule.originStation,
       destinationStation: schedule.destinationStation,
+      // Built train (Train Builder) behind this departure, when scheduled by train.
+      train: schedule.trainSet?.train
+        ? {
+            id: schedule.trainSet.train.id,
+            code: schedule.trainSet.train.code,
+            trainName: schedule.trainSet.train.trainName ?? null,
+          }
+        : null,
       trainSet: schedule.trainSet
         ? {
             id: schedule.trainSet.id,
@@ -5557,10 +6160,16 @@ export class TrainSchedulingService {
     }
 
     const freightType = booking.freightType === 'BULK' ? 'BULK' : 'CONTAINER';
-    let wagonType: WagonType;
-    try {
-      wagonType = await this.resolveWagonType(freightType, [booking.id]);
-    } catch {
+    const [fullBooking] = await this.bookingsRepository.findByIdsForScheduling([booking.id]);
+    const resolvedBooking = fullBooking ?? booking;
+    // List-based resolution: every wagon type allowed for the booking's
+    // container/cargo type counts toward its availability.
+    const allowed = this.loadAllowedWagonTypes([resolvedBooking]);
+    const candidates =
+      freightType === 'BULK'
+        ? [...allowed.byCargoTypeId.values()].flat()
+        : [...allowed.byContainerTypeId.values()].flat();
+    if (!candidates.length) {
       return {
         wagonsRequired: 0,
         requiredWagonTypeCode: '',
@@ -5571,11 +6180,15 @@ export class TrainSchedulingService {
     }
 
     const bulkCapacity =
-      freightType === 'BULK' ? Number(wagonType.capacityTons) : undefined;
-    const [fullBooking] = await this.bookingsRepository.findByIdsForScheduling([booking.id]);
-    const resolvedBooking = fullBooking ?? booking;
+      freightType === 'BULK'
+        ? Math.max(...candidates.map((wt) => Number(wt.capacityTons)))
+        : undefined;
     const wagonsRequired = wagonsRequiredForBooking(resolvedBooking, bulkCapacity);
-    const yardWagonsAvailable = fleetByTypeId.get(wagonType.id)?.available ?? 0;
+    const requiredWagonTypeCode = [...new Set(candidates.map((wt) => wt.code))].join('/');
+    const yardWagonsAvailable = candidates.reduce(
+      (sum, wt) => sum + (fleetByTypeId.get(wt.id)?.available ?? 0),
+      0,
+    );
 
     const allBookingIds = [...wagonAssignedIds, booking.id];
     const previewDto = {
@@ -5603,7 +6216,7 @@ export class TrainSchedulingService {
     } catch (err) {
       return {
         wagonsRequired,
-        requiredWagonTypeCode: wagonType.code,
+        requiredWagonTypeCode,
         yardWagonsAvailable,
         canAssign: false,
         blockReason: err instanceof Error ? err.message : 'Validation failed',
@@ -5613,7 +6226,7 @@ export class TrainSchedulingService {
     if (!validation.valid) {
       return {
         wagonsRequired,
-        requiredWagonTypeCode: wagonType.code,
+        requiredWagonTypeCode,
         yardWagonsAvailable,
         canAssign: false,
         blockReason: validation.violations[0] ?? 'Booking validation failed',
@@ -5625,17 +6238,17 @@ export class TrainSchedulingService {
       const deferred = validation.deferredBookings.find((d) => d.id === booking.id);
       const yardShortfall =
         yardWagonsAvailable < wagonsRequired
-          ? `No ${wagonType.code} wagons at origin yard (need ${wagonsRequired}, ${yardWagonsAvailable} available)`
+          ? `No ${requiredWagonTypeCode} wagons at origin yard (need ${wagonsRequired}, ${yardWagonsAvailable} available)`
           : null;
       return {
         wagonsRequired,
-        requiredWagonTypeCode: wagonType.code,
+        requiredWagonTypeCode,
         yardWagonsAvailable,
         canAssign: false,
         blockReason:
           deferred?.reason ??
           yardShortfall ??
-          `Need ${wagonsRequired} ${wagonType.code} wagon(s) at origin yard`,
+          `Need ${wagonsRequired} ${requiredWagonTypeCode} wagon(s) at origin yard`,
       };
     }
 
@@ -5650,7 +6263,7 @@ export class TrainSchedulingService {
       if (missing) {
         return {
           wagonsRequired,
-          requiredWagonTypeCode: wagonType.code,
+          requiredWagonTypeCode,
           yardWagonsAvailable,
           canAssign: false,
           blockReason: missing.issue,
@@ -5660,7 +6273,7 @@ export class TrainSchedulingService {
 
     return {
       wagonsRequired,
-      requiredWagonTypeCode: wagonType.code,
+      requiredWagonTypeCode,
       yardWagonsAvailable,
       canAssign: true,
       blockReason: null,
diff --git a/apps/edr-freight-api/src/modules/train-scheduling/wagon-plan-flex.util.ts b/apps/edr-freight-api/src/modules/train-scheduling/wagon-plan-flex.util.ts
new file mode 100644
index 000000000..b4b8657ba
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/train-scheduling/wagon-plan-flex.util.ts
@@ -0,0 +1,299 @@
+import { AllocationLoadType } from '@edr/types';
+
+import { Booking } from '../bookings/entities/booking.entity';
+import { WagonType } from '../wagon-types/entities/wagon-type.entity';
+import { sortBookingsForScheduling, type DeferredBookingRow } from './fleet-plan.util';
+import {
+  MAX_TEU_SLOTS_PER_WAGON,
+  expandBookingContainerUnits,
+  roundTons,
+  tareTonsOf,
+  teuSlotsForSizeFt,
+  type SlotLoadType,
+  type WagonPlanSlot,
+} from './wagon-plan.util';
+
+/**
+ * Wagon types allowed to carry each container type / bulk cargo type — the
+ * many-to-many configuration lists, resolved once per validation run.
+ */
+export type AllowedWagonTypeMap = {
+  byContainerTypeId: Map<string, WagonType[]>;
+  byCargoTypeId: Map<string, WagonType[]>;
+};
+
+/**
+ * Plannable wagon inventory. TRAIN mode is the built train's own consist —
+ * a hard cap, the plan never reaches for loose yard wagons. YARD mode is the
+ * AVAILABLE pool at the boarding yards (legacy schedules).
+ */
+export type WagonStock = {
+  mode: 'TRAIN' | 'YARD';
+  /** Remaining plannable wagons per wagon type id. Missing type = 0. */
+  remainingByTypeId: Map<string, number>;
+  /** Wagon-type code per id, for human-readable shortfall messages. */
+  codesByTypeId: Map<string, string>;
+};
+
+export type FlexPlanResult = {
+  plan: WagonPlanSlot[];
+  fitting: Booking[];
+  deferred: DeferredBookingRow[];
+  /**
+   * Misconfiguration (a scheduled type with no wagon types configured) —
+   * a hard violation, unlike stock shortfalls which merely defer bookings.
+   */
+  configIssues: string[];
+};
+
+type OpenSlot = {
+  slot: WagonPlanSlot;
+  teuUsed: number;
+  kind: SlotLoadType;
+  /** Kind purity: a bulk wagon carries ONE cargo type at a time. */
+  cargoTypeId: string | null;
+  freeCapacityTons: number;
+};
+
+type PlacementProblem = { kind: 'config' | 'stock'; message: string };
+
+const slotFromWagonType = (wagonType: WagonType, kind: SlotLoadType): WagonPlanSlot => ({
+  sequenceNo: 0, // stamped at the end
+  wagonTypeId: wagonType.id,
+  wagonTypeCode: wagonType.code,
+  capacityTons: Number(wagonType.capacityTons),
+  lengthMeters: Number(wagonType.lengthMeters),
+  tareWeightTons: tareTonsOf(wagonType),
+  assignedWeightTons: 0,
+  allocations: [],
+  slotLoadType: kind,
+});
+
+const addAllocation = (
+  slot: WagonPlanSlot,
+  bookingId: string,
+  bookingReference: string,
+  weightTons: number,
+  loadType: AllocationLoadType,
+) => {
+  let allocation = slot.allocations.find((a) => a.bookingId === bookingId);
+  if (!allocation) {
+    allocation = { bookingId, bookingReference, allocatedWeightTons: 0, loadType };
+    slot.allocations.push(allocation);
+  }
+  allocation.allocatedWeightTons = roundTons(allocation.allocatedWeightTons + weightTons);
+  slot.assignedWeightTons = roundTons(slot.assignedWeightTons + weightTons);
+};
+
+/**
+ * Build the wagon plan against a wagon-type inventory, mixing wagon types
+ * within one consist. Each booking is atomic: it either fits entirely (its
+ * containers/tonnage placed on wagons whose type is allowed for its container
+ * or cargo type) or is deferred with the shortfall reason. Wagon purity rules:
+ * a wagon carries one kind at a time — containers pack by TEU (one 40ft, or
+ * two 20ft, never mixed sizes), bulk fills by weight and never shares a wagon
+ * with a different cargo type.
+ */
+export function planWagonsWithStock(params: {
+  bookings: Booking[];
+  allowed: AllowedWagonTypeMap;
+  stock: WagonStock;
+}): FlexPlanResult {
+  const { bookings, allowed, stock } = params;
+  const remaining = new Map(stock.remainingByTypeId);
+  const openSlots: OpenSlot[] = [];
+  const fitting: Booking[] = [];
+  const deferred: DeferredBookingRow[] = [];
+  const configIssues = new Set<string>();
+
+  const noStockMessage = (candidates: WagonType[]): string => {
+    const codes = candidates.map((wt) => wt.code).join('/');
+    return stock.mode === 'TRAIN'
+      ? `Train has no free ${codes} wagon left`
+      : `No available ${codes} wagon at the yard`;
+  };
+
+  /** Open a new wagon of one of the candidate types, consuming stock. */
+  const openSlot = (
+    candidates: WagonType[],
+    kind: SlotLoadType,
+    cargoTypeId: string | null,
+  ): OpenSlot | PlacementProblem => {
+    const inStock = candidates.filter((wt) => (remaining.get(wt.id) ?? 0) > 0);
+    if (!inStock.length) return { kind: 'stock', message: noStockMessage(candidates) };
+    // Bulk favors the largest wagon (fewest wagons for the tonnage); containers
+    // favor the deepest stock so the consist drains evenly. Ties keep config order.
+    const chosen = [...inStock].sort((a, b) =>
+      kind === 'BULK'
+        ? Number(b.capacityTons) - Number(a.capacityTons) ||
+          (remaining.get(b.id) ?? 0) - (remaining.get(a.id) ?? 0)
+        : (remaining.get(b.id) ?? 0) - (remaining.get(a.id) ?? 0),
+    )[0];
+    remaining.set(chosen.id, (remaining.get(chosen.id) ?? 0) - 1);
+    const open: OpenSlot = {
+      slot: slotFromWagonType(chosen, kind),
+      teuUsed: 0,
+      kind,
+      cargoTypeId,
+      freeCapacityTons: Number(chosen.capacityTons),
+    };
+    openSlots.push(open);
+    return open;
+  };
+
+  const tryPlaceBooking = (booking: Booking): PlacementProblem | null => {
+    if (booking.freightType === 'CONTAINER') {
+      const units = expandBookingContainerUnits([booking]);
+      if (!units.length) {
+        // Degenerate container booking with no lines still reserves one wagon
+        // (legacy behavior) — but there is no container type to resolve against.
+        return {
+          kind: 'config',
+          message: `Booking ${booking.reference} has no container lines to plan`,
+        };
+      }
+      for (const unit of units) {
+        const candidates = allowed.byContainerTypeId.get(unit.containerTypeId) ?? [];
+        if (!candidates.length) {
+          return {
+            kind: 'config',
+            message: `Container type "${unit.containerTypeCode}" has no wagon types configured — set them in its configuration before scheduling.`,
+          };
+        }
+        const allowedIds = new Set(candidates.map((wt) => wt.id));
+        const teu = unit.teuSlots ?? teuSlotsForSizeFt(unit.sizeFt ?? 20);
+        let target = openSlots.find(
+          (open) =>
+            open.kind === 'CONTAINER' &&
+            allowedIds.has(open.slot.wagonTypeId) &&
+            open.teuUsed + teu <= MAX_TEU_SLOTS_PER_WAGON,
+        );
+        if (!target) {
+          const openedSlot = openSlot(candidates, 'CONTAINER', null);
+          if ('message' in openedSlot) return openedSlot;
+          target = openedSlot;
+        }
+        addAllocation(
+          target.slot,
+          unit.bookingId,
+          unit.bookingReference,
+          unit.grossWeightTons,
+          AllocationLoadType.Container,
+        );
+        target.teuUsed += teu;
+      }
+      return null;
+    }
+
+    // BULK — weight-based, one cargo type per wagon.
+    const cargoTypeId = booking.cargoTypeId ?? booking.cargoType?.id ?? null;
+    const candidates = cargoTypeId ? (allowed.byCargoTypeId.get(cargoTypeId) ?? []) : [];
+    if (!candidates.length) {
+      return {
+        kind: 'config',
+        message: `Cargo type "${booking.cargoType?.cargoTypeName ?? booking.cargoType?.code ?? 'unknown'}" has no wagon types configured — set them in its configuration before scheduling.`,
+      };
+    }
+    const allowedIds = new Set(candidates.map((wt) => wt.id));
+    let remainingWeight = roundTons(Number(booking.cargoTotalWeightVgm ?? 0));
+    let placedAnywhere = false;
+
+    // Top off wagons already carrying THIS cargo type before opening new ones.
+    for (const open of openSlots) {
+      if (remainingWeight <= 0) break;
+      if (open.kind !== 'BULK') continue;
+      if (open.cargoTypeId !== cargoTypeId) continue;
+      if (!allowedIds.has(open.slot.wagonTypeId)) continue;
+      if (open.freeCapacityTons <= 0) continue;
+      const take = roundTons(Math.min(open.freeCapacityTons, remainingWeight));
+      addAllocation(
+        open.slot,
+        booking.id,
+        booking.reference,
+        take,
+        AllocationLoadType.Bulk,
+      );
+      open.freeCapacityTons = roundTons(open.freeCapacityTons - take);
+      remainingWeight = roundTons(remainingWeight - take);
+      placedAnywhere = true;
+    }
+
+    while (remainingWeight > 0 || !placedAnywhere) {
+      const openedSlot = openSlot(candidates, 'BULK', cargoTypeId);
+      if ('message' in openedSlot) return openedSlot;
+      const take = roundTons(Math.min(openedSlot.freeCapacityTons, remainingWeight));
+      addAllocation(
+        openedSlot.slot,
+        booking.id,
+        booking.reference,
+        take,
+        AllocationLoadType.Bulk,
+      );
+      openedSlot.freeCapacityTons = roundTons(openedSlot.freeCapacityTons - take);
+      remainingWeight = roundTons(remainingWeight - take);
+      placedAnywhere = true;
+    }
+    return null;
+  };
+
+  for (const booking of sortBookingsForScheduling(bookings)) {
+    // Snapshot so a booking that doesn't fully fit leaves no half-placed wagons.
+    const remainingSnapshot = new Map(remaining);
+    const slotCountSnapshot = openSlots.length;
+    const slotStateSnapshot = openSlots.map((open) => ({
+      teuUsed: open.teuUsed,
+      freeCapacityTons: open.freeCapacityTons,
+      assignedWeightTons: open.slot.assignedWeightTons,
+      allocationCount: open.slot.allocations.length,
+      allocationWeights: open.slot.allocations.map((a) => a.allocatedWeightTons),
+    }));
+
+    const problem = tryPlaceBooking(booking);
+    if (!problem) {
+      fitting.push(booking);
+      continue;
+    }
+
+    // Roll back this booking's partial placements.
+    remaining.clear();
+    for (const [key, value] of remainingSnapshot) remaining.set(key, value);
+    openSlots.length = slotCountSnapshot;
+    openSlots.forEach((open, index) => {
+      const snap = slotStateSnapshot[index];
+      if (!snap) return;
+      open.teuUsed = snap.teuUsed;
+      open.freeCapacityTons = snap.freeCapacityTons;
+      open.slot.assignedWeightTons = snap.assignedWeightTons;
+      open.slot.allocations.length = snap.allocationCount;
+      snap.allocationWeights.forEach((weight, allocationIndex) => {
+        open.slot.allocations[allocationIndex].allocatedWeightTons = weight;
+      });
+    });
+
+    if (problem.kind === 'config') configIssues.add(problem.message);
+    deferred.push({ id: booking.id, reference: booking.reference, reason: problem.message });
+  }
+
+  return {
+    plan: openSlots.map((open, index) => ({ ...open.slot, sequenceNo: index + 1 })),
+    fitting,
+    deferred,
+    configIssues: [...configIssues],
+  };
+}
+
+/** Unbounded stock — used to compute pure demand for availability reporting. */
+export function unboundedStock(allowed: AllowedWagonTypeMap): WagonStock {
+  const remainingByTypeId = new Map<string, number>();
+  const codesByTypeId = new Map<string, string>();
+  for (const list of [
+    ...allowed.byContainerTypeId.values(),
+    ...allowed.byCargoTypeId.values(),
+  ]) {
+    for (const wagonType of list) {
+      remainingByTypeId.set(wagonType.id, Number.MAX_SAFE_INTEGER);
+      codesByTypeId.set(wagonType.id, wagonType.code);
+    }
+  }
+  return { mode: 'YARD', remainingByTypeId, codesByTypeId };
+}
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 2af606cdc..78cd8bf54 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
@@ -514,7 +514,7 @@ export function validateTrainLimits(
  */
 export function validateMixedTrainLimits(
   wagonPlan: WagonPlanSlot[],
-  wagonTypes: WagonType[],
+  wagonTypes: Array<Pick<WagonType, 'lengthMeters'>>,
   limits?: TrainLimitConfig,
 ): string[] {
   const maxLengthMeters = limits?.maxLengthMeters ?? MAX_TRAIN_LENGTH_METERS;
diff --git a/apps/edr-freight-api/src/modules/train-sets/entities/train-set.entity.ts b/apps/edr-freight-api/src/modules/train-sets/entities/train-set.entity.ts
index fde6d75c6..c82cfd2eb 100644
--- a/apps/edr-freight-api/src/modules/train-sets/entities/train-set.entity.ts
+++ b/apps/edr-freight-api/src/modules/train-sets/entities/train-set.entity.ts
@@ -2,6 +2,7 @@ import { BaseEntity } from '@edr/api-common';
 import { Column, Entity, Index, JoinColumn, ManyToOne, OneToMany, OneToOne } from 'typeorm';
 
 import { Locomotive } from '../../locomotives/entities/locomotive.entity';
+import { Train } from '../../trains/entities/train.entity';
 import { TrainSchedule } from '../../train-schedules/entities/train-schedule.entity';
 import { TrainSetLocomotive } from './train-set-locomotive.entity';
 import { TrainSetWagon } from './train-set-wagon.entity';
@@ -32,6 +33,14 @@ export class TrainSet extends BaseEntity {
   @OneToMany(() => TrainSetLocomotive, (link) => link.trainSet)
   locomotives?: TrainSetLocomotive[];
 
+  /** Built fleet train this set was formed from (Train Builder), when scheduled by train. */
+  @Column({ name: 'train_id', type: 'uuid', nullable: true })
+  trainId!: string | null;
+
+  @ManyToOne(() => Train, { nullable: true, onDelete: 'SET NULL' })
+  @JoinColumn({ name: 'train_id' })
+  train?: Train | null;
+
   @Column({ name: 'total_weight_tons', type: 'numeric', precision: 10, scale: 3 })
   totalWeightTons!: number;
 
diff --git a/apps/edr-freight-api/src/modules/trains/dto/assign-train-wagons.dto.ts b/apps/edr-freight-api/src/modules/trains/dto/assign-train-wagons.dto.ts
new file mode 100644
index 000000000..e9f150d40
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/trains/dto/assign-train-wagons.dto.ts
@@ -0,0 +1,14 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { ArrayMinSize, IsArray, IsUUID } from 'class-validator';
+
+export class AssignTrainWagonsDto {
+  @ApiProperty({
+    type: [String],
+    format: 'uuid',
+    description: 'Wagons to append to the consist, in order. Each must be AVAILABLE in the train\'s yard.',
+  })
+  @IsArray()
+  @ArrayMinSize(1)
+  @IsUUID('all', { each: true })
+  wagonIds!: string[];
+}
diff --git a/apps/edr-freight-api/src/modules/trains/dto/build-train.dto.ts b/apps/edr-freight-api/src/modules/trains/dto/build-train.dto.ts
new file mode 100644
index 000000000..c44be8786
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/trains/dto/build-train.dto.ts
@@ -0,0 +1,51 @@
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+import {
+  ArrayMinSize,
+  IsArray,
+  IsOptional,
+  IsString,
+  IsUUID,
+  MaxLength,
+} from 'class-validator';
+
+export class BuildTrainDto {
+  @ApiProperty({ example: '81001', description: 'Operator-assigned train code (unique)' })
+  @IsString()
+  @MaxLength(32)
+  code!: string;
+
+  @ApiProperty({ format: 'uuid', description: 'Yard the train is built in' })
+  @IsUUID()
+  currentYardId!: string;
+
+  @ApiProperty({
+    type: [String],
+    format: 'uuid',
+    description: 'Locomotives pulling the train (minimum 2 — front and back), in consist order',
+  })
+  @IsArray()
+  @ArrayMinSize(2, { message: 'A train must be pulled by at least two locomotives' })
+  @IsUUID('all', { each: true })
+  locomotiveIds!: string[];
+
+  @ApiPropertyOptional({
+    type: [String],
+    format: 'uuid',
+    description: 'Wagons to attach at build time, in consist order (must sit in the same yard)',
+  })
+  @IsOptional()
+  @IsArray()
+  @IsUUID('all', { each: true })
+  wagonIds?: string[];
+
+  @ApiPropertyOptional({ maxLength: 100 })
+  @IsOptional()
+  @IsString()
+  @MaxLength(100)
+  trainName?: string;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsString()
+  notes?: string;
+}
diff --git a/apps/edr-freight-api/src/modules/trains/dto/list-built-trains-query.dto.ts b/apps/edr-freight-api/src/modules/trains/dto/list-built-trains-query.dto.ts
new file mode 100644
index 000000000..4c2e259a8
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/trains/dto/list-built-trains-query.dto.ts
@@ -0,0 +1,22 @@
+import { Freight } from '@edr/types';
+import { ApiPropertyOptional } from '@nestjs/swagger';
+import { IsEnum, IsIn, IsOptional, IsUUID } from 'class-validator';
+
+import { PaginationQueryDto } from '../../../common/dto/pagination-query.dto';
+
+export class ListBuiltTrainsQueryDto extends PaginationQueryDto {
+  @ApiPropertyOptional({ enum: Freight.TrainStatus })
+  @IsOptional()
+  @IsEnum(Freight.TrainStatus)
+  status?: Freight.TrainStatus;
+
+  @ApiPropertyOptional({ format: 'uuid', description: 'Only trains sitting in this yard' })
+  @IsOptional()
+  @IsUUID()
+  currentYardId?: string;
+
+  @ApiPropertyOptional({ enum: ['code', 'trainName', 'status', 'createdAt'] })
+  @IsOptional()
+  @IsIn(['code', 'trainName', 'status', 'createdAt'])
+  sortBy?: 'code' | 'trainName' | 'status' | 'createdAt';
+}
diff --git a/apps/edr-freight-api/src/modules/trains/dto/reorder-train-wagons.dto.ts b/apps/edr-freight-api/src/modules/trains/dto/reorder-train-wagons.dto.ts
new file mode 100644
index 000000000..15e5020ca
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/trains/dto/reorder-train-wagons.dto.ts
@@ -0,0 +1,14 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { ArrayMinSize, IsArray, IsUUID } from 'class-validator';
+
+export class ReorderTrainWagonsDto {
+  @ApiProperty({
+    type: [String],
+    format: 'uuid',
+    description: 'Every wagon of the train, in the new consist order',
+  })
+  @IsArray()
+  @ArrayMinSize(1)
+  @IsUUID('all', { each: true })
+  wagonIds!: string[];
+}
diff --git a/apps/edr-freight-api/src/modules/trains/dto/update-train-locomotives.dto.ts b/apps/edr-freight-api/src/modules/trains/dto/update-train-locomotives.dto.ts
new file mode 100644
index 000000000..36562e970
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/trains/dto/update-train-locomotives.dto.ts
@@ -0,0 +1,14 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { ArrayMinSize, IsArray, IsUUID } from 'class-validator';
+
+export class UpdateTrainLocomotivesDto {
+  @ApiProperty({
+    type: [String],
+    format: 'uuid',
+    description: 'Full replacement locomotive set (minimum 2), in consist order',
+  })
+  @IsArray()
+  @ArrayMinSize(2, { message: 'A train must be pulled by at least two locomotives' })
+  @IsUUID('all', { each: true })
+  locomotiveIds!: string[];
+}
diff --git a/apps/edr-freight-api/src/modules/trains/dto/update-train-yard.dto.ts b/apps/edr-freight-api/src/modules/trains/dto/update-train-yard.dto.ts
new file mode 100644
index 000000000..428651288
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/trains/dto/update-train-yard.dto.ts
@@ -0,0 +1,12 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { IsUUID } from 'class-validator';
+
+export class UpdateTrainYardDto {
+  @ApiProperty({
+    format: 'uuid',
+    description:
+      'Yard the train now sits in. The coupled locomotives and wagons are relocated with it.',
+  })
+  @IsUUID()
+  currentYardId!: string;
+}
diff --git a/apps/edr-freight-api/src/modules/trains/entities/train-locomotive.entity.ts b/apps/edr-freight-api/src/modules/trains/entities/train-locomotive.entity.ts
new file mode 100644
index 000000000..681b39a55
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/trains/entities/train-locomotive.entity.ts
@@ -0,0 +1,34 @@
+import { BaseEntity } from '@edr/api-common';
+import { Column, Entity, Index, JoinColumn, ManyToOne } from 'typeorm';
+
+import { Locomotive } from '../../locomotives/entities/locomotive.entity';
+import { Train } from './train.entity';
+
+/**
+ * Link row joining a built train to one of its locomotives. A train must be
+ * pulled by at least two locomotives (front + back); `sequenceNo` is the order
+ * in the consist — 0 is the lead locomotive.
+ *
+ * Mirrors `train_set_locomotives`, but for the persistent fleet `Train` built
+ * in the Train Builder rather than the per-departure operational train set.
+ */
+@Entity({ schema: 'freight', name: 'train_locomotives' })
+@Index(['trainId', 'locomotiveId'], { unique: true })
+export class TrainLocomotive extends BaseEntity {
+  @Column({ name: 'train_id', type: 'uuid' })
+  trainId!: string;
+
+  @ManyToOne(() => Train, (train) => train.locomotives, { onDelete: 'CASCADE' })
+  @JoinColumn({ name: 'train_id' })
+  train?: Train;
+
+  @Column({ name: 'locomotive_id', type: 'uuid' })
+  locomotiveId!: string;
+
+  @ManyToOne(() => Locomotive)
+  @JoinColumn({ name: 'locomotive_id' })
+  locomotive?: Locomotive;
+
+  @Column({ name: 'sequence_no', type: 'int', default: 0 })
+  sequenceNo!: number;
+}
diff --git a/apps/edr-freight-api/src/modules/trains/entities/train.entity.ts b/apps/edr-freight-api/src/modules/trains/entities/train.entity.ts
index ab6b49b1d..078b07a20 100644
--- a/apps/edr-freight-api/src/modules/trains/entities/train.entity.ts
+++ b/apps/edr-freight-api/src/modules/trains/entities/train.entity.ts
@@ -1,12 +1,16 @@
 // apps/edr-freight-api/src/modules/trains/entities/train.entity.ts
 import { BaseEntity } from '@edr/api-common';
 import { Freight } from '@edr/types';
-import { Column, Entity, OneToMany } from 'typeorm';
+import { Column, Entity, JoinColumn, ManyToOne, OneToMany } from 'typeorm';
+import { Yard } from '../../rule-engine/entities/yard.entity';
 import { Wagon } from '../../wagons/entities/wagon.entity';
+import { TrainLocomotive } from './train-locomotive.entity';
 
 /**
- * Fleet master data — named wagon consist in inventory (POST /trains).
- * Operational departures use train_schedules + locomotives; scheduling never creates trains rows.
+ * Fleet master data — a train built in the Train Builder: a coded consist
+ * (e.g. 81001) of 2+ locomotives and ordered wagons, assembled in one yard.
+ * Operational departures reference it through `train_sets.train_id`; the
+ * schedule's own composition still lives on the train set.
  */
 @Entity({ schema: 'freight', name: 'trains' })
 export class Train extends BaseEntity {
@@ -56,7 +60,19 @@ export class Train extends BaseEntity {
   @Column({ name: 'remarks', type: 'text', nullable: true })
   remarks?: string;
 
+  /** Yard where the train currently sits (set at build, moved on schedule arrival). */
+  @Column({ name: 'current_yard_id', type: 'uuid', nullable: true })
+  currentYardId!: string | null;
+
+  @ManyToOne(() => Yard, { nullable: true, onDelete: 'SET NULL' })
+  @JoinColumn({ name: 'current_yard_id' })
+  currentYard?: Yard | null;
+
   // --- relationships ---
-   @OneToMany(() => Wagon, (wagon) => wagon.train)
-  wagons!: Wagon[];  // fixed typo: was 'wagens'
+  @OneToMany(() => Wagon, (wagon) => wagon.train)
+  wagons!: Wagon[];
+
+  /** Locomotives pulling this train (minimum 2), ordered by sequenceNo. */
+  @OneToMany(() => TrainLocomotive, (link) => link.train)
+  locomotives?: TrainLocomotive[];
 }
\ No newline at end of file
diff --git a/apps/edr-freight-api/src/modules/trains/train-builder.controller.ts b/apps/edr-freight-api/src/modules/trains/train-builder.controller.ts
new file mode 100644
index 000000000..7ed3e4c42
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/trains/train-builder.controller.ts
@@ -0,0 +1,102 @@
+import {
+  Body,
+  Controller,
+  Delete,
+  Get,
+  HttpCode,
+  HttpStatus,
+  Param,
+  ParseUUIDPipe,
+  Patch,
+  Post,
+  Put,
+  Query,
+} from '@nestjs/common';
+import { ApiBearerAuth, ApiOperation, ApiTags } from '@nestjs/swagger';
+
+import { FleetManage, FleetView } from '../../common/booking-guards';
+import { AssignTrainWagonsDto } from './dto/assign-train-wagons.dto';
+import { BuildTrainDto } from './dto/build-train.dto';
+import { ListBuiltTrainsQueryDto } from './dto/list-built-trains-query.dto';
+import { ReorderTrainWagonsDto } from './dto/reorder-train-wagons.dto';
+import { UpdateTrainLocomotivesDto } from './dto/update-train-locomotives.dto';
+import { UpdateTrainYardDto } from './dto/update-train-yard.dto';
+import { TrainBuilderService } from './train-builder.service';
+
+@ApiTags('train-builder')
+@ApiBearerAuth()
+@Controller('train-builder')
+@FleetView()
+export class TrainBuilderController {
+  constructor(private readonly trainBuilderService: TrainBuilderService) {}
+
+  @Post()
+  @FleetManage()
+  @ApiOperation({ summary: 'Build a train: code + yard + 2+ locomotives (+ optional wagons)' })
+  build(@Body() dto: BuildTrainDto) {
+    return this.trainBuilderService.buildTrain(dto);
+  }
+
+  @Get()
+  @ApiOperation({ summary: 'Paginated built trains with composition summary' })
+  list(@Query() query: ListBuiltTrainsQueryDto) {
+    return this.trainBuilderService.listBuilt(query);
+  }
+
+  @Get(':id')
+  @ApiOperation({ summary: 'Full train composition: locomotives, ordered wagons, totals vs. limits' })
+  composition(@Param('id', ParseUUIDPipe) id: string) {
+    return this.trainBuilderService.getComposition(id);
+  }
+
+  @Put(':id/locomotives')
+  @FleetManage()
+  @ApiOperation({ summary: 'Replace the locomotive set (minimum 2, same yard)' })
+  setLocomotives(
+    @Param('id', ParseUUIDPipe) id: string,
+    @Body() dto: UpdateTrainLocomotivesDto,
+  ) {
+    return this.trainBuilderService.setLocomotives(id, dto);
+  }
+
+  @Patch(':id/yard')
+  @FleetManage()
+  @ApiOperation({
+    summary: 'Relocate the train — its locomotives and wagons move to the new yard with it',
+  })
+  setYard(@Param('id', ParseUUIDPipe) id: string, @Body() dto: UpdateTrainYardDto) {
+    return this.trainBuilderService.setYard(id, dto.currentYardId);
+  }
+
+  @Post(':id/wagons')
+  @FleetManage()
+  @ApiOperation({ summary: "Append AVAILABLE wagons from the train's yard to the consist" })
+  assignWagons(@Param('id', ParseUUIDPipe) id: string, @Body() dto: AssignTrainWagonsDto) {
+    return this.trainBuilderService.assignWagons(id, dto);
+  }
+
+  @Delete(':id/wagons/:wagonId')
+  @FleetManage()
+  @ApiOperation({ summary: 'Detach one wagon from the consist' })
+  removeWagon(
+    @Param('id', ParseUUIDPipe) id: string,
+    @Param('wagonId', ParseUUIDPipe) wagonId: string,
+  ) {
+    return this.trainBuilderService.removeWagon(id, wagonId);
+  }
+
+  @Post(':id/reorder-wagons')
+  @FleetManage()
+  @ApiOperation({ summary: 'Persist a drag-reorder of the full consist' })
+  reorderWagons(@Param('id', ParseUUIDPipe) id: string, @Body() dto: ReorderTrainWagonsDto) {
+    return this.trainBuilderService.reorderWagons(id, dto);
+  }
+
+  @Delete(':id')
+  @FleetManage()
+  @HttpCode(HttpStatus.NO_CONTENT)
+  @ApiOperation({ summary: 'Disband the train (release wagons and locomotives)' })
+  disband(@Param('id', ParseUUIDPipe) id: string) {
+    return this.trainBuilderService.disband(id);
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/trains/train-builder.service.ts b/apps/edr-freight-api/src/modules/trains/train-builder.service.ts
new file mode 100644
index 000000000..16ff29d38
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/trains/train-builder.service.ts
@@ -0,0 +1,619 @@
+import { Freight, WagonMovementKind, WagonStatus } from '@edr/types';
+import {
+  BadRequestException,
+  ConflictException,
+  Injectable,
+  NotFoundException,
+} from '@nestjs/common';
+import { DataSource, EntityManager, ILike, In } from 'typeorm';
+
+import { Locomotive } from '../locomotives/entities/locomotive.entity';
+import { Yard } from '../rule-engine/entities/yard.entity';
+import { minLocomotiveLimits } from '../train-scheduling/train-capacity.util';
+import { WagonType } from '../wagon-types/entities/wagon-type.entity';
+import { WagonMovement } from '../wagons/entities/wagon-movement.entity';
+import { Wagon } from '../wagons/entities/wagon.entity';
+import { AssignTrainWagonsDto } from './dto/assign-train-wagons.dto';
+import { BuildTrainDto } from './dto/build-train.dto';
+import { ListBuiltTrainsQueryDto } from './dto/list-built-trains-query.dto';
+import { ReorderTrainWagonsDto } from './dto/reorder-train-wagons.dto';
+import { UpdateTrainLocomotivesDto } from './dto/update-train-locomotives.dto';
+import { TrainLocomotive } from './entities/train-locomotive.entity';
+import { Train } from './entities/train.entity';
+import {
+  buildPaginationMeta,
+  normalizePagination,
+} from '../../common/utils/pagination.util';
+
+const round = (value: unknown) => Math.round((Number(value) || 0) * 100) / 100;
+
+/**
+ * Train Builder — assembles persistent fleet trains (code + 2+ locomotives +
+ * ordered wagons, all in one yard) that scheduling can later reference as a
+ * unit instead of hand-picking locomotives per departure.
+ *
+ * Resource rules:
+ * - Locomotive double-use is prevented through the `train_locomotives` link
+ *   table (a locomotive rides at most one built train); its `status` column
+ *   keeps its operational meaning (ASSIGNED = out on a dispatched train).
+ * - Wagons attached to a train are flipped to ASSIGNED (same semantic the
+ *   legacy assign-train flow uses), so no other train or schedule grabs them.
+ */
+@Injectable()
+export class TrainBuilderService {
+  constructor(private readonly dataSource: DataSource) {}
+
+  async buildTrain(dto: BuildTrainDto) {
+    const locomotiveIds = [...new Set(dto.locomotiveIds)];
+    if (locomotiveIds.length < 2) {
+      throw new BadRequestException('A train must be pulled by at least two locomotives');
+    }
+
+    const trainId = await this.dataSource.transaction(async (manager) => {
+      const code = dto.code.trim();
+      const existing = await manager.getRepository(Train).findOne({ where: { code } });
+      if (existing) {
+        throw new ConflictException(`Train code ${code} is already in use`);
+      }
+
+      const yard = await manager.getRepository(Yard).findOne({ where: { id: dto.currentYardId } });
+      if (!yard) throw new NotFoundException(`Yard ${dto.currentYardId} not found`);
+
+      const locomotives = await this.validateAndLockLocomotives(
+        manager,
+        locomotiveIds,
+        yard,
+        null,
+      );
+
+      // Effective haul capacity is capped by the weakest locomotive in the set.
+      const limits = minLocomotiveLimits(locomotives);
+      const train = await manager.getRepository(Train).save(
+        manager.getRepository(Train).create({
+          code,
+          currentYardId: yard.id,
+          capacityTons: round(limits?.maxPullWeightTons ?? 0),
+          status: Freight.TrainStatus.Available,
+          trainName: dto.trainName?.trim() || undefined,
+          notes: dto.notes?.trim() || undefined,
+        }),
+      );
+
+      await this.replaceLocomotiveLinks(manager, train.id, locomotiveIds);
+
+      if (dto.wagonIds?.length) {
+        await this.attachWagons(manager, train, dto.wagonIds, 0);
+      }
+      return train.id;
+    });
+
+    return this.getComposition(trainId);
+  }
+
+  /** Paginated builder list with a composition summary per train. */
+  async listBuilt(query: ListBuiltTrainsQueryDto) {
+    const { page, pageSize, skip, take } = normalizePagination(query);
+    const search = query.search?.trim();
+    const filters = {
+      ...(query.status ? { status: query.status } : {}),
+      ...(query.currentYardId ? { currentYardId: query.currentYardId } : {}),
+    };
+    const where = search
+      ? [
+          { ...filters, code: ILike(`%${search}%`) },
+          { ...filters, trainName: ILike(`%${search}%`) },
+        ]
+      : filters;
+
+    const [trains, total] = await this.dataSource.getRepository(Train).findAndCount({
+      where,
+      relations: {
+        currentYard: true,
+        locomotives: { locomotive: true },
+        wagons: { wagonType: true },
+      },
+      order: { [query.sortBy ?? 'createdAt']: query.sortOrder ?? 'DESC' },
+      skip,
+      take,
+    });
+
+    return {
+      items: trains.map((train) => this.mapSummary(train)),
+      meta: buildPaginationMeta(total, page, pageSize),
+    };
+  }
+
+  /** Full consist: yard, ordered locomotives + wagons, totals vs. haul limits. */
+  async getComposition(id: string) {
+    const train = await this.dataSource.getRepository(Train).findOne({
+      where: { id },
+      relations: {
+        currentYard: true,
+        locomotives: { locomotive: { currentYard: true } },
+        wagons: { wagonType: true, currentYard: true },
+      },
+      order: {
+        locomotives: { sequenceNo: 'ASC' },
+        wagons: { sequenceNumber: 'ASC' },
+      },
+    });
+    if (!train) throw new NotFoundException(`Train ${id} not found`);
+
+    const schedules: { id: string; status: string; reference: string | null }[] =
+      await this.dataSource.query(
+        `SELECT ts.id, ts.status, ts.reference
+           FROM freight.train_schedules ts
+           JOIN freight.train_sets tset ON tset.id = ts.train_set_id
+          WHERE tset.train_id = $1
+            AND ts.deleted_at IS NULL
+            AND ts.status IN ('DRAFT', 'SCHEDULED', 'DISPATCHED')
+          ORDER BY ts.scheduled_departure_date ASC`,
+        [id],
+      );
+
+    const locomotives = (train.locomotives ?? [])
+      .filter((link) => link.locomotive)
+      .map((link, index) => ({
+        id: link.locomotive!.id,
+        code: link.locomotive!.code,
+        name: link.locomotive!.name ?? null,
+        locomotiveType: link.locomotive!.locomotiveType,
+        status: link.locomotive!.status,
+        sequenceNo: link.sequenceNo,
+        role: index === 0 ? 'LEAD' : 'ASSIST',
+        currentYardId: link.locomotive!.currentYardId ?? null,
+        currentYard: link.locomotive!.currentYard
+          ? {
+              id: link.locomotive!.currentYard.id,
+              code: link.locomotive!.currentYard.code,
+              label: link.locomotive!.currentYard.label,
+            }
+          : null,
+        maxPullWeightTons: round(link.locomotive!.maxPullWeightTons),
+        maxTrainLengthMeters: round(link.locomotive!.maxTrainLengthMeters),
+      }));
+
+    const wagons = (train.wagons ?? []).map((wagon) => ({
+      id: wagon.id,
+      wagonNumber: wagon.wagonNumber,
+      sequenceNumber: wagon.sequenceNumber,
+      status: wagon.status,
+      wagonType: wagon.wagonType
+        ? {
+            id: wagon.wagonType.id,
+            code: wagon.wagonType.code,
+            name: wagon.wagonType.name,
+            capacityTons: round(wagon.wagonType.capacityTons),
+            tareWeightTons: round(wagon.wagonType.tareWeightTons),
+            lengthMeters: round(wagon.wagonType.lengthMeters),
+          }
+        : null,
+    }));
+
+    const limits = minLocomotiveLimits(
+      (train.locomotives ?? [])
+        .map((link) => link.locomotive)
+        .filter((loco): loco is Locomotive => Boolean(loco)),
+    );
+    const totalTareTons = round(
+      wagons.reduce((sum, w) => sum + (w.wagonType?.tareWeightTons ?? 0), 0),
+    );
+    const totalCapacityTons = round(
+      wagons.reduce((sum, w) => sum + (w.wagonType?.capacityTons ?? 0), 0),
+    );
+    const totalLengthMeters = round(
+      wagons.reduce((sum, w) => sum + (w.wagonType?.lengthMeters ?? 0), 0),
+    );
+    const maxPullWeightTons = round(limits?.maxPullWeightTons ?? 0);
+    const maxTrainLengthMeters = round(limits?.maxTrainLengthMeters ?? 0);
+
+    return {
+      id: train.id,
+      code: train.code,
+      trainName: train.trainName ?? null,
+      status: train.status,
+      notes: train.notes ?? null,
+      createdAt: train.createdAt,
+      currentYard: train.currentYard
+        ? { id: train.currentYard.id, code: train.currentYard.code, label: train.currentYard.label }
+        : null,
+      locomotives,
+      wagons,
+      totals: {
+        wagonCount: wagons.length,
+        totalTareTons,
+        // Informational only — building never checks against full capacity;
+        // the real gross check (cargo + tare vs haul limit) runs at allocation.
+        totalCapacityTons,
+        totalLengthMeters,
+        maxPullWeightTons,
+        maxTrainLengthMeters,
+        // Cargo the locomotives can still haul once pulling the empty consist.
+        payloadCapacityTons: round(Math.max(0, maxPullWeightTons - totalTareTons)),
+        // Share of the haul limit consumed by the empty wagons alone.
+        tareUtilizationPct: maxPullWeightTons
+          ? round((totalTareTons / maxPullWeightTons) * 100)
+          : null,
+        lengthUtilizationPct: maxTrainLengthMeters
+          ? round((totalLengthMeters / maxTrainLengthMeters) * 100)
+          : null,
+      },
+      activeSchedules: schedules,
+      // Composition is frozen while the train is out on a dispatched run.
+      editable: !schedules.some((s) => s.status === 'DISPATCHED'),
+    };
+  }
+
+  /** Replace the locomotive set (still minimum 2, same-yard rule applies). */
+  async setLocomotives(id: string, dto: UpdateTrainLocomotivesDto) {
+    const locomotiveIds = [...new Set(dto.locomotiveIds)];
+    if (locomotiveIds.length < 2) {
+      throw new BadRequestException('A train must be pulled by at least two locomotives');
+    }
+    await this.dataSource.transaction(async (manager) => {
+      const train = await this.getEditableTrain(manager, id);
+      const yard = await manager
+        .getRepository(Yard)
+        .findOne({ where: { id: train.currentYardId ?? '' } });
+      if (!yard) {
+        throw new BadRequestException('Train has no yard; set the yard before changing locomotives');
+      }
+      const locomotives = await this.validateAndLockLocomotives(
+        manager,
+        locomotiveIds,
+        yard,
+        train.id,
+      );
+      await this.replaceLocomotiveLinks(manager, train.id, locomotiveIds);
+      const limits = minLocomotiveLimits(locomotives);
+      await manager
+        .getRepository(Train)
+        .update(train.id, { capacityTons: round(limits?.maxPullWeightTons ?? 0) });
+    });
+    return this.getComposition(id);
+  }
+
+  /**
+   * Relocate the train to another yard. The consist moves as one unit: every
+   * coupled locomotive and wagon follows to the new yard (so their current
+   * yards always match the train's), and each wagon gets a movement-ledger row.
+   * Blocked while the train is out on a dispatched run.
+   */
+  async setYard(id: string, currentYardId: string) {
+    await this.dataSource.transaction(async (manager) => {
+      const train = await this.getEditableTrain(manager, id);
+      if (train.currentYardId === currentYardId) return;
+      const yard = await manager.getRepository(Yard).findOne({ where: { id: currentYardId } });
+      if (!yard) throw new NotFoundException(`Yard ${currentYardId} not found`);
+
+      await manager.getRepository(Train).update(train.id, { currentYardId: yard.id });
+
+      const links = await manager
+        .getRepository(TrainLocomotive)
+        .find({ where: { trainId: train.id } });
+      if (links.length) {
+        await manager
+          .getRepository(Locomotive)
+          .update(
+            { id: In(links.map((link) => link.locomotiveId)) },
+            { currentYardId: yard.id },
+          );
+      }
+
+      const wagons = await manager.getRepository(Wagon).find({ where: { trainId: train.id } });
+      const now = new Date();
+      for (const wagon of wagons) {
+        if (wagon.currentYardId === yard.id) continue;
+        await manager.getRepository(Wagon).update(wagon.id, { currentYardId: yard.id });
+        // Ledger row keeps the wagon's yard history auditable (mirrors the
+        // manual-relocation path in the wagons service).
+        await manager.getRepository(WagonMovement).save(
+          manager.getRepository(WagonMovement).create({
+            wagonId: wagon.id,
+            fromYardId: wagon.currentYardId ?? null,
+            toYardId: yard.id,
+            kind: WagonMovementKind.Manual,
+            occurredAt: now,
+          }),
+        );
+      }
+    });
+    return this.getComposition(id);
+  }
+
+  /** Append AVAILABLE wagons from the train's own yard to the consist. */
+  async assignWagons(id: string, dto: AssignTrainWagonsDto) {
+    await this.dataSource.transaction(async (manager) => {
+      const train = await this.getEditableTrain(manager, id);
+      const currentCount = await manager
+        .getRepository(Wagon)
+        .count({ where: { trainId: train.id } });
+      await this.attachWagons(manager, train, dto.wagonIds, currentCount);
+    });
+    return this.getComposition(id);
+  }
+
+  /** Detach one wagon and close the sequence gap it leaves. */
+  async removeWagon(id: string, wagonId: string) {
+    await this.dataSource.transaction(async (manager) => {
+      const train = await this.getEditableTrain(manager, id);
+      const wagon = await manager.getRepository(Wagon).findOne({ where: { id: wagonId } });
+      if (!wagon || wagon.trainId !== train.id) {
+        throw new NotFoundException(`Wagon ${wagonId} is not part of this train`);
+      }
+      if (wagon.currentTrainScheduleId) {
+        throw new ConflictException(
+          `Wagon ${wagon.wagonNumber} is pinned to an active schedule and cannot be removed`,
+        );
+      }
+      await manager.getRepository(Wagon).update(wagon.id, {
+        trainId: null,
+        sequenceNumber: null,
+        status: WagonStatus.Available,
+      });
+      await this.resequenceWagons(manager, train.id);
+    });
+    return this.getComposition(id);
+  }
+
+  /** Persist a drag-reorder: `wagonIds` is the full consist in its new order. */
+  async reorderWagons(id: string, dto: ReorderTrainWagonsDto) {
+    await this.dataSource.transaction(async (manager) => {
+      const train = await this.getEditableTrain(manager, id);
+      const wagons = await manager
+        .getRepository(Wagon)
+        .find({ where: { trainId: train.id } });
+      const current = new Set(wagons.map((w) => w.id));
+      const incoming = new Set(dto.wagonIds);
+      if (current.size !== incoming.size || [...current].some((wid) => !incoming.has(wid))) {
+        throw new BadRequestException('Reorder must include every wagon of the train exactly once');
+      }
+      for (let i = 0; i < dto.wagonIds.length; i++) {
+        await manager.getRepository(Wagon).update(dto.wagonIds[i], { sequenceNumber: i + 1 });
+      }
+    });
+    return this.getComposition(id);
+  }
+
+  /** Disband the train: release wagons and locomotives, then delete it. */
+  async disband(id: string): Promise<void> {
+    await this.dataSource.transaction(async (manager) => {
+      const train = await manager.getRepository(Train).findOne({ where: { id } });
+      if (!train) throw new NotFoundException(`Train ${id} not found`);
+      const active: { count: string }[] = await manager.query(
+        `SELECT COUNT(*)::text AS count
+           FROM freight.train_schedules ts
+           JOIN freight.train_sets tset ON tset.id = ts.train_set_id
+          WHERE tset.train_id = $1
+            AND ts.deleted_at IS NULL
+            AND ts.status IN ('DRAFT', 'SCHEDULED', 'DISPATCHED')`,
+        [id],
+      );
+      if (Number(active[0]?.count ?? 0) > 0) {
+        throw new ConflictException(
+          'Train has active schedules; cancel them before disbanding the train',
+        );
+      }
+      await manager
+        .getRepository(Wagon)
+        .update(
+          { trainId: train.id },
+          { trainId: null, sequenceNumber: null, status: WagonStatus.Available },
+        );
+      await manager.getRepository(TrainLocomotive).delete({ trainId: train.id });
+      await manager.getRepository(Train).remove(train);
+    });
+  }
+
+  // ---------------------------------------------------------------- internals
+
+  private mapSummary(train: Train) {
+    const locomotives = [...(train.locomotives ?? [])]
+      .sort((a, b) => a.sequenceNo - b.sequenceNo)
+      .map((link) => link.locomotive)
+      .filter((loco): loco is Locomotive => Boolean(loco));
+    const wagons = train.wagons ?? [];
+    const totalTareTons = round(
+      wagons.reduce((sum, w) => sum + (Number(w.wagonType?.tareWeightTons) || 0), 0),
+    );
+    return {
+      id: train.id,
+      code: train.code,
+      trainName: train.trainName ?? null,
+      status: train.status,
+      createdAt: train.createdAt,
+      currentYard: train.currentYard
+        ? { id: train.currentYard.id, code: train.currentYard.code, label: train.currentYard.label }
+        : null,
+      locomotives: locomotives.map((loco) => ({ id: loco.id, code: loco.code, name: loco.name ?? null })),
+      wagonCount: wagons.length,
+      totalTareTons,
+      totalLengthMeters: round(
+        wagons.reduce((sum, w) => sum + (Number(w.wagonType?.lengthMeters) || 0), 0),
+      ),
+      maxPullWeightTons: round(train.capacityTons),
+    };
+  }
+
+  /** Load + freeze the train row for edit; block edits while it is out on a run. */
+  private async getEditableTrain(manager: EntityManager, id: string): Promise<Train> {
+    const train = await manager.getRepository(Train).findOne({
+      where: { id },
+      lock: { mode: 'pessimistic_write' },
+    });
+    if (!train) throw new NotFoundException(`Train ${id} not found`);
+    if (train.status === Freight.TrainStatus.InService) {
+      throw new ConflictException(
+        `Train ${train.code} is out on a dispatched run; its composition is frozen until arrival`,
+      );
+    }
+    return train;
+  }
+
+  /**
+   * Lock and validate the locomotives for a build/replace: each must exist, be
+   * serviceable, sit in the train's yard, and not ride another built train.
+   */
+  private async validateAndLockLocomotives(
+    manager: EntityManager,
+    locomotiveIds: string[],
+    yard: Yard,
+    ownTrainId: string | null,
+  ): Promise<Locomotive[]> {
+    const locomotives: Locomotive[] = [];
+    for (const locomotiveId of locomotiveIds) {
+      const locked = await manager.getRepository(Locomotive).findOne({
+        where: { id: locomotiveId },
+        lock: { mode: 'pessimistic_write' },
+      });
+      if (!locked) throw new NotFoundException(`Locomotive ${locomotiveId} not found`);
+      if (locked.status === 'OUT_OF_SERVICE' || locked.status === 'MAINTENANCE') {
+        throw new ConflictException(`Locomotive ${locked.code} is ${locked.status.toLowerCase().replace('_', ' ')}`);
+      }
+      if (locked.currentYardId !== yard.id) {
+        throw new BadRequestException(
+          `Locomotive ${locked.code} is not in yard ${yard.label ?? yard.code}; a train can only be built from locomotives in its own yard`,
+        );
+      }
+      locomotives.push(locked);
+    }
+
+    const taken = await manager.getRepository(TrainLocomotive).find({
+      where: { locomotiveId: In(locomotiveIds) },
+      relations: { train: true },
+    });
+    const conflict = taken.find((link) => link.trainId !== ownTrainId);
+    if (conflict) {
+      const loco = locomotives.find((l) => l.id === conflict.locomotiveId);
+      throw new ConflictException(
+        `Locomotive ${loco?.code ?? conflict.locomotiveId} is already coupled to train ${conflict.train?.code ?? conflict.trainId}`,
+      );
+    }
+    return locomotives;
+  }
+
+  private async replaceLocomotiveLinks(
+    manager: EntityManager,
+    trainId: string,
+    locomotiveIds: string[],
+  ): Promise<void> {
+    await manager.getRepository(TrainLocomotive).delete({ trainId });
+    await manager.getRepository(TrainLocomotive).save(
+      locomotiveIds.map((locomotiveId, index) =>
+        manager.getRepository(TrainLocomotive).create({ trainId, locomotiveId, sequenceNo: index }),
+      ),
+    );
+  }
+
+  private async attachWagons(
+    manager: EntityManager,
+    train: Train,
+    wagonIds: string[],
+    startCount: number,
+  ): Promise<void> {
+    const uniqueIds = [...new Set(wagonIds)];
+    const wagonRepo = manager.getRepository(Wagon);
+
+    // First pass: lock + validate every wagon so the length gate below sees
+    // the full incoming set before any row is written.
+    const toAttach: Wagon[] = [];
+    for (const wagonId of uniqueIds) {
+      const wagon = await wagonRepo.findOne({
+        where: { id: wagonId },
+        lock: { mode: 'pessimistic_write' },
+      });
+      if (!wagon) throw new NotFoundException(`Wagon ${wagonId} not found`);
+      if (wagon.trainId === train.id) continue;
+      if (wagon.trainId) {
+        throw new ConflictException(`Wagon ${wagon.wagonNumber} is already on another train`);
+      }
+      if (wagon.status !== WagonStatus.Available) {
+        throw new ConflictException(`Wagon ${wagon.wagonNumber} is not available (${wagon.status})`);
+      }
+      if (wagon.currentYardId !== train.currentYardId) {
+        throw new BadRequestException(
+          `Wagon ${wagon.wagonNumber} is not in the train's yard; only wagons in the same yard can be attached`,
+        );
+      }
+      toAttach.push(wagon);
+    }
+    if (!toAttach.length) return;
+
+    await this.assertConsistLengthWithinLimit(manager, train, toAttach);
+
+    let sequence = startCount;
+    for (const wagon of toAttach) {
+      sequence += 1;
+      await wagonRepo.update(wagon.id, {
+        trainId: train.id,
+        sequenceNumber: sequence,
+        status: WagonStatus.Assigned,
+      });
+    }
+  }
+
+  /**
+   * The consist (already-attached wagons + the incoming ones) must fit the
+   * train's locomotive length limit — the weakest locomotive of the set caps
+   * the train, mirroring how scheduling derives capacity.
+   */
+  private async assertConsistLengthWithinLimit(
+    manager: EntityManager,
+    train: Train,
+    incoming: Wagon[],
+  ): Promise<void> {
+    const links = await manager.getRepository(TrainLocomotive).find({
+      where: { trainId: train.id },
+      relations: { locomotive: true },
+    });
+    const limits = minLocomotiveLimits(
+      links
+        .map((link) => link.locomotive)
+        .filter((loco): loco is Locomotive => Boolean(loco)),
+    );
+    const maxLengthMeters = Number(limits?.maxTrainLengthMeters ?? 0);
+    if (!Number.isFinite(maxLengthMeters) || maxLengthMeters <= 0) return;
+
+    const existing = await manager.getRepository(Wagon).find({
+      where: { trainId: train.id },
+      relations: { wagonType: true },
+    });
+    const currentLength = existing.reduce(
+      (sum, w) => sum + (Number(w.wagonType?.lengthMeters) || 0),
+      0,
+    );
+
+    const typeIds = [...new Set(incoming.map((w) => w.wagonTypeId).filter(Boolean))];
+    const types = typeIds.length
+      ? await manager.getRepository(WagonType).find({ where: { id: In(typeIds) } })
+      : [];
+    const lengthByType = new Map(types.map((t) => [t.id, Number(t.lengthMeters) || 0]));
+    const addedLength = incoming.reduce(
+      (sum, w) => sum + (lengthByType.get(w.wagonTypeId) ?? 0),
+      0,
+    );
+
+    const totalLength = currentLength + addedLength;
+    if (totalLength > maxLengthMeters) {
+      throw new BadRequestException(
+        `Cannot attach wagons — train length would be ${round(totalLength)} m ` +
+          `(current ${round(currentLength)} m + ${round(addedLength)} m added), ` +
+          `over the locomotive limit of ${round(maxLengthMeters)} m. ` +
+          'Remove wagons from the consist or use locomotives with a higher length limit.',
+      );
+    }
+  }
+
+  /** Compact wagon sequence numbers back to 1..n after a removal. */
+  private async resequenceWagons(manager: EntityManager, trainId: string): Promise<void> {
+    const wagons = await manager.getRepository(Wagon).find({
+      where: { trainId },
+      order: { sequenceNumber: 'ASC' },
+    });
+    for (let i = 0; i < wagons.length; i++) {
+      if (wagons[i].sequenceNumber !== i + 1) {
+        await manager.getRepository(Wagon).update(wagons[i].id, { sequenceNumber: i + 1 });
+      }
+    }
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/trains/trains.module.ts b/apps/edr-freight-api/src/modules/trains/trains.module.ts
index 61098ff40..0c2ce8ded 100644
--- a/apps/edr-freight-api/src/modules/trains/trains.module.ts
+++ b/apps/edr-freight-api/src/modules/trains/trains.module.ts
@@ -1,14 +1,17 @@
 // apps/edr-freight-api/src/modules/trains/trains.module.ts
 import { Module } from '@nestjs/common';
 import { TypeOrmModule } from '@nestjs/typeorm';
+import { TrainLocomotive } from './entities/train-locomotive.entity';
 import { Train } from './entities/train.entity';
+import { TrainBuilderController } from './train-builder.controller';
+import { TrainBuilderService } from './train-builder.service';
 import { TrainsController } from './trains.controller';
 import { TrainsService } from './trains.service';
 
 @Module({
-  imports: [TypeOrmModule.forFeature([Train])],
-  controllers: [TrainsController],
-  providers: [TrainsService],
-  exports: [TrainsService], // if other modules need it
+  imports: [TypeOrmModule.forFeature([Train, TrainLocomotive])],
+  controllers: [TrainsController, TrainBuilderController],
+  providers: [TrainsService, TrainBuilderService],
+  exports: [TrainsService, TrainBuilderService],
 })
-export class TrainsModule {}
\ No newline at end of file
+export class TrainsModule {}
diff --git a/apps/edr-freight-api/src/modules/wagons/dto/create-transfer-request.dto.ts b/apps/edr-freight-api/src/modules/wagons/dto/create-transfer-request.dto.ts
new file mode 100644
index 000000000..4dd9f0f75
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/wagons/dto/create-transfer-request.dto.ts
@@ -0,0 +1,28 @@
+import { ApiPropertyOptional } from '@nestjs/swagger';
+import { IsInt, IsOptional, IsString, IsUUID, Max, Min } from 'class-validator';
+
+/**
+ * A count-only wagon-transfer request. The requester picks source yard, wagon
+ * type, destination yard and HOW MANY — never the specific wagons; OCC hand-picks
+ * those at fulfilment.
+ */
+export class CreateTransferRequestDto {
+  @IsUUID()
+  fromYardId!: string;
+
+  @IsUUID()
+  toYardId!: string;
+
+  @IsUUID()
+  wagonTypeId!: string;
+
+  @IsInt()
+  @Min(1)
+  @Max(1000)
+  quantity!: number;
+
+  @ApiPropertyOptional({ description: 'Optional note for the fulfilling staff' })
+  @IsOptional()
+  @IsString()
+  note?: string;
+}
diff --git a/apps/edr-freight-api/src/modules/wagons/dto/fulfill-transfer-request.dto.ts b/apps/edr-freight-api/src/modules/wagons/dto/fulfill-transfer-request.dto.ts
new file mode 100644
index 000000000..565156304
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/wagons/dto/fulfill-transfer-request.dto.ts
@@ -0,0 +1,13 @@
+import { ArrayNotEmpty, IsArray, IsUUID } from 'class-validator';
+
+/**
+ * OCC fulfilment: the specific wagons hand-picked to satisfy a transfer request.
+ * The service validates they all sit in the request's source yard, match its
+ * wagon type, and number exactly the requested quantity.
+ */
+export class FulfillTransferRequestDto {
+  @IsArray()
+  @ArrayNotEmpty()
+  @IsUUID('4', { each: true })
+  wagonIds!: string[];
+}
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
index 7c5ed092c..a36e5deea 100644
--- 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
@@ -4,6 +4,7 @@ import { Column, Entity, Index, JoinColumn, ManyToOne } from 'typeorm';
 
 import { Yard } from '../../rule-engine/entities/yard.entity';
 import { Wagon } from './wagon.entity';
+import { WagonTransferRequest } from './wagon-transfer-request.entity';
 
 /**
  * Ledger of every physical wagon relocation between yards — one row per move.
@@ -51,6 +52,14 @@ export class WagonMovement extends BaseEntity {
   @Column({ name: 'moved_by_user_id', type: 'uuid', nullable: true })
   movedByUserId?: string | null;
 
+  /** The transfer request this move fulfilled, when it came from one. */
+  @Column({ name: 'transfer_request_id', type: 'uuid', nullable: true })
+  transferRequestId?: string | null;
+
+  @ManyToOne(() => WagonTransferRequest, { nullable: true })
+  @JoinColumn({ name: 'transfer_request_id' })
+  transferRequest?: WagonTransferRequest | null;
+
   @Column({ name: 'occurred_at', type: 'timestamptz' })
   occurredAt!: Date;
 
diff --git a/apps/edr-freight-api/src/modules/wagons/entities/wagon-transfer-request.entity.ts b/apps/edr-freight-api/src/modules/wagons/entities/wagon-transfer-request.entity.ts
new file mode 100644
index 000000000..40005de26
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/wagons/entities/wagon-transfer-request.entity.ts
@@ -0,0 +1,62 @@
+import { BaseEntity } from '@edr/api-common';
+import { WagonTransferRequestStatus } from '@edr/types';
+import { Column, Entity, Index, JoinColumn, ManyToOne } from 'typeorm';
+
+import { Yard } from '../../rule-engine/entities/yard.entity';
+import { WagonType } from '../../wagon-types/entities/wagon-type.entity';
+
+/**
+ * A two-person wagon relocation request. A requester asks for `quantity` wagons
+ * of `wagonTypeId` to move from `fromYardId` to `toYardId` — specifying a count
+ * only, never the physical wagons. OCC staff later open the PENDING request,
+ * hand-pick the actual wagons in the source yard, and execute the transfer
+ * (which writes the `wagon_movements` ledger and marks this FULFILLED).
+ */
+@Entity({ schema: 'freight', name: 'wagon_transfer_requests' })
+@Index(['status', 'fromYardId'])
+export class WagonTransferRequest extends BaseEntity {
+  @Column({ name: 'from_yard_id', type: 'uuid' })
+  fromYardId!: string;
+
+  @ManyToOne(() => Yard)
+  @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;
+
+  @Column({ name: 'wagon_type_id', type: 'uuid' })
+  wagonTypeId!: string;
+
+  @ManyToOne(() => WagonType)
+  @JoinColumn({ name: 'wagon_type_id' })
+  wagonType?: WagonType | null;
+
+  /** How many wagons of `wagonTypeId` to move out of `fromYardId`. */
+  @Column({ name: 'quantity', type: 'int' })
+  quantity!: number;
+
+  @Column({
+    name: 'status',
+    type: 'varchar',
+    length: 20,
+    default: WagonTransferRequestStatus.Pending,
+  })
+  status!: WagonTransferRequestStatus;
+
+  @Column({ name: 'requested_by_user_id', type: 'uuid', nullable: true })
+  requestedByUserId?: string | null;
+
+  @Column({ name: 'fulfilled_by_user_id', type: 'uuid', nullable: true })
+  fulfilledByUserId?: string | null;
+
+  @Column({ name: 'fulfilled_at', type: 'timestamptz', nullable: true })
+  fulfilledAt?: Date | null;
+
+  @Column({ name: 'note', type: 'text', nullable: true })
+  note?: string | null;
+}
diff --git a/apps/edr-freight-api/src/modules/wagons/wagon-transfer-requests.controller.ts b/apps/edr-freight-api/src/modules/wagons/wagon-transfer-requests.controller.ts
new file mode 100644
index 000000000..12fdaf27c
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/wagons/wagon-transfer-requests.controller.ts
@@ -0,0 +1,101 @@
+import { WagonTransferRequestStatus } from '@edr/types';
+import {
+  Body,
+  Controller,
+  Get,
+  Param,
+  ParseUUIDPipe,
+  Post,
+  Query,
+} from '@nestjs/common';
+import { ApiOperation, ApiQuery, ApiTags } from '@nestjs/swagger';
+import { CurrentUser } from '@edr/api-common';
+import type { TCurrentUser } from '@tria-plc/api-common/modules/auth/types/current-user.type';
+
+import {
+  FleetManage,
+  FleetView,
+  WagonTransferFulfill,
+  WagonTransferHistoryAll,
+  WagonTransferRequest,
+} from '../../common/booking-guards';
+import { CreateTransferRequestDto } from './dto/create-transfer-request.dto';
+import { FulfillTransferRequestDto } from './dto/fulfill-transfer-request.dto';
+import { WagonTransferRequestsService } from './wagon-transfer-requests.service';
+
+/**
+ * Two-person wagon-transfer queue. Requester (transfer_request perm) files a
+ * count-only request; OCC (transfer_fulfill perm) picks the wagons and executes
+ * the move. Separate top-level path so it never collides with `wagons/:id`.
+ */
+@ApiTags('wagon-transfer-requests')
+@Controller('wagon-transfer-requests')
+@FleetView()
+export class WagonTransferRequestsController {
+  constructor(private readonly service: WagonTransferRequestsService) {}
+
+  @Post()
+  @WagonTransferRequest()
+  @ApiOperation({ summary: 'File a count-only wagon-transfer request' })
+  create(
+    @Body() dto: CreateTransferRequestDto,
+    @CurrentUser() user: TCurrentUser,
+  ) {
+    return this.service.createRequest(dto, user?.id);
+  }
+
+  @Get()
+  @ApiQuery({ name: 'status', required: false, enum: WagonTransferRequestStatus })
+  @ApiOperation({ summary: 'List transfer requests (OCC queue: status=PENDING)' })
+  list(@Query('status') status?: WagonTransferRequestStatus) {
+    return this.service.listRequests(status);
+  }
+
+  // NOTE: the two `history` routes MUST stay above `@Get(':id')` — Express
+  // matches in declaration order, so `/history` would otherwise be captured by
+  // the `:id` param route (and rejected by ParseUUIDPipe).
+  @Get('history')
+  @ApiOperation({
+    summary: "Caller's own transfer history (requests filed/fulfilled + wagons moved)",
+  })
+  myHistory(@CurrentUser() user: TCurrentUser) {
+    // Never fall through to the all-staff view: getHistory(undefined) means
+    // "everyone", so a missing caller id must return empty, not leak scope.
+    if (!user?.id) return { requests: [], movements: [] };
+    return this.service.getHistory(user.id);
+  }
+
+  @Get('history/all')
+  @WagonTransferHistoryAll()
+  @ApiQuery({ name: 'userId', required: false })
+  @ApiOperation({
+    summary: "Admin: any/all staff's transfer history (optional ?userId filter)",
+  })
+  allHistory(@Query('userId') userId?: string) {
+    return this.service.getHistory(userId);
+  }
+
+  @Get(':id')
+  @ApiOperation({ summary: 'Get one transfer request' })
+  findOne(@Param('id', ParseUUIDPipe) id: string) {
+    return this.service.findById(id);
+  }
+
+  @Post(':id/fulfill')
+  @WagonTransferFulfill()
+  @ApiOperation({ summary: 'OCC: pick wagons and execute the transfer' })
+  fulfill(
+    @Param('id', ParseUUIDPipe) id: string,
+    @Body() dto: FulfillTransferRequestDto,
+    @CurrentUser() user: TCurrentUser,
+  ) {
+    return this.service.fulfillRequest(id, dto, user?.id);
+  }
+
+  @Post(':id/cancel')
+  @FleetManage()
+  @ApiOperation({ summary: 'Withdraw a pending transfer request' })
+  cancel(@Param('id', ParseUUIDPipe) id: string) {
+    return this.service.cancelRequest(id);
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/wagons/wagon-transfer-requests.service.ts b/apps/edr-freight-api/src/modules/wagons/wagon-transfer-requests.service.ts
new file mode 100644
index 000000000..bf69d767d
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/wagons/wagon-transfer-requests.service.ts
@@ -0,0 +1,199 @@
+import { WagonTransferRequestStatus } from '@edr/types';
+import {
+  BadRequestException,
+  ConflictException,
+  Injectable,
+  NotFoundException,
+} from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { In, IsNull, Not, Repository } from 'typeorm';
+
+import { CreateTransferRequestDto } from './dto/create-transfer-request.dto';
+import { FulfillTransferRequestDto } from './dto/fulfill-transfer-request.dto';
+import { Wagon } from './entities/wagon.entity';
+import { WagonMovement } from './entities/wagon-movement.entity';
+import { WagonTransferRequest } from './entities/wagon-transfer-request.entity';
+import { WagonsService } from './wagons.service';
+
+/** Bundled per-user activity: requests they touched + wagons they moved. */
+export interface TransferHistory {
+  requests: WagonTransferRequest[];
+  movements: WagonMovement[];
+}
+
+/** How many ledger rows the history returns at most (newest first). */
+const HISTORY_LIMIT = 500;
+
+const REQUEST_RELATIONS = {
+  fromYard: true,
+  toYard: true,
+  wagonType: true,
+} as const;
+
+/**
+ * Two-person wagon-transfer workflow. A requester records a count-only request
+ * (see `createRequest`); OCC staff later open the PENDING queue, hand-pick the
+ * physical wagons, and `fulfillRequest` validates + executes the move. Replaces
+ * the single-step instant bulk transfer.
+ */
+@Injectable()
+export class WagonTransferRequestsService {
+  constructor(
+    @InjectRepository(WagonTransferRequest)
+    private readonly requestRepo: Repository<WagonTransferRequest>,
+    @InjectRepository(Wagon)
+    private readonly wagonRepo: Repository<Wagon>,
+    @InjectRepository(WagonMovement)
+    private readonly movementRepo: Repository<WagonMovement>,
+    private readonly wagonsService: WagonsService,
+  ) {}
+
+  /** Record a PENDING request. Count-only — no wagons are picked here. */
+  async createRequest(
+    dto: CreateTransferRequestDto,
+    userId?: string | null,
+  ): Promise<WagonTransferRequest> {
+    if (dto.fromYardId === dto.toYardId) {
+      throw new BadRequestException(
+        'Source and destination yard must be different',
+      );
+    }
+    const request = this.requestRepo.create({
+      fromYardId: dto.fromYardId,
+      toYardId: dto.toYardId,
+      wagonTypeId: dto.wagonTypeId,
+      quantity: dto.quantity,
+      status: WagonTransferRequestStatus.Pending,
+      requestedByUserId: userId ?? null,
+      note: dto.note ?? null,
+    });
+    const saved = await this.requestRepo.save(request);
+    return this.findById(saved.id);
+  }
+
+  /** Requests, newest first, optionally filtered by status (OCC queue = PENDING). */
+  async listRequests(
+    status?: WagonTransferRequestStatus,
+  ): Promise<WagonTransferRequest[]> {
+    return this.requestRepo.find({
+      where: status ? { status } : {},
+      relations: REQUEST_RELATIONS,
+      order: { createdAt: 'DESC' },
+    });
+  }
+
+  async findById(id: string): Promise<WagonTransferRequest> {
+    const request = await this.requestRepo.findOne({
+      where: { id },
+      relations: REQUEST_RELATIONS,
+    });
+    if (!request) throw new NotFoundException(`Transfer request ${id} not found`);
+    return request;
+  }
+
+  /**
+   * OCC fulfils a PENDING request with hand-picked wagons. Every wagon must sit
+   * in the request's source yard, match its wagon type, and the count must equal
+   * the requested quantity — then the transfer runs and the request is marked
+   * FULFILLED.
+   */
+  async fulfillRequest(
+    id: string,
+    dto: FulfillTransferRequestDto,
+    userId?: string | null,
+  ): Promise<WagonTransferRequest> {
+    const request = await this.findById(id);
+    if (request.status !== WagonTransferRequestStatus.Pending) {
+      throw new ConflictException(
+        `Request is already ${request.status.toLowerCase()}`,
+      );
+    }
+
+    const wagonIds = [...new Set(dto.wagonIds)];
+    if (wagonIds.length !== request.quantity) {
+      throw new BadRequestException(
+        `Select exactly ${request.quantity} wagon(s); you selected ${wagonIds.length}`,
+      );
+    }
+
+    const wagons = await this.wagonRepo.find({ where: { id: In(wagonIds) } });
+    if (wagons.length !== wagonIds.length) {
+      throw new NotFoundException('One or more selected wagons not found');
+    }
+    const offSource = wagons.filter((w) => w.currentYardId !== request.fromYardId);
+    if (offSource.length) {
+      throw new BadRequestException(
+        `These wagons are not in the source yard: ${offSource
+          .map((w) => w.wagonNumber)
+          .join(', ')}`,
+      );
+    }
+    const wrongType = wagons.filter((w) => w.wagonTypeId !== request.wagonTypeId);
+    if (wrongType.length) {
+      throw new BadRequestException(
+        `These wagons are the wrong type: ${wrongType
+          .map((w) => w.wagonNumber)
+          .join(', ')}`,
+      );
+    }
+
+    // Reuse the audited bulk-transfer path (writes wagon_movements ledger rows,
+    // each stamped with this request's id so history can link them back).
+    await this.wagonsService.bulkTransfer(
+      { wagonIds, toYardId: request.toYardId },
+      userId,
+      { transferRequestId: request.id },
+    );
+
+    request.status = WagonTransferRequestStatus.Fulfilled;
+    request.fulfilledByUserId = userId ?? null;
+    request.fulfilledAt = new Date();
+    await this.requestRepo.save(request);
+    return this.findById(id);
+  }
+
+  /**
+   * Per-user transfer history: the requests a user filed OR fulfilled, plus the
+   * individual wagons they physically moved (linked back to their request when
+   * one drove the move). Pass a `userId` to scope to one staffer; pass
+   * `undefined` for the admin all-staff view. Scope is decided by the CALLER
+   * (the controller passes the caller's id unless they hold the history-all
+   * permission) — this method trusts its argument.
+   */
+  async getHistory(userId?: string | null): Promise<TransferHistory> {
+    const requests = await this.requestRepo.find({
+      where: userId
+        ? [{ requestedByUserId: userId }, { fulfilledByUserId: userId }]
+        : {},
+      relations: REQUEST_RELATIONS,
+      order: { createdAt: 'DESC' },
+      take: HISTORY_LIMIT,
+    });
+
+    const movements = await this.movementRepo.find({
+      // Own view: moves I made. All view: every user-attributed move (skip the
+      // system-written loaded/reposition legs that carry no mover).
+      where: userId
+        ? { movedByUserId: userId }
+        : { movedByUserId: Not(IsNull()) },
+      relations: { wagon: true, fromYard: true, toYard: true, transferRequest: true },
+      order: { occurredAt: 'DESC' },
+      take: HISTORY_LIMIT,
+    });
+
+    return { requests, movements };
+  }
+
+  /** Withdraw a still-PENDING request. */
+  async cancelRequest(id: string): Promise<WagonTransferRequest> {
+    const request = await this.findById(id);
+    if (request.status !== WagonTransferRequestStatus.Pending) {
+      throw new ConflictException(
+        `Only pending requests can be cancelled (this one is ${request.status.toLowerCase()})`,
+      );
+    }
+    request.status = WagonTransferRequestStatus.Cancelled;
+    await this.requestRepo.save(request);
+    return this.findById(id);
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/wagons/wagons.module.ts b/apps/edr-freight-api/src/modules/wagons/wagons.module.ts
index bffe28860..107a31e7e 100644
--- a/apps/edr-freight-api/src/modules/wagons/wagons.module.ts
+++ b/apps/edr-freight-api/src/modules/wagons/wagons.module.ts
@@ -1,15 +1,31 @@
 import { Module } from '@nestjs/common';
 import { TypeOrmModule } from '@nestjs/typeorm';
 import { Wagon } from './entities/wagon.entity';
+import { WagonMovement } from './entities/wagon-movement.entity';
+import { WagonTransferRequest } from './entities/wagon-transfer-request.entity';
 import { Train } from '../trains/entities/train.entity';
 import { Yard } from '../rule-engine/entities/yard.entity';
 import { WagonsController, TrainWagonsReorderController } from './wagons.controller';
+import { WagonTransferRequestsController } from './wagon-transfer-requests.controller';
 import { WagonsService } from './wagons.service';
+import { WagonTransferRequestsService } from './wagon-transfer-requests.service';
 
 @Module({
-  imports: [TypeOrmModule.forFeature([Wagon, Train, Yard])],
-  controllers: [WagonsController, TrainWagonsReorderController],
-  providers: [WagonsService],
-  exports: [WagonsService],
+  imports: [
+    TypeOrmModule.forFeature([
+      Wagon,
+      WagonMovement,
+      WagonTransferRequest,
+      Train,
+      Yard,
+    ]),
+  ],
+  controllers: [
+    WagonsController,
+    TrainWagonsReorderController,
+    WagonTransferRequestsController,
+  ],
+  providers: [WagonsService, WagonTransferRequestsService],
+  exports: [WagonsService, WagonTransferRequestsService],
 })
 export class WagonsModule {}
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 ad39fbf7a..55dc177c9 100644
--- a/apps/edr-freight-api/src/modules/wagons/wagons.service.ts
+++ b/apps/edr-freight-api/src/modules/wagons/wagons.service.ts
@@ -180,6 +180,7 @@ export class WagonsService {
   async bulkTransfer(
     dto: BulkTransferWagonsDto,
     userId?: string | null,
+    opts?: { transferRequestId?: string | null },
   ): Promise<{ moved: number }> {
     const { wagonIds, toYardId } = dto;
     if (!wagonIds.length) return { moved: 0 };
@@ -215,6 +216,7 @@ export class WagonsService {
             toYardId,
             kind: WagonMovementKind.Manual,
             movedByUserId: userId ?? null,
+            transferRequestId: opts?.transferRequestId ?? null,
             occurredAt: new Date(),
           }),
         );
diff --git a/apps/edr-freight-api/src/modules/warehouses/dto/acknowledge-accrual.dto.ts b/apps/edr-freight-api/src/modules/warehouses/dto/acknowledge-accrual.dto.ts
new file mode 100644
index 000000000..6b3697f03
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/warehouses/dto/acknowledge-accrual.dto.ts
@@ -0,0 +1,18 @@
+import { ApiPropertyOptional } from '@nestjs/swagger';
+import { IsInt, IsOptional, IsString, Max, MaxLength, Min } from 'class-validator';
+
+/** Acknowledge (optionally snooze) an item's fee-accrual alert. */
+export class AcknowledgeAccrualDto {
+  @ApiPropertyOptional({ minimum: 1, maximum: 90, description: 'Days to suppress alerts; omit = indefinitely.' })
+  @IsOptional()
+  @IsInt()
+  @Min(1)
+  @Max(90)
+  snoozeDays?: number;
+
+  @ApiPropertyOptional({ description: 'Optional reason / note.' })
+  @IsOptional()
+  @IsString()
+  @MaxLength(500)
+  note?: string;
+}
diff --git a/apps/edr-freight-api/src/modules/warehouses/dto/approve-delivery.dto.ts b/apps/edr-freight-api/src/modules/warehouses/dto/approve-delivery.dto.ts
new file mode 100644
index 000000000..2ef499201
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/warehouses/dto/approve-delivery.dto.ts
@@ -0,0 +1,11 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { IsNotEmpty, IsString, MaxLength } from 'class-validator';
+
+/** The customer approving a handover must record their full name (signature optional). */
+export class ApproveDeliveryDto {
+  @ApiProperty({ description: 'Full name of the person approving delivery.' })
+  @IsString()
+  @IsNotEmpty()
+  @MaxLength(160)
+  signerName!: string;
+}
diff --git a/apps/edr-freight-api/src/modules/warehouses/entities/booking-handover.entity.ts b/apps/edr-freight-api/src/modules/warehouses/entities/booking-handover.entity.ts
index f5a730ea8..a0a7ad70f 100644
--- a/apps/edr-freight-api/src/modules/warehouses/entities/booking-handover.entity.ts
+++ b/apps/edr-freight-api/src/modules/warehouses/entities/booking-handover.entity.ts
@@ -37,6 +37,10 @@ export class BookingHandover extends BaseEntity {
   @Column({ name: 'signed_at', type: 'timestamptz', nullable: true })
   signedAt?: Date | null;
 
+  /** Full name of the person who signed off the handover (required at sign time). */
+  @Column({ name: 'signer_name', type: 'varchar', length: 160, nullable: true })
+  signerName?: string | null;
+
   @Column({ name: 'signed_by_user_id', type: 'uuid', nullable: true })
   signedByUserId?: string | null;
 
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 48ab3ac48..d50b27150 100644
--- a/apps/edr-freight-api/src/modules/warehouses/handover.service.ts
+++ b/apps/edr-freight-api/src/modules/warehouses/handover.service.ts
@@ -183,12 +183,20 @@ export class HandoverService {
   }
 
   /** Sign all unsigned handovers on a booking (self-haul: before the truck leaves). */
-  async signForBooking(bookingId: string, userId?: string | null): Promise<void> {
+  async signForBooking(
+    bookingId: string,
+    userId?: string | null,
+    signerName?: string | null,
+  ): Promise<void> {
     await this.dataSource
       .getRepository(BookingHandover)
       .update(
         { bookingId, signedAt: IsNull() },
-        { signedAt: new Date(), signedByUserId: userId ?? null },
+        {
+          signedAt: new Date(),
+          signedByUserId: userId ?? null,
+          signerName: signerName?.trim() || null,
+        },
       );
   }
 
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 14a3375c7..92aa36b85 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
@@ -1,7 +1,10 @@
-import { BadRequestException, Injectable, NotFoundException } from '@nestjs/common';
+import { BadRequestException, Injectable, Logger, NotFoundException } from '@nestjs/common';
+import { Cron, CronExpression } from '@nestjs/schedule';
 import { ExchangeService } from '@edr/api-common';
+import { NotificationAudience, NotificationType } from '@edr/types';
 import { DataSource } from 'typeorm';
 
+import { NotificationInboxService } from '../notification-inbox/notification-inbox.service';
 import { CreateFeeRuleDto, UpdateFeeRuleDto } from './dto/fee-rule.dto';
 import { FeeRuleBasis, FeeRuleType, WarehouseFeeRule, WarehouseFeeTier } from './entities/warehouse-fee-rule.entity';
 import { WarehouseFeeRuleRepository } from './warehouse-fee-rule.repository';
@@ -26,6 +29,35 @@ interface ItemAttributes {
   zoneId: string | null;
 }
 
+export type AccrualAlert = 'OK' | 'WARNING' | 'CHARGING';
+
+export interface AccrualDashboardRow {
+  inventoryId: string;
+  status: string;
+  bookingId: string | null;
+  companyId: string | null;
+  bookingReference: string | null;
+  customerName: string | null;
+  warehouseCode: string | null;
+  zoneCode: string | null;
+  receivedAt: string | null;
+  currency: string;
+  accruedAmount: number;
+  freeDaysLeft: number | null;
+  charging: boolean;
+  alert: AccrualAlert;
+  /** Reviewed by ops — suppressed from alerts (snoozed until snoozeUntil, or indefinitely). */
+  acknowledged: boolean;
+  snoozeUntil: string | null;
+  breakdown: Array<{
+    type: FeeRuleType;
+    amount: number;
+    freeDays: number;
+    elapsedDays: number;
+    chargeableDays: number;
+  }>;
+}
+
 export interface FeePreview {
   ruleType: FeeRuleType;
   /** Double-handling charge basis (PER_CONTAINER | PER_TON | PER_MACHINERY); null otherwise. */
@@ -70,12 +102,82 @@ const MS_PER_DAY = 24 * 60 * 60 * 1000;
 
 @Injectable()
 export class WarehouseFeeService {
+  private readonly logger = new Logger(WarehouseFeeService.name);
+
   constructor(
     private readonly dataSource: DataSource,
     private readonly feeRuleRepository: WarehouseFeeRuleRepository,
     private readonly exchangeService: ExchangeService,
+    private readonly inbox: NotificationInboxService,
   ) {}
 
+  /**
+   * Daily accrual alerts: for every in-warehouse item that is charging or within
+   * its last free days, send the customer an in-app notification with the
+   * outstanding accrued amount so they can collect before (more) charges hit.
+   */
+  @Cron(CronExpression.EVERY_DAY_AT_6AM, { name: 'warehouse-accrual-alert' })
+  async sendAccrualAlerts(): Promise<void> {
+    try {
+      const alerts = (await this.accrualDashboard()).filter(
+        (r) => r.alert !== 'OK' && !r.acknowledged,
+      );
+      if (!alerts.length) return;
+      this.logger.log(`Accrual alerts: ${alerts.length} item(s) charging or nearing charges`);
+
+      // Per-customer: notify each company about its own items.
+      for (const row of alerts.filter((r) => r.companyId)) {
+        const ref = row.bookingReference ?? row.inventoryId.slice(0, 8);
+        const amount = `${row.accruedAmount.toFixed(2)} ${row.currency}`;
+        const body = row.charging
+          ? `Storage/demurrage is now charging on booking ${ref} — ${amount} accrued. Collect the cargo to stop further charges.`
+          : `Booking ${ref} has ${row.freeDaysLeft ?? 0} free day(s) left before storage/demurrage charges start (${amount} accrued so far).`;
+        try {
+          await this.inbox.notify({
+            recipients: { companyId: row.companyId! },
+            audience: NotificationAudience.PORTAL,
+            type: NotificationType.BOOKING_STATUS,
+            title: row.charging ? 'Storage charges accruing' : 'Free days ending soon',
+            body,
+            link: row.bookingId ? `/bookings/${row.bookingId}` : undefined,
+            data: {
+              inventoryId: row.inventoryId,
+              bookingId: row.bookingId,
+              alert: row.alert,
+              accruedAmount: row.accruedAmount,
+              action: 'ACCRUAL_ALERT',
+            },
+          });
+        } catch (err) {
+          this.logger.warn(
+            `Accrual alert failed for ${row.inventoryId}: ${(err as Error).message}`,
+          );
+        }
+      }
+
+      // Ops staff: one digest covering every alerting item.
+      const charging = alerts.filter((r) => r.charging).length;
+      const nearing = alerts.length - charging;
+      const currency = alerts[0]?.currency ?? 'USD';
+      const total = alerts.reduce((sum, r) => sum + r.accruedAmount, 0);
+      try {
+        await this.inbox.notify({
+          recipients: { allBackoffice: true },
+          audience: NotificationAudience.BACKOFFICE,
+          type: NotificationType.BOOKING_STATUS,
+          title: 'Warehouse fee accruals need attention',
+          body: `${charging} item(s) charging, ${nearing} nearing the free-day limit — ${total.toFixed(2)} ${currency} accruing. Review the accrual dashboard.`,
+          link: '/dashboard/warehouse-fee-invoices',
+          data: { charging, nearing, totalAccrued: Math.round(total * 100) / 100, action: 'ACCRUAL_ALERT_DIGEST' },
+        });
+      } catch (err) {
+        this.logger.warn(`Accrual staff digest failed: ${(err as Error).message}`);
+      }
+    } catch (err) {
+      this.logger.warn(`Accrual alert tick failed: ${(err as Error).message}`);
+    }
+  }
+
   // ── Rule CRUD ──────────────────────────────────────────────────────────────
   listRules(): Promise<WarehouseFeeRule[]> {
     return this.feeRuleRepository.findAll({ order: { ruleType: 'ASC', priority: 'ASC' } });
@@ -416,6 +518,138 @@ export class WarehouseFeeService {
     };
   }
 
+  /**
+   * Live accrual dashboard: for every item still in the warehouse, the fees
+   * accruing right now (storage + demurrage + double-handling), how many free
+   * days remain, and an alert level so staff can act before charges land.
+   */
+  async accrualDashboard(billingCurrency = 'USD'): Promise<AccrualDashboardRow[]> {
+    const items: Array<{
+      id: string;
+      status: string;
+      bookingId: string | null;
+      companyId: string | null;
+      bookingReference: string | null;
+      customerName: string | null;
+      warehouseCode: string | null;
+      zoneCode: string | null;
+      receivedAt: string | null;
+    }> = await this.dataSource.query(
+      `SELECT inv.id,
+              inv.status,
+              b.id AS "bookingId",
+              b.company_id AS "companyId",
+              b.reference AS "bookingReference",
+              c.name AS "customerName",
+              w.code AS "warehouseCode",
+              z.code AS "zoneCode",
+              inv.created_at AS "receivedAt"
+         FROM freight.warehouse_inventory inv
+         LEFT JOIN freight.bookings b ON b.id = inv.booking_id AND b.deleted_at IS NULL
+         LEFT JOIN freight.companies c ON c.id = b.company_id
+         LEFT JOIN freight.warehouses w ON w.id = inv.warehouse_id
+         LEFT JOIN freight.warehouse_zones z ON z.id = inv.zone_id
+        WHERE inv.deleted_at IS NULL
+          AND inv.status IN ('RECEIVED', 'STORED', 'READY_FOR_LOADING', 'READY_FOR_PICKUP', 'RESERVED')
+        ORDER BY inv.created_at ASC`,
+    );
+
+    const ackRows: Array<{ inventoryId: string; snoozeUntil: string | null }> =
+      await this.dataSource.query(
+        `SELECT inventory_id AS "inventoryId", snooze_until AS "snoozeUntil"
+           FROM freight.warehouse_accrual_acks`,
+      );
+    const now = new Date();
+    const acks = new Map(ackRows.map((a) => [a.inventoryId, a.snoozeUntil]));
+
+    const rows = await Promise.all(
+      items.map(async (it): Promise<AccrualDashboardRow> => {
+        const previews = (await this.previewForInventory(it.id, billingCurrency)).filter(
+          (p) => p.ruleId,
+        );
+        const accruedAmount =
+          Math.round(previews.reduce((sum, p) => sum + (p.amount ?? 0), 0) * 100) / 100;
+        const charging = previews.some((p) => p.chargeableDays > 0);
+        const freeDaysLeftVals = previews
+          .filter((p) => p.endIsOpen)
+          .map((p) => Math.max(0, p.freeDays - p.elapsedDays));
+        const freeDaysLeft = freeDaysLeftVals.length ? Math.min(...freeDaysLeftVals) : null;
+        const alert: AccrualAlert = charging
+          ? 'CHARGING'
+          : freeDaysLeft != null && freeDaysLeft <= 2
+            ? 'WARNING'
+            : 'OK';
+        return {
+          inventoryId: it.id,
+          status: it.status,
+          bookingId: it.bookingId,
+          companyId: it.companyId,
+          bookingReference: it.bookingReference,
+          customerName: it.customerName,
+          warehouseCode: it.warehouseCode,
+          zoneCode: it.zoneCode,
+          receivedAt: it.receivedAt,
+          currency: billingCurrency,
+          accruedAmount,
+          freeDaysLeft,
+          charging,
+          alert,
+          acknowledged:
+            acks.has(it.id) &&
+            (acks.get(it.id) == null || new Date(acks.get(it.id) as string) > now),
+          snoozeUntil: acks.get(it.id) ?? null,
+          breakdown: previews.map((p) => ({
+            type: p.ruleType,
+            amount: p.amount,
+            freeDays: p.freeDays,
+            elapsedDays: p.elapsedDays,
+            chargeableDays: p.chargeableDays,
+          })),
+        };
+      }),
+    );
+
+    const rank = (a: AccrualAlert) => (a === 'CHARGING' ? 0 : a === 'WARNING' ? 1 : 2);
+    // Acknowledged items sink to the bottom; among the rest, worst alert first.
+    return rows.sort(
+      (a, b) =>
+        Number(a.acknowledged) - Number(b.acknowledged) ||
+        rank(a.alert) - rank(b.alert) ||
+        b.accruedAmount - a.accruedAmount,
+    );
+  }
+
+  /** Mark an item's accrual reviewed. `snoozeDays` > 0 suppresses alerts until then; omitted = indefinitely. */
+  async acknowledgeAccrual(
+    inventoryId: string,
+    opts: { snoozeDays?: number; note?: string; userId?: string } = {},
+  ): Promise<void> {
+    const snoozeUntil =
+      opts.snoozeDays && opts.snoozeDays > 0
+        ? new Date(Date.now() + opts.snoozeDays * 24 * 60 * 60 * 1000)
+        : null;
+    await this.dataSource.query(
+      `INSERT INTO freight.warehouse_accrual_acks
+         (inventory_id, acknowledged_by, acknowledged_at, snooze_until, note, updated_at)
+       VALUES ($1, $2, now(), $3, $4, now())
+       ON CONFLICT (inventory_id) DO UPDATE
+          SET acknowledged_by = EXCLUDED.acknowledged_by,
+              acknowledged_at = now(),
+              snooze_until = EXCLUDED.snooze_until,
+              note = EXCLUDED.note,
+              updated_at = now()`,
+      [inventoryId, opts.userId ?? null, snoozeUntil, opts.note?.trim() || null],
+    );
+  }
+
+  /** Remove an acknowledgement so the item re-surfaces for alerts. */
+  async unacknowledgeAccrual(inventoryId: string): Promise<void> {
+    await this.dataSource.query(
+      `DELETE FROM freight.warehouse_accrual_acks WHERE inventory_id = $1`,
+      [inventoryId],
+    );
+  }
+
   /** Preview demurrage + storage fees for an inventory item using the most specific active rules. */
   async previewForInventory(inventoryId: string, billingCurrency = 'USD'): Promise<FeePreview[]> {
     const item = await this.loadItem(inventoryId);
diff --git a/apps/edr-freight-api/src/modules/warehouses/warehouse-inspection.controller.ts b/apps/edr-freight-api/src/modules/warehouses/warehouse-inspection.controller.ts
index 533b0c6ae..7bd56e593 100644
--- a/apps/edr-freight-api/src/modules/warehouses/warehouse-inspection.controller.ts
+++ b/apps/edr-freight-api/src/modules/warehouses/warehouse-inspection.controller.ts
@@ -12,6 +12,8 @@ import {
 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 { CreateInspectionReportDto } from './dto/create-inspection-report.dto';
 import { UpdateInspectionReportDto } from './dto/update-inspection-report.dto';
 import { WarehouseInspectionService } from './warehouse-inspection.service';
@@ -19,10 +21,12 @@ import { WarehouseInspectionService } from './warehouse-inspection.service';
 @ApiTags('warehouse-inspection')
 @ApiBearerAuth()
 @Controller()
+@BookingStaff(FREIGHT_PERMS.warehouseInspectionReports.view)
 export class WarehouseInspectionController {
   constructor(private readonly inspectionService: WarehouseInspectionService) {}
 
   @Post('warehouse-inventory/:inventoryId/inspection-reports')
+  @BookingStaff(FREIGHT_PERMS.warehouseInspectionReports.create)
   @ApiOperation({ summary: 'Create an inspection / damage report for an inventory item' })
   create(
     @Param('inventoryId', ParseUUIDPipe) inventoryId: string,
@@ -46,12 +50,14 @@ export class WarehouseInspectionController {
   }
 
   @Patch('warehouse-inspection-reports/:id')
+  @BookingStaff(FREIGHT_PERMS.warehouseInspectionReports.update)
   @ApiOperation({ summary: 'Update an inspection report' })
   update(@Param('id', ParseUUIDPipe) id: string, @Body() dto: UpdateInspectionReportDto) {
     return this.inspectionService.update(id, dto);
   }
 
   @Post('warehouse-inspection-reports/:id/attachments')
+  @BookingStaff(FREIGHT_PERMS.warehouseInspectionReports.update)
   @UseInterceptors(AnyFilesInterceptor())
   @ApiConsumes('multipart/form-data')
   @ApiOperation({ summary: 'Upload inspection images / documents' })
diff --git a/apps/edr-freight-api/src/modules/warehouses/warehouse-inventory.controller.ts b/apps/edr-freight-api/src/modules/warehouses/warehouse-inventory.controller.ts
index 21f2663b6..8b14e6cdc 100644
--- a/apps/edr-freight-api/src/modules/warehouses/warehouse-inventory.controller.ts
+++ b/apps/edr-freight-api/src/modules/warehouses/warehouse-inventory.controller.ts
@@ -2,6 +2,8 @@ import { Body, Controller, Get, Param, ParseUUIDPipe, Patch, Post, Query, Reques
 import { ApiBearerAuth, ApiOperation, ApiTags } from '@nestjs/swagger';
 import type { Response } from 'express';
 
+import { BookingStaff } from '../../common/booking-guards';
+import { FREIGHT_PERMS } from '../../seed/freight-permissions.registry';
 import { BulkReceiveDto } from './dto/bulk-receive.dto';
 import { BulkInspectDto } from './dto/bulk-inspect.dto';
 import { DeliverInventoryDto } from './dto/deliver-inventory.dto';
@@ -11,6 +13,7 @@ import { LoadInventoryDto } from './dto/load-inventory.dto';
 import { MoveInventoryDto } from './dto/move-inventory.dto';
 import { StoreInventoryDto } from './dto/store-inventory.dto';
 import { ReceiveWarehouseInventoryDto } from './dto/receive-inventory.dto';
+import { ApproveDeliveryDto } from './dto/approve-delivery.dto';
 import { ReleaseOrderDto } from './dto/release-order.dto';
 import { ReserveInventoryDto } from './dto/reserve-inventory.dto';
 import { UnloadBookingDto } from './dto/unload-booking.dto';
@@ -29,48 +32,63 @@ export class WarehouseInventoryController {
   ) {}
 
   @Get()
+  @BookingStaff(FREIGHT_PERMS.warehouseInventory.view)
   @ApiOperation({ summary: 'List warehouse inventory' })
   findAll(@Query() filter: FilterWarehouseInventoryDto) {
     return this.inventoryService.findAll(filter);
   }
 
   @Get('ready-for-loading')
+  @BookingStaff(FREIGHT_PERMS.warehouseInventory.view)
   @ApiOperation({ summary: 'List inventory ready for loading' })
   findReadyForLoading(@Query() filter: FilterWarehouseInventoryDto) {
     return this.inventoryService.findReadyForLoading(filter);
   }
 
   @Get('inquiry')
+  @BookingStaff(FREIGHT_PERMS.warehouseInventory.view)
   @ApiOperation({ summary: 'Locate any item inside the warehouse' })
   inquiry(@Query() filter: InquiryWarehouseInventoryDto) {
     return this.inventoryService.inquiry(filter);
   }
 
   @Get('arrival-queue')
+  @BookingStaff(FREIGHT_PERMS.warehouseInventory.view)
   @ApiOperation({ summary: 'Arrived bookings awaiting unload / inspection' })
   arrivalQueue() {
     return this.inventoryService.arrivalQueue();
   }
 
+  @Get('ops-stats')
+  @BookingStaff(FREIGHT_PERMS.warehouseInventory.view)
+  @ApiOperation({ summary: 'At-a-glance warehouse ops counters for the KPI strip' })
+  opsStats() {
+    return this.inventoryService.opsStats();
+  }
+
   @Get('zone-occupancy')
+  @BookingStaff(FREIGHT_PERMS.warehouseInventory.view)
   @ApiOperation({ summary: 'Live occupancy per zone (rated capacity vs held) — heatmap data' })
   zoneOccupancy(@Query('yardId') yardId?: string) {
     return this.inventoryService.zoneOccupancy(yardId);
   }
 
   @Post('auto-unload-arrived')
+  @BookingStaff(FREIGHT_PERMS.warehouseInventory.unload)
   @ApiOperation({ summary: 'Bulk auto-unload all arrived bookings into the warehouse' })
   autoUnloadArrived() {
     return this.inventoryService.autoUnloadArrived();
   }
 
   @Post('auto-load-ready')
+  @BookingStaff(FREIGHT_PERMS.warehouseInventory.load)
   @ApiOperation({ summary: 'Auto-load READY_FOR_LOADING inventory with PAID bookings' })
   autoLoadReady() {
     return this.inventoryService.autoLoadReady();
   }
 
   @Get('eligible-bookings')
+  @BookingStaff(FREIGHT_PERMS.warehouseInventory.view)
   @ApiOperation({ summary: 'PAID bookings not yet received, classified IMPORT/EXPORT by route; omit direction for all' })
   eligibleBookings(@Query('direction') direction?: string) {
     const dir = direction === 'IMPORT' || direction === 'EXPORT' ? direction : undefined;
@@ -78,6 +96,7 @@ export class WarehouseInventoryController {
   }
 
   @Post('receive-bulk')
+  @BookingStaff(FREIGHT_PERMS.warehouseInventory.receive)
   @ApiOperation({ summary: 'Bulk-receive selected eligible PAID bookings into a location' })
   receiveBulk(@Body() dto: BulkReceiveDto) {
     return this.inventoryService.bulkReceive(dto);
@@ -85,36 +104,42 @@ export class WarehouseInventoryController {
 
 
   @Get('ready-to-load-export')
+  @BookingStaff(FREIGHT_PERMS.warehouseInventory.view)
   @ApiOperation({ summary: 'EXPORT inventory that passed inspection and is READY_FOR_LOADING' })
   readyToLoadExport() {
     return this.inventoryService.readyToLoadExport();
   }
 
   @Get('received-export')
+  @BookingStaff(FREIGHT_PERMS.warehouseInventory.view)
   @ApiOperation({ summary: 'EXPORT inventory that has been received and is awaiting inspection' })
   receivedExport() {
     return this.inventoryService.receivedExport();
   }
 
   @Get('loaded-export')
+  @BookingStaff(FREIGHT_PERMS.warehouseInventory.view)
   @ApiOperation({ summary: 'EXPORT inventory that is LOADED and queued for dispatch' })
   loadedExport() {
     return this.inventoryService.loadedExport();
   }
 
   @Get('loadable-trains')
+  @BookingStaff(FREIGHT_PERMS.warehouseInventory.view)
   @ApiOperation({ summary: 'EXPORT trains (pre-dispatch) with inventory waiting to be loaded' })
   loadableTrains() {
     return this.inventoryService.loadableTrains();
   }
 
   @Get('train/:scheduleId/loadable-items')
+  @BookingStaff(FREIGHT_PERMS.warehouseInventory.view)
   @ApiOperation({ summary: 'Container/cargo inventory assigned to a train, with allocated wagons' })
   trainLoadableItems(@Param('scheduleId', ParseUUIDPipe) scheduleId: string) {
     return this.inventoryService.trainLoadableItems(scheduleId);
   }
 
   @Post('train/:scheduleId/load')
+  @BookingStaff(FREIGHT_PERMS.warehouseInventory.load)
   @ApiOperation({ summary: 'Load selected inventory items onto their allocated wagons for a train' })
   loadItemsOntoTrain(
     @Param('scheduleId', ParseUUIDPipe) scheduleId: string,
@@ -124,18 +149,21 @@ export class WarehouseInventoryController {
   }
 
   @Post('bulk-dispatch-export')
+  @BookingStaff(FREIGHT_PERMS.warehouseInventory.dispatch)
   @ApiOperation({ summary: 'Bulk-dispatch loaded EXPORT inventory (LOADED → DISPATCHED)' })
   bulkDispatchExport(@Body() dto: { inventoryIds: string[]; performedBy?: string }) {
     return this.inventoryService.bulkDispatchExport(dto.inventoryIds ?? [], dto.performedBy);
   }
 
   @Post('bulk-mark-inspected')
+  @BookingStaff(FREIGHT_PERMS.warehouseInventory.inspect)
   @ApiOperation({ summary: 'Bulk mark received inventory inspection PASSED (EXPORT → READY_FOR_LOADING)' })
   bulkMarkInspected(@Body() dto: BulkInspectDto) {
     return this.inventoryService.bulkMarkInspected(dto);
   }
 
   @Post('bookings/:bookingId/unload')
+  @BookingStaff(FREIGHT_PERMS.warehouseInventory.unload)
   @ApiOperation({ summary: 'Unload a single arrived booking into a location' })
   unloadBooking(
     @Param('bookingId', ParseUUIDPipe) bookingId: string,
@@ -145,24 +173,28 @@ export class WarehouseInventoryController {
   }
 
   @Post(':id/gate-clearance')
+  @BookingStaff(FREIGHT_PERMS.warehouseInventory.gatePass)
   @ApiOperation({ summary: 'Final terminal release / gate clearance (blocked while fees unpaid)' })
   gateClearance(@Param('id', ParseUUIDPipe) id: string, @Body('performedBy') performedBy?: string) {
     return this.inventoryService.gateClearance(id, performedBy);
   }
 
   @Get('import/arrive-queue')
+  @BookingStaff(FREIGHT_PERMS.warehouseInventory.view)
   @ApiOperation({ summary: 'Arrived IMPORT train schedules (route-derived), read-only from scheduling' })
   importArriveQueue() {
     return this.scheduling.importArriveQueue();
   }
 
   @Get('import/trains/:scheduleId/items')
+  @BookingStaff(FREIGHT_PERMS.warehouseInventory.view)
   @ApiOperation({ summary: 'Assigned bookings/items for an arrived import train (read-only)' })
   importTrainDetail(@Param('scheduleId', ParseUUIDPipe) scheduleId: string) {
     return this.scheduling.importTrainDetail(scheduleId);
   }
 
   @Post('import/auto-unload-arrived-bookings')
+  @BookingStaff(FREIGHT_PERMS.warehouseInventory.unload)
   @ApiOperation({ summary: 'Unload all eligible assigned bookings of an ARRIVED import train (→ UNLOADED)' })
   autoUnloadArrivedBookings(@Body() dto: {
     scheduleId: string;
@@ -179,12 +211,14 @@ export class WarehouseInventoryController {
   }
 
   @Get('import/unloaded-queue')
+  @BookingStaff(FREIGHT_PERMS.warehouseInventory.view)
   @ApiOperation({ summary: 'IMPORT inventory in the Unloaded Queue (UNLOADED / destination inspection)' })
   importUnloadedQueue() {
     return this.inventoryService.importUnloadedQueue();
   }
 
   @Get('export/djibouti-arrival-queue')
+  @BookingStaff(FREIGHT_PERMS.warehouseInventory.view)
   @ApiOperation({ summary: 'Arrived EXPORT train schedules at Djibouti-side ports, ready for unloading' })
   exportDjiboutiArrivalQueue(
     @Query('scheduleId') scheduleId?: string,
@@ -203,102 +237,119 @@ export class WarehouseInventoryController {
   }
 
   @Get('export/djibouti-trains/:scheduleId/items')
+  @BookingStaff(FREIGHT_PERMS.warehouseInventory.view)
   @ApiOperation({ summary: 'Assigned export bookings/items for an arrived Djibouti-side train' })
   exportDjiboutiTrainDetail(@Param('scheduleId', ParseUUIDPipe) scheduleId: string) {
     return this.scheduling.exportDjiboutiTrainDetail(scheduleId);
   }
 
   @Post('export/auto-unload-at-djibouti')
+  @BookingStaff(FREIGHT_PERMS.warehouseInventory.unload)
   @ApiOperation({ summary: 'Unload all eligible export items assigned to an arrived Djibouti-side train' })
   autoUnloadExportAtDjibouti(@Body() dto: { scheduleId: string; performedBy?: string }) {
     return this.inventoryService.autoUnloadExportAtDjibouti(dto.scheduleId, dto.performedBy);
   }
 
   @Get('import/pickup-ready-queue')
+  @BookingStaff(FREIGHT_PERMS.warehouseInventory.view)
   @ApiOperation({ summary: 'IMPORT inventory that is PICKUP_READY (READY_FOR_PICKUP) awaiting pickup/dispatch' })
   importPickupReadyQueue() {
     return this.inventoryService.importPickupReadyQueue();
   }
 
   @Get('loadable-wagons')
+  @BookingStaff(FREIGHT_PERMS.warehouseInventory.view)
   @ApiOperation({ summary: 'List wagons usable for loading (read-only from scheduling)' })
   loadableWagons() {
     return this.scheduling.listLoadableWagons();
   }
 
   @Get('booking/:bookingId/schedule')
+  @BookingStaff(FREIGHT_PERMS.warehouseInventory.view)
   @ApiOperation({ summary: 'Read-only schedule + wagon + departure status for a booking' })
   bookingSchedule(@Param('bookingId', ParseUUIDPipe) bookingId: string) {
     return this.scheduling.getBookingSchedule(bookingId);
   }
 
   @Post('receive')
+  @BookingStaff(FREIGHT_PERMS.warehouseInventory.receive)
   @ApiOperation({ summary: 'Receive inventory at a warehouse location' })
   receive(@Body() dto: ReceiveWarehouseInventoryDto) {
     return this.inventoryService.receive(dto);
   }
 
   @Post('reserve')
+  @BookingStaff(FREIGHT_PERMS.warehouseInventory.move)
   @ApiOperation({ summary: 'Reserve stored inventory for a PAID booking' })
   reserve(@Body() dto: ReserveInventoryDto) {
     return this.inventoryService.reserve(dto);
   }
 
   @Get(':id/movements')
+  @BookingStaff(FREIGHT_PERMS.warehouseInventory.view)
   @ApiOperation({ summary: 'Inventory movement history' })
   movements(@Param('id', ParseUUIDPipe) id: string) {
     return this.inventoryService.findMovements(id);
   }
 
   @Get(':id/activity')
+  @BookingStaff(FREIGHT_PERMS.warehouseInventory.view)
   @ApiOperation({ summary: 'Inventory activity log' })
   activity(@Param('id', ParseUUIDPipe) id: string) {
     return this.inventoryService.findActivity(id);
   }
 
   @Get(':id/loadings')
+  @BookingStaff(FREIGHT_PERMS.warehouseInventory.view)
   @ApiOperation({ summary: 'Loading records for an inventory item' })
   loadings(@Param('id', ParseUUIDPipe) id: string) {
     return this.inventoryService.findLoadingsByInventory(id);
   }
 
   @Post(':id/move')
+  @BookingStaff(FREIGHT_PERMS.warehouseInventory.move)
   @ApiOperation({ summary: 'Move inventory to another warehouse/yard/zone' })
   move(@Param('id', ParseUUIDPipe) id: string, @Body() dto: MoveInventoryDto) {
     return this.inventoryService.move(id, dto);
   }
 
   @Post(':id/store')
+  @BookingStaff(FREIGHT_PERMS.warehouseInventory.move)
   @ApiOperation({ summary: 'Mark received inventory as STORED (optional explicit warehouse/yard/zone)' })
   store(@Param('id', ParseUUIDPipe) id: string, @Body() dto: StoreInventoryDto) {
     return this.inventoryService.store(id, dto.performedBy, dto);
   }
 
   @Post(':id/ready-for-loading')
+  @BookingStaff(FREIGHT_PERMS.warehouseInventory.move)
   @ApiOperation({ summary: 'Mark reserved inventory READY_FOR_LOADING' })
   readyForLoading(@Param('id', ParseUUIDPipe) id: string, @Body('performedBy') performedBy?: string) {
     return this.inventoryService.readyForLoading(id, performedBy);
   }
 
   @Post(':id/load')
+  @BookingStaff(FREIGHT_PERMS.warehouseInventory.load)
   @ApiOperation({ summary: 'Load READY_FOR_LOADING inventory onto a wagon' })
   load(@Param('id', ParseUUIDPipe) id: string, @Body() dto: LoadInventoryDto) {
     return this.inventoryService.load(id, dto);
   }
 
   @Post(':id/ready-for-pickup')
+  @BookingStaff(FREIGHT_PERMS.warehouseInventory.move)
   @ApiOperation({ summary: 'Mark inspected IMPORT inventory READY_FOR_PICKUP' })
   readyForPickup(@Param('id', ParseUUIDPipe) id: string, @Body('performedBy') performedBy?: string) {
     return this.inventoryService.readyForPickup(id, performedBy);
   }
 
   @Post(':id/release')
+  @BookingStaff(FREIGHT_PERMS.warehouseInventory.release)
   @ApiOperation({ summary: 'Issue a DO / release order for ready-for-pickup inventory' })
   release(@Param('id', ParseUUIDPipe) id: string, @Body() dto: ReleaseOrderDto) {
     return this.inventoryService.release(id, dto);
   }
 
   @Get(':id/release-document')
+  @BookingStaff(FREIGHT_PERMS.warehouseInventory.view)
   @ApiOperation({ summary: 'View warehouse release / exit paper PDF' })
   async releaseDocument(@Param('id', ParseUUIDPipe) id: string, @Res() res: Response) {
     const { filename, buffer } = await this.inventoryService.releaseDocument(id);
@@ -309,6 +360,7 @@ export class WarehouseInventoryController {
   }
 
   @Get('customer-truck-exit-paper/:assignmentId')
+  @BookingStaff(FREIGHT_PERMS.warehouseInventory.view)
   @ApiOperation({ summary: 'Per-truck exit paper PDF (containers loaded on one customer truck)' })
   async truckExitPaper(
     @Param('assignmentId', ParseUUIDPipe) assignmentId: string,
@@ -322,6 +374,7 @@ export class WarehouseInventoryController {
   }
 
   @Get(':id/grn-document')
+  @BookingStaff(FREIGHT_PERMS.warehouseInventory.view)
   @ApiOperation({ summary: 'View goods received note PDF' })
   async grnDocument(@Param('id', ParseUUIDPipe) id: string, @Res() res: Response) {
     const { filename, buffer } = await this.inventoryService.grnDocument(id);
@@ -342,12 +395,17 @@ export class WarehouseInventoryController {
   }
 
   @Post('bookings/:bookingId/approve-delivery')
-  @ApiOperation({ summary: "Approve delivery using the current customer's saved signature" })
+  @ApiOperation({ summary: "Approve delivery — customer records their full name (signature optional)" })
   approveDeliveryForBooking(
     @Param('bookingId', ParseUUIDPipe) bookingId: string,
+    @Body() dto: ApproveDeliveryDto,
     @Request() req: { user?: { id?: string; sub?: string } },
   ) {
-    return this.inventoryService.approveDeliveryForBooking(bookingId, req.user?.id ?? req.user?.sub);
+    return this.inventoryService.approveDeliveryForBooking(
+      bookingId,
+      req.user?.id ?? req.user?.sub,
+      dto.signerName,
+    );
   }
 
   @Get('bookings/:bookingId/handovers')
@@ -362,6 +420,26 @@ export class WarehouseInventoryController {
     return this.handoverService.requestSignature(bookingId);
   }
 
+  @Get('bookings/:bookingId/grn-document')
+  @ApiOperation({ summary: 'View GRN PDF for a booking (customer portal)' })
+  async bookingGrnDocument(@Param('bookingId', ParseUUIDPipe) bookingId: string, @Res() res: Response) {
+    const { filename, buffer } = await this.inventoryService.grnDocumentForBooking(bookingId);
+    res.setHeader('Content-Type', 'application/pdf');
+    res.setHeader('Content-Disposition', `inline; filename="${filename}"`);
+    res.setHeader('Content-Length', buffer.length);
+    return res.send(buffer);
+  }
+
+  @Get('bookings/:bookingId/release-document')
+  @ApiOperation({ summary: 'View gate-clearance / release-order PDF for a booking (customer portal)' })
+  async bookingReleaseDocument(@Param('bookingId', ParseUUIDPipe) bookingId: string, @Res() res: Response) {
+    const { filename, buffer } = await this.inventoryService.releaseDocumentForBooking(bookingId);
+    res.setHeader('Content-Type', 'application/pdf');
+    res.setHeader('Content-Disposition', `inline; filename="${filename}"`);
+    res.setHeader('Content-Length', buffer.length);
+    return res.send(buffer);
+  }
+
   @Get('bookings/:bookingId/handover-document')
   @ApiOperation({ summary: 'View import goods handover document PDF (resolved by booking)' })
   async bookingHandoverDocument(@Param('bookingId', ParseUUIDPipe) bookingId: string, @Res() res: Response) {
@@ -385,12 +463,14 @@ export class WarehouseInventoryController {
   }
 
   @Post(':id/deliver')
+  @BookingStaff(FREIGHT_PERMS.warehouseInventory.deliver)
   @ApiOperation({ summary: 'Deliver import goods to the customer + capture proof of delivery' })
   deliver(@Param('id', ParseUUIDPipe) id: string, @Body() dto: DeliverInventoryDto) {
     return this.inventoryService.deliver(id, dto);
   }
 
   @Patch(':id/dispatch')
+  @BookingStaff(FREIGHT_PERMS.warehouseInventory.dispatch)
   @ApiOperation({ summary: 'Mark loaded inventory DISPATCHED (left the terminal)' })
   dispatch(@Param('id', ParseUUIDPipe) id: string, @Body('performedBy') performedBy?: string) {
     return this.inventoryService.dispatch(id, performedBy);
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 7c8edcce0..9a42bc895 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
@@ -397,6 +397,45 @@ export class WarehouseInventoryService {
    * but has no customer truck assigned yet, nudge the customer to assign one — with
    * a deep-link to the booking's truck-assignment card. Fire-and-forget.
    */
+  /**
+   * At-a-glance warehouse ops counters for the KPI strip:
+   *  - receivedToday: items received today
+   *  - pendingInspection: RECEIVED items not yet inspected
+   *  - trucksOnSite: customer trucks arrived but not departed
+   *  - itemsAging: in-warehouse items older than 7 days (demurrage risk)
+   */
+  async opsStats(): Promise<{
+    receivedToday: number;
+    pendingInspection: number;
+    trucksOnSite: number;
+    itemsAging: number;
+  }> {
+    const [row]: Array<{
+      receivedToday: number;
+      pendingInspection: number;
+      trucksOnSite: number;
+      itemsAging: number;
+    }> = await this.dataSource.query(
+      `SELECT
+         (SELECT count(*)::int FROM freight.warehouse_inventory
+           WHERE deleted_at IS NULL AND created_at::date = CURRENT_DATE) AS "receivedToday",
+         (SELECT count(*)::int FROM freight.warehouse_inventory
+           WHERE deleted_at IS NULL AND status = 'RECEIVED' AND inspection_status IS NULL) AS "pendingInspection",
+         (SELECT count(*)::int FROM freight.customer_truck_assignments
+           WHERE deleted_at IS NULL AND arrived_at IS NOT NULL AND departed_at IS NULL) AS "trucksOnSite",
+         (SELECT count(*)::int FROM freight.warehouse_inventory
+           WHERE deleted_at IS NULL
+             AND status IN ('RECEIVED', 'STORED', 'READY_FOR_LOADING', 'READY_FOR_PICKUP', 'RESERVED')
+             AND created_at < now() - interval '7 days') AS "itemsAging"`,
+    );
+    return {
+      receivedToday: row?.receivedToday ?? 0,
+      pendingInspection: row?.pendingInspection ?? 0,
+      trucksOnSite: row?.trucksOnSite ?? 0,
+      itemsAging: row?.itemsAging ?? 0,
+    };
+  }
+
   /**
    * Live occupancy per zone: rated capacity vs the weight/items currently held
    * (excludes items that have left — DELIVERED/DISPATCHED). Powers the yard
@@ -454,14 +493,17 @@ export class WarehouseInventoryService {
 
     return rows.map((r) => {
       const capWeight = r.capacityWeight != null ? Number(r.capacityWeight) : null;
+      // Zone capacity_weight is in TONNES; inventory weight is in KG — normalise
+      // used weight to tonnes before comparing so weight occupancy is correct.
+      const usedWeightTons = r.usedWeight / 1000;
       const byWeight =
-        capWeight && capWeight > 0 ? (r.usedWeight / capWeight) * 100 : null;
+        capWeight && capWeight > 0 ? (usedWeightTons / capWeight) * 100 : null;
       const byItems =
         r.capacityContainers && r.capacityContainers > 0
           ? (r.usedItems / r.capacityContainers) * 100
           : null;
-      // Prefer container-count occupancy (unit-consistent). Weight capacity is
-      // tonnes while inventory weight is kg, so weight% is only a rough fallback.
+      // Container zones use item-count occupancy; bulk zones (no container cap)
+      // fall back to the now unit-correct weight occupancy.
       const pct = byItems ?? byWeight;
       return {
         id: r.id,
@@ -2788,6 +2830,7 @@ export class WarehouseInventoryService {
     Array<{
       containerNumber: string;
       goods: string | null;
+      containerSize: string | null;
       stage: 'PENDING' | 'RECEIVED' | 'GRN' | 'ASSIGNED' | 'LOADED' | 'LEFT' | 'DELIVERED';
       grnNumber: string | null;
       truckAssignmentId: string | null;
@@ -2804,6 +2847,7 @@ export class WarehouseInventoryService {
     const rows: Array<{
       containerNumber: string;
       goods: string | null;
+      containerSize: string | null;
       received: boolean;
       grnNumber: string | null;
       truckAssignmentId: string | null;
@@ -2818,6 +2862,7 @@ export class WarehouseInventoryService {
     }> = await this.dataSource.query(
       `SELECT bcu.container_number AS "containerNumber",
               COALESCE(ct.cargo_type_name, b.cargo_free_text) AS goods,
+              bc.container_size AS "containerSize",
               bcu.received_to_port AS received,
               bcu.grn_number AS "grnNumber",
               ctc.assignment_id AS "truckAssignmentId",
@@ -2854,6 +2899,7 @@ export class WarehouseInventoryService {
     return rows.map((r) => ({
       containerNumber: r.containerNumber,
       goods: r.goods,
+      containerSize: r.containerSize,
       // A container the customer assigned to a truck is ASSIGNED (planned); it
       // only becomes LOADED once the operator loads it (loaded_at) on truck
       // leaving. Departed → LEFT, delivered → DELIVERED.
@@ -3132,16 +3178,20 @@ export class WarehouseInventoryService {
   async approveDeliveryForBooking(
     bookingId: string,
     userId?: string,
+    signerName?: string,
   ): Promise<{ bookingId: string; inventoryId: string; approvedAt: string; signerDisplayName: string }> {
     if (!userId) {
       throw new BadRequestException('Authentication is required to approve delivery');
     }
-
-    const signature = await this.signatures.getForUser(userId);
-    if (!signature?.signatureImageUrl) {
-      throw new BadRequestException('Please save your signature before approving delivery');
+    const name = signerName?.trim();
+    if (!name) {
+      throw new BadRequestException('Please enter your full name to approve delivery');
     }
 
+    // A saved signature is applied when available; otherwise the typed full name
+    // is the record of who approved (self-haul customers may have no signature).
+    const signature = await this.signatures.getForUser(userId).catch(() => null);
+
     const [item]: Array<{
       id: string;
       warehouseId: string | null;
@@ -3176,8 +3226,8 @@ export class WarehouseInventoryService {
     const approvedAt = new Date();
     const approval = {
       approvedAt: approvedAt.toISOString(),
-      signerDisplayName: signature.signerDisplayName,
-      signatureImageUrl: signature.signatureImageUrl,
+      signerDisplayName: name,
+      signatureImageUrl: signature?.signatureImageUrl ?? null,
       userId,
     };
     const existingNotes = this.stripCustomerDeliveryApproval(item.notes);
@@ -3192,8 +3242,8 @@ export class WarehouseInventoryService {
           activityType: 'INVENTORY_RELEASED',
           inventoryId: item.id,
           warehouseId: item.warehouseId,
-          description: `Customer approved delivery as ${signature.signerDisplayName}`,
-          performedBy: signature.signerDisplayName,
+          description: `Customer approved delivery as ${name}`,
+          performedBy: name,
         },
         manager,
       );
@@ -3201,13 +3251,13 @@ export class WarehouseInventoryService {
 
     // Sign the structured handover record(s) for this booking (self-haul: before
     // the truck leaves). Kept alongside the legacy approval note.
-    await this.handover.signForBooking(bookingId, userId);
+    await this.handover.signForBooking(bookingId, userId, name);
 
     return {
       bookingId,
       inventoryId: item.id,
       approvedAt: approval.approvedAt,
-      signerDisplayName: signature.signerDisplayName,
+      signerDisplayName: name,
     };
   }
 
@@ -3226,6 +3276,31 @@ export class WarehouseInventoryService {
     return this.handoverDocument(inv.id);
   }
 
+  /** Resolve the primary warehouse-inventory item for a booking (most recent). */
+  private async primaryInventoryIdForBooking(bookingId: string): Promise<string> {
+    const [inv]: Array<{ id: string }> = await this.dataSource.query(
+      `SELECT id FROM freight.warehouse_inventory
+        WHERE booking_id = $1 AND deleted_at IS NULL
+        ORDER BY updated_at DESC NULLS LAST, created_at DESC
+        LIMIT 1`,
+      [bookingId],
+    );
+    if (!inv) {
+      throw new NotFoundException(`No warehouse inventory found for booking ${bookingId}`);
+    }
+    return inv.id;
+  }
+
+  /** Booking-scoped GRN document (customer portal). */
+  async grnDocumentForBooking(bookingId: string): Promise<{ filename: string; buffer: Buffer }> {
+    return this.grnDocument(await this.primaryInventoryIdForBooking(bookingId));
+  }
+
+  /** Booking-scoped gate-clearance / release document (customer portal). */
+  async releaseDocumentForBooking(bookingId: string): Promise<{ filename: string; buffer: Buffer }> {
+    return this.releaseDocument(await this.primaryInventoryIdForBooking(bookingId));
+  }
+
   async handoverDocument(id: string): Promise<{ filename: string; buffer: Buffer }> {
     const [row] = await this.dataSource.query(
       `SELECT inv.id,
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 a1c5db837..635ca1a10 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
@@ -2,6 +2,8 @@ import { Body, Controller, Get, Param, ParseUUIDPipe, Patch, Post, Query, Res }
 import { ApiBearerAuth, ApiOperation, ApiTags } from '@nestjs/swagger';
 import type { Response } from 'express';
 
+import { BookingStaff } from '../../common/booking-guards';
+import { FREIGHT_PERMS } from '../../seed/freight-permissions.registry';
 import { PayInvoiceDto as GatewayPayInvoiceDto } from '../billing/dto/pay-invoice.dto';
 import { GenerateInvoiceDto, PayInvoiceBodyDto } from './dto/invoice.dto';
 import { WarehouseInvoiceService } from './warehouse-invoice.service';
@@ -13,12 +15,14 @@ export class WarehouseInvoiceController {
   constructor(private readonly invoiceService: WarehouseInvoiceService) {}
 
   @Post('warehouse-inventory/:id/generate-fee-invoice')
+  @BookingStaff(FREIGHT_PERMS.warehouseFeeInvoices.generate)
   @ApiOperation({ summary: 'Generate a warehouse fee invoice from Batch 5 fee calculation' })
   generate(@Param('id', ParseUUIDPipe) id: string, @Body() dto: GenerateInvoiceDto) {
     return this.invoiceService.generateForInventory(id, dto);
   }
 
   @Post('last-mile/:id/generate-truck-detention-invoice')
+  @BookingStaff(FREIGHT_PERMS.warehouseFeeInvoices.generate)
   @ApiOperation({ summary: 'Generate a truck-detention invoice for a last-mile leg (per truck per day)' })
   generateTruckDetention(
     @Param('id', ParseUUIDPipe) id: string,
@@ -28,6 +32,7 @@ export class WarehouseInvoiceController {
   }
 
   @Get('warehouse-inventory/:id/fee-invoices')
+  @BookingStaff(FREIGHT_PERMS.warehouseFeeInvoices.view)
   @ApiOperation({ summary: 'List fee invoices for an inventory item' })
   listForInventory(@Param('id', ParseUUIDPipe) id: string) {
     return this.invoiceService.listForInventory(id);
@@ -40,6 +45,7 @@ export class WarehouseInvoiceController {
   }
 
   @Get('warehouse-fee-invoices')
+  @BookingStaff(FREIGHT_PERMS.warehouseFeeInvoices.view)
   @ApiOperation({ summary: 'List / filter warehouse fee invoices' })
   findAll(
     @Query('status') status?: string,
@@ -86,12 +92,14 @@ export class WarehouseInvoiceController {
   }
 
   @Patch('warehouse-fee-invoices/:id/cancel')
+  @BookingStaff(FREIGHT_PERMS.warehouseFeeInvoices.cancel)
   @ApiOperation({ summary: 'Cancel a warehouse fee invoice' })
   cancel(@Param('id', ParseUUIDPipe) id: string) {
     return this.invoiceService.cancel(id);
   }
 
   @Post('warehouse-fee-invoices/:id/pay')
+  @BookingStaff(FREIGHT_PERMS.warehouseFeeInvoices.pay)
   @ApiOperation({ summary: 'Record a payment against a warehouse fee invoice' })
   pay(@Param('id', ParseUUIDPipe) id: string, @Body() dto: PayInvoiceBodyDto) {
     return this.invoiceService.pay(id, dto);
diff --git a/apps/edr-freight-api/src/modules/warehouses/warehouse-loadings.controller.ts b/apps/edr-freight-api/src/modules/warehouses/warehouse-loadings.controller.ts
index aab8e18b2..32860082e 100644
--- a/apps/edr-freight-api/src/modules/warehouses/warehouse-loadings.controller.ts
+++ b/apps/edr-freight-api/src/modules/warehouses/warehouse-loadings.controller.ts
@@ -1,11 +1,14 @@
 import { Controller, Get, Query } from '@nestjs/common';
 import { ApiBearerAuth, ApiOperation, ApiTags } from '@nestjs/swagger';
 
+import { BookingStaff } from '../../common/booking-guards';
+import { FREIGHT_PERMS } from '../../seed/freight-permissions.registry';
 import { WarehouseInventoryService } from './warehouse-inventory.service';
 
 @ApiTags('warehouse-loadings')
 @ApiBearerAuth()
 @Controller('warehouse-loadings')
+@BookingStaff(FREIGHT_PERMS.warehouseInventory.view)
 export class WarehouseLoadingsController {
   constructor(private readonly inventoryService: WarehouseInventoryService) {}
 
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 d35587d9e..7a5c53d38 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
@@ -1,12 +1,15 @@
 import { Body, Controller, Delete, Get, HttpCode, Param, ParseUUIDPipe, Patch, Post, Query } from '@nestjs/common';
 import { ApiBearerAuth, ApiOperation, ApiTags } from '@nestjs/swagger';
 
+import { BookingStaff } from '../../common/booking-guards';
+import { FREIGHT_PERMS } from '../../seed/freight-permissions.registry';
 import {
   AllocationPreviewDto,
   CreateAllocationRuleDto,
   UpdateAllocationRuleDto,
 } from './dto/allocation-rule.dto';
 import { CreateFeeRuleDto, UpdateFeeRuleDto } from './dto/fee-rule.dto';
+import { AcknowledgeAccrualDto } from './dto/acknowledge-accrual.dto';
 import { WarehouseAllocationService } from './warehouse-allocation.service';
 import { WarehouseFeeService } from './warehouse-fee.service';
 
@@ -21,18 +24,21 @@ export class WarehouseRulesController {
 
   // ── Allocation rules ───────────────────────────────────────────────────────
   @Get('warehouse-allocation-rules')
+  @BookingStaff(FREIGHT_PERMS.warehouseAllocationRules.view)
   @ApiOperation({ summary: 'List warehouse allocation rules' })
   listAllocationRules() {
     return this.allocationService.listRules();
   }
 
   @Post('warehouse-allocation-rules')
+  @BookingStaff(FREIGHT_PERMS.warehouseAllocationRules.create)
   @ApiOperation({ summary: 'Create a warehouse allocation rule' })
   createAllocationRule(@Body() dto: CreateAllocationRuleDto) {
     return this.allocationService.createRule(dto);
   }
 
   @Patch('warehouse-allocation-rules/:id')
+  @BookingStaff(FREIGHT_PERMS.warehouseAllocationRules.update)
   @ApiOperation({ summary: 'Update a warehouse allocation rule' })
   updateAllocationRule(@Param('id', ParseUUIDPipe) id: string, @Body() dto: UpdateAllocationRuleDto) {
     return this.allocationService.updateRule(id, dto);
@@ -40,12 +46,14 @@ export class WarehouseRulesController {
 
   @Delete('warehouse-allocation-rules/:id')
   @HttpCode(204)
+  @BookingStaff(FREIGHT_PERMS.warehouseAllocationRules.delete)
   @ApiOperation({ summary: 'Delete a warehouse allocation rule' })
   deleteAllocationRule(@Param('id', ParseUUIDPipe) id: string) {
     return this.allocationService.deleteRule(id);
   }
 
   @Post('warehouse-allocation/preview')
+  @BookingStaff(FREIGHT_PERMS.warehouseAllocationRules.view)
   @ApiOperation({ summary: 'Preview the yard/warehouse/zone a booking would be allocated to' })
   previewAllocation(@Body() dto: AllocationPreviewDto) {
     return this.allocationService.resolveLocation(dto);
@@ -53,18 +61,21 @@ export class WarehouseRulesController {
 
   // ── Fee rules ────────────────────────────────────────────────────────────────
   @Get('warehouse-fee-rules')
+  @BookingStaff(FREIGHT_PERMS.warehouseFeeRules.view)
   @ApiOperation({ summary: 'List storage / demurrage fee rules' })
   listFeeRules() {
     return this.feeService.listRules();
   }
 
   @Post('warehouse-fee-rules')
+  @BookingStaff(FREIGHT_PERMS.warehouseFeeRules.create)
   @ApiOperation({ summary: 'Create a storage / demurrage fee rule' })
   createFeeRule(@Body() dto: CreateFeeRuleDto) {
     return this.feeService.createRule(dto);
   }
 
   @Patch('warehouse-fee-rules/:id')
+  @BookingStaff(FREIGHT_PERMS.warehouseFeeRules.update)
   @ApiOperation({ summary: 'Update a fee rule' })
   updateFeeRule(@Param('id', ParseUUIDPipe) id: string, @Body() dto: UpdateFeeRuleDto) {
     return this.feeService.updateRule(id, dto);
@@ -72,12 +83,42 @@ export class WarehouseRulesController {
 
   @Delete('warehouse-fee-rules/:id')
   @HttpCode(204)
+  @BookingStaff(FREIGHT_PERMS.warehouseFeeRules.delete)
   @ApiOperation({ summary: 'Delete a fee rule' })
   deleteFeeRule(@Param('id', ParseUUIDPipe) id: string) {
     return this.feeService.deleteRule(id);
   }
 
+  @Get('warehouse-fees/accrual-dashboard')
+  @BookingStaff(FREIGHT_PERMS.warehouseFeeRules.view)
+  @ApiOperation({ summary: 'Live per-item fee accrual (storage/demurrage) with alerts' })
+  accrualDashboard(@Query('billingCurrency') billingCurrency?: string) {
+    return this.feeService.accrualDashboard(billingCurrency);
+  }
+
+  @Post('warehouse-fees/accrual/:inventoryId/acknowledge')
+  @BookingStaff(FREIGHT_PERMS.warehouseFeeRules.update)
+  @ApiOperation({ summary: 'Acknowledge / snooze an item fee-accrual alert' })
+  acknowledgeAccrual(
+    @Param('inventoryId', ParseUUIDPipe) inventoryId: string,
+    @Body() dto: AcknowledgeAccrualDto,
+  ) {
+    return this.feeService.acknowledgeAccrual(inventoryId, {
+      snoozeDays: dto.snoozeDays,
+      note: dto.note,
+    });
+  }
+
+  @Delete('warehouse-fees/accrual/:inventoryId/acknowledge')
+  @HttpCode(204)
+  @BookingStaff(FREIGHT_PERMS.warehouseFeeRules.update)
+  @ApiOperation({ summary: 'Remove an accrual acknowledgement (re-surface for alerts)' })
+  unacknowledgeAccrual(@Param('inventoryId', ParseUUIDPipe) inventoryId: string) {
+    return this.feeService.unacknowledgeAccrual(inventoryId);
+  }
+
   @Get('warehouse-inventory/:id/fee-preview')
+  @BookingStaff(FREIGHT_PERMS.warehouseFeeRules.view)
   @ApiOperation({ summary: 'Preview demurrage + storage fees for an inventory item' })
   feePreview(
     @Param('id', ParseUUIDPipe) id: string,
@@ -87,6 +128,7 @@ export class WarehouseRulesController {
   }
 
   @Get('last-mile/:id/truck-detention-preview')
+  @BookingStaff(FREIGHT_PERMS.warehouseFeeRules.view)
   @ApiOperation({ summary: 'Preview truck detention for a last-mile leg (per truck per day after grace)' })
   truckDetentionPreview(
     @Param('id', ParseUUIDPipe) id: string,
diff --git a/apps/edr-freight-api/src/modules/warehouses/warehouse-yards.controller.ts b/apps/edr-freight-api/src/modules/warehouses/warehouse-yards.controller.ts
index c14cea7a4..fdfbc36be 100644
--- a/apps/edr-freight-api/src/modules/warehouses/warehouse-yards.controller.ts
+++ b/apps/edr-freight-api/src/modules/warehouses/warehouse-yards.controller.ts
@@ -1,6 +1,8 @@
 import { Body, Controller, Get, Param, ParseUUIDPipe, Patch, Post } from '@nestjs/common';
 import { ApiBearerAuth, ApiOperation, ApiTags } from '@nestjs/swagger';
 
+import { BookingStaff } from '../../common/booking-guards';
+import { FREIGHT_PERMS } from '../../seed/freight-permissions.registry';
 import { CreateWarehouseZoneDto } from './dto/create-warehouse-zone.dto';
 import { UpdateWarehouseYardDto } from './dto/update-warehouse-yard.dto';
 import { WarehouseYardsService } from './warehouse-yards.service';
@@ -9,6 +11,7 @@ import { WarehouseZonesService } from './warehouse-zones.service';
 @ApiTags('warehouse-yards')
 @ApiBearerAuth()
 @Controller('warehouse-yards')
+@BookingStaff(FREIGHT_PERMS.warehouseYards.view)
 export class WarehouseYardsController {
   constructor(
     private readonly yardsService: WarehouseYardsService,
@@ -28,18 +31,21 @@ export class WarehouseYardsController {
   }
 
   @Patch(':id')
+  @BookingStaff(FREIGHT_PERMS.warehouseYards.update)
   @ApiOperation({ summary: 'Update warehouse yard' })
   update(@Param('id', ParseUUIDPipe) id: string, @Body() dto: UpdateWarehouseYardDto) {
     return this.yardsService.update(id, dto);
   }
 
   @Get(':yardId/zones')
+  @BookingStaff(FREIGHT_PERMS.warehouseZones.view)
   @ApiOperation({ summary: 'List zones within a yard' })
   listZones(@Param('yardId', ParseUUIDPipe) yardId: string) {
     return this.zonesService.findByYard(yardId);
   }
 
   @Post(':yardId/zones')
+  @BookingStaff(FREIGHT_PERMS.warehouseZones.create)
   @ApiOperation({ summary: 'Create a zone within a yard' })
   createZone(
     @Param('yardId', ParseUUIDPipe) yardId: string,
diff --git a/apps/edr-freight-api/src/modules/warehouses/warehouse-zones.controller.ts b/apps/edr-freight-api/src/modules/warehouses/warehouse-zones.controller.ts
index 7d51feac3..b0371cbcc 100644
--- a/apps/edr-freight-api/src/modules/warehouses/warehouse-zones.controller.ts
+++ b/apps/edr-freight-api/src/modules/warehouses/warehouse-zones.controller.ts
@@ -1,12 +1,15 @@
 import { Body, Controller, Get, Param, ParseUUIDPipe, Patch } from '@nestjs/common';
 import { ApiBearerAuth, ApiOperation, ApiTags } from '@nestjs/swagger';
 
+import { BookingStaff } from '../../common/booking-guards';
+import { FREIGHT_PERMS } from '../../seed/freight-permissions.registry';
 import { UpdateWarehouseZoneDto } from './dto/update-warehouse-zone.dto';
 import { WarehouseZonesService } from './warehouse-zones.service';
 
 @ApiTags('warehouse-zones')
 @ApiBearerAuth()
 @Controller('warehouse-zones')
+@BookingStaff(FREIGHT_PERMS.warehouseZones.view)
 export class WarehouseZonesController {
   constructor(private readonly zonesService: WarehouseZonesService) {}
 
@@ -23,6 +26,7 @@ export class WarehouseZonesController {
   }
 
   @Patch(':id')
+  @BookingStaff(FREIGHT_PERMS.warehouseZones.update)
   @ApiOperation({ summary: 'Update warehouse zone' })
   update(@Param('id', ParseUUIDPipe) id: string, @Body() dto: UpdateWarehouseZoneDto) {
     return this.zonesService.update(id, dto);
diff --git a/apps/edr-freight-api/src/modules/warehouses/warehouses.controller.ts b/apps/edr-freight-api/src/modules/warehouses/warehouses.controller.ts
index bb7702603..63c40de94 100644
--- a/apps/edr-freight-api/src/modules/warehouses/warehouses.controller.ts
+++ b/apps/edr-freight-api/src/modules/warehouses/warehouses.controller.ts
@@ -1,6 +1,8 @@
 import { Body, Controller, Get, Param, ParseUUIDPipe, Patch, Post, Query } from '@nestjs/common';
 import { ApiBearerAuth, ApiOperation, ApiTags } from '@nestjs/swagger';
 
+import { BookingStaff } from '../../common/booking-guards';
+import { FREIGHT_PERMS } from '../../seed/freight-permissions.registry';
 import { CreateWarehouseDto } from './dto/create-warehouse.dto';
 import { CreateWarehouseYardDto } from './dto/create-warehouse-yard.dto';
 import { FilterWarehouseDto } from './dto/filter-warehouse.dto';
@@ -12,6 +14,7 @@ import { WarehousesService } from './warehouses.service';
 @ApiTags('warehouses')
 @ApiBearerAuth()
 @Controller('warehouses')
+@BookingStaff(FREIGHT_PERMS.warehouses.view)
 export class WarehousesController {
   constructor(
     private readonly warehousesService: WarehousesService,
@@ -26,12 +29,14 @@ export class WarehousesController {
   }
 
   @Get('dashboard')
+  @BookingStaff(FREIGHT_PERMS.warehouseDashboard.view)
   @ApiOperation({ summary: 'Warehouse dashboard metrics' })
   dashboard() {
     return this.dashboardService.getDashboard();
   }
 
   @Post()
+  @BookingStaff(FREIGHT_PERMS.warehouses.create)
   @ApiOperation({ summary: 'Create warehouse' })
   create(@Body() dto: CreateWarehouseDto) {
     return this.warehousesService.create(dto);
@@ -44,18 +49,21 @@ export class WarehousesController {
   }
 
   @Patch(':id')
+  @BookingStaff(FREIGHT_PERMS.warehouses.update)
   @ApiOperation({ summary: 'Update warehouse' })
   update(@Param('id', ParseUUIDPipe) id: string, @Body() dto: UpdateWarehouseDto) {
     return this.warehousesService.update(id, dto);
   }
 
   @Get(':warehouseId/yards')
+  @BookingStaff(FREIGHT_PERMS.warehouseYards.view)
   @ApiOperation({ summary: 'List yards within a warehouse' })
   listYards(@Param('warehouseId', ParseUUIDPipe) warehouseId: string) {
     return this.yardsService.findByWarehouse(warehouseId);
   }
 
   @Post(':warehouseId/yards')
+  @BookingStaff(FREIGHT_PERMS.warehouseYards.create)
   @ApiOperation({ summary: 'Create a yard within a warehouse' })
   createYard(
     @Param('warehouseId', ParseUUIDPipe) warehouseId: string,
diff --git a/apps/edr-freight-api/src/seed/freight-permissions.registry.ts b/apps/edr-freight-api/src/seed/freight-permissions.registry.ts
index e281e6464..6e4ec81b1 100644
--- a/apps/edr-freight-api/src/seed/freight-permissions.registry.ts
+++ b/apps/edr-freight-api/src/seed/freight-permissions.registry.ts
@@ -175,6 +175,9 @@ export const FLEET_RAIL_PERMISSIONS: FreightPermissionSeed[] = [
   perm('e1b00001-0001-4000-8000-000000000002', 'edr_freight_app:wagons:create', 'Create wagon'),
   perm('e1b00001-0001-4000-8000-000000000003', 'edr_freight_app:wagons:update', 'Update wagon'),
   perm('e1b00001-0001-4000-8000-000000000004', 'edr_freight_app:wagons:delete', 'Delete wagon'),
+  perm('e1b00001-0001-4000-8000-000000000005', 'edr_freight_app:wagons:transfer_request', 'Request wagon transfer'),
+  perm('e1b00001-0001-4000-8000-000000000006', 'edr_freight_app:wagons:transfer_fulfill', 'Fulfil wagon transfer (OCC)'),
+  perm('e1b00001-0001-4000-8000-000000000007', 'edr_freight_app:wagons:transfer_history_all', "View all staff's transfer history"),
   perm('e1c00001-0001-4000-8000-000000000001', 'edr_freight_app:trains:view', 'View trains'),
   perm('e1c00001-0001-4000-8000-000000000002', 'edr_freight_app:trains:create', 'Create train'),
   perm('e1c00001-0001-4000-8000-000000000003', 'edr_freight_app:trains:update', 'Update train'),
@@ -440,6 +443,13 @@ export const FREIGHT_PERMS = {
     create: 'edr_freight_app:wagons:create',
     update: 'edr_freight_app:wagons:update',
     delete: 'edr_freight_app:wagons:delete',
+    // Requester creates a transfer request; OCC fulfils it (picks the wagons and
+    // executes the move). Distinct keys so OCC can hold fulfil without request.
+    transferRequest: 'edr_freight_app:wagons:transfer_request',
+    transferFulfill: 'edr_freight_app:wagons:transfer_fulfill',
+    // Admin: read every staffer's transfer history. Without it, a user only sees
+    // their own (the /history endpoint uses the caller id, backend-enforced).
+    transferHistoryAll: 'edr_freight_app:wagons:transfer_history_all',
   },
   trains: {
     view: 'edr_freight_app:trains:view',
diff --git a/apps/edr-freight-web/backoffice/src/App.tsx b/apps/edr-freight-web/backoffice/src/App.tsx
index 18e291872..0da9fe3f0 100644
--- a/apps/edr-freight-web/backoffice/src/App.tsx
+++ b/apps/edr-freight-web/backoffice/src/App.tsx
@@ -4,6 +4,7 @@ import {
   Container,
   FileSignature,
   FileText,
+  Hammer,
   LayoutDashboard,
   LayoutGrid,
   MapPin,
@@ -109,6 +110,8 @@ import ContractValidityPeriodsPage from "./pages/configuration/ContractValidityP
 import FirstMilePage from "./pages/operations/FirstMilePage";
 import LastMilePage from "./pages/operations/LastMilePage";
 import TrainDetailPage from "./pages/trains/TrainDetailPage";
+import TrainBuilderDetailPage from "./pages/trainBuilder/TrainBuilderDetailPage";
+import TrainBuilderListPage from "./pages/trainBuilder/TrainBuilderListPage";
 import ArrivalQueuePage from "./pages/warehouses/ArrivalQueuePage";
 import DispatchQueuePage from "./pages/warehouses/DispatchQueuePage";
 import ExportDjiboutiUnloadingQueuePage from "./pages/warehouses/ExportDjiboutiUnloadingQueuePage";
@@ -261,6 +264,12 @@ const buildSidebarSections = (demoItems: SidebarItem[]): SidebarSection[] => [
         icon: <Train />,
         permission: FREIGHT_PERMS.fleet.view,
       },
+      {
+        label: "Train Builder",
+        href: "/dashboard/train-builder",
+        icon: <Hammer />,
+        permission: FREIGHT_PERMS.fleet.view,
+      },
 
       // {
       //   label: "Wagon types",
@@ -1032,6 +1041,22 @@ const App = () => {
             </RequirePermission>
           }
         />
+        <Route
+          path="train-builder"
+          element={
+            <RequirePermission permission={FREIGHT_PERMS.fleet.view}>
+              <TrainBuilderListPage />
+            </RequirePermission>
+          }
+        />
+        <Route
+          path="train-builder/:id"
+          element={
+            <RequirePermission permission={FREIGHT_PERMS.fleet.view}>
+              <TrainBuilderDetailPage />
+            </RequirePermission>
+          }
+        />
         <Route
           path="wagons"
           element={
@@ -1246,6 +1271,22 @@ const App = () => {
             </RequirePermission>
           }
         />
+        <Route
+          path="train-builder"
+          element={
+            <RequirePermission permission={FREIGHT_PERMS.fleet.view}>
+              <TrainBuilderListPage />
+            </RequirePermission>
+          }
+        />
+        <Route
+          path="train-builder/:id"
+          element={
+            <RequirePermission permission={FREIGHT_PERMS.fleet.view}>
+              <TrainBuilderDetailPage />
+            </RequirePermission>
+          }
+        />
         <Route
           path="wagons"
           element={
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 223b357c1..0cd00d63b 100644
--- a/apps/edr-freight-web/backoffice/src/components/contracts/GlCreateBookingForm.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/contracts/GlCreateBookingForm.tsx
@@ -49,6 +49,7 @@ import { api } from "@/services/api";
 import { PageContainer } from "@/components/page";
 import { PageHeader } from "@/components/page/PageHeader";
 import { contractsService } from "@/services/contracts.service";
+import { bookingsService } from "@/services/bookings.service";
 import {
   useContractCapacity,
   useContractDetail,
@@ -180,6 +181,9 @@ export default function GlCreateBookingForm() {
   }>();
   const [searchParams] = useSearchParams();
   const requestIdParam = searchParams.get("requestId");
+  // Rebook: copy an EXPIRED booking's cargo into a fresh booking on the same
+  // contract (GL only picks a new schedule). Set by the clearance Rebook action.
+  const copyFromParam = searchParams.get("copyFrom");
   const navigate = useNavigate();
   const { data: contract, isLoading } = useContractDetail(id);
   const mutations = useContractMutations(id ?? "");
@@ -205,6 +209,13 @@ export default function GlCreateBookingForm() {
     enabled: Boolean(requestId),
   });
 
+  // The expired booking a Rebook is copying from (its cargo seeds the form).
+  const { data: copyFromBooking } = useQuery({
+    queryKey: ["rebook-copy-from", copyFromParam],
+    queryFn: () => bookingsService.getById(copyFromParam!),
+    enabled: Boolean(copyFromParam),
+  });
+
   // Same window-gating the customer sees: booking is only allowed while a
   // window is OPEN for one of the contract's routes. Intercity contracts are
   // never window-gated — the shipment rides a passing train staff pick later.
@@ -363,6 +374,28 @@ export default function GlCreateBookingForm() {
     if (bookingRequest.notes) setNotes(bookingRequest.notes);
   }, [bookingRequest, prefilled]);
 
+  // Rebook seed: copy the source booking's container lines once. (Bulk weight /
+  // item count isn't on the booking payload yet, so bulk rebooks fall through to
+  // the normal contract seed and GL re-enters the quantity.)
+  useEffect(() => {
+    if (!copyFromBooking || prefilled) return;
+    const lines = copyFromBooking.bookingContainers ?? [];
+    if (!lines.length) return;
+    setPrefilled(true);
+    setContainerLines(
+      lines.map((c) => {
+        const qty = Math.max(1, c.quantity);
+        return {
+          containerSize: String(c.containerType?.sizeFt ?? ""),
+          quantity: String(qty),
+          hazardousQuantity: "0",
+          reeferQuantity: "0",
+          units: Array.from({ length: qty }, emptyUnit),
+        };
+      }),
+    );
+  }, [copyFromBooking, prefilled]);
+
   // Seed one shipment line per contracted size exactly once — same seeding the
   // portal form does. Subsequent renders reuse the lines.
   useEffect(() => {
diff --git a/apps/edr-freight-web/backoffice/src/components/ruleEngine/RuleEngineFormDialog.tsx b/apps/edr-freight-web/backoffice/src/components/ruleEngine/RuleEngineFormDialog.tsx
index 8c1aed302..feaf8760d 100644
--- a/apps/edr-freight-web/backoffice/src/components/ruleEngine/RuleEngineFormDialog.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/ruleEngine/RuleEngineFormDialog.tsx
@@ -5,6 +5,7 @@ import {
   Button,
   TextInput,
   Textarea,
+  MultiSelect,
   Select,
   Switch,
   Stack,
@@ -79,8 +80,12 @@ const buildInitialValues = (
 ): Record<string, unknown> => {
   const values: Record<string, unknown> = {};
   for (const field of fields) {
-    const raw = record?.[field.name];
-    if (raw !== undefined && raw !== null) {
+    const raw = field.getInitialValue && record
+      ? field.getInitialValue(record)
+      : record?.[field.name];
+    if (field.type === "multiselect") {
+      values[field.name] = Array.isArray(raw) ? raw.map(String) : [];
+    } else if (raw !== undefined && raw !== null) {
       if (field.type === "date" && typeof raw === "string") {
         values[field.name] = raw.slice(0, 10);
       } else if (Array.isArray(raw)) {
@@ -197,7 +202,10 @@ const RuleEngineFormDialog = ({
 
     for (const field of visibleFields) {
       const raw = values[field.name];
-      if (field.type === "number") {
+      if (field.type === "multiselect") {
+        // Always the full replacement list — the API syncs the relation to it.
+        payload[field.name] = Array.isArray(raw) ? raw : [];
+      } else if (field.type === "number") {
         if (raw === "" || raw === undefined) continue;
         payload[field.name] = Number(raw);
       } else if (field.type === "boolean") {
@@ -258,6 +266,38 @@ const RuleEngineFormDialog = ({
 
     const label = <FieldLabel label={field.label} required={field.required} />;
 
+    if (field.type === "multiselect") {
+      const options = field.optionsFromValues
+        ? field.optionsFromValues(values)
+        : (field.options ?? []);
+      const selected = Array.isArray(values[field.name])
+        ? (values[field.name] as string[])
+        : [];
+      return (
+        <MultiSelect
+          key={field.name}
+          label={label}
+          description={field.description}
+          placeholder={
+            selectOptionsLoading
+              ? "Loading options..."
+              : (field.placeholder ?? "Select one or more")
+          }
+          value={selected}
+          onChange={(v) => setField(field.name, v)}
+          disabled={selectOptionsLoading}
+          data={options
+            .filter((opt) => opt.value !== "" && opt.value !== RULE_ENGINE_SELECT_NONE)
+            .map((opt) => ({ label: opt.label, value: opt.value }))}
+          searchable
+          clearable
+          size="md"
+          radius="md"
+          styles={inputStyles}
+        />
+      );
+    }
+
     if (field.type === "select") {
       // Dynamic options (e.g. rate unit) resolve from the live form values so
       // the choices track the other fields the admin has picked.
diff --git a/apps/edr-freight-web/backoffice/src/components/trainBuilder/AvailableWagonsPanel.tsx b/apps/edr-freight-web/backoffice/src/components/trainBuilder/AvailableWagonsPanel.tsx
new file mode 100644
index 000000000..a75449a9d
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/components/trainBuilder/AvailableWagonsPanel.tsx
@@ -0,0 +1,152 @@
+import { Freight } from "@edr/types";
+import {
+  Button,
+  Checkbox,
+  Group,
+  ScrollArea,
+  Select,
+  Stack,
+  Text,
+  TextInput,
+} from "@mantine/core";
+import { useQuery } from "@tanstack/react-query";
+import { Plus, Search } from "lucide-react";
+import { useMemo, useState } from "react";
+
+import { api } from "@/services/api";
+
+/**
+ * AVAILABLE wagons standing in the train's own yard — the only ones that can
+ * be coupled. Pick any number and append them to the consist.
+ */
+export default function AvailableWagonsPanel({
+  yardId,
+  yardLabel,
+  onAssign,
+  assigning,
+}: AvailableWagonsPanelProps) {
+  const [search, setSearch] = useState("");
+  const [typeFilter, setTypeFilter] = useState<string>("ALL");
+  const [selected, setSelected] = useState<string[]>([]);
+
+  const wagonsQuery = useQuery(
+    api.wagons.list.queryOptions({
+      input: {
+        filters: { status: Freight.WagonStatus.Available, currentYardId: yardId },
+      },
+      enabled: Boolean(yardId),
+    }),
+  );
+
+  const wagons = useMemo(() => {
+    const q = search.trim().toLowerCase();
+    return (wagonsQuery.data ?? []).filter((wagon) => {
+      if (typeFilter !== "ALL" && wagon.wagonTypeId !== typeFilter) return false;
+      if (q && !wagon.wagonNumber.toLowerCase().includes(q)) return false;
+      return true;
+    });
+  }, [wagonsQuery.data, search, typeFilter]);
+
+  const typeOptions = useMemo(() => {
+    const byId = new Map<string, string>();
+    for (const wagon of wagonsQuery.data ?? []) {
+      if (wagon.wagonType) byId.set(wagon.wagonType.id, wagon.wagonType.name);
+    }
+    return [
+      { value: "ALL", label: "All types" },
+      ...[...byId.entries()].map(([value, label]) => ({ value, label })),
+    ];
+  }, [wagonsQuery.data]);
+
+  const toggle = (wagonId: string, checked: boolean) => {
+    setSelected((prev) =>
+      checked ? [...prev, wagonId] : prev.filter((id) => id !== wagonId),
+    );
+  };
+
+  const handleAssign = () => {
+    if (!selected.length) return;
+    onAssign(selected);
+    setSelected([]);
+  };
+
+  return (
+    <Stack gap="sm">
+      <Group gap="xs" grow>
+        <TextInput
+          size="sm"
+          placeholder="Search wagon number…"
+          leftSection={<Search size={14} />}
+          value={search}
+          onChange={(e) => setSearch(e.currentTarget.value)}
+        />
+        <Select
+          size="sm"
+          data={typeOptions}
+          value={typeFilter}
+          onChange={(v) => setTypeFilter(v ?? "ALL")}
+        />
+      </Group>
+
+      <ScrollArea.Autosize mah={380} type="auto">
+        <Stack gap={6}>
+          {wagonsQuery.isLoading ? (
+            <Text py="md" ta="center" c="dimmed" size="sm">
+              Loading wagons…
+            </Text>
+          ) : !wagons.length ? (
+            <Text py="md" ta="center" c="dimmed" size="sm">
+              No available wagons in {yardLabel ?? "this yard"}
+            </Text>
+          ) : (
+            wagons.map((wagon) => (
+              <Group
+                key={wagon.id}
+                gap="sm"
+                wrap="nowrap"
+                p="xs"
+                style={{
+                  border: "1px solid var(--mantine-color-gray-2)",
+                  borderRadius: "var(--mantine-radius-md)",
+                }}
+              >
+                <Checkbox
+                  size="sm"
+                  checked={selected.includes(wagon.id)}
+                  onChange={(e) => toggle(wagon.id, e.currentTarget.checked)}
+                  aria-label={`Select wagon ${wagon.wagonNumber}`}
+                />
+                <Stack gap={0} style={{ flex: 1, minWidth: 0 }}>
+                  <Text size="sm" fw={600} ff="monospace" truncate>
+                    {wagon.wagonNumber}
+                  </Text>
+                  <Text size="xs" c="dimmed" truncate>
+                    {wagon.wagonType
+                      ? `${wagon.wagonType.name} · ${wagon.wagonType.capacityTons ?? "—"}T cap`
+                      : "Unknown type"}
+                  </Text>
+                </Stack>
+              </Group>
+            ))
+          )}
+        </Stack>
+      </ScrollArea.Autosize>
+
+      <Button
+        leftSection={<Plus size={16} />}
+        disabled={!selected.length}
+        loading={assigning}
+        onClick={handleAssign}
+      >
+        Add {selected.length ? `${selected.length} wagon${selected.length > 1 ? "s" : ""}` : "wagons"} to consist
+      </Button>
+    </Stack>
+  );
+}
+
+export interface AvailableWagonsPanelProps {
+  yardId: string;
+  yardLabel?: string | null;
+  onAssign: (wagonIds: string[]) => void;
+  assigning: boolean;
+}
diff --git a/apps/edr-freight-web/backoffice/src/components/trainBuilder/BuildTrainModal.tsx b/apps/edr-freight-web/backoffice/src/components/trainBuilder/BuildTrainModal.tsx
new file mode 100644
index 000000000..74f897728
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/components/trainBuilder/BuildTrainModal.tsx
@@ -0,0 +1,182 @@
+import {
+  Button,
+  Group,
+  Modal,
+  MultiSelect,
+  Select,
+  Stack,
+  Text,
+  TextInput,
+  Textarea,
+} from "@mantine/core";
+import { useMutation, useQuery } from "@tanstack/react-query";
+import { isAxiosError } from "axios";
+import { useEffect, useState } from "react";
+
+import { api } from "@/services/api";
+import type { TrainComposition } from "@/services/trainBuilder.service";
+import { useToast } from "@/hooks/use-toast";
+
+const parseError = (error: unknown, fallback: string) => {
+  if (isAxiosError(error)) {
+    const message = error.response?.data?.message;
+    if (Array.isArray(message)) return message.join(", ");
+    if (typeof message === "string") return message;
+  }
+  return fallback;
+};
+
+/**
+ * Step one of the Train Builder: give the train its operator code, pick the
+ * yard it is being assembled in, and couple at least two locomotives from that
+ * yard. Wagons are attached afterwards on the composition page.
+ */
+export default function BuildTrainModal({ opened, onClose, onBuilt }: BuildTrainModalProps) {
+  const { toast } = useToast();
+  const [code, setCode] = useState("");
+  const [trainName, setTrainName] = useState("");
+  const [yardId, setYardId] = useState("");
+  const [locomotiveIds, setLocomotiveIds] = useState<string[]>([]);
+  const [notes, setNotes] = useState("");
+
+  const yardsQuery = useQuery(api.routes.yards.queryOptions({ staleTime: 5 * 60_000 }));
+  // Only serviceable locomotives standing in the selected yard can be coupled.
+  const locomotivesQuery = useQuery(
+    api.locomotives.listFiltered.queryOptions({
+      input: { filters: { status: "AVAILABLE", currentYardId: yardId } },
+      enabled: Boolean(yardId),
+    }),
+  );
+  const build = useMutation(api.trainBuilder.build.mutationOptions());
+
+  // A locomotive belongs to one yard — switching yards invalidates the pick.
+  useEffect(() => {
+    setLocomotiveIds([]);
+  }, [yardId]);
+
+  useEffect(() => {
+    if (!opened) {
+      setCode("");
+      setTrainName("");
+      setYardId("");
+      setLocomotiveIds([]);
+      setNotes("");
+    }
+  }, [opened]);
+
+  const handleBuild = async () => {
+    if (!code.trim() || !yardId || locomotiveIds.length < 2) {
+      toast({
+        title: "Enter a train code, pick a yard, and couple at least two locomotives",
+        variant: "destructive",
+      });
+      return;
+    }
+    try {
+      const composition = await build.mutateAsync({
+        code: code.trim(),
+        currentYardId: yardId,
+        locomotiveIds,
+        ...(trainName.trim() ? { trainName: trainName.trim() } : {}),
+        ...(notes.trim() ? { notes: notes.trim() } : {}),
+      });
+      toast({ title: `Train ${composition.code} built` });
+      onClose();
+      onBuilt(composition);
+    } catch (err) {
+      toast({
+        title: "Build failed",
+        description: parseError(err, "Could not build the train"),
+        variant: "destructive",
+      });
+    }
+  };
+
+  const locomotiveOptions = (locomotivesQuery.data ?? []).map((loco) => ({
+    value: loco.id,
+    label: `${loco.code}${loco.name ? ` — ${loco.name}` : ""} · pulls ${loco.maxPullWeightTons}T`,
+  }));
+
+  return (
+    <Modal
+      opened={opened}
+      onClose={onClose}
+      title={<Text fw={600}>Build a train</Text>}
+      radius="lg"
+      centered
+    >
+      <Stack gap="md">
+        <Text size="sm" c="dimmed">
+          A train is assembled in one yard: two or more locomotives plus wagons
+          standing in that same yard. Wagons are attached on the next screen.
+        </Text>
+        <Group grow>
+          <TextInput
+            label="Train code"
+            placeholder="e.g. 81001"
+            value={code}
+            onChange={(e) => setCode(e.currentTarget.value)}
+            maxLength={32}
+          />
+          <TextInput
+            label="Name (optional)"
+            placeholder="e.g. Fertilizer block"
+            value={trainName}
+            onChange={(e) => setTrainName(e.currentTarget.value)}
+            maxLength={100}
+          />
+        </Group>
+        <Select
+          label="Build yard"
+          placeholder="Select the yard the train is assembled in"
+          data={(yardsQuery.data ?? []).map((y) => ({
+            value: y.id,
+            label: y.label ?? y.code,
+          }))}
+          value={yardId || null}
+          onChange={(v) => setYardId(v ?? "")}
+          searchable
+        />
+        <MultiSelect
+          label="Locomotives"
+          description="A train must be pulled by at least two locomotives (front and back). First pick becomes the lead."
+          placeholder={yardId ? "Select at least two locomotives" : "Select a yard first"}
+          data={locomotiveOptions}
+          value={locomotiveIds}
+          onChange={setLocomotiveIds}
+          searchable
+          disabled={!yardId}
+          error={
+            locomotiveIds.length > 0 && locomotiveIds.length < 2
+              ? "Select at least two locomotives"
+              : undefined
+          }
+          nothingFoundMessage={
+            yardId ? "No available locomotives in this yard" : "Select a yard first"
+          }
+        />
+        <Textarea
+          label="Notes (optional)"
+          value={notes}
+          onChange={(e) => setNotes(e.currentTarget.value)}
+          autosize
+          minRows={2}
+        />
+        <Group justify="flex-end">
+          <Button variant="default" onClick={onClose}>
+            Cancel
+          </Button>
+          <Button loading={build.isPending} onClick={handleBuild}>
+            Build train
+          </Button>
+        </Group>
+      </Stack>
+    </Modal>
+  );
+}
+
+export interface BuildTrainModalProps {
+  opened: boolean;
+  onClose: () => void;
+  onBuilt: (composition: TrainComposition) => void;
+}
diff --git a/apps/edr-freight-web/backoffice/src/components/trainBuilder/ChangeLocomotivesModal.tsx b/apps/edr-freight-web/backoffice/src/components/trainBuilder/ChangeLocomotivesModal.tsx
new file mode 100644
index 000000000..24ec8ed8b
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/components/trainBuilder/ChangeLocomotivesModal.tsx
@@ -0,0 +1,128 @@
+import { Button, Group, Modal, MultiSelect, Stack, Text } from "@mantine/core";
+import { useMutation, useQuery } from "@tanstack/react-query";
+import { isAxiosError } from "axios";
+import { useEffect, useMemo, useState } from "react";
+
+import { api } from "@/services/api";
+import type { TrainComposition } from "@/services/trainBuilder.service";
+import { useToast } from "@/hooks/use-toast";
+
+const parseError = (error: unknown, fallback: string) => {
+  if (isAxiosError(error)) {
+    const message = error.response?.data?.message;
+    if (Array.isArray(message)) return message.join(", ");
+    if (typeof message === "string") return message;
+  }
+  return fallback;
+};
+
+/** Swap the locomotive set of a built train (minimum 2, same-yard rule). */
+export default function ChangeLocomotivesModal({
+  composition,
+  opened,
+  onClose,
+}: ChangeLocomotivesModalProps) {
+  const { toast } = useToast();
+  const [locomotiveIds, setLocomotiveIds] = useState<string[]>([]);
+
+  const yardId = composition?.currentYard?.id ?? "";
+  const availableQuery = useQuery(
+    api.locomotives.listFiltered.queryOptions({
+      input: { filters: { status: "AVAILABLE", currentYardId: yardId } },
+      enabled: opened && Boolean(yardId),
+    }),
+  );
+  const setLocomotives = useMutation(api.trainBuilder.setLocomotives.mutationOptions());
+
+  useEffect(() => {
+    if (opened && composition) {
+      setLocomotiveIds(composition.locomotives.map((l) => l.id));
+    }
+  }, [opened, composition]);
+
+  // Pickable = available locomotives in the yard + the ones already coupled
+  // to this train (valid to keep even though they are not "loose" anymore).
+  const options = useMemo(() => {
+    const seen = new Set<string>();
+    const rows: Array<{ value: string; label: string }> = [];
+    for (const loco of composition?.locomotives ?? []) {
+      seen.add(loco.id);
+      rows.push({
+        value: loco.id,
+        label: `${loco.code}${loco.name ? ` — ${loco.name}` : ""} · pulls ${loco.maxPullWeightTons}T (coupled)`,
+      });
+    }
+    for (const loco of availableQuery.data ?? []) {
+      if (seen.has(loco.id)) continue;
+      rows.push({
+        value: loco.id,
+        label: `${loco.code}${loco.name ? ` — ${loco.name}` : ""} · pulls ${loco.maxPullWeightTons}T`,
+      });
+    }
+    return rows;
+  }, [composition, availableQuery.data]);
+
+  const handleSave = async () => {
+    if (!composition) return;
+    if (locomotiveIds.length < 2) {
+      toast({ title: "A train needs at least two locomotives", variant: "destructive" });
+      return;
+    }
+    try {
+      await setLocomotives.mutateAsync({ id: composition.id, locomotiveIds });
+      toast({ title: "Locomotives updated" });
+      onClose();
+    } catch (err) {
+      toast({
+        title: "Update failed",
+        description: parseError(err, "Could not update locomotives"),
+        variant: "destructive",
+      });
+    }
+  };
+
+  return (
+    <Modal
+      opened={opened}
+      onClose={onClose}
+      title={<Text fw={600}>Change locomotives</Text>}
+      radius="lg"
+      centered
+    >
+      <Stack gap="md">
+        <Text size="sm" c="dimmed">
+          Only available locomotives standing in{" "}
+          {composition?.currentYard?.label ?? "the train's yard"} can be coupled.
+          The first pick is the lead locomotive.
+        </Text>
+        <MultiSelect
+          label="Locomotives"
+          data={options}
+          value={locomotiveIds}
+          onChange={setLocomotiveIds}
+          searchable
+          error={
+            locomotiveIds.length > 0 && locomotiveIds.length < 2
+              ? "Select at least two locomotives"
+              : undefined
+          }
+          nothingFoundMessage="No available locomotives in this yard"
+        />
+        <Group justify="flex-end">
+          <Button variant="default" onClick={onClose}>
+            Cancel
+          </Button>
+          <Button loading={setLocomotives.isPending} onClick={handleSave}>
+            Save
+          </Button>
+        </Group>
+      </Stack>
+    </Modal>
+  );
+}
+
+export interface ChangeLocomotivesModalProps {
+  composition: TrainComposition | null;
+  opened: boolean;
+  onClose: () => void;
+}
diff --git a/apps/edr-freight-web/backoffice/src/components/trainBuilder/ChangeYardModal.tsx b/apps/edr-freight-web/backoffice/src/components/trainBuilder/ChangeYardModal.tsx
new file mode 100644
index 000000000..0e4bddbc3
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/components/trainBuilder/ChangeYardModal.tsx
@@ -0,0 +1,103 @@
+import { Alert, Button, Group, Modal, Select, Stack, Text } from "@mantine/core";
+import { useMutation, useQuery } from "@tanstack/react-query";
+import { isAxiosError } from "axios";
+import { MapPin } from "lucide-react";
+import { useEffect, useState } from "react";
+
+import { api } from "@/services/api";
+import type { TrainComposition } from "@/services/trainBuilder.service";
+import { useToast } from "@/hooks/use-toast";
+
+const parseError = (error: unknown, fallback: string) => {
+  if (isAxiosError(error)) {
+    const message = error.response?.data?.message;
+    if (Array.isArray(message)) return message.join(", ");
+    if (typeof message === "string") return message;
+  }
+  return fallback;
+};
+
+/**
+ * Relocate the train to another yard. The consist moves as one unit — every
+ * coupled locomotive and wagon follows, so their current yards always match
+ * the train's.
+ */
+export default function ChangeYardModal({ composition, opened, onClose }: ChangeYardModalProps) {
+  const { toast } = useToast();
+  const [yardId, setYardId] = useState("");
+
+  const yardsQuery = useQuery(api.routes.yards.queryOptions({ staleTime: 5 * 60_000 }));
+  const setYard = useMutation(api.trainBuilder.setYard.mutationOptions());
+
+  useEffect(() => {
+    if (opened) setYardId(composition?.currentYard?.id ?? "");
+  }, [opened, composition]);
+
+  const handleSave = async () => {
+    if (!composition || !yardId) return;
+    try {
+      await setYard.mutateAsync({ id: composition.id, currentYardId: yardId });
+      toast({ title: "Train relocated" });
+      onClose();
+    } catch (err) {
+      toast({
+        title: "Relocation failed",
+        description: parseError(err, "Could not change the yard"),
+        variant: "destructive",
+      });
+    }
+  };
+
+  const memberCount =
+    (composition?.locomotives.length ?? 0) + (composition?.totals.wagonCount ?? 0);
+
+  return (
+    <Modal
+      opened={opened}
+      onClose={onClose}
+      title={<Text fw={600}>Change yard — train {composition?.code}</Text>}
+      radius="lg"
+      centered
+    >
+      <Stack gap="md">
+        <Alert color="yellow" icon={<MapPin size={16} />}>
+          The whole consist moves with the train: {composition?.locomotives.length ?? 0}{" "}
+          locomotive{(composition?.locomotives.length ?? 0) === 1 ? "" : "s"} and{" "}
+          {composition?.totals.wagonCount ?? 0} wagon
+          {(composition?.totals.wagonCount ?? 0) === 1 ? "" : "s"} ({memberCount} vehicles)
+          are relocated so their current yard always matches the train's. Wagon moves are
+          recorded in the movement ledger.
+        </Alert>
+        <Select
+          label="New yard"
+          placeholder="Select yard"
+          data={(yardsQuery.data ?? []).map((y) => ({
+            value: y.id,
+            label: y.label ?? y.code,
+          }))}
+          value={yardId || null}
+          onChange={(v) => setYardId(v ?? "")}
+          searchable
+        />
+        <Group justify="flex-end">
+          <Button variant="default" onClick={onClose}>
+            Cancel
+          </Button>
+          <Button
+            loading={setYard.isPending}
+            disabled={!yardId || yardId === composition?.currentYard?.id}
+            onClick={handleSave}
+          >
+            Relocate train
+          </Button>
+        </Group>
+      </Stack>
+    </Modal>
+  );
+}
+
+export interface ChangeYardModalProps {
+  composition: TrainComposition | null;
+  opened: boolean;
+  onClose: () => void;
+}
diff --git a/apps/edr-freight-web/backoffice/src/components/trainBuilder/ConsistWagonList.tsx b/apps/edr-freight-web/backoffice/src/components/trainBuilder/ConsistWagonList.tsx
new file mode 100644
index 000000000..b08e0643d
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/components/trainBuilder/ConsistWagonList.tsx
@@ -0,0 +1,171 @@
+import {
+  DragDropContext,
+  Draggable,
+  Droppable,
+  type DraggableProvided,
+  type DraggableStateSnapshot,
+  type DropResult,
+} from "@hello-pangea/dnd";
+import { ActionIcon, Badge, Box, Group, Stack, Text, Tooltip } from "@mantine/core";
+import { GripVertical, Trash2 } from "lucide-react";
+import { type ReactNode } from "react";
+import { createPortal } from "react-dom";
+
+import type { TrainCompositionWagon } from "@/services/trainBuilder.service";
+
+/** Reparent dragged row to body — fixes position:fixed inside transformed parents. */
+const PortalAwareRow = ({
+  snapshot,
+  children,
+}: {
+  snapshot: DraggableStateSnapshot;
+  children: ReactNode;
+}) => {
+  if (snapshot.isDragging) {
+    return createPortal(children, document.body);
+  }
+  return <>{children}</>;
+};
+
+/**
+ * The train's ordered wagon consist. Drag to reorder (persisted on drop),
+ * trash to detach a wagon back to the yard.
+ */
+export default function ConsistWagonList({
+  wagons,
+  editable,
+  onReorder,
+  onRemove,
+  busy = false,
+}: ConsistWagonListProps) {
+  const onDragEnd = (result: DropResult) => {
+    if (!result.destination) return;
+    const from = result.source.index;
+    const to = result.destination.index;
+    if (from === to) return;
+    const next = [...wagons];
+    const [moved] = next.splice(from, 1);
+    next.splice(to, 0, moved!);
+    onReorder(next.map((w) => w.id));
+  };
+
+  if (!wagons.length) {
+    return (
+      <Text py="lg" ta="center" c="dimmed" size="sm">
+        No wagons in the consist yet.
+      </Text>
+    );
+  }
+
+  return (
+    <DragDropContext onDragEnd={onDragEnd}>
+      <Droppable droppableId="train-consist-wagons" isDropDisabled={!editable || busy}>
+        {(dropProvided) => (
+          <Stack gap="xs" ref={dropProvided.innerRef} {...dropProvided.droppableProps}>
+            {wagons.map((wagon, index) => (
+              <Draggable
+                key={wagon.id}
+                draggableId={wagon.id}
+                index={index}
+                isDragDisabled={!editable || busy}
+              >
+                {(dragProvided, snapshot) => (
+                  <WagonRow
+                    wagon={wagon}
+                    index={index}
+                    dragProvided={dragProvided}
+                    snapshot={snapshot}
+                    editable={editable}
+                    busy={busy}
+                    onRemove={onRemove}
+                  />
+                )}
+              </Draggable>
+            ))}
+            {dropProvided.placeholder}
+          </Stack>
+        )}
+      </Droppable>
+    </DragDropContext>
+  );
+}
+
+export interface ConsistWagonListProps {
+  wagons: TrainCompositionWagon[];
+  editable: boolean;
+  onReorder: (wagonIds: string[]) => void;
+  onRemove: (wagonId: string) => void;
+  busy?: boolean;
+}
+
+function WagonRow({
+  wagon,
+  index,
+  dragProvided,
+  snapshot,
+  editable,
+  busy,
+  onRemove,
+}: {
+  wagon: TrainCompositionWagon;
+  index: number;
+  dragProvided: DraggableProvided;
+  snapshot: DraggableStateSnapshot;
+  editable: boolean;
+  busy: boolean;
+  onRemove: (wagonId: string) => void;
+}) {
+  return (
+    <PortalAwareRow snapshot={snapshot}>
+      <Group
+        ref={dragProvided.innerRef}
+        {...dragProvided.draggableProps}
+        {...dragProvided.dragHandleProps}
+        gap="sm"
+        wrap="nowrap"
+        p="sm"
+        style={{
+          ...dragProvided.draggableProps.style,
+          border: "1px solid var(--mantine-color-gray-3)",
+          borderRadius: "var(--mantine-radius-md)",
+          background: snapshot.isDragging ? "var(--mantine-color-gray-0)" : "white",
+          boxShadow: snapshot.isDragging ? "0 8px 24px rgba(0, 0, 0, 0.12)" : undefined,
+          cursor: editable ? (snapshot.isDragging ? "grabbing" : "grab") : "default",
+          userSelect: "none",
+        }}
+      >
+        {editable ? (
+          <Box c="dimmed" style={{ display: "flex", alignItems: "center" }}>
+            <GripVertical size={18} />
+          </Box>
+        ) : null}
+        <Badge variant="light" color="gray" size="sm">
+          {index + 1}
+        </Badge>
+        <Stack gap={2} style={{ flex: 1, minWidth: 0 }}>
+          <Text size="sm" fw={600} ff="monospace" truncate>
+            {wagon.wagonNumber}
+          </Text>
+          <Text size="xs" c="dimmed" truncate>
+            {wagon.wagonType
+              ? `${wagon.wagonType.name} · ${wagon.wagonType.capacityTons}T cap · ${wagon.wagonType.lengthMeters}m`
+              : "Unknown type"}
+          </Text>
+        </Stack>
+        {editable ? (
+          <Tooltip label="Detach wagon" withArrow>
+            <ActionIcon
+              variant="subtle"
+              color="red"
+              disabled={busy}
+              onClick={() => onRemove(wagon.id)}
+              aria-label={`Detach wagon ${wagon.wagonNumber}`}
+            >
+              <Trash2 size={16} />
+            </ActionIcon>
+          </Tooltip>
+        ) : null}
+      </Group>
+    </PortalAwareRow>
+  );
+}
diff --git a/apps/edr-freight-web/backoffice/src/components/trainBuilder/trainStatus.ts b/apps/edr-freight-web/backoffice/src/components/trainBuilder/trainStatus.ts
new file mode 100644
index 000000000..696e6cc6e
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/components/trainBuilder/trainStatus.ts
@@ -0,0 +1,25 @@
+import type { BuiltTrainStatus } from "@/services/trainBuilder.service";
+
+/** Badge color per built-train lifecycle status (Mantine palette keys). */
+export const trainStatusColor = (status: BuiltTrainStatus | string): string => {
+  switch (status) {
+    case "AVAILABLE":
+      return "edr-green";
+    case "SCHEDULED":
+      return "blue";
+    case "IN_SERVICE":
+      return "teal";
+    case "UNDER_MAINTENANCE":
+      return "yellow";
+    case "OUT_OF_SERVICE":
+      return "red";
+    default:
+      return "gray";
+  }
+};
+
+export const trainStatusLabel = (status: BuiltTrainStatus | string): string =>
+  String(status)
+    .toLowerCase()
+    .replace(/_/g, " ")
+    .replace(/^\w/, (c) => c.toUpperCase());
diff --git a/apps/edr-freight-web/backoffice/src/components/trainScheduling/AdjustConsistModal.tsx b/apps/edr-freight-web/backoffice/src/components/trainScheduling/AdjustConsistModal.tsx
new file mode 100644
index 000000000..1ca91e01f
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/components/trainScheduling/AdjustConsistModal.tsx
@@ -0,0 +1,396 @@
+import {
+  Alert,
+  Badge,
+  Button,
+  Checkbox,
+  Divider,
+  Grid,
+  Group,
+  Modal,
+  Progress,
+  ScrollArea,
+  Stack,
+  Text,
+} from "@mantine/core";
+import { useMutation, useQuery } from "@tanstack/react-query";
+import { isAxiosError } from "axios";
+import { AlertTriangle, History, Minus, Plus } from "lucide-react";
+import { useEffect, useMemo, useState } from "react";
+
+import { api } from "@/services/api";
+import type { ConsistWagonRef } from "@/services/trainBuilder.service";
+import { useToast } from "@/hooks/use-toast";
+
+const parseError = (error: unknown, fallback: string) => {
+  if (isAxiosError(error)) {
+    const message = error.response?.data?.message;
+    if (Array.isArray(message)) return message.join(", ");
+    if (typeof message === "string") return message;
+  }
+  return fallback;
+};
+
+const tareOf = (w: ConsistWagonRef) => w.wagonType?.tareWeightTons ?? 0;
+const lengthOf = (w: ConsistWagonRef) => w.wagonType?.lengthMeters ?? 0;
+const round2 = (v: number) => Math.round(v * 100) / 100;
+
+/**
+ * Adjust the built train's consist from a schedule: trim free wagons (their
+ * tare no longer rides — the fix when gross weight beats the pull limit) or
+ * couple extra yard wagons while weight/length headroom remains. Changes are
+ * permanent on the train and logged on the schedule.
+ */
+export default function AdjustConsistModal({
+  scheduleId,
+  opened,
+  onClose,
+}: AdjustConsistModalProps) {
+  const { toast } = useToast();
+  const [removeIds, setRemoveIds] = useState<string[]>([]);
+  const [addIds, setAddIds] = useState<string[]>([]);
+
+  const consistQuery = useQuery(
+    api.trainScheduling.scheduleConsist.queryOptions({
+      input: { scheduleId },
+      enabled: opened && Boolean(scheduleId),
+    }),
+  );
+  const adjust = useMutation(api.trainScheduling.adjustConsist.mutationOptions());
+  const data = consistQuery.data;
+
+  useEffect(() => {
+    if (opened) {
+      setRemoveIds([]);
+      setAddIds([]);
+    }
+  }, [opened]);
+
+  // Live projection: gross = cargo + tare of (consist − trims + adds).
+  const projection = useMemo(() => {
+    if (!data) return null;
+    const removed = new Set(removeIds);
+    const keptTare = data.wagons
+      .filter((w) => !removed.has(w.id))
+      .reduce((s, w) => s + tareOf(w), 0);
+    const keptLength = data.wagons
+      .filter((w) => !removed.has(w.id))
+      .reduce((s, w) => s + lengthOf(w), 0);
+    const addedWagons = data.addableWagons.filter((w) => addIds.includes(w.id));
+    const tare = keptTare + addedWagons.reduce((s, w) => s + tareOf(w), 0);
+    const length = keptLength + addedWagons.reduce((s, w) => s + lengthOf(w), 0);
+    const gross = round2(data.totals.cargoTons + tare);
+    return {
+      wagonCount: data.totals.wagonCount - removeIds.length + addIds.length,
+      tare: round2(tare),
+      gross,
+      length: round2(length),
+      grossPct: data.limits.pullCapTons
+        ? Math.round((gross / data.limits.pullCapTons) * 100)
+        : null,
+      lengthPct: data.limits.lengthCapMeters
+        ? Math.round((length / data.limits.lengthCapMeters) * 100)
+        : null,
+      overWeight: data.limits.pullCapTons > 0 && gross > data.limits.pullCapTons,
+      overLength:
+        data.limits.lengthCapMeters > 0 && length > data.limits.lengthCapMeters,
+    };
+  }, [data, removeIds, addIds]);
+
+  const toggle = (setter: typeof setRemoveIds) => (id: string, checked: boolean) =>
+    setter((prev) => (checked ? [...prev, id] : prev.filter((x) => x !== id)));
+
+  const handleSubmit = async () => {
+    if (!removeIds.length && !addIds.length) return;
+    try {
+      await adjust.mutateAsync({
+        scheduleId,
+        payload: {
+          ...(addIds.length ? { addWagonIds: addIds } : {}),
+          ...(removeIds.length ? { removeWagonIds: removeIds } : {}),
+        },
+      });
+      toast({
+        title: `Consist updated — ${removeIds.length ? `${removeIds.length} trimmed` : ""}${
+          removeIds.length && addIds.length ? ", " : ""
+        }${addIds.length ? `${addIds.length} added` : ""}`,
+      });
+      setRemoveIds([]);
+      setAddIds([]);
+    } catch (err) {
+      toast({
+        title: "Adjustment failed",
+        description: parseError(err, "Could not adjust the consist"),
+        variant: "destructive",
+      });
+    }
+  };
+
+  return (
+    <Modal
+      opened={opened}
+      onClose={onClose}
+      title={
+        <Text fw={600}>
+          Adjust consist{data ? ` — train ${data.train.code}` : ""}
+        </Text>
+      }
+      radius="lg"
+      size={860}
+      centered
+    >
+      {consistQuery.isLoading || !data ? (
+        <Text py="lg" ta="center" c="dimmed" size="sm">
+          {consistQuery.isError
+            ? "This schedule has no built train to adjust."
+            : "Loading consist…"}
+        </Text>
+      ) : (
+        <Stack gap="md">
+          {!data.editable ? (
+            <Alert color="yellow" icon={<AlertTriangle size={16} />}>
+              The consist is frozen once the train is dispatched.
+            </Alert>
+          ) : null}
+
+          <Grid gap="md">
+            <Grid.Col span={{ base: 12, sm: 6 }}>
+              <LimitGauge
+                label="Gross weight"
+                detail={`${data.totals.cargoTons}T cargo + ${projection?.tare}T tare = ${projection?.gross}T of ${data.limits.pullCapTons}T (limit ${data.limits.maxPullWeightTons}T + ${data.limits.overageToleranceTons}T tolerance)`}
+                pct={projection?.grossPct ?? null}
+                over={projection?.overWeight ?? false}
+              />
+            </Grid.Col>
+            <Grid.Col span={{ base: 12, sm: 6 }}>
+              <LimitGauge
+                label="Consist length"
+                detail={`${projection?.length}m of ${data.limits.lengthCapMeters}m (limit ${data.limits.maxTrainLengthMeters}m + ${data.limits.overageToleranceMeters}m tolerance)`}
+                pct={projection?.lengthPct ?? null}
+                over={projection?.overLength ?? false}
+              />
+            </Grid.Col>
+          </Grid>
+
+          <Grid gap="md">
+            <Grid.Col span={{ base: 12, md: 6 }}>
+              <Stack gap="xs">
+                <Group gap={6}>
+                  <Minus size={14} />
+                  <Text size="sm" fw={600}>
+                    Trim coupled wagons ({data.totals.wagonCount})
+                  </Text>
+                </Group>
+                <Text size="xs" c="dimmed">
+                  Only free (unloaded, unpinned) wagons can be detached. Detaching is
+                  permanent — the wagon returns to the yard as available.
+                </Text>
+                <ScrollArea.Autosize mah={260} type="auto">
+                  <Stack gap={4}>
+                    {data.wagons.map((wagon) => (
+                      <WagonRow
+                        key={wagon.id}
+                        wagon={wagon}
+                        checked={removeIds.includes(wagon.id)}
+                        disabled={!data.editable || !wagon.removable}
+                        badge={
+                          wagon.loaded ? "Loaded" : !wagon.removable ? "Pinned" : null
+                        }
+                        onToggle={toggle(setRemoveIds)}
+                      />
+                    ))}
+                  </Stack>
+                </ScrollArea.Autosize>
+              </Stack>
+            </Grid.Col>
+            <Grid.Col span={{ base: 12, md: 6 }}>
+              <Stack gap="xs">
+                <Group gap={6}>
+                  <Plus size={14} />
+                  <Text size="sm" fw={600}>
+                    Couple yard wagons ({data.addableWagons.length} available)
+                  </Text>
+                </Group>
+                <Text size="xs" c="dimmed">
+                  AVAILABLE wagons standing in the train's yard. Blocked when they push
+                  gross weight or length past the locomotive limits incl. tolerance.
+                </Text>
+                <ScrollArea.Autosize mah={260} type="auto">
+                  <Stack gap={4}>
+                    {data.addableWagons.length ? (
+                      data.addableWagons.map((wagon) => (
+                        <WagonRow
+                          key={wagon.id}
+                          wagon={wagon}
+                          checked={addIds.includes(wagon.id)}
+                          disabled={!data.editable}
+                          badge={null}
+                          onToggle={toggle(setAddIds)}
+                        />
+                      ))
+                    ) : (
+                      <Text size="sm" c="dimmed" py="sm" ta="center">
+                        No available wagons in this yard
+                      </Text>
+                    )}
+                  </Stack>
+                </ScrollArea.Autosize>
+              </Stack>
+            </Grid.Col>
+          </Grid>
+
+          {data.adjustments.length ? (
+            <>
+              <Divider />
+              <Stack gap={4}>
+                <Group gap={6}>
+                  <History size={14} />
+                  <Text size="sm" fw={600}>
+                    Adjustment history
+                  </Text>
+                </Group>
+                <ScrollArea.Autosize mah={120} type="auto">
+                  <Stack gap={2}>
+                    {data.adjustments.map((log) => (
+                      <Group key={log.id} gap="xs">
+                        <Badge
+                          size="xs"
+                          variant="light"
+                          color={log.action === "ADD" ? "edr-green" : "red"}
+                        >
+                          {log.action === "ADD" ? "Added" : "Trimmed"}
+                        </Badge>
+                        <Text size="xs" ff="monospace">
+                          {log.wagonNumber}
+                        </Text>
+                        <Text size="xs" c="dimmed">
+                          {new Date(log.occurredAt).toLocaleString()}
+                        </Text>
+                      </Group>
+                    ))}
+                  </Stack>
+                </ScrollArea.Autosize>
+              </Stack>
+            </>
+          ) : null}
+
+          <Group justify="space-between">
+            <Text size="xs" c="dimmed">
+              Projected consist: {projection?.wagonCount} wagons
+            </Text>
+            <Group>
+              <Button variant="default" onClick={onClose}>
+                Close
+              </Button>
+              <Button
+                loading={adjust.isPending}
+                disabled={
+                  !data.editable ||
+                  (!removeIds.length && !addIds.length) ||
+                  (addIds.length > 0 && (projection?.overWeight || projection?.overLength))
+                }
+                onClick={handleSubmit}
+              >
+                Apply{" "}
+                {removeIds.length ? `−${removeIds.length}` : ""}
+                {removeIds.length && addIds.length ? " / " : ""}
+                {addIds.length ? `+${addIds.length}` : ""}
+              </Button>
+            </Group>
+          </Group>
+        </Stack>
+      )}
+    </Modal>
+  );
+}
+
+export interface AdjustConsistModalProps {
+  scheduleId: string;
+  opened: boolean;
+  onClose: () => void;
+}
+
+function LimitGauge({
+  label,
+  detail,
+  pct,
+  over,
+}: {
+  label: string;
+  detail: string;
+  pct: number | null;
+  over: boolean;
+}) {
+  return (
+    <Stack gap={4}>
+      <Group justify="space-between">
+        <Text size="xs" fw={600}>
+          {label}
+        </Text>
+        <Text size="xs" fw={700} c={over ? "red.7" : "edr-green.7"}>
+          {pct != null ? `${pct}%` : "—"}
+        </Text>
+      </Group>
+      <Progress
+        value={Math.min(pct ?? 0, 100)}
+        size="md"
+        radius="xl"
+        color={over ? "red" : (pct ?? 0) > 85 ? "yellow" : "edr-green"}
+        striped={over}
+        animated={over}
+      />
+      <Text size="xs" c="dimmed">
+        {detail}
+      </Text>
+    </Stack>
+  );
+}
+
+function WagonRow({
+  wagon,
+  checked,
+  disabled,
+  badge,
+  onToggle,
+}: {
+  wagon: ConsistWagonRef;
+  checked: boolean;
+  disabled: boolean;
+  badge: string | null;
+  onToggle: (id: string, checked: boolean) => void;
+}) {
+  return (
+    <Group
+      gap="sm"
+      wrap="nowrap"
+      p={6}
+      style={{
+        border: "1px solid var(--mantine-color-gray-2)",
+        borderRadius: "var(--mantine-radius-md)",
+        opacity: disabled && !badge ? 0.7 : 1,
+      }}
+    >
+      <Checkbox
+        size="sm"
+        checked={checked}
+        disabled={disabled}
+        onChange={(e) => onToggle(wagon.id, e.currentTarget.checked)}
+        aria-label={`Select wagon ${wagon.wagonNumber}`}
+      />
+      <Stack gap={0} style={{ flex: 1, minWidth: 0 }}>
+        <Text size="sm" fw={600} ff="monospace" truncate>
+          {wagon.wagonNumber}
+        </Text>
+        <Text size="xs" c="dimmed" truncate>
+          {wagon.wagonType
+            ? `${wagon.wagonType.code} · ${wagon.wagonType.tareWeightTons}T tare · ${wagon.wagonType.lengthMeters}m`
+            : "Unknown type"}
+        </Text>
+      </Stack>
+      {badge ? (
+        <Badge size="xs" variant="light" color={badge === "Loaded" ? "orange" : "gray"}>
+          {badge}
+        </Badge>
+      ) : null}
+    </Group>
+  );
+}
diff --git a/apps/edr-freight-web/backoffice/src/components/trainScheduling/TrainCompositionDiagram.tsx b/apps/edr-freight-web/backoffice/src/components/trainScheduling/TrainCompositionDiagram.tsx
index 6ba1a0e29..2805ba60a 100644
--- a/apps/edr-freight-web/backoffice/src/components/trainScheduling/TrainCompositionDiagram.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/trainScheduling/TrainCompositionDiagram.tsx
@@ -506,12 +506,19 @@ function TrackBed() {
 
 export function TrainCompositionDiagram({
   locomotive,
+  locomotives,
   wagons,
   freightType,
   trainNumber,
   totalLengthMeters,
 }: {
   locomotive?: { code?: string | null; name?: string | null; maxPullWeightTons?: number | null } | null;
+  /** Full locomotive set (built trains, ≥2). Takes precedence over `locomotive`. */
+  locomotives?: Array<{
+    code?: string | null;
+    name?: string | null;
+    maxPullWeightTons?: number | null;
+  }> | null;
   wagons: DiagramWagonInput[];
   freightType?: string | null;
   trainNumber?: string | null;
@@ -519,6 +526,11 @@ export function TrainCompositionDiagram({
 }) {
   const { ref, width } = useElementSize();
 
+  const locos = useMemo(
+    () => (locomotives?.length ? locomotives : locomotive ? [locomotive] : []),
+    [locomotives, locomotive],
+  );
+
   const normalized = useMemo(
     () => wagons.map((w) => normalizeWagon(w, freightType)),
     [wagons, freightType],
@@ -533,6 +545,11 @@ export function TrainCompositionDiagram({
     // ceiling the allocation engine spends from.
     const totalTare = normalized.reduce((s, w) => s + w.tareWeightTons, 0);
     const grossWeight = totalWeight + totalTare;
+    // Weakest locomotive caps the set — same rule the allocation engine applies.
+    const pullLimits = locos
+      .map((l) => Number(l.maxPullWeightTons))
+      .filter((v) => Number.isFinite(v) && v > 0);
+    const pullLimit = pullLimits.length ? Math.min(...pullLimits) : null;
     return {
       total: normalized.length,
       assigned,
@@ -541,22 +558,25 @@ export function TrainCompositionDiagram({
       totalTare: Math.round(totalTare * 100) / 100,
       grossWeight: Math.round(grossWeight * 100) / 100,
       totalCapacity,
-      pullUtil:
-        locomotive?.maxPullWeightTons && locomotive.maxPullWeightTons > 0
-          ? Math.min(100, Math.round((grossWeight / locomotive.maxPullWeightTons) * 100))
-          : null,
+      pullLimit,
+      pullUtil: pullLimit
+        ? Math.min(100, Math.round((grossWeight / pullLimit) * 100))
+        : null,
     };
-  }, [normalized, locomotive]);
+  }, [normalized, locos]);
 
-  // cars-per-row from measured width; locomotive counts as one car
+  // cars-per-row from measured width; each locomotive counts as one car
   const perRow = Math.max(1, Math.floor((width || CAR_WIDTH) / CAR_WIDTH));
   const cars = useMemo(
-    () => [{ kind: "loco" as const }, ...normalized.map((w) => ({ kind: "wagon" as const, w }))],
-    [normalized],
+    () => [
+      ...locos.map((l) => ({ kind: "loco" as const, l })),
+      ...normalized.map((w) => ({ kind: "wagon" as const, w })),
+    ],
+    [locos, normalized],
   );
   const rows = useMemo(() => chunk(cars, perRow), [cars, perRow]);
 
-  if (!locomotive && !wagons.length) return null;
+  if (!locos.length && !wagons.length) return null;
 
   return (
     <Paper
@@ -658,8 +678,8 @@ export function TrainCompositionDiagram({
                 <Text size="xs" fw={700} c="edr-green.8">
                   Locomotive load ·{" "}
                   {stats.totalTare > 0
-                    ? `${stats.grossWeight}T of ${locomotive?.maxPullWeightTons}T (${stats.totalWeight}T cargo + ${stats.totalTare}T tare)`
-                    : `${stats.totalWeight}T of ${locomotive?.maxPullWeightTons}T`}
+                    ? `${stats.grossWeight}T of ${stats.pullLimit}T (${stats.totalWeight}T cargo + ${stats.totalTare}T tare)`
+                    : `${stats.totalWeight}T of ${stats.pullLimit}T`}
                 </Text>
               </Group>
               <Text size="sm" fw={800} c={stats.pullUtil > 95 ? "red.7" : "edr-green.7"}>
@@ -702,13 +722,11 @@ export function TrainCompositionDiagram({
                         <Group key={carIndex} gap={0} wrap="nowrap" style={{ flexDirection: reversed ? "row-reverse" : "row" }}>
                           {carIndex > 0 ? <Coupler /> : null}
                           {car.kind === "loco" ? (
-                            locomotive ? (
-                              <LocomotiveCar
-                                code={locomotive.code ?? "LOCO"}
-                                name={locomotive.name}
-                                maxPullWeightTons={locomotive.maxPullWeightTons}
-                              />
-                            ) : null
+                            <LocomotiveCar
+                              code={car.l.code ?? "LOCO"}
+                              name={car.l.name}
+                              maxPullWeightTons={car.l.maxPullWeightTons}
+                            />
                           ) : (
                             <WagonCar wagon={car.w} />
                           )}
diff --git a/apps/edr-freight-web/backoffice/src/components/wagons/WagonTransferRequestsModal.tsx b/apps/edr-freight-web/backoffice/src/components/wagons/WagonTransferRequestsModal.tsx
new file mode 100644
index 000000000..f17c74d9a
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/components/wagons/WagonTransferRequestsModal.tsx
@@ -0,0 +1,525 @@
+import { Freight } from "@edr/types";
+import {
+  Badge,
+  Button,
+  Card,
+  Checkbox,
+  Divider,
+  Group,
+  Loader,
+  Modal,
+  ScrollArea,
+  Stack,
+  Switch,
+  Tabs,
+  Text,
+  ThemeIcon,
+} from "@mantine/core";
+import { useMutation, useQuery } from "@tanstack/react-query";
+import {
+  ArrowRight,
+  ChevronLeft,
+  History,
+  Inbox,
+  PackageCheck,
+  Warehouse,
+  X,
+} from "lucide-react";
+import { useMemo, useState } from "react";
+
+import { api } from "@/services/api";
+import { useAuth } from "@/auth/useAuth";
+import { FREIGHT_PERMS, hasPermission } from "@/lib/permissions";
+import { useToast } from "@/hooks/use-toast";
+import type {
+  WagonMovementRecord,
+  WagonTransferRequest,
+} from "@/services/wagon.service";
+
+export interface WagonTransferRequestsModalProps {
+  opened: boolean;
+  onClose: () => void;
+}
+
+const PENDING = Freight.WagonTransferRequestStatus.Pending;
+const AVAILABLE = Freight.WagonStatus.Available;
+
+const yardLabel = (y?: { label?: string; code?: string } | null) =>
+  y?.label || y?.code || "—";
+const typeLabel = (t?: { code?: string; name?: string } | null) =>
+  t ? `${t.code ?? ""}${t.name ? ` · ${t.name}` : ""}` : "—";
+
+/** Requester → destination + type + count summary line, reused in list and picker. */
+const RequestSummary = ({ r }: { r: WagonTransferRequest }) => (
+  <Group gap={8} wrap="nowrap">
+    <Text fw={600} size="sm" truncate>
+      {yardLabel(r.fromYard)}
+    </Text>
+    <ArrowRight size={14} style={{ flexShrink: 0 }} />
+    <Text fw={600} size="sm" truncate>
+      {yardLabel(r.toYard)}
+    </Text>
+    <Badge variant="light" color="grape" radius="sm">
+      {r.quantity}× {typeLabel(r.wagonType)}
+    </Badge>
+  </Group>
+);
+
+const STATUS_COLOR: Record<string, string> = {
+  PENDING: "gray",
+  FULFILLED: "teal",
+  CANCELLED: "red",
+};
+
+const fmtDateTime = (iso: string) =>
+  new Date(iso).toLocaleString("en-GB", {
+    day: "numeric",
+    month: "short",
+    hour: "2-digit",
+    minute: "2-digit",
+    hour12: false,
+  });
+
+/**
+ * Per-user transfer history. A staffer sees their OWN activity — the requests
+ * they filed or fulfilled, and the individual wagons they moved. Holders of
+ * `transfer_history_all` get an "All staff" toggle that widens the view; the
+ * backend enforces the scope regardless of the toggle.
+ */
+function HistoryPanel({ opened }: { opened: boolean }) {
+  const { user } = useAuth();
+  const canSeeAll = hasPermission(
+    user,
+    FREIGHT_PERMS.wagons.transferHistoryAll,
+  );
+  const myId = (user as { id?: string } | null | undefined)?.id;
+  const [allStaff, setAllStaff] = useState(false);
+  const scopeAll = canSeeAll && allStaff;
+
+  const mine = useQuery({
+    ...api.wagonTransferRequests.history.queryOptions(),
+    enabled: opened && !scopeAll,
+  });
+  const all = useQuery({
+    ...api.wagonTransferRequests.historyAll.queryOptions({ input: {} }),
+    enabled: opened && scopeAll,
+  });
+  const source = scopeAll ? all : mine;
+  const requests = source.data?.requests ?? [];
+  const movements: WagonMovementRecord[] = source.data?.movements ?? [];
+
+  const roleBadge = (r: WagonTransferRequest) => {
+    if (myId && r.fulfilledByUserId === myId)
+      return (
+        <Badge size="xs" variant="light" color="blue">
+          fulfilled
+        </Badge>
+      );
+    if (myId && r.requestedByUserId === myId)
+      return (
+        <Badge size="xs" variant="light" color="grape">
+          requested
+        </Badge>
+      );
+    return null;
+  };
+
+  return (
+    <Stack gap="lg">
+      {canSeeAll ? (
+        <Group justify="flex-end">
+          <Switch
+            checked={allStaff}
+            onChange={(e) => setAllStaff(e.currentTarget.checked)}
+            label="All staff"
+            color="edr-green"
+          />
+        </Group>
+      ) : null}
+
+      {source.isLoading ? (
+        <Group justify="center" p="xl">
+          <Loader />
+        </Group>
+      ) : (
+        <>
+          <div>
+            <Text fw={700} size="sm" mb={8}>
+              Requests{scopeAll ? "" : " you touched"}
+            </Text>
+            {requests.length === 0 ? (
+              <Text size="sm" c="dimmed">
+                No requests yet.
+              </Text>
+            ) : (
+              <Stack gap={6}>
+                {requests.map((r) => (
+                  <Card key={r.id} withBorder radius="md" padding="xs">
+                    <Group justify="space-between" wrap="nowrap">
+                      <RequestSummary r={r} />
+                      <Group gap={8} wrap="nowrap">
+                        {roleBadge(r)}
+                        <Badge
+                          size="sm"
+                          variant="light"
+                          color={STATUS_COLOR[r.status] ?? "gray"}
+                        >
+                          {r.status.toLowerCase()}
+                        </Badge>
+                      </Group>
+                    </Group>
+                  </Card>
+                ))}
+              </Stack>
+            )}
+          </div>
+
+          <Divider />
+
+          <div>
+            <Text fw={700} size="sm" mb={8}>
+              Wagons moved
+            </Text>
+            {movements.length === 0 ? (
+              <Text size="sm" c="dimmed">
+                No wagon moves yet.
+              </Text>
+            ) : (
+              <ScrollArea.Autosize mah={260}>
+                <Stack gap={6}>
+                  {movements.map((m) => (
+                    <Card key={m.id} withBorder radius="md" padding="xs">
+                      <Group justify="space-between" wrap="nowrap">
+                        <Group gap={8} wrap="nowrap" style={{ minWidth: 0 }}>
+                          <Text fw={600} size="sm">
+                            {m.wagon?.wagonNumber ?? "Wagon"}
+                          </Text>
+                          <Text size="xs" c="dimmed" truncate>
+                            {yardLabel(m.fromYard)} → {yardLabel(m.toYard)}
+                          </Text>
+                          {m.transferRequestId ? (
+                            <Badge size="xs" variant="light" color="teal">
+                              from request
+                            </Badge>
+                          ) : null}
+                        </Group>
+                        <Text size="xs" c="dimmed" style={{ flexShrink: 0 }}>
+                          {fmtDateTime(m.occurredAt)}
+                        </Text>
+                      </Group>
+                    </Card>
+                  ))}
+                </Stack>
+              </ScrollArea.Autosize>
+            )}
+          </div>
+        </>
+      )}
+    </Stack>
+  );
+}
+
+/**
+ * OCC fulfilment queue for wagon-transfer requests. Lists PENDING requests; open
+ * one to hand-pick exactly the requested number of wagons from the source yard
+ * (of the requested type) and execute the move, or cancel the request.
+ * A second tab shows per-user transfer history.
+ */
+const WagonTransferRequestsModal = ({
+  opened,
+  onClose,
+}: WagonTransferRequestsModalProps) => {
+  const { toast } = useToast();
+  const [tab, setTab] = useState<string | null>("queue");
+  const [active, setActive] = useState<WagonTransferRequest | null>(null);
+  const [picked, setPicked] = useState<Set<string>>(new Set());
+
+  const { data: requests = [], isLoading } = useQuery({
+    ...api.wagonTransferRequests.list.queryOptions({ input: { status: PENDING } }),
+    enabled: opened,
+  });
+
+  // Available wagons of the requested type sitting in the request's source yard.
+  const { data: wagons = [], isLoading: wagonsLoading } = useQuery({
+    ...api.wagons.list.queryOptions({
+      input: {
+        filters: active
+          ? {
+              currentYardId: active.fromYardId,
+              wagonTypeId: active.wagonTypeId,
+              status: AVAILABLE,
+            }
+          : {},
+      },
+    }),
+    enabled: opened && Boolean(active),
+  });
+
+  const fulfill = useMutation(api.wagonTransferRequests.fulfill.mutationOptions());
+  const cancel = useMutation(api.wagonTransferRequests.cancel.mutationOptions());
+
+  const showError = (err: unknown, fallback: string) => {
+    const message =
+      (err as { response?: { data?: { message?: string } } })?.response?.data
+        ?.message ?? fallback;
+    toast({ title: fallback, description: String(message), variant: "destructive" });
+  };
+
+  const openPicker = (r: WagonTransferRequest) => {
+    setActive(r);
+    setPicked(new Set());
+  };
+  const closePicker = () => {
+    setActive(null);
+    setPicked(new Set());
+  };
+
+  const toggle = (id: string) =>
+    setPicked((prev) => {
+      const next = new Set(prev);
+      if (next.has(id)) next.delete(id);
+      else if (active && next.size >= active.quantity) return prev; // cap at quantity
+      else next.add(id);
+      return next;
+    });
+
+  const need = active?.quantity ?? 0;
+  const shortfall = active ? Math.max(0, need - wagons.length) : 0;
+
+  const handleFulfill = async () => {
+    if (!active || picked.size !== need) return;
+    try {
+      await fulfill.mutateAsync({ id: active.id, wagonIds: [...picked] });
+      toast({
+        title: `Transferred ${need} wagon(s) · ${yardLabel(active.fromYard)} → ${yardLabel(
+          active.toYard,
+        )}`,
+      });
+      closePicker();
+    } catch (err) {
+      showError(err, "Transfer failed");
+    }
+  };
+
+  const handleCancel = async (r: WagonTransferRequest) => {
+    try {
+      await cancel.mutateAsync({ id: r.id });
+      toast({ title: "Request cancelled" });
+    } catch (err) {
+      showError(err, "Cancel failed");
+    }
+  };
+
+  const sortedWagons = useMemo(
+    () => [...wagons].sort((a, b) => a.wagonNumber.localeCompare(b.wagonNumber)),
+    [wagons],
+  );
+
+  return (
+    <Modal
+      opened={opened}
+      onClose={onClose}
+      size="min(760px, 96vw)"
+      radius="lg"
+      centered
+      overlayProps={{ blur: 2 }}
+      title={
+        <Group gap="sm">
+          <ThemeIcon variant="light" color="edr-green" radius="md" size="lg">
+            <Inbox size={18} />
+          </ThemeIcon>
+          <div>
+            <Text fw={700}>Wagon Transfer Requests</Text>
+            <Text size="xs" c="dimmed">
+              {active
+                ? "Pick the wagons to move, then transfer"
+                : "OCC queue — pick wagons and complete each move"}
+            </Text>
+          </div>
+        </Group>
+      }
+    >
+      <Tabs value={tab} onChange={setTab} keepMounted={false}>
+        <Tabs.List mb="md">
+          <Tabs.Tab value="queue" leftSection={<Inbox size={14} />}>
+            Queue
+          </Tabs.Tab>
+          <Tabs.Tab value="history" leftSection={<History size={14} />}>
+            History
+          </Tabs.Tab>
+        </Tabs.List>
+
+        <Tabs.Panel value="queue">
+      {!active ? (
+        // ---- Pending queue ----
+        isLoading ? (
+          <Group justify="center" p="xl">
+            <Loader />
+          </Group>
+        ) : requests.length === 0 ? (
+          <Card withBorder radius="md" padding="xl">
+            <Stack align="center" gap={6}>
+              <ThemeIcon variant="light" color="gray" radius="xl" size={48}>
+                <Inbox size={22} />
+              </ThemeIcon>
+              <Text fw={600}>No pending transfer requests</Text>
+              <Text size="sm" c="dimmed" ta="center" maw={420}>
+                When staff request a yard-to-yard wagon move, it appears here for
+                you to fulfil.
+              </Text>
+            </Stack>
+          </Card>
+        ) : (
+          <Stack gap="sm">
+            {requests.map((r) => (
+              <Card key={r.id} withBorder radius="md" padding="md">
+                <Group justify="space-between" wrap="nowrap" align="flex-start">
+                  <Stack gap={6} style={{ minWidth: 0 }}>
+                    <RequestSummary r={r} />
+                    {r.note ? (
+                      <Text size="xs" c="dimmed">
+                        “{r.note}”
+                      </Text>
+                    ) : null}
+                  </Stack>
+                  <Group gap={8} wrap="nowrap">
+                    <Button
+                      size="compact-sm"
+                      variant="subtle"
+                      color="gray"
+                      leftSection={<X size={14} />}
+                      loading={cancel.isPending}
+                      onClick={() => handleCancel(r)}
+                    >
+                      Cancel
+                    </Button>
+                    <Button
+                      size="compact-sm"
+                      color="edr-green"
+                      leftSection={<PackageCheck size={14} />}
+                      onClick={() => openPicker(r)}
+                    >
+                      Fulfil
+                    </Button>
+                  </Group>
+                </Group>
+              </Card>
+            ))}
+          </Stack>
+        )
+      ) : (
+        // ---- Wagon picker for the active request ----
+        <Stack gap="md">
+          <Card withBorder radius="md" padding="sm" bg="var(--mantine-color-gray-0)">
+            <RequestSummary r={active} />
+          </Card>
+
+          <Group justify="space-between">
+            <Text size="sm" fw={600}>
+              Select wagons in {yardLabel(active.fromYard)}
+            </Text>
+            <Badge
+              color={picked.size === need ? "teal" : "gray"}
+              variant={picked.size === need ? "filled" : "light"}
+            >
+              {picked.size} / {need} selected
+            </Badge>
+          </Group>
+
+          {wagonsLoading ? (
+            <Group justify="center" p="lg">
+              <Loader size="sm" />
+            </Group>
+          ) : sortedWagons.length === 0 ? (
+            <Card withBorder radius="md" padding="lg">
+              <Group gap={8} justify="center">
+                <Warehouse size={16} />
+                <Text size="sm" c="dimmed">
+                  No available wagons of this type in {yardLabel(active.fromYard)}.
+                </Text>
+              </Group>
+            </Card>
+          ) : (
+            <>
+              {shortfall > 0 ? (
+                <Text size="xs" c="orange.7">
+                  Only {sortedWagons.length} available — {shortfall} short of the{" "}
+                  {need} requested.
+                </Text>
+              ) : null}
+              <ScrollArea.Autosize mah={320}>
+                <Stack gap={6}>
+                  {sortedWagons.map((w) => {
+                    const checked = picked.has(w.id);
+                    const atCap = !checked && picked.size >= need;
+                    return (
+                      <Card
+                        key={w.id}
+                        withBorder
+                        radius="md"
+                        padding="xs"
+                        onClick={() => !atCap && toggle(w.id)}
+                        style={{
+                          cursor: atCap ? "not-allowed" : "pointer",
+                          borderColor: checked
+                            ? "var(--mantine-color-edr-green-4)"
+                            : undefined,
+                          opacity: atCap ? 0.55 : 1,
+                        }}
+                      >
+                        <Group gap="sm" wrap="nowrap">
+                          {/* Visual only — the Card's onClick owns the toggle so a
+                              click on the box doesn't fire both and cancel out. */}
+                          <Checkbox
+                            checked={checked}
+                            readOnly
+                            disabled={atCap}
+                            color="edr-green"
+                            tabIndex={-1}
+                            aria-hidden
+                          />
+                          <Text fw={600} size="sm">
+                            {w.wagonNumber}
+                          </Text>
+                        </Group>
+                      </Card>
+                    );
+                  })}
+                </Stack>
+              </ScrollArea.Autosize>
+            </>
+          )}
+
+          <Divider />
+          <Group justify="space-between">
+            <Button
+              variant="subtle"
+              color="gray"
+              leftSection={<ChevronLeft size={16} />}
+              onClick={closePicker}
+            >
+              Back to queue
+            </Button>
+            <Button
+              color="edr-green"
+              leftSection={<PackageCheck size={16} />}
+              loading={fulfill.isPending}
+              disabled={picked.size !== need}
+              onClick={handleFulfill}
+            >
+              Transfer {need} wagon{need === 1 ? "" : "s"}
+            </Button>
+          </Group>
+        </Stack>
+      )}
+        </Tabs.Panel>
+
+        <Tabs.Panel value="history">
+          <HistoryPanel opened={opened} />
+        </Tabs.Panel>
+      </Tabs>
+    </Modal>
+  );
+};
+
+export default WagonTransferRequestsModal;
diff --git a/apps/edr-freight-web/backoffice/src/components/wagons/WagonYardWorkspaceModal.tsx b/apps/edr-freight-web/backoffice/src/components/wagons/WagonYardWorkspaceModal.tsx
index 67506caed..47bf93aa7 100644
--- a/apps/edr-freight-web/backoffice/src/components/wagons/WagonYardWorkspaceModal.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/wagons/WagonYardWorkspaceModal.tsx
@@ -14,7 +14,6 @@ import {
   Select,
   Slider,
   Stack,
-  Switch,
   Text,
   ThemeIcon,
 } from "@mantine/core";
@@ -126,11 +125,12 @@ const WagonYardWorkspaceModal = ({ opened, onClose }: WagonYardWorkspaceModalPro
 
   const [transferYardId, setTransferYardId] = useState<string | null>(null);
   const [transferQty, setTransferQty] = useState(0);
-  const [freeAfterMove, setFreeAfterMove] = useState(false);
   const [toAssignedQty, setToAssignedQty] = useState(0);
   const [toAvailableQty, setToAvailableQty] = useState(0);
 
-  const transfer = useMutation(api.wagons.bulkTransfer.mutationOptions());
+  const createRequest = useMutation(
+    api.wagonTransferRequests.create.mutationOptions(),
+  );
   const setStatus = useMutation(api.wagons.bulkSetStatus.mutationOptions());
 
   const yardName = useMemo(() => {
@@ -187,13 +187,6 @@ const WagonYardWorkspaceModal = ({ opened, onClose }: WagonYardWorkspaceModalPro
     () => matching.filter((w) => w.status !== AVAILABLE && w.status !== ASSIGNED),
     [matching],
   );
-  // Available first, then assigned, then the rest — a partial move relocates
-  // idle wagons before touching assigned ones.
-  const transferPool = useMemo(
-    () => [...availableWagons, ...assignedWagons, ...otherWagons],
-    [availableWagons, assignedWagons, otherWagons],
-  );
-
   const total = matching.length;
   const availableCount = availableWagons.length;
   const assignedCount = assignedWagons.length;
@@ -214,7 +207,6 @@ const WagonYardWorkspaceModal = ({ opened, onClose }: WagonYardWorkspaceModalPro
   useEffect(() => {
     setTransferYardId(null);
     setTransferQty(0);
-    setFreeAfterMove(false);
     setToAssignedQty(0);
     setToAvailableQty(0);
   }, [yardId, typeId]);
@@ -238,25 +230,27 @@ const WagonYardWorkspaceModal = ({ opened, onClose }: WagonYardWorkspaceModalPro
     toast({ title: fallback, description: String(message), variant: "destructive" });
   };
 
-  const handleTransfer = async () => {
-    if (!transferYardId || transferQty < 1) return;
-    const ids = transferPool.slice(0, transferQty).map((w) => w.id);
-    if (!ids.length) return;
+  // Request-only: the requester specifies count + destination; OCC later picks
+  // the physical wagons and executes the move. No wagons are moved here.
+  const handleRequest = async () => {
+    if (!yardId || !typeId || !transferYardId || transferQty < 1) return;
     try {
-      const res = await transfer.mutateAsync({ wagonIds: ids, toYardId: transferYardId });
-      if (freeAfterMove) {
-        await setStatus.mutateAsync({ wagonIds: ids, status: AVAILABLE });
-      }
+      await createRequest.mutateAsync({
+        fromYardId: yardId,
+        toYardId: transferYardId,
+        wagonTypeId: typeId,
+        quantity: transferQty,
+      });
       toast({
-        title: `Moved ${res.moved} wagon(s) to ${yardName(transferYardId)}${
-          freeAfterMove ? " · set Available" : ""
-        }`,
+        title: `Requested ${transferQty} ${typeInfo.code(typeId)} wagon(s) · ${yardName(
+          yardId,
+        )} → ${yardName(transferYardId)}`,
+        description: "OCC will pick the wagons and complete the move.",
       });
       setTransferQty(0);
       setTransferYardId(null);
-      setFreeAfterMove(false);
     } catch (err) {
-      showError(err, "Transfer failed");
+      showError(err, "Request failed");
     }
   };
 
@@ -279,7 +273,7 @@ const WagonYardWorkspaceModal = ({ opened, onClose }: WagonYardWorkspaceModalPro
     }
   };
 
-  const busy = transfer.isPending || setStatus.isPending;
+  const busy = createRequest.isPending || setStatus.isPending;
   const pct = (n: number) => (total > 0 ? (n / total) * 100 : 0);
 
   return (
@@ -402,12 +396,15 @@ const WagonYardWorkspaceModal = ({ opened, onClose }: WagonYardWorkspaceModalPro
               {/* Transfer */}
               <Grid.Col span={{ base: 12, md: 6 }}>
                 <Card withBorder radius="md" h="100%" padding="lg">
-                  <Group gap="xs" mb="md">
+                  <Group gap="xs" mb={4}>
                     <ThemeIcon variant="light" color="grape" radius="md" size="md">
                       <ArrowRightLeft size={16} />
                     </ThemeIcon>
-                    <Text fw={700}>Move to another yard</Text>
+                    <Text fw={700}>Request transfer to another yard</Text>
                   </Group>
+                  <Text size="xs" c="dimmed" mb="md">
+                    Sends a request to OCC — they pick the wagons and complete the move.
+                  </Text>
                   <Stack gap="md">
                     <div>
                       <Text size="sm" fw={500} mb={4}>
@@ -424,12 +421,6 @@ const WagonYardWorkspaceModal = ({ opened, onClose }: WagonYardWorkspaceModalPro
                       searchable
                       radius="md"
                     />
-                    <Switch
-                      checked={freeAfterMove}
-                      onChange={(e) => setFreeAfterMove(e.currentTarget.checked)}
-                      label="Set moved wagons to Available"
-                      color="teal"
-                    />
                     {transferYardId && transferQty > 0 ? (
                       <Card bg="var(--mantine-color-gray-0)" radius="md" padding="sm" withBorder>
                         <Group gap={8} wrap="nowrap">
@@ -453,12 +444,13 @@ const WagonYardWorkspaceModal = ({ opened, onClose }: WagonYardWorkspaceModalPro
                     ) : null}
                     <Button
                       leftSection={<ArrowRightLeft size={16} />}
-                      onClick={handleTransfer}
-                      loading={transfer.isPending}
+                      onClick={handleRequest}
+                      loading={createRequest.isPending}
                       disabled={busy || !transferYardId || transferQty < 1}
                       color="edr-green"
                     >
-                      Move {transferQty > 0 ? `${transferQty} ` : ""}wagon{transferQty === 1 ? "" : "s"}
+                      Request {transferQty > 0 ? `${transferQty} ` : ""}wagon
+                      {transferQty === 1 ? "" : "s"}
                     </Button>
                   </Stack>
                 </Card>
diff --git a/apps/edr-freight-web/backoffice/src/components/warehouses/AccrualDashboard.tsx b/apps/edr-freight-web/backoffice/src/components/warehouses/AccrualDashboard.tsx
new file mode 100644
index 000000000..5170b345d
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/components/warehouses/AccrualDashboard.tsx
@@ -0,0 +1,241 @@
+import { useMemo } from 'react';
+import { ActionIcon, Badge, Card, Group, Loader, Menu, SimpleGrid, Stack, Table, Text, ThemeIcon } from '@mantine/core';
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { AlertTriangle, Bell, BellOff, Check, Clock, DollarSign, MoreVertical } from 'lucide-react';
+
+import { useAccrualDashboard } from '@/hooks/useWarehouses';
+import { warehouseService } from '@/services/warehouse.service';
+import { useToast } from '@/hooks/use-toast';
+import type { AccrualAlert, AccrualDashboardRow } from '@/types/warehouse';
+
+const ALERT_META: Record<AccrualAlert, { color: string; label: string }> = {
+  CHARGING: { color: 'red', label: 'Charging' },
+  WARNING: { color: 'orange', label: 'Free days ending' },
+  OK: { color: 'teal', label: 'Within free days' },
+};
+
+function money(amount: number, currency: string): string {
+  return `${amount.toLocaleString(undefined, { minimumFractionDigits: 2, maximumFractionDigits: 2 })} ${currency}`;
+}
+
+function freeDaysLabel(row: AccrualDashboardRow): string {
+  if (row.charging) return 'charging now';
+  if (row.freeDaysLeft == null) return '—';
+  return `${row.freeDaysLeft} day${row.freeDaysLeft === 1 ? '' : 's'} left`;
+}
+
+/**
+ * Live accrual dashboard: storage / demurrage ticking per in-warehouse item,
+ * sorted so items already charging (or about to) surface first. Read-only.
+ */
+export function AccrualDashboard() {
+  const { data: rows = [], isLoading } = useAccrualDashboard();
+  const { toast } = useToast();
+  const qc = useQueryClient();
+
+  const refresh = () =>
+    qc.invalidateQueries({ queryKey: ['warehouse-fees', 'accrual-dashboard'] });
+
+  const ack = useMutation({
+    mutationFn: ({ id, snoozeDays }: { id: string; snoozeDays?: number }) =>
+      warehouseService.acknowledgeAccrual(id, snoozeDays ? { snoozeDays } : {}),
+    onSuccess: (_r, v) => {
+      toast({ title: v.snoozeDays ? `Snoozed ${v.snoozeDays} days` : 'Marked reviewed' });
+      void refresh();
+    },
+    onError: () => toast({ variant: 'destructive', title: 'Could not acknowledge' }),
+  });
+  const unack = useMutation({
+    mutationFn: (id: string) => warehouseService.unacknowledgeAccrual(id),
+    onSuccess: () => {
+      toast({ title: 'Acknowledgement removed' });
+      void refresh();
+    },
+    onError: () => toast({ variant: 'destructive', title: 'Could not un-acknowledge' }),
+  });
+
+  const summary = useMemo(() => {
+    const currency = rows[0]?.currency ?? 'USD';
+    return {
+      currency,
+      charging: rows.filter((r) => r.alert === 'CHARGING').length,
+      atRisk: rows.filter((r) => r.alert === 'WARNING').length,
+      totalAccruing: Math.round(rows.reduce((s, r) => s + r.accruedAmount, 0) * 100) / 100,
+    };
+  }, [rows]);
+
+  if (isLoading) {
+    return (
+      <Group justify="center" py="xl">
+        <Loader />
+      </Group>
+    );
+  }
+
+  return (
+    <Stack gap="md">
+      <SimpleGrid cols={{ base: 1, xs: 3 }} spacing="sm">
+        <StatCard
+          icon={<DollarSign size={18} />}
+          label="Accruing now"
+          value={money(summary.totalAccruing, summary.currency)}
+          color="edr-green"
+        />
+        <StatCard
+          icon={<AlertTriangle size={18} />}
+          label="Charging"
+          value={summary.charging}
+          color={summary.charging > 0 ? 'red' : 'gray'}
+        />
+        <StatCard
+          icon={<Clock size={18} />}
+          label="Free days ending (≤2d)"
+          value={summary.atRisk}
+          color={summary.atRisk > 0 ? 'orange' : 'gray'}
+        />
+      </SimpleGrid>
+
+      <Card withBorder radius="md" padding={0}>
+        {rows.length === 0 ? (
+          <Text c="dimmed" ta="center" py="xl" size="sm">
+            No in-warehouse items are accruing fees.
+          </Text>
+        ) : (
+          <Table.ScrollContainer minWidth={900}>
+            <Table verticalSpacing="sm" highlightOnHover striped>
+              <Table.Thead>
+                <Table.Tr>
+                  <Table.Th>Booking</Table.Th>
+                  <Table.Th>Customer</Table.Th>
+                  <Table.Th>Location</Table.Th>
+                  <Table.Th>Status</Table.Th>
+                  <Table.Th ta="right">Accrued</Table.Th>
+                  <Table.Th>Free days</Table.Th>
+                  <Table.Th>Alert</Table.Th>
+                  <Table.Th ta="right" />
+                </Table.Tr>
+              </Table.Thead>
+              <Table.Tbody>
+                {rows.map((row) => {
+                  const meta = ALERT_META[row.alert];
+                  const busy = ack.isPending || unack.isPending;
+                  return (
+                    <Table.Tr key={row.inventoryId} style={{ opacity: row.acknowledged ? 0.55 : 1 }}>
+                      <Table.Td>
+                        <Text fw={600} size="sm">
+                          {row.bookingReference ?? row.inventoryId.slice(0, 8)}
+                        </Text>
+                      </Table.Td>
+                      <Table.Td>{row.customerName ?? '—'}</Table.Td>
+                      <Table.Td>
+                        <Text size="sm">
+                          {[row.warehouseCode, row.zoneCode].filter(Boolean).join(' · ') || '—'}
+                        </Text>
+                      </Table.Td>
+                      <Table.Td>
+                        <Badge variant="light" color="gray" size="sm">
+                          {row.status}
+                        </Badge>
+                      </Table.Td>
+                      <Table.Td ta="right">
+                        <Text fw={600} size="sm" c={row.accruedAmount > 0 ? 'red' : undefined}>
+                          {money(row.accruedAmount, row.currency)}
+                        </Text>
+                      </Table.Td>
+                      <Table.Td>
+                        <Text size="sm" c={row.charging ? 'red' : undefined}>
+                          {freeDaysLabel(row)}
+                        </Text>
+                      </Table.Td>
+                      <Table.Td>
+                        {row.acknowledged ? (
+                          <Badge color="gray" variant="light" size="sm" leftSection={<Check size={11} />}>
+                            Reviewed{row.snoozeUntil ? ' (snoozed)' : ''}
+                          </Badge>
+                        ) : (
+                          <Badge color={meta.color} variant={row.alert === 'OK' ? 'light' : 'filled'} size="sm">
+                            {meta.label}
+                          </Badge>
+                        )}
+                      </Table.Td>
+                      <Table.Td ta="right">
+                        <Menu shadow="md" position="bottom-end" withinPortal>
+                          <Menu.Target>
+                            <ActionIcon variant="subtle" color="gray" loading={busy} aria-label="Accrual actions">
+                              <MoreVertical size={16} />
+                            </ActionIcon>
+                          </Menu.Target>
+                          <Menu.Dropdown>
+                            {row.acknowledged ? (
+                              <Menu.Item
+                                leftSection={<Bell size={14} />}
+                                onClick={() => unack.mutate(row.inventoryId)}
+                              >
+                                Un-acknowledge
+                              </Menu.Item>
+                            ) : (
+                              <>
+                                <Menu.Item
+                                  leftSection={<Check size={14} />}
+                                  onClick={() => ack.mutate({ id: row.inventoryId })}
+                                >
+                                  Mark reviewed
+                                </Menu.Item>
+                                <Menu.Item
+                                  leftSection={<BellOff size={14} />}
+                                  onClick={() => ack.mutate({ id: row.inventoryId, snoozeDays: 3 })}
+                                >
+                                  Snooze 3 days
+                                </Menu.Item>
+                                <Menu.Item
+                                  leftSection={<BellOff size={14} />}
+                                  onClick={() => ack.mutate({ id: row.inventoryId, snoozeDays: 7 })}
+                                >
+                                  Snooze 7 days
+                                </Menu.Item>
+                              </>
+                            )}
+                          </Menu.Dropdown>
+                        </Menu>
+                      </Table.Td>
+                    </Table.Tr>
+                  );
+                })}
+              </Table.Tbody>
+            </Table>
+          </Table.ScrollContainer>
+        )}
+      </Card>
+    </Stack>
+  );
+}
+
+function StatCard({
+  icon,
+  label,
+  value,
+  color,
+}: {
+  icon: React.ReactNode;
+  label: string;
+  value: React.ReactNode;
+  color: string;
+}) {
+  return (
+    <Card withBorder radius="md" padding="md">
+      <Group gap="sm" wrap="nowrap">
+        <ThemeIcon color={color} variant="light" size={40} radius="md">
+          {icon}
+        </ThemeIcon>
+        <Stack gap={0} style={{ minWidth: 0 }}>
+          <Text size="xs" c="dimmed" tt="uppercase" fw={700}>
+            {label}
+          </Text>
+          <Text fw={800} fz={20} lh={1.1} truncate>
+            {value}
+          </Text>
+        </Stack>
+      </Group>
+    </Card>
+  );
+}
diff --git a/apps/edr-freight-web/backoffice/src/components/warehouses/ContainerItemsModal.tsx b/apps/edr-freight-web/backoffice/src/components/warehouses/ContainerItemsModal.tsx
index 57be67d68..0a2dd5b7f 100644
--- a/apps/edr-freight-web/backoffice/src/components/warehouses/ContainerItemsModal.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/warehouses/ContainerItemsModal.tsx
@@ -80,14 +80,17 @@ export function ContainerItemsModal({ opened, onClose, bookingId, bookingReferen
     () => (tab === 'ALL' ? items : items.filter((i) => i.stage === tab)),
     [items, tab],
   );
-  // Only arrived, not-yet-departed trucks can be loaded.
+  // Any assigned, not-yet-departed truck can be loaded here — loading a truck at
+  // the warehouse auto-marks it arrived on the backend, so assigned-but-not-yet-
+  // arrived trucks are selectable too (labelled "assigned" until they arrive).
   const truckOptions = trucks
-    .filter(
-      (t) =>
-        Boolean((t as { arrivedAt?: string }).arrivedAt) &&
-        !(t as { departedAt?: string }).departedAt,
-    )
-    .map((t) => ({ value: t.id, label: `${t.plateNumber} · ${t.driverName}` }));
+    .filter((t) => !(t as { departedAt?: string }).departedAt)
+    .map((t) => ({
+      value: t.id,
+      label: `${t.plateNumber} · ${t.driverName}${
+        (t as { arrivedAt?: string }).arrivedAt ? '' : ' (assigned)'
+      }`,
+    }));
 
   const loadMutation = useMutation({
     mutationFn: () => warehouseService.loadTruck(bookingId as string, truckId as string, selected),
@@ -125,7 +128,28 @@ export function ContainerItemsModal({ opened, onClose, bookingId, bookingReferen
     }
   };
 
-  const toggle = (n: string) => setSelected((s) => (s.includes(n) ? s.filter((x) => x !== n) : [...s, n]));
+  const is40 = (n: string) =>
+    (items.find((i) => i.containerNumber === n)?.containerSize ?? '').includes('40');
+
+  // A truck carries at most 2 containers, and a 40ft fills the truck (max 1).
+  const toggle = (n: string) =>
+    setSelected((s) => {
+      if (s.includes(n)) return s.filter((x) => x !== n);
+      const next = [...s, n];
+      if (next.length > 2) {
+        toast({ variant: 'destructive', title: 'A truck carries at most 2 containers' });
+        return s;
+      }
+      if (next.length > 1 && next.some(is40)) {
+        toast({
+          variant: 'destructive',
+          title: 'A 40ft container fills the truck',
+          description: 'Load only one 40ft container per truck.',
+        });
+        return s;
+      }
+      return next;
+    });
 
   return (
     <Modal
@@ -162,6 +186,7 @@ export function ContainerItemsModal({ opened, onClose, bookingId, bookingReferen
                 <Table.Tr>
                   <Table.Th />
                   <Table.Th>Container</Table.Th>
+                  <Table.Th>Size</Table.Th>
                   <Table.Th>Goods</Table.Th>
                   <Table.Th>Stage</Table.Th>
                   <Table.Th>Truck</Table.Th>
@@ -182,6 +207,15 @@ export function ContainerItemsModal({ opened, onClose, bookingId, bookingReferen
                       />
                     </Table.Td>
                     <Table.Td><Text fw={600}>{i.containerNumber}</Text></Table.Td>
+                    <Table.Td>
+                      {i.containerSize ? (
+                        <Badge variant="light" color={i.containerSize.includes('40') ? 'grape' : 'blue'}>
+                          {i.containerSize}
+                        </Badge>
+                      ) : (
+                        <Text c="dimmed" size="sm">bulk</Text>
+                      )}
+                    </Table.Td>
                     <Table.Td>{i.goods ?? '—'}</Table.Td>
                     <Table.Td><Badge color={STAGE_COLOR[i.stage]} variant="light">{i.stage}</Badge></Table.Td>
                     <Table.Td>{i.truckPlate ?? '—'}</Table.Td>
@@ -221,11 +255,17 @@ export function ContainerItemsModal({ opened, onClose, bookingId, bookingReferen
 
           {/* Multiselect → load onto a truck */}
           <Group justify="space-between" align="flex-end">
-            <Text size="sm" c="dimmed">{selected.length} selected</Text>
+            <Text size="sm" c="dimmed">
+              {selected.length} selected
+              {(() => {
+                const pending = items.filter((i) => !i.truckAssignmentId).length;
+                return pending > 0 ? ` · ${pending} container${pending === 1 ? '' : 's'} pending assignment` : '';
+              })()}
+            </Text>
             <Group gap="sm" align="flex-end">
               <Select
                 label="Load onto truck"
-                placeholder={truckOptions.length ? 'Select truck' : 'No arrived truck'}
+                placeholder={truckOptions.length ? 'Select truck' : 'No truck assigned'}
                 data={truckOptions}
                 value={truckId}
                 onChange={setTruckId}
diff --git a/apps/edr-freight-web/backoffice/src/components/warehouses/InventoryWorkbench.tsx b/apps/edr-freight-web/backoffice/src/components/warehouses/InventoryWorkbench.tsx
index c4f1f5cec..d8b370de0 100644
--- a/apps/edr-freight-web/backoffice/src/components/warehouses/InventoryWorkbench.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/warehouses/InventoryWorkbench.tsx
@@ -19,7 +19,7 @@ import { MoveInventoryModal } from './MoveInventoryModal';
 import { ReleaseOrderModal } from './ReleaseOrderModal';
 import { WarehouseInventoryTable } from './WarehouseInventoryTable';
 import { extractDownloadErrorMessage, extractErrorMessage } from './options';
-import { openPdfBlob } from './pdf';
+import { openPdfBlob, saveBlob } from './pdf';
 
 interface InventoryWorkbenchProps {
   items: WarehouseInventoryItem[];
@@ -138,6 +138,42 @@ export function InventoryWorkbench({ items, isLoading, onLastMile }: InventoryWo
     }
   };
 
+  // One-click bundle: download every available document for the item (GRN +
+  // gate clearance / release order + handover). Best-effort — docs that aren't
+  // generatable yet for this item are skipped.
+  const downloadDocumentBundle = async (item: WarehouseInventoryItem) => {
+    setBusyId(item.id);
+    const ref = item.booking?.reference ?? item.bookingId ?? item.id;
+    const jobs: Array<{ name: string; fn: () => Promise<{ data: Blob }> }> = [
+      { name: `GRN-${ref}.pdf`, fn: () => warehouseService.downloadGrnDocument(item.id) },
+      { name: `gate-clearance-${ref}.pdf`, fn: () => warehouseService.downloadReleaseDocument(item.id) },
+      { name: `handover-${ref}.pdf`, fn: () => warehouseService.downloadHandoverDocument(item.id) },
+    ];
+    let saved = 0;
+    for (const job of jobs) {
+      try {
+        const response = await job.fn();
+        saveBlob(response.data, job.name);
+        saved += 1;
+      } catch {
+        // Document not available for this item yet — skip it.
+      }
+    }
+    setBusyId(null);
+    if (saved === 0) {
+      toast({
+        variant: 'destructive',
+        title: 'No documents available',
+        description: 'This item has no GRN, gate clearance or handover document yet.',
+      });
+    } else {
+      toast({
+        title: `Downloaded ${saved} document${saved !== 1 ? 's' : ''}`,
+        description: `Bundle for ${ref} (available documents only).`,
+      });
+    }
+  };
+
   const acceptLastMile = async (item: WarehouseInventoryItem) => {
     const reference = item.booking?.reference;
     if (!reference) {
@@ -243,6 +279,7 @@ export function InventoryWorkbench({ items, isLoading, onLastMile }: InventoryWo
           onFeePreview={setFeeItem}
           onReleaseDocument={downloadReleaseDocument}
           onHandoverDocument={openHandoverDocument}
+          onDownloadBundle={downloadDocumentBundle}
           onLastMile={onLastMile ? acceptLastMile : undefined}
           selectedIds={selected}
           onToggleSelect={toggleSelect}
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 6833167f7..26f2334b9 100644
--- a/apps/edr-freight-web/backoffice/src/components/warehouses/ReleaseOrderModal.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/warehouses/ReleaseOrderModal.tsx
@@ -121,6 +121,14 @@ export function ReleaseOrderModal({ opened, onClose, item, truckPrefill }: Relea
     queryFn: () => warehouseService.getCustomerTrucks(bookingId as string),
     enabled: opened && Boolean(bookingId),
   });
+  // EDR last-mile trucks assigned to this booking — surfaced even when the modal
+  // is opened from the warehouse flow (which passes no truckPrefill prop), so an
+  // assigned EDR truck no longer shows as "not assigned yet".
+  const { data: lastMileTrucks = [] } = useQuery({
+    queryKey: ['release-last-mile-trucks', bookingId],
+    queryFn: () => warehouseService.getLastMileTrucks(bookingId as string),
+    enabled: opened && Boolean(bookingId),
+  });
   // Per-container cargo weights — the truck's net (gross − tare) must equal the
   // total cargo weight of the containers selected as loaded on it.
   const { data: containerWeights = [] } = useQuery({
@@ -176,6 +184,24 @@ export function ReleaseOrderModal({ opened, onClose, item, truckPrefill }: Relea
   const isCustomerAssignedTruck = Boolean(item?.booking?.customerTruckAssignedAt);
   const hasLastMileTruckPrefill = Boolean(truckPrefill?.truckPlateNumber || truckPrefill?.trailerPlateNumber);
 
+  // Opened from the warehouse flow (no truckPrefill prop): once the last-mile
+  // truck query resolves, auto-fill the first assigned EDR truck — without
+  // overwriting anything the operator typed or the locked exit-step values.
+  useEffect(() => {
+    if (!opened || truckPrefill || isExitStep) return;
+    const first = lastMileTrucks[0];
+    if (!first) return;
+    setTruckPlateNumber((p) => p || first.truckPlateNumber || '');
+    setTrailerPlateNumber((p) => p || first.trailerPlateNumber || '');
+    setDriverName((p) => p || first.driverName || '');
+    setDriverLicense((p) => p || first.driverLicense || '');
+    setDriverPhone((p) => p || first.driverPhone || '');
+    setTruckType((p) => p || first.truckType || '');
+    setContainerNumbers((prev) =>
+      prev.length === 1 && !prev[0] && first.containerNumber ? [first.containerNumber] : prev,
+    );
+  }, [opened, truckPrefill, isExitStep, lastMileTrucks]);
+
   // Registered trucks for THIS booking, from both sources: EDR last-mile
   // (truckPrefill) and the customer portal (customer_truck_assignments).
   const assignedTruckOptions = [
@@ -199,6 +225,16 @@ export function ReleaseOrderModal({ opened, onClose, item, truckPrefill }: Relea
       driverPhone: '',
       truckType: t.truckType,
     })),
+    ...lastMileTrucks
+      .filter((t) => t.truckPlateNumber || t.vehicleId)
+      .map((t) => ({
+        value: (t.truckPlateNumber || t.vehicleId) as string,
+        label: `Last-mile · ${t.truckPlateNumber ?? ''}${t.driverName ? ` — ${t.driverName}` : ''}`,
+        trailerPlate: t.trailerPlateNumber ?? '',
+        driverName: t.driverName ?? '',
+        driverPhone: t.driverPhone ?? '',
+        truckType: t.truckType ?? '',
+      })),
   ];
   // Only trucks actually assigned to THIS booking (last-mile prefill or customer
   // portal) are selectable. No global fleet list — if nothing is assigned, the
diff --git a/apps/edr-freight-web/backoffice/src/components/warehouses/WarehouseInventoryTable.tsx b/apps/edr-freight-web/backoffice/src/components/warehouses/WarehouseInventoryTable.tsx
index 51650b459..de262767f 100644
--- a/apps/edr-freight-web/backoffice/src/components/warehouses/WarehouseInventoryTable.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/warehouses/WarehouseInventoryTable.tsx
@@ -1,6 +1,6 @@
 import { useState, type MouseEvent } from 'react';
 import { ActionIcon, Badge, Button, Checkbox, Group, Table, Text, Tooltip } from '@mantine/core';
-import { ArrowRightLeft, ClipboardList, Coins, Eye, FileText, History, MapPin } from 'lucide-react';
+import { ArrowRightLeft, ClipboardList, Coins, Download, Eye, FileText, History, MapPin } from 'lucide-react';
 
 import { useToast } from '@/hooks/use-toast';
 import { warehouseService } from '@/services/warehouse.service';
@@ -24,6 +24,7 @@ interface WarehouseInventoryTableProps {
   onFeePreview?: (item: WarehouseInventoryItem) => void;
   onReleaseDocument?: (item: WarehouseInventoryItem) => void;
   onHandoverDocument?: (item: WarehouseInventoryItem) => void;
+  onDownloadBundle?: (item: WarehouseInventoryItem) => void;
   onLastMile?: (item: WarehouseInventoryItem) => void;
   selectedIds?: Set<string>;
   onToggleSelect?: (id: string) => void;
@@ -110,6 +111,7 @@ export function WarehouseInventoryTable({
   onFeePreview,
   onReleaseDocument,
   onHandoverDocument,
+  onDownloadBundle,
   onLastMile,
   selectedIds,
   onToggleSelect,
@@ -285,6 +287,13 @@ export function WarehouseInventoryTable({
                         </ActionIcon>
                       </Tooltip>
                     )}
+                    {onDownloadBundle && item.grnNumber && (
+                      <Tooltip label="Download document bundle (GRN + gate clearance + handover)" withArrow>
+                        <ActionIcon variant="subtle" color="grape" onClick={() => onDownloadBundle(item)}>
+                          <Download size={16} />
+                        </ActionIcon>
+                      </Tooltip>
+                    )}
                     {onLastMile && item.booking?.lastMileDeliveryAddress && (
                       <Tooltip label="Last mile delivery" withArrow>
                         <ActionIcon variant="subtle" color="blue" onClick={() => onLastMile(item)}>
diff --git a/apps/edr-freight-web/backoffice/src/components/warehouses/WarehouseOpsKpiStrip.tsx b/apps/edr-freight-web/backoffice/src/components/warehouses/WarehouseOpsKpiStrip.tsx
new file mode 100644
index 000000000..cf8e34343
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/components/warehouses/WarehouseOpsKpiStrip.tsx
@@ -0,0 +1,45 @@
+import { AlertTriangle, ClipboardCheck, PackageCheck, Truck } from "lucide-react";
+
+import { KpiStrip } from "@/components/page";
+import { useWarehouseOpsStats } from "@/hooks/useWarehouses";
+
+/**
+ * At-a-glance warehouse ops KPIs (received today, pending inspection, trucks
+ * on-site, items aging). Drop-in for any warehouse ops page header.
+ */
+export function WarehouseOpsKpiStrip() {
+  const { data, isLoading } = useWarehouseOpsStats();
+
+  return (
+    <KpiStrip
+      loading={isLoading}
+      items={[
+        {
+          label: "Received today",
+          value: data?.receivedToday ?? 0,
+          icon: PackageCheck,
+          color: "edr-green",
+        },
+        {
+          label: "Pending inspection",
+          value: data?.pendingInspection ?? 0,
+          icon: ClipboardCheck,
+          color: "yellow",
+        },
+        {
+          label: "Trucks on-site",
+          value: data?.trucksOnSite ?? 0,
+          icon: Truck,
+          color: "blue",
+        },
+        {
+          label: "Items aging (>7d)",
+          value: data?.itemsAging ?? 0,
+          icon: AlertTriangle,
+          color: (data?.itemsAging ?? 0) > 0 ? "red" : "edr-green",
+          hint: "In warehouse over 7 days",
+        },
+      ]}
+    />
+  );
+}
diff --git a/apps/edr-freight-web/backoffice/src/components/warehouses/index.ts b/apps/edr-freight-web/backoffice/src/components/warehouses/index.ts
index 075237198..7b3504480 100644
--- a/apps/edr-freight-web/backoffice/src/components/warehouses/index.ts
+++ b/apps/edr-freight-web/backoffice/src/components/warehouses/index.ts
@@ -30,3 +30,5 @@ export { WarehouseDashboardCharts } from './WarehouseDashboardCharts';
 export { InspectionReportModal } from './InspectionReportModal';
 export { FeePreviewModal } from './FeePreviewModal';
 export { ZoneOccupancyHeatmap } from './ZoneOccupancyHeatmap';
+export { WarehouseOpsKpiStrip } from './WarehouseOpsKpiStrip';
+export { AccrualDashboard } from './AccrualDashboard';
diff --git a/apps/edr-freight-web/backoffice/src/components/warehouses/pdf.ts b/apps/edr-freight-web/backoffice/src/components/warehouses/pdf.ts
index 7a467b9db..91ca2ec16 100644
--- a/apps/edr-freight-web/backoffice/src/components/warehouses/pdf.ts
+++ b/apps/edr-freight-web/backoffice/src/components/warehouses/pdf.ts
@@ -22,3 +22,16 @@ export function openPdfBlob(blob: Blob, filename: string, targetWindow?: Window
   URL.revokeObjectURL(url);
   return false;
 }
+
+/** Force a browser download of a blob under the given filename (no preview tab). */
+export function saveBlob(blob: Blob, filename: string) {
+  const url = URL.createObjectURL(blob);
+  const a = document.createElement('a');
+  a.href = url;
+  a.download = filename;
+  document.body.appendChild(a);
+  a.click();
+  a.remove();
+  // Delay revoke so the download has time to start (esp. for rapid multi-saves).
+  setTimeout(() => URL.revokeObjectURL(url), 10_000);
+}
diff --git a/apps/edr-freight-web/backoffice/src/constants/QUERY_KEYS.ts b/apps/edr-freight-web/backoffice/src/constants/QUERY_KEYS.ts
index 3d064355a..a8d1e0137 100644
--- a/apps/edr-freight-web/backoffice/src/constants/QUERY_KEYS.ts
+++ b/apps/edr-freight-web/backoffice/src/constants/QUERY_KEYS.ts
@@ -99,6 +99,8 @@ export const QUERY_KEYS = {
       ] as const,
     locomotives: (routeId?: string) =>
       ["train-scheduling", "locomotives", routeId ?? "all"] as const,
+    availableTrains: (routeId?: string) =>
+      ["train-scheduling", "available-trains", routeId ?? "all"] as const,
     stations: () => ["train-scheduling", "stations"] as const,
     schedules: (filters?: unknown) =>
       ["train-scheduling", "schedules", filters ?? {}] as const,
@@ -122,6 +124,12 @@ export const QUERY_KEYS = {
       ["fleet", "list", resource] as const,
   },
 
+  TRAIN_BUILDER: {
+    ROOT: ["train-builder"] as const,
+    list: (filters?: unknown) => ["train-builder", "list", filters ?? {}] as const,
+    composition: (id: string) => ["train-builder", "composition", id] as const,
+  },
+
   VEHICLES: {
     ROOT: ["vehicles"] as const,
     list: (filter?: Record<string, unknown>) =>
diff --git a/apps/edr-freight-web/backoffice/src/constants/URLS.ts b/apps/edr-freight-web/backoffice/src/constants/URLS.ts
index 2eaee8090..618d0ba30 100644
--- a/apps/edr-freight-web/backoffice/src/constants/URLS.ts
+++ b/apps/edr-freight-web/backoffice/src/constants/URLS.ts
@@ -486,6 +486,7 @@ export const URL_CONSTANTS = {
     MOVE: (id: string) => `/warehouse-inventory/${id}/move`,
     RESERVE: "/warehouse-inventory/reserve",
     ARRIVAL_QUEUE: "/warehouse-inventory/arrival-queue",
+    OPS_STATS: "/warehouse-inventory/ops-stats",
     ZONE_OCCUPANCY: (yardId?: string) =>
       yardId
         ? `/warehouse-inventory/zone-occupancy?yardId=${yardId}`
@@ -557,6 +558,9 @@ export const URL_CONSTANTS = {
     FEES_BY_ID: (id: string) => `/warehouse-fee-rules/${id}`,
     FEE_PREVIEW: (inventoryId: string) =>
       `/warehouse-inventory/${inventoryId}/fee-preview`,
+    ACCRUAL_DASHBOARD: "/warehouse-fees/accrual-dashboard",
+    ACCRUAL_ACK: (inventoryId: string) =>
+      `/warehouse-fees/accrual/${inventoryId}/acknowledge`,
   },
 
   WAREHOUSE_INVOICES: {
diff --git a/apps/edr-freight-web/backoffice/src/hooks/useWarehouses.ts b/apps/edr-freight-web/backoffice/src/hooks/useWarehouses.ts
index 59709d2d7..56ef4876b 100644
--- a/apps/edr-freight-web/backoffice/src/hooks/useWarehouses.ts
+++ b/apps/edr-freight-web/backoffice/src/hooks/useWarehouses.ts
@@ -144,6 +144,22 @@ export function useZoneOccupancy(yardId?: string) {
   });
 }
 
+/** At-a-glance warehouse ops counters for the KPI strip. */
+export function useWarehouseOpsStats() {
+  return useQuery({
+    queryKey: ['warehouse-inventory', 'ops-stats'],
+    queryFn: () => warehouseService.opsStats().then((r) => r.data),
+  });
+}
+
+/** Live per-item fee accrual (storage/demurrage) with alerts. */
+export function useAccrualDashboard(billingCurrency?: 'ETB' | 'USD') {
+  return useQuery({
+    queryKey: ['warehouse-fees', 'accrual-dashboard', billingCurrency ?? 'USD'],
+    queryFn: () => warehouseService.accrualDashboard(billingCurrency).then((r) => r.data),
+  });
+}
+
 export function useCreateZone() {
   const qc = useQueryClient();
   return useMutation({
diff --git a/apps/edr-freight-web/backoffice/src/lib/permissions.ts b/apps/edr-freight-web/backoffice/src/lib/permissions.ts
index 92fe85ad7..9bf9aab6e 100644
--- a/apps/edr-freight-web/backoffice/src/lib/permissions.ts
+++ b/apps/edr-freight-web/backoffice/src/lib/permissions.ts
@@ -106,6 +106,9 @@ export const FREIGHT_PERMS = {
     create: "edr_freight_app:wagons:create",
     update: "edr_freight_app:wagons:update",
     delete: "edr_freight_app:wagons:delete",
+    transferRequest: "edr_freight_app:wagons:transfer_request",
+    transferFulfill: "edr_freight_app:wagons:transfer_fulfill",
+    transferHistoryAll: "edr_freight_app:wagons:transfer_history_all",
   },
   trains: {
     view: "edr_freight_app:trains:view",
diff --git a/apps/edr-freight-web/backoffice/src/pages/bookings/NewBookingPage.tsx b/apps/edr-freight-web/backoffice/src/pages/bookings/NewBookingPage.tsx
index 0344e99cb..07a6c72cd 100644
--- a/apps/edr-freight-web/backoffice/src/pages/bookings/NewBookingPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/bookings/NewBookingPage.tsx
@@ -1,5 +1,6 @@
 import {
   ActionIcon,
+  Alert,
   Badge,
   Box,
   Button,
@@ -324,6 +325,21 @@ export default function NewBookingPage() {
   const containerWeight = lines.reduce((s, l) => s + (l.quantity || 0) * (l.vgmPerUnitTons || 0), 0);
   const cargoTotalWeightVgm = freightType === "CONTAINER" ? containerWeight : bulkWeight;
 
+  // 20ft containers ride two per wagon, so a booking must hold an even number
+  // of them — odd counts would leave half a wagon waiting on a co-loader
+  // (cross-booking consolidation is disabled for now).
+  const twentyFtCount = useMemo(() => {
+    const sizeById = new Map<string, string>();
+    for (const group of refData?.containers ?? []) {
+      for (const type of group.types) sizeById.set(type.id, group.size);
+    }
+    return lines.reduce((sum, l) => {
+      const size = l.containerTypeId ? (sizeById.get(l.containerTypeId) ?? "") : "";
+      return String(size).includes("20") ? sum + (l.quantity || 0) : sum;
+    }, 0);
+  }, [refData?.containers, lines]);
+  const hasOdd20ft = freightType === "CONTAINER" && twentyFtCount % 2 === 1;
+
   // ---- validation ----
   const lineValid = (l: ContainerLine) =>
     Boolean(l.containerTypeId) && l.quantity >= 1 && l.vgmPerUnitTons > 0;
@@ -344,7 +360,7 @@ export default function NewBookingPage() {
     (isGovernment ? Boolean(govCompanyId && govProfileId) : Boolean(companyId)) &&
     (freightType === "BULK"
       ? Boolean(cargoTypeId) && bulkWeight > 0
-      : allLinesValid);
+      : allLinesValid && !hasOdd20ft);
 
   const updateLine = (key: string, patch: Partial<ContainerLine>) =>
     setLines((prev) => prev.map((l) => (l.key === key ? { ...l, ...patch } : l)));
@@ -842,6 +858,20 @@ export default function NewBookingPage() {
                 </Group>
               ) : null}
 
+              {hasOdd20ft ? (
+                <Alert color="red" icon={<AlertTriangle size={16} />} radius="md" mt="md">
+                  <Text size="sm" fw={600}>
+                    Odd number of 20ft containers ({twentyFtCount})
+                  </Text>
+                  <Text size="xs" mt={4}>
+                    20ft containers travel two per wagon, so they must be booked in
+                    even numbers. Add one more 20ft container or remove one — e.g.
+                    book {twentyFtCount + 1} or {twentyFtCount - 1} instead of{" "}
+                    {twentyFtCount}.
+                  </Text>
+                </Alert>
+              ) : null}
+
               <Stack gap="sm" mt="lg">
                 <Button
                   size="md"
diff --git a/apps/edr-freight-web/backoffice/src/pages/contracts/ContractClearanceListPage.tsx b/apps/edr-freight-web/backoffice/src/pages/contracts/ContractClearanceListPage.tsx
index 142173298..91d944ffc 100644
--- a/apps/edr-freight-web/backoffice/src/pages/contracts/ContractClearanceListPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/contracts/ContractClearanceListPage.tsx
@@ -1,4 +1,11 @@
-import { useCallback, useEffect, useMemo, useState, type ReactNode } from "react";
+import {
+  Fragment,
+  useCallback,
+  useEffect,
+  useMemo,
+  useState,
+  type ReactNode,
+} from "react";
 import { useNavigate } from "react-router-dom";
 import {
   ActionIcon,
@@ -75,6 +82,8 @@ interface ClearanceRow {
   freightType: string;
   originLabel: string;
   destinationLabel: string;
+  /** Full ordered corridor across the contract's route legs (origin → … → destination). */
+  routeStops: string[];
   contractKind: string;
   serviceTypeName: string;
   customs: boolean;
@@ -93,6 +102,25 @@ function yardLabel(
   return yard.label ?? yard.name ?? yard.code ?? fallback;
 }
 
+/**
+ * Chain the contract's ordered route legs into one corridor of stops —
+ * origin of the first leg, then each leg's destination (Djibouti → Adama →
+ * Dire Dawa). A leg whose origin differs from the previous destination inserts
+ * that stop too, so gapped route lists stay readable.
+ */
+function contractRouteStops(routes: Freight.IContractRoute[]): string[] {
+  const stops: string[] = [];
+  for (const r of routes) {
+    const origin = yardLabel(r.originYard);
+    const destination = yardLabel(r.destinationYard);
+    if (stops.length === 0 || stops[stops.length - 1] !== origin) {
+      stops.push(origin);
+    }
+    stops.push(destination);
+  }
+  return stops;
+}
+
 function toClearanceRow(contract: Freight.IContract): ClearanceRow {
   const routes = [...(contract.routes ?? [])].sort(
     (a, b) => a.sortOrder - b.sortOrder,
@@ -109,6 +137,7 @@ function toClearanceRow(contract: Freight.IContract): ClearanceRow {
     freightType: contract.freightType ?? "—",
     originLabel: yardLabel(first?.originYard),
     destinationLabel: yardLabel(last?.destinationYard),
+    routeStops: contractRouteStops(routes),
     contractKind: contract.contractKind,
     serviceTypeName: contract.serviceType?.serviceName ?? "—",
     customs:
@@ -412,14 +441,23 @@ export default function ContractClearanceListPage() {
           const r = row.original;
           return (
             <Stack gap={4} py={2}>
-              <Group gap={6} wrap="nowrap">
-                <Text size="sm" fw={500} truncate maw={120}>
-                  {r.originLabel}
-                </Text>
-                <ArrowRight size={14} className="shrink-0 text-muted-foreground" />
-                <Text size="sm" fw={500} truncate maw={120}>
-                  {r.destinationLabel}
-                </Text>
+              <Group gap={6} wrap="wrap">
+                {(r.routeStops.length >= 2
+                  ? r.routeStops
+                  : [r.originLabel, r.destinationLabel]
+                ).map((stop, i) => (
+                  <Fragment key={i}>
+                    {i > 0 ? (
+                      <ArrowRight
+                        size={14}
+                        className="shrink-0 text-muted-foreground"
+                      />
+                    ) : null}
+                    <Text size="sm" fw={500}>
+                      {stop}
+                    </Text>
+                  </Fragment>
+                ))}
               </Group>
               <Group gap={8} align="center">
                 <DirectionIcon direction={r.tradeDirection} />
@@ -638,6 +676,11 @@ export default function ContractClearanceListPage() {
                     `/dashboard/contracts/${row.contractId}/bookings/${row.id}/complete`,
                   )
                 }
+                onRebook={(row) =>
+                  navigate(
+                    `/dashboard/contracts/${row.contractId}/create-booking?copyFrom=${row.id}`,
+                  )
+                }
                 onViewContract={(contractId) =>
                   navigate(`/dashboard/contracts/clearance/${contractId}`)
                 }
@@ -731,6 +774,7 @@ function ShipmentBookingsTable({
   canCreateBooking,
   onOpen,
   onCreateBooking,
+  onRebook,
   onViewContract,
 }: {
   rows: ShipmentBookingRow[];
@@ -739,6 +783,7 @@ function ShipmentBookingsTable({
   canCreateBooking: boolean;
   onOpen: (id: string) => void;
   onCreateBooking: (row: ShipmentBookingRow) => void;
+  onRebook: (row: ShipmentBookingRow) => void;
   onViewContract: (contractId: string) => void;
 }) {
   // A bare initiated instance that has cleared but not yet been created by GL.
@@ -748,6 +793,14 @@ function ShipmentBookingsTable({
     !r.bookingCreated &&
     r.status === "CLEARANCE_READY";
 
+  // A customs shipment whose booking lost its slot — GL rebooks it (customer
+  // can't self-rebook a customs booking). Copies the expired booking's cargo.
+  const isRebookable = (r: ShipmentBookingRow) =>
+    canCreateBooking &&
+    Boolean(r.contractId) &&
+    r.customs &&
+    r.status === "EXPIRED";
+
   const columns = useMemo<ColumnDef<ShipmentBookingRow>[]>(
     () => [
       {
@@ -877,6 +930,7 @@ function ShipmentBookingsTable({
         cell: ({ row }) => {
           const r = row.original;
           const bookable = isBookable(r);
+          const rebookable = isRebookable(r);
           return (
             <Group
               justify="flex-end"
@@ -896,6 +950,17 @@ function ShipmentBookingsTable({
                   Create booking
                 </Button>
               ) : null}
+              {rebookable ? (
+                <Button
+                  size="compact-sm"
+                  color="grape"
+                  radius="md"
+                  leftSection={<RefreshCw size={14} />}
+                  onClick={() => onRebook(r)}
+                >
+                  Rebook
+                </Button>
+              ) : null}
               <Menu shadow="md" radius="md" position="bottom-end" withinPortal>
                 <Menu.Target>
                   <ActionIcon
@@ -919,6 +984,14 @@ function ShipmentBookingsTable({
                       Create booking
                     </Menu.Item>
                   ) : null}
+                  {rebookable ? (
+                    <Menu.Item
+                      leftSection={<RefreshCw size={14} />}
+                      onClick={() => onRebook(r)}
+                    >
+                      Rebook (GL)
+                    </Menu.Item>
+                  ) : null}
                   {r.contractId ? (
                     <Menu.Item
                       leftSection={<ExternalLink size={14} />}
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 395e360d5..d912874e7 100644
--- a/apps/edr-freight-web/backoffice/src/pages/fleet/FleetResourcePage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/fleet/FleetResourcePage.tsx
@@ -4,7 +4,7 @@ import { useMutation, useQuery } from "@tanstack/react-query";
 
 import { api } from "@/services/api";
 import Breadcrumbs from "@/components/ui/Breadcrumbs";
-import { Plus, Warehouse } from "lucide-react";
+import { Inbox, Plus, Warehouse } from "lucide-react";
 import { useEffect, useMemo, useState } from "react";
 import { Navigate, useLocation } from "react-router-dom";
 
@@ -15,6 +15,7 @@ import FleetRecordActions from "@/components/fleet/FleetRecordActions";
 import FleetToolbar from "@/components/fleet/FleetToolbar";
 import WagonMovementHistoryModal from "@/components/fleet/WagonMovementHistoryModal";
 import WagonYardWorkspaceModal from "@/components/wagons/WagonYardWorkspaceModal";
+import WagonTransferRequestsModal from "@/components/wagons/WagonTransferRequestsModal";
 import { formatFleetCell, registerFleetOptionLabels } from "@/components/fleet/fleetFormat";
 import { useFleetViewMode } from "@/components/fleet/useFleetViewMode";
 import { ruleEngineTable } from "@/components/ruleEngine/ruleEngineStyles";
@@ -48,6 +49,7 @@ const FleetResourcePage = () => {
   const [historyTarget, setHistoryTarget] = useState<FleetRecord | null>(null);
   const [selectedDriver, setSelectedDriver] = useState<string>("");
   const [wagonWorkspaceOpen, setWagonWorkspaceOpen] = useState(false);
+  const [transferRequestsOpen, setTransferRequestsOpen] = useState(false);
   const { viewMode, setViewMode } = useFleetViewMode(slug);
 
   const serverListFilters = useMemo((): FleetListFilters | undefined => {
@@ -373,15 +375,26 @@ const FleetResourcePage = () => {
           </div>
           <Group gap="sm">
             {slug === "wagons" ? (
-              <Button
-                variant="light"
-                color="edr-green"
-                leftSection={<Warehouse size={16} />}
-                styles={{ label: { fontWeight: 500 } }}
-                onClick={() => setWagonWorkspaceOpen(true)}
-              >
-                Yard Workspace
-              </Button>
+              <>
+                <Button
+                  variant="light"
+                  color="edr-green"
+                  leftSection={<Warehouse size={16} />}
+                  styles={{ label: { fontWeight: 500 } }}
+                  onClick={() => setWagonWorkspaceOpen(true)}
+                >
+                  Yard Workspace
+                </Button>
+                <Button
+                  variant="light"
+                  color="grape"
+                  leftSection={<Inbox size={16} />}
+                  styles={{ label: { fontWeight: 500 } }}
+                  onClick={() => setTransferRequestsOpen(true)}
+                >
+                  Transfer Requests
+                </Button>
+              </>
             ) : null}
             <Button leftSection={<Plus size={16} />} styles={{ label: { fontWeight: 500 } }} onClick={() => {
               setEditing(null);
@@ -605,6 +618,13 @@ const FleetResourcePage = () => {
         />
       ) : null}
 
+      {slug === "wagons" ? (
+        <WagonTransferRequestsModal
+          opened={transferRequestsOpen}
+          onClose={() => setTransferRequestsOpen(false)}
+        />
+      ) : null}
+
       {slug === "wagons" ? (
         <WagonMovementHistoryModal
           opened={Boolean(historyTarget)}
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 062332107..e5de54880 100644
--- a/apps/edr-freight-web/backoffice/src/pages/operations/LastMilePage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/operations/LastMilePage.tsx
@@ -666,8 +666,12 @@ const LastMilePage = () => {
       void qc.invalidateQueries({ queryKey: QUERY_KEYS.LAST_MILE.ROOT });
       void qc.invalidateQueries({ queryKey: ["vehicles"] });
     },
-    onError: () => {
-      toast({ title: "Assign failed", variant: "destructive" });
+    onError: (e: unknown) => {
+      // Surface the backend reason (e.g. "Truck … has no assigned driver …").
+      const raw = (e as { response?: { data?: { message?: string | string[] } } })?.response?.data
+        ?.message;
+      const description = Array.isArray(raw) ? raw.join(", ") : raw;
+      toast({ title: "Assign failed", description, variant: "destructive" });
     },
   });
 
diff --git a/apps/edr-freight-web/backoffice/src/pages/ruleEngine/CargoTypesPage.tsx b/apps/edr-freight-web/backoffice/src/pages/ruleEngine/CargoTypesPage.tsx
index 1002387a2..cf917f5ff 100644
--- a/apps/edr-freight-web/backoffice/src/pages/ruleEngine/CargoTypesPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/ruleEngine/CargoTypesPage.tsx
@@ -54,8 +54,8 @@ interface CargoNode extends RuleEngineRecord {
   requiresDirectorApproval?: boolean;
   /** How this cargo is measured (PER_TON / PER_ITEM); null for groups/unset. */
   unitOfMeasure?: string | null;
-  /** Wagon type FK used to carry this bulk cargo during scheduling; null if unset. */
-  wagonTypeId?: string | null;
+  /** Wagon types that can carry this bulk cargo during scheduling; empty if unset. */
+  wagonTypes?: { id: string; code?: string; name?: string }[];
   isActive?: boolean;
   displayOrder?: number;
 }
@@ -82,16 +82,19 @@ const FORM_FIELDS: FormFieldDef[] = [
     ],
   },
   {
-    // Wagon type that carries this (bulk) commodity — drives train-scheduling
-    // wagon resolution. Optional: leave "None" for grouping categories and
-    // container/legacy cargo; set it on scheduled bulk commodities.
+    // Wagon types that can carry this (bulk) commodity — drive train-scheduling
+    // wagon resolution (the plan uses whichever type the train/yard has).
+    // Optional: leave empty for grouping categories and container/legacy cargo;
+    // set them on scheduled bulk commodities.
     // Options injected at render from useWagonTypeOptions.
-    name: "wagonTypeId",
-    label: "Wagon type",
-    type: "select",
+    name: "wagonTypeIds",
+    label: "Wagon types",
+    type: "multiselect",
     optional: true,
-    placeholder: "Select wagon type (bulk cargo)",
-    options: [{ label: "None", value: RULE_ENGINE_SELECT_NONE }],
+    placeholder: "Select wagon types (bulk cargo)",
+    options: [],
+    getInitialValue: (record) =>
+      ((record.wagonTypes as { id: string }[] | undefined) ?? []).map((wt) => wt.id),
   },
   { name: "requiresDirectorApproval", label: "Requires director approval", type: "boolean" },
   { name: "isActive", label: "Active", type: "boolean" },
@@ -119,19 +122,13 @@ const CargoTypesPage = () => {
 
   const { create, update, remove } = useRuleEngineMutations(CARGO_SLUG);
 
-  // Wagon-type options for the "Wagon type" picker (bulk cargo → wagon FK).
+  // Wagon-type options for the "Wagon types" picker (bulk cargo → allowed list).
   const { data: wagonTypeOptions } = useWagonTypeOptions(canManage);
   const formFields = useMemo<FormFieldDef[]>(
     () =>
       FORM_FIELDS.map((field) =>
-        field.name === "wagonTypeId"
-          ? {
-              ...field,
-              options: [
-                { label: "None", value: RULE_ENGINE_SELECT_NONE },
-                ...(wagonTypeOptions ?? []),
-              ],
-            }
+        field.name === "wagonTypeIds"
+          ? { ...field, options: wagonTypeOptions ?? [] }
           : field,
       ),
     [wagonTypeOptions],
diff --git a/apps/edr-freight-web/backoffice/src/pages/ruleEngine/RuleEngineResourcePage.tsx b/apps/edr-freight-web/backoffice/src/pages/ruleEngine/RuleEngineResourcePage.tsx
index ddd61b91f..81a485a3a 100644
--- a/apps/edr-freight-web/backoffice/src/pages/ruleEngine/RuleEngineResourcePage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/ruleEngine/RuleEngineResourcePage.tsx
@@ -153,7 +153,9 @@ const RuleEngineResourcePage = () => {
     config?.formFields.some((f) => f.name === "rateId"),
   );
   const usesWagonTypeField = Boolean(
-    config?.formFields.some((f) => f.name === "wagonTypeId"),
+    config?.formFields.some(
+      (f) => f.name === "wagonTypeId" || f.name === "wagonTypeIds",
+    ),
   );
 
   const { data: cargoParentOptions, isLoading: cargoParentOptionsLoading } =
@@ -206,6 +208,13 @@ const RuleEngineResourcePage = () => {
           options: wagonTypeOptions ?? [],
         };
       }
+      if (field.name === "wagonTypeIds") {
+        return {
+          ...field,
+          type: "multiselect" as const,
+          options: wagonTypeOptions ?? [],
+        };
+      }
       return field;
     });
   }, [config, cargoParentOptions, cargoLeafOptions, containerTypeOptions, liveRateOptions, wagonTypeOptions]);
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 6992c67e1..bc17fb47a 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
@@ -55,6 +55,12 @@ export interface FormFieldDef {
    * from the fleet config's string-based `dynamicOptions` to avoid a clash.)
    */
   optionsFromValues?: (values: Record<string, unknown>) => { label: string; value: string }[];
+  /**
+   * Derive the field's initial form value from the record being edited when it
+   * doesn't live under `record[name]` — e.g. a multiselect of ids backed by a
+   * relation list (`wagonTypeIds` read from `record.wagonTypes`).
+   */
+  getInitialValue?: (record: Record<string, unknown>) => unknown;
 }
 
 export interface RuleEngineOrderConfig {
@@ -258,11 +264,14 @@ export const RULE_ENGINE_RESOURCES: RuleEngineResourceConfig[] = [
       { name: "sizeFt", label: "Size (ft)", type: "number", required: true },
       // Options injected at render from useWagonTypeOptions (RuleEngineResourcePage).
       {
-        name: "wagonTypeId",
-        label: "Wagon type",
-        type: "select",
+        name: "wagonTypeIds",
+        label: "Wagon types",
+        type: "multiselect",
         required: true,
-        description: "Wagon type used to carry this container during train scheduling.",
+        description:
+          "Wagon types that can carry this container during train scheduling (one container size per wagon at a time).",
+        getInitialValue: (record) =>
+          ((record.wagonTypes as { id: string }[] | undefined) ?? []).map((wt) => wt.id),
       },
       { name: "isOpenTop", label: "Open top", type: "boolean" },
       { name: "isActive", label: "Active", type: "boolean" },
diff --git a/apps/edr-freight-web/backoffice/src/pages/trainBuilder/TrainBuilderDetailPage.tsx b/apps/edr-freight-web/backoffice/src/pages/trainBuilder/TrainBuilderDetailPage.tsx
new file mode 100644
index 000000000..e88fcc893
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/pages/trainBuilder/TrainBuilderDetailPage.tsx
@@ -0,0 +1,378 @@
+import {
+  Alert,
+  Badge,
+  Button,
+  Card,
+  Grid,
+  Group,
+  Menu,
+  Modal,
+  Progress,
+  Stack,
+  Text,
+} from "@mantine/core";
+import { useMutation, useQuery } from "@tanstack/react-query";
+import { isAxiosError } from "axios";
+import {
+  AlertTriangle,
+  CalendarClock,
+  MapPin,
+  MoreHorizontal,
+  Replace,
+  Ruler,
+  Trash2,
+  Train as TrainIcon,
+  TrainFront,
+  Weight,
+} from "lucide-react";
+import { useState } from "react";
+import { useNavigate, useParams } from "react-router-dom";
+
+import AvailableWagonsPanel from "@/components/trainBuilder/AvailableWagonsPanel";
+import ChangeLocomotivesModal from "@/components/trainBuilder/ChangeLocomotivesModal";
+import ChangeYardModal from "@/components/trainBuilder/ChangeYardModal";
+import ConsistWagonList from "@/components/trainBuilder/ConsistWagonList";
+import { trainStatusColor, trainStatusLabel } from "@/components/trainBuilder/trainStatus";
+import { TrainCompositionDiagram } from "@/components/trainScheduling/TrainCompositionDiagram";
+import { KpiStrip, PageContainer, PageHeader } from "@/components/page";
+import { api } from "@/services/api";
+import { useToast } from "@/hooks/use-toast";
+
+const parseError = (error: unknown, fallback: string) => {
+  if (isAxiosError(error)) {
+    const message = error.response?.data?.message;
+    if (Array.isArray(message)) return message.join(", ");
+    if (typeof message === "string") return message;
+  }
+  return fallback;
+};
+
+/** Utilization bar color: green while safe, amber when close, red when over. */
+const utilizationColor = (pct: number | null) => {
+  if (pct == null) return "gray";
+  if (pct > 100) return "red";
+  if (pct > 85) return "yellow";
+  return "edr-green";
+};
+
+/**
+ * Train Builder workspace for one train: the visual consist, the wagon yard
+ * panel, and the locomotive set — everything needed to (re)compose the train.
+ */
+export default function TrainBuilderDetailPage() {
+  const { id = "" } = useParams();
+  const navigate = useNavigate();
+  const { toast } = useToast();
+  const [locoModalOpen, setLocoModalOpen] = useState(false);
+  const [yardModalOpen, setYardModalOpen] = useState(false);
+  const [disbandOpen, setDisbandOpen] = useState(false);
+
+  const compositionQuery = useQuery(
+    api.trainBuilder.composition.queryOptions({ input: { id }, enabled: Boolean(id) }),
+  );
+  const assignWagons = useMutation(api.trainBuilder.assignWagons.mutationOptions());
+  const removeWagon = useMutation(api.trainBuilder.removeWagon.mutationOptions());
+  const reorderWagons = useMutation(api.trainBuilder.reorderWagons.mutationOptions());
+  const disband = useMutation(api.trainBuilder.disband.mutationOptions());
+
+  const composition = compositionQuery.data;
+  const busy =
+    assignWagons.isPending || removeWagon.isPending || reorderWagons.isPending;
+
+  const withToast = async (action: () => Promise<unknown>, failTitle: string) => {
+    try {
+      await action();
+    } catch (err) {
+      toast({
+        title: failTitle,
+        description: parseError(err, "Something went wrong"),
+        variant: "destructive",
+      });
+    }
+  };
+
+  if (compositionQuery.isLoading) {
+    return (
+      <PageContainer>
+        <Text py="xl" ta="center" c="dimmed">
+          Loading train…
+        </Text>
+      </PageContainer>
+    );
+  }
+
+  if (compositionQuery.isError || !composition) {
+    return (
+      <PageContainer>
+        <Alert color="red" icon={<AlertTriangle size={16} />}>
+          Failed to load this train.{" "}
+          <Button variant="subtle" size="compact-sm" onClick={() => compositionQuery.refetch()}>
+            Retry
+          </Button>
+        </Alert>
+      </PageContainer>
+    );
+  }
+
+  const { totals } = composition;
+  const yard = composition.currentYard;
+
+  return (
+    <PageContainer>
+      <PageHeader
+        title={`Train ${composition.code}`}
+        subtitle={
+          composition.trainName
+            ? `${composition.trainName} · built in ${yard?.label ?? "unknown yard"}`
+            : `Built in ${yard?.label ?? "unknown yard"}`
+        }
+        backTo="/dashboard/train-builder"
+        meta={
+          <Badge color={trainStatusColor(composition.status)} variant="light">
+            {trainStatusLabel(composition.status)}
+          </Badge>
+        }
+        action={
+          <Menu position="bottom-end" withinPortal shadow="md" width={220}>
+            <Menu.Target>
+              <Button variant="default" rightSection={<MoreHorizontal size={16} />}>
+                Actions
+              </Button>
+            </Menu.Target>
+            <Menu.Dropdown>
+              <Menu.Item
+                leftSection={<Replace size={15} />}
+                disabled={!composition.editable}
+                onClick={() => setLocoModalOpen(true)}
+              >
+                Change locomotives
+              </Menu.Item>
+              <Menu.Item
+                leftSection={<MapPin size={15} />}
+                disabled={!composition.editable}
+                onClick={() => setYardModalOpen(true)}
+              >
+                Change yard
+              </Menu.Item>
+              <Menu.Item
+                color="red"
+                leftSection={<Trash2 size={15} />}
+                disabled={composition.activeSchedules.length > 0}
+                onClick={() => setDisbandOpen(true)}
+              >
+                Disband train
+              </Menu.Item>
+            </Menu.Dropdown>
+          </Menu>
+        }
+      />
+
+      <KpiStrip
+        items={[
+          { label: "Locomotives", value: composition.locomotives.length, icon: TrainFront },
+          { label: "Wagons", value: totals.wagonCount, icon: TrainIcon },
+          {
+            label: "Tare weight / haul limit",
+            value: `${totals.totalTareTons}T of ${totals.maxPullWeightTons}T`,
+            icon: Weight,
+          },
+          {
+            label: "Length / limit",
+            value: `${totals.totalLengthMeters}m / ${totals.maxTrainLengthMeters}m`,
+            icon: Ruler,
+          },
+        ]}
+      />
+
+      {!composition.editable ? (
+        <Alert color="yellow" icon={<AlertTriangle size={16} />}>
+          This train is out on a dispatched run — its composition is frozen until arrival.
+        </Alert>
+      ) : null}
+
+      <Stack gap="sm">
+        <TrainCompositionDiagram
+          locomotives={composition.locomotives.map((loco) => ({
+            code: loco.code,
+            name: loco.name,
+            maxPullWeightTons: loco.maxPullWeightTons,
+          }))}
+          wagons={composition.wagons.map((wagon, index) => ({
+            sequenceNo: wagon.sequenceNumber ?? index + 1,
+            capacityTons: wagon.wagonType?.capacityTons ?? 0,
+            // No bookings at build time — wagons ride empty until allocation.
+            assignedWeightTons: 0,
+            tareWeightTons: wagon.wagonType?.tareWeightTons ?? 0,
+            wagonTypeCode: wagon.wagonType?.code ?? null,
+            physicalWagonNumber: wagon.wagonNumber,
+            allocations: [],
+          }))}
+          trainNumber={composition.code}
+          totalLengthMeters={totals.totalLengthMeters}
+        />
+        <Card>
+          <Grid gap="lg">
+            <Grid.Col span={{ base: 12, sm: 6 }}>
+              <UtilizationBar label="Length utilization" pct={totals.lengthUtilizationPct} />
+            </Grid.Col>
+            <Grid.Col span={{ base: 12, sm: 6 }}>
+              <Text size="xs" c="dimmed" mt={4}>
+                The real weight check happens at allocation: booked cargo weight plus
+                wagon tare (gross) must stay within the locomotives' haul limit.
+              </Text>
+            </Grid.Col>
+          </Grid>
+        </Card>
+      </Stack>
+
+      <Grid gap="lg" align="stretch">
+        {composition.editable ? (
+          <Grid.Col span={{ base: 12, md: 5 }}>
+            <Card h="100%">
+              <Stack gap="sm">
+                <Text fw={600}>Available wagons — {yard?.label ?? "yard"}</Text>
+                <Text size="xs" c="dimmed">
+                  Only AVAILABLE wagons standing in the train's own yard can be coupled.
+                </Text>
+                <AvailableWagonsPanel
+                  yardId={yard?.id ?? ""}
+                  yardLabel={yard?.label}
+                  assigning={assignWagons.isPending}
+                  onAssign={(wagonIds) =>
+                    void withToast(
+                      () => assignWagons.mutateAsync({ id: composition.id, wagonIds }),
+                      "Could not add wagons",
+                    )
+                  }
+                />
+              </Stack>
+            </Card>
+          </Grid.Col>
+        ) : null}
+        <Grid.Col span={{ base: 12, md: composition.editable ? 7 : 12 }}>
+          <Card h="100%">
+            <Stack gap="sm">
+              <Text fw={600}>Wagon order</Text>
+              <Text size="xs" c="dimmed">
+                Drag to reorder — position 1 couples right behind the locomotives.
+              </Text>
+              <ConsistWagonList
+                wagons={composition.wagons}
+                editable={composition.editable}
+                busy={busy}
+                onReorder={(wagonIds) =>
+                  void withToast(
+                    () => reorderWagons.mutateAsync({ id: composition.id, wagonIds }),
+                    "Could not reorder wagons",
+                  )
+                }
+                onRemove={(wagonId) =>
+                  void withToast(
+                    () => removeWagon.mutateAsync({ id: composition.id, wagonId }),
+                    "Could not detach wagon",
+                  )
+                }
+              />
+            </Stack>
+          </Card>
+        </Grid.Col>
+      </Grid>
+
+      {composition.activeSchedules.length ? (
+        <Card>
+          <Stack gap="sm">
+            <Text fw={600}>Upcoming runs</Text>
+            {composition.activeSchedules.map((schedule) => (
+              <Group key={schedule.id} justify="space-between">
+                <Group gap="sm">
+                  <CalendarClock size={15} color="var(--mantine-color-gray-6)" />
+                  <Text size="sm" ff="monospace" fw={600}>
+                    {schedule.reference ?? schedule.id.slice(0, 8)}
+                  </Text>
+                  <Badge size="sm" variant="light">
+                    {schedule.status}
+                  </Badge>
+                </Group>
+                <Button
+                  variant="subtle"
+                  size="compact-sm"
+                  onClick={() =>
+                    navigate(`/dashboard/operations/train-scheduling-v2/${schedule.id}`)
+                  }
+                >
+                  Open schedule
+                </Button>
+              </Group>
+            ))}
+          </Stack>
+        </Card>
+      ) : null}
+
+      <ChangeLocomotivesModal
+        composition={composition}
+        opened={locoModalOpen}
+        onClose={() => setLocoModalOpen(false)}
+      />
+
+      <ChangeYardModal
+        composition={composition}
+        opened={yardModalOpen}
+        onClose={() => setYardModalOpen(false)}
+      />
+
+      <Modal
+        opened={disbandOpen}
+        onClose={() => setDisbandOpen(false)}
+        title={<Text fw={600}>Disband train {composition.code}?</Text>}
+        radius="lg"
+        centered
+      >
+        <Stack gap="md">
+          <Text size="sm" c="dimmed">
+            All wagons and locomotives are released back to{" "}
+            {yard?.label ?? "their yard"} and the train is deleted. This cannot be undone.
+          </Text>
+          <Group justify="flex-end">
+            <Button variant="default" onClick={() => setDisbandOpen(false)}>
+              Keep train
+            </Button>
+            <Button
+              color="red"
+              loading={disband.isPending}
+              onClick={() =>
+                void withToast(async () => {
+                  await disband.mutateAsync(composition.id);
+                  toast({ title: `Train ${composition.code} disbanded` });
+                  navigate("/dashboard/train-builder");
+                }, "Could not disband train")
+              }
+            >
+              Disband
+            </Button>
+          </Group>
+        </Stack>
+      </Modal>
+    </PageContainer>
+  );
+}
+
+function UtilizationBar({ label, pct }: { label: string; pct: number | null }) {
+  return (
+    <Stack gap={4}>
+      <Group justify="space-between">
+        <Text size="xs" c="dimmed">
+          {label}
+        </Text>
+        <Text size="xs" fw={600} c={pct != null && pct > 100 ? "red" : undefined}>
+          {pct != null ? `${pct}%` : "—"}
+        </Text>
+      </Group>
+      <Progress
+        value={Math.min(pct ?? 0, 100)}
+        color={utilizationColor(pct)}
+        size="sm"
+        radius="xl"
+      />
+    </Stack>
+  );
+}
diff --git a/apps/edr-freight-web/backoffice/src/pages/trainBuilder/TrainBuilderListPage.tsx b/apps/edr-freight-web/backoffice/src/pages/trainBuilder/TrainBuilderListPage.tsx
new file mode 100644
index 000000000..53bd1a818
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/pages/trainBuilder/TrainBuilderListPage.tsx
@@ -0,0 +1,336 @@
+import type { ColumnDef } from "@edr/ui-common";
+import { DataTable, DataTableFooter, usePagination } from "@edr/ui-common";
+import {
+  Badge,
+  Box,
+  Button,
+  Card,
+  Group,
+  Select,
+  Stack,
+  Text,
+  TextInput,
+} from "@mantine/core";
+import { useDebouncedValue } from "@mantine/hooks";
+import { keepPreviousData, useQuery } from "@tanstack/react-query";
+import {
+  Hammer,
+  Ruler,
+  Search,
+  Train as TrainIcon,
+  TrainFront,
+  Weight,
+} from "lucide-react";
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { useNavigate } from "react-router-dom";
+
+import { KpiStrip, PageContainer, PageHeader } from "@/components/page";
+import { ruleEngineTable } from "@/components/ruleEngine/ruleEngineStyles";
+import BuildTrainModal from "@/components/trainBuilder/BuildTrainModal";
+import { trainStatusColor, trainStatusLabel } from "@/components/trainBuilder/trainStatus";
+import { api } from "@/services/api";
+import type {
+  BuiltTrainListFilters,
+  BuiltTrainStatus,
+  BuiltTrainSummary,
+} from "@/services/trainBuilder.service";
+
+/**
+ * Train Builder board: every built train (code, yard, locomotive set, consist
+ * totals, lifecycle status) plus the entry point for building a new one.
+ */
+export default function TrainBuilderListPage() {
+  const navigate = useNavigate();
+  const { pagination, setPagination } = usePagination({ pageSize: 10 });
+  const [search, setSearch] = useState("");
+  const [debouncedSearch] = useDebouncedValue(search, 300);
+  const [statusFilter, setStatusFilter] = useState<"ALL" | BuiltTrainStatus>("ALL");
+  const [yardFilter, setYardFilter] = useState("ALL");
+  const [buildOpen, setBuildOpen] = useState(false);
+
+  const resetPage = useCallback(() => {
+    setPagination((prev) =>
+      prev.pageIndex === 0 ? prev : { ...prev, pageIndex: 0 },
+    );
+  }, [setPagination]);
+
+  useEffect(() => {
+    resetPage();
+  }, [debouncedSearch, resetPage]);
+
+  const filters = useMemo<BuiltTrainListFilters>(
+    () => ({
+      page: pagination.pageIndex + 1,
+      pageSize: pagination.pageSize,
+      ...(debouncedSearch.trim() ? { search: debouncedSearch.trim() } : {}),
+      ...(statusFilter !== "ALL" ? { status: statusFilter } : {}),
+      ...(yardFilter !== "ALL" ? { currentYardId: yardFilter } : {}),
+      sortBy: "createdAt",
+      sortOrder: "DESC",
+    }),
+    [
+      pagination.pageIndex,
+      pagination.pageSize,
+      debouncedSearch,
+      statusFilter,
+      yardFilter,
+    ],
+  );
+
+  const trainsQuery = useQuery(
+    api.trainBuilder.list.queryOptions({
+      input: { filters },
+      placeholderData: keepPreviousData,
+      staleTime: 30_000,
+    }),
+  );
+  const yardsQuery = useQuery(api.routes.yards.queryOptions({ staleTime: 5 * 60_000 }));
+
+  const trains = trainsQuery.data?.items ?? [];
+  const totalTrains = trainsQuery.data?.meta.total ?? 0;
+  const pageCount = Math.max(1, trainsQuery.data?.meta.totalPages ?? 1);
+
+  const stats = useMemo(() => {
+    const base = { available: 0, scheduled: 0, inService: 0, wagons: 0 };
+    for (const train of trains) {
+      if (train.status === "AVAILABLE") base.available += 1;
+      if (train.status === "SCHEDULED") base.scheduled += 1;
+      if (train.status === "IN_SERVICE") base.inService += 1;
+      base.wagons += train.wagonCount;
+    }
+    return base;
+  }, [trains]);
+
+  const yardOptions = useMemo(
+    () =>
+      (yardsQuery.data ?? []).map((y) => ({
+        value: y.id,
+        label: y.label ?? y.code,
+      })),
+    [yardsQuery.data],
+  );
+
+  const columns = useMemo((): ColumnDef<BuiltTrainSummary>[] => {
+    const headerClassName = ruleEngineTable.headerCell;
+    const cellClassName = ruleEngineTable.bodyCell;
+    return [
+      {
+        id: "code",
+        header: "Train",
+        meta: { headerClassName, cellClassName },
+        cell: ({ row }) => (
+          <Group gap="sm" wrap="nowrap">
+            <Box
+              style={{
+                display: "flex",
+                alignItems: "center",
+                justifyContent: "center",
+                width: 34,
+                height: 34,
+                borderRadius: 9,
+                background: "var(--mantine-color-edr-green-0)",
+                color: "var(--mantine-color-edr-green-7)",
+                flexShrink: 0,
+              }}
+            >
+              <TrainIcon size={16} />
+            </Box>
+            <Stack gap={0}>
+              <Text size="sm" fw={600} ff="monospace" lh={1.2}>
+                {row.original.code}
+              </Text>
+              <Text size="xs" c="dimmed" lh={1.2}>
+                {row.original.trainName ?? "—"}
+              </Text>
+            </Stack>
+          </Group>
+        ),
+      },
+      {
+        id: "yard",
+        header: "Yard",
+        meta: { headerClassName, cellClassName },
+        cell: ({ row }) => (
+          <Text size="sm">{row.original.currentYard?.label ?? "—"}</Text>
+        ),
+      },
+      {
+        id: "locomotives",
+        header: "Locomotives",
+        meta: { headerClassName, cellClassName },
+        cell: ({ row }) => {
+          const locos = row.original.locomotives;
+          if (!locos.length) {
+            return (
+              <Text size="sm" c="dimmed">
+                —
+              </Text>
+            );
+          }
+          return (
+            <Group gap={6} wrap="nowrap">
+              <TrainFront size={14} color="var(--mantine-color-gray-5)" />
+              <Text size="sm" fw={500}>
+                {locos.map((l) => l.code).join(" + ")}
+              </Text>
+            </Group>
+          );
+        },
+      },
+      {
+        id: "consist",
+        header: "Consist",
+        meta: { headerClassName, cellClassName },
+        cell: ({ row }) => (
+          <Text size="sm">
+            {row.original.wagonCount} wagons · {row.original.totalTareTons}T tare ·{" "}
+            {row.original.totalLengthMeters}m
+          </Text>
+        ),
+      },
+      {
+        id: "capacity",
+        header: "Haul limit",
+        meta: { headerClassName, cellClassName },
+        cell: ({ row }) => (
+          <Text size="sm" fw={500}>
+            {row.original.maxPullWeightTons}T
+          </Text>
+        ),
+      },
+      {
+        id: "status",
+        header: "Status",
+        meta: { headerClassName, cellClassName },
+        cell: ({ row }) => (
+          <Badge color={trainStatusColor(row.original.status)} variant="light">
+            {trainStatusLabel(row.original.status)}
+          </Badge>
+        ),
+      },
+    ];
+  }, []);
+
+  const tableStatus = trainsQuery.isLoading
+    ? "loading"
+    : trainsQuery.isError
+      ? "error"
+      : "success";
+
+  return (
+    <PageContainer>
+      <PageHeader
+        title="Train Builder"
+        subtitle="Assemble coded trains from locomotives and wagons in a yard, ready to schedule as a unit."
+        action={
+          <Button leftSection={<Hammer size={18} />} onClick={() => setBuildOpen(true)}>
+            Build train
+          </Button>
+        }
+      />
+
+      <KpiStrip
+        items={[
+          { label: "Trains", value: totalTrains, icon: TrainIcon },
+          { label: "Available", value: stats.available, icon: Hammer },
+          { label: "Scheduled / in service", value: stats.scheduled + stats.inService, icon: Weight },
+          { label: "Wagons coupled", value: stats.wagons, icon: Ruler },
+        ]}
+      />
+
+      <Card p={0}>
+        <Stack gap={0}>
+          <Box px="md" pt="md" pb="sm" w="100%">
+            <Group gap="sm" wrap="wrap">
+              <TextInput
+                size="sm"
+                radius="lg"
+                placeholder="Search by code or name…"
+                leftSection={<Search size={14} />}
+                value={search}
+                onChange={(e) => setSearch(e.currentTarget.value)}
+                style={{ flex: 1, minWidth: 220 }}
+              />
+              <Select
+                size="sm"
+                radius="lg"
+                value={statusFilter}
+                onChange={(v) => {
+                  if (!v) return;
+                  setStatusFilter(v as "ALL" | BuiltTrainStatus);
+                  resetPage();
+                }}
+                data={[
+                  { value: "ALL", label: "All statuses" },
+                  { value: "AVAILABLE", label: "Available" },
+                  { value: "SCHEDULED", label: "Scheduled" },
+                  { value: "IN_SERVICE", label: "In service" },
+                  { value: "UNDER_MAINTENANCE", label: "Under maintenance" },
+                  { value: "OUT_OF_SERVICE", label: "Out of service" },
+                ]}
+                w={180}
+                styles={{ input: { borderColor: "var(--mantine-color-gray-3)" } }}
+              />
+              <Select
+                size="sm"
+                radius="lg"
+                placeholder="Yard"
+                searchable
+                value={yardFilter}
+                onChange={(v) => {
+                  setYardFilter(v ?? "ALL");
+                  resetPage();
+                }}
+                data={[{ value: "ALL", label: "All yards" }, ...yardOptions]}
+                w={170}
+                styles={{ input: { borderColor: "var(--mantine-color-gray-3)" } }}
+              />
+            </Group>
+          </Box>
+
+          <DataTable
+            columns={columns}
+            data={trains}
+            status={tableStatus}
+            onRowClick={(train) => navigate(`/dashboard/train-builder/${train.id}`)}
+            error={
+              trainsQuery.isError
+                ? {
+                    message: "Failed to load trains.",
+                    onRetry: () => void trainsQuery.refetch(),
+                  }
+                : undefined
+            }
+            emptyMessage="No trains built yet — build the first one"
+            pagination={{
+              pageIndex: pagination.pageIndex,
+              pageSize: pagination.pageSize,
+              pageCount,
+              totalCount: totalTrains,
+            }}
+            tableOptions={{
+              manualPagination: true,
+              pageCount,
+              state: { pagination },
+              onPaginationChange: setPagination,
+            }}
+            containerClassName="border-0 shadow-none bg-transparent"
+            footer={({ table, pagination: footerPagination }) => (
+              <DataTableFooter
+                table={table}
+                pagination={footerPagination}
+                options={{ labels: { items: "trains" } }}
+              />
+            )}
+          />
+        </Stack>
+      </Card>
+
+      <BuildTrainModal
+        opened={buildOpen}
+        onClose={() => setBuildOpen(false)}
+        onBuilt={(composition) => navigate(`/dashboard/train-builder/${composition.id}`)}
+      />
+    </PageContainer>
+  );
+}
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 ae75debb1..5cfe550a2 100644
--- a/apps/edr-freight-web/backoffice/src/pages/trainScheduling/BatchScheduleDetailPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/trainScheduling/BatchScheduleDetailPage.tsx
@@ -43,6 +43,7 @@ import { CountdownTimer, DataTable, type ColumnDef } from "@edr/ui-common";
 import { KpiStrip, PageContainer } from "@/components/page";
 import { ruleEngineTable } from "@/components/ruleEngine/ruleEngineStyles";
 import Breadcrumbs from "@/components/ui/Breadcrumbs";
+import AdjustConsistModal from "@/components/trainScheduling/AdjustConsistModal";
 import { TrainCompositionDiagram } from "@/components/trainScheduling/TrainCompositionDiagram";
 import {
   TrainConsistView,
@@ -684,6 +685,7 @@ export default function BatchScheduleDetailPage() {
   );
 
   const [activeTab, setActiveTab] = useState<string | null>("overview");
+  const [adjustConsistOpen, setAdjustConsistOpen] = useState(false);
   const [selectedBookingId, setSelectedBookingId] = useState<string | null>(
     null,
   );
@@ -838,6 +840,12 @@ export default function BatchScheduleDetailPage() {
                       }).format(new Date(data.scheduleDate)) + " EAT"
                       : "No date"}
                   </HeroChip>
+                  {data.train ? (
+                    <HeroChip icon={<TrainFront size={12} />}>
+                      Train {data.train.code}
+                      {data.train.trainName ? ` — ${data.train.trainName}` : ""}
+                    </HeroChip>
+                  ) : null}
                   {data.locomotive ? (
                     <HeroChip icon={<TrainFront size={12} />}>
                       Loco {data.locomotive.code} ·{" "}
@@ -864,6 +872,17 @@ export default function BatchScheduleDetailPage() {
                 >
                   Refresh
                 </Button>
+                {data.train && ["DRAFT", "SCHEDULED"].includes(data.status) ? (
+                  <Button
+                    variant="light"
+                    color="edr-green"
+                    radius="md"
+                    leftSection={<TrainFront size={16} />}
+                    onClick={() => setAdjustConsistOpen(true)}
+                  >
+                    Adjust consist
+                  </Button>
+                ) : null}
                 {data.windowPhase === "DOC_REVIEW" ? (
                   <Button
                     color="yellow"
@@ -1175,6 +1194,12 @@ export default function BatchScheduleDetailPage() {
           )}
         </Tabs.Panel>
       </Tabs>
+
+      <AdjustConsistModal
+        scheduleId={data.scheduleId}
+        opened={adjustConsistOpen}
+        onClose={() => setAdjustConsistOpen(false)}
+      />
     </PageContainer>
   );
 }
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 f4cd3be02..2fa5b2ee0 100644
--- a/apps/edr-freight-web/backoffice/src/pages/trainScheduling/TrainScheduleV2DetailPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/trainScheduling/TrainScheduleV2DetailPage.tsx
@@ -52,6 +52,7 @@ import { IntercityRideAlongPanel } from "@/components/trainScheduling/IntercityR
 import { YardWorkPanel } from "@/components/trainScheduling/YardWorkPanel";
 // import { ImportLoadingConfirmationPanel } from "@/components/trainScheduling/ImportLoadingConfirmationPanel";
 import { RescheduleTrainDialog } from "@/components/trainScheduling/RescheduleTrainDialog";
+import AdjustConsistModal from "@/components/trainScheduling/AdjustConsistModal";
 import BookingWindowSettingsModal from "@/components/trainScheduling/BookingWindowSettingsModal";
 // import { ScheduleBatchPanel } from "@/components/trainScheduling/ScheduleBatchPanel";
 import { ScheduleBookingsStep } from "@/components/trainScheduling/ScheduleBookingsStep";
@@ -101,6 +102,7 @@ export default function TrainScheduleV2DetailPage() {
   const [previewResult, setPreviewResult] = useState<TrainSchedulePreviewResponse | null>(null);
   const [containerPlacements, setContainerPlacements] = useState<ContainerPlacement[]>([]);
   const [maintenanceOpen, setMaintenanceOpen] = useState(false);
+  const [adjustConsistOpen, setAdjustConsistOpen] = useState(false);
   const [windowSettingsOpen, setWindowSettingsOpen] = useState(false);
   const [gatepassSecuredAt, setGatepassSecuredAt] = useState("");
   const [gatepassReference, setGatepassReference] = useState("");
@@ -757,13 +759,14 @@ export default function TrainScheduleV2DetailPage() {
       <Stack gap="md">
         <TrainCompositionDiagram
           locomotive={schedule.trainSet?.locomotive}
+          locomotives={locomotives}
           wagons={
             schedule.trainSet?.wagons?.length
               ? schedule.trainSet.wagons
               : displayWagonPlan
           }
           freightType={freightType}
-          trainNumber={schedule.trainNumber}
+          trainNumber={schedule.train ? schedule.train.code : schedule.trainNumber}
           totalLengthMeters={schedule.trainSet?.totalLengthMeters}
         />
         <Paper
@@ -948,6 +951,18 @@ export default function TrainScheduleV2DetailPage() {
                   Reschedule train
                 </Button>
               ) : null}
+              {schedule.train && ["DRAFT", "SCHEDULED"].includes(schedule.status) ? (
+                <Button
+                  variant="light"
+                  color="edr-green"
+                  radius="lg"
+                  size="sm"
+                  leftSection={<Train size={16} />}
+                  onClick={() => setAdjustConsistOpen(true)}
+                >
+                  Adjust consist
+                </Button>
+              ) : null}
               {gatepassApplies ? (
                 gatepassSecured ? (
                   <Button
@@ -1003,6 +1018,16 @@ export default function TrainScheduleV2DetailPage() {
 
       <KpiStrip
         items={[
+          ...(schedule.train
+            ? [
+                {
+                  label: "Train",
+                  value: schedule.train.code,
+                  hint: schedule.train.trainName ?? "Built train (Train Builder)",
+                  icon: Train,
+                },
+              ]
+            : []),
           {
             label: locomotives.length > 1 ? "Locomotives" : "Locomotive",
             value: locomotives.length
@@ -1162,6 +1187,12 @@ export default function TrainScheduleV2DetailPage() {
         />
       ) : null}
 
+      <AdjustConsistModal
+        scheduleId={schedule.id}
+        opened={adjustConsistOpen}
+        onClose={() => setAdjustConsistOpen(false)}
+      />
+
       <BookingWindowSettingsModal
         scheduleId={scheduleId ?? null}
         opened={windowSettingsOpen}
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 e42fc1a0b..322957441 100644
--- a/apps/edr-freight-web/backoffice/src/pages/trainScheduling/TrainScheduleV2ListPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/trainScheduling/TrainScheduleV2ListPage.tsx
@@ -7,7 +7,6 @@ import {
   Group,
   Menu,
   Modal,
-  MultiSelect,
   Select,
   SimpleGrid,
   Stack,
@@ -41,10 +40,7 @@ import { ruleEngineTable } from "@/components/ruleEngine/ruleEngineStyles";
 import { FreightTypeBadge } from "@/components/trainScheduling/ScheduleStatusBadge";
 import BookingWindowSettingsModal from "@/components/trainScheduling/BookingWindowSettingsModal";
 import EditScheduleDateModal from "@/components/trainScheduling/EditScheduleDateModal";
-import {
-  locomotiveOption,
-  showScheduleWarnings,
-} from "@/components/trainScheduling/locomotiveOptions";
+import { showScheduleWarnings } from "@/components/trainScheduling/locomotiveOptions";
 import {
   RouteCorridor,
   StatusPill,
@@ -119,7 +115,7 @@ export default function TrainScheduleV2ListPage() {
     useState<TrainScheduleListItem | null>(null);
   const [routeId, setRouteId] = useState("");
   const [scheduleDate, setScheduleDate] = useState("");
-  const [locomotiveIds, setLocomotiveIds] = useState<string[]>([]);
+  const [trainId, setTrainId] = useState("");
   // Recomputed each time the create modal opens so a long-lived tab can't keep
   // offering a stale "now" as the earliest selectable departure.
   const minScheduleDate = useMemo(
@@ -186,9 +182,10 @@ export default function TrainScheduleV2ListPage() {
   const routesQuery = useQuery(
     api.routes.list.queryOptions({ input: { status: "AVAILABLE" } }),
   );
-  const locomotivesQuery = useQuery(
-    api.trainScheduling.availableLocomotives.queryOptions({
-      input: { routeId: routeId || undefined },
+  const trainsQuery = useQuery(
+    api.trainScheduling.availableTrains.queryOptions({
+      input: { routeId },
+      enabled: Boolean(routeId),
     }),
   );
   const create = useMutation(api.trainScheduling.createSchedule.mutationOptions());
@@ -203,17 +200,17 @@ export default function TrainScheduleV2ListPage() {
 
   const selectedRoute = activeRoutes.find((r) => r.id === routeId);
 
-  const locomotiveYardHint = useMemo(() => {
+  const trainYardHint = useMemo(() => {
     if (!selectedRoute) return "Select a route first";
     const originLabel =
       selectedRoute.originYard?.label ??
       selectedRoute.originYard?.code ??
       "the route origin yard";
-    return `All in-service locomotives are shown — those not yet at ${originLabel} or already on future schedules are flagged`;
+    return `All schedulable built trains are shown — those not yet at ${originLabel} or already on future schedules are flagged`;
   }, [selectedRoute]);
 
   useEffect(() => {
-    setLocomotiveIds([]);
+    setTrainId("");
   }, [routeId]);
 
   // Filtering, sorting, and paging all happen server-side — `schedules` IS the
@@ -326,10 +323,29 @@ export default function TrainScheduleV2ListPage() {
         cell: ({ row }) => <FreightTypeBadge freightType={row.original.freightType} />,
       },
       {
-        id: "loco",
-        header: "Locomotives",
+        id: "train",
+        header: "Train",
         meta: { headerClassName, cellClassName },
         cell: ({ row }) => {
+          // Schedules created from the Train Builder carry the train code;
+          // legacy rows fall back to their locomotive set.
+          if (row.original.train) {
+            return (
+              <Group gap={6} wrap="nowrap">
+                <Train size={14} color="var(--mantine-color-gray-5)" />
+                <Stack gap={0}>
+                  <Text size="sm" fw={600} ff="monospace" lh={1.2}>
+                    {row.original.train.code}
+                  </Text>
+                  {row.original.train.trainName ? (
+                    <Text size="xs" c="dimmed" lh={1.2}>
+                      {row.original.train.trainName}
+                    </Text>
+                  ) : null}
+                </Stack>
+              </Group>
+            );
+          }
           const locos =
             row.original.locomotives && row.original.locomotives.length > 0
               ? row.original.locomotives
@@ -456,9 +472,9 @@ export default function TrainScheduleV2ListPage() {
   }, [navigate, cancel.isPending, cancel, toast]);
 
   const handleCreate = async () => {
-    if (!routeId || !scheduleDate || locomotiveIds.length < 2) {
+    if (!routeId || !scheduleDate || !trainId) {
       toast({
-        title: "Select route, date, and at least two locomotives",
+        title: "Select route, date, and the train to run",
         variant: "destructive",
       });
       return;
@@ -475,7 +491,7 @@ export default function TrainScheduleV2ListPage() {
         payload: {
           routeId,
           scheduleDate: new Date(scheduleDate).toISOString(),
-          locomotiveIds,
+          trainId,
         },
       });
       toast({ title: "Train schedule created" });
@@ -728,7 +744,7 @@ export default function TrainScheduleV2ListPage() {
           />
           {routeId ? (
             <Text size="xs" c="dimmed">
-              {locomotiveYardHint}
+              {trainYardHint}
             </Text>
           ) : null}
           <TextInput
@@ -738,24 +754,26 @@ export default function TrainScheduleV2ListPage() {
             value={scheduleDate}
             onChange={(e) => setScheduleDate(e.currentTarget.value)}
           />
-          <MultiSelect
-            label="Locomotives"
-            description="A train must be pulled by at least two locomotives (front and back)"
-            placeholder={
-              routeId ? "Select at least two locomotives" : "Select a route first"
-            }
-            data={(locomotivesQuery.data ?? []).map((l) => locomotiveOption(l))}
-            value={locomotiveIds}
-            onChange={setLocomotiveIds}
+          <Select
+            label="Train"
+            description="A built train (Train Builder) runs this departure with its locomotives and wagons"
+            placeholder={routeId ? "Select a train" : "Select a route first"}
+            data={(trainsQuery.data ?? []).map((train) => ({
+              value: train.id,
+              label: `${train.code}${train.trainName ? ` — ${train.trainName}` : ""} · ${
+                train.locomotives.length
+              } locos · ${train.wagonCount} wagons${train.atOriginYard ? "" : " · not at origin yard"}${
+                train.futureScheduleCount ? ` · ${train.futureScheduleCount} future run(s)` : ""
+              }`,
+            }))}
+            value={trainId || null}
+            onChange={(v) => setTrainId(v ?? "")}
             searchable
             disabled={!routeId}
-            error={
-              locomotiveIds.length > 0 && locomotiveIds.length < 2
-                ? "Select at least two locomotives"
-                : undefined
-            }
             nothingFoundMessage={
-              routeId ? "No available locomotives for this corridor" : "Select a route first"
+              routeId
+                ? "No built trains yet — assemble one in the Train Builder first"
+                : "Select a route first"
             }
           />
           <Group justify="flex-end">
diff --git a/apps/edr-freight-web/backoffice/src/pages/warehouses/ArrivalQueuePage.tsx b/apps/edr-freight-web/backoffice/src/pages/warehouses/ArrivalQueuePage.tsx
index 821589271..61afa426c 100644
--- a/apps/edr-freight-web/backoffice/src/pages/warehouses/ArrivalQueuePage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/warehouses/ArrivalQueuePage.tsx
@@ -15,6 +15,7 @@ import { ChevronDown, ChevronRight, PackageOpen, Truck } from 'lucide-react';
 import { PageContainer, PageHeader } from '@/components/page';
 import {
   VisualEmptyState,
+  WarehouseOpsKpiStrip,
   formatDate,
   formatNumber,
 } from '@/components/warehouses';
@@ -291,6 +292,8 @@ export default function ArrivalQueuePage() {
         breadcrumbs={[{ label: 'Arrival queue' }]}
       />
 
+      <WarehouseOpsKpiStrip />
+
       <Card withBorder radius="md" padding="lg">
           <Group justify="space-between" mb="md">
             <Stack gap={2}>
diff --git a/apps/edr-freight-web/backoffice/src/pages/warehouses/ExportDjiboutiUnloadingQueuePage.tsx b/apps/edr-freight-web/backoffice/src/pages/warehouses/ExportDjiboutiUnloadingQueuePage.tsx
index 6e694ed1e..735026fa7 100644
--- a/apps/edr-freight-web/backoffice/src/pages/warehouses/ExportDjiboutiUnloadingQueuePage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/warehouses/ExportDjiboutiUnloadingQueuePage.tsx
@@ -29,6 +29,7 @@ import {
   ActivityTimeline,
   InventoryMovementHistoryTable,
   VisualEmptyState,
+  WarehouseOpsKpiStrip,
   formatDate,
   formatNumber,
 } from '@/components/warehouses';
@@ -292,6 +293,8 @@ export default function ExportDjiboutiUnloadingQueuePage() {
         breadcrumbs={[{ label: 'Djibouti Arrival / Unloading Queue' }]}
       />
 
+      <WarehouseOpsKpiStrip />
+
       <Card withBorder radius="md" padding="lg">
           <Group justify="space-between" mb="md">
             <Text fw={600}>{trains.length} arrived export train(s)</Text>
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 e9bb3a162..a03c7038e 100644
--- a/apps/edr-freight-web/backoffice/src/pages/warehouses/LoadingQueuePage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/warehouses/LoadingQueuePage.tsx
@@ -8,6 +8,7 @@ import { PageContainer, PageHeader } from '@/components/page';
 import {
   InventoryWorkbench,
   VisualEmptyState,
+  WarehouseOpsKpiStrip,
   formatNumber,
 } from '@/components/warehouses';
 import { LoadToTrainPanel } from '@/components/warehouses/LoadToTrainPanel';
@@ -74,6 +75,8 @@ export default function LoadingQueuePage() {
         }
       />
 
+      <WarehouseOpsKpiStrip />
+
       <Card>
         <Tabs defaultValue="ready">
             <Tabs.List>
diff --git a/apps/edr-freight-web/backoffice/src/pages/warehouses/WarehouseInvoicesPage.tsx b/apps/edr-freight-web/backoffice/src/pages/warehouses/WarehouseInvoicesPage.tsx
index 6f4c16594..1f632c1e7 100644
--- a/apps/edr-freight-web/backoffice/src/pages/warehouses/WarehouseInvoicesPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/warehouses/WarehouseInvoicesPage.tsx
@@ -20,6 +20,7 @@ import { useNavigate } from 'react-router-dom';
 import { DataTable, type ColumnDef } from '@edr/ui-common';
 
 import { PageContainer, PageHeader } from '@/components/page';
+import { AccrualDashboard } from '@/components/warehouses';
 import { useMutation, useQuery } from '@tanstack/react-query';
 
 import { api } from '@/services/api';
@@ -122,6 +123,13 @@ export default function WarehouseInvoicesPage() {
         subtitle="Demurrage & storage invoices generated from warehouse fee rules."
       />
 
+      <Stack gap="xs">
+        <Text fw={700} size="sm" tt="uppercase" c="dimmed">
+          Accruing now
+        </Text>
+        <AccrualDashboard />
+      </Stack>
+
       <Card>
         <Group justify="space-between" mb="md" wrap="wrap">
             <TextInput
diff --git a/apps/edr-freight-web/backoffice/src/services/api.ts b/apps/edr-freight-web/backoffice/src/services/api.ts
index dbb6fb819..6a35fd49c 100644
--- a/apps/edr-freight-web/backoffice/src/services/api.ts
+++ b/apps/edr-freight-web/backoffice/src/services/api.ts
@@ -156,6 +156,7 @@ import {
 import {
   locomotivesService,
   type Locomotive,
+  type LocomotiveListFilters,
   type SaveLocomotivePayload,
 } from "./locomotives.service";
 import { overviewService } from "./overview.service";
@@ -181,13 +182,27 @@ import {
   type SaveSignaturePayload,
 } from "./signatures.service";
 import { trainService, type Train } from "./trains.service";
+import {
+  trainBuilderService,
+  type AdjustConsistPayload,
+  type AvailableTrain,
+  type BuildTrainPayload,
+  type BuiltTrainListFilters,
+  type BuiltTrainListResponse,
+  type ScheduleConsist,
+  type TrainComposition,
+} from "./trainBuilder.service";
 import { trainSchedulingService } from "./trainScheduling.service";
 import { wagonTypesService, type WagonType } from "./wagon-types.service";
 import {
   wagonService,
+  wagonTransferRequestService,
   type Wagon,
   type WagonListFilters,
   type WagonMovementRecord,
+  type WagonTransferRequest,
+  type CreateTransferRequestPayload,
+  type TransferHistory,
 } from "./wagon.service";
 import { warehouseService } from "./warehouse.service";
 
@@ -213,6 +228,19 @@ const TRAIN_SCHEDULING_INVALIDATIONS: ReadonlyArray<readonly unknown[]> = [
   QUERY_KEYS.BOOKINGS.ROOT,
 ];
 
+/**
+ * Train Builder mutations change wagon/locomotive availability and the
+ * schedule-creation train picker alongside the builder's own lists.
+ */
+const TRAIN_BUILDER_INVALIDATIONS: ReadonlyArray<readonly unknown[]> = [
+  QUERY_KEYS.TRAIN_BUILDER.ROOT,
+  QUERY_KEYS.TRAIN_SCHEDULING.ROOT,
+  ["wagons"],
+  ["locomotives"],
+  ["trains"],
+  QUERY_KEYS.FLEET.ROOT,
+];
+
 export const api = {
   trainScheduling: {
     // ── Queries ────────────────────────────────────────────────────────────
@@ -286,6 +314,38 @@ export const api = {
       ({ routeId }) => QUERY_KEYS.TRAIN_SCHEDULING.locomotives(routeId),
     ),
 
+    availableTrains: endpoint<{ routeId: string }, AvailableTrain[]>(
+      "train-scheduling",
+      "available-trains",
+      ({ routeId }) =>
+        trainBuilderService.availableTrains(routeId).then((r) => r.data),
+      ({ routeId }) => QUERY_KEYS.TRAIN_SCHEDULING.availableTrains(routeId),
+    ),
+
+    scheduleConsist: endpoint<{ scheduleId: string }, ScheduleConsist>(
+      "train-scheduling",
+      "schedule-consist",
+      ({ scheduleId }) =>
+        trainBuilderService.scheduleConsist(scheduleId).then((r) => r.data),
+      ({ scheduleId }) => [
+        ...QUERY_KEYS.TRAIN_SCHEDULING.ROOT,
+        "consist",
+        scheduleId,
+      ],
+    ),
+
+    adjustConsist: endpoint<
+      { scheduleId: string; payload: AdjustConsistPayload },
+      ScheduleConsist
+    >(
+      "train-scheduling",
+      "adjust-consist",
+      ({ scheduleId, payload }) =>
+        trainBuilderService.adjustConsist(scheduleId, payload).then((r) => r.data),
+      undefined,
+      () => TRAIN_BUILDER_INVALIDATIONS,
+    ),
+
     bookableSchedules: endpoint<
       { originYardId?: string | null; destinationYardId?: string | null },
       BookableSchedule[]
@@ -1621,6 +1681,70 @@ export const api = {
     ),
   },
 
+  wagonTransferRequests: {
+    list: endpoint<
+      { status?: WagonTransferRequest["status"] },
+      WagonTransferRequest[]
+    >(
+      "wagonTransferRequests",
+      "list",
+      ({ status }) =>
+        wagonTransferRequestService.list(status).then((r) => r.data),
+      ({ status }) => ["wagonTransferRequests", "list", status ?? "ALL"],
+    ),
+
+    getById: endpoint<{ id: string }, WagonTransferRequest>(
+      "wagonTransferRequests",
+      "getById",
+      ({ id }) => wagonTransferRequestService.getById(id).then((r) => r.data),
+      ({ id }) => ["wagonTransferRequests", "detail", id],
+    ),
+
+    create: endpoint<CreateTransferRequestPayload, WagonTransferRequest>(
+      "wagonTransferRequests",
+      "create",
+      (payload) =>
+        wagonTransferRequestService.create(payload).then((r) => r.data),
+      undefined,
+      () => [["wagonTransferRequests"]],
+    ),
+
+    fulfill: endpoint<
+      { id: string; wagonIds: string[] },
+      WagonTransferRequest
+    >(
+      "wagonTransferRequests",
+      "fulfill",
+      ({ id, wagonIds }) =>
+        wagonTransferRequestService.fulfill(id, wagonIds).then((r) => r.data),
+      undefined,
+      () => [["wagonTransferRequests"], ["wagons"]],
+    ),
+
+    cancel: endpoint<{ id: string }, WagonTransferRequest>(
+      "wagonTransferRequests",
+      "cancel",
+      ({ id }) => wagonTransferRequestService.cancel(id).then((r) => r.data),
+      undefined,
+      () => [["wagonTransferRequests"]],
+    ),
+
+    history: endpoint<void, TransferHistory>(
+      "wagonTransferRequests",
+      "history",
+      () => wagonTransferRequestService.myHistory().then((r) => r.data),
+      () => ["wagonTransferRequests", "history", "mine"],
+    ),
+
+    historyAll: endpoint<{ userId?: string }, TransferHistory>(
+      "wagonTransferRequests",
+      "historyAll",
+      ({ userId }) =>
+        wagonTransferRequestService.allHistory(userId).then((r) => r.data),
+      ({ userId }) => ["wagonTransferRequests", "history", "all", userId ?? ""],
+    ),
+  },
+
   trains: {
     list: endpoint<void, Train[]>(
       "trains",
@@ -1661,6 +1785,89 @@ export const api = {
     ),
   },
 
+  // Train Builder — persistent coded consists (2+ locomotives + ordered wagons)
+  // that train scheduling can reference as a unit. Every mutation also touches
+  // wagon/locomotive availability, so those roots are invalidated together.
+  trainBuilder: {
+    list: endpoint<{ filters?: BuiltTrainListFilters }, BuiltTrainListResponse>(
+      "train-builder",
+      "list",
+      ({ filters }) => trainBuilderService.list(filters).then((r) => r.data),
+      ({ filters }) => QUERY_KEYS.TRAIN_BUILDER.list(filters),
+    ),
+
+    composition: endpoint<{ id: string }, TrainComposition>(
+      "train-builder",
+      "composition",
+      ({ id }) => trainBuilderService.getComposition(id).then((r) => r.data),
+      ({ id }) => QUERY_KEYS.TRAIN_BUILDER.composition(id),
+    ),
+
+    build: endpoint<BuildTrainPayload, TrainComposition>(
+      "train-builder",
+      "build",
+      (payload) => trainBuilderService.build(payload).then((r) => r.data),
+      undefined,
+      () => TRAIN_BUILDER_INVALIDATIONS,
+    ),
+
+    setLocomotives: endpoint<
+      { id: string; locomotiveIds: string[] },
+      TrainComposition
+    >(
+      "train-builder",
+      "setLocomotives",
+      ({ id, locomotiveIds }) =>
+        trainBuilderService.setLocomotives(id, locomotiveIds).then((r) => r.data),
+      undefined,
+      () => TRAIN_BUILDER_INVALIDATIONS,
+    ),
+
+    setYard: endpoint<{ id: string; currentYardId: string }, TrainComposition>(
+      "train-builder",
+      "setYard",
+      ({ id, currentYardId }) =>
+        trainBuilderService.setYard(id, currentYardId).then((r) => r.data),
+      undefined,
+      () => TRAIN_BUILDER_INVALIDATIONS,
+    ),
+
+    assignWagons: endpoint<{ id: string; wagonIds: string[] }, TrainComposition>(
+      "train-builder",
+      "assignWagons",
+      ({ id, wagonIds }) =>
+        trainBuilderService.assignWagons(id, wagonIds).then((r) => r.data),
+      undefined,
+      () => TRAIN_BUILDER_INVALIDATIONS,
+    ),
+
+    removeWagon: endpoint<{ id: string; wagonId: string }, TrainComposition>(
+      "train-builder",
+      "removeWagon",
+      ({ id, wagonId }) =>
+        trainBuilderService.removeWagon(id, wagonId).then((r) => r.data),
+      undefined,
+      () => TRAIN_BUILDER_INVALIDATIONS,
+    ),
+
+    reorderWagons: endpoint<{ id: string; wagonIds: string[] }, TrainComposition>(
+      "train-builder",
+      "reorderWagons",
+      ({ id, wagonIds }) =>
+        trainBuilderService.reorderWagons(id, wagonIds).then((r) => r.data),
+      undefined,
+      () => TRAIN_BUILDER_INVALIDATIONS,
+    ),
+
+    disband: endpoint<string, void>(
+      "train-builder",
+      "disband",
+      (id) => trainBuilderService.disband(id).then(() => undefined),
+      undefined,
+      () => TRAIN_BUILDER_INVALIDATIONS,
+    ),
+  },
+
   locomotives: {
     list: endpoint<void, Locomotive[]>(
       "locomotives",
@@ -1669,6 +1876,13 @@ export const api = {
       () => ["locomotives"],
     ),
 
+    listFiltered: endpoint<{ filters?: LocomotiveListFilters }, Locomotive[]>(
+      "locomotives",
+      "listFiltered",
+      ({ filters }) => locomotivesService.getAll(filters ?? {}).then((r) => r.data),
+      ({ filters }) => ["locomotives", "list", filters ?? {}],
+    ),
+
     create: endpoint<Partial<SaveLocomotivePayload>, Locomotive>(
       "locomotives",
       "create",
diff --git a/apps/edr-freight-web/backoffice/src/services/trainBuilder.service.ts b/apps/edr-freight-web/backoffice/src/services/trainBuilder.service.ts
new file mode 100644
index 000000000..d88cd3ed6
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/services/trainBuilder.service.ts
@@ -0,0 +1,245 @@
+import { api as apiClient } from "../auth/http";
+
+// ---------------------------------------------------------------------------
+// Types — mirror the freight API's train-builder responses
+// ---------------------------------------------------------------------------
+
+export type BuiltTrainStatus =
+  | "AVAILABLE"
+  | "SCHEDULED"
+  | "IN_SERVICE"
+  | "UNDER_MAINTENANCE"
+  | "OUT_OF_SERVICE";
+
+export interface YardRefLite {
+  id: string;
+  code: string;
+  label: string;
+}
+
+export interface BuiltTrainSummary {
+  id: string;
+  code: string;
+  trainName: string | null;
+  status: BuiltTrainStatus;
+  createdAt: string;
+  currentYard: YardRefLite | null;
+  locomotives: Array<{ id: string; code: string; name: string | null }>;
+  wagonCount: number;
+  totalTareTons: number;
+  totalLengthMeters: number;
+  maxPullWeightTons: number;
+}
+
+export interface TrainCompositionLocomotive {
+  id: string;
+  code: string;
+  name: string | null;
+  locomotiveType: "DIESEL" | "ELECTRIC";
+  status: string;
+  sequenceNo: number;
+  role: "LEAD" | "ASSIST";
+  currentYardId: string | null;
+  currentYard: YardRefLite | null;
+  maxPullWeightTons: number;
+  maxTrainLengthMeters: number;
+}
+
+export interface TrainCompositionWagon {
+  id: string;
+  wagonNumber: string;
+  sequenceNumber: number | null;
+  status: string;
+  wagonType: {
+    id: string;
+    code: string;
+    name: string;
+    capacityTons: number;
+    tareWeightTons: number;
+    lengthMeters: number;
+  } | null;
+}
+
+export interface TrainCompositionTotals {
+  wagonCount: number;
+  totalTareTons: number;
+  /** Informational only — building never checks against full capacity. */
+  totalCapacityTons: number;
+  totalLengthMeters: number;
+  maxPullWeightTons: number;
+  maxTrainLengthMeters: number;
+  /** Cargo the locomotives can still haul once pulling the empty consist. */
+  payloadCapacityTons: number;
+  /** Share of the haul limit consumed by the empty wagons alone. */
+  tareUtilizationPct: number | null;
+  lengthUtilizationPct: number | null;
+}
+
+export interface TrainComposition {
+  id: string;
+  code: string;
+  trainName: string | null;
+  status: BuiltTrainStatus;
+  notes: string | null;
+  createdAt: string;
+  currentYard: YardRefLite | null;
+  locomotives: TrainCompositionLocomotive[];
+  wagons: TrainCompositionWagon[];
+  totals: TrainCompositionTotals;
+  activeSchedules: Array<{ id: string; status: string; reference: string | null }>;
+  editable: boolean;
+}
+
+export interface BuiltTrainListFilters {
+  page?: number;
+  pageSize?: number;
+  search?: string;
+  status?: BuiltTrainStatus;
+  currentYardId?: string;
+  sortBy?: "code" | "trainName" | "status" | "createdAt";
+  sortOrder?: "ASC" | "DESC";
+}
+
+export interface BuiltTrainListResponse {
+  items: BuiltTrainSummary[];
+  meta: {
+    total: number;
+    page: number;
+    pageSize: number;
+    totalPages: number;
+  };
+}
+
+export interface BuildTrainPayload {
+  code: string;
+  currentYardId: string;
+  locomotiveIds: string[];
+  wagonIds?: string[];
+  trainName?: string;
+  notes?: string;
+}
+
+/** Built train annotated for the schedule-creation picker. */
+export interface AvailableTrain {
+  id: string;
+  code: string;
+  trainName: string | null;
+  status: BuiltTrainStatus;
+  currentYardId: string | null;
+  currentYard: YardRefLite | null;
+  locomotives: Array<{ id: string; code: string; name: string | null }>;
+  wagonCount: number;
+  totalTareTons: number;
+  totalLengthMeters: number;
+  maxPullWeightTons: number;
+  atOriginYard: boolean;
+  futureScheduleCount: number;
+}
+
+// ---------------------------------------------------------------------------
+// Service
+// ---------------------------------------------------------------------------
+
+const BASE = "/train-builder";
+
+const toQuery = (filters: BuiltTrainListFilters = {}) => {
+  const params = new URLSearchParams();
+  Object.entries(filters).forEach(([key, value]) => {
+    if (value !== undefined && value !== null && value !== "") {
+      params.set(key, String(value));
+    }
+  });
+  const qs = params.toString();
+  return qs ? `?${qs}` : "";
+};
+
+// ---------------------------------------------------------------------------
+// Schedule consist adjustment (train-bound schedules)
+// ---------------------------------------------------------------------------
+
+export interface ConsistWagonRef {
+  id: string;
+  wagonNumber: string;
+  sequenceNumber: number | null;
+  wagonType: {
+    id: string;
+    code: string;
+    tareWeightTons: number;
+    capacityTons: number;
+    lengthMeters: number;
+  } | null;
+}
+
+export interface ScheduleConsist {
+  schedule: { id: string; reference: string | null; status: string };
+  train: {
+    id: string;
+    code: string;
+    trainName: string | null;
+    currentYardId: string | null;
+  };
+  limits: {
+    maxPullWeightTons: number;
+    overageToleranceTons: number;
+    pullCapTons: number;
+    maxTrainLengthMeters: number;
+    overageToleranceMeters: number;
+    lengthCapMeters: number;
+  };
+  totals: {
+    wagonCount: number;
+    cargoTons: number;
+    consistTareTons: number;
+    grossTons: number;
+    consistLengthMeters: number;
+  };
+  wagons: Array<ConsistWagonRef & { loaded: boolean; removable: boolean }>;
+  addableWagons: ConsistWagonRef[];
+  adjustments: Array<{
+    id: string;
+    action: "ADD" | "REMOVE";
+    wagonId: string;
+    wagonNumber: string;
+    adjustedByUserId: string | null;
+    occurredAt: string;
+  }>;
+  editable: boolean;
+}
+
+export interface AdjustConsistPayload {
+  addWagonIds?: string[];
+  removeWagonIds?: string[];
+}
+
+export const trainBuilderService = {
+  list: (filters: BuiltTrainListFilters = {}) =>
+    apiClient.get<BuiltTrainListResponse>(`${BASE}${toQuery(filters)}`),
+  getComposition: (id: string) => apiClient.get<TrainComposition>(`${BASE}/${id}`),
+  build: (payload: BuildTrainPayload) => apiClient.post<TrainComposition>(BASE, payload),
+  setLocomotives: (id: string, locomotiveIds: string[]) =>
+    apiClient.put<TrainComposition>(`${BASE}/${id}/locomotives`, { locomotiveIds }),
+  /** Relocate the train — coupled locomotives and wagons move with it. */
+  setYard: (id: string, currentYardId: string) =>
+    apiClient.patch<TrainComposition>(`${BASE}/${id}/yard`, { currentYardId }),
+  assignWagons: (id: string, wagonIds: string[]) =>
+    apiClient.post<TrainComposition>(`${BASE}/${id}/wagons`, { wagonIds }),
+  removeWagon: (id: string, wagonId: string) =>
+    apiClient.delete<TrainComposition>(`${BASE}/${id}/wagons/${wagonId}`),
+  reorderWagons: (id: string, wagonIds: string[]) =>
+    apiClient.post<TrainComposition>(`${BASE}/${id}/reorder-wagons`, { wagonIds }),
+  disband: (id: string) => apiClient.delete<void>(`${BASE}/${id}`),
+  /** Built trains schedulable on a route (train-scheduling picker). */
+  availableTrains: (routeId: string) =>
+    apiClient.get<AvailableTrain[]>(`/train-scheduling/available-trains`, {
+      params: { routeId },
+    }),
+  /** Consist snapshot for a train-bound schedule (adjust-consist UI). */
+  scheduleConsist: (scheduleId: string) =>
+    apiClient.get<ScheduleConsist>(`/train-scheduling/schedules/${scheduleId}/consist`),
+  /** Permanently trim/add wagons on the schedule's built train. */
+  adjustConsist: (scheduleId: string, payload: AdjustConsistPayload) =>
+    apiClient.post<ScheduleConsist>(
+      `/train-scheduling/schedules/${scheduleId}/adjust-consist`,
+      payload,
+    ),
+};
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 e096a3126..e818467f5 100644
--- a/apps/edr-freight-web/backoffice/src/services/wagon.service.ts
+++ b/apps/edr-freight-web/backoffice/src/services/wagon.service.ts
@@ -55,9 +55,12 @@ export interface WagonMovementRecord {
   bookingId: string | null;
   kind: Freight.WagonMovementKind;
   movedByUserId: string | null;
+  /** The transfer request this move fulfilled, when one drove it. */
+  transferRequestId: string | null;
   occurredAt: string;
   note: string | null;
   createdAt: string;
+  wagon?: { id: string; wagonNumber?: string } | null;
 }
 
 export const wagonService = {
@@ -90,3 +93,67 @@ export const wagonService = {
   bulkSetStatus: (wagonIds: string[], status: Freight.WagonStatus) =>
     apiClient.post<{ updated: number }>('/wagons/bulk-status', { wagonIds, status }),
 };
+
+/**
+ * A two-person wagon-transfer request: a requester asks for N wagons of a type
+ * to move between yards (count only); OCC hand-picks the wagons and fulfils it.
+ */
+export interface WagonTransferRequest {
+  id: string;
+  fromYardId: string;
+  toYardId: string;
+  wagonTypeId: string;
+  quantity: number;
+  status: Freight.WagonTransferRequestStatus;
+  requestedByUserId: string | null;
+  fulfilledByUserId: string | null;
+  fulfilledAt: string | null;
+  note: string | null;
+  fromYard?: { id: string; label?: string; code?: string } | null;
+  toYard?: { id: string; label?: string; code?: string } | null;
+  wagonType?: { id: string; code?: string; name?: string } | null;
+  createdAt: string;
+}
+
+export interface CreateTransferRequestPayload {
+  fromYardId: string;
+  toYardId: string;
+  wagonTypeId: string;
+  quantity: number;
+  note?: string;
+}
+
+/** Per-user activity: requests filed/fulfilled + the wagons physically moved. */
+export interface TransferHistory {
+  requests: WagonTransferRequest[];
+  movements: WagonMovementRecord[];
+}
+
+export const wagonTransferRequestService = {
+  list: (status?: Freight.WagonTransferRequestStatus) =>
+    apiClient.get<WagonTransferRequest[]>(
+      `/wagon-transfer-requests${status ? `?status=${status}` : ''}`,
+    ),
+  /** The caller's own history (both roles: requests they filed and fulfilled). */
+  myHistory: () =>
+    apiClient.get<TransferHistory>('/wagon-transfer-requests/history'),
+  /** Admin: any/all staff's history (optional userId filter). */
+  allHistory: (userId?: string) =>
+    apiClient.get<TransferHistory>(
+      `/wagon-transfer-requests/history/all${userId ? `?userId=${userId}` : ''}`,
+    ),
+  getById: (id: string) =>
+    apiClient.get<WagonTransferRequest>(`/wagon-transfer-requests/${id}`),
+  create: (data: CreateTransferRequestPayload) =>
+    apiClient.post<WagonTransferRequest>('/wagon-transfer-requests', data),
+  /** OCC: execute the transfer with the hand-picked wagons. */
+  fulfill: (id: string, wagonIds: string[]) =>
+    apiClient.post<WagonTransferRequest>(
+      `/wagon-transfer-requests/${id}/fulfill`,
+      { wagonIds },
+    ),
+  cancel: (id: string) =>
+    apiClient.post<WagonTransferRequest>(
+      `/wagon-transfer-requests/${id}/cancel`,
+    ),
+};
diff --git a/apps/edr-freight-web/backoffice/src/services/warehouse.service.ts b/apps/edr-freight-web/backoffice/src/services/warehouse.service.ts
index ea0baa32e..53ba263a5 100644
--- a/apps/edr-freight-web/backoffice/src/services/warehouse.service.ts
+++ b/apps/edr-freight-web/backoffice/src/services/warehouse.service.ts
@@ -5,6 +5,8 @@ import { api as apiClient } from '../auth/http';
 import { URL_CONSTANTS } from '@/constants/URLS';
 import type {
   ZoneOccupancy,
+  WarehouseOpsStats,
+  AccrualDashboardRow,
   AllocationCriteria,
   AllocationPreviewResult,
   AllocationRule,
@@ -69,6 +71,8 @@ export type ContainerItemStage = 'PENDING' | 'RECEIVED' | 'GRN' | 'ASSIGNED' | '
 export interface ContainerItem {
   containerNumber: string;
   goods: string | null;
+  /** Container size, e.g. "20ft" / "40ft"; null for bulk. */
+  containerSize: string | null;
   stage: ContainerItemStage;
   grnNumber: string | null;
   truckAssignmentId: string | null;
@@ -124,6 +128,18 @@ const cleanParams = (params: object) =>
     Object.entries(params).filter(([, value]) => value !== undefined && value !== '' && value !== null),
   );
 
+/** An assigned EDR last-mile truck, shaped for the arrival/exit weighing prefill. */
+export interface LastMileArrivalTruck {
+  vehicleId: string;
+  truckPlateNumber: string | null;
+  trailerPlateNumber: string | null;
+  driverName: string | null;
+  driverLicense: string | null;
+  driverPhone: string | null;
+  truckType: string | null;
+  containerNumber: string | null;
+}
+
 export const warehouseService = {
   /** Customer self-haul trucks assigned to a booking (portal multi-truck). */
   getCustomerTrucks: async (bookingId: string): Promise<Freight.ICustomerTruck[]> => {
@@ -131,6 +147,12 @@ export const warehouseService = {
     return data?.data ?? data ?? [];
   },
 
+  /** Assigned EDR last-mile trucks for a booking (arrival/exit weighing prefill). */
+  getLastMileTrucks: async (bookingId: string): Promise<LastMileArrivalTruck[]> => {
+    const { data } = await apiClient.get(`/last-mile/booking/${bookingId}/arrival-trucks`);
+    return data?.data ?? data ?? [];
+  },
+
   /** Per-container/bulk items of a booking with lifecycle stage + refs. */
   getContainerItems: async (bookingId: string): Promise<ContainerItem[]> => {
     const { data } = await apiClient.get(
@@ -370,6 +392,8 @@ export const warehouseService = {
     apiClient.get<ZoneOccupancy[]>(
       URL_CONSTANTS.WAREHOUSE_INVENTORY.ZONE_OCCUPANCY(yardId),
     ),
+  opsStats: () =>
+    apiClient.get<WarehouseOpsStats>(URL_CONSTANTS.WAREHOUSE_INVENTORY.OPS_STATS),
   autoUnloadArrived: () =>
     apiClient.post<AutoUnloadResult>(URL_CONSTANTS.WAREHOUSE_INVENTORY.AUTO_UNLOAD_ARRIVED),
   autoLoadReady: () =>
@@ -422,6 +446,14 @@ export const warehouseService = {
     apiClient.get<FeePreview[]>(URL_CONSTANTS.WAREHOUSE_RULES.FEE_PREVIEW(inventoryId), {
       params: cleanParams({ billingCurrency }),
     }),
+  accrualDashboard: (billingCurrency?: 'ETB' | 'USD') =>
+    apiClient.get<AccrualDashboardRow[]>(URL_CONSTANTS.WAREHOUSE_RULES.ACCRUAL_DASHBOARD, {
+      params: cleanParams({ billingCurrency }),
+    }),
+  acknowledgeAccrual: (inventoryId: string, body: { snoozeDays?: number; note?: string } = {}) =>
+    apiClient.post(URL_CONSTANTS.WAREHOUSE_RULES.ACCRUAL_ACK(inventoryId), body),
+  unacknowledgeAccrual: (inventoryId: string) =>
+    apiClient.delete(URL_CONSTANTS.WAREHOUSE_RULES.ACCRUAL_ACK(inventoryId)),
 
   // ── Batch 6: Warehouse fee invoices ────────────────────────────────────────
   listInvoices: (filter?: WarehouseInvoiceFilter) =>
diff --git a/apps/edr-freight-web/backoffice/src/types/trainScheduling.ts b/apps/edr-freight-web/backoffice/src/types/trainScheduling.ts
index 73a08d569..ee301b970 100644
--- a/apps/edr-freight-web/backoffice/src/types/trainScheduling.ts
+++ b/apps/edr-freight-web/backoffice/src/types/trainScheduling.ts
@@ -162,6 +162,12 @@ export interface TrainScheduleListItem {
   origin: string | null;
   destination: string | null;
   freightType?: FreightType | null;
+  /** Built train (Train Builder) behind this departure, when scheduled by train. */
+  train?: {
+    id: string;
+    code: string;
+    trainName?: string | null;
+  } | null;
   locomotive:
     | {
         id: string;
@@ -303,6 +309,12 @@ export interface BatchBoardSchedule {
   docReviewEndsAt: string | null;
   paymentPhaseEndsAt: string | null;
   bookingCycleNo: number;
+  /** Built train (Train Builder) behind this departure, when scheduled by train. */
+  train: {
+    id: string;
+    code: string;
+    trainName: string | null;
+  } | null;
   locomotive: {
     code: string;
     name: string | null;
@@ -411,6 +423,8 @@ export interface BatchBoardScheduleDetail {
   docReviewEndsAt: string | null;
   paymentPhaseEndsAt: string | null;
   bookingCycleNo: number;
+  /** Built train (Train Builder) behind this departure, when scheduled by train. */
+  train: BatchBoardSchedule["train"];
   locomotive: BatchBoardSchedule["locomotive"];
   capacity: BatchBoardSchedule["capacity"];
   counts: BatchBoardSchedule["counts"];
@@ -505,6 +519,12 @@ export interface TrainScheduleDetail {
   deferredBookings?: DeferredBookingRow[];
   freightType?: FreightType | null;
   trainNumber?: string | null;
+  /** Built train (Train Builder) behind this departure, when scheduled by train. */
+  train?: {
+    id: string;
+    code: string;
+    trainName?: string | null;
+  } | null;
   direction?: string | null;
   /** True when this schedule needs loading confirmed before dispatch (import-Djibouti). */
   requiresLoadingConfirmation?: boolean;
@@ -771,8 +791,10 @@ export interface ReschedulePlan {
 export interface CreateTrainSchedulePayload {
   routeId: string;
   scheduleDate: string;
-  /** Locomotives pulling the train (minimum 2 — front and back). */
-  locomotiveIds: string[];
+  /** Built train (Train Builder) to run this departure — its locomotives are used. */
+  trainId?: string;
+  /** Hand-picked locomotives (minimum 2 — front and back). Ignored when trainId is set. */
+  locomotiveIds?: string[];
   maxTrainWeightTons?: number;
   maxTrainLengthMeters?: number;
   maxWagonsPerTrain?: number;
diff --git a/apps/edr-freight-web/backoffice/src/types/warehouse.ts b/apps/edr-freight-web/backoffice/src/types/warehouse.ts
index 4023bf986..7a88b136e 100644
--- a/apps/edr-freight-web/backoffice/src/types/warehouse.ts
+++ b/apps/edr-freight-web/backoffice/src/types/warehouse.ts
@@ -1107,3 +1107,40 @@ export interface ZoneOccupancy {
   /** 0–100+, container-count based (weight is a rough fallback). Null if no capacity set. */
   occupancyPct: number | null;
 }
+
+/** At-a-glance warehouse ops counters for the KPI strip. */
+export interface WarehouseOpsStats {
+  receivedToday: number;
+  pendingInspection: number;
+  trucksOnSite: number;
+  itemsAging: number;
+}
+
+export type AccrualAlert = 'OK' | 'WARNING' | 'CHARGING';
+
+/** One item's live fee accrual for the accrual dashboard. */
+export interface AccrualDashboardRow {
+  inventoryId: string;
+  status: string;
+  bookingId: string | null;
+  companyId: string | null;
+  bookingReference: string | null;
+  customerName: string | null;
+  warehouseCode: string | null;
+  zoneCode: string | null;
+  receivedAt: string | null;
+  currency: string;
+  accruedAmount: number;
+  freeDaysLeft: number | null;
+  charging: boolean;
+  alert: AccrualAlert;
+  acknowledged: boolean;
+  snoozeUntil: string | null;
+  breakdown: Array<{
+    type: string;
+    amount: number;
+    freeDays: number;
+    elapsedDays: number;
+    chargeableDays: number;
+  }>;
+}
diff --git a/apps/edr-freight-web/backoffice/src/user-management/AppMenuTabs.tsx b/apps/edr-freight-web/backoffice/src/user-management/AppMenuTabs.tsx
index d4cd8eb86..fb523fc06 100644
--- a/apps/edr-freight-web/backoffice/src/user-management/AppMenuTabs.tsx
+++ b/apps/edr-freight-web/backoffice/src/user-management/AppMenuTabs.tsx
@@ -237,9 +237,11 @@ export const AppMenuTabs = () => {
     // Sticky (not fixed) so it stays in flow: content below never needs a
     // magic offset matching this bar's responsive height. top-16 keeps it
     // pinned just below the fixed 64px <Top> header while scrolling.
+    // -mt-8 cancels the excess of <Top>'s in-flow h-24 wrapper over its 64px
+    // fixed header, so the bar sits flush under the header with no jump.
     // shrink-0 is load-bearing: as a flex item with overflow-hidden this bar
     // would otherwise be flex-squashed to zero height when the page overflows.
-    <div className="sticky top-16 z-30 shrink-0 bg-white dark:bg-gray-900 border-b dark:border-gray-800 overflow-hidden flex flex-col">
+    <div className="sticky top-16 -mt-8 z-30 shrink-0 bg-white dark:bg-gray-900 border-b dark:border-gray-800 overflow-hidden flex flex-col">
       {/* Mobile View - Two separate rows */}
       <div className="md:hidden flex flex-col pt-5 pb-3 px-4 space-y-3 mt-2">
         {/* Primary items row */}
diff --git a/apps/edr-freight-web/backoffice/src/user-management/Applayout.tsx b/apps/edr-freight-web/backoffice/src/user-management/Applayout.tsx
index 7a7e56b76..3b33519b6 100644
--- a/apps/edr-freight-web/backoffice/src/user-management/Applayout.tsx
+++ b/apps/edr-freight-web/backoffice/src/user-management/Applayout.tsx
@@ -27,9 +27,10 @@ export const AppLayout = () => {
   }
 
   return (
-    // pt-16 clears the fixed 64px <Top>; AppMenuTabs is sticky and in flow,
-    // so content starts right below it at any tabs height (mobile/desktop).
-    <div className="w-full h-dvh overflow-y-auto flex flex-col pt-16 bg-background text-foreground">
+    // <Top> renders its own in-flow h-24 wrapper around the fixed 64px header,
+    // so flow already clears the header — no extra top padding here.
+    // AppMenuTabs is sticky and in flow, so content starts right below it.
+    <div className="w-full h-dvh overflow-y-auto flex flex-col bg-background text-foreground">
       <Top onToggleSidebar={toggleSidebar} showRecordManagementShortcut={!isSuperAdmin} />
       <AppMenuTabs />
       <div className="px-2 pb-2 pt-4 sm:px-4 sm:pb-4 sm:pt-6 flex-1">
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 ad2d5ace9..f9a3dd246 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
@@ -1,5 +1,5 @@
 import { ActionIcon, Box, Group, Skeleton, Stack, Text } from "@mantine/core";
-import { memo, useMemo, useState } from "react";
+import { Fragment, memo, useMemo, useState } from "react";
 import {
   ArrowRight,
   CalendarClock,
@@ -8,6 +8,7 @@ import {
 } from "lucide-react";
 import { CountdownTimer } from "@edr/ui-common";
 import type { MyBookingWindow } from "@/services/bookings.service";
+import { windowRouteStops } from "@/pages/contracts/booking-window";
 import { Card } from "./Card";
 
 const INK = "#10202F";
@@ -284,14 +285,21 @@ export const UpcomingWindowsSection = memo(function UpcomingWindowsSection({
               }}
             >
               <Box style={{ minWidth: 0 }}>
-                <Group gap={6} wrap="nowrap">
-                  <Text fz={14} fw={700} style={{ color: INK }} truncate>
-                    {w.origin ?? "—"}
-                  </Text>
-                  <ArrowRight size={13} color={MUTED} style={{ flexShrink: 0 }} />
-                  <Text fz={14} fw={700} style={{ color: INK }} truncate>
-                    {w.destination ?? "—"}
-                  </Text>
+                <Group gap={6} wrap="wrap">
+                  {windowRouteStops(w).map((stop, i) => (
+                    <Fragment key={i}>
+                      {i > 0 ? (
+                        <ArrowRight
+                          size={13}
+                          color={MUTED}
+                          style={{ flexShrink: 0 }}
+                        />
+                      ) : null}
+                      <Text fz={14} fw={700} style={{ color: INK }}>
+                        {stop}
+                      </Text>
+                    </Fragment>
+                  ))}
                   {w.reference && (
                     <Text
                       fz={11}
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 d0ecb12a6..04739b55d 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
@@ -133,6 +133,11 @@ export function ReadonlyBookingView({
         ["PAID", "TRUCK_ASSIGNED"].includes(status));
   const showCountdown = canPay && !!booking.paymentDeadline;
   const isExpired = status === "EXPIRED";
+  // Customs (Path B) bookings are created AND rebooked by Global Logistics, not
+  // the customer. Hide the customer's rebook everywhere and tell them GL will
+  // handle it. Non-customs bookings stay self-service.
+  const isCustoms = Boolean(booking.customsClearingEnabled);
+  const canSelfRebook = !isCustoms;
   const isPendingConsolidation = status === "PENDING_CONSOLIDATION";
   const isClearance = [
     "AWAITING_DOCUMENTS",
@@ -169,7 +174,7 @@ export function ReadonlyBookingView({
           )
         }
         menuActions={{
-          onRebook,
+          onRebook: canSelfRebook ? onRebook : undefined,
           onSupport: () => navigate("/support"),
         }}
       />
@@ -186,14 +191,18 @@ export function ReadonlyBookingView({
               : "This booking process has been terminated."
           }
           reason={booking.latestChangeRequestNote}
-          onRebook={onRebook}
+          onRebook={canSelfRebook ? onRebook : undefined}
         />
       ) : isExpired ? (
         <CancelledBanner
           pillLabel="Expired"
           title={`The payment window expired on ${fmtDate(booking.updatedAt)}.`}
-          subtitle="Payment wasn't completed in time, so this booking lost its slot. Rebook to try another schedule."
-          onRebook={onRebook}
+          subtitle={
+            isCustoms
+              ? "Payment wasn't completed in time, so this booking lost its slot. Global Logistics will rebook this shipment for you — no action is needed on your side."
+              : "Payment wasn't completed in time, so this booking lost its slot. Rebook to try another schedule."
+          }
+          onRebook={canSelfRebook ? onRebook : undefined}
         />
       ) : isPendingConsolidation ? (
         <ConsolidationWaitingBanner
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 a73057fcd..7c9cbeb0e 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
@@ -77,6 +77,10 @@ export function CustomerTruckAssignmentCard({
   const availableContainers = (booking.containerNumbers ?? []).filter(
     (n) => !assignedNumbers.has(n) || editingOwn.has(n),
   );
+  // Containers on the booking not yet assigned to any truck (independent of edit).
+  const pendingAssignmentCount = (booking.containerNumbers ?? []).filter(
+    (n) => !assignedNumbers.has(n),
+  ).length;
 
   // Both import and export specify the containers each truck carries.
   const resetForm = () => {
@@ -158,11 +162,18 @@ export function CustomerTruckAssignmentCard({
             <Truck size={18} color="#0a9f6a" />
             <CardTitle>External Truck Assignment</CardTitle>
           </Group>
-          {trucks.length > 0 && (
-            <Text size="sm" fw={700} c="#0a9f6a">
-              {trucks.length} truck{trucks.length !== 1 ? "s" : ""}
-            </Text>
-          )}
+          <Group gap={12}>
+            {pendingAssignmentCount > 0 && (
+              <Text size="sm" fw={600} c="#b45309">
+                {pendingAssignmentCount} container{pendingAssignmentCount !== 1 ? "s" : ""} pending assignment
+              </Text>
+            )}
+            {trucks.length > 0 && (
+              <Text size="sm" fw={700} c="#0a9f6a">
+                {trucks.length} truck{trucks.length !== 1 ? "s" : ""}
+              </Text>
+            )}
+          </Group>
         </Group>
 
         {/* Assigned trucks */}
diff --git a/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/components/DocumentsTab.tsx b/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/components/DocumentsTab.tsx
index a24f34763..fe7f58e62 100644
--- a/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/components/DocumentsTab.tsx
+++ b/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/components/DocumentsTab.tsx
@@ -21,6 +21,10 @@ import { BookingActionModal } from "@/pages/bookings/clearance/BookingActionModa
 import { getBookingNextAction } from "@/pages/bookings/clearance/bookingNextAction";
 import { ClearanceUploadedDocumentsPanel } from "@/components/contracts/ClearanceUploadedDocumentsPanel";
 
+import toast from "react-hot-toast";
+
+import { bookingsService } from "@/services/bookings.service";
+import { saveBlob } from "@/utils/download";
 import { fmtDate } from "../utils";
 import { IconSquare } from "./Documents";
 import { CardTitle, SectionCard } from "./layout";
@@ -361,6 +365,39 @@ export function DocumentsTab({ booking }: { booking: Freight.IBooking }) {
 
   const company = contract?.company;
 
+  // One-click warehouse-document bundle: GRN + gate clearance + handover.
+  const [bundleBusy, setBundleBusy] = useState(false);
+  const downloadWarehouseDocuments = async () => {
+    setBundleBusy(true);
+    const ref = booking.reference ?? booking.id;
+    const jobs: Array<{ name: string; fn: () => Promise<Blob> }> = [
+      { name: `GRN-${ref}.pdf`, fn: () => bookingsService.downloadBookingGrnDocument(booking.id) },
+      {
+        name: `gate-clearance-${ref}.pdf`,
+        fn: () => bookingsService.downloadBookingReleaseDocument(booking.id),
+      },
+      {
+        name: `handover-${ref}.pdf`,
+        fn: () => bookingsService.downloadBookingHandoverDocument(booking.id),
+      },
+    ];
+    let saved = 0;
+    for (const job of jobs) {
+      try {
+        saveBlob(await job.fn(), job.name);
+        saved += 1;
+      } catch {
+        // Document not available for this booking yet — skip it.
+      }
+    }
+    setBundleBusy(false);
+    if (saved === 0) {
+      toast.error("No warehouse documents are available for this booking yet.");
+    } else {
+      toast.success(`Downloaded ${saved} document${saved !== 1 ? "s" : ""}.`);
+    }
+  };
+
   return (
     <Stack gap="lg">
       {/* ── 1. Clearance documents ──────────────────────────────────────── */}
@@ -552,6 +589,23 @@ export function DocumentsTab({ booking }: { booking: Freight.IBooking }) {
         </SectionCard>
       )}
 
+      {/* ── Warehouse documents (one-click bundle) ──────────────────────── */}
+      <SectionCard>
+        <CardTitle>Warehouse documents</CardTitle>
+        <Text fz="12.5px" c="dimmed" mt={4} mb="sm">
+          Goods Received Note, gate clearance / release order and handover — download all
+          available documents for this booking in one click.
+        </Text>
+        <Button
+          leftSection={<Download size={16} />}
+          color="edr-green"
+          loading={bundleBusy}
+          onClick={downloadWarehouseDocuments}
+        >
+          Download documents
+        </Button>
+      </SectionCard>
+
       {!hasContract && otherBookingFiles.length === 0 && (
         <SectionCard>
           <Alert color="gray" radius="md" icon={<Info size={16} />}>
diff --git a/apps/edr-freight-web/portal/src/pages/bookings/delivery/ApproveDeliveryModal.tsx b/apps/edr-freight-web/portal/src/pages/bookings/delivery/ApproveDeliveryModal.tsx
index a3723b650..90e95369f 100644
--- a/apps/edr-freight-web/portal/src/pages/bookings/delivery/ApproveDeliveryModal.tsx
+++ b/apps/edr-freight-web/portal/src/pages/bookings/delivery/ApproveDeliveryModal.tsx
@@ -1,4 +1,4 @@
-import { Alert, Button, Group, Loader, Modal, Stack, Text } from "@mantine/core";
+import { Alert, Button, Group, Loader, Modal, Stack, Text, TextInput } from "@mantine/core";
 import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
 import { CheckCircle2, Info } from "lucide-react";
 import { useEffect, useState } from "react";
@@ -47,6 +47,7 @@ export function ApproveDeliveryModal({
   const navigate = useNavigate();
   const queryClient = useQueryClient();
   const [pdfUrl, setPdfUrl] = useState<string | null>(null);
+  const [signerName, setSignerName] = useState("");
 
   const {
     data: docBlob,
@@ -122,8 +123,9 @@ export function ApproveDeliveryModal({
       <Stack gap="md">
         <Alert color="blue" variant="light" icon={<Info size={16} />}>
           <Text size="sm">
-            Review the handover document below. Approving applies your saved signature
-            and confirms you received the goods.
+            Review the handover document below, then type your full name to sign and
+            confirm you received the goods. Your saved signature is applied automatically
+            if you have one.
           </Text>
         </Alert>
 
@@ -151,6 +153,15 @@ export function ApproveDeliveryModal({
           />
         )}
 
+        <TextInput
+          label="Your full name"
+          placeholder="e.g. Abebe Kebede"
+          required
+          value={signerName}
+          onChange={(e) => setSignerName(e.currentTarget.value)}
+          disabled={busy}
+        />
+
         <Group justify="flex-end">
           <Button variant="default" onClick={onClose} disabled={busy}>
             Cancel
@@ -159,8 +170,8 @@ export function ApproveDeliveryModal({
             color="edr-green"
             leftSection={<CheckCircle2 size={16} />}
             loading={busy}
-            disabled={isLoading || isError}
-            onClick={() => approve.mutate({ id: bookingId })}
+            disabled={isLoading || isError || !signerName.trim()}
+            onClick={() => approve.mutate({ id: bookingId, signerName: signerName.trim() })}
           >
             Approve &amp; sign delivery
           </Button>
diff --git a/apps/edr-freight-web/portal/src/pages/bookings/new-booking-form/step5-cargo-details.tsx b/apps/edr-freight-web/portal/src/pages/bookings/new-booking-form/step5-cargo-details.tsx
index b582468cf..b9cf743fa 100644
--- a/apps/edr-freight-web/portal/src/pages/bookings/new-booking-form/step5-cargo-details.tsx
+++ b/apps/edr-freight-web/portal/src/pages/bookings/new-booking-form/step5-cargo-details.tsx
@@ -787,13 +787,17 @@ export function Step5CargoDetails({
             const result = calcWagons(containers ?? []);
             if (result.hasOddUnit) {
               return (
-                <AlertBox tone="warning">
-                  <p className="font-semibold">Unpaired 20ft Container</p>
+                <AlertBox tone="error">
+                  <p className="font-semibold">
+                    Odd number of 20ft containers ({result.ft20Wagons})
+                  </p>
                   <p className="mt-1 text-xs">
-                    One 20ft container occupies only half a wagon. The wagon will
-                    depart once a co-loader is found to fill the remaining slot,
-                    which <strong>may delay departure</strong> beyond the standard
-                    lead time.
+                    20ft containers travel two per wagon, so they must be booked in
+                    even numbers. Please <strong>add one more 20ft container</strong>{" "}
+                    or <strong>remove one</strong> (e.g. book{" "}
+                    {result.ft20Wagons + 1} or {result.ft20Wagons - 1} instead of{" "}
+                    {result.ft20Wagons}) — the booking cannot be submitted with an
+                    unpaired 20ft container.
                   </p>
                 </AlertBox>
               );
diff --git a/apps/edr-freight-web/portal/src/pages/bookings/new-booking-form/step8-review.tsx b/apps/edr-freight-web/portal/src/pages/bookings/new-booking-form/step8-review.tsx
index a789943c2..501a04a5d 100644
--- a/apps/edr-freight-web/portal/src/pages/bookings/new-booking-form/step8-review.tsx
+++ b/apps/edr-freight-web/portal/src/pages/bookings/new-booking-form/step8-review.tsx
@@ -25,10 +25,11 @@ import {
 } from "lucide-react";
 import type { Freight } from "@/types";
 import {
+  calcWagons,
   type BookingFormInputValues,
   type BookingFormValues,
 } from "./schema";
-import { StepHeader } from "./shared";
+import { AlertBox, StepHeader } from "./shared";
 
 export const REVIEW_STEP_TARGETS = {
   contract: 1,
@@ -160,6 +161,12 @@ export function Step8Review({
           .join(", ")
       : "";
 
+  // 20ft containers must pair up (two per wagon) — an odd total blocks submit.
+  const { hasOddUnit: hasOdd20ft, ft20Wagons: twentyFtCount } =
+    values.cargoType === "container"
+      ? calcWagons(values.containers ?? [])
+      : { hasOddUnit: false, ft20Wagons: 0 };
+
   const isGeneralContract = values.bookingType === "general_contract";
   // Both one-time and general contracts take the bulk amount from the cargo step
   // (cargoWeight); general contracts no longer collect a per-route quantity.
@@ -529,10 +536,27 @@ export function Step8Review({
             </Paper>
 
             <Paper radius={20} p="lg" withBorder bg="white">
-              <Text size="sm" c="dimmed" mb="md">
-                Ready to submit. You'll review the unit rates before final
-                submission.
-              </Text>
+              {hasOdd20ft ? (
+                <Box mb="md">
+                  <AlertBox tone="error">
+                    <p className="font-semibold">
+                      Odd number of 20ft containers ({twentyFtCount})
+                    </p>
+                    <p className="mt-1 text-xs">
+                      20ft containers travel two per wagon, so they must be booked
+                      in even numbers. Go back to the cargo step and{" "}
+                      <strong>add one more 20ft container</strong> or{" "}
+                      <strong>remove one</strong> (e.g. {twentyFtCount + 1} or{" "}
+                      {twentyFtCount - 1} instead of {twentyFtCount}).
+                    </p>
+                  </AlertBox>
+                </Box>
+              ) : (
+                <Text size="sm" c="dimmed" mb="md">
+                  Ready to submit. You'll review the unit rates before final
+                  submission.
+                </Text>
+              )}
               <Stack gap="sm">
                 <Button
                   type="button"
@@ -543,7 +567,7 @@ export function Step8Review({
                   leftSection={<Send size={16} />}
                   onClick={onSubmit}
                   loading={submitPending}
-                  disabled={submitPending}
+                  disabled={submitPending || hasOdd20ft}
                 >
                   Submit
                 </Button>
diff --git a/apps/edr-freight-web/portal/src/pages/contracts/ContractBookingWindowsSection.tsx b/apps/edr-freight-web/portal/src/pages/contracts/ContractBookingWindowsSection.tsx
index 524f3804e..3b7ef132b 100644
--- a/apps/edr-freight-web/portal/src/pages/contracts/ContractBookingWindowsSection.tsx
+++ b/apps/edr-freight-web/portal/src/pages/contracts/ContractBookingWindowsSection.tsx
@@ -1,4 +1,4 @@
-import { useMemo, useState } from "react";
+import { Fragment, useMemo, useState } from "react";
 import {
   ActionIcon,
   Badge,
@@ -21,7 +21,11 @@ import {
 import { CountdownTimer } from "@edr/ui-common";
 
 import type { MyBookingWindow } from "@/services/bookings.service";
-import { formatWindowOpensAt, soonestUpcomingWindow } from "./booking-window";
+import {
+  formatWindowOpensAt,
+  soonestUpcomingWindow,
+  windowRouteStops,
+} from "./booking-window";
 
 const INK = "#10202F";
 const MUTED = "#6B7C8E";
@@ -189,14 +193,21 @@ function WindowCard({ w }: { w: MyBookingWindow }) {
             </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 gap={6} wrap="wrap" mt={10}>
+            {windowRouteStops(w).map((stop, i) => (
+              <Fragment key={i}>
+                {i > 0 ? (
+                  <ArrowRight
+                    size={14}
+                    color={MUTED}
+                    style={{ flexShrink: 0 }}
+                  />
+                ) : null}
+                <Text fz={15} fw={700} style={{ color: INK }}>
+                  {stop}
+                </Text>
+              </Fragment>
+            ))}
           </Group>
 
           <Group gap={6} wrap="nowrap" mt={8}>
diff --git a/apps/edr-freight-web/portal/src/pages/contracts/NewShipmentRequestPage.tsx b/apps/edr-freight-web/portal/src/pages/contracts/NewShipmentRequestPage.tsx
index c0bfbfc4c..0b5c1796c 100644
--- a/apps/edr-freight-web/portal/src/pages/contracts/NewShipmentRequestPage.tsx
+++ b/apps/edr-freight-web/portal/src/pages/contracts/NewShipmentRequestPage.tsx
@@ -26,7 +26,12 @@ export default function NewShipmentRequestPage() {
   const { id } = useParams<{ id: string }>();
   const navigate = useNavigate();
   const [scheduledDate, setScheduledDate] = useState("");
-  const [quantity, setQuantity] = useState<number | string>(1);
+  // Container contracts: one quantity per enabled size (e.g. 20ft + 40ft).
+  const [qtyBySize, setQtyBySize] = useState<Record<string, number | string>>(
+    {},
+  );
+  // Bulk contracts: a single amount — tons (PER_TON) or item count (PER_ITEM).
+  const [bulkAmount, setBulkAmount] = useState<number | string>("");
   const [notes, setNotes] = useState("");
 
   const { data: contract, isLoading } = useQuery({
@@ -76,6 +81,22 @@ export default function NewShipmentRequestPage() {
     contract.contractKind === "GENERAL" &&
     (contract.serviceType?.includesCustoms ?? contract.customsClearingEnabled);
 
+  // Only the container sizes the contract was scoped for (20ft, 40ft, or both).
+  const SIZE_ORDER = ["20ft", "40ft"];
+  const enabledSizes = SIZE_ORDER.filter((s) =>
+    contract.cargoScope?.some(
+      (l) => (l.containerSize ?? "").toLowerCase() === s,
+    ),
+  );
+  // A CONTAINER contract should always carry scope lines; fall back to both.
+  const sizes = enabledSizes.length ? enabledSizes : SIZE_ORDER;
+
+  // Bulk: pick the bulk scope line and read how it's measured.
+  const bulkScope =
+    contract.cargoScope?.find((l) => !l.containerSize) ??
+    contract.cargoScope?.[0];
+  const isPerItem = bulkScope?.cargoType?.unitOfMeasure === "PER_ITEM";
+
   const handleSubmit = () => {
     const dto: Freight.CreateBookingRequestDto = {
       contractRouteId: route?.id,
@@ -84,17 +105,24 @@ export default function NewShipmentRequestPage() {
     };
 
     if (isContainer) {
-      const size = contract.cargoScope?.[0]?.containerSize ?? "20FT";
-      dto.containers = [
-        {
-          containerSize: size,
-          quantity: Number(quantity) || 1,
-        },
-      ];
+      // One line per size the user filled; 0 (or blank) sizes are dropped.
+      const containers = sizes
+        .map((size) => ({ containerSize: size, quantity: Number(qtyBySize[size]) || 0 }))
+        .filter((line) => line.quantity > 0);
+      if (containers.length === 0) {
+        toast.error("Enter a quantity for at least one container size");
+        return;
+      }
+      dto.containers = containers;
     } else {
+      const amount = Number(bulkAmount) || 0;
+      if (amount <= 0) {
+        toast.error(isPerItem ? "Enter the number of items" : "Enter the cargo weight");
+        return;
+      }
       dto.bulk = {
-        cargoTypeId: contract.cargoScope?.[0]?.cargoTypeId ?? null,
-        cargoWeightTons: Number(quantity) || undefined,
+        cargoTypeId: bulkScope?.cargoTypeId ?? null,
+        ...(isPerItem ? { itemCount: amount } : { cargoWeightTons: amount }),
       };
     }
 
@@ -131,17 +159,47 @@ export default function NewShipmentRequestPage() {
               />
             )}
 
-            <NumberInput
-              label={isContainer ? "Number of containers" : "Cargo weight (tons)"}
-              description={
-                hasCustoms
-                  ? "Global Logistics schedules the shipment date during customs clearance — you only state the quantity."
-                  : undefined
-              }
-              value={quantity}
-              onChange={setQuantity}
-              min={1}
-            />
+            {isContainer ? (
+              <Stack gap="sm">
+                {sizes.map((size) => (
+                  <NumberInput
+                    key={size}
+                    label={`Number of ${size} containers`}
+                    value={qtyBySize[size] ?? 0}
+                    onChange={(v) =>
+                      setQtyBySize((prev) => ({ ...prev, [size]: v }))
+                    }
+                    min={0}
+                    allowDecimal={false}
+                  />
+                ))}
+                {sizes.length > 1 ? (
+                  <Text size="xs" c="dimmed">
+                    Enter a quantity for each size you need — leave a size at 0 if
+                    you don&apos;t need it.
+                  </Text>
+                ) : null}
+                {hasCustoms ? (
+                  <Text size="xs" c="dimmed">
+                    Global Logistics schedules the shipment date during customs
+                    clearance — you only state the quantity.
+                  </Text>
+                ) : null}
+              </Stack>
+            ) : (
+              <NumberInput
+                label={isPerItem ? "Number of items" : "Cargo weight (tons)"}
+                description={
+                  hasCustoms
+                    ? "Global Logistics schedules the shipment date during customs clearance — you only state the quantity."
+                    : undefined
+                }
+                value={bulkAmount}
+                onChange={setBulkAmount}
+                min={0}
+                allowDecimal={!isPerItem}
+              />
+            )}
 
             {capacity?.length ? (
               <Text size="xs" c="dimmed">
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 ab25284ba..1f0825f57 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
@@ -25,6 +25,16 @@ export function hasOpenWindow(windows: MyBookingWindow[]): boolean {
   return windows.some((w) => w.isOpenNow);
 }
 
+/**
+ * Full ordered corridor for a window — every stop from origin through the
+ * intermediate milestones to the destination. Falls back to origin/destination
+ * when the backend sends no milestone chain (older schedules, routeless windows).
+ */
+export function windowRouteStops(w: MyBookingWindow): string[] {
+  if (w.routeStations && w.routeStations.length >= 2) return w.routeStations;
+  return [w.origin ?? "—", w.destination ?? "—"];
+}
+
 /**
  * The next upcoming (not-yet-open) window the customer should come back for —
  * the one that OPENS soonest from now. Two guards matter here:
diff --git a/apps/edr-freight-web/portal/src/services/api.ts b/apps/edr-freight-web/portal/src/services/api.ts
index 6cd606b2e..6f4527c0b 100644
--- a/apps/edr-freight-web/portal/src/services/api.ts
+++ b/apps/edr-freight-web/portal/src/services/api.ts
@@ -387,10 +387,10 @@ export const api = {
       ({ orderId }) => bookingsService.checkPayment(orderId),
     ),
 
-    approveDelivery: endpoint<{ id: string }, ApproveDeliveryResponse>(
+    approveDelivery: endpoint<{ id: string; signerName: string }, ApproveDeliveryResponse>(
       "bookings",
       "approveDelivery",
-      ({ id }) => bookingsService.approveDelivery(id),
+      ({ id, signerName }) => bookingsService.approveDelivery(id, signerName),
     ),
 
     getBookableSchedules: endpoint<
diff --git a/apps/edr-freight-web/portal/src/services/bookings.service.ts b/apps/edr-freight-web/portal/src/services/bookings.service.ts
index 1128b0883..88113c451 100644
--- a/apps/edr-freight-web/portal/src/services/bookings.service.ts
+++ b/apps/edr-freight-web/portal/src/services/bookings.service.ts
@@ -94,6 +94,12 @@ export interface MyBookingWindow {
   departureDate: string;
   origin: string | null;
   destination: string | null;
+  /**
+   * Full ordered corridor for the window's route — origin, every intermediate
+   * milestone stop, then destination (e.g. Djibouti → Adama → Dire Dawa).
+   * Falls back to [origin, destination] when the route has no milestones.
+   */
+  routeStations: string[];
 }
 
 export interface GeneratePriceResponse {
@@ -209,6 +215,20 @@ export const bookingsService = {
     );
     return data;
   },
+  downloadBookingGrnDocument: async (bookingId: string): Promise<Blob> => {
+    const { data } = await client.get(
+      `/api/warehouse-inventory/bookings/${bookingId}/grn-document`,
+      { responseType: "blob" },
+    );
+    return data;
+  },
+  downloadBookingReleaseDocument: async (bookingId: string): Promise<Blob> => {
+    const { data } = await client.get(
+      `/api/warehouse-inventory/bookings/${bookingId}/release-document`,
+      { responseType: "blob" },
+    );
+    return data;
+  },
   tracking: async (id: string): Promise<Freight.IBookingTracking> => {
     const { data } = await client.get(`/api/bookings/${id}/tracking`);
     return data.data;
@@ -359,9 +379,13 @@ export const bookingsService = {
     return data.data ?? data;
   },
 
-  approveDelivery: async (id: string): Promise<ApproveDeliveryResponse> => {
+  approveDelivery: async (
+    id: string,
+    signerName: string,
+  ): Promise<ApproveDeliveryResponse> => {
     const { data } = await client.post(
       `/api/warehouse-inventory/bookings/${id}/approve-delivery`,
+      { signerName },
     );
     return data.data ?? data;
   },
diff --git a/apps/edr-passenger-api/.env.example b/apps/edr-passenger-api/.env.example
index fcca698e9..215490361 100644
--- a/apps/edr-passenger-api/.env.example
+++ b/apps/edr-passenger-api/.env.example
@@ -124,6 +124,12 @@ WAAFI_INSECURE_TLS=false
 # Payment Configuration
 PAYMENT_PROVIDERS_ENABLED=TELEBIRR,CBE_BIRR,EBIRR,CARD,WALLET,WAAFI
 
+# Portal domains the browser-facing redirects (telebirr, waafi, Fayda WEB) may be rebased onto:
+# the API swaps the configured URL's host for whichever of these the request came from. Comma-
+# separated exact origins (scheme + host, no trailing slash). Leave empty to always use the
+# configured URLs below. DMONEY is a server webhook and is never rebased.
+PAYMENT_REDIRECT_ALLOWED_ORIGINS=
+
 # Browser return targets after a hosted payment page (UX only — payment is confirmed by the
 # webhook/queryStatus, never this redirect). Global fallback used when a method-specific URL
 # below is unset. Most providers use a single redirect; Waafi takes separate success/failure.
diff --git a/apps/edr-passenger-api/prisma/migrations/20260714111430_add_redirect_url/migration.sql b/apps/edr-passenger-api/prisma/migrations/20260714111430_add_redirect_url/migration.sql
new file mode 100644
index 000000000..c844b3257
--- /dev/null
+++ b/apps/edr-passenger-api/prisma/migrations/20260714111430_add_redirect_url/migration.sql
@@ -0,0 +1,2 @@
+-- AlterTable
+ALTER TABLE "FaydaVerificationSession" ADD COLUMN     "redirectUri" TEXT;
diff --git a/apps/edr-passenger-api/prisma/schema.prisma b/apps/edr-passenger-api/prisma/schema.prisma
index 00c5a8194..2721bb156 100644
--- a/apps/edr-passenger-api/prisma/schema.prisma
+++ b/apps/edr-passenger-api/prisma/schema.prisma
@@ -1395,6 +1395,7 @@ model FaydaVerificationSession {
   codeVerifier     String
   purpose          String    @default("VERIFY") // VERIFY | LOGIN
   platform         String    @default("WEB") // WEB | MOBILE — recorded for audit
+  redirectUri      String? // exact OAuth redirect_uri sent to eSignet at start; reused verbatim at token exchange (domain-aware for WEB)
   saveToAccount    Boolean   @default(false)
   status           String    @default("PENDING")
   errorCode        String?
diff --git a/apps/edr-passenger-api/src/common/utils/redirect-origin.util.ts b/apps/edr-passenger-api/src/common/utils/redirect-origin.util.ts
new file mode 100644
index 000000000..437ccee69
--- /dev/null
+++ b/apps/edr-passenger-api/src/common/utils/redirect-origin.util.ts
@@ -0,0 +1,82 @@
+/**
+ * Domain-aware redirect helpers.
+ *
+ * The passenger portal is served from more than one public domain
+ * (e.g. https://bookingedr.et and https://passenger.edrsc.com). Payment
+ * providers and Fayda need a browser-facing return/redirect URL, and that URL
+ * must live on the SAME domain the user is currently browsing — otherwise the
+ * user is bounced to the "other" site mid-flow.
+ *
+ * We derive the target domain from the incoming request's Origin (falling back
+ * to Referer), but only trust it when it matches an explicit allowlist
+ * (PAYMENT_REDIRECT_ALLOWED_ORIGINS) so a spoofed Origin can't turn these into
+ * an open redirect. When the origin is absent or not allowlisted, the
+ * configured (env) URL is left untouched.
+ *
+ * NOTE: this only rebases the ORIGIN (scheme + host + port). The path/query of
+ * the configured URL is preserved, so the redirect always keeps its known
+ * suffix (e.g. /booking/payment/telebirr/success). For Fayda this matters — the
+ * full redirect_uri, host included, must be pre-registered with eSignet for
+ * BOTH domains, or the login is rejected.
+ */
+
+/** Normalize to a bare origin ("https://host[:port]"), or null if unparseable. */
+function toOrigin(value?: string | null): string | null {
+  if (!value) return null;
+  try {
+    return new URL(value.trim()).origin;
+  } catch {
+    return null;
+  }
+}
+
+/** Allowlisted origins from PAYMENT_REDIRECT_ALLOWED_ORIGINS (comma-separated). */
+function allowedOrigins(): string[] {
+  return (process.env.PAYMENT_REDIRECT_ALLOWED_ORIGINS ?? "")
+    .split(",")
+    .map((o) => toOrigin(o))
+    .filter((o): o is string => o !== null);
+}
+
+/**
+ * Pick the origin the request came from, restricted to the allowlist. Sources
+ * are tried in order of trustworthiness:
+ *   1. `origin`  — the Origin header (most reliable on cross-origin requests).
+ *   2. `referer` — Referer fallback (browsers omit Origin on some same-site
+ *      navigations but usually still send Referer).
+ *   3. `frontendBaseUrl` — the X-Frontend-Base-URL header the portal sets
+ *      explicitly, used as a last resort when neither of the above is present.
+ * Returns null when none is present or allowlisted — callers then keep the
+ * configured URL.
+ */
+export function resolveAllowedOrigin(
+  origin?: string | null,
+  referer?: string | null,
+  frontendBaseUrl?: string | null,
+): string | null {
+  const candidate =
+    toOrigin(origin) ?? toOrigin(referer) ?? toOrigin(frontendBaseUrl);
+  if (!candidate) return null;
+  return allowedOrigins().includes(candidate) ? candidate : null;
+}
+
+/**
+ * Return `configuredUrl` with its origin swapped to `allowedOrigin`, preserving
+ * path, query and hash. If `allowedOrigin` is null or either URL is unparseable,
+ * the configured URL is returned unchanged.
+ */
+export function rebaseUrlOrigin(
+  configuredUrl: string | undefined,
+  allowedOrigin: string | null,
+): string | undefined {
+  if (!configuredUrl || !allowedOrigin) return configuredUrl;
+  try {
+    const target = new URL(configuredUrl);
+    const base = new URL(allowedOrigin);
+    target.protocol = base.protocol;
+    target.host = base.host;
+    return target.toString();
+  } catch {
+    return configuredUrl;
+  }
+}
diff --git a/apps/edr-passenger-api/src/modules/bookings/bookings.controller.ts b/apps/edr-passenger-api/src/modules/bookings/bookings.controller.ts
index 854621e0d..88bbe6ec4 100644
--- a/apps/edr-passenger-api/src/modules/bookings/bookings.controller.ts
+++ b/apps/edr-passenger-api/src/modules/bookings/bookings.controller.ts
@@ -525,8 +525,11 @@ export class BookingsController {
       "Missing required fields for bookingType, or Verifayda verification failed",
   })
   @ApiResponse({ status: 404, description: "Schedule or seat hold not found" })
-  create(@Body() dto: CreateBookingDto) {
-    return this.service.create(dto);
+  create(@Req() req: any, @Body() dto: CreateBookingDto) {
+    // Always resolve passengerId from the authenticated JWT — never trust the request body
+    const iamUserId = req.user?.id;
+    if (!iamUserId) throw new UnauthorizedException();
+    return this.service.create({ ...dto, passengerId: iamUserId });
   }
 
   @Get(":id/usage")
@@ -612,8 +615,8 @@ Results are ordered most-recent first. Use the returned \`bookingRef\` to open b
     status: 400,
     description: "Cannot modify cancelled or past bookings",
   })
-  modify(@Body() dto: ModifyBookingDto) {
-    return this.service.modify(dto);
+  modify(@Req() req: any, @Body() dto: ModifyBookingDto) {
+    return this.service.modify(dto, req.user?.id);
   }
 
   @Delete(":id")
@@ -658,7 +661,7 @@ Results are ordered most-recent first. Use the returned \`bookingRef\` to open b
     description: "Booking cancelled with refund amount",
   })
   @ApiResponse({ status: 400, description: "Booking already cancelled" })
-  cancel(@Param("bookingRef") ref: string, @Body() dto: CancelBookingDto) {
-    return this.service.cancel(ref, dto.reason);
+  cancel(@Req() req: any, @Param("bookingRef") ref: string, @Body() dto: CancelBookingDto) {
+    return this.service.cancel(ref, dto.reason, req.user?.id);
   }
 }
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 d50f48592..73887454c 100644
--- a/apps/edr-passenger-api/src/modules/bookings/bookings.dto.ts
+++ b/apps/edr-passenger-api/src/modules/bookings/bookings.dto.ts
@@ -88,8 +88,8 @@ export class RoundTripPassengerDto {
 }
 
 export class CreateBookingDto {
-  @ApiProperty({ description: 'Passenger ID' }) 
-  @IsString() passengerId: string;
+  @ApiPropertyOptional({ description: 'Passenger ID — resolved automatically from JWT token; only required for agent/back-office calls' }) 
+  @IsOptional() @IsString() passengerId: string;
   
   @ApiProperty({ description: 'Outbound / leg-1 schedule ID' }) 
   @IsString() scheduleId: string;
@@ -145,7 +145,7 @@ export class CreateBookingDto {
   @ApiPropertyOptional({ description: 'Package price tier ID — required when packageId is provided' })
   @IsOptional() @IsString() priceTierId?: string;
 
-  @ApiPropertyOptional({ description: 'Total amount in minor units (ETB) as computed and displayed on the review page. When provided, this overrides the fare engine total — use to pass the exact berth-specific amount the user saw.' })
+  @ApiPropertyOptional({ description: 'Total amount in display-currency minor units as computed and displayed on the review page. When displayCurrency is ETB this equals ETB minor units; for DJF/USD it is the converted display amount. The backend uses this directly as displayTotalMinor and back-converts to ETB for storage.' })
   @IsOptional() @IsInt() reviewedTotalMinor?: number;
 
   @ApiPropertyOptional({ description: 'Promo code for discount (applies to combined fare for round-trip)' }) 
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 114c0cc9d..dea2517c0 100644
--- a/apps/edr-passenger-api/src/modules/bookings/bookings.service.ts
+++ b/apps/edr-passenger-api/src/modules/bookings/bookings.service.ts
@@ -12,6 +12,7 @@ import { FareEngineService } from '../fare-engine/fare-engine.service';
 import { Currency, PassengerCategory, IdDocumentType } from '@prisma/client';
 import { resolveCurrencyFromNationality } from '../fare-engine/fare-engine.dto';
 import { DeleteOperationException } from '../../common/exceptions/delete-operation.exception';
+import { AuditService } from '../../common/audit.service';
 
 function generateRef(): string {
   const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
@@ -104,6 +105,7 @@ export class BookingsService {
     private readonly verifaydaService: VerifaydaService,
     private readonly currencyService: CurrencyService,
     private readonly fareEngine: FareEngineService,
+    private readonly auditService: AuditService,
   ) {}
 
   async findByIamUserId(iamUserId: string, filters: BookingFilters = {}) {
@@ -151,7 +153,7 @@ export class BookingsService {
         bookingRef: booking.bookingRef,
         status: booking.status,
         totalMinor: resolvePackageRoundTripTotal(booking, (booking as any).priceTier?.priceMinor, booking.adultCount, booking.childCount),
-        currency: 'ETB',
+        currency: booking.displayCurrency,
         displayCurrency: booking.displayCurrency,
         displayTotalMinor: booking.displayTotalMinor,
         adultCount: booking.adultCount,
@@ -295,7 +297,7 @@ export class BookingsService {
       bookingRef: booking.bookingRef,
       status: booking.status,
       totalMinor: resolvePackageRoundTripTotal(booking, (booking as any).priceTier?.priceMinor, booking.adultCount, booking.childCount),
-      currency: 'ETB',
+      currency: booking.displayCurrency,
       displayCurrency: booking.displayCurrency,
       displayTotalMinor: booking.displayTotalMinor,
       adultCount: booking.adultCount,
@@ -408,7 +410,7 @@ export class BookingsService {
         bookingRef: booking.bookingRef,
         status: booking.status,
         totalMinor: resolvePackageRoundTripTotal(booking, (booking as any).priceTier?.priceMinor, booking.adultCount, booking.childCount),
-        currency: 'ETB',
+        currency: booking.displayCurrency,
         displayCurrency: booking.displayCurrency,
         displayTotalMinor: booking.displayTotalMinor,
         adultCount: booking.adultCount,
@@ -681,7 +683,7 @@ export class BookingsService {
         bookingRef: booking.bookingRef,
         status: booking.status,
         totalMinor: resolvePackageRoundTripTotal(booking, (booking as any).priceTier?.priceMinor, booking.adultCount, booking.childCount),
-        currency: 'ETB',
+        currency: booking.displayCurrency,
         displayCurrency: booking.displayCurrency,
         displayTotalMinor: booking.displayTotalMinor,
         contactEmail: resolvedEmail,
@@ -756,7 +758,14 @@ export class BookingsService {
     };
   }
 
-    async create(dto: CreateBookingDto) {
+  async create(dto: CreateBookingDto) {
+    // Resolve passengerId from iamUserId when the caller is authenticated
+    if (dto.passengerId && !dto.passengerId.match(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i)) {
+      // passengerId is actually an iamUserId — resolve the passenger record
+      const passenger = await this.prisma.passenger.findUnique({ where: { iamUserId: dto.passengerId }, select: { id: true } });
+      if (!passenger) throw new NotFoundException('Passenger profile not found for this account');
+      dto = { ...dto, passengerId: passenger.id };
+    }
     if (dto.bookingType === 'ROUND_TRIP')         return this.createRoundTripBooking(dto);
     if (dto.bookingType === 'TRANSIT')            return this.createTransitBooking(dto);
     if (dto.bookingType === 'ROUND_TRIP_TRANSIT') return this.createRoundTripTransitBooking(dto);
@@ -837,16 +846,30 @@ export class BookingsService {
     // Free children have no seatId and no seatFareMinor — exclude them from the check.
     const seatedPassengers = passengersData.filter(p => p.seatId);
     const allFaresProvided = seatedPassengers.length > 0 && seatedPassengers.every(p => p.seatFareMinor != null);
-    const resolvedTotalMinor = dto.reviewedTotalMinor ??
-      (allFaresProvided
-        ? passengersWithFares.reduce((sum, p) => sum + p.fareMinor, 0)
-        : fareCalculation.totalMinor);
-    this.logger.log(`createOneWayBooking: resolvedTotalMinor=${resolvedTotalMinor} (reviewedTotalMinor=${dto.reviewedTotalMinor} allFaresProvided=${allFaresProvided} fareEngine=${fareCalculation.totalMinor})`);
-
-    let displayTotalMinor = resolvedTotalMinor;
-    if (displayCurrency !== Currency.ETB) {
-      displayTotalMinor = await this.currencyService.convertAmount(resolvedTotalMinor, Currency.ETB, displayCurrency);
+    // reviewedTotalMinor is now sent in display-currency minor units from the review page.
+    // When displayCurrency != ETB, use it directly as displayTotalMinor and back-convert to ETB.
+    let resolvedTotalMinor: number;
+    let displayTotalMinor: number;
+    if (dto.reviewedTotalMinor != null) {
+      if (displayCurrency !== Currency.ETB) {
+        displayTotalMinor = dto.reviewedTotalMinor;
+        resolvedTotalMinor = await this.currencyService.convertAmount(dto.reviewedTotalMinor, displayCurrency, Currency.ETB);
+      } else {
+        resolvedTotalMinor = dto.reviewedTotalMinor;
+        displayTotalMinor = dto.reviewedTotalMinor;
+      }
+    } else if (allFaresProvided) {
+      resolvedTotalMinor = passengersWithFares.reduce((sum, p) => sum + p.fareMinor, 0);
+      displayTotalMinor = displayCurrency !== Currency.ETB
+        ? await this.currencyService.convertAmount(resolvedTotalMinor, Currency.ETB, displayCurrency)
+        : resolvedTotalMinor;
+    } else {
+      resolvedTotalMinor = fareCalculation.totalMinor;
+      displayTotalMinor = displayCurrency !== Currency.ETB
+        ? await this.currencyService.convertAmount(resolvedTotalMinor, Currency.ETB, displayCurrency)
+        : resolvedTotalMinor;
     }
+    this.logger.log(`createOneWayBooking: resolvedTotalMinor=${resolvedTotalMinor} displayTotalMinor=${displayTotalMinor} displayCurrency=${displayCurrency} (reviewedTotalMinor=${dto.reviewedTotalMinor} allFaresProvided=${allFaresProvided} fareEngine=${fareCalculation.totalMinor})`);
 
     const booking = await this.prisma.booking.create({
       data: {
@@ -892,6 +915,7 @@ export class BookingsService {
       });
     }
     this.eventEmitter.emit('booking.created', { booking });
+    await this.auditService.log({ userId: dto.passengerId, action: 'CREATE', entityType: 'Booking', entityId: booking.id, newData: { bookingRef: booking.bookingRef, bookingType: 'ONE_WAY', totalMinor: resolvedTotalMinor } });
     return { ...booking, fareBreakdown: fareCalculation };
   }
 
@@ -1011,11 +1035,14 @@ export class BookingsService {
     const rtSeatedPassengers = passengersData.filter(p => p.outboundSeatId);
     const allRTFaresProvided = rtSeatedPassengers.length > 0 &&
       rtSeatedPassengers.every(p => p.seatFareMinor != null && p.returnSeatFareMinor != null);
-    if (dto.reviewedTotalMinor) {
-      totalMinor = dto.reviewedTotalMinor;
-      displayTotalMinor = displayCurrency !== Currency.ETB
-        ? await this.currencyService.convertAmount(totalMinor, Currency.ETB, displayCurrency)
-        : totalMinor;
+    if (dto.reviewedTotalMinor != null) {
+      if (displayCurrency !== Currency.ETB) {
+        displayTotalMinor = dto.reviewedTotalMinor;
+        totalMinor = await this.currencyService.convertAmount(dto.reviewedTotalMinor, displayCurrency, Currency.ETB);
+      } else {
+        totalMinor = dto.reviewedTotalMinor;
+        displayTotalMinor = dto.reviewedTotalMinor;
+      }
     } else if (allRTFaresProvided && !dto.packageId) {
       totalMinor = passengersWithFares.reduce((sum, p) => sum + p.outboundFareMinor + p.returnFareMinor, 0);
       if (displayCurrency !== Currency.ETB) {
@@ -1101,6 +1128,7 @@ export class BookingsService {
     }
 
     this.eventEmitter.emit('booking.created', { booking });
+    await this.auditService.log({ userId: dto.passengerId, action: 'CREATE', entityType: 'Booking', entityId: booking.id, newData: { bookingRef: booking.bookingRef, bookingType: 'ROUND_TRIP', totalMinor } });
 
     return {
       ...booking,
@@ -1112,7 +1140,7 @@ export class BookingsService {
         loyaltyRedemptionMinor: loyaltyMinor,
         taxesFeesMinor: taxesMinor,
         totalMinor,
-        currency: 'ETB',
+        currency: booking.displayCurrency,
         displayCurrency,
         displayTotalMinor
       }
@@ -1728,13 +1756,42 @@ export class BookingsService {
     );
   }
 
+  // Resolves the passenger's actual boarding/alighting stations AND times for one leg
+  // from originStationId/destinationStationId (set when the booking covers only part of
+  // a longer multi-stop schedule, e.g. train runs A→D but the passenger booked B→D) via
+  // the schedule's stopTimes, falling back to the schedule's own full-route endpoints/
+  // times when there's no segment override (older records, or a booking that covers the
+  // whole run). Station resolution mirrors notifications.service.ts's
+  // resolveSegmentStations (already applied to SMS/email); the departureAt/arrivalAt
+  // resolution mirrors search.service.ts's leg construction (originStop.plannedDepartureAt
+  // / destStop.plannedArrivalAt) — this brings the booking API (voucher, detail page,
+  // confirmation) to the same behavior search results already have, instead of always
+  // showing the train's full-route span.
+  private resolveSegmentStations(
+    schedule: any,
+    originStationId: string | null | undefined,
+    destinationStationId: string | null | undefined,
+  ): { origin: any; destination: any; departureAt: any; arrivalAt: any } {
+    const stopTimes: any[] = schedule?.stopTimes ?? [];
+    const findStop = (stationId: string | null | undefined) =>
+      stationId && stopTimes.length > 0 ? stopTimes.find((st: any) => st.stationId === stationId) : undefined;
+    const originStop = findStop(originStationId);
+    const destStop = findStop(destinationStationId);
+    return {
+      origin: originStop?.station ?? schedule?.originStation ?? null,
+      destination: destStop?.station ?? schedule?.destinationStation ?? null,
+      departureAt: originStop?.plannedDepartureAt ?? schedule?.departureAt ?? null,
+      arrivalAt: destStop?.plannedArrivalAt ?? schedule?.arrivalAt ?? null,
+    };
+  }
+
   async getByRef(bookingRefOrId: string) {
     const isUuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(bookingRefOrId);
     const booking = await this.prisma.booking.findUnique({
       where: isUuid ? { id: bookingRefOrId } : { bookingRef: bookingRefOrId },
       include: {
-        schedule: { include: { originStation: true, destinationStation: true, train: true } },
-        returnSchedule: { include: { originStation: true, destinationStation: true, train: true } },
+        schedule: { include: { originStation: true, destinationStation: true, train: true, stopTimes: { include: { station: true } } } },
+        returnSchedule: { include: { originStation: true, destinationStation: true, train: true, stopTimes: { include: { station: true } } } },
         seats: { include: { seat: { include: { coach: { include: { coachType: { include: { seatClasses: true } } } } } } } },
         paymentIntent: true, tickets: true,
         priceTier: { select: { priceMinor: true } },
@@ -1803,6 +1860,19 @@ export class BookingsService {
       };
     }
 
+    const outboundSegment = this.resolveSegmentStations(
+      (booking as any).schedule,
+      (booking as any).originStationId,
+      (booking as any).destinationStationId,
+    );
+    const returnSegment = (booking as any).returnSchedule
+      ? this.resolveSegmentStations(
+          (booking as any).returnSchedule,
+          (booking as any).returnOriginStationId,
+          (booking as any).returnDestinationStationId,
+        )
+      : null;
+
     return {
       id: booking.id, bookingRef: booking.bookingRef, status: booking.status,
       totalMinor: resolvePackageRoundTripTotal(booking, (booking as any).priceTier?.priceMinor, booking.adultCount, booking.childCount), currency: 'ETB',
@@ -1819,34 +1889,46 @@ export class BookingsService {
         id: (booking as any).schedule.id,
         trainNumber: (booking as any).schedule.train.number,
         trainName: (booking as any).schedule.train.name,
-        origin: { id: (booking as any).schedule.originStation.id, name: (booking as any).schedule.originStation.name, code: (booking as any).schedule.originStation.code, city: (booking as any).schedule.originStation.city },
-        destination: { id: (booking as any).schedule.destinationStation.id, name: (booking as any).schedule.destinationStation.name, code: (booking as any).schedule.destinationStation.code, city: (booking as any).schedule.destinationStation.city },
-        departureAt: (booking as any).schedule.departureAt, arrivalAt: (booking as any).schedule.arrivalAt,
+        origin: { id: outboundSegment.origin.id, name: outboundSegment.origin.name, code: outboundSegment.origin.code, city: outboundSegment.origin.city },
+        destination: { id: outboundSegment.destination.id, name: outboundSegment.destination.name, code: outboundSegment.destination.code, city: outboundSegment.destination.city },
+        departureAt: outboundSegment.departureAt, arrivalAt: outboundSegment.arrivalAt,
       },
       returnSchedule: (booking as any).returnSchedule
         ? {
             id: (booking as any).returnSchedule.id,
             trainNumber: (booking as any).returnSchedule.train.number,
             trainName: (booking as any).returnSchedule.train.name,
-            origin: { id: (booking as any).returnSchedule.originStation.id, name: (booking as any).returnSchedule.originStation.name, code: (booking as any).returnSchedule.originStation.code, city: (booking as any).returnSchedule.originStation.city },
-            destination: { id: (booking as any).returnSchedule.destinationStation.id, name: (booking as any).returnSchedule.destinationStation.name, code: (booking as any).returnSchedule.destinationStation.code, city: (booking as any).returnSchedule.destinationStation.city },
-            departureAt: (booking as any).returnSchedule.departureAt, arrivalAt: (booking as any).returnSchedule.arrivalAt,
+            origin: { id: returnSegment!.origin.id, name: returnSegment!.origin.name, code: returnSegment!.origin.code, city: returnSegment!.origin.city },
+            destination: { id: returnSegment!.destination.id, name: returnSegment!.destination.name, code: returnSegment!.destination.code, city: returnSegment!.destination.city },
+            departureAt: returnSegment!.departureAt, arrivalAt: returnSegment!.arrivalAt,
           }
         : null,
-      passengers: (booking as any).seats?.map((bs: any) => ({
-        fullName: bs.passengerName,
-        category: bs.passengerCategory,
-        leg: bs.leg ?? 1,
-        fareMinor: bs.fareMinor,
-        verifaydaVerified: bs.verifaydaVerified,
-        seat: {
-          id: bs.seat.id,
-          number: bs.seat.seatNumber,
-          coach: bs.seat.coach.number,
-          coachId: bs.seat.coach.id,
-          seatClass: bs.seat.coach.coachType?.seatClasses?.[0]?.name ?? null,
-        },
-      })),
+      passengers: (booking as any).seats?.map((bs: any) => {
+        // A coach type can have several seat classes (e.g. a VIP Bed coach has separate
+        // Upper/Lower classes) — seatClasses[0] is whichever was seeded first, so it always
+        // showed the SAME class for every seat in the coach regardless of that seat's own
+        // bed position. Match against the seat's actual bedPosition instead (Seat.bedPosition
+        // is lowercase, SeatClass.bedPosition is uppercase — compare case-insensitively).
+        // Falls back to [0] for non-bed seats (bedPosition is null, single class per coach).
+        const classes = bs.seat.coach.coachType?.seatClasses ?? [];
+        const matchedClass = bs.seat.bedPosition
+          ? classes.find((sc: any) => sc.bedPosition?.toLowerCase() === bs.seat.bedPosition.toLowerCase())
+          : null;
+        return {
+          fullName: bs.passengerName,
+          category: bs.passengerCategory,
+          leg: bs.leg ?? 1,
+          fareMinor: bs.fareMinor,
+          verifaydaVerified: bs.verifaydaVerified,
+          seat: {
+            id: bs.seat.id,
+            number: bs.seat.seatNumber,
+            coach: bs.seat.coach.number,
+            coachId: bs.seat.coach.id,
+            seatClass: (matchedClass ?? classes[0])?.name ?? null,
+          },
+        };
+      }),
       payment: (booking as any).paymentIntent
         ? {
             method: (booking as any).paymentIntent.method,
@@ -1870,7 +1952,7 @@ export class BookingsService {
     };
   }
 
-  async modify(dto: ModifyBookingDto) {
+  async modify(dto: ModifyBookingDto, iamUserId?: string) {
     const booking = await this.prisma.booking.findUnique({ where: { bookingRef: dto.bookingRef }, include: { seats: true, schedule: true } });
     if (!booking) throw new NotFoundException('Booking not found');
     if (booking.status !== 'CONFIRMED') throw new BadRequestException('Only confirmed bookings can be modified');
@@ -1882,10 +1964,11 @@ export class BookingsService {
     });
     await this.seatsService.releaseSeats(booking.id);
     await this.seatsService.confirmSeats(dto.newSeatIds);
+    await this.auditService.log({ userId: iamUserId ?? booking.passengerId, action: 'UPDATE', entityType: 'Booking', entityId: booking.id, oldData: { seatIds: oldSeats }, newData: { seatIds: dto.newSeatIds, reason: dto.reason } });
     return { modified: true, bookingRef: dto.bookingRef };
   }
 
-  async cancel(bookingRef: string, reason?: string) {
+  async cancel(bookingRef: string, reason?: string, iamUserId?: string) {
     const booking = await this.prisma.booking.findUnique({ where: { bookingRef }, include: { seats: true, paymentIntent: true } });
     if (!booking) throw new NotFoundException('Booking not found');
     if (booking.status === 'CANCELLED') throw new BadRequestException('Booking already cancelled');
@@ -1894,6 +1977,7 @@ export class BookingsService {
     await this.seatsService.releaseSeats(booking.id);
     await this.prisma.booking.update({ where: { bookingRef }, data: { status: 'CANCELLED' } });
     this.eventEmitter.emit('booking.cancelled', { booking, refundAmount });
+    await this.auditService.log({ userId: iamUserId ?? booking.passengerId, action: 'DELETE', entityType: 'Booking', entityId: booking.id, oldData: { bookingRef, status: booking.status }, newData: { status: 'CANCELLED', reason, refundAmount } });
     return { cancelled: true, refundAmount: refundAmount / 100, currency: 'ETB' };
   }
 
@@ -1960,6 +2044,7 @@ export class BookingsService {
 
     await this.prisma.bookingSeat.deleteMany({ where: { bookingId: id } });
     await this.prisma.booking.delete({ where: { id } });
+    await this.auditService.log({ action: 'DELETE', entityType: 'Booking', entityId: id, oldData: { bookingRef: booking.bookingRef } });
 
     return { deleted: true, bookingRef: booking.bookingRef };
   }
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 080b4404f..321e2269b 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
@@ -324,7 +324,7 @@ export class GuestBookingService {
         discountMinor,
         taxesFeesMinor: taxesMinor,
         totalMinor: resolvedTotalMinor,
-        currency: 'ETB',
+        currency: booking.displayCurrency,
         displayCurrency,
         displayTotalMinor,
       },
@@ -805,7 +805,7 @@ export class GuestBookingService {
         paidChildrenCount,
         combinedBaseFareMinor: combinedBase,
         discountMinor, taxesFeesMinor: taxesMinor, totalMinor,
-        currency: 'ETB', displayCurrency, displayTotalMinor,
+        currency: displayCurrency, displayTotalMinor,
       },
     };
   }
diff --git a/apps/edr-passenger-api/src/modules/currencies/currencies.module.ts b/apps/edr-passenger-api/src/modules/currencies/currencies.module.ts
index 0adb94656..614359dff 100644
--- a/apps/edr-passenger-api/src/modules/currencies/currencies.module.ts
+++ b/apps/edr-passenger-api/src/modules/currencies/currencies.module.ts
@@ -4,9 +4,10 @@ import { CurrenciesController } from './currencies.controller';
 import { CurrenciesService } from './currencies.service';
 import { CurrencyModule } from '../currency/currency.module';
 import { PrismaModule } from '../../common/prisma.module';
+import { AuditModule } from '../../common/audit.module';
 
 @Module({
-  imports: [HttpModule, PrismaModule, CurrencyModule],
+  imports: [HttpModule, PrismaModule, CurrencyModule, AuditModule],
   controllers: [CurrenciesController],
   providers: [CurrenciesService],
   exports: [CurrenciesService],
diff --git a/apps/edr-passenger-api/src/modules/currencies/currencies.service.ts b/apps/edr-passenger-api/src/modules/currencies/currencies.service.ts
index 8c875eb8b..648deb77c 100644
--- a/apps/edr-passenger-api/src/modules/currencies/currencies.service.ts
+++ b/apps/edr-passenger-api/src/modules/currencies/currencies.service.ts
@@ -2,12 +2,14 @@ import { Injectable, BadRequestException, NotFoundException } from '@nestjs/comm
 import { PrismaService } from '../../common/prisma.service';
 import { CurrencyService } from '../currency/currency.service';
 import { CreateCurrencyDto, UpdateCurrencyDto } from './currencies.dto';
+import { AuditService } from '../../common/audit.service';
 
 @Injectable()
 export class CurrenciesService {
   constructor(
     private prisma: PrismaService,
     private currencyService: CurrencyService,
+    private auditService: AuditService,
   ) {}
 
   async getAllCurrencies() {
@@ -57,6 +59,7 @@ export class CurrenciesService {
       },
     });
 
+    await this.auditService.log({ action: 'CREATE', entityType: 'Currency', entityId: rate.id, newData: { code, exchangeRate } });
     return {
       id: rate.id,
       code: rate.toCurrency,
@@ -92,6 +95,7 @@ export class CurrenciesService {
       'MANUAL',
     );
 
+    await this.auditService.log({ action: 'UPDATE', entityType: 'Currency', entityId: updated.id, newData: { exchangeRate: Number(updated.rate) } });
     return {
       id: updated.id,
       code: updated.toCurrency,
@@ -125,7 +129,7 @@ export class CurrenciesService {
     await this.prisma.currencyExchangeRate.deleteMany({
       where: { fromCurrency: existing.fromCurrency, toCurrency: existing.toCurrency },
     });
-
+    await this.auditService.log({ action: 'DELETE', entityType: 'Currency', entityId: id, oldData: { toCurrency: existing.toCurrency } });
     return { message: 'Currency deleted successfully' };
   }
 
diff --git a/apps/edr-passenger-api/src/modules/currency/currency.service.ts b/apps/edr-passenger-api/src/modules/currency/currency.service.ts
index 806ab423e..57276b116 100644
--- a/apps/edr-passenger-api/src/modules/currency/currency.service.ts
+++ b/apps/edr-passenger-api/src/modules/currency/currency.service.ts
@@ -51,26 +51,31 @@ export class CurrencyService {
   }
 
   /**
-   * Converts an ETB minor-unit amount to the charge major-unit amount sent to the
-   * payment provider. Applies the exchange rate for foreign currencies then divides
-   * by 100 to yield major units (e.g. 300000 ETB minor → 3000.00 ETB major).
+   * Converts a booking's stored minor-unit amount (in its own `fromCurrency`) to the charge
+   * major-unit amount sent to the payment provider in `targetCurrency`. When the two currencies
+   * match, no exchange rate is applied — the stored amount is charged as-is. Otherwise the
+   * fromCurrency→targetCurrency rate is applied. In both cases the result is divided by 100 to
+   * yield major units and rounded to the target currency's precision
+   * (e.g. 300000 ETB minor → 3000.00 ETB major; DJF rounds to whole francs).
    */
-  async convertEtbMinorToChargeMajor(
-    amountMinorEtb: number,
+  async convertMinorToChargeMajor(
+    amountMinor: number,
+    fromCurrency: string,
     targetCurrency: string,
   ): Promise<number> {
+    const from = fromCurrency.toUpperCase();
     const target = targetCurrency.toUpperCase();
     if (CHARGE_CURRENCY_DECIMALS[target] === undefined) {
       throw new BadRequestException(`Unsupported charge currency: ${targetCurrency}`);
     }
     const decimals = CHARGE_CURRENCY_DECIMALS[target];
 
-    if (target === Currency.ETB) {
-      return this.roundTo(amountMinorEtb / 100, decimals);
+    if (from === target) {
+      return this.roundTo(amountMinor / 100, decimals);
     }
 
-    const rate = await this.getRateOrThrow(Currency.ETB, target as Currency);
-    return this.roundTo((amountMinorEtb * rate) / 100, decimals);
+    const rate = await this.getRateOrThrow(from as Currency, target as Currency);
+    return this.roundTo((amountMinor * rate) / 100, decimals);
   }
 
   async getRateOrThrow(
diff --git a/apps/edr-passenger-api/src/modules/excess-baggage/excess-baggage.module.ts b/apps/edr-passenger-api/src/modules/excess-baggage/excess-baggage.module.ts
index e0545d44f..e734d4fb4 100644
--- a/apps/edr-passenger-api/src/modules/excess-baggage/excess-baggage.module.ts
+++ b/apps/edr-passenger-api/src/modules/excess-baggage/excess-baggage.module.ts
@@ -7,9 +7,10 @@ import {
 } from './excess-baggage.controller';
 import { PaymentsModule } from '../payments/payments.module';
 import { NotificationsModule } from '../notifications/notifications.module';
+import { AuditModule } from '../../common/audit.module';
 
 @Module({
-  imports: [HttpModule, PaymentsModule, NotificationsModule],
+  imports: [HttpModule, PaymentsModule, NotificationsModule, AuditModule],
   controllers: [ExcessBaggageAgentController, ExcessBaggagePublicController],
   providers: [ExcessBaggageService],
   exports: [ExcessBaggageService],
diff --git a/apps/edr-passenger-api/src/modules/excess-baggage/excess-baggage.service.ts b/apps/edr-passenger-api/src/modules/excess-baggage/excess-baggage.service.ts
index 30ab0fd5e..ee968ba61 100644
--- a/apps/edr-passenger-api/src/modules/excess-baggage/excess-baggage.service.ts
+++ b/apps/edr-passenger-api/src/modules/excess-baggage/excess-baggage.service.ts
@@ -5,6 +5,7 @@ import {
   Logger,
 } from '@nestjs/common';
 import { PrismaService } from '../../common/prisma.service';
+import { AuditService } from '../../common/audit.service';
 import { PaymentClientService } from '../payments/payment-client.service';
 import { NotificationsService } from '../notifications/notifications.service';
 import { SmsClientService } from '../notifications/sms-client.service';
@@ -30,6 +31,7 @@ export class ExcessBaggageService {
 
   constructor(
     private prisma: PrismaService,
+    private auditService: AuditService,
     private paymentClient: PaymentClientService,
     private notifications: NotificationsService,
     private smsClient: SmsClientService,
@@ -91,6 +93,7 @@ export class ExcessBaggageService {
       await this.sendPaymentLink(charge, booking, contactPhone, contactEmail);
     }
 
+    await this.auditService.log({ action: 'CREATE', entityType: 'ExcessBaggageCharge', entityId: charge.id, newData: { bookingId: dto.bookingId, excessWeightKg: dto.excessWeightKg, totalMinor, status } });
     return charge;
   }
 
@@ -208,10 +211,12 @@ export class ExcessBaggageService {
     if (['PAID', 'CASH_COLLECTED'].includes(charge.status)) {
       throw new BadRequestException('Cannot waive a charge that has already been paid');
     }
-    return this.prisma.excessBaggageCharge.update({
+    const waived = await this.prisma.excessBaggageCharge.update({
       where: { id },
       data: { status: 'WAIVED', waivedBy: dto.waivedBy, waivedReason: dto.waivedReason },
     });
+    await this.auditService.log({ action: 'UPDATE', entityType: 'ExcessBaggageCharge', entityId: id, newData: { status: 'WAIVED', waivedBy: dto.waivedBy, waivedReason: dto.waivedReason } });
+    return waived;
   }
 
   async resendLink(id: string) {
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 dd4e15b9c..fd3d75401 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
@@ -103,6 +103,18 @@ export class FareEngineService {
       },
     });
 
+    // Route-level fare override: checked after segment (most specific) but before
+    // schedule-scoped rules and the global seat-class tariff (least specific).
+    const routeFareOverride = segmentOverride ? null : await this.prisma.routeFareRule.findFirst({
+      where: {
+        routeId: route.id,
+        seatClassId: nationalitySeatClass.id,
+        validFrom: { lte: now },
+        OR: [{ validUntil: null }, { validUntil: { gte: now } }],
+      },
+      orderBy: { validFrom: 'desc' },
+    });
+
     if (segmentOverride) {
       baseFarePerPassengerMinor = segmentOverride.baseFareMinor;
       if (nationalityType === 'INTERNATIONAL' && !segmentOverride.nationality) {
@@ -110,6 +122,20 @@ export class FareEngineService {
       }
       ratePerKmMinor = totalDistanceKm > 0 ? Math.round(baseFarePerPassengerMinor / totalDistanceKm) : 0;
       fareSource = 'SEGMENT_FARE_RULE';
+    } else if (routeFareOverride) {
+      // Stored as a per-km rate (same unit as SeatClass.baseFareMinor × 100).
+      // Insurance factor and USD→ETB conversion are applied identically to the
+      // global seat-class formula so the override is a pure rate substitution.
+      const ratePerKmEtb = routeFareOverride.baseFareMinor / 100;
+      insuranceFactor = nationalitySeatClass.insuranceFeeMinor > 0
+        ? nationalitySeatClass.insuranceFeeMinor / 100 : 1;
+      usdToEtbRate = await this.currencyService.getExchangeRate(Currency.USD, Currency.ETB);
+      ratePerKmMinor = routeFareOverride.baseFareMinor;
+      baseFarePerPassengerMinor = Math.round(
+        totalDistanceKm * ratePerKmEtb * insuranceFactor * usdToEtbRate,
+      );
+      fareSource = 'ROUTE_FARE_OVERRIDE';
+      insuranceAlreadyInBase = true;
     } else if (fareRule?.tripId) {
       baseFarePerPassengerMinor = fareRule.baseFareMinor;
       if (nationalityType === 'INTERNATIONAL' && !fareRule.nationality) {
@@ -172,7 +198,7 @@ export class FareEngineService {
     const calculation = [
       `Distance:       ${totalDistanceKm} km (${originStation?.name} → ${destStation?.name})`,
       `Nationality:    ${dto.nationality ?? 'unspecified'} → ${nationalityType}${nationalityType === 'INTERNATIONAL' ? ' (2× surcharge applied)' : ''} → ${nationalitySeatClass.name}`,
-      `Rate per km:    ${nationalitySeatClass.baseFareMinor} minor → ${nationalitySeatClass.baseFareMinor / 100} ETB/km`,
+      `Rate per km:    ${routeFareOverride ? routeFareOverride.baseFareMinor : nationalitySeatClass.baseFareMinor} minor → ${(routeFareOverride ? routeFareOverride.baseFareMinor : nationalitySeatClass.baseFareMinor) / 100} ETB/km${routeFareOverride ? ' [ROUTE OVERRIDE]' : ''}`,
       `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`,
diff --git a/apps/edr-passenger-api/src/modules/fleet/fleet.controller.ts b/apps/edr-passenger-api/src/modules/fleet/fleet.controller.ts
index d3864e2b2..ee2a048f0 100644
--- a/apps/edr-passenger-api/src/modules/fleet/fleet.controller.ts
+++ b/apps/edr-passenger-api/src/modules/fleet/fleet.controller.ts
@@ -3,7 +3,8 @@ import { ApiTags, ApiOperation, ApiBearerAuth, ApiParam, ApiQuery, ApiBody, ApiR
 import { FleetService } from './fleet.service';
 import { CreateTrainDto, CreateCoachDto, UpdateCoachDto, AssignCoachDto, ListCoachesDto, CreateCoachTypeDto, UpdateCoachTypeDto, CreateClassDto, UpdateClassDto, GenerateSeatMapDto } from './fleet.dto';
 import { JwtGuard } from '../../common/jwt.guard';
-import { PassengerAdmin } from '../../common/passenger-guards';
+import { PassengerAdmin, PassengerStaff } from '../../common/passenger-guards';
+import { PASSENGER_PERMS } from '../../seed/passenger-permissions.registry';
 
 @ApiTags('Fleet')
 @Controller('fleet')
@@ -21,6 +22,7 @@ export class FleetController {
   }
 
   @Post('coach-types')
+  @PassengerStaff([PASSENGER_PERMS.coaches.manage, PASSENGER_PERMS.admin])
   @ApiOperation({ summary: 'Create a coach type' })
   @ApiBody({ type: CreateCoachTypeDto })
   @ApiResponse({ status: 201, description: 'Coach type created' })
@@ -29,6 +31,7 @@ export class FleetController {
   }
 
   @Patch('coach-types/:id')
+  @PassengerStaff([PASSENGER_PERMS.coaches.manage, PASSENGER_PERMS.admin])
   @ApiOperation({ summary: 'Update a coach type' })
   @ApiParam({ name: 'id', description: 'Coach Type UUID' })
   @ApiBody({ type: UpdateCoachTypeDto })
@@ -59,6 +62,7 @@ export class FleetController {
   }
 
   @Post('classes')
+  @PassengerStaff([PASSENGER_PERMS.classes.manage, PASSENGER_PERMS.admin])
   @ApiOperation({ summary: 'Create a class' })
   @ApiBody({ type: CreateClassDto })
   @ApiResponse({ status: 201, description: 'Class created' })
@@ -67,6 +71,7 @@ export class FleetController {
   }
 
   @Patch('classes/:id')
+  @PassengerStaff([PASSENGER_PERMS.classes.manage, PASSENGER_PERMS.admin])
   @ApiOperation({ summary: 'Update a class' })
   @ApiParam({ name: 'id', description: 'Class UUID' })
   @ApiBody({ type: UpdateClassDto })
@@ -98,6 +103,7 @@ export class FleetController {
   }
 
   @Post('seat-classes')
+  @PassengerStaff([PASSENGER_PERMS.classes.manage, PASSENGER_PERMS.admin])
   @ApiOperation({ summary: 'Create a class (DEPRECATED - use /fleet/classes)' })
   @ApiBody({ type: CreateClassDto })
   @ApiResponse({ status: 201, description: 'Class created' })
@@ -106,6 +112,7 @@ export class FleetController {
   }
 
   @Patch('seat-classes/:id')
+  @PassengerStaff([PASSENGER_PERMS.classes.manage, PASSENGER_PERMS.admin])
   @ApiOperation({ summary: 'Update a class (DEPRECATED - use /fleet/classes)' })
   @ApiParam({ name: 'id', description: 'Class UUID' })
   @ApiBody({ type: UpdateClassDto })
@@ -136,6 +143,7 @@ export class FleetController {
   }
 
   @Post('trains')
+  @PassengerStaff([PASSENGER_PERMS.trains.manage, PASSENGER_PERMS.admin])
   @ApiOperation({ summary: 'Create a train service' })
   @ApiBody({ type: CreateTrainDto })
   @ApiResponse({ status: 201, description: 'Train created' })
@@ -144,6 +152,7 @@ export class FleetController {
   }
 
   @Patch('trains/:id')
+  @PassengerStaff([PASSENGER_PERMS.trains.manage, PASSENGER_PERMS.admin])
   @ApiOperation({ summary: 'Update a train service' })
   @ApiParam({ name: 'id', description: 'Train UUID' })
   @ApiBody({ type: CreateTrainDto })
@@ -166,6 +175,7 @@ export class FleetController {
   }
 
   @Patch('trains/:id/restore')
+  @PassengerStaff([PASSENGER_PERMS.trains.manage, PASSENGER_PERMS.admin])
   @ApiOperation({ summary: 'Restore (reactivate) a deactivated train' })
   @ApiParam({ name: 'id', description: 'Train UUID' })
   @ApiResponse({ status: 200, description: 'Train restored' })
@@ -268,6 +278,7 @@ export class FleetController {
   }
 
   @Post('coaches')
+  @PassengerStaff([PASSENGER_PERMS.coaches.manage, PASSENGER_PERMS.admin])
   @ApiOperation({ summary: 'Create a coach with auto-generated seat numbers' })
   @ApiBody({ type: CreateCoachDto })
   @ApiResponse({ 
@@ -293,6 +304,7 @@ export class FleetController {
   }
 
   @Patch('coaches/:id')
+  @PassengerStaff([PASSENGER_PERMS.coaches.manage, PASSENGER_PERMS.admin])
   @ApiOperation({ summary: 'Update coach properties' })
   @ApiParam({ name: 'id', description: 'Coach UUID' })
   @ApiBody({ type: UpdateCoachDto })
@@ -331,6 +343,7 @@ export class FleetController {
   }
 
   @Post('assignments')
+  @PassengerStaff([PASSENGER_PERMS.coaches.manage, PASSENGER_PERMS.admin])
   @ApiOperation({ summary: 'Assign a coach to a schedule' })
   @ApiBody({ type: AssignCoachDto })
   @ApiResponse({ status: 201, description: 'Coach assigned' })
diff --git a/apps/edr-passenger-api/src/modules/fleet/fleet.module.ts b/apps/edr-passenger-api/src/modules/fleet/fleet.module.ts
index e2f4a28c9..dd39a72ec 100644
--- a/apps/edr-passenger-api/src/modules/fleet/fleet.module.ts
+++ b/apps/edr-passenger-api/src/modules/fleet/fleet.module.ts
@@ -1,6 +1,7 @@
 import { Module } from '@nestjs/common';
 import { FleetController } from './fleet.controller';
 import { FleetService } from './fleet.service';
+import { AuditModule } from '../../common/audit.module';
 
-@Module({ controllers: [FleetController], providers: [FleetService], exports: [FleetService] })
+@Module({ imports: [AuditModule], controllers: [FleetController], providers: [FleetService], exports: [FleetService] })
 export class FleetModule {}
diff --git a/apps/edr-passenger-api/src/modules/fleet/fleet.service.ts b/apps/edr-passenger-api/src/modules/fleet/fleet.service.ts
index dc29f4ecc..a4c1d8ccf 100644
--- a/apps/edr-passenger-api/src/modules/fleet/fleet.service.ts
+++ b/apps/edr-passenger-api/src/modules/fleet/fleet.service.ts
@@ -3,6 +3,7 @@ import { PrismaService } from '../../common/prisma.service';
 import { CreateTrainDto, CreateCoachDto, UpdateCoachDto, AssignCoachDto, ListCoachesDto, CreateCoachTypeDto, UpdateCoachTypeDto, CreateClassDto, UpdateClassDto, GenerateSeatMapDto } from './fleet.dto';
 import { SeatKind } from '@prisma/client';
 import { DeleteOperationException } from '../../common/exceptions/delete-operation.exception';
+import { AuditService } from '../../common/audit.service';
 
 // Parses '2+2' → [2, 2], '2+2+2' → [2, 2, 2]
 function parseArrangement(arrangement: string): number[] {
@@ -147,7 +148,7 @@ type SeatRow = {
 
 @Injectable()
 export class FleetService {
-  constructor(private prisma: PrismaService) {}
+  constructor(private prisma: PrismaService, private auditService: AuditService) {}
 
   async createCoachType(dto: CreateCoachTypeDto) {
     return this.prisma.coachType.create({
@@ -333,8 +334,8 @@ export class FleetService {
     });
   }
 
-  createTrain(dto: CreateTrainDto) {
-    return this.prisma.train.create({
+  async createTrain(dto: CreateTrainDto) {
+    const train = await this.prisma.train.create({
       data: {
         number: dto.number,
         name: dto.name,
@@ -344,12 +345,14 @@ export class FleetService {
         isActive: dto.isActive ?? true,
       },
     });
+    await this.auditService.log({ action: 'CREATE', entityType: 'Train', entityId: train.id, newData: { number: train.number, name: train.name } });
+    return train;
   }
 
   async updateTrain(id: string, dto: CreateTrainDto) {
     const train = await this.prisma.train.findUnique({ where: { id } });
     if (!train) throw new NotFoundException('Train not found');
-    return this.prisma.train.update({
+    const updated = await this.prisma.train.update({
       where: { id },
       data: {
         number: dto.number,
@@ -360,6 +363,8 @@ export class FleetService {
         ...(dto.isActive !== undefined && { isActive: dto.isActive }),
       },
     });
+    await this.auditService.log({ action: 'UPDATE', entityType: 'Train', entityId: id, newData: { number: dto.number, name: dto.name } });
+    return updated;
   }
 
   async deleteTrain(id: string, cascade = false) {
@@ -436,7 +441,9 @@ export class FleetService {
       await this.prisma.trainSchedule.deleteMany({ where: { id: { in: scheduleIds } } });
     }
     
-    return this.prisma.train.delete({ where: { id } });
+    const deleted = await this.prisma.train.delete({ where: { id } });
+    await this.auditService.log({ action: 'DELETE', entityType: 'Train', entityId: id, oldData: { number: train.number, name: train.name } });
+    return deleted;
   }
 
   async restoreTrain(id: string) {
@@ -519,6 +526,7 @@ export class FleetService {
       await this.prisma.seat.createMany({ data: seats });
     }
 
+    await this.auditService.log({ action: 'CREATE', entityType: 'Coach', entityId: coach.id, newData: { number: coach.number, capacity: coach.capacity } });
     return coach;
   }
 
@@ -526,7 +534,7 @@ export class FleetService {
     const coach = await this.prisma.coach.findUnique({ where: { id } });
     if (!coach) throw new NotFoundException('Coach not found');
     
-    return this.prisma.coach.update({ 
+    const updated = await this.prisma.coach.update({ 
       where: { id }, 
       data: {
         number: dto.number,
@@ -537,6 +545,8 @@ export class FleetService {
       },
       include: { coachType: true },
     });
+    await this.auditService.log({ action: 'UPDATE', entityType: 'Coach', entityId: id, newData: { number: dto.number, status: dto.status } });
+    return updated;
   }
 
   async deleteCoach(id: string, cascade = false) {
@@ -611,7 +621,9 @@ export class FleetService {
 
     await this.prisma.seat.deleteMany({ where: { coachId: id } });
     
-    return this.prisma.coach.delete({ where: { id } });
+    const deleted = await this.prisma.coach.delete({ where: { id } });
+    await this.auditService.log({ action: 'DELETE', entityType: 'Coach', entityId: id, oldData: { number: coach.number } });
+    return deleted;
   }
 
   async assignCoach(dto: AssignCoachDto) {
diff --git a/apps/edr-passenger-api/src/modules/packages/packages.controller.ts b/apps/edr-passenger-api/src/modules/packages/packages.controller.ts
index 314f8aeb4..79f04f9d9 100644
--- a/apps/edr-passenger-api/src/modules/packages/packages.controller.ts
+++ b/apps/edr-passenger-api/src/modules/packages/packages.controller.ts
@@ -3,10 +3,10 @@ import { ApiTags, ApiOperation, ApiBearerAuth, ApiQuery } from '@nestjs/swagger'
 import { IsPublic } from '@tria-plc/api-common/modules/auth/decorators/public.decorator';
 import { PackagesService } from './packages.service';
 import { CreatePackageDto, BookPackageDto, CreatePriceTierDto, UpdatePriceTierDto, CreateInquiryDto, UpdateInquiryStatusDto, PackageBookingContextDto } from './packages.dto';
-import { IamGuard } from '../../common/iam-adapter';
 import { JwtGuard } from '../../common/jwt.guard';
 import { OptionalJwtGuard } from '../verifayda/optional-jwt.guard';
-import { PassengerAdmin } from '../../common/passenger-guards';
+import { PassengerAdmin, PassengerStaff } from '../../common/passenger-guards';
+import { PASSENGER_PERMS } from '../../seed/passenger-permissions.registry';
 
 @ApiTags('Packages')
 @Controller('packages')
@@ -21,7 +21,7 @@ export class PackagesController {
   }
 
   @Get('inquiries')
-  @UseGuards(IamGuard)
+  @PassengerStaff([PASSENGER_PERMS.inquiries.view, PASSENGER_PERMS.admin])
   @ApiBearerAuth('IAM-auth')
   @ApiOperation({ summary: 'List all inquiries (backoffice)' })
   listInquiries(
@@ -34,7 +34,7 @@ export class PackagesController {
   }
 
   @Patch('inquiries/:id/status')
-  @UseGuards(IamGuard)
+  @PassengerStaff([PASSENGER_PERMS.inquiries.manage, PASSENGER_PERMS.admin])
   @ApiBearerAuth('IAM-auth')
   @ApiOperation({ summary: 'Update inquiry status (backoffice)' })
   updateInquiryStatus(@Param('id') id: string, @Body() dto: UpdateInquiryStatusDto) {
@@ -57,7 +57,7 @@ export class PackagesController {
   }
 
   @Get('all')
-  @UseGuards(IamGuard)
+  @PassengerStaff([PASSENGER_PERMS.packages.view, PASSENGER_PERMS.admin])
   @ApiBearerAuth('IAM-auth')
   @ApiOperation({ summary: 'List all packages (backoffice)' })
   listAll(@Query('page') page?: string, @Query('pageSize') pageSize?: string) {
@@ -65,7 +65,7 @@ export class PackagesController {
   }
 
   @Get('bookings')
-  @UseGuards(IamGuard)
+  @PassengerStaff([PASSENGER_PERMS.packages.view, PASSENGER_PERMS.admin])
   @ApiBearerAuth('IAM-auth')
   @ApiOperation({ summary: 'List all package bookings (backoffice)' })
   listBookings(
@@ -124,7 +124,7 @@ export class PackagesController {
   }
 
   @Post()
-  @UseGuards(IamGuard)
+  @PassengerStaff([PASSENGER_PERMS.packages.manage, PASSENGER_PERMS.admin])
   @ApiBearerAuth('IAM-auth')
   @ApiOperation({ summary: 'Create package (admin)' })
   create(@Body() dto: CreatePackageDto) {
@@ -132,7 +132,7 @@ export class PackagesController {
   }
 
   @Patch(':id')
-  @UseGuards(IamGuard)
+  @PassengerStaff([PASSENGER_PERMS.packages.manage, PASSENGER_PERMS.admin])
   @ApiBearerAuth('IAM-auth')
   @ApiOperation({ summary: 'Update package (admin)' })
   update(@Param('id') id: string, @Body() dto: Partial<CreatePackageDto>) {
@@ -149,7 +149,7 @@ export class PackagesController {
   }
 
   @Patch(':id/activate')
-  @UseGuards(IamGuard)
+  @PassengerStaff([PASSENGER_PERMS.packages.manage, PASSENGER_PERMS.admin])
   @ApiBearerAuth('IAM-auth')
   @ApiOperation({ summary: 'Activate package (admin)' })
   activate(@Param('id') id: string) {
@@ -157,7 +157,7 @@ export class PackagesController {
   }
 
   @Patch(':id/deactivate')
-  @UseGuards(IamGuard)
+  @PassengerStaff([PASSENGER_PERMS.packages.manage, PASSENGER_PERMS.admin])
   @ApiBearerAuth('IAM-auth')
   @ApiOperation({ summary: 'Deactivate package (admin)' })
   deactivate(@Param('id') id: string) {
@@ -165,7 +165,7 @@ export class PackagesController {
   }
 
   @Post(':id/tiers')
-  @UseGuards(IamGuard)
+  @PassengerStaff([PASSENGER_PERMS.packages.manage, PASSENGER_PERMS.admin])
   @ApiBearerAuth('IAM-auth')
   @ApiOperation({ summary: 'Add price tier to package (admin)' })
   addTier(@Param('id') id: string, @Body() dto: CreatePriceTierDto) {
@@ -173,7 +173,7 @@ export class PackagesController {
   }
 
   @Patch('tiers/:tierId')
-  @UseGuards(IamGuard)
+  @PassengerStaff([PASSENGER_PERMS.packages.manage, PASSENGER_PERMS.admin])
   @ApiBearerAuth('IAM-auth')
   @ApiOperation({ summary: 'Update price tier (admin)' })
   updateTier(@Param('tierId') tierId: string, @Body() dto: UpdatePriceTierDto) {
diff --git a/apps/edr-passenger-api/src/modules/packages/packages.module.ts b/apps/edr-passenger-api/src/modules/packages/packages.module.ts
index 32aec44fc..41e9da839 100644
--- a/apps/edr-passenger-api/src/modules/packages/packages.module.ts
+++ b/apps/edr-passenger-api/src/modules/packages/packages.module.ts
@@ -4,9 +4,10 @@ import { PackagesController } from './packages.controller';
 import { PackagesService } from './packages.service';
 import { CurrencyModule } from '../currency/currency.module';
 import { BookingsModule } from '../bookings/bookings.module';
+import { AuditModule } from '../../common/audit.module';
 
 @Module({
-  imports: [PrismaModule, CurrencyModule, BookingsModule],
+  imports: [PrismaModule, CurrencyModule, BookingsModule, AuditModule],
   controllers: [PackagesController],
   providers: [PackagesService],
   exports: [PackagesService],
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 916a0425b..9ddc1fb0a 100644
--- a/apps/edr-passenger-api/src/modules/packages/packages.service.ts
+++ b/apps/edr-passenger-api/src/modules/packages/packages.service.ts
@@ -5,6 +5,7 @@ import { CreatePackageDto, BookPackageDto, UpdatePriceTierDto, CreatePriceTierDt
 import { Currency } from '@prisma/client';
 import { BookingsService } from '../bookings/bookings.service';
 import { GuestBookingService } from '../bookings/guest-booking.service';
+import { AuditService } from '../../common/audit.service';
 
 /** Package-specific fare rules */
 const PKG_MAX_ADULTS = 5;
@@ -49,6 +50,7 @@ export class PackagesService {
     private readonly currencyService: CurrencyService,
     private readonly bookingsService: BookingsService,
     private readonly guestBookingService: GuestBookingService,
+    private readonly auditService: AuditService,
   ) {}
 
   async getBookingContext(packageId: string, tierId: string, adultCount: number, childCount = 0) {
@@ -254,8 +256,8 @@ export class PackagesService {
     };
   }
 
-  create(dto: CreatePackageDto) {
-    return this.prisma.travelPackage.create({
+  async create(dto: CreatePackageDto) {
+    const pkg = await this.prisma.travelPackage.create({
       data: {
         code: dto.code,
         name: dto.name,
@@ -279,12 +281,14 @@ export class PackagesService {
       },
       include: { priceTiers: true },
     });
+    await this.auditService.log({ action: 'CREATE', entityType: 'Package', entityId: pkg.id, newData: { code: pkg.code, name: pkg.name } });
+    return pkg;
   }
 
   async update(id: string, dto: Partial<CreatePackageDto>) {
     const pkg = await this.prisma.travelPackage.findUnique({ where: { id } });
     if (!pkg) throw new NotFoundException('Package not found');
-    return this.prisma.travelPackage.update({
+    const updated = await this.prisma.travelPackage.update({
       where: { id },
       data: {
         ...(dto.code && { code: dto.code }),
@@ -307,6 +311,8 @@ export class PackagesService {
       },
       include: { priceTiers: true },
     });
+    await this.auditService.log({ action: 'UPDATE', entityType: 'Package', entityId: id, newData: { code: dto.code, name: dto.name } });
+    return updated;
   }
 
   async addTier(packageId: string, dto: CreatePriceTierDto) {
@@ -353,19 +359,24 @@ export class PackagesService {
     await this.prisma.packageInquiry.deleteMany({ where: { packageId: id } });
     await this.prisma.packagePriceTier.deleteMany({ where: { packageId: id } });
     await this.prisma.travelPackage.delete({ where: { id } });
+    await this.auditService.log({ action: 'DELETE', entityType: 'Package', entityId: id });
     return { deleted: true };
   }
 
   async activate(id: string) {
     const pkg = await this.prisma.travelPackage.findUnique({ where: { id } });
     if (!pkg) throw new NotFoundException('Package not found');
-    return this.prisma.travelPackage.update({ where: { id }, data: { status: 'ACTIVE' } });
+    const activated = await this.prisma.travelPackage.update({ where: { id }, data: { status: 'ACTIVE' } });
+    await this.auditService.log({ action: 'UPDATE', entityType: 'Package', entityId: id, newData: { status: 'ACTIVE' } });
+    return activated;
   }
 
   async deactivate(id: string) {
     const pkg = await this.prisma.travelPackage.findUnique({ where: { id } });
     if (!pkg) throw new NotFoundException('Package not found');
-    return this.prisma.travelPackage.update({ where: { id }, data: { status: 'DRAFT' } });
+    const deactivated = await this.prisma.travelPackage.update({ where: { id }, data: { status: 'DRAFT' } });
+    await this.auditService.log({ action: 'UPDATE', entityType: 'Package', entityId: id, newData: { status: 'DRAFT' } });
+    return deactivated;
   }
 
   async book(dto: BookPackageDto, passengerId?: string) {
@@ -478,7 +489,7 @@ export class PackagesService {
         paidChildFareMinor: adultFareMinor,
         childFareNote: `First child per adult travels free (no seat); additional children pay full adult fare`,
         totalMinor,
-        currency: 'ETB',
+        currency: booking.displayCurrency,
         displayCurrency,
         displayTotalMinor,
       },
diff --git a/apps/edr-passenger-api/src/modules/passengers/passengers.module.ts b/apps/edr-passenger-api/src/modules/passengers/passengers.module.ts
index cc7748457..9fdb95b6c 100644
--- a/apps/edr-passenger-api/src/modules/passengers/passengers.module.ts
+++ b/apps/edr-passenger-api/src/modules/passengers/passengers.module.ts
@@ -4,10 +4,11 @@ import { PassengersController } from './passengers.controller';
 import { PassengersService } from './passengers.service';
 import { VerifaydaModule } from '../verifayda/verifayda.module';
 import { PrismaModule } from '../../common/prisma.module';
+import { AuditModule } from '../../common/audit.module';
 
-@Module({ 
-  imports: [VerifaydaModule, HttpModule, PrismaModule],
-  controllers: [PassengersController], 
-  providers: [PassengersService] 
+@Module({
+  imports: [VerifaydaModule, HttpModule, PrismaModule, AuditModule],
+  controllers: [PassengersController],
+  providers: [PassengersService],
 })
 export class PassengersModule {}
diff --git a/apps/edr-passenger-api/src/modules/passengers/passengers.service.ts b/apps/edr-passenger-api/src/modules/passengers/passengers.service.ts
index 2c52db955..742b7ae89 100644
--- a/apps/edr-passenger-api/src/modules/passengers/passengers.service.ts
+++ b/apps/edr-passenger-api/src/modules/passengers/passengers.service.ts
@@ -5,6 +5,7 @@ import { PrismaService } from '../../common/prisma.service';
 import { CreateTravelerProfileDto, CreateSavedRouteDto, RegisterPassengerDto } from './passengers.dto';
 import { VerifaydaService } from '../verifayda/verifayda.service';
 import { DeleteOperationException } from '../../common/exceptions/delete-operation.exception';
+import { AuditService } from '../../common/audit.service';
 
 interface PassengerFilters {
   search?: string;
@@ -30,6 +31,7 @@ export class PassengersService {
     private readonly prisma: PrismaService,
     @InjectDataSource() private readonly dataSource: DataSource,
     private readonly verifaydaService: VerifaydaService,
+    private readonly auditService: AuditService,
   ) {}
 
   async findAll(filters: PassengerFilters = {}) {
@@ -509,7 +511,7 @@ export class PassengersService {
     await this.prisma.travelerProfile.deleteMany({ where: { passengerId } });
     await this.prisma.savedRoute.deleteMany({ where: { passengerId } });
     await this.prisma.passenger.delete({ where: { id: passengerId } });
-
+    await this.auditService.log({ action: 'DELETE', entityType: 'Passenger', entityId: passengerId });
     return { deleted: true, passengerId };
   }
 
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 3c3135832..f917a9590 100644
--- a/apps/edr-passenger-api/src/modules/payments/payments.controller.ts
+++ b/apps/edr-passenger-api/src/modules/payments/payments.controller.ts
@@ -3,6 +3,7 @@ import {
   Controller,
   Delete,
   Get,
+  Headers,
   HttpStatus,
   Param,
   Patch,
@@ -37,6 +38,7 @@ import {
 } from "./payments.dto";
 import { PassengerStaff } from "../../common/passenger-guards";
 import { PASSENGER_PERMS } from "../../seed/passenger-permissions.registry";
+import { resolveAllowedOrigin } from "../../common/utils/redirect-origin.util";
 
 @ApiTags("Payment")
 @Controller("payments")
@@ -53,7 +55,11 @@ export class PaymentsController {
   }
 
   @Get("all")
-  @PassengerStaff([PASSENGER_PERMS.payments.viewAll, PASSENGER_PERMS.admin])
+  @PassengerStaff([
+    PASSENGER_PERMS.payments.view,
+    PASSENGER_PERMS.payments.viewAll,
+    PASSENGER_PERMS.admin,
+  ])
   @ApiBearerAuth("IAM-auth")
   @ApiOperation({ summary: "Get all payments with filters (staff/admin only)" })
   @ApiQuery({ name: "search", required: false })
@@ -83,8 +89,19 @@ export class PaymentsController {
     summary: "Initiate payment with nationality-based payment methods",
     description: `Initiates payment for a booking with support for multiple payment providers:\n\n**Ethiopian Payment Methods:**\n- TELEBIRR - Ethiopia's leading mobile money\n- CBE_BIRR - Commercial Bank of Ethiopia\n- EBIRR - Electronic payment gateway\n\n**Djiboutian Payment Methods:**\n- WAAFI - Djibouti's mobile money service\n\n**International Payment Methods:**\n- CARD - Visa, Mastercard\n- WALLET - Internal wallet balance\n\n**Multi-Currency:**\n- All transactions processed in ETB\n- Display amounts in ETB, DJF, or USD\n- Real-time exchange rate conversion`,
   })
-  initiatePayment(@Body() dto: InitiatePaymentDto) {
-    return this.service.initiatePayment(dto);
+  initiatePayment(
+    @Body() dto: InitiatePaymentDto,
+    @Headers("origin") origin?: string,
+    @Headers("referer") referer?: string,
+    @Headers("x-frontend-base-url") frontendBaseUrl?: string,
+  ) {
+    // Browser-facing return URLs (telebirr/waafi) follow the domain the user is
+    // on — derived from Origin, then Referer, then the X-Frontend-Base-URL
+    // header the portal sets, all validated against the allowlist.
+    return this.service.initiatePayment(
+      dto,
+      resolveAllowedOrigin(origin, referer, frontendBaseUrl),
+    );
   }
 
   @Get("intents/:bookingId")
@@ -133,7 +150,11 @@ export class PaymentsController {
   }
 
   @Post("refund")
-  @PassengerStaff([PASSENGER_PERMS.payments.refund, PASSENGER_PERMS.admin])
+  @PassengerStaff([
+    PASSENGER_PERMS.payments.manage,
+    PASSENGER_PERMS.payments.refund,
+    PASSENGER_PERMS.admin,
+  ])
   @ApiBearerAuth("IAM-auth")
   @ApiOperation({ summary: "Refund a confirmed booking (staff/agent only)" })
   refund(@Body() dto: RefundDto) {
@@ -142,6 +163,7 @@ export class PaymentsController {
 
   @Post(":bookingId/force-confirm")
   @PassengerStaff([
+    PASSENGER_PERMS.payments.manage,
     PASSENGER_PERMS.payments.manageMethods,
     PASSENGER_PERMS.admin,
   ])
@@ -161,6 +183,7 @@ export class PaymentsController {
 
   @Post("methods")
   @PassengerStaff([
+    PASSENGER_PERMS.paymentMethods.manage,
     PASSENGER_PERMS.payments.manageMethods,
     PASSENGER_PERMS.admin,
   ])
@@ -174,6 +197,7 @@ export class PaymentsController {
 
   @Patch("methods/:id")
   @PassengerStaff([
+    PASSENGER_PERMS.paymentMethods.manage,
     PASSENGER_PERMS.payments.manageMethods,
     PASSENGER_PERMS.admin,
   ])
diff --git a/apps/edr-passenger-api/src/modules/payments/payments.module.ts b/apps/edr-passenger-api/src/modules/payments/payments.module.ts
index 1b9af89f3..3c08eb3cd 100644
--- a/apps/edr-passenger-api/src/modules/payments/payments.module.ts
+++ b/apps/edr-passenger-api/src/modules/payments/payments.module.ts
@@ -19,6 +19,7 @@ import { ServiceAuthGuard } from "../../common/guards/service-auth.guard";
 import { SeatsModule } from "../seats/seats.module";
 import { TicketsModule } from "../tickets/tickets.module";
 import { CurrencyModule } from "../currency/currency.module";
+import { AuditModule } from "../../common/audit.module";
 
 const PASSENGER_QUEUE = PAYMENT_QUEUES[PaymentService.PASSENGER];
 
@@ -53,6 +54,7 @@ function rabbitMQImport(): DynamicModule[] {
     SeatsModule,
     TicketsModule,
     CurrencyModule,
+    AuditModule,
     // The payment service proxies slow provider calls (e.g. CAC Bank initiate, which SMSes an
     // OTP and can take tens of seconds). Keep this hop generous; overridable via env.
     HttpModule.register({
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 4a02941aa..fb70b2d76 100644
--- a/apps/edr-passenger-api/src/modules/payments/payments.service.ts
+++ b/apps/edr-passenger-api/src/modules/payments/payments.service.ts
@@ -26,6 +26,8 @@ import {
 import { PaymentEventDto, MarkPaidResponseDto } from "./internal-payments.dto";
 import { PaymentClientService } from "./payment-client.service";
 import { CurrencyService } from "../currency/currency.service";
+import { AuditService } from "../../common/audit.service";
+import { rebaseUrlOrigin } from "../../common/utils/redirect-origin.util";
 import {
   PaymentService as PaymentServiceEnum,
   PaymentReferenceType,
@@ -41,6 +43,15 @@ const NON_TERMINAL_STATUSES: PaymentIntentStatus[] = [
   PaymentIntentStatus.SUCCEEDED,
 ];
 
+// Methods whose return/failure URLs are browser-facing pages on the passenger
+// portal, so they should follow whichever domain the user came in on. DMONEY is
+// deliberately excluded — its return URL is a server-to-server webhook host, not
+// a page the browser lands on.
+const DOMAIN_AWARE_METHODS = new Set<PaymentMethodType>([
+  PaymentMethodType.TELEBIRR,
+  PaymentMethodType.WAAFI,
+]);
+
 @Injectable()
 export class PaymentsService {
   private readonly logger = new Logger(PaymentsService.name);
@@ -54,6 +65,7 @@ export class PaymentsService {
     private eventEmitter: EventEmitter2,
     private paymentClient: PaymentClientService,
     private currencyService: CurrencyService,
+    private auditService: AuditService,
   ) {}
 
   async deletePayment(id: string) {
@@ -172,7 +184,10 @@ export class PaymentsService {
     return correctTotal;
   }
 
-  async initiatePayment(dto: InitiatePaymentDto): Promise<InitiateResponseDto> {
+  async initiatePayment(
+    dto: InitiatePaymentDto,
+    requestOrigin?: string | null,
+  ): Promise<InitiateResponseDto> {
     const booking = await this.prisma.booking.findUnique({
       where: { id: dto.bookingId },
       include: { seats: true },
@@ -213,7 +228,10 @@ export class PaymentsService {
       return this.initiateWalletPayment(booking);
     }
 
-    const { returnUrl, failureUrl } = this.resolveReturnUrls(method);
+    const { returnUrl, failureUrl } = this.resolveReturnUrls(
+      method,
+      requestOrigin,
+    );
 
     // The selected method's settlement currency lives in the PaymentMethod table (WAAFI/DMONEY
     // settle in DJF, CARD in USD, Ethiopian wallets in ETB). Convert the ETB booking total into
@@ -224,8 +242,9 @@ export class PaymentsService {
     const chargeCurrency = (
       paymentMethod?.currency ?? booking.currency
     ).toUpperCase();
-    const chargeAmount = await this.currencyService.convertEtbMinorToChargeMajor(
+    const chargeAmount = await this.currencyService.convertMinorToChargeMajor(
       booking.totalMinor,
+      booking.currency,
       chargeCurrency,
     );
 
@@ -294,7 +313,10 @@ export class PaymentsService {
     return this.formatIntentStatus(intent);
   }
 
-  private resolveReturnUrls(method: PaymentMethodType): {
+  private resolveReturnUrls(
+    method: PaymentMethodType,
+    requestOrigin?: string | null,
+  ): {
     returnUrl?: string;
     failureUrl?: string;
   } {
@@ -323,9 +345,18 @@ export class PaymentsService {
     };
 
     const m = perMethod[method] ?? {};
-    const returnUrl = m.returnUrl || process.env.PAYMENT_RETURN_URL || undefined;
-    const failureUrl =
+    let returnUrl = m.returnUrl || process.env.PAYMENT_RETURN_URL || undefined;
+    let failureUrl =
       m.failureUrl || process.env.PAYMENT_FAILURE_URL || returnUrl;
+
+    // For browser-facing methods, swap the configured URL's host for whichever
+    // allowlisted domain the user is currently on (bookingedr.et vs
+    // passenger.edrsc.com). `requestOrigin` is already validated against the
+    // allowlist by the controller; when it's null the configured URL is kept.
+    if (DOMAIN_AWARE_METHODS.has(method) && requestOrigin) {
+      returnUrl = rebaseUrlOrigin(returnUrl, requestOrigin);
+      failureUrl = rebaseUrlOrigin(failureUrl, requestOrigin);
+    }
     return { returnUrl, failureUrl };
   }
 
@@ -564,6 +595,7 @@ export class PaymentsService {
         data: { status: "CANCELLED" },
       });
     }
+    await this.auditService.log({ action: 'UPDATE', entityType: 'Payment', entityId: intent.id, newData: { status: 'REFUNDED', bookingId: dto.bookingId } });
     return { refunded: true, bookingRef: booking?.bookingRef };
   }
 
@@ -870,6 +902,9 @@ export class PaymentsService {
     return this.finalizePaymentSuccess({
       intentId: intent.id,
       providerTxnId: dto.paymentReference ?? intent.providerTxnId ?? undefined,
+    }).then(async (result) => {
+      await this.auditService.log({ action: 'UPDATE', entityType: 'Payment', entityId: intent.id, newData: { status: 'FORCE_CONFIRMED', bookingId, paymentMethod: dto.paymentMethod, paymentReference: dto.paymentReference } });
+      return result;
     });
   }
 
diff --git a/apps/edr-passenger-api/src/modules/schedules/routes.controller.ts b/apps/edr-passenger-api/src/modules/schedules/routes.controller.ts
index e751278ce..d468bba7c 100644
--- a/apps/edr-passenger-api/src/modules/schedules/routes.controller.ts
+++ b/apps/edr-passenger-api/src/modules/schedules/routes.controller.ts
@@ -1,9 +1,9 @@
-import { Body, Controller, Delete, Get, Param, Patch, Post, Put, Query, ParseIntPipe, UseGuards } from '@nestjs/common';
+import { Body, Controller, Delete, Get, Param, Patch, Post, Put, Query, ParseIntPipe } from '@nestjs/common';
 import { ApiTags, ApiOperation, ApiBearerAuth, ApiParam, ApiQuery, ApiResponse } from '@nestjs/swagger';
 import { RoutesService } from './routes.service';
 import { CreateRouteDto, AddRouteStopDto, UpdateRouteDto, SetRouteCoachTemplateDto } from './routes.dto';
-import { JwtGuard } from '../../common/jwt.guard';
-import { PassengerAdmin } from '../../common/passenger-guards';
+import { PassengerAdmin, PassengerStaff } from '../../common/passenger-guards';
+import { PASSENGER_PERMS } from '../../seed/passenger-permissions.registry';
 
 @ApiTags('Routes')
 @Controller('routes')
@@ -13,7 +13,7 @@ export class RoutesController {
   // ── Routes ─────────────────────────────────────────────────────────────────
 
   @Post()
-  @UseGuards(JwtGuard) @ApiBearerAuth('JWT-auth')
+  @PassengerStaff([PASSENGER_PERMS.routes.manage, PASSENGER_PERMS.admin]) @ApiBearerAuth('IAM-auth')
   @ApiOperation({
     summary: 'Create a reusable route with its ordered stops',
     description: `Define the physical corridor once (e.g. ADD→ADM→AWS→DDW→AYS→DJI).
@@ -41,7 +41,7 @@ Route stops carry distanceKm for fare-by-distance calculations.`,
   getRoute(@Param('id') id: string) { return this.service.getRoute(id); }
 
   @Patch(':id')
-  @UseGuards(JwtGuard) @ApiBearerAuth('JWT-auth')
+  @PassengerStaff([PASSENGER_PERMS.routes.manage, PASSENGER_PERMS.admin]) @ApiBearerAuth('IAM-auth')
   @ApiOperation({ summary: 'Update route metadata (name, description, active flag, effectiveUntil)' })
   @ApiParam({ name: 'id', description: 'Route UUID' })
   @ApiResponse({ status: 200, description: 'Route updated' })
@@ -68,7 +68,7 @@ Route stops carry distanceKm for fare-by-distance calculations.`,
   getStops(@Param('id') id: string) { return this.service.getStops(id); }
 
   @Post(':id/stops')
-  @UseGuards(JwtGuard) @ApiBearerAuth('JWT-auth')
+  @PassengerStaff([PASSENGER_PERMS.routes.manage, PASSENGER_PERMS.admin]) @ApiBearerAuth('IAM-auth')
   @ApiOperation({ summary: 'Add a stop to an existing route' })
   @ApiParam({ name: 'id', description: 'Route UUID' })
   @ApiResponse({ status: 201, description: 'Stop added' })
@@ -108,7 +108,7 @@ Route stops carry distanceKm for fare-by-distance calculations.`,
   getCoachTemplate(@Param('id') id: string) { return this.service.getRouteCoachTemplate(id); }
 
   @Put(':id/coaches')
-  @UseGuards(JwtGuard) @ApiBearerAuth('JWT-auth')
+  @PassengerStaff([PASSENGER_PERMS.routes.manage, PASSENGER_PERMS.admin]) @ApiBearerAuth('IAM-auth')
   @ApiOperation({
     summary: 'Set the default coach lineup for this route',
     description: 'Replaces the entire coach template. Coaches are auto-assigned in this order when a new schedule is created for this route.',
diff --git a/apps/edr-passenger-api/src/modules/schedules/routes.service.ts b/apps/edr-passenger-api/src/modules/schedules/routes.service.ts
index e459e3663..9a9bdd30a 100644
--- a/apps/edr-passenger-api/src/modules/schedules/routes.service.ts
+++ b/apps/edr-passenger-api/src/modules/schedules/routes.service.ts
@@ -2,10 +2,11 @@ import { Injectable, NotFoundException, ConflictException, BadRequestException }
 import { PrismaService } from '../../common/prisma.service';
 import { CreateRouteDto, AddRouteStopDto, UpdateRouteDto, SetRouteCoachTemplateDto } from './routes.dto';
 import { DeleteOperationException } from '../../common/exceptions/delete-operation.exception';
+import { AuditService } from '../../common/audit.service';
 
 @Injectable()
 export class RoutesService {
-  constructor(private prisma: PrismaService) {}
+  constructor(private prisma: PrismaService, private auditService: AuditService) {}
 
   // ── Route CRUD ─────────────────────────────────────────────────────────────
 
@@ -22,7 +23,7 @@ export class RoutesService {
     const stations = await this.prisma.station.findMany({ where: { id: { in: stationIds } } });
     if (stations.length !== stationIds.length) throw new BadRequestException('One or more station IDs not found');
 
-    return this.prisma.route.create({
+    const route = await this.prisma.route.create({
       data: {
         code: dto.code,
         name: dto.name,
@@ -40,6 +41,8 @@ export class RoutesService {
       },
       include: { stops: { include: { route: false }, orderBy: { sequence: 'asc' } } },
     });
+    await this.auditService.log({ action: 'CREATE', entityType: 'Route', entityId: route.id, newData: { code: route.code, name: route.name } });
+    return route;
   }
 
   async listRoutes(activeOnly = false) {
@@ -104,6 +107,7 @@ export class RoutesService {
       });
     }
 
+    await this.auditService.log({ action: 'UPDATE', entityType: 'Route', entityId: id, newData: { name: dto.name, active: dto.active } });
     return this.prisma.route.findUnique({
       where: { id },
       include: { stops: { orderBy: { sequence: 'asc' } } },
@@ -192,6 +196,7 @@ export class RoutesService {
     }
 
     await this.prisma.route.delete({ where: { id } });
+    await this.auditService.log({ action: 'DELETE', entityType: 'Route', entityId: id, oldData: { code: route.code, name: route.name } });
     return { deleted: true, id };
   }
 
diff --git a/apps/edr-passenger-api/src/modules/schedules/schedules.controller.ts b/apps/edr-passenger-api/src/modules/schedules/schedules.controller.ts
index 9fc2ba851..b11ac3098 100644
--- a/apps/edr-passenger-api/src/modules/schedules/schedules.controller.ts
+++ b/apps/edr-passenger-api/src/modules/schedules/schedules.controller.ts
@@ -1,10 +1,10 @@
-import { Body, Controller, Delete, Get, Param, Patch, Post, Put, Query, ParseIntPipe, UseGuards } from '@nestjs/common';
+import { Body, Controller, Delete, Get, Param, Patch, Post, Put, Query, ParseIntPipe } from '@nestjs/common';
 import { ApiTags, ApiOperation, ApiBearerAuth, ApiParam, ApiQuery, ApiResponse } from '@nestjs/swagger';
 import { IsPublic } from '@tria-plc/api-common/modules/auth/decorators/public.decorator';
 import { SchedulesService } from './schedules.service';
 import { CreateScheduleDto, UpdateScheduleDto, CreateFareRuleDto, UpdateScheduleStatusDto, UpdateStopTimeDto, ListSchedulesDto, BulkCreateSchedulesDto, BulkSchedulesResponseDto, TripStatus } from './schedules.dto';
-import { JwtGuard } from '../../common/jwt.guard';
-import { PassengerAdmin } from '../../common/passenger-guards';
+import { PassengerAdmin, PassengerStaff } from '../../common/passenger-guards';
+import { PASSENGER_PERMS } from '../../seed/passenger-permissions.registry';
 
 @ApiTags('Schedule')
 @Controller('schedules')
@@ -12,14 +12,14 @@ export class SchedulesController {
   constructor(private service: SchedulesService) {}
 
   @Post('bulk-generate')
-  @UseGuards(JwtGuard) @ApiBearerAuth('JWT-auth')
+  @PassengerStaff([PASSENGER_PERMS.schedules.manage, PASSENGER_PERMS.admin]) @ApiBearerAuth('IAM-auth')
   @ApiOperation({ summary: 'Bulk generate repetitive schedules' })
   bulkGenerateSchedules(@Body() dto: BulkCreateSchedulesDto) {
     return this.service.bulkGenerateSchedules(dto);
   }
 
   @Post()
-  @UseGuards(JwtGuard) @ApiBearerAuth('JWT-auth')
+  @PassengerStaff([PASSENGER_PERMS.schedules.manage, PASSENGER_PERMS.admin]) @ApiBearerAuth('IAM-auth')
   @ApiOperation({ summary: 'Create a train schedule from a route template' })
   createSchedule(@Body() dto: CreateScheduleDto) { return this.service.createSchedule(dto); }
 
@@ -42,13 +42,13 @@ export class SchedulesController {
   // ===== SPECIFIC ROUTES (must come BEFORE generic :id routes) =====
 
   @Post('fares')
-  @UseGuards(JwtGuard) @ApiBearerAuth('JWT-auth')
+  @PassengerStaff([PASSENGER_PERMS.schedules.manage, PASSENGER_PERMS.admin]) @ApiBearerAuth('IAM-auth')
   @ApiOperation({ summary: 'Create a fare rule scoped to a schedule or route code' })
   @ApiResponse({ status: 201, description: 'Fare rule created' })
   createFareRule(@Body() dto: CreateFareRuleDto) { return this.service.createFareRule(dto); }
 
   @Patch('fares/:id')
-  @UseGuards(JwtGuard) @ApiBearerAuth('JWT-auth')
+  @PassengerStaff([PASSENGER_PERMS.schedules.manage, PASSENGER_PERMS.admin]) @ApiBearerAuth('IAM-auth')
   @ApiOperation({ summary: 'Update a fare rule' })
   @ApiParam({ name: 'id', description: 'FareRule UUID' })
   @ApiResponse({ status: 200, description: 'Fare rule updated' })
@@ -65,10 +65,44 @@ export class SchedulesController {
   deleteFareRule(@Param('id') id: string) { return this.service.deleteFareRule(id); }
 
   @Post('segment-fares')
-  @UseGuards(JwtGuard) @ApiBearerAuth('JWT-auth')
+  @PassengerStaff([PASSENGER_PERMS.schedules.manage, PASSENGER_PERMS.admin]) @ApiBearerAuth('IAM-auth')
   @ApiOperation({ summary: 'Create a segment fare rule' })
   createSegmentFareRule(@Body() dto: any) { return this.service.createSegmentFareRule(dto); }
 
+  // Static sub-path MUST come before routes/:routeId/* to avoid :routeId swallowing 'fare-rules'
+  @Delete('routes/fare-rules/:id')
+  @PassengerAdmin()
+  @ApiBearerAuth('IAM-auth')
+  @ApiOperation({ summary: 'Delete a route-level fare override' })
+  @ApiParam({ name: 'id', description: 'RouteFareRule UUID' })
+  deleteRouteFareRule(@Param('id') id: string) {
+    return this.service.deleteRouteFareRule(id);
+  }
+
+  @Patch('routes/fare-rules/:id')
+  @PassengerStaff([PASSENGER_PERMS.schedules.manage, PASSENGER_PERMS.admin]) @ApiBearerAuth('IAM-auth')
+  @ApiOperation({ summary: 'Update a route-level fare override' })
+  @ApiParam({ name: 'id', description: 'RouteFareRule UUID' })
+  updateRouteFareRule(@Param('id') id: string, @Body() dto: any) {
+    return this.service.updateRouteFareRule(id, dto);
+  }
+
+  @Get('routes/:routeId/fare-rules')
+  @IsPublic()
+  @ApiOperation({ summary: 'List route-level fare overrides for a route' })
+  @ApiParam({ name: 'routeId', description: 'Route UUID' })
+  listRouteFareRules(@Param('routeId') routeId: string) {
+    return this.service.listRouteFareRules(routeId);
+  }
+
+  @Post('routes/:routeId/fare-rules')
+  @PassengerStaff([PASSENGER_PERMS.schedules.manage, PASSENGER_PERMS.admin]) @ApiBearerAuth('IAM-auth')
+  @ApiOperation({ summary: 'Create a route-level fare override' })
+  @ApiParam({ name: 'routeId', description: 'Route UUID' })
+  createRouteFareRule(@Param('routeId') routeId: string, @Body() dto: any) {
+    return this.service.createRouteFareRule({ ...dto, routeId });
+  }
+
   @Get('routes/:routeId/segment-fares')
   @IsPublic()
   @ApiOperation({ summary: 'List all segment fare rules for a route' })
@@ -76,7 +110,7 @@ export class SchedulesController {
   getSegmentFares(@Param('routeId') routeId: string) { return this.service.getSegmentFares(routeId); }
 
   @Patch('segment-fares/:id')
-  @UseGuards(JwtGuard) @ApiBearerAuth('JWT-auth')
+  @PassengerStaff([PASSENGER_PERMS.schedules.manage, PASSENGER_PERMS.admin]) @ApiBearerAuth('IAM-auth')
   @ApiOperation({ summary: 'Update a segment fare rule' })
   @ApiParam({ name: 'id', description: 'SegmentFareRule UUID' })
   updateSegmentFareRule(@Param('id') id: string, @Body() dto: any) { return this.service.updateSegmentFareRule(id, dto); }
@@ -97,7 +131,7 @@ export class SchedulesController {
   getSchedule(@Param('id') id: string) { return this.service.getSchedule(id); }
 
   @Patch(':id')
-  @UseGuards(JwtGuard) @ApiBearerAuth('JWT-auth')
+  @PassengerStaff([PASSENGER_PERMS.schedules.manage, PASSENGER_PERMS.admin]) @ApiBearerAuth('IAM-auth')
   @ApiOperation({ summary: 'Update a schedule (partial)' })
   @ApiParam({ name: 'id', description: 'TrainSchedule UUID' })
   updateSchedule(@Param('id') id: string, @Body() dto: UpdateScheduleDto) {
@@ -105,7 +139,7 @@ export class SchedulesController {
   }
 
   @Patch(':id/status')
-  @UseGuards(JwtGuard) @ApiBearerAuth('JWT-auth')
+  @PassengerStaff([PASSENGER_PERMS.schedules.manage, PASSENGER_PERMS.admin]) @ApiBearerAuth('IAM-auth')
   @ApiOperation({ summary: 'Update schedule status' })
   @ApiParam({ name: 'id', description: 'TrainSchedule UUID' })
   updateStatus(@Param('id') id: string, @Body() dto: UpdateScheduleStatusDto) {
@@ -127,7 +161,7 @@ export class SchedulesController {
   getStops(@Param('id') id: string) { return this.service.getStops(id); }
 
   @Patch(':id/stops/:sequence')
-  @UseGuards(JwtGuard) @ApiBearerAuth('JWT-auth')
+  @PassengerStaff([PASSENGER_PERMS.schedules.manage, PASSENGER_PERMS.admin]) @ApiBearerAuth('IAM-auth')
   @ApiOperation({ summary: 'Update a stop time' })
   @ApiParam({ name: 'id', description: 'TrainSchedule UUID' })
   @ApiParam({ name: 'sequence', description: 'Stop sequence number' })
@@ -138,7 +172,7 @@ export class SchedulesController {
   ) { return this.service.updateStop(id, sequence, dto); }
 
   @Put(':scheduleId/fares/:seatClassId')
-  @UseGuards(JwtGuard) @ApiBearerAuth('JWT-auth')
+  @PassengerStaff([PASSENGER_PERMS.schedules.manage, PASSENGER_PERMS.admin]) @ApiBearerAuth('IAM-auth')
   @ApiOperation({
     summary: 'Override fare for a specific seat class on a schedule',
     description: 'Upserts a schedule-scoped FareRule. Expires any existing active rule for the same schedule+seatClass and creates a new one.',
@@ -186,12 +220,13 @@ export class SchedulesController {
   }
 
   @Post(':id/fares/sync')
+  @PassengerStaff([PASSENGER_PERMS.schedules.manage, PASSENGER_PERMS.admin]) @ApiBearerAuth('IAM-auth')
   @ApiOperation({ summary: 'Sync fares from fare engine' })
   @ApiParam({ name: 'id', description: 'TrainSchedule UUID' })
   syncFares(@Param('id') id: string) { return this.service.syncFaresFromEngine(id); }
 
   @Post(':id/coaches')
-  @UseGuards(JwtGuard) @ApiBearerAuth('JWT-auth')
+  @PassengerStaff([PASSENGER_PERMS.schedules.manage, PASSENGER_PERMS.admin]) @ApiBearerAuth('IAM-auth')
   @ApiOperation({ summary: 'Assign coaches to a schedule' })
   @ApiParam({ name: 'id', description: 'TrainSchedule UUID' })
   assignCoaches(
diff --git a/apps/edr-passenger-api/src/modules/schedules/schedules.module.ts b/apps/edr-passenger-api/src/modules/schedules/schedules.module.ts
index 5eca9f1be..18d88d631 100644
--- a/apps/edr-passenger-api/src/modules/schedules/schedules.module.ts
+++ b/apps/edr-passenger-api/src/modules/schedules/schedules.module.ts
@@ -4,9 +4,10 @@ import { SchedulesService } from './schedules.service';
 import { RoutesController } from './routes.controller';
 import { RoutesService } from './routes.service';
 import { FareEngineModule } from '../fare-engine/fare-engine.module';
+import { AuditModule } from '../../common/audit.module';
 
 @Module({
-  imports: [FareEngineModule],
+  imports: [FareEngineModule, AuditModule],
   controllers: [RoutesController, SchedulesController],
   providers: [RoutesService, SchedulesService],
   exports: [RoutesService, SchedulesService],
diff --git a/apps/edr-passenger-api/src/modules/schedules/schedules.service.ts b/apps/edr-passenger-api/src/modules/schedules/schedules.service.ts
index 92a0a66db..7cca548aa 100644
--- a/apps/edr-passenger-api/src/modules/schedules/schedules.service.ts
+++ b/apps/edr-passenger-api/src/modules/schedules/schedules.service.ts
@@ -5,6 +5,7 @@ import { FareEngineService } from '../fare-engine/fare-engine.service';
 import { CreateScheduleDto, UpdateScheduleDto, CreateFareRuleDto, UpdateScheduleStatusDto, UpdateStopTimeDto, ListSchedulesDto, BulkCreateSchedulesDto } from './schedules.dto';
 import { DeleteOperationException } from '../../common/exceptions/delete-operation.exception';
 import { parseEthiopianTime, startOfDayEAT, startOfNextDayEAT } from '../../common/utils/timezone.utils';
+import { AuditService } from '../../common/audit.service';
 
 @Injectable()
 export class SchedulesService {
@@ -12,6 +13,7 @@ export class SchedulesService {
     private prisma: PrismaService,
     private routesService: RoutesService,
     private fareEngine: FareEngineService,
+    private auditService: AuditService,
   ) { }
 
   async bulkGenerateSchedules(dto: BulkCreateSchedulesDto) {
@@ -191,7 +193,9 @@ export class SchedulesService {
       );
     }
 
-    return this.getSchedule(schedule.id);
+    const result = await this.getSchedule(schedule.id);
+    await this.auditService.log({ action: 'CREATE', entityType: 'Schedule', entityId: schedule.id, newData: { trainId: dto.trainId, routeId: dto.routeId, departureAt: dep } });
+    return result;
   }
 
   async getSchedule(id: string) {
@@ -325,10 +329,12 @@ export class SchedulesService {
     const plannedTimesMap = Object.fromEntries(plannedTimes.map(t => [t.sequence, t]));
     await this.routesService.applyRouteToSchedule(dto.routeId, id, plannedTimesMap);
 
-    return this.getSchedule(id);
+    const result = await this.getSchedule(id);
+    await this.auditService.log({ action: 'UPDATE', entityType: 'Schedule', entityId: id, newData: { trainId: dto.trainId, departureAt: dep } });
+    return result;
   }
 
-  updateScheduleStatus(id: string, dto: UpdateScheduleStatusDto) {
+  async updateScheduleStatus(id: string, dto: UpdateScheduleStatusDto) {
     return this.prisma.trainSchedule.update({ where: { id }, data: { status: dto.status } });
   }
 
@@ -409,7 +415,9 @@ export class SchedulesService {
       await this.prisma.packagePriceTier.deleteMany({ where: { packageId: { in: packageIds } } });
       await this.prisma.travelPackage.deleteMany({ where: { id: { in: packageIds } } });
     }
-    return this.prisma.trainSchedule.delete({ where: { id } });
+    await this.prisma.trainSchedule.delete({ where: { id } });
+    await this.auditService.log({ action: 'DELETE', entityType: 'Schedule', entityId: id });
+    return { deleted: true, id };
   }
 
   getStops(scheduleId: string) {
@@ -467,7 +475,7 @@ export class SchedulesService {
 
   createFareRule(dto: CreateFareRuleDto) {
     const { validFrom, validUntil, scheduleId, nationality, passengerCategory, ...rest } = dto;
-    return this.prisma.fareRule.create({
+    const result = this.prisma.fareRule.create({
       data: {
         ...rest,
         tripId: scheduleId,
@@ -477,6 +485,8 @@ export class SchedulesService {
       },
       include: { seatClass: true },
     });
+    result.then(r => this.auditService.log({ action: 'CREATE', entityType: 'FareRule', entityId: r.id, newData: { seatClassId: r.seatClassId, baseFareMinor: r.baseFareMinor } }));
+    return result;
   }
 
   async updateFareRule(id: string, dto: Partial<CreateFareRuleDto>) {
@@ -501,6 +511,7 @@ export class SchedulesService {
     const existing = await this.prisma.fareRule.findUnique({ where: { id } });
     if (!existing) throw new NotFoundException('Fare rule not found');
     await this.prisma.fareRule.delete({ where: { id } });
+    await this.auditService.log({ action: 'DELETE', entityType: 'FareRule', entityId: id });
     return { deleted: true, id };
   }
 
@@ -676,4 +687,66 @@ export class SchedulesService {
     await this.prisma.coachAssignment.delete({ where: { id: assignment.id } });
     return { message: 'Coach assignment removed' };
   }
+
+  // ── Route Fare Rule Overrides ──────────────────────────────────────────────
+
+  listRouteFareRules(routeId: string) {
+    return this.prisma.routeFareRule.findMany({
+      where: { routeId },
+      include: { seatClass: true, route: true },
+      orderBy: { createdAt: 'desc' },
+    });
+  }
+
+  async createRouteFareRule(dto: {
+    routeId: string;
+    seatClassId: string;
+    passengerCategory?: string;
+    baseFareMinor: number;
+    validFrom: string;
+    validUntil?: string;
+  }) {
+    const [route, seatClass] = await Promise.all([
+      this.prisma.route.findUnique({ where: { id: dto.routeId } }),
+      this.prisma.seatClass.findUnique({ where: { id: dto.seatClassId } }),
+    ]);
+    if (!route) throw new NotFoundException('Route not found');
+    if (!seatClass) throw new NotFoundException('Seat class not found');
+    const rule = await this.prisma.routeFareRule.create({
+      data: {
+        routeId: dto.routeId,
+        seatClassId: dto.seatClassId,
+        passengerCategory: (dto.passengerCategory as any) ?? 'ADULT',
+        baseFareMinor: dto.baseFareMinor,
+        validFrom: parseEthiopianTime(dto.validFrom),
+        validUntil: dto.validUntil ? parseEthiopianTime(dto.validUntil) : null,
+      },
+      include: { seatClass: true, route: true },
+    });
+    await this.auditService.log({ action: 'CREATE', entityType: 'RouteFareRule', entityId: rule.id, newData: { routeId: dto.routeId, seatClassId: dto.seatClassId, baseFareMinor: dto.baseFareMinor } });
+    return rule;
+  }
+
+  async updateRouteFareRule(id: string, dto: { baseFareMinor?: number; surchargeMinor?: number; validFrom?: string; validUntil?: string }) {
+    const rule = await this.prisma.routeFareRule.findUnique({ where: { id } });
+    if (!rule) throw new NotFoundException('Route fare rule not found');
+    return this.prisma.routeFareRule.update({
+      where: { id },
+      data: {
+        ...(dto.baseFareMinor !== undefined && { baseFareMinor: dto.baseFareMinor }),
+        ...(dto.surchargeMinor !== undefined && { surchargeMinor: dto.surchargeMinor }),
+        ...(dto.validFrom && { validFrom: parseEthiopianTime(dto.validFrom) }),
+        ...(dto.validUntil !== undefined && { validUntil: dto.validUntil ? parseEthiopianTime(dto.validUntil) : null }),
+      },
+      include: { seatClass: true, route: true },
+    });
+  }
+
+  async deleteRouteFareRule(id: string) {
+    const rule = await this.prisma.routeFareRule.findUnique({ where: { id } });
+    if (!rule) throw new NotFoundException('Route fare rule not found');
+    await this.prisma.routeFareRule.delete({ where: { id } });
+    await this.auditService.log({ action: 'DELETE', entityType: 'RouteFareRule', entityId: id });
+    return { deleted: true, id };
+  }
 }
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 7cbc6d881..9f9fb7bdc 100644
--- a/apps/edr-passenger-api/src/modules/search/search.service.ts
+++ b/apps/edr-passenger-api/src/modules/search/search.service.ts
@@ -398,10 +398,24 @@ export class SearchService {
       this.calculateFaresForSegment(schedule, originStationId, destinationStationId, nationality),
     ]);
 
-    // Compute per-class availability using the pre-computed free seat set
+    // Compute per-class availability using the pre-computed free seat set. A coach type
+    // has separate seat classes per nationality tier (e.g. "VIP Bed Upper (Local)" AND
+    // "VIP Bed Upper (Intl)" on the same coach) — filter to the searching passenger's own
+    // nationality first, otherwise a name-based `.find()` across both tiers would credit
+    // all availability to whichever tier happens to come first in the query result,
+    // leaving the other tier's class permanently at 0 ("Fully booked") even when seats
+    // are actually free. Matched via the class's own bedPosition field (case-insensitive:
+    // Seat.bedPosition is lowercase, SeatClass.bedPosition is uppercase) rather than a
+    // name substring, since that's an exact, unambiguous signal.
+    const nationalityUpper = (nationality ?? '').toUpperCase();
+    const resolvedNationalityType = (nationalityUpper === 'ETHIOPIAN' || nationalityUpper === 'DJIBOUTIAN')
+      ? 'LOCAL' : 'INTERNATIONAL';
+
     const availabilityByClass: Record<string, number> = {};
     for (const assignment of schedule.coachAssignments) {
-      const seatClassNames = assignment.coach.coachType?.seatClasses?.map((sc: any) => sc.name) || ['Standard'];
+      const seatClasses = (assignment.coach.coachType?.seatClasses ?? []).filter(
+        (sc: any) => !sc.nationalityType || sc.nationalityType === resolvedNationalityType,
+      );
       const isBedCoach = assignment.coach.seats.some((s: any) => s.bedPosition);
 
       if (isBedCoach) {
@@ -412,8 +426,8 @@ export class SearchService {
             if (freeSeats.has(seat.id)) count++;
           }
           if (count > 0) {
-            const matchingClass = seatClassNames.find((n: string) => n.toLowerCase().includes(bedPosition));
-            if (matchingClass) availabilityByClass[matchingClass] = (availabilityByClass[matchingClass] ?? 0) + count;
+            const matchingClass = seatClasses.find((sc: any) => sc.bedPosition?.toLowerCase() === bedPosition);
+            if (matchingClass) availabilityByClass[matchingClass.name] = (availabilityByClass[matchingClass.name] ?? 0) + count;
           }
         }
       } else {
@@ -422,11 +436,12 @@ export class SearchService {
           if (seat.status === 'BLOCKED' || !seat.seatNumber?.trim()) continue;
           if (freeSeats.has(seat.id)) available++;
         }
-        for (const name of seatClassNames) availabilityByClass[name] = (availabilityByClass[name] ?? 0) + available;
+        const names = seatClasses.length > 0 ? seatClasses.map((sc: any) => sc.name) : ['Standard'];
+        for (const name of names) availabilityByClass[name] = (availabilityByClass[name] ?? 0) + available;
       }
     }
 
-    const coachTypes   = this.buildCoachTypeDetails(schedule, faresByClass, nationality);
+    const coachTypes   = this.buildCoachTypeDetails(schedule, faresByClass, nationality, availabilityByClass);
     const legDepartureAt = originStop.plannedDepartureAt ?? schedule.departureAt;
     const legArrivalAt   = destStop.plannedArrivalAt   ?? schedule.arrivalAt;
 
@@ -748,12 +763,13 @@ export class SearchService {
     schedule: ScheduleWithIncludes,
     faresByClass: Array<{ seatClassName: string; baseFareMinor: number; displayCurrency: Currency; displayAmountMinor: number }>,
     nationality?: string,
+    availabilityByClass: Record<string, number> = {},
   ): Array<{
     coachTypeId: string;
     coachTypeName: string;
     coachTypeCode: string;
     coachId: string;
-    classes: Array<{ name: string; baseFareMinor: number; displayCurrency: Currency; displayAmountMinor: number }>;
+    classes: Array<{ name: string; baseFareMinor: number; displayCurrency: Currency; displayAmountMinor: number; available: number }>;
   }> {
     const coachTypeMap = new Map<
       string,
@@ -795,9 +811,10 @@ export class SearchService {
             baseFareMinor:      fareInfo.baseFareMinor,
             displayCurrency:    fareInfo.displayCurrency,
             displayAmountMinor: fareInfo.displayAmountMinor,
+            available:          availabilityByClass[className] ?? 0,
           };
         })
-        .filter((c): c is { name: string; baseFareMinor: number; displayCurrency: Currency; displayAmountMinor: number } => c !== null)
+        .filter((c): c is { name: string; baseFareMinor: number; displayCurrency: Currency; displayAmountMinor: number; available: number } => c !== null)
         .sort((a, b) => a.baseFareMinor - b.baseFareMinor);
 
       if (classes.length === 0) continue;
diff --git a/apps/edr-passenger-api/src/modules/seat-classes/seat-classes.controller.ts b/apps/edr-passenger-api/src/modules/seat-classes/seat-classes.controller.ts
index 4eb6c212b..5b75d4b3b 100644
--- a/apps/edr-passenger-api/src/modules/seat-classes/seat-classes.controller.ts
+++ b/apps/edr-passenger-api/src/modules/seat-classes/seat-classes.controller.ts
@@ -1,10 +1,10 @@
-import { Body, Controller, Delete, Get, Param, Patch, Post, UseGuards } from '@nestjs/common';
+import { Body, Controller, Delete, Get, Param, Patch, Post, Query } from '@nestjs/common';
 import { ApiTags, ApiOperation, ApiBearerAuth, ApiParam, ApiResponse, ApiBody } from '@nestjs/swagger';
 import { IsPublic } from '@tria-plc/api-common/modules/auth/decorators/public.decorator';
 import { SeatClassesService } from './seat-classes.service';
 import { CreateSeatClassDto, UpdateSeatClassDto } from './seat-classes.dto';
-import { JwtGuard } from '../../common/jwt.guard';
-import { PassengerAdmin } from '../../common/passenger-guards';
+import { PassengerAdmin, PassengerStaff } from '../../common/passenger-guards';
+import { PASSENGER_PERMS } from '../../seed/passenger-permissions.registry';
 
 @ApiTags('Seat Classes')
 @Controller('seat-classes')
@@ -26,7 +26,7 @@ export class SeatClassesController {
   getSeatClass(@Param('id') id: string) { return this.service.getSeatClass(id); }
 
   @Post()
-  @UseGuards(JwtGuard) @ApiBearerAuth('JWT-auth')
+  @PassengerStaff([PASSENGER_PERMS.tariffRates.manage, PASSENGER_PERMS.admin]) @ApiBearerAuth('IAM-auth')
   @ApiOperation({ summary: 'Create a seat class' })
   @ApiBody({ type: CreateSeatClassDto })
   @ApiResponse({ status: 201, description: 'Seat class created' })
@@ -34,7 +34,7 @@ export class SeatClassesController {
   createSeatClass(@Body() dto: CreateSeatClassDto) { return this.service.createSeatClass(dto); }
 
   @Patch(':id')
-  @UseGuards(JwtGuard) @ApiBearerAuth('JWT-auth')
+  @PassengerStaff([PASSENGER_PERMS.tariffRates.manage, PASSENGER_PERMS.admin]) @ApiBearerAuth('IAM-auth')
   @ApiOperation({ summary: 'Update a seat class' })
   @ApiParam({ name: 'id', description: 'Seat class UUID' })
   @ApiBody({ type: UpdateSeatClassDto })
@@ -49,5 +49,7 @@ export class SeatClassesController {
   @ApiParam({ name: 'id', description: 'Seat class UUID' })
   @ApiResponse({ status: 200, description: 'Seat class deleted' })
   @ApiResponse({ status: 404, description: 'Seat class not found' })
-  deleteSeatClass(@Param('id') id: string) { return this.service.deleteSeatClass(id); }
+  deleteSeatClass(@Param('id') id: string, @Query('cascade') cascade?: string) {
+    return this.service.deleteSeatClass(id, cascade === 'true');
+  }
 }
diff --git a/apps/edr-passenger-api/src/modules/seat-classes/seat-classes.module.ts b/apps/edr-passenger-api/src/modules/seat-classes/seat-classes.module.ts
index a7e8648e1..1882bd577 100644
--- a/apps/edr-passenger-api/src/modules/seat-classes/seat-classes.module.ts
+++ b/apps/edr-passenger-api/src/modules/seat-classes/seat-classes.module.ts
@@ -1,6 +1,7 @@
 import { Module } from '@nestjs/common';
 import { SeatClassesController } from './seat-classes.controller';
 import { SeatClassesService } from './seat-classes.service';
+import { AuditModule } from '../../common/audit.module';
 
-@Module({ controllers: [SeatClassesController], providers: [SeatClassesService], exports: [SeatClassesService] })
+@Module({ imports: [AuditModule], controllers: [SeatClassesController], providers: [SeatClassesService], exports: [SeatClassesService] })
 export class SeatClassesModule {}
diff --git a/apps/edr-passenger-api/src/modules/seat-classes/seat-classes.service.ts b/apps/edr-passenger-api/src/modules/seat-classes/seat-classes.service.ts
index 63f5e1f29..f33ecac64 100644
--- a/apps/edr-passenger-api/src/modules/seat-classes/seat-classes.service.ts
+++ b/apps/edr-passenger-api/src/modules/seat-classes/seat-classes.service.ts
@@ -1,10 +1,11 @@
 import { Injectable, NotFoundException, ConflictException } from '@nestjs/common';
 import { PrismaService } from '../../common/prisma.service';
 import { DeleteOperationException } from '../../common/exceptions/delete-operation.exception';
+import { AuditService } from '../../common/audit.service';
 
 @Injectable()
 export class SeatClassesService {
-  constructor(private prisma: PrismaService) {}
+  constructor(private prisma: PrismaService, private auditService: AuditService) {}
 
   listSeatClasses() {
     return this.prisma.seatClass.findMany({
@@ -28,7 +29,9 @@ export class SeatClassesService {
       ...rest,
       ...(basePrice !== undefined && { baseFareMinor: basePrice }),
     };
-    return this.prisma.seatClass.update({ where: { id }, data });
+    const updated = await this.prisma.seatClass.update({ where: { id }, data });
+    await this.auditService.log({ action: 'UPDATE', entityType: 'SeatClass', entityId: id, newData: { name: updated.name } });
+    return updated;
   }
 
   async createSeatClass(dto: any) {
@@ -38,14 +41,16 @@ export class SeatClassesService {
         ...rest,
         ...(basePrice !== undefined && { baseFareMinor: basePrice }),
       };
-      return await this.prisma.seatClass.create({ data });
+      const sc = await this.prisma.seatClass.create({ data });
+      await this.auditService.log({ action: 'CREATE', entityType: 'SeatClass', entityId: sc.id, newData: { name: sc.name } });
+      return sc;
     } catch (e: any) {
       if (e.code === 'P2002') throw new ConflictException(`Seat class "${dto.name}" already exists`);
       throw e;
     }
   }
 
-  async deleteSeatClass(id: string) {
+  async deleteSeatClass(id: string, cascade = false) {
     const sc = await this.prisma.seatClass.findUnique({
       where: { id },
       include: {
@@ -59,11 +64,19 @@ export class SeatClassesService {
       (sc as any)._count.routeFareRules +
       (sc as any)._count.segmentFares;
 
-    if (totalFareRules > 0)
+    if (totalFareRules > 0 && !cascade)
       throw new DeleteOperationException('Seat Class', sc.name, [
         { entityName: 'fare rule', count: totalFareRules, action: 'delete' },
       ]);
 
-    return this.prisma.seatClass.delete({ where: { id } });
+    if (cascade) {
+      await this.prisma.fareRule.deleteMany({ where: { seatClassId: id } });
+      await this.prisma.routeFareRule.deleteMany({ where: { seatClassId: id } });
+      await this.prisma.segmentFareRule.deleteMany({ where: { seatClassId: id } });
+    }
+
+    const deleted = await this.prisma.seatClass.delete({ where: { id } });
+    await this.auditService.log({ action: 'DELETE', entityType: 'SeatClass', entityId: id, oldData: { name: sc.name } });
+    return deleted;
   }
 }
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 fa233f45c..752b66390 100644
--- a/apps/edr-passenger-api/src/modules/seats/seats.controller.ts
+++ b/apps/edr-passenger-api/src/modules/seats/seats.controller.ts
@@ -21,7 +21,8 @@ import {
 import { SeatsService } from "./seats.service";
 import { HoldSeatsDto, ReleaseHoldDto } from "./seats.dto";
 import { JwtGuard } from "../../common/jwt.guard";
-import { IamGuard } from "../../common/iam-adapter";
+import { PassengerStaff } from "../../common/passenger-guards";
+import { PASSENGER_PERMS } from "../../seed/passenger-permissions.registry";
 
 @ApiTags("Seats")
 @Controller("seats")
@@ -205,7 +206,7 @@ This makes it clear which segment of the route each seat is held for, enabling s
 
   // ── Seat Block / Unblock ───────────────────────────────────────────────────
   @Post(":seatId/block")
-  @UseGuards(IamGuard)
+  @PassengerStaff([PASSENGER_PERMS.seats.manage, PASSENGER_PERMS.admin])
   @ApiBearerAuth("IAM-auth")
   @ApiOperation({ summary: "Block a seat (e.g., maintenance, damage)" })
   @ApiParam({ name: "seatId", description: "Seat UUID" })
@@ -215,7 +216,7 @@ This makes it clear which segment of the route each seat is held for, enabling s
   }
 
   @Delete(":seatId/block")
-  @UseGuards(IamGuard)
+  @PassengerStaff([PASSENGER_PERMS.seats.manage, PASSENGER_PERMS.admin])
   @ApiBearerAuth("IAM-auth")
   @ApiOperation({ summary: "Unblock a seat" })
   @ApiParam({ name: "seatId", description: "Seat UUID" })
@@ -226,7 +227,7 @@ This makes it clear which segment of the route each seat is held for, enabling s
 
   // ── Maintenance ───────────────────────────────────────────────────────────
   @Post(":seatId/maintenance")
-  @UseGuards(IamGuard)
+  @PassengerStaff([PASSENGER_PERMS.seats.manage, PASSENGER_PERMS.admin])
   @ApiBearerAuth("IAM-auth")
   @ApiOperation({ summary: "Set seat status to Under Maintenance" })
   @ApiParam({ name: "seatId", description: "Seat UUID" })
@@ -236,7 +237,7 @@ This makes it clear which segment of the route each seat is held for, enabling s
   }
 
   @Delete(":seatId/maintenance")
-  @UseGuards(IamGuard)
+  @PassengerStaff([PASSENGER_PERMS.seats.manage, PASSENGER_PERMS.admin])
   @ApiBearerAuth("IAM-auth")
   @ApiOperation({ summary: "Clear seat maintenance status" })
   @ApiParam({ name: "seatId", description: "Seat UUID" })
@@ -247,7 +248,7 @@ This makes it clear which segment of the route each seat is held for, enabling s
 
   // ── Remove Seat ────────────────────────────────────────────────────────────
   @Patch(":seatId/remove")
-  @UseGuards(IamGuard)
+  @PassengerStaff([PASSENGER_PERMS.seats.manage, PASSENGER_PERMS.admin])
   @ApiBearerAuth("IAM-auth")
   @ApiOperation({
     summary: "Remove a seat by marking with negative seatNumber",
@@ -263,7 +264,7 @@ This makes it clear which segment of the route each seat is held for, enabling s
   }
 
   @Patch(":seatId/undo-remove")
-  @UseGuards(IamGuard)
+  @PassengerStaff([PASSENGER_PERMS.seats.manage, PASSENGER_PERMS.admin])
   @ApiBearerAuth("IAM-auth")
   @ApiOperation({
     summary: "Undo seat removal by restoring original seatNumber",
diff --git a/apps/edr-passenger-api/src/modules/seats/seats.module.ts b/apps/edr-passenger-api/src/modules/seats/seats.module.ts
index 425f517c6..0725f4393 100644
--- a/apps/edr-passenger-api/src/modules/seats/seats.module.ts
+++ b/apps/edr-passenger-api/src/modules/seats/seats.module.ts
@@ -4,9 +4,10 @@ import { SeatsController } from './seats.controller';
 import { SeatsService } from './seats.service';
 import { SegmentsModule } from '../segments/segments.module';
 import { SystemConfigModule } from '../system-config/system-config.module';
+import { AuditModule } from '../../common/audit.module';
 
 @Module({
-  imports: [SegmentsModule, HttpModule, SystemConfigModule],
+  imports: [SegmentsModule, HttpModule, SystemConfigModule, AuditModule],
   controllers: [SeatsController],
   providers: [SeatsService],
   exports: [SeatsService],
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 3d485d22c..ad92660a4 100644
--- a/apps/edr-passenger-api/src/modules/seats/seats.service.ts
+++ b/apps/edr-passenger-api/src/modules/seats/seats.service.ts
@@ -4,6 +4,7 @@ import { HoldSeatsDto, JourneyDirection } from './seats.dto';
 import { Cron, CronExpression } from '@nestjs/schedule';
 import { SegmentsService } from '../segments/segments.service';
 import { SystemConfigService, CONFIG_KEYS } from '../system-config/system-config.service';
+import { AuditService } from '../../common/audit.service';
 
 @Injectable()
 export class SeatsService {
@@ -11,6 +12,7 @@ export class SeatsService {
     private prisma: PrismaService,
     private segmentsService: SegmentsService,
     private systemConfig: SystemConfigService,
+    private auditService: AuditService,
   ) {}
 
   async getSeatMap(scheduleId: string, coachTypeId?: string, journeyDirection?: JourneyDirection, originStationId?: string, destinationStationId?: string) {
@@ -803,7 +805,7 @@ export class SeatsService {
 
     await this.prisma.seat.update({ where: { id: seatId }, data: { status: 'BLOCKED' } });
     await this.prisma.seatBlock.create({ data: { seatId, reason, blockedBy: 'system' } });
-
+    await this.auditService.log({ action: 'UPDATE', entityType: 'Seat', entityId: seatId, newData: { status: 'BLOCKED', reason } });
     return { blocked: true, seatId, reason };
   }
 
@@ -813,7 +815,7 @@ export class SeatsService {
 
     await this.prisma.seat.update({ where: { id: seatId }, data: { status: 'AVAILABLE' } });
     await this.prisma.seatBlock.deleteMany({ where: { seatId } });
-
+    await this.auditService.log({ action: 'UPDATE', entityType: 'Seat', entityId: seatId, newData: { status: 'AVAILABLE' } });
     return { unblocked: true, seatId };
   }
 
@@ -846,7 +848,7 @@ export class SeatsService {
     });
 
     await this.renumberCoachSeats(seat.coachId);
-
+    await this.auditService.log({ action: 'DELETE', entityType: 'Seat', entityId: seatId, oldData: { seatNumber: seat.seatNumber, coachId: seat.coachId } });
     return { removed: true, seatId, originalSeatNumber: seat.seatNumber };
   }
 
diff --git a/apps/edr-passenger-api/src/modules/stations/stations.controller.ts b/apps/edr-passenger-api/src/modules/stations/stations.controller.ts
index 0f367043b..5ddd64383 100644
--- a/apps/edr-passenger-api/src/modules/stations/stations.controller.ts
+++ b/apps/edr-passenger-api/src/modules/stations/stations.controller.ts
@@ -1,10 +1,10 @@
-import { Body, Controller, Get, Param, Post, Patch, Delete, UseGuards, Query } from '@nestjs/common';
+import { Body, Controller, Get, Param, Post, Patch, Delete, Query } from '@nestjs/common';
 import { ApiTags, ApiOperation, ApiBearerAuth, ApiQuery, ApiResponse } from '@nestjs/swagger';
 import { IsPublic } from '@tria-plc/api-common/modules/auth/decorators/public.decorator';
 import { StationsService } from './stations.service';
 import { CreateStationDto } from './stations.dto';
-import { JwtGuard } from '../../common/jwt.guard';
-import { PassengerAdmin } from '../../common/passenger-guards';
+import { PassengerAdmin, PassengerStaff } from '../../common/passenger-guards';
+import { PASSENGER_PERMS } from '../../seed/passenger-permissions.registry';
 
 @ApiTags('Stations')
 @Controller('stations')
@@ -79,8 +79,8 @@ export class StationsController {
   findOne(@Param('id') id: string) { return this.service.findOne(id); }
   
   @Post()
-  @UseGuards(JwtGuard)
-  @ApiBearerAuth('JWT-auth')
+  @PassengerStaff([PASSENGER_PERMS.stations.manage, PASSENGER_PERMS.admin])
+  @ApiBearerAuth('IAM-auth')
   @ApiOperation({ summary: 'Create new station' })
   @ApiResponse({
     status: 201,
@@ -105,8 +105,8 @@ export class StationsController {
   create(@Body() dto: CreateStationDto) { return this.service.create(dto); }
 
   @Patch(':id')
-  @UseGuards(JwtGuard)
-  @ApiBearerAuth('JWT-auth')
+  @PassengerStaff([PASSENGER_PERMS.stations.manage, PASSENGER_PERMS.admin])
+  @ApiBearerAuth('IAM-auth')
   @ApiOperation({ summary: 'Update station' })
   @ApiResponse({
     status: 200,
diff --git a/apps/edr-passenger-api/src/modules/tickets/tickets.module.ts b/apps/edr-passenger-api/src/modules/tickets/tickets.module.ts
index 1ccc2e392..2056d4eda 100644
--- a/apps/edr-passenger-api/src/modules/tickets/tickets.module.ts
+++ b/apps/edr-passenger-api/src/modules/tickets/tickets.module.ts
@@ -4,9 +4,10 @@ import { TicketsService } from './tickets.service';
 import { JwtGuard } from '../../common/jwt.guard';
 import { NotificationsModule } from '../notifications/notifications.module';
 import { SystemConfigModule } from '../system-config/system-config.module';
+import { AuditModule } from '../../common/audit.module';
 
 @Module({
-  imports: [NotificationsModule, SystemConfigModule],
+  imports: [NotificationsModule, SystemConfigModule, AuditModule],
   controllers: [TicketsController],
   providers: [TicketsService, JwtGuard],
   exports: [TicketsService, JwtGuard],
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 656e726ab..648b43cad 100644
--- a/apps/edr-passenger-api/src/modules/tickets/tickets.service.ts
+++ b/apps/edr-passenger-api/src/modules/tickets/tickets.service.ts
@@ -4,6 +4,7 @@ import { DataSource } from 'typeorm';
 import { PrismaService } from '../../common/prisma.service';
 import { NotificationsService } from '../notifications/notifications.service';
 import { SystemConfigService, CONFIG_KEYS } from '../system-config/system-config.service';
+import { AuditService } from '../../common/audit.service';
 import * as QRCode from 'qrcode';
 
 interface OfflineValidation {
@@ -22,6 +23,7 @@ export class TicketsService {
     private readonly prisma: PrismaService,
     private readonly notifications: NotificationsService,
     private readonly systemConfig: SystemConfigService,
+    private readonly auditService: AuditService,
     @InjectDataSource() private readonly dataSource: DataSource,
   ) {}
 
@@ -229,7 +231,6 @@ export class TicketsService {
       }
     }
 
-    // Delete existing tickets if any
     await this.prisma.ticket.deleteMany({ where: { bookingId } });
 
     // Generate one ticket per unique passenger (grouped by passengerName)
@@ -291,6 +292,7 @@ export class TicketsService {
       }).catch(() => null);
     }
 
+    await this.auditService.log({ action: 'CREATE', entityType: 'Ticket', entityId: booking.id, newData: { bookingRef: booking.bookingRef, totalTickets: tickets.length } });
     return { tickets, totalTickets: tickets.length };
   }
 
@@ -557,6 +559,7 @@ export class TicketsService {
       await this.prisma.ticket.update({ where: { id: ticket.id }, data: { validatedAt: now, validatorId: resolvedValidatorId } });
       await this.prisma.gateValidationLog.create({ data: { ticketId: ticket.id, validatorId: resolvedValidatorId, gateId, status: 'APPROVED' } });
       this.fireBoardingPassNotification(booking, ticket, null);
+      await this.auditService.log({ action: 'VERIFY', entityType: 'Ticket', entityId: ticket.id, newData: { bookingRef, validatorId: resolvedValidatorId, leg: 'ONE_WAY' } });
       return { validated: true, ticketId: ticket.id, validatedAt: now };
     }
 
@@ -575,6 +578,7 @@ export class TicketsService {
       if (!ticket.validatedAt) await this.prisma.ticket.update({ where: { id: ticket.id }, data: { validatedAt: now, validatorId: resolvedValidatorId } });
       await this.prisma.gateValidationLog.create({ data: { ticketId: ticket.id, validatorId: resolvedValidatorId, gateId, leg: resolvedLeg, status: 'APPROVED' } as any });
       this.fireBoardingPassNotification(booking, ticket, resolvedLeg);
+      await this.auditService.log({ action: 'VERIFY', entityType: 'Ticket', entityId: ticket.id, newData: { bookingRef, validatorId: resolvedValidatorId, leg: resolvedLeg } });
       return { validated: true, ticketId: ticket.id, leg: resolvedLeg, validatedAt: now };
     }
 
@@ -608,6 +612,7 @@ export class TicketsService {
       }
       await this.prisma.gateValidationLog.create({ data: { ticketId: ticket.id, validatorId: resolvedValidatorId, gateId, leg: resolvedLeg, status: 'APPROVED' } as any });
       this.fireBoardingPassNotification(booking, ticket, resolvedLeg);
+      await this.auditService.log({ action: 'VERIFY', entityType: 'Ticket', entityId: ticket.id, newData: { bookingRef, validatorId: resolvedValidatorId, leg: resolvedLeg } });
       return { validated: true, ticketId: ticket.id, leg: resolvedLeg, validatedAt: now };
     }
 
diff --git a/apps/edr-passenger-api/src/modules/verifayda/verifayda.controller.ts b/apps/edr-passenger-api/src/modules/verifayda/verifayda.controller.ts
index 13de29616..4fd37f8a6 100644
--- a/apps/edr-passenger-api/src/modules/verifayda/verifayda.controller.ts
+++ b/apps/edr-passenger-api/src/modules/verifayda/verifayda.controller.ts
@@ -2,6 +2,7 @@ import {
   Body,
   Controller,
   Get,
+  Headers,
   HttpCode,
   HttpStatus,
   Post,
@@ -19,6 +20,7 @@ import type { TCurrentUser } from "@tria-plc/api-common/modules/auth/types/curre
 import { IsPublic } from "@tria-plc/api-common/modules/auth/decorators/public.decorator";
 import { JwtGuard } from "../../common/jwt.guard";
 import { OptionalJwtGuard } from "./optional-jwt.guard";
+import { resolveAllowedOrigin } from "../../common/utils/redirect-origin.util";
 import {
   CompleteVerificationResultDto,
   StartVerificationDto,
@@ -68,12 +70,20 @@ export class VerifaydaController {
   async start(
     @Body() dto: StartVerificationDto,
     @Req() req: RequestWithOptionalUser,
+    @Headers("origin") origin?: string,
+    @Headers("referer") referer?: string,
+    @Headers("x-frontend-base-url") frontendBaseUrl?: string,
   ): Promise<{ authorizationUrl: string }> {
     const authorizationUrl = await this.service.startVerification({
       purpose: dto.purpose ?? "VERIFY",
       platform: dto.platform ?? "WEB",
       userId: req.user?.id,
       wantsPasswordSetup: dto.wantsPasswordSetup ?? false,
+      // WEB redirect_uri host follows the domain the user is on — Origin, then
+      // Referer, then the X-Frontend-Base-URL header — validated against the
+      // allowlist. Both domain variants must be registered with eSignet or the
+      // login is rejected.
+      requestOrigin: resolveAllowedOrigin(origin, referer, frontendBaseUrl),
     });
     return { authorizationUrl };
   }
diff --git a/apps/edr-passenger-api/src/modules/verifayda/verifayda.service.ts b/apps/edr-passenger-api/src/modules/verifayda/verifayda.service.ts
index 99b1d1d7c..89edf25a6 100644
--- a/apps/edr-passenger-api/src/modules/verifayda/verifayda.service.ts
+++ b/apps/edr-passenger-api/src/modules/verifayda/verifayda.service.ts
@@ -18,6 +18,7 @@ import {
   generateState,
 } from './utils/pkce.util';
 import { generateClientAssertion } from './utils/client-assertion.util';
+import { rebaseUrlOrigin } from '../../common/utils/redirect-origin.util';
 import { VerifaydaCallbackDto, VerificationStatusDto } from './verifayda.dto';
 import {
   FaydaTokenExchangeException,
@@ -49,6 +50,13 @@ export interface StartVerificationInput {
   platform?: FaydaPlatform;
   userId?: string;   // iamUserId of the authenticated user, if any
   wantsPasswordSetup?: boolean;
+  /**
+   * Allowlisted browser origin the request came from (e.g. https://bookingedr.et
+   * or https://passenger.edrsc.com), already validated by the controller. For
+   * WEB sessions the eSignet redirect_uri host is swapped to this so the user
+   * lands back on the same domain. Null/undefined keeps the configured default.
+   */
+  requestOrigin?: string | null;
 }
 
 export interface FaydaUserSummary {
@@ -145,12 +153,26 @@ export class VerifaydaService {
       Date.now() + this.faydaConfig.sessionTtlMinutes * 60_000,
     );
 
+    const platform = input.platform ?? 'WEB';
+    // WEB sessions follow the domain the user came in on (bookingedr.et vs
+    // passenger.edrsc.com); MOBILE always uses the native base redirect_uri.
+    // Persist the exact URI so token exchange at /complete reuses it verbatim —
+    // eSignet requires the redirect_uri to match between authorize and token.
+    const redirectUri =
+      platform === 'MOBILE'
+        ? this.redirectUriForPlatform('MOBILE')
+        : rebaseUrlOrigin(
+            this.faydaConfig.webRedirectUri,
+            input.requestOrigin ?? null,
+          ) ?? this.faydaConfig.webRedirectUri;
+
     await this.prisma.faydaVerificationSession.create({
       data: {
         state,
         codeVerifier,
         purpose: input.purpose,
-        platform: input.platform ?? 'WEB',
+        platform,
+        redirectUri,
         saveToAccount: input.wantsPasswordSetup ?? false,
         iamUserId: input.userId ?? null,
         expiresAt,
@@ -158,13 +180,13 @@ export class VerifaydaService {
     });
 
     this.logger.log(
-      `Fayda verification started: purpose=${input.purpose} platform=${input.platform ?? 'WEB'} userId=${input.userId ?? 'none'}`,
+      `Fayda verification started: purpose=${input.purpose} platform=${platform} userId=${input.userId ?? 'none'} redirectUri=${redirectUri}`,
     );
 
     return this.buildAuthorizationUrl({
       state,
       codeChallenge,
-      redirectUri: this.redirectUriForPlatform(input.platform ?? 'WEB'),
+      redirectUri,
     });
   }
 
@@ -224,7 +246,11 @@ export class VerifaydaService {
       const tokens = await this.exchangeCodeForTokens(
         query.code,
         session.codeVerifier,
-        this.redirectUriForPlatform(session.platform as FaydaPlatform),
+        // Reuse the exact redirect_uri sent at authorize (persisted on the
+        // session). Fall back to the platform default for sessions created
+        // before this column existed.
+        session.redirectUri ??
+          this.redirectUriForPlatform(session.platform as FaydaPlatform),
       );
       const userInfo = await this.fetchUserInfo(tokens.access_token);
       const normalized = this.normalizeUserInfo(userInfo);
diff --git a/apps/edr-passenger-api/src/seed/edr-passenger.seed.ts b/apps/edr-passenger-api/src/seed/edr-passenger.seed.ts
index 578cf66ff..4313d5426 100644
--- a/apps/edr-passenger-api/src/seed/edr-passenger.seed.ts
+++ b/apps/edr-passenger-api/src/seed/edr-passenger.seed.ts
@@ -54,4 +54,19 @@ export const EDR_PASSENGER_ROLES: PassengerSeedRole[] = [
     name: { en: 'EDR Passenger Finance' },
     permissionKeys: [...ROLE_PERMISSION_PRESETS.finance],
   },
+  {
+    key: 'edr_passenger_operations_manager',
+    name: { en: 'EDR Passenger Operations Manager' },
+    permissionKeys: [...ROLE_PERMISSION_PRESETS.operationsManager],
+  },
+  {
+    key: 'edr_passenger_marketing_manager',
+    name: { en: 'EDR Passenger Marketing Manager' },
+    permissionKeys: [...ROLE_PERMISSION_PRESETS.marketingManager],
+  },
+  {
+    key: 'edr_passenger_finance_manager',
+    name: { en: 'EDR Passenger Finance Manager' },
+    permissionKeys: [...ROLE_PERMISSION_PRESETS.financeManager],
+  },
 ];
diff --git a/apps/edr-passenger-api/src/seed/passenger-permissions.registry.ts b/apps/edr-passenger-api/src/seed/passenger-permissions.registry.ts
index bab7787b9..d62d5a261 100644
--- a/apps/edr-passenger-api/src/seed/passenger-permissions.registry.ts
+++ b/apps/edr-passenger-api/src/seed/passenger-permissions.registry.ts
@@ -34,6 +34,38 @@ export const PASSENGER_PERMISSIONS: PassengerPermissionSeed[] = [
   perm('75b5ff62-a8e4-4331-b6e6-d53e1456d10e', 'edr_passenger_app:currencies:manage',         'Manage currencies'),
   perm('4a47da9b-cf6e-4240-aff8-aadf01641c54', 'edr_passenger_app:notifications:send',        'Send notifications'),
   perm('bfe3428f-8b85-4a36-87c6-33063b084bf3', 'edr_passenger_app:dashboard:view',            'View dashboard'),
+
+  // ── Master Data ────────────────────────────────────────────────────────────
+  perm('102969bc-13a2-4f4a-aa7f-ce4b2599ce82', 'edr_passenger_app:stations:view',             'View stations'),
+  perm('931cf6fc-8f41-46b6-82b8-b242f75d296e', 'edr_passenger_app:stations:manage',           'Manage stations'),
+  perm('82a801b3-2451-409b-99e8-9f4d3515d329', 'edr_passenger_app:trains:view',               'View trains'),
+  perm('e2a7f842-7691-4007-bd71-fd91c467044d', 'edr_passenger_app:trains:manage',             'Manage trains'),
+  perm('71de593c-ae4a-4d15-9f0a-b889eeb4910c', 'edr_passenger_app:coaches:view',              'View coaches'),
+  perm('39b3de2e-c779-4010-8ef3-d478f00a15c6', 'edr_passenger_app:coaches:manage',            'Manage coaches'),
+  perm('ba0fdd0b-6580-48a8-b31f-eb5ef76a2453', 'edr_passenger_app:seats:view',                'View seats'),
+  perm('6fb9affb-1885-446e-a8e4-962af9fae33f', 'edr_passenger_app:seats:manage',              'Manage seats'),
+  perm('b7b659d9-f453-41d3-a6db-72e671446214', 'edr_passenger_app:classes:view',              'View classes'),
+  perm('b2d06665-33f5-46d7-a895-785b5fb1896a', 'edr_passenger_app:classes:manage',            'Manage classes'),
+  perm('8731ee98-24c2-4f8b-9c06-cf3fa900a95a', 'edr_passenger_app:routes:view',               'View routes'),
+  perm('5851233c-78de-45b9-9d3f-63816d068622', 'edr_passenger_app:routes:manage',             'Manage routes'),
+  perm('c453bdf9-496a-4ac8-b733-8eb5dd5d591a', 'edr_passenger_app:schedules:view',            'View schedules'),
+  perm('d3f3cfd0-c7ce-47ab-be7f-bf3d6b40e488', 'edr_passenger_app:schedules:manage',          'Manage schedules'),
+
+  // ── Tourism ────────────────────────────────────────────────────────────────
+  perm('d78d810b-3003-4d81-92d5-41c437f3cc42', 'edr_passenger_app:packages:view',             'View packages'),
+  perm('dcfab0d9-1f80-4822-892a-e2851b549297', 'edr_passenger_app:packages:manage',           'Manage packages'),
+  perm('6d7ab68c-1b88-405d-9f92-b130055eece6', 'edr_passenger_app:inquiries:view',            'View package inquiries'),
+  perm('dbe5a07a-d12f-4a36-b191-0bb4f980054e', 'edr_passenger_app:inquiries:manage',          'Manage package inquiries'),
+
+  // ── Finance ────────────────────────────────────────────────────────────────
+  perm('4b6efd87-f230-4109-abe1-593e53cb0c10', 'edr_passenger_app:tariff_rates:view',         'View tariff rates'),
+  perm('94f17a59-397c-4c9c-a424-38a9c66c9e50', 'edr_passenger_app:tariff_rates:manage',       'Manage tariff rates'),
+  perm('2dc4eb75-5b28-4ead-a2d4-82ac95cd290c', 'edr_passenger_app:payments:view',             'View payments'),
+  perm('418b5f64-656b-4d44-a543-930ada9ec1a7', 'edr_passenger_app:payments:manage',           'Manage payments'),
+  perm('3f3d5479-af33-4883-867e-aae9e2aeeeca', 'edr_passenger_app:currencies:view',           'View currencies'),
+  perm('b4e63290-cc3a-4df8-9f2a-9ff726e86e36', 'edr_passenger_app:payment_methods:view',      'View payment methods'),
+  perm('f9fb6af2-e869-4e6e-938c-259643393315', 'edr_passenger_app:payment_methods:manage',    'Manage payment methods'),
+
   perm('49fd28cd-5b58-4403-8e53-1df4b93cbbd2', 'edr_passenger_app:admin',                     'Full admin access'),
 ];
 
@@ -54,10 +86,57 @@ export const PASSENGER_PERMS = {
     manage: 'edr_passenger_app:tickets:manage',
   },
   payments: {
+    view:           'edr_passenger_app:payments:view',
+    manage:         'edr_passenger_app:payments:manage',
+    // legacy keys — retained as aliases for backward compatibility
     viewAll:        'edr_passenger_app:payments:view_all',
     refund:         'edr_passenger_app:payments:refund',
     manageMethods:  'edr_passenger_app:payments:manage_methods',
   },
+  paymentMethods: {
+    view:   'edr_passenger_app:payment_methods:view',
+    manage: 'edr_passenger_app:payment_methods:manage',
+  },
+  stations: {
+    view:   'edr_passenger_app:stations:view',
+    manage: 'edr_passenger_app:stations:manage',
+  },
+  trains: {
+    view:   'edr_passenger_app:trains:view',
+    manage: 'edr_passenger_app:trains:manage',
+  },
+  coaches: {
+    view:   'edr_passenger_app:coaches:view',
+    manage: 'edr_passenger_app:coaches:manage',
+  },
+  seats: {
+    view:   'edr_passenger_app:seats:view',
+    manage: 'edr_passenger_app:seats:manage',
+  },
+  classes: {
+    view:   'edr_passenger_app:classes:view',
+    manage: 'edr_passenger_app:classes:manage',
+  },
+  routes: {
+    view:   'edr_passenger_app:routes:view',
+    manage: 'edr_passenger_app:routes:manage',
+  },
+  schedules: {
+    view:   'edr_passenger_app:schedules:view',
+    manage: 'edr_passenger_app:schedules:manage',
+  },
+  packages: {
+    view:   'edr_passenger_app:packages:view',
+    manage: 'edr_passenger_app:packages:manage',
+  },
+  inquiries: {
+    view:   'edr_passenger_app:inquiries:view',
+    manage: 'edr_passenger_app:inquiries:manage',
+  },
+  tariffRates: {
+    view:   'edr_passenger_app:tariff_rates:view',
+    manage: 'edr_passenger_app:tariff_rates:manage',
+  },
   reports: {
     view: 'edr_passenger_app:reports:view',
   },
@@ -73,6 +152,7 @@ export const PASSENGER_PERMS = {
     manage: 'edr_passenger_app:agents:manage',
   },
   currencies: {
+    view:   'edr_passenger_app:currencies:view',
     manage: 'edr_passenger_app:currencies:manage',
   },
   notifications: {
@@ -126,9 +206,36 @@ export const ROLE_PERMISSION_PRESETS = {
   ],
 
   finance: [
+    PASSENGER_PERMS.payments.view,
     PASSENGER_PERMS.payments.viewAll,
     PASSENGER_PERMS.payments.refund,
     PASSENGER_PERMS.reports.view,
     PASSENGER_PERMS.dashboard.view,
   ],
+
+  operationsManager: [
+    PASSENGER_PERMS.stations.view,   PASSENGER_PERMS.stations.manage,
+    PASSENGER_PERMS.trains.view,     PASSENGER_PERMS.trains.manage,
+    PASSENGER_PERMS.coaches.view,    PASSENGER_PERMS.coaches.manage,
+    PASSENGER_PERMS.seats.view,      PASSENGER_PERMS.seats.manage,
+    PASSENGER_PERMS.classes.view,    PASSENGER_PERMS.classes.manage,
+    PASSENGER_PERMS.routes.view,     PASSENGER_PERMS.routes.manage,
+    PASSENGER_PERMS.schedules.view,  PASSENGER_PERMS.schedules.manage,
+    PASSENGER_PERMS.dashboard.view,
+  ],
+
+  marketingManager: [
+    PASSENGER_PERMS.packages.view,   PASSENGER_PERMS.packages.manage,
+    PASSENGER_PERMS.inquiries.view,  PASSENGER_PERMS.inquiries.manage,
+    PASSENGER_PERMS.dashboard.view,
+  ],
+
+  financeManager: [
+    PASSENGER_PERMS.tariffRates.view,      PASSENGER_PERMS.tariffRates.manage,
+    PASSENGER_PERMS.payments.view,         PASSENGER_PERMS.payments.manage,
+    PASSENGER_PERMS.currencies.view,       PASSENGER_PERMS.currencies.manage,
+    PASSENGER_PERMS.paymentMethods.view,   PASSENGER_PERMS.paymentMethods.manage,
+    PASSENGER_PERMS.reports.view,
+    PASSENGER_PERMS.dashboard.view,
+  ],
 } as const;
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 4ab5cb9b7..1a80a2aef 100644
--- a/apps/edr-passenger-web/backoffice/src/app/bookings/page.tsx
+++ b/apps/edr-passenger-web/backoffice/src/app/bookings/page.tsx
@@ -270,7 +270,7 @@ function BookingsPageContent() {
       render: (booking: any) => (
         <div>
           <Badge variant="status" status={booking.paymentIntent?.status || 'PENDING'}>{booking.paymentIntent?.status || 'PENDING'}</Badge>
-          <div className="text-sm text-muted-foreground">{formatCurrency(booking.totalMinor, booking.currency)}</div>
+          <div className="text-sm text-muted-foreground">{formatCurrency(booking.displayTotalMinor ?? booking.totalMinor, booking.displayCurrency ?? booking.currency ?? 'ETB')}</div>
         </div>
       ),
     },
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 f5aed275e..af2cab29b 100644
--- a/apps/edr-passenger-web/backoffice/src/app/classes/page.tsx
+++ b/apps/edr-passenger-web/backoffice/src/app/classes/page.tsx
@@ -311,7 +311,6 @@ export default function ClassesPage() {
                   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>
diff --git a/apps/edr-passenger-web/backoffice/src/app/payment-methods/page.tsx b/apps/edr-passenger-web/backoffice/src/app/payment-methods/page.tsx
index 8937497c6..4e6a71950 100644
--- a/apps/edr-passenger-web/backoffice/src/app/payment-methods/page.tsx
+++ b/apps/edr-passenger-web/backoffice/src/app/payment-methods/page.tsx
@@ -9,14 +9,13 @@ import ActionButton from '@/components/ui/ActionButton';
 import Modal from '@/components/ui/Modal';
 import ConfirmDialog from '@/components/ui/ConfirmDialog';
 import { apiClient, paymentsApi } from '@/lib/api';
-import { PermissionGuard } from '@/components/layout/PermissionGuard';
 import { usePermission } from '@/lib/use-permission';
 import { PERMS } from '@/lib/permissions';
 
 export default function PaymentMethodsPage() {
-  const canManagePayments = usePermission(PERMS.payments.manage);
+  const canManageMethods = usePermission(PERMS.paymentMethods.manage);
   const canManageAdmin = usePermission(PERMS.admin);
-  const canManage = canManagePayments || canManageAdmin;
+  const canManage = canManageMethods || canManageAdmin;
   const [createModalOpen, setCreateModalOpen] = useState(false);
   const [editModalOpen, setEditModalOpen] = useState(false);
   const [deleteConfirmOpen, setDeleteConfirmOpen] = useState(false);
@@ -228,11 +227,11 @@ export default function PaymentMethodsPage() {
           <h1 className="text-2xl font-bold text-foreground">Payment Methods</h1>
           <p className="text-muted-foreground">Manage supported payment systems</p>
         </div>
-        <PermissionGuard permission={PERMS.admin}>
+        {canManage && (
           <ActionButton icon={Plus} onClick={() => setCreateModalOpen(true)}>
             Add Method
           </ActionButton>
-        </PermissionGuard>
+        )}
       </div>
 
       {successMessage && (
diff --git a/apps/edr-passenger-web/backoffice/src/app/tariff-rates/BaggageTab.tsx b/apps/edr-passenger-web/backoffice/src/app/tariff-rates/BaggageTab.tsx
new file mode 100644
index 000000000..5723197c9
--- /dev/null
+++ b/apps/edr-passenger-web/backoffice/src/app/tariff-rates/BaggageTab.tsx
@@ -0,0 +1,134 @@
+'use client';
+
+import { useState } from 'react';
+import { Edit, Trash2 } from 'lucide-react';
+import DataTable from '@/components/ui/DataTable';
+import Modal from '@/components/ui/Modal';
+import ActionButton from '@/components/ui/ActionButton';
+import ConfirmDialog from '@/components/ui/ConfirmDialog';
+import { useBaggageMutations } from './hooks';
+import type { SeatClass, BaggageAllowance } from './types';
+
+interface Props {
+  allClasses: SeatClass[];
+  isOpen: boolean;
+  onClose: () => void;
+}
+
+export default function BaggageTab({ allClasses, isOpen, onClose }: Props) {
+  const { allowances, isLoading, create, update, remove } = useBaggageMutations();
+  const [form, setForm] = useState({ seatClassId: '', maxWeightKg: '', maxPiecesCount: '', excessFeePerKg: '' });
+  const [editing, setEditing] = useState<BaggageAllowance | null>(null);
+  const [error, setError] = useState<string | null>(null);
+  const [deleteConfirm, setDeleteConfirm] = useState<{ isOpen: boolean; id: string | null }>({ isOpen: false, id: null });
+
+  const resetForm = () => { setForm({ seatClassId: '', maxWeightKg: '', maxPiecesCount: '', excessFeePerKg: '' }); setEditing(null); setError(null); };
+
+  const handleSave = async () => {
+    setError(null);
+    if (!form.seatClassId || !form.maxWeightKg || !form.maxPiecesCount || !form.excessFeePerKg) {
+      setError('All fields are required'); return;
+    }
+    const payload = {
+      seatClassId: form.seatClassId,
+      maxWeightKg: parseInt(form.maxWeightKg),
+      maxPiecesCount: parseInt(form.maxPiecesCount),
+      excessFeePerKg: Math.round(parseFloat(form.excessFeePerKg) * 100),
+    };
+    try {
+      if (editing) {
+        await update.mutateAsync({ id: editing.id, ...payload });
+      } else {
+        await create.mutateAsync(payload);
+      }
+      resetForm();
+      onClose();
+    } catch (e: any) {
+      setError(e?.response?.data?.message ?? 'Failed to save');
+    }
+  };
+
+  return (
+    <>
+      {isLoading ? (
+        <div className="flex items-center justify-center py-8">
+          <div className="h-6 w-6 animate-spin rounded-full border-2 border-primary border-t-transparent" />
+        </div>
+      ) : (
+        <DataTable
+          data={allowances}
+          columns={[
+            { key: 'seatClass', label: 'Seat Class', render: (a: BaggageAllowance) => <span className="font-medium">{a.seatClass?.name ?? a.seatClassId}</span> },
+            { key: 'maxWeightKg', label: 'Free Allowance', render: (a: BaggageAllowance) => <span>{a.maxWeightKg} kg, {a.maxPiecesCount} pcs</span> },
+            { key: 'excessFeePerKg', label: 'Excess Fee / kg', render: (a: BaggageAllowance) => <span className="font-mono font-semibold">{(a.excessFeePerKg / 100).toFixed(2)} ETB</span> },
+          ]}
+          actions={[
+            {
+              label: 'Edit', icon: Edit, variant: 'secondary' as const,
+              onClick: (a: BaggageAllowance) => {
+                setEditing(a);
+                setForm({ seatClassId: a.seatClassId, maxWeightKg: String(a.maxWeightKg), maxPiecesCount: String(a.maxPiecesCount), excessFeePerKg: (a.excessFeePerKg / 100).toFixed(2) });
+                setError(null);
+              },
+            },
+            { label: 'Delete', icon: Trash2, variant: 'danger' as const, onClick: (a: BaggageAllowance) => setDeleteConfirm({ isOpen: true, id: a.id }) },
+          ]}
+          loading={false}
+          emptyMessage='No baggage allowance rules defined. Click "Add Allowance Rule" to create one.'
+        />
+      )}
+
+      <Modal
+        isOpen={isOpen || !!editing}
+        onClose={() => { resetForm(); onClose(); }}
+        title={editing ? 'Edit Allowance Rule' : 'Add Allowance Rule'}
+        size="md"
+      >
+        <div className="space-y-4">
+          {error && <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">{error}</div>}
+          <div>
+            <label className="label">Seat Class *</label>
+            <select value={form.seatClassId} onChange={e => setForm({ ...form, seatClassId: e.target.value })} className="input w-full" disabled={!!editing}>
+              <option value="">Select seat class...</option>
+              {allClasses.map(sc => <option key={sc.id} value={sc.id}>{sc.name}</option>)}
+            </select>
+            {editing && <p className="text-xs text-muted-foreground mt-1">Seat class cannot be changed. Delete and recreate to change.</p>}
+          </div>
+          <div className="grid grid-cols-2 gap-4">
+            <div>
+              <label className="label">Free Allowance (kg) *</label>
+              <input type="number" min="0" className="input w-full" placeholder="e.g. 20" value={form.maxWeightKg} onChange={e => setForm({ ...form, maxWeightKg: e.target.value })} />
+            </div>
+            <div>
+              <label className="label">Max Pieces *</label>
+              <input type="number" min="1" className="input w-full" placeholder="e.g. 2" value={form.maxPiecesCount} onChange={e => setForm({ ...form, maxPiecesCount: e.target.value })} />
+            </div>
+          </div>
+          <div>
+            <label className="label">Excess Fee per kg (ETB) *</label>
+            <input type="number" min="0" step="0.01" className="input w-full" placeholder="e.g. 50.00" value={form.excessFeePerKg} onChange={e => setForm({ ...form, excessFeePerKg: e.target.value })} />
+            <p className="text-xs text-muted-foreground mt-1">Amount charged per kg above the free allowance</p>
+          </div>
+          <div className="flex justify-end gap-2 pt-2">
+            <ActionButton variant="secondary" onClick={() => { resetForm(); onClose(); }}>Cancel</ActionButton>
+            <ActionButton onClick={handleSave} loading={create.isPending || update.isPending}>
+              {editing ? 'Update' : 'Save'}
+            </ActionButton>
+          </div>
+        </div>
+      </Modal>
+
+      <ConfirmDialog
+        isOpen={deleteConfirm.isOpen}
+        onClose={() => setDeleteConfirm({ isOpen: false, id: null })}
+        onConfirm={() => remove.mutate(deleteConfirm.id!)}
+        title="Delete Allowance Rule"
+        message="Are you sure you want to delete this baggage allowance rule?"
+        confirmText="Delete"
+        isDanger
+        isLoading={remove.isPending}
+        warning="The excess baggage fallback rate (50 ETB/kg) will apply until a new rule is created."
+      />
+    </>
+  );
+}
diff --git a/apps/edr-passenger-web/backoffice/src/app/tariff-rates/OverridesTab.tsx b/apps/edr-passenger-web/backoffice/src/app/tariff-rates/OverridesTab.tsx
new file mode 100644
index 000000000..abdb0887f
--- /dev/null
+++ b/apps/edr-passenger-web/backoffice/src/app/tariff-rates/OverridesTab.tsx
@@ -0,0 +1,272 @@
+'use client';
+
+import { useState } from 'react';
+import { Plus, Edit, Trash2 } from 'lucide-react';
+import DataTable from '@/components/ui/DataTable';
+import Badge from '@/components/ui/Badge';
+import ActionButton from '@/components/ui/ActionButton';
+import ConfirmDialog from '@/components/ui/ConfirmDialog';
+import Modal from '@/components/ui/Modal';
+import { useRouteFareRules, useRouteFareRuleMutations, useSeatClasses } from './hooks';
+import type { Route, RouteFareRule, SeatClass } from './types';
+
+interface Props {
+  routes: Route[];
+}
+
+type OverrideForm = {
+  isOpen: boolean;
+  rule: RouteFareRule | null; // null = add mode
+  error: string | null;
+};
+
+export default function OverridesTab({ routes }: Props) {
+  const [selectedRouteId, setSelectedRouteId] = useState<string | null>(null);
+  const [deleteConfirm, setDeleteConfirm] = useState<{
+    isOpen: boolean;
+    id: string | null;
+    name: string;
+    cascade: boolean;
+    cascadeChecked: boolean;
+    error?: string;
+  }>({ isOpen: false, id: null, name: '', cascade: false, cascadeChecked: false });
+  const [form, setForm] = useState<OverrideForm>({ isOpen: false, rule: null, error: null });
+
+  const { overrides, isLoading } = useRouteFareRules(selectedRouteId);
+  const { update, remove, create } = useRouteFareRuleMutations(selectedRouteId);
+  const { allClasses } = useSeatClasses();
+
+  const handleDeleteClick = (r: RouteFareRule) => {
+    setDeleteConfirm({
+      isOpen: true, id: r.id,
+      name: r.seatClass?.name ?? r.seatClassId,
+      cascade: false, cascadeChecked: false, error: undefined,
+    });
+  };
+
+  const handleConfirmDelete = async () => {
+    try {
+      await remove.mutateAsync(deleteConfirm.id!);
+      setDeleteConfirm({ isOpen: false, id: null, name: '', cascade: false, cascadeChecked: false });
+    } catch (err: any) {
+      const msg = err?.response?.data?.message ?? err?.message ?? 'Delete failed';
+      const isFkError = msg.includes('Cannot delete') || err?.response?.status === 400;
+      setDeleteConfirm(prev => ({
+        ...prev,
+        cascade: isFkError && !prev.cascade ? true : prev.cascade,
+        cascadeChecked: false,
+        error: msg,
+      }));
+    }
+  };
+
+  const handleFormSubmit = async (e: React.FormEvent<HTMLFormElement>) => {
+    e.preventDefault();
+    setForm(prev => ({ ...prev, error: null }));
+    const fd = new FormData(e.currentTarget);
+    const baseFareMinor = Math.round(Number(fd.get('baseFareMinor')) * 100) || 0;
+    const surchargeMinor = Math.round(Number(fd.get('surchargeMinor') ?? '0') * 100) || 0;
+    try {
+      if (form.rule) {
+        await update.mutateAsync({ id: form.rule.id, baseFareMinor, surchargeMinor });
+      } else {
+        const routeId = fd.get('routeId') as string;
+        const seatClassId = fd.get('seatClassId') as string;
+        await create.mutateAsync({
+          routeId,
+          seatClassId,
+          passengerCategory: 'ADULT',
+          baseFareMinor,
+          surchargeMinor,
+          validFrom: new Date().toISOString(),
+        });
+      }
+      setForm({ isOpen: false, rule: null, error: null });
+    } catch (err: any) {
+      setForm(prev => ({ ...prev, error: err?.response?.data?.message ?? err?.message ?? 'Failed to save' }));
+    }
+  };
+
+  const columns = [
+    {
+      key: 'route', label: 'Route',
+      render: (r: RouteFareRule) => <span className="font-medium">{r.route?.name ?? r.routeId}</span>,
+    },
+    {
+      key: 'seatClass', label: 'Seat Class',
+      render: (r: RouteFareRule) => <span>{r.seatClass?.name ?? r.seatClassId}</span>,
+    },
+    {
+      key: 'passengerCategory', label: 'Category',
+      render: (r: RouteFareRule) => (
+        <Badge variant="status" status={r.passengerCategory === 'ADULT' ? 'CONFIRMED' : 'INFO'}>
+          {r.passengerCategory}
+        </Badge>
+      ),
+    },
+    {
+      key: 'baseFareMinor', label: 'Rate per km',
+      render: (r: RouteFareRule) => <span className="font-mono font-medium">{r.baseFareMinor / 100}</span>,
+    },
+    {
+      key: 'surchargeMinor', label: 'Insurance Fee',
+      render: (r: RouteFareRule) => (
+        <span className="font-mono text-sm">
+          {r.surchargeMinor ? (r.surchargeMinor / 100).toFixed(2) : '0.00'} ETB
+        </span>
+      ),
+    },
+    {
+      key: 'validFrom', label: 'Valid From',
+      render: (r: RouteFareRule) => <span className="text-sm">{new Date(r.validFrom).toLocaleDateString()}</span>,
+    },
+    {
+      key: 'validUntil', label: 'Valid Until',
+      render: (r: RouteFareRule) => (
+        <span className="text-sm">{r.validUntil ? new Date(r.validUntil).toLocaleDateString() : '—'}</span>
+      ),
+    },
+  ];
+
+  const isAddMode = form.isOpen && !form.rule;
+  const isPending = create.isPending || update.isPending;
+
+  return (
+    <>
+      <div className="flex items-center gap-3 mb-4">
+        <select
+          className="input w-64"
+          value={selectedRouteId ?? ''}
+          onChange={e => setSelectedRouteId(e.target.value || null)}
+        >
+          <option value="">All routes</option>
+          {routes.map(r => (
+            <option key={r.id} value={r.id}>{r.name}{r.code ? ` (${r.code})` : ''}</option>
+          ))}
+        </select>
+
+        <ActionButton
+          icon={Plus}
+          onClick={() => setForm({ isOpen: true, rule: null, error: null })}
+        >
+          Add Override
+        </ActionButton>
+      </div>
+
+      {!selectedRouteId ? (
+        <div className="text-center py-8 text-muted-foreground">
+          Select a route above to view its fare overrides.
+        </div>
+      ) : (
+        <DataTable
+          data={overrides}
+          columns={columns}
+          actions={[
+            {
+              label: 'Edit', icon: Edit, variant: 'secondary' as const,
+              onClick: (r: RouteFareRule) => setForm({ isOpen: true, rule: r, error: null }),
+            },
+            { label: 'Delete', icon: Trash2, variant: 'danger' as const, onClick: handleDeleteClick },
+          ]}
+          loading={isLoading}
+          emptyMessage="No overrides for this route. Click 'Add Override' to create one."
+        />
+      )}
+
+      {/* Add / Edit modal */}
+      <Modal
+        isOpen={form.isOpen}
+        onClose={() => setForm({ isOpen: false, rule: null, error: null })}
+        title={isAddMode ? 'Add Route Override' : 'Edit Route Override'}
+        size="md"
+      >
+        <form key={form.rule?.id ?? 'add'} onSubmit={handleFormSubmit} className="space-y-4">
+          {form.error && (
+            <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-800 dark:text-red-200">
+              {form.error}
+            </div>
+          )}
+
+          {isAddMode ? (
+            <div className="grid grid-cols-1 gap-4">
+              <div>
+                <label className="label">Route *</label>
+                <select name="routeId" className="input w-full" defaultValue={selectedRouteId ?? ''} required>
+                  <option value="">Select route</option>
+                  {routes.map(r => (
+                    <option key={r.id} value={r.id}>{r.name}{r.code ? ` (${r.code})` : ''}</option>
+                  ))}
+                </select>
+              </div>
+              <div>
+                <label className="label">Seat Class Tariff *</label>
+                <select name="seatClassId" className="input w-full" required>
+                  <option value="">Select seat class</option>
+                  {allClasses.filter(c => c.isActive).map((c: SeatClass) => (
+                    <option key={c.id} value={c.id}>{c.name}</option>
+                  ))}
+                </select>
+              </div>
+            </div>
+          ) : (
+            <div className="p-3 rounded-lg bg-muted/50 text-sm text-muted-foreground">
+              <span className="font-medium text-foreground">{form.rule?.seatClass?.name ?? form.rule?.seatClassId}</span>
+              {' · '}{form.rule?.route?.name ?? form.rule?.routeId}
+              {' · '}{form.rule?.passengerCategory}
+            </div>
+          )}
+
+          <div className="grid grid-cols-2 gap-4">
+            <div>
+              <label className="label">Rate per km *</label>
+              <input
+                type="number"
+                name="baseFareMinor"
+                className="input"
+                defaultValue={form.rule ? form.rule.baseFareMinor / 100 : ''}
+                min="0" step="any" required
+              />
+            </div>
+            <div>
+              <label className="label">Insurance Fee (ETB)</label>
+              <input
+                type="number"
+                name="surchargeMinor"
+                className="input"
+                defaultValue={form.rule ? ((form.rule.surchargeMinor ?? 0) / 100).toFixed(2) : '0.00'}
+                min="0" step="0.01"
+              />
+            </div>
+          </div>
+
+          <div className="flex justify-end gap-2 pt-2">
+            <ActionButton type="button" variant="secondary" onClick={() => setForm({ isOpen: false, rule: null, error: null })}>Cancel</ActionButton>
+            <ActionButton type="submit" loading={isPending}>
+              {isAddMode ? 'Create Override' : 'Update Override'}
+            </ActionButton>
+          </div>
+        </form>
+      </Modal>
+
+      <ConfirmDialog
+        isOpen={deleteConfirm.isOpen}
+        onClose={() => setDeleteConfirm({ isOpen: false, id: null, name: '', cascade: false, cascadeChecked: false })}
+        onConfirm={handleConfirmDelete}
+        title="Delete Route Override"
+        message={`Delete the fare override for "${deleteConfirm.name}"? The global seat class rate will apply instead.`}
+        confirmText="Delete"
+        isDanger
+        isLoading={remove.isPending}
+        error={deleteConfirm.error}
+        warning={!deleteConfirm.cascade
+          ? 'Removing this override means all future bookings on this route will fall back to the global tariff rate.'
+          : undefined}
+        cascadeWarning={deleteConfirm.cascade
+          ? 'This override has related records that will also be permanently deleted.'
+          : undefined}
+        cascadeChecked={deleteConfirm.cascadeChecked}
+        onCascadeChange={checked => setDeleteConfirm(prev => ({ ...prev, cascadeChecked: checked }))}
+      />
+    </>
+  );
+}
diff --git a/apps/edr-passenger-web/backoffice/src/app/tariff-rates/RateModal.tsx b/apps/edr-passenger-web/backoffice/src/app/tariff-rates/RateModal.tsx
new file mode 100644
index 000000000..aaa676001
--- /dev/null
+++ b/apps/edr-passenger-web/backoffice/src/app/tariff-rates/RateModal.tsx
@@ -0,0 +1,250 @@
+'use client';
+
+import { useState, useEffect } from 'react';
+import Modal from '@/components/ui/Modal';
+import ActionButton from '@/components/ui/ActionButton';
+import { BED_POSITIONS, COACH_TYPE_LABELS, getTariffRef } from './constants';
+import type { SeatClass, CoachType, Route } from './types';
+
+interface Props {
+  isOpen: boolean;
+  onClose: () => void;
+  editingClass: SeatClass | null;
+  allClasses: SeatClass[];
+  coachTypes: CoachType[];
+  routes?: Route[];
+  preselectedRouteId?: string | null;
+  allowRouteOverride?: boolean;
+  onSubmitGlobal: (payload: any) => Promise<void>;
+  onSubmitOverride: (routeId: string, payload: any) => Promise<void>;
+  isPending: boolean;
+}
+
+export default function RateModal({
+  isOpen, onClose, editingClass, allClasses, coachTypes, routes,
+  preselectedRouteId, allowRouteOverride, onSubmitGlobal, onSubmitOverride, isPending,
+}: Props) {
+  const [nationalityType, setNationalityType] = useState('LOCAL');
+  const [coachTypeId, setCoachTypeId] = useState('');
+  const [bedPosition, setBedPosition] = useState('');
+  const [routeId, setRouteId] = useState(preselectedRouteId ?? '');
+  const [error, setError] = useState<string | null>(null);
+
+  useEffect(() => {
+    if (!isOpen) return;
+    setNationalityType(editingClass?.nationalityType ?? 'LOCAL');
+    setCoachTypeId(editingClass?.coachTypeId ?? '');
+    setBedPosition(editingClass?.bedPosition ?? '');
+    setRouteId(preselectedRouteId ?? '');
+    setError(null);
+  }, [isOpen]); // eslint-disable-line react-hooks/exhaustive-deps
+
+  const selectedCoachType = coachTypes.find(c => c.id === coachTypeId) ?? (editingClass as any)?.coachType;
+  const isBedCoach = selectedCoachType?.name?.toLowerCase().includes('bed') ||
+    selectedCoachType?.code?.toLowerCase().includes('bed');
+
+  const suggestName = () => {
+    if (!selectedCoachType) return '';
+    const label = COACH_TYPE_LABELS[selectedCoachType.code] ?? selectedCoachType.name;
+    const pos = bedPosition ? ` ${bedPosition.charAt(0) + bedPosition.slice(1).toLowerCase()}` : '';
+    const nat = nationalityType === 'LOCAL' ? 'Local' : 'Intl';
+    return `${label}${pos} (${nat})`;
+  };
+
+  const suggestRate = () => {
+    if (!selectedCoachType) return '';
+    const ref = getTariffRef(nationalityType, selectedCoachType.code, bedPosition || null);
+    return ref ? String(ref) : '';
+  };
+
+  const handleSubmit = async (e: React.FormEvent<HTMLFormElement>) => {
+    e.preventDefault();
+    setError(null);
+    const fd = new FormData(e.currentTarget);
+
+    try {
+      if (routeId && !editingClass) {
+        const matched = allClasses.find(c =>
+          c.coachTypeId === coachTypeId &&
+          c.nationalityType === nationalityType &&
+          (c.bedPosition ?? null) === (bedPosition || null),
+        );
+        if (!matched) {
+          setError('No matching seat class found for the selected combination. Create the global rate first.');
+          return;
+        }
+        await onSubmitOverride(routeId, {
+          seatClassId: matched.id,
+          passengerCategory: 'ADULT',
+          baseFareMinor: Math.round(Number(fd.get('baseFareMinor')) * 100) || 0,
+          surchargeMinor: Math.round(Number(fd.get('surchargeMinor') ?? '0') * 100) || 0,
+          validFrom: new Date().toISOString(),
+        });
+      } else {
+        await onSubmitGlobal({
+          coachTypeId,
+          name: fd.get('name') as string,
+          nationalityType,
+          bedPosition: bedPosition || null,
+          basePrice: Math.round(Number(fd.get('baseFareMinor')) * 100) || 0,
+          insuranceFeeMinor: Math.round(Number(fd.get('insuranceFeeMinor') ?? '0') * 100) || 0,
+          isActive: fd.get('isActive') === 'true',
+        });
+      }
+      onClose();
+    } catch (err: any) {
+      setError(err?.response?.data?.message ?? err?.message ?? 'Failed to save');
+    }
+  };
+
+  const isOverrideMode = !!routeId && !editingClass;
+  const title = editingClass ? 'Edit Tariff Rate' : isOverrideMode ? 'Add Route Override' : 'Add Tariff Rate';
+
+  return (
+    <Modal isOpen={isOpen} onClose={onClose} title={title} size="lg">
+      <form key={editingClass?.id ?? `new-${preselectedRouteId}`} onSubmit={handleSubmit} className="space-y-4">
+        {error && (
+          <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-800 dark:text-red-200">
+            {error}
+          </div>
+        )}
+
+        {!editingClass && allowRouteOverride && (
+          <div>
+            <label className="label">Route Override (optional)</label>
+            <select className="input w-full" value={routeId} onChange={e => setRouteId(e.target.value)}>
+              <option value="">Global rate (applies to all routes)</option>
+              {(routes ?? []).map(r => (
+                <option key={r.id} value={r.id}>{r.name}{r.code ? ` (${r.code})` : ''}</option>
+              ))}
+            </select>
+            {isOverrideMode && (
+              <p className="text-xs text-muted-foreground mt-1">
+                Override applies only to this route. A matching global seat class must already exist.
+              </p>
+            )}
+          </div>
+        )}
+
+        <div className="grid grid-cols-1 md:grid-cols-2 gap-4">
+          <div>
+            <label className="label">Passenger Nationality *</label>
+            <select className="input" value={nationalityType} onChange={e => setNationalityType(e.target.value)} required>
+              <option value="LOCAL">Local (Ethiopian / Djiboutian)</option>
+              <option value="INTERNATIONAL">International (Foreign nationals)</option>
+            </select>
+          </div>
+
+          <div>
+            <label className="label">Coach Type *</label>
+            <select
+              className="input"
+              value={coachTypeId}
+              onChange={e => { setCoachTypeId(e.target.value); setBedPosition(''); }}
+              required
+            >
+              <option value="">Select coach type</option>
+              {coachTypes.map(ct => (
+                <option key={ct.id} value={ct.id}>{ct.code} — {ct.name}</option>
+              ))}
+            </select>
+          </div>
+
+          {isBedCoach && (
+            <div>
+              <label className="label">Bed Position *</label>
+              <select className="input" value={bedPosition} onChange={e => setBedPosition(e.target.value)} required>
+                <option value="">Select bed position</option>
+                {BED_POSITIONS.map(pos => <option key={pos} value={pos}>{pos}</option>)}
+              </select>
+              <p className="text-xs text-muted-foreground mt-1">
+                {selectedCoachType?.code === 'HBC' ? 'Economy Bed: Upper / Middle / Lower' : 'VIP Bed: Upper / Lower'}
+              </p>
+            </div>
+          )}
+
+          {!isOverrideMode && (
+            <div>
+              <label className="label">Class Name *</label>
+              <input
+                type="text"
+                name="name"
+                className="input"
+                defaultValue={editingClass?.name ?? ''}
+                key={editingClass?.id ?? `name-${coachTypeId}-${bedPosition}-${nationalityType}`}
+                placeholder={suggestName() || 'e.g. Economy Bed Upper (Local)'}
+                required
+              />
+              {!editingClass && suggestName() && (
+                <p className="text-xs text-muted-foreground mt-1">
+                  Suggested:{' '}
+                  <button type="button" className="text-primary underline" onClick={e => {
+                    const inp = (e.currentTarget.closest('form')?.querySelector('input[name=name]') as HTMLInputElement);
+                    if (inp) inp.value = suggestName();
+                  }}>{suggestName()}</button>
+                </p>
+              )}
+            </div>
+          )}
+
+          <div>
+            <label className="label">Rate per km *</label>
+            <input
+              type="number"
+              name="baseFareMinor"
+              className="input"
+              defaultValue={editingClass ? editingClass.baseFareMinor! / 100 : ''}
+              key={editingClass?.id ?? `rate-${coachTypeId}-${bedPosition}-${nationalityType}`}
+              placeholder={suggestRate() || 'e.g. 0.06'}
+              min="0"
+              step="any"
+              required
+            />
+            {suggestRate() && (
+              <p className="text-xs text-muted-foreground mt-1">
+                Official tariff:{' '}
+                <button type="button" className="text-primary underline" onClick={e => {
+                  const inp = (e.currentTarget.closest('form')?.querySelector('input[name=baseFareMinor]') as HTMLInputElement);
+                  if (inp) inp.value = suggestRate();
+                }}>{suggestRate()}</button>
+                {' '}(stored as {Math.round(Number(suggestRate()) * 100)})
+              </p>
+            )}
+          </div>
+
+          {/* Insurance fee — different field name depending on mode */}
+          <div>
+            <label className="label">Insurance Fee (ETB)</label>
+            <input
+              type="number"
+              name={isOverrideMode ? 'surchargeMinor' : 'insuranceFeeMinor'}
+              className="input"
+              defaultValue={editingClass ? (editingClass.insuranceFeeMinor! / 100).toFixed(2) : '0.00'}
+              key={editingClass?.id ?? `ins-${isOverrideMode}`}
+              min="0"
+              step="0.01"
+              placeholder="e.g. 25.00"
+            />
+          </div>
+
+          {!isOverrideMode && (
+            <div>
+              <label className="label">Status</label>
+              <select name="isActive" className="input" defaultValue={editingClass?.isActive !== false ? 'true' : 'false'}>
+                <option value="true">Active</option>
+                <option value="false">Inactive</option>
+              </select>
+            </div>
+          )}
+        </div>
+
+        <div className="flex justify-end gap-2 pt-4">
+          <ActionButton type="button" variant="secondary" onClick={onClose}>Cancel</ActionButton>
+          <ActionButton type="submit" loading={isPending}>
+            {editingClass ? 'Update Rate' : isOverrideMode ? 'Create Override' : 'Create Rate'}
+          </ActionButton>
+        </div>
+      </form>
+    </Modal>
+  );
+}
diff --git a/apps/edr-passenger-web/backoffice/src/app/tariff-rates/SegmentOverridesTab.tsx b/apps/edr-passenger-web/backoffice/src/app/tariff-rates/SegmentOverridesTab.tsx
new file mode 100644
index 000000000..7dcb445c4
--- /dev/null
+++ b/apps/edr-passenger-web/backoffice/src/app/tariff-rates/SegmentOverridesTab.tsx
@@ -0,0 +1,289 @@
+'use client';
+
+import { useState } from 'react';
+import { Plus, Edit, Trash2 } from 'lucide-react';
+import DataTable from '@/components/ui/DataTable';
+import ActionButton from '@/components/ui/ActionButton';
+import ConfirmDialog from '@/components/ui/ConfirmDialog';
+import Modal from '@/components/ui/Modal';
+import { useSegmentFareRules, useSegmentFareMutations, useSeatClasses, useRoutes } from './hooks';
+import type { Route, SegmentFareRule, SeatClass } from './types';
+import { useQuery } from '@tanstack/react-query';
+import { apiClient } from '@/lib/api-client';
+
+interface RouteStop { sequence: number; station?: { name: string; code: string } }
+
+function useRouteStops(routeId: string | null) {
+  const { data } = useQuery({
+    queryKey: ['route-stops', routeId],
+    queryFn: () => apiClient.get<RouteStop[]>(`/routes/${routeId}/stops`),
+    enabled: !!routeId,
+  });
+  return (Array.isArray(data) ? data : (data as any)?.items ?? []) as RouteStop[];
+}
+
+function useExchangeRates() {
+  const { data } = useQuery({
+    queryKey: ['exchange-rates'],
+    queryFn: () => apiClient.get<any[]>('/currencies'),
+  });
+  const rates: any[] = Array.isArray(data) ? data : (data as any)?.items ?? [];
+  // Build ETB→X lookup: rate value
+  const rateMap: Record<string, number> = {};
+  for (const r of rates) {
+    if (r.fromCurrency === 'ETB') rateMap[r.toCurrency] = r.rate;
+  }
+  return rateMap;
+}
+
+function formatFixed(amountMinor: number, currency = 'ETB', rateMap: Record<string, number> = {}) {
+  const etb = (amountMinor / 100).toFixed(2);
+  if (currency === 'ETB') return `ETB ${etb}`;
+  const rate = rateMap[currency];
+  if (!rate) return `ETB ${etb}`;
+  const converted = ((amountMinor / 100) * rate).toFixed(2);
+  return `ETB ${etb} ≈ ${currency} ${converted}`;
+}
+
+interface Props { routes: Route[] }
+
+type FormState = { isOpen: boolean; rule: SegmentFareRule | null; error: string | null };
+
+export default function SegmentOverridesTab({ routes }: Props) {
+  const [selectedRouteId, setSelectedRouteId] = useState<string | null>(null);
+  const [form, setForm] = useState<FormState>({ isOpen: false, rule: null, error: null });
+  const [deleteConfirm, setDeleteConfirm] = useState<{ isOpen: boolean; id: string | null; name: string; error?: string }>({ isOpen: false, id: null, name: '' });
+
+  const { segmentFares, isLoading } = useSegmentFareRules(selectedRouteId);
+  const { create, update, remove } = useSegmentFareMutations(selectedRouteId);
+  const { allClasses } = useSeatClasses();
+  const stops = useRouteStops(selectedRouteId);
+  const rateMap = useExchangeRates();
+
+  const stopLabel = (seq: number) => {
+    const s = stops.find(st => st.sequence === seq);
+    return s?.station ? `${s.station.name} (${s.station.code})` : `Stop ${seq}`;
+  };
+
+  const handleFormSubmit = async (e: React.FormEvent<HTMLFormElement>) => {
+    e.preventDefault();
+    setForm(prev => ({ ...prev, error: null }));
+    const fd = new FormData(e.currentTarget);
+    const baseFareMinor = Math.round(Number(fd.get('baseFareMinor')) * 100);
+    try {
+      if (form.rule) {
+        await update.mutateAsync({ id: form.rule.id, baseFareMinor });
+      } else {
+        await create.mutateAsync({
+          routeId: selectedRouteId,
+          originStopSequence: Number(fd.get('originStopSequence')),
+          destinationStopSequence: Number(fd.get('destinationStopSequence')),
+          seatClassId: fd.get('seatClassId') as string,
+          nationality: (fd.get('nationality') as string) || null,
+          baseFareMinor,
+          validFrom: new Date().toISOString(),
+        });
+      }
+      setForm({ isOpen: false, rule: null, error: null });
+    } catch (err: any) {
+      setForm(prev => ({ ...prev, error: err?.response?.data?.message ?? err?.message ?? 'Failed to save' }));
+    }
+  };
+
+  const handleDelete = async () => {
+    try {
+      await remove.mutateAsync(deleteConfirm.id!);
+      setDeleteConfirm({ isOpen: false, id: null, name: '' });
+    } catch (err: any) {
+      setDeleteConfirm(prev => ({ ...prev, error: err?.response?.data?.message ?? err?.message ?? 'Delete failed' }));
+    }
+  };
+
+  const columns = [
+    {
+      key: 'segment', label: 'Segment',
+      render: (r: SegmentFareRule) => (
+        <span className="font-medium">
+          {stopLabel(r.originStopSequence)} → {stopLabel(r.destinationStopSequence)}
+        </span>
+      ),
+    },
+    {
+      key: 'seatClass', label: 'Seat Class',
+      render: (r: SegmentFareRule) => <span>{r.seatClass?.name ?? r.seatClassId}</span>,
+    },
+    {
+      key: 'nationality', label: 'Nationality',
+      render: (r: SegmentFareRule) => <span className="text-sm">{r.nationality ?? 'All'}</span>,
+    },
+    {
+      key: 'baseFareMinor', label: 'Fixed Price',
+      render: (r: SegmentFareRule) => (
+        <span className="font-mono font-medium text-sm">{formatFixed(r.baseFareMinor, 'ETB', rateMap)}</span>
+      ),
+    },
+    {
+      key: 'converted', label: 'Converted',
+      render: (r: SegmentFareRule) => (
+        <div className="text-xs text-muted-foreground space-y-0.5">
+          {Object.entries(rateMap).map(([cur, rate]) => (
+            <div key={cur}>{cur} {((r.baseFareMinor / 100) * rate).toFixed(2)}</div>
+          ))}
+        </div>
+      ),
+    },
+    {
+      key: 'validFrom', label: 'Valid From',
+      render: (r: SegmentFareRule) => <span className="text-sm">{new Date(r.validFrom).toLocaleDateString()}</span>,
+    },
+    {
+      key: 'validUntil', label: 'Valid Until',
+      render: (r: SegmentFareRule) => <span className="text-sm">{r.validUntil ? new Date(r.validUntil).toLocaleDateString() : '—'}</span>,
+    },
+  ];
+
+  const isAddMode = form.isOpen && !form.rule;
+  const isPending = create.isPending || update.isPending;
+
+  return (
+    <>
+      <div className="mb-3 text-sm text-muted-foreground bg-blue-50 dark:bg-blue-900/20 border border-blue-200 dark:border-blue-800 rounded-lg px-4 py-2">
+        Segment overrides set a <strong>fixed total price</strong> for a specific origin→destination stop pair, bypassing per-km calculation.
+        Precedence: <strong>Segment Override</strong> → Route Override → Seat Class Tariff.
+      </div>
+
+      <div className="flex items-center gap-3 mb-4">
+        <select
+          className="input w-64"
+          value={selectedRouteId ?? ''}
+          onChange={e => setSelectedRouteId(e.target.value || null)}
+        >
+          <option value="">Select route</option>
+          {routes.map(r => (
+            <option key={r.id} value={r.id}>{r.name}{r.code ? ` (${r.code})` : ''}</option>
+          ))}
+        </select>
+
+        <ActionButton icon={Plus} onClick={() => setForm({ isOpen: true, rule: null, error: null })} disabled={!selectedRouteId}>
+          Add Segment Override
+        </ActionButton>
+      </div>
+
+      {!selectedRouteId ? (
+        <div className="text-center py-8 text-muted-foreground">Select a route above to view its segment overrides.</div>
+      ) : (
+        <DataTable
+          data={segmentFares}
+          columns={columns}
+          actions={[
+            { label: 'Edit', icon: Edit, variant: 'secondary' as const, onClick: (r: SegmentFareRule) => setForm({ isOpen: true, rule: r, error: null }) },
+            { label: 'Delete', icon: Trash2, variant: 'danger' as const, onClick: (r: SegmentFareRule) => setDeleteConfirm({ isOpen: true, id: r.id, name: `${stopLabel(r.originStopSequence)} → ${stopLabel(r.destinationStopSequence)}` }) },
+          ]}
+          loading={isLoading}
+          emptyMessage="No segment overrides for this route."
+        />
+      )}
+
+      <Modal
+        isOpen={form.isOpen}
+        onClose={() => setForm({ isOpen: false, rule: null, error: null })}
+        title={isAddMode ? 'Add Segment Override' : 'Edit Segment Override'}
+        size="md"
+      >
+        <form key={form.rule?.id ?? 'add'} onSubmit={handleFormSubmit} className="space-y-4">
+          {form.error && (
+            <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-800 dark:text-red-200">{form.error}</div>
+          )}
+
+          {isAddMode ? (
+            <div className="grid grid-cols-1 gap-4">
+              <div className="grid grid-cols-2 gap-4">
+                <div>
+                  <label className="label">Origin Stop *</label>
+                  <select name="originStopSequence" className="input w-full" required>
+                    <option value="">Select origin</option>
+                    {stops.map(s => (
+                      <option key={s.sequence} value={s.sequence}>{stopLabel(s.sequence)}</option>
+                    ))}
+                  </select>
+                </div>
+                <div>
+                  <label className="label">Destination Stop *</label>
+                  <select name="destinationStopSequence" className="input w-full" required>
+                    <option value="">Select destination</option>
+                    {stops.map(s => (
+                      <option key={s.sequence} value={s.sequence}>{stopLabel(s.sequence)}</option>
+                    ))}
+                  </select>
+                </div>
+              </div>
+              <div>
+                <label className="label">Seat Class *</label>
+                <select name="seatClassId" className="input w-full" required>
+                  <option value="">Select seat class</option>
+                  {allClasses.filter((c: SeatClass) => c.isActive).map((c: SeatClass) => (
+                    <option key={c.id} value={c.id}>{c.name}</option>
+                  ))}
+                </select>
+              </div>
+              <div>
+                <label className="label">Nationality <span className="text-muted-foreground font-normal">(optional — leave blank for all)</span></label>
+                <select name="nationality" className="input w-full">
+                  <option value="">All nationalities</option>
+                  <option value="Ethiopian">Ethiopian</option>
+                  <option value="Djiboutian">Djiboutian</option>
+                  <option value="Other">Other (International)</option>
+                </select>
+              </div>
+            </div>
+          ) : (
+            <div className="p-3 rounded-lg bg-muted/50 text-sm text-muted-foreground">
+              <span className="font-medium text-foreground">
+                {form.rule && stopLabel(form.rule.originStopSequence)} → {form.rule && stopLabel(form.rule.destinationStopSequence)}
+              </span>
+              {' · '}{form.rule?.seatClass?.name ?? form.rule?.seatClassId}
+              {form.rule?.nationality ? ` · ${form.rule.nationality}` : ' · All nationalities'}
+            </div>
+          )}
+
+          <div>
+            <label className="label">Fixed Price (ETB) *</label>
+            <input
+              type="number"
+              name="baseFareMinor"
+              className="input"
+              defaultValue={form.rule ? (form.rule.baseFareMinor / 100).toFixed(2) : ''}
+              min="0" step="0.01" required
+              placeholder="e.g. 350.00"
+            />
+            {Object.keys(rateMap).length > 0 && (
+              <p className="text-xs text-muted-foreground mt-1">
+                Exchange rates applied at booking: {Object.entries(rateMap).map(([c, r]) => `1 ETB = ${r} ${c}`).join(', ')}
+              </p>
+            )}
+          </div>
+
+          <div className="flex justify-end gap-2 pt-2">
+            <ActionButton type="button" variant="secondary" onClick={() => setForm({ isOpen: false, rule: null, error: null })}>Cancel</ActionButton>
+            <ActionButton type="submit" loading={isPending}>
+              {isAddMode ? 'Create Override' : 'Update Override'}
+            </ActionButton>
+          </div>
+        </form>
+      </Modal>
+
+      <ConfirmDialog
+        isOpen={deleteConfirm.isOpen}
+        onClose={() => setDeleteConfirm({ isOpen: false, id: null, name: '' })}
+        onConfirm={handleDelete}
+        title="Delete Segment Override"
+        message={`Delete the segment override for "${deleteConfirm.name}"? The route override or global tariff will apply instead.`}
+        confirmText="Delete"
+        isDanger
+        isLoading={remove.isPending}
+        error={deleteConfirm.error}
+        warning="Removing this override means bookings on this segment will fall back to the route override or global tariff rate."
+      />
+    </>
+  );
+}
diff --git a/apps/edr-passenger-web/backoffice/src/app/tariff-rates/TariffTab.tsx b/apps/edr-passenger-web/backoffice/src/app/tariff-rates/TariffTab.tsx
new file mode 100644
index 000000000..63c9b5d38
--- /dev/null
+++ b/apps/edr-passenger-web/backoffice/src/app/tariff-rates/TariffTab.tsx
@@ -0,0 +1,172 @@
+'use client';
+
+import { useState, useEffect } from 'react';
+import { Edit, Trash2, Search } from 'lucide-react';
+import DataTable from '@/components/ui/DataTable';
+import Badge from '@/components/ui/Badge';
+import ConfirmDialog from '@/components/ui/ConfirmDialog';
+import { getTariffRef } from './constants';
+import type { SeatClass, CoachType } from './types';
+
+interface Props {
+  classes: SeatClass[];
+  coachTypes: CoachType[];
+  isLoading: boolean;
+  onEdit: (cls: SeatClass) => void;
+  onDelete: (id: string, cascade: boolean) => void;
+  isDeleting: boolean;
+  deleteError?: string;
+  deleteSuccess?: number;
+}
+
+export default function TariffTab({ classes, coachTypes, isLoading, onEdit, onDelete, isDeleting, deleteError, deleteSuccess }: Props) {
+  const [search, setSearch] = useState('');
+  const [deleteConfirm, setDeleteConfirm] = useState<{
+    isOpen: boolean;
+    item: SeatClass | null;
+    cascade: boolean;
+    cascadeChecked: boolean;
+    error?: string;
+  }>({ isOpen: false, item: null, cascade: false, cascadeChecked: false });
+
+  // Close dialog on successful delete
+  useEffect(() => {
+    if (!deleteSuccess) return;
+    setDeleteConfirm({ isOpen: false, item: null, cascade: false, cascadeChecked: false });
+  }, [deleteSuccess]); // eslint-disable-line react-hooks/exhaustive-deps
+
+  // Sync external error into dialog when it arrives
+  useEffect(() => {
+    if (!deleteError || !deleteConfirm.isOpen) return;
+    setDeleteConfirm(prev => ({
+      ...prev,
+      cascade: prev.cascade || deleteError.includes('Cannot delete'),
+      cascadeChecked: false,
+      error: deleteError,
+    }));
+  }, [deleteError]); // eslint-disable-line react-hooks/exhaustive-deps
+
+  const handleDeleteClick = (cls: SeatClass) => {
+    setDeleteConfirm({ isOpen: true, item: cls, cascade: false, cascadeChecked: false, error: undefined });
+  };
+
+  const handleConfirm = () => {
+    onDelete(deleteConfirm.item!.id, deleteConfirm.cascade && deleteConfirm.cascadeChecked);
+  };
+
+  const displayed = classes
+    .filter(c => c.nationalityType)
+    .filter(c => {
+      if (!search) return true;
+      const s = search.toLowerCase();
+      const ct = coachTypes.find(t => t.id === c.coachTypeId);
+      return (
+        c.name?.toLowerCase().includes(s) ||
+        c.nationalityType?.toLowerCase().includes(s) ||
+        c.bedPosition?.toLowerCase().includes(s) ||
+        ct?.name?.toLowerCase().includes(s)
+      );
+    })
+    .sort((a, b) => (a.nationalityType === b.nationalityType ? 0 : a.nationalityType === 'LOCAL' ? -1 : 1));
+
+  const columns = [
+    {
+      key: 'nationalityType', label: 'Passenger Type',
+      render: (c: SeatClass) => (
+        <Badge variant="status" status={c.nationalityType === 'LOCAL' ? 'CONFIRMED' : 'INFO'}>
+          {c.nationalityType === 'LOCAL' ? 'Local' : 'International'}
+        </Badge>
+      ),
+    },
+    {
+      key: 'coachType', label: 'Coach Type',
+      render: (c: SeatClass) => {
+        const ct = coachTypes.find(t => t.id === c.coachTypeId);
+        return <span className="text-sm">{ct ? `${ct.code} — ${ct.name}` : c.coachTypeId}</span>;
+      },
+    },
+    {
+      key: 'name', label: 'Class Name',
+      render: (c: SeatClass) => <span className="font-medium">{c.name}</span>,
+    },
+    {
+      key: 'baseFareMinor', label: 'Rate per km',
+      render: (c: SeatClass) => {
+        const ct = coachTypes.find(t => t.id === c.coachTypeId);
+        const ref = ct ? getTariffRef(c.nationalityType!, ct.code, c.bedPosition ?? null) : undefined;
+        const tariffMinor = ref ? Math.round(ref * 100) : undefined;
+        const matches = tariffMinor === c.baseFareMinor;
+        return (
+          <div className="flex items-center gap-2">
+            <span className="font-mono font-medium">{c.baseFareMinor! / 100}</span>
+            {tariffMinor !== undefined && (
+              <span className={`text-xs px-1.5 py-0.5 rounded ${matches ? 'bg-green-100 text-green-700 dark:bg-green-900/30 dark:text-green-400' : 'bg-yellow-100 text-yellow-700 dark:bg-yellow-900/30 dark:text-yellow-400'}`}>
+                {matches ? '✓ tariff' : `tariff: ${tariffMinor / 100}`}
+              </span>
+            )}
+          </div>
+        );
+      },
+    },
+    {
+      key: 'insuranceFeeMinor', label: 'Insurance Fee',
+      render: (c: SeatClass) => (
+        <span className="font-mono text-sm">{c.insuranceFeeMinor ? (c.insuranceFeeMinor / 100).toFixed(2) : '0.00'} ETB</span>
+      ),
+    },
+    {
+      key: 'isActive', label: 'Status',
+      render: (c: SeatClass) => (
+        <Badge variant="status" status={c.isActive ? 'CONFIRMED' : 'CANCELLED'}>
+          {c.isActive ? 'Active' : 'Inactive'}
+        </Badge>
+      ),
+    },
+  ];
+
+  return (
+    <>
+      <div className="relative mb-4">
+        <Search className="absolute left-3 top-1/2 -translate-y-1/2 h-4 w-4 text-muted-foreground" />
+        <input
+          type="text"
+          placeholder="Search by name, nationality, etc."
+          className="input pl-10 w-full"
+          value={search}
+          onChange={e => setSearch(e.target.value)}
+        />
+      </div>
+
+      <DataTable
+        data={displayed}
+        columns={columns}
+        actions={[
+          { label: 'Edit', icon: Edit, variant: 'secondary' as const, onClick: onEdit },
+          { label: 'Delete', icon: Trash2, variant: 'danger' as const, onClick: handleDeleteClick },
+        ]}
+        loading={isLoading}
+        emptyMessage={search ? 'No tariff rates match your search' : 'No tariff rates found'}
+      />
+
+      <ConfirmDialog
+        isOpen={deleteConfirm.isOpen}
+        onClose={() => setDeleteConfirm({ isOpen: false, item: null, cascade: false, cascadeChecked: false })}
+        onConfirm={handleConfirm}
+        title="Delete Tariff Rate"
+        message={`Delete "${deleteConfirm.item?.name}"? This will affect fare calculations for this class.`}
+        confirmText="Delete"
+        isDanger
+        isLoading={isDeleting}
+        error={deleteConfirm.error}
+        warning={!deleteConfirm.cascade
+          ? 'This seat class may be referenced by fare rules, route overrides, and segment fares. Deleting it will impact pricing across all routes.'
+          : undefined}
+        cascadeWarning={deleteConfirm.cascade
+          ? 'This seat class has related fare rules, route overrides, or segment fares that will also be permanently deleted.'
+          : undefined}
+        cascadeChecked={deleteConfirm.cascadeChecked}
+        onCascadeChange={checked => setDeleteConfirm(prev => ({ ...prev, cascadeChecked: checked }))}
+      />
+    </>
+  );
+}
diff --git a/apps/edr-passenger-web/backoffice/src/app/tariff-rates/constants.ts b/apps/edr-passenger-web/backoffice/src/app/tariff-rates/constants.ts
new file mode 100644
index 000000000..f34a80b69
--- /dev/null
+++ b/apps/edr-passenger-web/backoffice/src/app/tariff-rates/constants.ts
@@ -0,0 +1,31 @@
+export const BED_POSITIONS = ['UPPER', 'MIDDLE', 'LOWER'] as const;
+
+export const COACH_TYPE_LABELS: Record<string, string> = {
+  HSC: 'Regular Seat (Hard Seat)',
+  HBC: 'Economy Bed (Hard Berth)',
+  SBC: 'VIP Bed (Soft Berth)',
+};
+
+export const TARIFF_REFERENCE: Record<string, Record<string, number>> = {
+  LOCAL: {
+    'HSC-null': 0.03,
+    'HBC-UPPER': 0.04,
+    'HBC-MIDDLE': 0.055,
+    'HBC-LOWER': 0.06,
+    'SBC-UPPER': 0.075,
+    'SBC-LOWER': 0.08,
+  },
+  INTERNATIONAL: {
+    'HSC-null': 0.06,
+    'HBC-UPPER': 0.08,
+    'HBC-MIDDLE': 0.11,
+    'HBC-LOWER': 0.12,
+    'SBC-UPPER': 0.15,
+    'SBC-LOWER': 0.16,
+  },
+};
+
+export function getTariffRef(nationalityType: string, coachCode: string, bedPosition: string | null) {
+  const key = `${coachCode}-${bedPosition ?? 'null'}`;
+  return TARIFF_REFERENCE[nationalityType]?.[key];
+}
diff --git a/apps/edr-passenger-web/backoffice/src/app/tariff-rates/hooks.ts b/apps/edr-passenger-web/backoffice/src/app/tariff-rates/hooks.ts
new file mode 100644
index 000000000..5dad6f4be
--- /dev/null
+++ b/apps/edr-passenger-web/backoffice/src/app/tariff-rates/hooks.ts
@@ -0,0 +1,135 @@
+import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
+import { apiClient } from '@/lib/api-client';
+import type { SeatClass, CoachType, Route, RouteFareRule, SegmentFareRule, BaggageAllowance } from './types';
+
+function toArray<T>(data: unknown): T[] {
+  if (Array.isArray(data)) return data as T[];
+  const d = data as any;
+  return d?.items ?? d?.data ?? [];
+}
+
+export function useSeatClasses() {
+  const { data, isLoading } = useQuery({
+    queryKey: ['seat-classes'],
+    queryFn: () => apiClient.get<unknown>('/seat-classes'),
+  });
+  return { allClasses: toArray<SeatClass>(data), isLoading };
+}
+
+export function useCoachTypes() {
+  const { data } = useQuery({
+    queryKey: ['coach-types'],
+    queryFn: () => apiClient.get<unknown>('/fleet/coach-types'),
+  });
+  return { coachTypes: toArray<CoachType>(data) };
+}
+
+export function useRoutes() {
+  const { data } = useQuery({
+    queryKey: ['routes-active'],
+    queryFn: () => apiClient.get<unknown>('/routes?activeOnly=true'),
+  });
+  return { routes: toArray<Route>(data) };
+}
+
+export function useSegmentFareRules(routeId: string | null) {
+  const { data, isLoading, refetch } = useQuery({
+    queryKey: ['segment-fare-rules', routeId],
+    queryFn: () => apiClient.get<unknown>(`/schedules/routes/${routeId}/segment-fares`),
+    enabled: !!routeId,
+  });
+  return { segmentFares: toArray<SegmentFareRule>(data), isLoading, refetch };
+}
+
+export function useSegmentFareMutations(routeId: string | null) {
+  const queryClient = useQueryClient();
+  const invalidate = () => queryClient.invalidateQueries({ queryKey: ['segment-fare-rules', routeId] });
+
+  const create = useMutation({
+    mutationFn: (data: any) => apiClient.post('/schedules/segment-fares', data),
+    onSuccess: invalidate,
+  });
+  const update = useMutation({
+    mutationFn: ({ id, ...data }: any) => apiClient.patch(`/schedules/segment-fares/${id}`, data),
+    onSuccess: invalidate,
+  });
+  const remove = useMutation({
+    mutationFn: (id: string) => apiClient.delete(`/schedules/segment-fares/${id}`),
+    onSuccess: invalidate,
+  });
+
+  return { create, update, remove };
+}
+
+export function useRouteFareRules(routeId: string | null) {
+  const { data, isLoading, refetch } = useQuery({
+    queryKey: ['route-fare-rules', routeId],
+    queryFn: () => apiClient.get<unknown>(`/schedules/routes/${routeId}/fare-rules`),
+    enabled: !!routeId,
+  });
+  return { overrides: toArray<RouteFareRule>(data), isLoading, refetch };
+}
+
+export function useSeatClassMutations(onSuccess: () => void) {
+  const queryClient = useQueryClient();
+  const invalidate = () => queryClient.invalidateQueries({ queryKey: ['seat-classes'] });
+
+  const create = useMutation({
+    mutationFn: (data: any) => apiClient.post('/seat-classes', data),
+    onSuccess: () => { invalidate(); onSuccess(); },
+  });
+  const update = useMutation({
+    mutationFn: ({ id, data }: { id: string; data: any }) => apiClient.patch(`/seat-classes/${id}`, data),
+    onSuccess: () => { invalidate(); onSuccess(); },
+  });
+  const remove = useMutation({
+    mutationFn: ({ id, cascade }: { id: string; cascade?: boolean }) =>
+      apiClient.delete(`/seat-classes/${id}${cascade ? '?cascade=true' : ''}`),
+    onSuccess: invalidate,
+  });
+
+  return { create, update, remove };
+}
+
+export function useRouteFareRuleMutations(routeId: string | null) {
+  const queryClient = useQueryClient();
+  const invalidate = (rid?: string) =>
+    queryClient.invalidateQueries({ queryKey: ['route-fare-rules', rid ?? routeId] });
+
+  const create = useMutation({
+    mutationFn: ({ routeId: rid, ...data }: any) => apiClient.post(`/schedules/routes/${rid}/fare-rules`, data),
+    onSuccess: (_: any, vars: any) => invalidate(vars.routeId),
+  });
+  const update = useMutation({
+    mutationFn: ({ id, ...data }: any) => apiClient.patch<any>(`/schedules/routes/fare-rules/${id}`, data),
+    onSuccess: invalidate,
+  });
+  const remove = useMutation({
+    mutationFn: (id: string) => apiClient.delete<any>(`/schedules/routes/fare-rules/${id}`),
+    onSuccess: invalidate,
+  });
+
+  return { create, update, remove };
+}
+
+export function useBaggageMutations() {
+  const { data, isLoading, refetch } = useQuery({
+    queryKey: ['baggage-allowances'],
+    queryFn: () => apiClient.get<unknown>('/agents/excess-baggage/allowances'),
+  });
+
+  const create = useMutation({
+    mutationFn: (data: any) => apiClient.post('/agents/excess-baggage/allowances', data),
+    onSuccess: () => refetch(),
+  });
+  const update = useMutation({
+    mutationFn: ({ id, ...data }: any) => apiClient.patch(`/agents/excess-baggage/allowances/${id}`, data),
+    onSuccess: () => refetch(),
+  });
+  const remove = useMutation({
+    mutationFn: (id: string) => apiClient.delete(`/agents/excess-baggage/allowances/${id}`),
+    onSuccess: () => refetch(),
+  });
+
+  return { allowances: toArray<BaggageAllowance>(data), isLoading, create, update, remove };
+}
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 530b335e7..7239809f0 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
@@ -1,285 +1,66 @@
 'use client';
 
 import { useState } from 'react';
-import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
-import { Plus, Edit, Trash2, Search } from 'lucide-react';
-import DataTable from '@/components/ui/DataTable';
-import Badge from '@/components/ui/Badge';
+import { Plus } from 'lucide-react';
 import ActionButton from '@/components/ui/ActionButton';
-import Modal from '@/components/ui/Modal';
-import ConfirmDialog from '@/components/ui/ConfirmDialog';
-import { apiClient } from '@/lib/api-client';
-
-interface SeatClass { id: string; name: string; }
-
-const BED_POSITIONS = ['UPPER', 'MIDDLE', 'LOWER'] as const;
-const COACH_TYPE_LABELS: Record<string, string> = {
-  HSC: 'Regular Seat (Hard Seat)',
-  HBC: 'Economy Bed (Hard Berth)',
-  SBC: 'VIP Bed (Soft Berth)',
-};
-
-const TARIFF_REFERENCE: Record<string, Record<string, number>> = {
-  LOCAL: {
-    'HSC-null': 0.03,
-    'HBC-UPPER': 0.04,
-    'HBC-MIDDLE': 0.055,
-    'HBC-LOWER': 0.06,
-    'SBC-UPPER': 0.075,
-    'SBC-LOWER': 0.08,
-  },
-  INTERNATIONAL: {
-    'HSC-null': 0.06,
-    'HBC-UPPER': 0.08,
-    'HBC-MIDDLE': 0.11,
-    'HBC-LOWER': 0.12,
-    'SBC-UPPER': 0.15,
-    'SBC-LOWER': 0.16,
-  },
-};
-
-function getTariffRef(nationalityType: string, coachCode: string, bedPosition: string | null) {
-  const key = `${coachCode}-${bedPosition ?? 'null'}`;
-  return TARIFF_REFERENCE[nationalityType]?.[key];
-}
+import TariffTab from './TariffTab';
+import OverridesTab from './OverridesTab';
+import SegmentOverridesTab from './SegmentOverridesTab';
+import BaggageTab from './BaggageTab';
+import RateModal from './RateModal';
+import { useSeatClasses, useCoachTypes, useRoutes, useSeatClassMutations, useRouteFareRuleMutations } from './hooks';
+import type { SeatClass, TabType } from './types';
 
 export default function TariffRatesPage() {
-  const [tab, setTab] = useState<'tariff' | 'baggage'>('tariff');
-  const [search, setSearch] = useState('');
-  const [showModal, setShowModal] = useState(false);
-  const [editingClass, setEditingClass] = useState<any>(null);
-  const [deleteConfirm, setDeleteConfirm] = useState<{ isOpen: boolean; item: any | null; error?: string }>({ isOpen: false, item: null });
-  const [formError, setFormError] = useState<string | null>(null);
-  const [selectedCoachTypeId, setSelectedCoachTypeId] = useState('');
-  const [selectedBedPosition, setSelectedBedPosition] = useState<string>('');
-  const [selectedNationalityType, setSelectedNationalityType] = useState<string>('LOCAL');
+  const [tab, setTab] = useState<TabType>('tariff');
+  const [showRateModal, setShowRateModal] = useState(false);
+  const [editingClass, setEditingClass] = useState<SeatClass | null>(null);
+  const [showBaggageModal, setShowBaggageModal] = useState(false);
+  const [preselectedRouteId, setPreselectedRouteId] = useState<string | null>(null);
+  const [deleteError, setDeleteError] = useState<string | undefined>(undefined);
+  const [deleteSuccess, setDeleteSuccess] = useState(0);
 
-  const [baggageForm, setBaggageForm] = useState({ seatClassId: '', maxWeightKg: '', maxPiecesCount: '', excessFeePerKg: '' });
-  const [editingAllowance, setEditingAllowance] = useState<any>(null);
-  const [baggageError, setBaggageError] = useState<string | null>(null);
-  const [baggageModal, setBaggageModal] = useState(false);
-  const [deleteAllowanceConfirm, setDeleteAllowanceConfirm] = useState<{ isOpen: boolean; id: string | null }>({ isOpen: false, id: null });
+  const { allClasses, isLoading } = useSeatClasses();
+  const { coachTypes } = useCoachTypes();
+  const { routes } = useRoutes();
 
-  const queryClient = useQueryClient();
+  const closeRateModal = () => { setShowRateModal(false); setEditingClass(null); setPreselectedRouteId(null); };
 
-  const { data: allowances, isLoading: allowancesLoading, refetch: refetchAllowances } = useQuery({
-    queryKey: ['baggage-allowances'],
-    queryFn: () => apiClient.get<any[]>('/agents/excess-baggage/allowances'),
-    enabled: tab === 'baggage',
-  });
+  const seatClassMutations = useSeatClassMutations(closeRateModal);
+  const overrideMutations = useRouteFareRuleMutations(preselectedRouteId);
 
-  const createAllowanceMutation = useMutation({
-    mutationFn: (data: any) => apiClient.post('/agents/excess-baggage/allowances', data),
-    onSuccess: () => { refetchAllowances(); setBaggageModal(false); setBaggageError(null); },
-    onError: (e: any) => setBaggageError(e?.response?.data?.message || 'Failed to save'),
-  });
-
-  const updateAllowanceMutation = useMutation({
-    mutationFn: ({ id, ...data }: any) => apiClient.patch(`/agents/excess-baggage/allowances/${id}`, data),
-    onSuccess: () => { refetchAllowances(); setBaggageModal(false); setEditingAllowance(null); setBaggageError(null); },
-    onError: (e: any) => setBaggageError(e?.response?.data?.message || 'Failed to update'),
-  });
-
-  const deleteAllowanceMutation = useMutation({
-    mutationFn: (id: string) => apiClient.delete(`/agents/excess-baggage/allowances/${id}`),
-    onSuccess: () => { refetchAllowances(); setDeleteAllowanceConfirm({ isOpen: false, id: null }); },
-    onError: (e: any) => setBaggageError(e?.response?.data?.message || 'Failed to delete'),
-  });
-
-  const handleSaveAllowance = async () => {
-    setBaggageError(null);
-    if (!baggageForm.seatClassId || !baggageForm.maxWeightKg || !baggageForm.maxPiecesCount || !baggageForm.excessFeePerKg) {
-      setBaggageError('All fields are required'); return;
-    }
-    const payload = {
-      seatClassId: baggageForm.seatClassId,
-      maxWeightKg: parseInt(baggageForm.maxWeightKg),
-      maxPiecesCount: parseInt(baggageForm.maxPiecesCount),
-      excessFeePerKg: Math.round(parseFloat(baggageForm.excessFeePerKg) * 100),
-    };
-    if (editingAllowance) {
-      await updateAllowanceMutation.mutateAsync({ id: editingAllowance.id, ...payload });
-    } else {
-      await createAllowanceMutation.mutateAsync(payload);
-    }
-  };
-
-  const { data: classesData, isLoading } = useQuery({
-    queryKey: ['seat-classes'],
-    queryFn: () => apiClient.get<any>('/seat-classes'),
-  });
-
-  const { data: coachTypesData } = useQuery({
-    queryKey: ['coach-types'],
-    queryFn: () => apiClient.get<any>('/fleet/coach-types'),
-  });
-
-  const createMutation = useMutation({
-    mutationFn: (data: any) => apiClient.post('/seat-classes', data),
-    onSuccess: () => { queryClient.invalidateQueries({ queryKey: ['seat-classes'] }); closeModal(); },
-    onError: (e: any) => setFormError(e?.response?.data?.message || e?.message || 'Failed to save'),
-  });
-
-  const updateMutation = useMutation({
-    mutationFn: ({ id, data }: { id: string; data: any }) => apiClient.patch(`/seat-classes/${id}`, data),
-    onSuccess: () => { queryClient.invalidateQueries({ queryKey: ['seat-classes'] }); closeModal(); },
-    onError: (e: any) => setFormError(e?.response?.data?.message || e?.message || 'Failed to update'),
-  });
-
-  const deleteMutation = useMutation({
-    mutationFn: (id: string) => apiClient.delete(`/seat-classes/${id}`),
-    onSuccess: () => { queryClient.invalidateQueries({ queryKey: ['seat-classes'] }); setDeleteConfirm({ isOpen: false, item: null }); },
-    onError: (e: any) => setDeleteConfirm(prev => ({ ...prev, error: e?.response?.data?.message || e?.message || 'Delete failed' })),
-  });
-
-  const closeModal = () => {
-    setShowModal(false);
-    setEditingClass(null);
-    setFormError(null);
-    setSelectedCoachTypeId('');
-    setSelectedBedPosition('');
-    setSelectedNationalityType('LOCAL');
-  };
-
-  const openEdit = (cls: any) => {
-    setEditingClass(cls);
-    setSelectedCoachTypeId(cls.coachTypeId || '');
-    setSelectedBedPosition(cls.bedPosition || '');
-    setSelectedNationalityType(cls.nationalityType || 'LOCAL');
-    setFormError(null);
-    setShowModal(true);
-  };
-
-  const handleSubmit = async (e: React.FormEvent<HTMLFormElement>) => {
-    e.preventDefault();
-    setFormError(null);
-    const fd = new FormData(e.currentTarget);
-    const payload: any = {
-      coachTypeId: selectedCoachTypeId,
-      name: fd.get('name') as string,
-      nationalityType: selectedNationalityType,
-      bedPosition: selectedBedPosition || null,
-      basePrice: Math.round(Number(fd.get('baseFareMinor') as string) * 100) || 0,
-      insuranceFeeMinor: Math.round(Number(fd.get('insuranceFeeMinor') as string) * 100) || 0,
-      isActive: fd.get('isActive') === 'true',
-    };
+  const handleSubmitGlobal = async (payload: any) => {
     if (editingClass) {
-      await updateMutation.mutateAsync({ id: editingClass.id, data: payload });
+      await seatClassMutations.update.mutateAsync({ id: editingClass.id, data: payload });
     } else {
-      await createMutation.mutateAsync(payload);
+      await seatClassMutations.create.mutateAsync(payload);
+    }
+    closeRateModal();
+  };
+
+  const handleSubmitOverride = async (routeId: string, payload: any) => {
+    await overrideMutations.create.mutateAsync({ routeId, ...payload });
+    closeRateModal();
+  };
+
+  const handleDelete = async (id: string, cascade: boolean) => {
+    setDeleteError(undefined);
+    try {
+      await seatClassMutations.remove.mutateAsync({ id, cascade });
+      setDeleteSuccess(n => n + 1);
+    } catch (err: any) {
+      const msg = err?.response?.data?.message ?? err?.message ?? 'Delete failed';
+      setDeleteError(Array.isArray(msg) ? msg.join(' ') : msg);
     }
   };
 
-  const coachTypesArray: any[] = Array.isArray(coachTypesData)
-    ? coachTypesData
-    : (coachTypesData as any)?.data || (coachTypesData as any)?.items || [];
-
-  const allClasses: any[] = Array.isArray(classesData)
-    ? classesData
-    : (classesData as any)?.items || (classesData as any)?.data || [];
-
-  const allowancesArray: any[] = Array.isArray(allowances) ? allowances : (allowances as any)?.items || [];
-
-  const tariffClasses = allClasses.filter((c: any) => c.nationalityType);
-
-  const displayed = tariffClasses.filter((c: any) => {
-    if (!search) return true;
-    const s = search.toLowerCase();
-    return (
-      c.name?.toLowerCase().includes(s) ||
-      c.nationalityType?.toLowerCase().includes(s) ||
-      c.bedPosition?.toLowerCase().includes(s) ||
-      c.coachType?.name?.toLowerCase().includes(s)
-    );
-  }).sort((a: any, b: any) => {
-    if (a.nationalityType === b.nationalityType) return 0;
-    return a.nationalityType === 'LOCAL' ? -1 : 1;
-  });
-
-  const suggestName = () => {
-    const ct = coachTypesArray.find((c: any) => c.id === selectedCoachTypeId);
-    if (!ct) return '';
-    const label = COACH_TYPE_LABELS[ct.code] || ct.name;
-    const pos = selectedBedPosition ? ` ${selectedBedPosition.charAt(0) + selectedBedPosition.slice(1).toLowerCase()}` : '';
-    const nat = selectedNationalityType === 'LOCAL' ? 'Local' : 'Intl';
-    return `${label}${pos} (${nat})`;
-  };
-
-  // Returns the human-readable rate (e.g. 0.03); stored value = this × 100
-  const suggestRate = () => {
-    const ct = coachTypesArray.find((c: any) => c.id === selectedCoachTypeId);
-    if (!ct) return '';
-    const ref = getTariffRef(selectedNationalityType, ct.code, selectedBedPosition || null);
-    return ref ? String(ref) : '';
-  };
-
-  const columns = [
-    {
-      key: 'nationalityType', label: 'Passenger Type',
-      render: (c: any) => (
-        <Badge variant="status" status={c.nationalityType === 'LOCAL' ? 'CONFIRMED' : 'INFO'}>
-          {c.nationalityType === 'LOCAL' ? 'Local' : 'International'}
-        </Badge>
-      ),
-    },
-    {
-      key: 'coachType', label: 'Coach Type',
-      render: (c: any) => {
-        const ct = coachTypesArray.find((t: any) => t.id === c.coachTypeId);
-        return <span className="text-sm">{ct ? `${ct.code} — ${ct.name}` : c.coachTypeId}</span>;
-      },
-    },
-    {
-      key: 'name', label: 'Class Name',
-      render: (c: any) => <span className="font-medium">{c.name}</span>,
-    },
-    {
-      key: 'baseFareMinor', label: 'Rate per km',
-      render: (c: any) => {
-        const ct = coachTypesArray.find((t: any) => t.id === c.coachTypeId);
-        const ref = ct ? getTariffRef(c.nationalityType, ct.code, c.bedPosition) : undefined;
-        const tariffMinor = ref ? Math.round(ref * 100) : undefined;
-        const matches = tariffMinor === c.baseFareMinor;
-        return (
-          <div className="flex items-center gap-2">
-            <span className="font-mono font-medium">{c.baseFareMinor / 100}</span>
-            {tariffMinor !== undefined && (
-              <span className={`text-xs px-1.5 py-0.5 rounded ${matches ? 'bg-green-100 text-green-700 dark:bg-green-900/30 dark:text-green-400' : 'bg-yellow-100 text-yellow-700 dark:bg-yellow-900/30 dark:text-yellow-400'}`}>
-                {matches ? '✓ tariff' : `tariff: ${tariffMinor / 100}`}
-              </span>
-            )}
-          </div>
-        );
-      },
-    },
-    {
-      key: 'insuranceFeeMinor', label: 'Insurance Fee',
-      render: (c: any) => (
-        <span className="font-mono text-sm">{c.insuranceFeeMinor ? (c.insuranceFeeMinor / 100).toFixed(2) : '0.00'} ETB</span>
-      ),
-    },
-    {
-      key: 'isActive', label: 'Status',
-      render: (c: any) => (
-        <Badge variant="status" status={c.isActive ? 'CONFIRMED' : 'CANCELLED'}>
-          {c.isActive ? 'Active' : 'Inactive'}
-        </Badge>
-      ),
-    },
+  const tabs: { key: TabType; label: string }[] = [
+    { key: 'tariff', label: 'Seat Class Tariffs' },
+    { key: 'overrides', label: 'Route Overrides' },
+    { key: 'segment-overrides', label: 'Segment Overrides' },
+    { key: 'baggage', label: 'Excess Luggage Rates' },
   ];
 
-  const actions = [
-    { label: 'Edit', icon: Edit, variant: 'secondary' as const, onClick: openEdit },
-    {
-      label: 'Delete', icon: Trash2, variant: 'danger' as const,
-      onClick: (c: any) => setDeleteConfirm({ isOpen: true, item: c }),
-    },
-  ];
-
-  const selectedCoachType = coachTypesArray.find((c: any) => c.id === selectedCoachTypeId)
-    ?? editingClass?.coachType;
-  const isBedCoach = selectedCoachType?.name?.toLowerCase().includes('bed') || selectedCoachType?.code?.toLowerCase().includes('bed');
-
   return (
     <div className="space-y-6">
       <div className="flex items-center justify-between">
@@ -289,332 +70,76 @@ export default function TariffRatesPage() {
             Manage per-km fare rates and excess luggage allowances per the official EDR tariff policy
           </p>
         </div>
-        <ActionButton
-          icon={Plus}
-          onClick={() => {
+        {tab !== 'overrides' && tab !== 'segment-overrides' && (
+          <ActionButton icon={Plus} onClick={() => {
             if (tab === 'baggage') {
-              setBaggageForm({ seatClassId: '', maxWeightKg: '', maxPiecesCount: '', excessFeePerKg: '' });
-              setEditingAllowance(null);
-              setBaggageError(null);
-              setBaggageModal(true);
+              setShowBaggageModal(true);
             } else {
               setEditingClass(null);
-              setFormError(null);
-              setShowModal(true);
+              setPreselectedRouteId(null);
+              setShowRateModal(true);
             }
-          }}
-        >
-          {tab === 'baggage' ? 'Add Allowance Rule' : 'Add Rate'}
-        </ActionButton>
+          }}>
+            {tab === 'baggage' ? 'Add Allowance Rule' : 'Add Rate'}
+          </ActionButton>
+        )}
       </div>
 
       <div className="card">
         <div className="flex gap-4 border-b mb-6">
-          <button
-            onClick={() => setTab('tariff')}
-            className={`px-4 py-2 font-medium border-b-2 transition-colors ${tab === 'tariff' ? 'border-primary text-primary' : 'border-transparent text-muted-foreground'}`}
-          >
-            Seat Class Tariffs
-          </button>
-          <button
-            onClick={() => setTab('baggage')}
-            className={`px-4 py-2 font-medium border-b-2 transition-colors ${tab === 'baggage' ? 'border-primary text-primary' : 'border-transparent text-muted-foreground'}`}
-          >
-            Excess Luggage Rates
-          </button>
+          {tabs.map(t => (
+            <button
+              key={t.key}
+              onClick={() => setTab(t.key)}
+              className={`px-4 py-2 font-medium border-b-2 transition-colors ${tab === t.key ? 'border-primary text-primary' : 'border-transparent text-muted-foreground'}`}
+            >
+              {t.label}
+            </button>
+          ))}
         </div>
 
         {tab === 'tariff' && (
-          <>
-            <div className="relative mb-4">
-              <Search className="absolute left-3 top-1/2 -translate-y-1/2 h-4 w-4 text-muted-foreground" />
-              <input
-                type="text"
-                placeholder="Search by name, nationality, etc."
-                className="input pl-10 w-full"
-                value={search}
-                onChange={(e) => setSearch(e.target.value)}
-              />
-            </div>
-            <DataTable
-              data={displayed}
-              columns={columns}
-              actions={actions}
-              loading={isLoading}
-              emptyMessage={search ? 'No tariff rates match your search' : 'No tariff rates found'}
-            />
-          </>
+          <TariffTab
+            classes={allClasses}
+            coachTypes={coachTypes}
+            isLoading={isLoading}
+            onEdit={cls => { setEditingClass(cls); setPreselectedRouteId(null); setShowRateModal(true); }}
+            onDelete={handleDelete}
+            isDeleting={seatClassMutations.remove.isPending}
+            deleteError={deleteError}
+            deleteSuccess={deleteSuccess}
+          />
+        )}
+
+        {tab === 'overrides' && (
+          <OverridesTab routes={routes} />
+        )}
+
+        {tab === 'segment-overrides' && (
+          <SegmentOverridesTab routes={routes} />
         )}
 
         {tab === 'baggage' && (
-          allowancesLoading ? (
-            <div className="flex items-center justify-center py-8">
-              <div className="h-6 w-6 animate-spin rounded-full border-2 border-primary border-t-transparent" />
-            </div>
-          ) : allowancesArray.length === 0 ? (
-            <div className="text-center py-8 text-muted-foreground">
-              No baggage allowance rules defined. Click "Add Allowance Rule" to create one.
-            </div>
-          ) : (
-            <DataTable
-              data={allowancesArray}
-              columns={[
-                { key: 'seatClass', label: 'Seat Class', render: (a: any) => <span className="font-medium">{a.seatClass?.name ?? a.seatClassId}</span> },
-                { key: 'maxWeightKg', label: 'Free Allowance', render: (a: any) => <span>{a.maxWeightKg} kg, {a.maxPiecesCount} pcs</span> },
-                { key: 'excessFeePerKg', label: 'Excess Fee / kg', render: (a: any) => <span className="font-mono font-semibold">{(a.excessFeePerKg / 100).toFixed(2)} ETB</span> },
-              ]}
-              actions={[
-                {
-                  label: 'Edit', icon: Edit, variant: 'secondary' as const,
-                  onClick: (a: any) => {
-                    setEditingAllowance(a);
-                    setBaggageForm({
-                      seatClassId: a.seatClassId,
-                      maxWeightKg: String(a.maxWeightKg),
-                      maxPiecesCount: String(a.maxPiecesCount),
-                      excessFeePerKg: (a.excessFeePerKg / 100).toFixed(2),
-                    });
-                    setBaggageError(null);
-                    setBaggageModal(true);
-                  },
-                },
-                {
-                  label: 'Delete', icon: Trash2, variant: 'danger' as const,
-                  onClick: (a: any) => setDeleteAllowanceConfirm({ isOpen: true, id: a.id }),
-                },
-              ]}
-              loading={false}
-              emptyMessage="No allowance rules found."
-            />
-          )
+          <BaggageTab
+            allClasses={allClasses}
+            isOpen={showBaggageModal}
+            onClose={() => setShowBaggageModal(false)}
+          />
         )}
       </div>
 
-      <ConfirmDialog
-        isOpen={deleteConfirm.isOpen}
-        onClose={() => setDeleteConfirm({ isOpen: false, item: null })}
-        onConfirm={() => deleteMutation.mutate(deleteConfirm.item?.id)}
-        title="Delete Tariff Rate"
-        message={`Delete "${deleteConfirm.item?.name}"? This will affect fare calculations for this class.`}
-        confirmText="Delete"
-        isDanger
-        isLoading={deleteMutation.isPending}
-        error={deleteConfirm.error}
-        warning="Bookings in progress may be affected. Ensure a replacement rate exists."
+      <RateModal
+        isOpen={showRateModal}
+        onClose={closeRateModal}
+        editingClass={editingClass}
+        allClasses={allClasses}
+        coachTypes={coachTypes}
+        routes={routes}
+        preselectedRouteId={preselectedRouteId}
+        onSubmitGlobal={handleSubmitGlobal}
+        onSubmitOverride={handleSubmitOverride}
+        isPending={seatClassMutations.create.isPending || seatClassMutations.update.isPending || overrideMutations.create.isPending}
       />
-
-      <ConfirmDialog
-        isOpen={deleteAllowanceConfirm.isOpen}
-        onClose={() => setDeleteAllowanceConfirm({ isOpen: false, id: null })}
-        onConfirm={() => deleteAllowanceMutation.mutateAsync(deleteAllowanceConfirm.id!)}
-        title="Delete Allowance Rule"
-        message="Are you sure you want to delete this baggage allowance rule?"
-        confirmText="Delete"
-        isDanger
-        isLoading={deleteAllowanceMutation.isPending}
-        warning="The excess baggage fallback rate (50 ETB/kg) will apply until a new rule is created."
-      />
-
-      <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>
-          )}
-          <div>
-            <label className="label">Seat Class *</label>
-            <select value={baggageForm.seatClassId} onChange={(e) => setBaggageForm({ ...baggageForm, seatClassId: e.target.value })} className="input w-full" disabled={!!editingAllowance}>
-              <option value="">Select seat class...</option>
-              {allClasses.map((sc: SeatClass) => <option key={sc.id} value={sc.id}>{sc.name}</option>)}
-            </select>
-            {editingAllowance && <p className="text-xs text-muted-foreground mt-1">Seat class cannot be changed. Delete and recreate to change.</p>}
-          </div>
-          <div className="grid grid-cols-2 gap-4">
-            <div>
-              <label className="label">Free Allowance (kg) *</label>
-              <input type="number" min="0" className="input w-full" placeholder="e.g. 20" value={baggageForm.maxWeightKg} onChange={(e) => setBaggageForm({ ...baggageForm, maxWeightKg: e.target.value })} />
-            </div>
-            <div>
-              <label className="label">Max Pieces *</label>
-              <input type="number" min="1" className="input w-full" placeholder="e.g. 2" value={baggageForm.maxPiecesCount} onChange={(e) => setBaggageForm({ ...baggageForm, maxPiecesCount: e.target.value })} />
-            </div>
-          </div>
-          <div>
-            <label className="label">Excess Fee per kg (ETB) *</label>
-            <input type="number" min="0" step="0.01" className="input w-full" placeholder="e.g. 50.00" value={baggageForm.excessFeePerKg} onChange={(e) => setBaggageForm({ ...baggageForm, excessFeePerKg: e.target.value })} />
-            <p className="text-xs text-muted-foreground mt-1">Amount charged per kg above the free allowance</p>
-          </div>
-          <div className="flex justify-end gap-2 pt-2">
-            <ActionButton variant="secondary" onClick={() => { setBaggageModal(false); setEditingAllowance(null); setBaggageError(null); }}>Cancel</ActionButton>
-            <ActionButton onClick={handleSaveAllowance} loading={createAllowanceMutation.isPending || updateAllowanceMutation.isPending}>
-              {editingAllowance ? 'Update' : 'Save'}
-            </ActionButton>
-          </div>
-        </div>
-      </Modal>
-
-      <Modal
-        isOpen={showModal}
-        onClose={closeModal}
-        title={`${editingClass ? 'Edit' : 'Add'} Tariff Rate`}
-        size="lg"
-      >
-        <form key={editingClass?.id ?? 'new'} onSubmit={handleSubmit} className="space-y-4">
-          {formError && (
-            <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-800 dark:text-red-200">
-              {formError}
-            </div>
-          )}
-
-          <div className="grid grid-cols-1 md:grid-cols-2 gap-4">
-            <div>
-              <label className="label">Passenger Nationality *</label>
-              <select
-                className="input"
-                value={selectedNationalityType}
-                onChange={(e) => setSelectedNationalityType(e.target.value)}
-                required
-              >
-                <option value="LOCAL">Local (Ethiopian / Djiboutian)</option>
-                <option value="INTERNATIONAL">International (Foreign nationals)</option>
-              </select>
-            </div>
-
-            <div>
-              <label className="label">Coach Type *</label>
-              <select
-                className="input"
-                value={selectedCoachTypeId}
-                onChange={(e) => { setSelectedCoachTypeId(e.target.value); setSelectedBedPosition(''); }}
-                required
-              >
-                <option value="">Select coach type</option>
-                {coachTypesArray.map((ct: any) => (
-                  <option key={ct.id} value={ct.id}>
-                    {ct.code} — {ct.name}
-                  </option>
-                ))}
-              </select>
-            </div>
-
-            {isBedCoach && (
-              <div>
-                <label className="label">Bed Position *</label>
-                <select
-                  className="input"
-                  value={selectedBedPosition}
-                  onChange={(e) => setSelectedBedPosition(e.target.value)}
-                  required={isBedCoach}
-                >
-                  <option value="">Select bed position</option>
-                  {(selectedCoachType?.code === 'HBC'
-                    ? BED_POSITIONS
-                    : (['Upper','Middle',  'Lower'] as const)
-                  ).map((pos) => (
-                    <option key={pos} value={pos}>{pos}</option>
-                  ))}
-                </select>
-                <p className="text-xs text-muted-foreground mt-1">
-                  {selectedCoachType?.code === 'HBC' ? 'Economy Bed: Upper / Middle / Lower' : 'VIP Bed: Upper / Lower'}
-                </p>
-              </div>
-            )}
-
-            <div>
-              <label className="label">Class Name *</label>
-              <input
-                type="text"
-                name="name"
-                className="input"
-                defaultValue={editingClass?.name || ''}
-                key={editingClass?.id ?? `new-${selectedCoachTypeId}-${selectedBedPosition}-${selectedNationalityType}`}
-                placeholder={suggestName() || 'e.g. Economy Bed Upper (Local)'}
-                required
-              />
-              {!editingClass && suggestName() && (
-                <p className="text-xs text-muted-foreground mt-1">
-                  Suggested:{' '}
-                  <button
-                    type="button"
-                    className="text-primary underline"
-                    onClick={(e) => {
-                      const inp = (e.currentTarget.closest('.space-y-4')?.querySelector('input[name=name]') as HTMLInputElement);
-                      if (inp) inp.value = suggestName();
-                    }}
-                  >
-                    {suggestName()}
-                  </button>
-                </p>
-              )}
-            </div>
-
-            <div>
-              <label className="label">Rate per km *</label>
-              <input
-                type="number"
-                name="baseFareMinor"
-                className="input"
-                defaultValue={editingClass ? editingClass.baseFareMinor / 100 : ''}
-                key={editingClass?.id ?? `rate-${selectedCoachTypeId}-${selectedBedPosition}-${selectedNationalityType}`}
-                placeholder={suggestRate() || 'e.g. 6'}
-                min="0"
-                step="any"
-                required
-              />
-              {suggestRate() && (
-                <p className="text-xs text-muted-foreground mt-1">
-                  Official tariff rate:{' '}
-                  <button
-                    type="button"
-                    className="text-primary underline"
-                    onClick={(e) => {
-                      const inp = (e.currentTarget.closest('.space-y-4')?.querySelector('input[name=baseFareMinor]') as HTMLInputElement);
-                      if (inp) inp.value = suggestRate();
-                    }}
-                  >
-                    {suggestRate()}
-                  </button>
-                  {' '}(stored as {Math.round(Number(suggestRate()) * 100)})
-                </p>
-              )}
-            </div>
-
-            <div>
-              <label className="label">Insurance Fee (ETB)</label>
-              <input
-                type="number"
-                name="insuranceFeeMinor"
-                className="input"
-                defaultValue={editingClass ? (editingClass.insuranceFeeMinor / 100).toFixed(2) : '0.00'}
-                key={editingClass?.id ?? 'new-insurance'}
-                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>
-              <label className="label">Status</label>
-              <select name="isActive" className="input" defaultValue={editingClass?.isActive !== false ? 'true' : 'false'}>
-                <option value="true">Active</option>
-                <option value="false">Inactive</option>
-              </select>
-            </div>
-          </div>
-
-          <div className="flex justify-end gap-2 pt-4">
-            <ActionButton type="button" variant="secondary" onClick={closeModal}>Cancel</ActionButton>
-            <ActionButton type="submit" loading={createMutation.isPending || updateMutation.isPending}>
-              {editingClass ? 'Update' : 'Create'} Rate
-            </ActionButton>
-          </div>
-        </form>
-      </Modal>
     </div>
   );
 }
diff --git a/apps/edr-passenger-web/backoffice/src/app/tariff-rates/types.ts b/apps/edr-passenger-web/backoffice/src/app/tariff-rates/types.ts
new file mode 100644
index 000000000..a99de7709
--- /dev/null
+++ b/apps/edr-passenger-web/backoffice/src/app/tariff-rates/types.ts
@@ -0,0 +1,63 @@
+export interface SeatClass {
+  id: string;
+  name: string;
+  coachTypeId?: string;
+  nationalityType?: string;
+  bedPosition?: string | null;
+  baseFareMinor?: number;
+  insuranceFeeMinor?: number;
+  isActive?: boolean;
+}
+
+export interface CoachType {
+  id: string;
+  code: string;
+  name: string;
+}
+
+export interface Route {
+  id: string;
+  name: string;
+  code?: string;
+}
+
+export interface SegmentFareRule {
+  id: string;
+  routeId: string;
+  originStopSequence: number;
+  destinationStopSequence: number;
+  seatClassId: string;
+  baseFareMinor: number;
+  nationality?: string | null;
+  currency: string;
+  validFrom: string;
+  validUntil?: string | null;
+  createdAt: string;
+  seatClass?: SeatClass;
+  route?: Route;
+}
+
+export interface RouteFareRule {
+  id: string;
+  routeId: string;
+  seatClassId: string;
+  passengerCategory: string;
+  baseFareMinor: number;
+  surchargeMinor?: number | null;
+  validFrom: string;
+  validUntil?: string | null;
+  createdAt: string;
+  seatClass?: SeatClass;
+  route?: Route;
+}
+
+export interface BaggageAllowance {
+  id: string;
+  seatClassId: string;
+  maxWeightKg: number;
+  maxPiecesCount: number;
+  excessFeePerKg: number;
+  seatClass?: SeatClass;
+}
+
+export type TabType = 'tariff' | 'overrides' | 'segment-overrides' | 'baggage';
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 d7fddfac9..2396ca8b7 100644
--- a/apps/edr-passenger-web/backoffice/src/components/layout/Sidebar.tsx
+++ b/apps/edr-passenger-web/backoffice/src/components/layout/Sidebar.tsx
@@ -70,33 +70,33 @@ const navigationSections: { title: string; items: NavItem[] }[] = [
   {
     title: 'Tourism',
     items: [
-      { name: 'Packages',         href: '/packages',          icon: Package,       permission: PERMS.admin },
-      // { name: 'Bookings',     href: '/package-bookings',  icon: Ticket,        permission: PERMS.admin },
-      { name: 'Inquiries',        href: '/package-inquiries', icon: MessageSquare, permission: PERMS.admin },
+      { name: 'Packages',         href: '/packages',          icon: Package,       permission: PERMS.packages.view },
+      // { name: 'Bookings',     href: '/package-bookings',  icon: Ticket,        permission: PERMS.packages.view },
+      { name: 'Inquiries',        href: '/package-inquiries', icon: MessageSquare, permission: PERMS.inquiries.view },
     ]
   },
   {
     title: 'Master Data',
     items: [
-      { name: 'Stations',   href: '/stations',   icon: MapPin,    permission: PERMS.admin },
-      { name: 'Trains',     href: '/trains',     icon: Train,     permission: PERMS.admin },
-      { name: 'Coaches',    href: '/coaches',    icon: Grid3x3,   permission: PERMS.admin },
-      { name: 'Seats',      href: '/seats',      icon: Armchair,  permission: PERMS.admin },
-      { name: 'Classes',    href: '/classes',    icon: Settings,  permission: PERMS.admin },
-      { name: 'Routes',     href: '/routes',     icon: Route,     permission: PERMS.admin },
-      { name: 'Schedules',  href: '/schedules',  icon: Calendar,  permission: PERMS.admin },
+      { name: 'Stations',   href: '/stations',   icon: MapPin,    permission: PERMS.stations.view },
+      { name: 'Trains',     href: '/trains',     icon: Train,     permission: PERMS.trains.view },
+      { name: 'Coaches',    href: '/coaches',    icon: Grid3x3,   permission: PERMS.coaches.view },
+      { name: 'Seats',      href: '/seats',      icon: Armchair,  permission: PERMS.seats.view },
+      { name: 'Classes',    href: '/classes',    icon: Settings,  permission: PERMS.classes.view },
+      { name: 'Routes',     href: '/routes',     icon: Route,     permission: PERMS.routes.view },
+      { name: 'Schedules',  href: '/schedules',  icon: Calendar,  permission: PERMS.schedules.view },
     ]
   },
   {
     title: 'Financial',
     items: [
       // { name: 'Pricing & Fares',       href: '/pricing',         icon: DollarSign, permission: PERMS.admin },
-      { name: 'Tariff Rates',           href: '/tariff-rates',    icon: Banknote,   permission: PERMS.admin },
+      { name: 'Tariff Rates',           href: '/tariff-rates',    icon: Banknote,   permission: PERMS.tariffRates.view },
       // { name: 'Fare Rules',             href: '/fare-management', icon: Settings,   permission: PERMS.admin },
       { name: 'Payments',             href: '/payments',        icon: CreditCard, permission: PERMS.payments.view },
-      { name: 'Currencies',           href: '/currencies',      icon: Banknote,   permission: PERMS.currencies.manage },      
+      { name: 'Currencies',           href: '/currencies',      icon: Banknote,   permission: PERMS.currencies.view },
       // { name: 'Promo Codes',          href: '/promos',          icon: Gift,       permission: PERMS.admin },
-      { name: 'Payment Methods',      href: '/payment-methods',  icon: CreditCard, permission: PERMS.payments.view },
+      { name: 'Payment Methods',      href: '/payment-methods',  icon: CreditCard, permission: PERMS.paymentMethods.view },
       // { name: 'Wallet Accounts',        href: '/wallet-accounts',  icon: Wallet,     permission: PERMS.payments.view },
     ]
   },
diff --git a/apps/edr-passenger-web/backoffice/src/lib/permissions.ts b/apps/edr-passenger-web/backoffice/src/lib/permissions.ts
index 7731d784e..2a893f971 100644
--- a/apps/edr-passenger-web/backoffice/src/lib/permissions.ts
+++ b/apps/edr-passenger-web/backoffice/src/lib/permissions.ts
@@ -13,11 +13,69 @@ export const PERMS = {
     view:        'edr_passenger_app:tickets:view',
     manage:      'edr_passenger_app:tickets:manage',
   },
-  payments: {
-    view:        'edr_passenger_app:payments:view_all',
-    refund:      'edr_passenger_app:payments:refund',
-    manage:      'edr_passenger_app:payments:manage_methods',
+
+  // ── Master Data ────────────────────────────────────────────────
+  stations: {
+    view:        'edr_passenger_app:stations:view',
+    manage:      'edr_passenger_app:stations:manage',
   },
+  trains: {
+    view:        'edr_passenger_app:trains:view',
+    manage:      'edr_passenger_app:trains:manage',
+  },
+  coaches: {
+    view:        'edr_passenger_app:coaches:view',
+    manage:      'edr_passenger_app:coaches:manage',
+  },
+  seats: {
+    view:        'edr_passenger_app:seats:view',
+    manage:      'edr_passenger_app:seats:manage',
+  },
+  classes: {
+    view:        'edr_passenger_app:classes:view',
+    manage:      'edr_passenger_app:classes:manage',
+  },
+  routes: {
+    view:        'edr_passenger_app:routes:view',
+    manage:      'edr_passenger_app:routes:manage',
+  },
+  schedules: {
+    view:        'edr_passenger_app:schedules:view',
+    manage:      'edr_passenger_app:schedules:manage',
+  },
+
+  // ── Tourism ────────────────────────────────────────────────────
+  packages: {
+    view:        'edr_passenger_app:packages:view',
+    manage:      'edr_passenger_app:packages:manage',
+  },
+  inquiries: {
+    view:        'edr_passenger_app:inquiries:view',
+    manage:      'edr_passenger_app:inquiries:manage',
+  },
+
+  // ── Finance ────────────────────────────────────────────────────
+  tariffRates: {
+    view:        'edr_passenger_app:tariff_rates:view',
+    manage:      'edr_passenger_app:tariff_rates:manage',
+  },
+  payments: {
+    view:        'edr_passenger_app:payments:view',
+    manage:      'edr_passenger_app:payments:manage',
+    // legacy aliases — still honoured by the backend guards
+    viewAll:     'edr_passenger_app:payments:view_all',
+    refund:      'edr_passenger_app:payments:refund',
+    manageMethods: 'edr_passenger_app:payments:manage_methods',
+  },
+  paymentMethods: {
+    view:        'edr_passenger_app:payment_methods:view',
+    manage:      'edr_passenger_app:payment_methods:manage',
+  },
+  currencies: {
+    view:        'edr_passenger_app:currencies:view',
+    manage:      'edr_passenger_app:currencies:manage',
+  },
+
   reports: {
     view:        'edr_passenger_app:reports:view',
   },
@@ -32,9 +90,6 @@ export const PERMS = {
     view:        'edr_passenger_app:agents:view',
     manage:      'edr_passenger_app:agents:manage',
   },
-  currencies: {
-    manage:      'edr_passenger_app:currencies:manage',
-  },
   notifications: {
     send:        'edr_passenger_app:notifications:send',
   },
diff --git a/apps/edr-passenger-web/portal/src/app/booking/auth-check/page.tsx b/apps/edr-passenger-web/portal/src/app/booking/auth-check/page.tsx
index 8db5e35ad..d9c7f92a3 100644
--- a/apps/edr-passenger-web/portal/src/app/booking/auth-check/page.tsx
+++ b/apps/edr-passenger-web/portal/src/app/booking/auth-check/page.tsx
@@ -4,7 +4,7 @@ import { useEffect, useState } from 'react';
 import { useRouter } from 'next/navigation';
 import { useAuthStore } from '@/lib/auth-store';
 import { useBookingStore } from '@/lib/booking-store';
-import { UserPlus, ChevronLeft } from 'lucide-react';
+import { UserPlus, LogIn, ChevronLeft } from 'lucide-react';
 
 function Tooltip({ children, content }: { children: React.ReactNode; content: string[] }) {
   const [visible, setVisible] = useState(false);
@@ -95,7 +95,6 @@ export default function AuthCheckPage() {
             </button>
           </Tooltip>
 
-          {/* TODO: re-enable once auth is integrated
           <Tooltip content={[
             'Saved passenger details',
             'View booking history',
@@ -109,7 +108,6 @@ export default function AuthCheckPage() {
               SignIn or Register
             </button>
           </Tooltip>
-          */}
         </div>
 
         <div className="mt-8 text-center">
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 e2e90be05..b10109c0f 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
@@ -11,6 +11,7 @@ import { useEffect, useState } from "react";
 import { CheckCircle, Clock, Copy, Train, FileText } from "lucide-react";
 import { format } from "date-fns";
 import { isChild, isFirstChild } from "@/utils/fare-utils";
+import { toZonedDate } from "@/utils/format";
 
 type BookingWithTicket = {
   id: string;
@@ -125,7 +126,10 @@ export default function ConfirmationPage() {
       const settledAmountMinor = _booking?.payment?.amountMinor;
       const settledCurrency = _booking?.payment?.currency;
       const hasSettledAmount = settledAmountMinor != null && !!settledCurrency;
-      const voucherCurrency = hasSettledAmount ? settledCurrency! : "ETB";
+      // Derive display currency from nationality (same logic as review/payment pages)
+      const nat = (searchCriteria?.nationality ?? '').toUpperCase();
+      const passengerDisplayCurrency = nat === 'DJIBOUTIAN' ? 'DJF' : nat === 'ETHIOPIAN' ? 'ETB' : 'USD';
+      const voucherCurrency = hasSettledAmount ? settledCurrency! : passengerDisplayCurrency;
       const createdAt = _booking?.createdAt || new Date().toISOString();
       const status = _booking?.status || "CONFIRMED";
 
@@ -383,7 +387,7 @@ export default function ConfirmationPage() {
                           </p>
                           <p className="font-semibold text-gray-900 dark:text-gray-100">
                             {schedule.departureTime &&
-                              format(new Date(schedule.departureTime), "PPp")}
+                              format(toZonedDate(new Date(schedule.departureTime)), "PPp")}
                           </p>
                         </div>
                         <div>
@@ -392,7 +396,7 @@ export default function ConfirmationPage() {
                           </p>
                           <p className="font-semibold text-gray-900 dark:text-gray-100">
                             {schedule.arrivalTime &&
-                              format(new Date(schedule.arrivalTime), "PPp")}
+                              format(toZonedDate(new Date(schedule.arrivalTime)), "PPp")}
                           </p>
                         </div>
                         <div>
@@ -456,7 +460,7 @@ export default function ConfirmationPage() {
                         <p className="font-semibold text-gray-900 dark:text-gray-100">
                           {inboundSchedule.departureTime &&
                             format(
-                              new Date(inboundSchedule.departureTime),
+                              toZonedDate(new Date(inboundSchedule.departureTime)),
                               "PPp",
                             )}
                         </p>
@@ -468,7 +472,7 @@ export default function ConfirmationPage() {
                         <p className="font-semibold text-gray-900 dark:text-gray-100">
                           {inboundSchedule.arrivalTime &&
                             format(
-                              new Date(inboundSchedule.arrivalTime),
+                              toZonedDate(new Date(inboundSchedule.arrivalTime)),
                               "PPp",
                             )}
                         </p>
@@ -529,15 +533,15 @@ export default function ConfirmationPage() {
                     // The server-confirmed settled amount is authoritative — prefer it over
                     // any client-side session state, which can go stale (e.g. after a refresh).
                     if (_booking?.payment?.amountMinor != null) {
-                      return `${_booking.payment.currency || "ETB"} ${_booking.payment.amountMinor}`;
+                      return `${_booking.payment.currency || 'ETB'} ${(_booking.payment.amountMinor / 100).toFixed(2)}`;
                     }
                     if (reviewedTotalMinor != null)
-                      return `ETB ${(reviewedTotalMinor / 100).toFixed(2)}`;
+                      return `${paidCurrency || 'ETB'} ${(reviewedTotalMinor / 100).toFixed(2)}`;
                     if (paidAmountMinor != null)
-                      return `${paidCurrency} ${(paidAmountMinor / 100).toFixed(2)}`;
+                      return `${paidCurrency || 'ETB'} ${(paidAmountMinor / 100).toFixed(2)}`;
                     if (_booking?.totalMinor != null)
                       return `ETB ${(_booking.totalMinor / 100).toFixed(2)}`;
-                    return "ETB 0.00";
+                    return 'ETB 0.00';
                   })()}
                 </p>
               </div>
@@ -726,7 +730,7 @@ export default function ConfirmationPage() {
             </div>
             <div className="p-4 bg-green-50 dark:bg-green-900/30 border border-green-200 dark:border-green-800 rounded-lg">
               <p className="text-sm text-green-800 dark:text-green-300">
-                ✅ Please arrive at the station at least 30 minutes before
+                ✅ Please arrive at the station at least 2 hours before
                 departure.
               </p>
             </div>
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 6442fd0d6..025c212bf 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
@@ -21,7 +21,7 @@ import {
   X,
 } from "lucide-react";
 import { format } from "date-fns";
-import { formatTime, getTimePeriod } from "@/utils/format";
+import { formatTime, getTimePeriod, toZonedDate } from "@/utils/format";
 import { formatFare } from "@/utils/fare-utils";
 import {
   markManageBookingPaymentReturn,
@@ -29,9 +29,11 @@ import {
 } 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;
+// Derive display currency from the booking record's own displayCurrency field
+// (set at booking creation from the passenger's nationality). Falls back to ETB.
+function getBookingDisplayCurrency(booking: any): string {
+  return booking?.displayCurrency || 'ETB';
+}
 
 const getIconForMethod = (methodType: string) => {
   if (methodType.includes("CARD")) return CreditCard;
@@ -126,8 +128,10 @@ function BookingDetailContent() {
   const selectedPaymentMethod =
     (paymentMethods || []).find((m: any) => m.type === selectedMethod) || null;
 
+  const displayCurrency = getBookingDisplayCurrency(booking);
+
   // 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.
+  // when the selected method actually settles in a different currency than the booking's display currency.
   const isConversionNeeded =
     !!selectedMethodCurrency && selectedMethodCurrency !== displayCurrency;
   const amountCurrency = isConversionNeeded
@@ -152,7 +156,7 @@ function BookingDetailContent() {
     ? bookingAmountData != null
       ? bookingAmountData.amount
       : null
-    : (booking?.totalMinor ?? 0) / 100;
+    : (booking?.displayTotalMinor ?? booking?.totalMinor ?? 0) / 100;
   const confirmedCurrency = isConversionNeeded
     ? bookingAmountData?.currency || amountCurrency
     : displayCurrency;
@@ -399,6 +403,15 @@ function BookingDetailContent() {
     }));
   })();
 
+  // Scale per-passenger ETB fareMinor to the booking's display currency using the
+  // ratio of displayTotalMinor / totalMinor. Falls back to 1 (ETB) when not available.
+  const fareScaleFactor = (() => {
+    const etbTotal = booking?.totalMinor;
+    const displayTotal = booking?.displayTotalMinor;
+    if (!etbTotal || !displayTotal || etbTotal === displayTotal) return 1;
+    return displayTotal / etbTotal;
+  })();
+
   // 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.
@@ -439,7 +452,7 @@ function BookingDetailContent() {
                   )}
                 </span>
                 <span className="text-sm font-semibold text-gray-900 dark:text-gray-100">
-                  {formatFare(passenger.fareMinor ?? 0, displayCurrency)}
+                  {formatFare(Math.round((passenger.fareMinor ?? 0) * fareScaleFactor), displayCurrency)}
                 </span>
               </div>
               {isRoundTripBooking && !isFreeChild && (
@@ -448,7 +461,7 @@ function BookingDetailContent() {
                     <span>Outbound</span>
                     <span>
                       {formatFare(
-                        passenger.outboundFareMinor ?? 0,
+                        Math.round((passenger.outboundFareMinor ?? 0) * fareScaleFactor),
                         displayCurrency,
                       )}
                     </span>
@@ -457,7 +470,7 @@ function BookingDetailContent() {
                     <span>Return</span>
                     <span>
                       {formatFare(
-                        passenger.returnFareMinor ?? 0,
+                        Math.round((passenger.returnFareMinor ?? 0) * fareScaleFactor),
                         displayCurrency,
                       )}
                     </span>
@@ -606,7 +619,7 @@ function BookingDetailContent() {
                         </div>
                         <div className="text-sm text-gray-500 dark:text-gray-400 mt-0.5">
                           {booking.schedule?.departureAt
-                            ? `${format(new Date(booking.schedule.departureAt), "EEE, MMM d")} · ${getTimePeriod(booking.schedule.departureAt)}`
+                            ? `${format(toZonedDate(new Date(booking.schedule.departureAt)), "EEE, MMM d")} · ${getTimePeriod(booking.schedule.departureAt)}`
                             : "N/A"}
                         </div>
                         <div className="text-base font-semibold text-gray-900 dark:text-white mt-2">
@@ -655,7 +668,7 @@ function BookingDetailContent() {
                         </div>
                         <div className="text-sm text-gray-500 dark:text-gray-400 mt-0.5">
                           {booking.schedule?.arrivalAt
-                            ? `${format(new Date(booking.schedule.arrivalAt), "EEE, MMM d")} · ${getTimePeriod(booking.schedule.arrivalAt)}`
+                            ? `${format(toZonedDate(new Date(booking.schedule.arrivalAt)), "EEE, MMM d")} · ${getTimePeriod(booking.schedule.arrivalAt)}`
                             : "N/A"}
                         </div>
                         <div className="text-base font-semibold text-gray-900 dark:text-white mt-2">
@@ -937,7 +950,7 @@ function BookingDetailContent() {
                   Total paid:{" "}
                   <span className="font-semibold text-gray-900 dark:text-gray-100">
                     {booking?.payment?.amountMinor != null
-                      ? `${booking.payment.currency || "ETB"} ${booking.payment.amountMinor}`
+                      ? `${booking.payment.currency || 'ETB'} ${(booking.payment.amountMinor / 100).toFixed(2)}`
                       : `ETB ${((booking?.totalMinor ?? 0) / 100).toFixed(2)}`}
                   </span>
                   {booking?.payment?.method && (
@@ -1014,7 +1027,7 @@ function BookingDetailContent() {
                     </div>
                     <div className="text-sm text-gray-500 dark:text-gray-400 mt-0.5">
                       {booking.schedule?.departureAt
-                        ? `${format(new Date(booking.schedule.departureAt), "EEE, MMM d")} · ${getTimePeriod(booking.schedule.departureAt)}`
+                        ? `${format(toZonedDate(new Date(booking.schedule.departureAt)), "EEE, MMM d")} · ${getTimePeriod(booking.schedule.departureAt)}`
                         : "N/A"}
                     </div>
                     <div className="text-base font-semibold text-gray-900 dark:text-white mt-2">
@@ -1063,7 +1076,7 @@ function BookingDetailContent() {
                     </div>
                     <div className="text-sm text-gray-500 dark:text-gray-400 mt-0.5">
                       {booking.schedule?.arrivalAt
-                        ? `${format(new Date(booking.schedule.arrivalAt), "EEE, MMM d")} · ${getTimePeriod(booking.schedule.arrivalAt)}`
+                        ? `${format(toZonedDate(new Date(booking.schedule.arrivalAt)), "EEE, MMM d")} · ${getTimePeriod(booking.schedule.arrivalAt)}`
                         : "N/A"}
                     </div>
                     <div className="text-base font-semibold text-gray-900 dark:text-white mt-2">
diff --git a/apps/edr-passenger-web/portal/src/app/booking/lookup/page.tsx b/apps/edr-passenger-web/portal/src/app/booking/lookup/page.tsx
index da369fb54..123cd5710 100644
--- a/apps/edr-passenger-web/portal/src/app/booking/lookup/page.tsx
+++ b/apps/edr-passenger-web/portal/src/app/booking/lookup/page.tsx
@@ -5,6 +5,7 @@ import { useRouter } from "next/navigation";
 import { useState } from "react";
 import { apiClient } from "@/lib/api-client";
 import { format } from "date-fns";
+import { toZonedDate } from "@/utils/format";
 
 type SearchMode = "pnr" | "phone";
 
@@ -14,6 +15,8 @@ interface BookingListItem {
   status: string;
   totalMinor: number;
   currency: string;
+  displayCurrency?: string | null;
+  displayTotalMinor?: number | null;
   adultCount: number;
   childCount: number;
   bookingType: string;
@@ -199,7 +202,8 @@ export default function BookingLookupPage() {
                   </p>
                   {phoneResults.map((b) => {
                     const statusInfo = STATUS_LABELS[b.status] ?? { label: b.status, className: "bg-gray-100 text-gray-700" };
-                    const amountEtb = (b.totalMinor / 100).toLocaleString("en-ET", { minimumFractionDigits: 2 });
+                    const displayCurrency = b.displayCurrency || 'ETB';
+                    const displayAmount = ((b.displayTotalMinor ?? b.totalMinor) / 100).toLocaleString("en-ET", { minimumFractionDigits: 2 });
                     return (
                       <button
                         key={b.id}
@@ -220,7 +224,7 @@ export default function BookingLookupPage() {
                               {b.schedule.originStation.name} → {b.schedule.destinationStation.name}
                             </p>
                             <p className="text-xs text-gray-500 dark:text-gray-400 mt-0.5">
-                              {format(new Date(b.schedule.departureAt), "dd MMM yyyy, HH:mm")}
+                              {format(toZonedDate(new Date(b.schedule.departureAt)), "dd MMM yyyy, HH:mm")}
                               {" · "}
                               {b.adultCount} adult{b.adultCount !== 1 ? "s" : ""}
                               {b.childCount > 0 && `, ${b.childCount} child${b.childCount !== 1 ? "ren" : ""}`}
@@ -228,7 +232,7 @@ export default function BookingLookupPage() {
                           </div>
                           <div className="flex flex-col items-end gap-1 flex-shrink-0">
                             <span className="text-sm font-semibold text-gray-900 dark:text-white whitespace-nowrap">
-                              {amountEtb} ETB
+                              {displayAmount} {displayCurrency}
                             </span>
                             <ChevronRight className="w-4 h-4 text-gray-400 group-hover:text-[rgb(20,113,76)] transition-colors" />
                           </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 3992e140f..e56680d11 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
@@ -8,7 +8,7 @@ import { apiClient } from "@/lib/api-client";
 import { useState, useEffect } from "react";
 import { PaymentMethod } from "@/types";
 import { format } from "date-fns";
-import { formatTime, getTimePeriod } from '@/utils/format';
+import { formatTime, getTimePeriod, toZonedDate } from '@/utils/format';
 import { isChild, isFirstChild, formatFare } from '@/utils/fare-utils';
 import {
   CreditCard,
@@ -49,7 +49,9 @@ export default function PaymentPage() {
   const isRoundTrip = searchCriteria?.tripType === 'ROUND_TRIP';
   const isPackage = !!packageName;
 
-  const displayCurrency = 'ETB' as const;
+  // Use the same display currency as the review page (derived from nationality)
+  const nat = (searchCriteria?.nationality ?? '').toUpperCase();
+  const displayCurrency = nat === 'DJIBOUTIAN' ? 'DJF' : nat === 'ETHIOPIAN' ? 'ETB' : 'USD';
 
   const { data: paymentMethods = [], isLoading: loadingMethods, error } = useQuery<PaymentMethod[]>({
     queryKey: ['paymentMethods', displayCurrency],
@@ -289,7 +291,7 @@ export default function PaymentPage() {
               </div>
               <div className="text-xs text-gray-500 dark:text-gray-400">
                 {schedule?.departureTime
-                  ? `${format(new Date(schedule.departureTime), 'EEE, MMM d')} · ${getTimePeriod(schedule.departureTime)}`
+                  ? `${format(toZonedDate(new Date(schedule.departureTime)), 'EEE, MMM d')} · ${getTimePeriod(schedule.departureTime)}`
                   : ''}
               </div>
               <div className="text-sm font-semibold text-gray-900 dark:text-white mt-1">{schedule?.origin}</div>
@@ -304,7 +306,7 @@ export default function PaymentPage() {
               </div>
               <div className="text-xs text-gray-500 dark:text-gray-400">
                 {schedule?.arrivalTime
-                  ? `${format(new Date(schedule.arrivalTime), 'EEE, MMM d')} · ${getTimePeriod(schedule.arrivalTime)}`
+                  ? `${format(toZonedDate(new Date(schedule.arrivalTime)), 'EEE, MMM d')} · ${getTimePeriod(schedule.arrivalTime)}`
                   : ''}
               </div>
               <div className="text-sm font-semibold text-gray-900 dark:text-white mt-1">{schedule?.destination}</div>
@@ -314,7 +316,7 @@ export default function PaymentPage() {
         {fare !== undefined && (
           <div className="mt-3 pt-2 border-t border-gray-100 dark:border-gray-800 flex justify-between text-sm">
             <span className="text-gray-500 dark:text-gray-400">{label} fare</span>
-            <span className="font-semibold text-gray-900 dark:text-gray-100">{displayCurrency} {(fare / 100).toFixed(2)}</span>
+            <span className="font-semibold text-gray-900 dark:text-gray-100">{confirmedCurrency} {(fare / 100).toFixed(2)}</span>
           </div>
         )}
       </div>
diff --git a/apps/edr-passenger-web/portal/src/app/booking/results/page.tsx b/apps/edr-passenger-web/portal/src/app/booking/results/page.tsx
index afaeb1f44..45331e761 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
@@ -21,11 +21,19 @@ import {
   Star,
 } from "lucide-react";
 import { format } from "date-fns";
-import { formatTime, getTimePeriod } from "@/utils/format";
+import { formatTime, getTimePeriod, toZonedDate } from "@/utils/format";
 import { formatFare } from "@/utils/fare-utils";
-import { useCurrencySymbol } from "@/lib/useCurrencies";
 import { useState, useEffect } from "react";
 
+// Shared by the compact schedule card's coach-type badges and the "Choose Your Coach"
+// modal, so both pick the same icon for a given coach type name.
+const getCoachIcon = (typeName: string) => {
+  const lower = typeName.toLowerCase();
+  if (lower.includes("soft") || lower.includes("vip")) return Star;
+  if (lower.includes("bed")) return Bed;
+  return Armchair;
+};
+
 export default function ResultsPage() {
   const router = useRouter();
   const searchParams = useSearchParams();
@@ -97,7 +105,6 @@ export default function ResultsPage() {
 
   const nat = (searchData.nationality ?? '').toUpperCase();
   const displayCurrencyCode = nat === 'DJIBOUTIAN' ? 'DJF' : nat === 'ETHIOPIAN' ? 'ETB' : 'USD';
-  const displayCurrencySymbol = useCurrencySymbol(displayCurrencyCode);
 
   useEffect(() => {
     if (searchParams.get("origin")) {
@@ -365,13 +372,6 @@ export default function ResultsPage() {
       (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;
-      return Armchair;
-    };
-
     return (
       <>
         <div
@@ -419,7 +419,7 @@ export default function ResultsPage() {
                         ...coachType.classes.map((c: any) => c.displayAmountMinor ?? c.baseFareMinor),
                       )
                     : 0;
-                  const coachCurrency = displayCurrencySymbol;
+                  const coachCurrency = displayCurrencyCode;
                   const CoachIcon = getCoachIcon(coachType.coachTypeName);
 
                   const selectThisCoach = () =>
@@ -519,9 +519,11 @@ export default function ResultsPage() {
                               <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>
+                              {coachType.classes.some((c: any) => c.available != null) && (
+                                <span className="text-xs text-gray-500 dark:text-gray-400 font-medium">
+                                  {coachType.classes.reduce((sum: number, c: any) => sum + (c.available ?? 0), 0)} seats left
+                                </span>
+                              )}
                             </div>
                             <div className="space-y-2.5">
                               {coachType.classes.map(
@@ -532,15 +534,32 @@ export default function ResultsPage() {
                                   >
                                     <div className="flex items-center gap-2.5">
                                       <CoachIcon className="w-3.5 h-3.5 text-gray-500 dark:text-gray-400" />
-                                      <span className="text-sm font-medium text-gray-700 dark:text-gray-300">
-                                        {cls.name}
-                                      </span>
+                                      <div className="flex flex-col">
+                                        <span className="text-sm font-medium text-gray-700 dark:text-gray-300">
+                                          {cls.name}
+                                        </span>
+                                        {cls.available != null && (
+                                          <span
+                                            className={`text-[11px] font-medium ${
+                                              cls.available === 0
+                                                ? "text-red-500"
+                                                : cls.available <= 3
+                                                  ? "text-amber-600 dark:text-amber-400"
+                                                  : "text-gray-400 dark:text-gray-500"
+                                            }`}
+                                          >
+                                            {cls.available === 0
+                                              ? "Fully booked"
+                                              : `${cls.available} seat${cls.available === 1 ? "" : "s"} left`}
+                                          </span>
+                                        )}
+                                      </div>
                                     </div>
                                     <div className="flex items-baseline gap-1">
                                       <span className="text-base font-bold tabular-nums text-gray-900 dark:text-white">
                                         {((cls.displayAmountMinor ?? cls.baseFareMinor) / 100).toFixed(2)}
                                       </span>
-                                      <span className="text-xs text-gray-500 dark:text-gray-400 font-medium">
+                                      <span className="text-xs text-gray-500 dark:text-gray-400 font-medium ml-1">
                                         {coachCurrency}
                                       </span>
                                     </div>
@@ -616,7 +635,7 @@ export default function ResultsPage() {
     // 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 = displayCurrencySymbol;
+    const displayCurrency = displayCurrencyCode;
     if (schedule.coachTypes?.length) {
       const allClasses = schedule.coachTypes.flatMap((ct) => ct.classes);
       const allFares = allClasses
@@ -657,7 +676,7 @@ export default function ResultsPage() {
               <Calendar className="w-3.5 h-3.5" />
               Different date —{" "}
               {schedule.departureAt
-                ? format(new Date(schedule.departureAt), "EEEE, MMMM d, yyyy")
+                ? format(toZonedDate(new Date(schedule.departureAt)), "EEEE, MMMM d, yyyy")
                 : "N/A"}
             </span>
             <span
@@ -696,7 +715,7 @@ export default function ResultsPage() {
                 </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)}`
+                    ? `${format(toZonedDate(new Date(schedule.departureAt)), "MMM d")} · ${getTimePeriod(schedule.departureAt)}`
                     : ""}
                 </div>
                 <div className="text-sm text-gray-600 dark:text-gray-400 mt-1">
@@ -730,7 +749,7 @@ export default function ResultsPage() {
                 <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)}`
+                      ? `${format(toZonedDate(new Date(schedule.arrivalAt)), "MMM d")} · ${getTimePeriod(schedule.arrivalAt)}`
                       : ""}
                   </span>
                   {isNextDay && (
@@ -776,6 +795,48 @@ export default function ResultsPage() {
             </div>
           </div>
         </div>
+
+        {schedule.coachTypes && schedule.coachTypes.length > 0 && (
+          <div className="mt-4 pt-4 border-t border-gray-100 dark:border-gray-800 flex flex-wrap gap-2">
+            {schedule.coachTypes
+              .filter((ct: any) => ct.coachTypeCode !== "DPC")
+              .map((ct: any, idx: number) => {
+                const CoachIcon = getCoachIcon(ct.coachTypeName);
+                // Only classes that actually reported a count contribute — if none of
+                // them did (API didn't return `available` for this coach type), there's
+                // nothing honest to show, so the count is omitted rather than shown as 0.
+                const hasAvailabilityData = ct.classes.some(
+                  (c: any) => c.available != null,
+                );
+                const available = ct.classes.reduce(
+                  (sum: number, c: any) => sum + (c.available ?? 0),
+                  0,
+                );
+                return (
+                  <span
+                    key={idx}
+                    className={`inline-flex items-center gap-1.5 text-xs font-medium px-2.5 py-1 rounded-full ${
+                      !hasAvailabilityData
+                        ? "bg-gray-100 dark:bg-gray-800 text-gray-600 dark:text-gray-400"
+                        : available === 0
+                          ? "bg-red-50 dark:bg-red-900/20 text-red-500 dark:text-red-400"
+                          : available <= 3
+                            ? "bg-amber-50 dark:bg-amber-900/20 text-amber-600 dark:text-amber-400"
+                            : "bg-gray-100 dark:bg-gray-800 text-gray-600 dark:text-gray-400"
+                    }`}
+                  >
+                    <CoachIcon className="w-3.5 h-3.5 flex-shrink-0" />
+                    {ct.coachTypeName}
+                    {hasAvailabilityData && (
+                      <span className="font-semibold">
+                        {available === 0 ? "Full" : `${available} left`}
+                      </span>
+                    )}
+                  </span>
+                );
+              })}
+          </div>
+        )}
       </div>
     );
   };
@@ -1213,7 +1274,7 @@ export default function ResultsPage() {
                             {outboundScheduleData.origin} →{" "}
                             {outboundScheduleData.destination}
                             {outboundScheduleData.departureTime
-                              ? ` · ${format(new Date(outboundScheduleData.departureTime), "EEE, MMM d, yyyy")}`
+                              ? ` · ${format(toZonedDate(new Date(outboundScheduleData.departureTime)), "EEE, MMM d, yyyy")}`
                               : ""}
                             {outboundScheduleData.selectedSeatClassName
                               ? ` · ${outboundScheduleData.selectedSeatClassName}`
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 265417d58..10051f0d3 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
@@ -6,11 +6,10 @@ import { useAuthStore } from '@/lib/auth-store';
 import { useMutation } from '@tanstack/react-query';
 import { apiClient } from '@/lib/api-client';
 import { format } from 'date-fns';
-import { formatTime, getTimePeriod } from '@/utils/format';
-import { useState, useEffect, useCallback } from 'react';
+import { formatTime, getTimePeriod, toZonedDate } from '@/utils/format';
+import { useState, useEffect, useRef } from 'react';
 import { ChevronLeft } from 'lucide-react';
 import { isChild, isFirstChild, formatFare } from '@/utils/fare-utils';
-import { useCurrencySymbol } from '@/lib/useCurrencies';
 
 // Helper function to decode JWT token and extract passengerId
 function getPassengerIdFromToken(token: string): string | null {
@@ -57,10 +56,13 @@ export default function ReviewPage() {
 
   const isRoundTrip = searchCriteria?.tripType === 'ROUND_TRIP';
 
-  // Derive display currency from nationality so fares show in the passenger's home currency.
+  // Use the display currency stored on the schedule (set at search/selection time).
+  // Fall back to nationality-based derivation only if the schedule has no displayCurrency.
+  const scheduleCurrency = isRoundTrip
+    ? outboundSchedule?.displayCurrency
+    : selectedSchedule?.displayCurrency;
   const nat = (searchCriteria?.nationality ?? '').toUpperCase();
-  const displayCurrencyCode = nat === 'DJIBOUTIAN' ? 'DJF' : nat === 'ETHIOPIAN' ? 'ETB' : 'USD';
-  const displayCurrencySymbol = useCurrencySymbol(displayCurrencyCode);
+  const displayCurrencyCode = scheduleCurrency || (nat === 'DJIBOUTIAN' ? 'DJF' : nat === 'ETHIOPIAN' ? 'ETB' : 'USD');
 
   useEffect(() => {
     if (!seatHold?.expiresAt) return;
@@ -152,7 +154,8 @@ export default function ReviewPage() {
   }, [selectedSchedule?.id, outboundSchedule?.id, inboundSchedule?.id, passengers, isRoundTrip]);
 
   const isPackageBooking = packageTierPriceMinor !== null || !!packageName;
-  const adultPassengerCount = searchCriteria?.adultCount ?? passengers.filter(p => !isChild(p)).length;
+
+const adultPassengerCount = searchCriteria?.adultCount ?? passengers.filter(p => !isChild(p)).length;
   const pkgAdultFare = isPackageBooking && packageTierPriceMinor != null ? packageTierPriceMinor * 2 : 0;
   const pkgChildFare = pkgAdultFare;
 
@@ -166,7 +169,15 @@ export default function ReviewPage() {
     return childIndex < adultPassengerCount;
   };
 
-  const getPassengerSeatFare = (p: any): number | null => {
+  // Returns the fare for a passenger in the display currency.
+  // Prefers displayFareMinor (converted) from the fare breakdown API when available.
+  // Falls back to raw ETB seat fares (which are always in minor units).
+  const getPassengerSeatFare = (p: any, index?: number): number | null => {
+    if (!isPackageBooking && fareBreakdown?.passengers && index != null) {
+      const line = fareBreakdown.passengers[index];
+      const displayFare = line?.displayFareMinor ?? line?.fareMinor;
+      if (displayFare != null) return displayFare;
+    }
     if (isRoundTrip) {
       if (p.outboundSeatFareMinor == null && p.inboundSeatFareMinor == null) return null;
       if (isPackageBooking) return (p.outboundSeatFareMinor ?? 0) * 2;
@@ -445,13 +456,14 @@ export default function ReviewPage() {
         const isFreeChild = isPackageBooking
           ? (isChildPassenger && (i - adultPassengerCount) < adultPassengerCount)
           : (line?.isFree ?? (isChild(p) && isFirstChild(passengers, i)));
-        const seatFare = getPassengerSeatFare(p);
+        const seatFare = getPassengerSeatFare(p, i);
         const pkgFallback = isChildPassenger ? pkgChildFare : pkgAdultFare;
         const fareMinor = isPackageBooking
           ? (isFreeChild ? 0 : (seatFare ?? pkgFallback))
           : (isFreeChild ? 0 : (seatFare ?? line?.fareMinor ?? 0));
-        const outboundFareMinor = isRoundTrip ? ((p as any).outboundSeatFareMinor ?? undefined) : undefined;
-        const inboundFareMinor = isRoundTrip ? ((p as any).inboundSeatFareMinor ?? undefined) : undefined;
+        const halfFare = seatFare != null ? Math.round(seatFare / 2) : undefined;
+        const outboundFareMinor = isRoundTrip ? (halfFare ?? (p as any).outboundSeatFareMinor ?? undefined) : undefined;
+        const inboundFareMinor = isRoundTrip ? (halfFare ?? (p as any).inboundSeatFareMinor ?? undefined) : undefined;
         return { fareMinor, isFree: isFreeChild, outboundFareMinor, inboundFareMinor };
       });
       setReviewedTotal(computedTotal, passengerFares);
@@ -482,55 +494,60 @@ export default function ReviewPage() {
     }
   }, [isRoundTrip, selectedSchedule, outboundSchedule, inboundSchedule, passengers.length, createBookingMutation.isPending, createBookingMutation.isSuccess, router]);
 
-  const fetchFareBreakdown = useCallback(async (scheduleId: string, originStationId: string, destinationStationId: string) => {
-    // Package bookings use the stored tier price — no fare calculation needed
-    if (isPackageBooking) return;
-
-    try {
-      const seatClasses: any[] = await apiClient.get('/seat-classes');
-      const scheduleSeatClassName = isRoundTrip
-        ? (outboundSchedule as any)?.seatClassName
-        : (selectedSchedule as any)?.seatClassName;
-      const fallbackSeatClassId = seatClasses.find((sc: any) => sc.name === scheduleSeatClassName)?.id || seatClasses[0]?.id;
-      if (!fallbackSeatClassId) return;
-
-      const resolveSeatClassId = (p: any): string => {
-        const bedPosition: string | undefined = isRoundTrip ? (p as any).outboundBedPosition : (p as any).bedPosition;
-        if (!bedPosition) return fallbackSeatClassId;
-        const match = seatClasses.find((sc: any) => sc.name?.toLowerCase().includes(bedPosition));
-        return match?.id || fallbackSeatClassId;
-      };
-
-      const passengersParam = JSON.stringify(
-        passengers.map(p => ({
-          passengerName: p.name,
-          dateOfBirth: p.dateOfBirth,
-          seatClassId: resolveSeatClassId(p),
-          nationality: p.nationality,
-        }))
-      );
-
-      const params = new URLSearchParams({
-        scheduleId,
-        originStationId,
-        destinationStationId,
-        passengers: passengersParam,
-        displayCurrency: displayCurrencyCode,
-        ...(searchCriteria?.promoCode ? { promoCode: searchCriteria.promoCode } : {}),
-      });
-
-      const result: any = await apiClient.get(`/search/fare-breakdown?${params}`);
-      setFareBreakdown(result);
-    } catch (err) {
-    }
-  }, [isPackageBooking, passengers, selectedSchedule, outboundSchedule, isRoundTrip, searchCriteria, displayCurrencyCode]);
+  const fareBreakdownFetchedRef = useRef(false);
+  const scheduleId = isRoundTrip ? outboundSchedule?.id : selectedSchedule?.id;
 
   useEffect(() => {
+    if (fareBreakdownFetchedRef.current) return;
     if (!searchCriteria?.originStationId || !searchCriteria?.destinationStationId) return;
-    const scheduleId = isRoundTrip ? outboundSchedule?.id : selectedSchedule?.id;
     if (!scheduleId) return;
-    fetchFareBreakdown(scheduleId, searchCriteria.originStationId, searchCriteria.destinationStationId);
-  }, [fetchFareBreakdown, isRoundTrip, outboundSchedule?.id, selectedSchedule?.id, searchCriteria?.originStationId, searchCriteria?.destinationStationId]);
+    if (isPackageBooking) return;
+
+    fareBreakdownFetchedRef.current = true;
+
+    (async () => {
+      try {
+        const seatClasses: any[] = await apiClient.get('/seat-classes');
+        const scheduleSeatClassName = isRoundTrip
+          ? (outboundSchedule as any)?.seatClassName
+          : (selectedSchedule as any)?.seatClassName;
+        const fallbackSeatClassId = seatClasses.find((sc: any) => sc.name === scheduleSeatClassName)?.id || seatClasses[0]?.id;
+        if (!fallbackSeatClassId) return;
+
+        const resolveSeatClassId = (p: any): string => {
+          const bedPosition: string | undefined = isRoundTrip ? (p as any).outboundBedPosition : (p as any).bedPosition;
+          if (!bedPosition) return fallbackSeatClassId;
+          const match = seatClasses.find((sc: any) => sc.name?.toLowerCase().includes(bedPosition));
+          return match?.id || fallbackSeatClassId;
+        };
+
+        const passengersParam = JSON.stringify(
+          passengers.map(p => ({
+            passengerName: p.name,
+            dateOfBirth: p.dateOfBirth,
+            seatClassId: resolveSeatClassId(p),
+            nationality: p.nationality,
+          }))
+        );
+
+        const params = new URLSearchParams({
+          scheduleId,
+          originStationId: searchCriteria.originStationId,
+          destinationStationId: searchCriteria.destinationStationId,
+          passengers: passengersParam,
+          displayCurrency: displayCurrencyCode,
+          ...(searchCriteria.promoCode ? { promoCode: searchCriteria.promoCode } : {}),
+        });
+
+        const result: any = await apiClient.get(`/search/fare-breakdown?${params}`);
+        setFareBreakdown(result);
+      } catch (err) {
+      }
+    })();
+  // Intentionally re-runs until store is hydrated (scheduleId/originStationId become
+  // available), then the ref guard ensures it only fetches once.
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [searchCriteria?.originStationId, searchCriteria?.destinationStationId, scheduleId]);
 
   // For package bookings, passengers are initialized without dateOfBirth so isChild() is
   // unreliable. Use the stored adultCount from searchCriteria to determine category by index.
@@ -539,7 +556,7 @@ export default function ReviewPage() {
         const isChild_ = isPackageChild(i);
         const isFreeChild = isChild_ && (i - adultPassengerCount) < adultPassengerCount;
         if (isFreeChild) return sum;
-        const seatFare = getPassengerSeatFare(p);
+        const seatFare = getPassengerSeatFare(p, i);
         const pkgFallback = isChild_ ? pkgChildFare : pkgAdultFare;
         return sum + (seatFare ?? pkgFallback);
       }, 0)
@@ -548,8 +565,9 @@ export default function ReviewPage() {
         const line = fareBreakdown?.passengers?.[i];
         const isFreeChild = line?.isFree ?? (isChildPassenger && isFirstChild(passengers, i));
         if (isFreeChild) return sum;
-        const seatFare = getPassengerSeatFare(p);
-        return sum + (seatFare ?? line?.fareMinor ?? 0);
+        const seatFare = getPassengerSeatFare(p, i);
+        const displayFare = line?.displayFareMinor ?? line?.fareMinor;
+        return sum + (seatFare ?? displayFare ?? 0);
       }, 0);
 
   // Keep computedTotal in sync so handleConfirm can persist it to the store
@@ -568,17 +586,26 @@ export default function ReviewPage() {
           ? isPkgFreeChild(i)
           : (line?.isFree ?? (isChild(p) && isFirstChild(passengers, i)));
 
-        // Per-leg fares for round trips
+        // Per-leg fares for round trips — use converted amounts from fareBreakdown when available
+        const displayFare = line?.displayFareMinor ?? line?.fareMinor;
         const outboundFare: number | null = isRoundTrip
-          ? (isPackageBooking ? (packageTierPriceMinor ?? null) : ((p as any).outboundSeatFareMinor ?? null))
+          ? (isPackageBooking
+              ? (packageTierPriceMinor ?? null)
+              : (displayFare != null
+                  ? Math.round(displayFare / 2)
+                  : ((p as any).outboundSeatFareMinor ?? null)))
           : null;
         const inboundFare: number | null = isRoundTrip
-          ? (isPackageBooking ? (packageTierPriceMinor ?? null) : ((p as any).inboundSeatFareMinor ?? null))
+          ? (isPackageBooking
+              ? (packageTierPriceMinor ?? null)
+              : (displayFare != null
+                  ? Math.round(displayFare / 2)
+                  : ((p as any).inboundSeatFareMinor ?? null)))
           : null;
-        const seatFare = getPassengerSeatFare(p);
+        const seatFare = getPassengerSeatFare(p, i);
         const passengerTotal = isPackageBooking
           ? (isFreeChild ? 0 : (seatFare ?? (isChildPassenger ? pkgChildFare : pkgAdultFare)))
-          : (isFreeChild ? 0 : (seatFare ?? line?.fareMinor ?? 0));
+          : (isFreeChild ? 0 : (seatFare ?? displayFare ?? 0));
 
         return (
           <div key={i} className="border-b border-gray-100 dark:border-gray-800 pb-2 last:border-0">
@@ -594,7 +621,7 @@ export default function ReviewPage() {
                 )}
               </span>
               <span className="text-sm font-semibold text-gray-900 dark:text-gray-100">
-                {formatFare(passengerTotal, displayCurrencySymbol)}
+                {formatFare(passengerTotal, displayCurrencyCode)}
               </span>
             </div>
             {/* Round-trip: show outbound + inbound breakdown */}
@@ -602,11 +629,11 @@ export default function ReviewPage() {
               <div className="mt-1 space-y-0.5 pl-2">
                 <div className="flex justify-between text-xs text-gray-500 dark:text-gray-400">
                   <span>↗ Outbound</span>
-                  <span>{outboundFare != null ? formatFare(outboundFare, displayCurrencySymbol) : '—'}</span>
+                  <span>{outboundFare != null ? formatFare(outboundFare, displayCurrencyCode) : '—'}</span>
                 </div>
                 <div className="flex justify-between text-xs text-gray-500 dark:text-gray-400">
                   <span>↙ Return</span>
-                  <span>{inboundFare != null ? formatFare(inboundFare, displayCurrencySymbol) : '—'}</span>
+                  <span>{inboundFare != null ? formatFare(inboundFare, displayCurrencyCode) : '—'}</span>
                 </div>
               </div>
             )}
@@ -615,7 +642,7 @@ export default function ReviewPage() {
       })}
       <div className="flex justify-between items-center pt-1 border-t border-gray-200 dark:border-gray-700">
         <span className="font-bold text-gray-900 dark:text-gray-100">Total</span>
-        <span className="text-xl font-bold text-primary">{formatFare(total, displayCurrencySymbol)}</span>
+        <span className="text-xl font-bold text-primary">{formatFare(total, displayCurrencyCode)}</span>
       </div>
 
       {/* Action buttons — visible only in desktop sidebar */}
@@ -690,7 +717,7 @@ export default function ReviewPage() {
                       </div>
                       <div className="text-sm text-gray-500 dark:text-gray-400 mt-0.5">
                         {outboundSchedule.departureTime
-                          ? `${format(new Date(outboundSchedule.departureTime), 'EEE, MMM d')} · ${getTimePeriod(outboundSchedule.departureTime)}`
+                          ? `${format(toZonedDate(new Date(outboundSchedule.departureTime)), 'EEE, MMM d')} · ${getTimePeriod(outboundSchedule.departureTime)}`
                           : 'N/A'}
                       </div>
                       <div className="text-base font-semibold text-gray-900 dark:text-white mt-2">
@@ -723,7 +750,7 @@ export default function ReviewPage() {
                       </div>
                       <div className="text-sm text-gray-500 dark:text-gray-400 mt-0.5">
                         {outboundSchedule.arrivalTime
-                          ? `${format(new Date(outboundSchedule.arrivalTime), 'EEE, MMM d')} · ${getTimePeriod(outboundSchedule.arrivalTime)}`
+                          ? `${format(toZonedDate(new Date(outboundSchedule.arrivalTime)), 'EEE, MMM d')} · ${getTimePeriod(outboundSchedule.arrivalTime)}`
                           : 'N/A'}
                       </div>
                       <div className="text-base font-semibold text-gray-900 dark:text-white mt-2">
@@ -764,7 +791,7 @@ export default function ReviewPage() {
                       </div>
                       <div className="text-sm text-gray-500 dark:text-gray-400 mt-0.5">
                         {inboundSchedule.departureTime
-                          ? `${format(new Date(inboundSchedule.departureTime), 'EEE, MMM d')} · ${getTimePeriod(inboundSchedule.departureTime)}`
+                          ? `${format(toZonedDate(new Date(inboundSchedule.departureTime)), 'EEE, MMM d')} · ${getTimePeriod(inboundSchedule.departureTime)}`
                           : 'N/A'}
                       </div>
                       <div className="text-base font-semibold text-gray-900 dark:text-white mt-2">
@@ -797,7 +824,7 @@ export default function ReviewPage() {
                       </div>
                       <div className="text-sm text-gray-500 dark:text-gray-400 mt-0.5">
                         {inboundSchedule.arrivalTime
-                          ? `${format(new Date(inboundSchedule.arrivalTime), 'EEE, MMM d')} · ${getTimePeriod(inboundSchedule.arrivalTime)}`
+                          ? `${format(toZonedDate(new Date(inboundSchedule.arrivalTime)), 'EEE, MMM d')} · ${getTimePeriod(inboundSchedule.arrivalTime)}`
                           : 'N/A'}
                       </div>
                       <div className="text-base font-semibold text-gray-900 dark:text-white mt-2">
@@ -841,7 +868,7 @@ export default function ReviewPage() {
                       </div>
                       <div className="text-sm text-gray-500 dark:text-gray-400 mt-0.5">
                         {selectedSchedule.departureTime
-                          ? `${format(new Date(selectedSchedule.departureTime), 'EEE, MMM d')} · ${getTimePeriod(selectedSchedule.departureTime)}`
+                          ? `${format(toZonedDate(new Date(selectedSchedule.departureTime)), 'EEE, MMM d')} · ${getTimePeriod(selectedSchedule.departureTime)}`
                           : 'N/A'}
                       </div>
                       <div className="text-base font-semibold text-gray-900 dark:text-white mt-2">
@@ -874,7 +901,7 @@ export default function ReviewPage() {
                       </div>
                       <div className="text-sm text-gray-500 dark:text-gray-400 mt-0.5">
                         {selectedSchedule.arrivalTime
-                          ? `${format(new Date(selectedSchedule.arrivalTime), 'EEE, MMM d')} · ${getTimePeriod(selectedSchedule.arrivalTime)}`
+                          ? `${format(toZonedDate(new Date(selectedSchedule.arrivalTime)), 'EEE, MMM d')} · ${getTimePeriod(selectedSchedule.arrivalTime)}`
                           : 'N/A'}
                       </div>
                       <div className="text-base font-semibold text-gray-900 dark:text-white mt-2">
@@ -963,7 +990,7 @@ export default function ReviewPage() {
       <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">{formatFare(total, displayCurrencySymbol)}</span>
+          <span className="text-lg font-bold text-primary">{formatFare(total, displayCurrencyCode)}</span>
         </div>
         {createBookingMutation.isError && (
           <p className="text-red-600 dark:text-red-400 text-xs mb-2">
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 1463b238a..a143f7a1e 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
@@ -415,7 +415,7 @@ export default function SeatsPage() {
     if (!coachTypeId) return null;
     const types = (currentSchedule as any)?.coachTypes || [];
     const match = types.find((ct: any) => ct.coachTypeId === coachTypeId || ct.coachId === coachTypeId);
-    const fares = (match?.classes || []).map((c: any) => c.baseFareMinor).filter((f: number) => f > 0);
+    const fares = (match?.classes || []).map((c: any) => c.displayAmountMinor ?? c.baseFareMinor).filter((f: number) => f > 0);
     return fares.length ? Math.min(...fares) : null;
   };
 
@@ -437,10 +437,10 @@ export default function SeatsPage() {
         const match = currentCoachTypeClasses.find((c: any) =>
           c.name?.toLowerCase().includes(seat.bedPosition),
         );        
-        if (match) return match.baseFareMinor;
+        if (match) return match.displayAmountMinor ?? match.baseFareMinor;
       }
       const regular = currentCoachTypeClasses.find((c: any) => /regular/i.test(c.name || ""));
-      return (regular || currentCoachTypeClasses[0])?.baseFareMinor ?? null;
+      return (regular || currentCoachTypeClasses[0])?.displayAmountMinor ?? (regular || currentCoachTypeClasses[0])?.baseFareMinor ?? null;
     },
     [currentCoachTypeClasses],
   );
@@ -573,7 +573,7 @@ export default function SeatsPage() {
       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?`,
+        message: `Switching to ${coach.label} (${matchedType.coachTypeName || coach.typeName || ""}) changes the fare to ${currentSchedule?.displayCurrency || 'ETB'} ${(newFare / 100 * (isRoundTrip ? 2 : 1)).toFixed(2)} per adult (currently ${currentSchedule?.displayCurrency || 'ETB'} ${(currentFare / 100 * (isRoundTrip ? 2 : 1)).toFixed(2)}). Continue?`,
         type: "warning",
         showCancel: true,
         confirmText: "Switch Coach",
@@ -588,7 +588,7 @@ export default function SeatsPage() {
       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."
+        newFare != null ? ` Fare: ${currentSchedule?.displayCurrency || 'ETB'} ${(newFare / 100 * (isRoundTrip ? 2 : 1)).toFixed(2)} per adult.` : " This will have a fare change."
       }`,
       type: "info",
       showCancel: true,
@@ -926,7 +926,7 @@ export default function SeatsPage() {
           setModalState({
             isOpen: true,
             title: "Fare Will Change",
-            message: `${positionLabel} ${seatLabel} costs ETB ${(newFare / 100 * legMultiplier).toFixed(2)}, different from ${referenceLabel} (ETB ${(referenceFare / 100 * legMultiplier).toFixed(2)}). Continue with this selection?`,
+            message: `${positionLabel} ${seatLabel} costs ${currentSchedule?.displayCurrency || 'ETB'} ${(newFare / 100 * legMultiplier).toFixed(2)}, different from ${referenceLabel} (${currentSchedule?.displayCurrency || 'ETB'} ${(referenceFare / 100 * legMultiplier).toFixed(2)}). Continue with this selection?`,
             type: "warning",
             showCancel: true,
             confirmText: "Continue",
@@ -966,7 +966,7 @@ export default function SeatsPage() {
 
       commitSeatAssignment(seatId);
     },
-    [passengerSeatMap, activePassengerIndex, validSeats, getSeatFare, commitSeatAssignment, isPackageBooking, packageTierPriceMinor, packageId, priceTierId, packageName, packageDepartureStationId, packageDepartureStationName, setPackageContext, isRoundTrip],
+    [passengerSeatMap, activePassengerIndex, validSeats, getSeatFare, commitSeatAssignment, isPackageBooking, packageTierPriceMinor, packageId, priceTierId, packageName, packageDepartureStationId, packageDepartureStationName, setPackageContext, isRoundTrip, currentSchedule?.displayCurrency],
   );
 
   const allSeatsAssigned =
@@ -1927,9 +1927,6 @@ export default function SeatsPage() {
             ? allCoachSeats?.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 (
@@ -1979,11 +1976,6 @@ export default function SeatsPage() {
                 >
                   {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>
           );
diff --git a/apps/edr-passenger-web/portal/src/app/guide/page.tsx b/apps/edr-passenger-web/portal/src/app/guide/page.tsx
index 3297d1389..09f965a96 100644
--- a/apps/edr-passenger-web/portal/src/app/guide/page.tsx
+++ b/apps/edr-passenger-web/portal/src/app/guide/page.tsx
@@ -174,7 +174,7 @@ export default function HowToGuidePage() {
                   </p>
                   <div className="bg-green-50 dark:bg-green-900/20 border border-green-200 dark:border-green-800 p-4 rounded-lg">
                     <p className="text-sm text-green-800 dark:text-green-300">
-                      📱 Show the QR code at the gate for easy check-in. Arrive at least 30 minutes before departure.
+                      📱 Show the QR code at the gate for easy check-in. Arrive at least 2 hours before departure.
                     </p>
                   </div>
                 </div>
@@ -225,7 +225,7 @@ export default function HowToGuidePage() {
               <div>
                 <h3 className="font-semibold text-gray-900 dark:text-gray-100 mb-2">What should I bring on the day of travel?</h3>
                 <p className="text-sm text-gray-600 dark:text-gray-400">
-                  Bring your ticket (digital or printed), valid ID/passport, and arrive 30 minutes before departure.
+                  Bring your ticket (digital or printed), valid ID/passport, and arrive 2 hours before departure.
                 </p>
               </div>
             </div>
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 bb839906d..067d93a1b 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
@@ -105,17 +105,22 @@ interface PackageDetail {
 
 // ─── Helpers ──────────────────────────────────────────────────────────────────
 
+// Train schedules are stored/computed server-side in Ethiopian time (EAT - UTC+3) —
+// pinning display to the same zone keeps this page consistent with every other
+// booking page and the voucher PDF, regardless of the viewing device's own timezone.
 function fmt(iso: string, opts?: Intl.DateTimeFormatOptions): string {
   try {
-    return new Date(iso).toLocaleDateString("en-US", opts ?? {
+    return new Date(iso).toLocaleDateString("en-US", {
       weekday: "short", month: "short", day: "numeric",
+      ...opts,
+      timeZone: "Africa/Addis_Ababa",
     });
   } catch { return iso; }
 }
 
 function fmtTime(iso: string): string {
   try {
-    return new Date(iso).toLocaleTimeString("en-US", { hour: "numeric", minute: "2-digit", hour12: true });
+    return new Date(iso).toLocaleTimeString("en-US", { hour: "numeric", minute: "2-digit", hour12: true, timeZone: "Africa/Addis_Ababa" });
   } catch { return iso; }
 }
 
diff --git a/apps/edr-passenger-web/portal/src/app/profile/page.tsx b/apps/edr-passenger-web/portal/src/app/profile/page.tsx
index d44474976..37ffdabfb 100644
--- a/apps/edr-passenger-web/portal/src/app/profile/page.tsx
+++ b/apps/edr-passenger-web/portal/src/app/profile/page.tsx
@@ -346,8 +346,8 @@ export default function ProfilePage() {
                           <div className="flex items-center gap-2">
                             <Calendar className="w-4 h-4 text-gray-400" />
                             <span className="text-gray-600 dark:text-gray-400">
-                              {booking.trip?.departureAt 
-                                ? new Date(booking.trip.departureAt).toLocaleDateString() 
+                              {booking.trip?.departureAt
+                                ? new Date(booking.trip.departureAt).toLocaleDateString('en-US', { timeZone: 'Africa/Addis_Ababa' })
                                 : 'N/A'}
                             </span>
                           </div>
diff --git a/apps/edr-passenger-web/portal/src/components/AppSidebar.tsx b/apps/edr-passenger-web/portal/src/components/AppSidebar.tsx
index 81a455401..0acb5d9ea 100644
--- a/apps/edr-passenger-web/portal/src/components/AppSidebar.tsx
+++ b/apps/edr-passenger-web/portal/src/components/AppSidebar.tsx
@@ -192,9 +192,7 @@ export default function AppSidebar() {
             )}
           </div>
         ) : (
-          // TODO: Sign in / Register temporarily disabled — re-enable later.
-          null
-          /* <div className="flex items-center gap-2 px-1 pt-1">
+          <div className="flex items-center gap-2 px-1 pt-1">
             <Link
               href="/login"
               className="flex-1 text-center px-3 py-2 text-sm font-medium text-gray-100 hover:bg-white/10 rounded-lg transition-colors"
@@ -207,7 +205,7 @@ export default function AppSidebar() {
             >
               Register
             </Link>
-          </div> */
+          </div>
         )}
       </div>
 
diff --git a/apps/edr-passenger-web/portal/src/components/BottomTabBar.tsx b/apps/edr-passenger-web/portal/src/components/BottomTabBar.tsx
index 9a1d71f15..ee4cdccad 100644
--- a/apps/edr-passenger-web/portal/src/components/BottomTabBar.tsx
+++ b/apps/edr-passenger-web/portal/src/components/BottomTabBar.tsx
@@ -1,10 +1,9 @@
 'use client';
 
-// NOTE: User icon + useAuthStore are unused while the Sign in / Account tab is
-// temporarily disabled below. Re-add them when that tab is restored.
-import { Home, Phone, Ticket } from 'lucide-react';
+import { Home, Phone, Ticket, User } from 'lucide-react';
 import Link from 'next/link';
 import { usePathname } from 'next/navigation';
+import { useAuthStore } from '@/lib/auth-store';
 
 // The linear, one-screen-at-a-time booking flow — each of these pages already
 // has its own sticky mobile CTA bar (and the mobile step strip at the top),
@@ -22,6 +21,7 @@ const LINEAR_FLOW_PREFIXES = [
 
 export default function BottomTabBar() {
   const pathname = usePathname() ?? '';
+  const isAuthenticated = useAuthStore((s) => s.isAuthenticated);
 
   const isInLinearFlow = LINEAR_FLOW_PREFIXES.some((p) => pathname.startsWith(p));
   if (isInLinearFlow) return null;
@@ -30,13 +30,12 @@ export default function BottomTabBar() {
     { href: '/', label: 'Home', icon: Home, match: (p: string) => p === '/' },
     { href: '/booking/lookup', label: 'Bookings', icon: Ticket, match: (p: string) => p.startsWith('/booking/lookup') || p.startsWith('/booking/detail') },
     { href: '/contact', label: 'Contact', icon: Phone, match: (p: string) => p.startsWith('/contact') },
-    // TODO: Sign in / Account tab temporarily disabled — re-enable later.
-    // {
-    //   href: isAuthenticated ? '/profile' : '/login',
-    //   label: isAuthenticated ? 'Account' : 'Sign in',
-    //   icon: User,
-    //   match: (p: string) => p.startsWith('/profile') || p.startsWith('/login') || p.startsWith('/register'),
-    // },
+    {
+      href: isAuthenticated ? '/profile' : '/login',
+      label: isAuthenticated ? 'Account' : 'Sign in',
+      icon: User,
+      match: (p: string) => p.startsWith('/profile') || p.startsWith('/login') || p.startsWith('/register'),
+    },
   ];
 
   return (
diff --git a/apps/edr-passenger-web/portal/src/components/PackagesSection.tsx b/apps/edr-passenger-web/portal/src/components/PackagesSection.tsx
index 304671050..adfc838ea 100644
--- a/apps/edr-passenger-web/portal/src/components/PackagesSection.tsx
+++ b/apps/edr-passenger-web/portal/src/components/PackagesSection.tsx
@@ -59,12 +59,16 @@ interface HolidayPackage {
 
 // ─── Helpers ──────────────────────────────────────────────────────────────────
 
+// Pinned to Ethiopian time (EAT - UTC+3) — the zone train schedules are stored/computed
+// in server-side — so this matches every other booking page and the voucher PDF
+// regardless of the viewing device's own timezone.
 function fmtDate(iso: string, opts?: Intl.DateTimeFormatOptions): string {
   try {
-    return new Date(iso).toLocaleDateString(
-      "en-US",
-      opts ?? { month: "short", day: "numeric" },
-    );
+    return new Date(iso).toLocaleDateString("en-US", {
+      month: "short", day: "numeric",
+      ...opts,
+      timeZone: "Africa/Addis_Ababa",
+    });
   } catch {
     return iso;
   }
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 a25679d75..894795c52 100644
--- a/apps/edr-passenger-web/portal/src/lib/generate-voucher.ts
+++ b/apps/edr-passenger-web/portal/src/lib/generate-voucher.ts
@@ -1,6 +1,12 @@
 import jsPDF from 'jspdf';
 import QRCode from 'qrcode';
 
+// Train schedules are stored/computed server-side in Ethiopian time (EAT - UTC+3) — see
+// apps/edr-passenger-api's timezone.utils.ts. Pinning every date/time on the voucher to
+// this same zone (instead of the generating device's own local zone) is what keeps the
+// PDF's journey times matching what the booking pages show, regardless of the device.
+const APP_TIMEZONE = 'Africa/Addis_Ababa';
+
 interface ScheduleInfo {
   trainNumber: string;
   trainName?: string;
@@ -255,9 +261,9 @@ function drawJourneyLeg(doc: jsPDF, schedule: ScheduleInfo, legLabel: string | n
 
   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 + 18);
+  doc.text(dep.toLocaleTimeString('en-US', { hour: 'numeric', minute: '2-digit', hour12: true, timeZone: APP_TIMEZONE }), margin + padX, topY + 18);
   doc.setTextColor(...MUTED); doc.setFontSize(7); doc.setFont('helvetica', 'normal');
-  doc.text(dep.toLocaleDateString('en-US', { weekday: 'short', month: 'short', day: 'numeric' }), margin + padX, topY + 22);
+  doc.text(dep.toLocaleDateString('en-US', { weekday: 'short', month: 'short', day: 'numeric', timeZone: APP_TIMEZONE }), margin + padX, topY + 22);
 
   // Destination block (right-aligned)
   const dx = pageWidth - margin - padX;
@@ -269,9 +275,9 @@ function drawJourneyLeg(doc: jsPDF, schedule: ScheduleInfo, legLabel: string | n
 
   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 + 18, { align: 'right' });
+  doc.text(arr.toLocaleTimeString('en-US', { hour: 'numeric', minute: '2-digit', hour12: true, timeZone: APP_TIMEZONE }), dx, topY + 18, { align: 'right' });
   doc.setTextColor(...MUTED); doc.setFontSize(7); doc.setFont('helvetica', 'normal');
-  doc.text(arr.toLocaleDateString('en-US', { weekday: 'short', month: 'short', day: 'numeric' }), dx, topY + 22, { align: 'right' });
+  doc.text(arr.toLocaleDateString('en-US', { weekday: 'short', month: 'short', day: 'numeric', timeZone: APP_TIMEZONE }), dx, topY + 22, { align: 'right' });
 
   // Dashed route line with endpoint markers, connecting the two blocks
   const lineY = topY + 7.5;
@@ -368,7 +374,7 @@ function drawInstructions(doc: jsPDF, y: number, margin: number, pageWidth: numb
   doc.text('BEFORE YOU TRAVEL', margin + padX, y + 6, { charSpace: 0.3 });
   doc.setFont('helvetica', 'normal'); doc.setFontSize(8);
   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);
+  doc.text('Please arrive at least 2 hours before scheduled departure.', margin + padX, y + 15);
 
   return y + cardH + 4;
 }
@@ -387,7 +393,7 @@ function drawFooter(doc: jsPDF, createdAt: string, contentY: number): void {
   doc.setFontSize(7.5); doc.setTextColor(...MUTED); doc.setFont('helvetica', 'normal');
   doc.text('edr_@edrsc.com   ·   9546   ·   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' });
+  doc.text(`Issued ${new Date(createdAt).toLocaleString('en-US', { timeZone: APP_TIMEZONE })}`, pageWidth / 2, footerY + 10.5, { align: 'center' });
 }
 
 // ─── public API ──────────────────────────────────────────────────────────────
@@ -446,7 +452,9 @@ interface VoucherData {
   schedule: VoucherSchedule;
   returnSchedule?: VoucherSchedule | null;
   totalMinor: number;
-  currency: string;
+  displayTotalMinor?: number;
+  currency?: string;
+  displayCurrency?: string;
   bookingType: string;
   createdAt: string;
   // One ticket per passenger per leg (round trips have a separate ticket/barcode for the
@@ -467,7 +475,10 @@ export const generateVoucherPDF = async (booking: VoucherData): Promise<void> =>
   const settledAmountMinor = booking.payment?.amountMinor;
   const settledCurrency = booking.payment?.currency;
   const useSettledAmount = settledAmountMinor != null && !!settledCurrency;
-  const voucherCurrency = useSettledAmount ? settledCurrency! : booking.currency;
+  // Prefer displayCurrency (passenger's home currency) over the internal ETB currency field.
+  const voucherCurrency = useSettledAmount ? settledCurrency! : (booking.displayCurrency || booking.currency || 'ETB');
+  // Use displayTotalMinor when available so the voucher shows the passenger's currency amount.
+  const voucherFareMinor = useSettledAmount ? settledAmountMinor! : (booking.displayTotalMinor ?? booking.totalMinor);
 
   const isRoundTrip = booking.bookingType === 'ROUND_TRIP' && !!booking.returnSchedule;
 
@@ -513,7 +524,7 @@ export const generateVoucherPDF = async (booking: VoucherData): Promise<void> =>
       seatNumber:          isRoundTrip ? undefined : p.outboundSeat?.number,
       outboundSeatNumber:  isRoundTrip ? p.outboundSeat?.number : undefined,
       inboundSeatNumber:   isRoundTrip ? p.returnSeat?.number : undefined,
-      fareMinor:           useSettledAmount ? settledAmountMinor! : booking.totalMinor,
+      fareMinor:           voucherFareMinor,
       currency:            voucherCurrency,
       fareIsMajorUnits:    useSettledAmount,
       createdAt:           booking.createdAt,
diff --git a/apps/edr-passenger-web/portal/src/types/index.ts b/apps/edr-passenger-web/portal/src/types/index.ts
index d1a906cbb..c299f10fd 100644
--- a/apps/edr-passenger-web/portal/src/types/index.ts
+++ b/apps/edr-passenger-web/portal/src/types/index.ts
@@ -51,6 +51,7 @@ export interface Schedule {
       baseFareMinor: number;
       displayCurrency?: string;
       displayAmountMinor?: number;
+      available?: number;
     }>;
   }>;
   displayCurrency?: string;
diff --git a/apps/edr-passenger-web/portal/src/utils/format.ts b/apps/edr-passenger-web/portal/src/utils/format.ts
index 3743334ad..9f5bb9836 100644
--- a/apps/edr-passenger-web/portal/src/utils/format.ts
+++ b/apps/edr-passenger-web/portal/src/utils/format.ts
@@ -1,5 +1,24 @@
 import { format } from 'date-fns';
 
+// The backend stores and computes every train schedule in Ethiopian time (EAT -
+// UTC+3) — see apps/edr-passenger-api's timezone.utils.ts and main.ts, which pin the
+// server process to this zone. The frontend previously formatted dates using
+// whatever timezone the viewing/generating device happened to be set to, which made
+// the on-screen booking pages and the downloaded voucher PDF disagree (by exactly
+// the device's offset from EAT) whenever that device wasn't itself in EAT. Pinning
+// every display here to the same explicit zone makes them agree by construction.
+const APP_TIMEZONE = 'Africa/Addis_Ababa';
+
+// date-fns' `format()` always reads the Date object's LOCAL (device) getters — it has
+// no built-in timezone conversion. This shifts the Date so those local getters report
+// the wall-clock time in `timeZone` instead of the device's own zone, so `format()`
+// calls (here and at other call sites formatting journey times) produce EAT-correct
+// output regardless of the device. Exported for pages that call date-fns' `format()`
+// directly instead of going through the helpers below.
+export function toZonedDate(date: Date, timeZone: string = APP_TIMEZONE): Date {
+  return new Date(date.toLocaleString('en-US', { timeZone }));
+}
+
 export const formatCurrency = (amount: number, currency: string = 'ETB'): string => {
   return new Intl.NumberFormat('en-US', {
     style: 'currency',
@@ -9,19 +28,19 @@ export const formatCurrency = (amount: number, currency: string = 'ETB'): string
 };
 
 export const formatDate = (date: string | Date, formatStr: string = 'MMM dd, yyyy'): string => {
-  return format(new Date(date), formatStr);
+  return format(toZonedDate(new Date(date), APP_TIMEZONE), formatStr);
 };
 
 export const formatDateTime = (date: string | Date): string => {
-  return format(new Date(date), 'MMM dd, yyyy h:mm a');
+  return format(toZonedDate(new Date(date), APP_TIMEZONE), 'MMM dd, yyyy h:mm a');
 };
 
 export const formatTime = (date: string | Date): string => {
-  return format(new Date(date), 'h:mm a');
+  return format(toZonedDate(new Date(date), APP_TIMEZONE), 'h:mm a');
 };
 
 export const getTimePeriod = (date: string | Date): string => {
-  const hour = new Date(date).getHours();
+  const hour = toZonedDate(new Date(date), APP_TIMEZONE).getHours();
   if (hour >= 5 && hour < 12) return 'Morning';
   if (hour >= 12 && hour < 17) return 'Afternoon';
   if (hour >= 17 && hour < 21) return 'Evening';
diff --git a/docker-compose.yaml b/docker-compose.yaml
index d3c89c4a9..7637c500a 100644
--- a/docker-compose.yaml
+++ b/docker-compose.yaml
@@ -5,9 +5,6 @@
 # Build:  DOCKER_BUILDKIT=1 docker compose build
 # Run:    docker compose up -d
 services:
-  # Message broker for payment event delivery (payment-api -> passenger/freight).
-  # Management UI: http://localhost:15672 (login edr / edr_secret). vhost: payment.
-  # In deployed envs this is a shared/managed RabbitMQ; only PAYMENT_RABBITMQ_URL changes.
   freight-api:
     build:
       context: .
@@ -21,26 +18,19 @@ services:
     extra_hosts:
       - "paymentcallback.triaplc.com:10.18.7.179"
 
-  # Standalone GT06 GPS tracker ingester (@edr/gps-tracker). Raw TCP only, no
-  # HTTP. Writes freight.gps_devices / freight.gps_positions in the shared
-  # freight DB; the /gps REST API stays in freight-api. Never runs migrations.
   gps-tracker:
     build:
       context: .
       dockerfile: apps/edr-gps-tracker/Dockerfile
       secrets:
         - npmrc
-    depends_on:
-      - freight-api
     ports:
-      # Raw TCP — reachable by tracker SIMs. Not HTTP; no L7 proxy can host-route it.
       - "${GT06_TCP_PORT:-5023}:5023"
     environment:
       GT06_TCP_PORT: "5023"
       GT06_TCP_HOST: "0.0.0.0"
     env_file:
-      # Reuses the freight DB credentials (DB_HOST/DB_PORT/DB_USER/DB_PASSWORD/DB_NAME).
-      - apps/edr-freight-api/.env
+      - apps/edr-gps-tracker/.env
     restart: unless-stopped
 
   passenger-api:
@@ -54,17 +44,7 @@ services:
     extra_hosts:
       - "paymentcallback.triaplc.com:10.18.7.179"
     restart: unless-stopped
-    healthcheck:
-      test: ["CMD", "wget", "-qO-", "http://localhost:4000/health/ready"]
-      interval: 30s
-      timeout: 10s
-      retries: 3
-      start_period: 60s
-    deploy:
-      resources:
-        limits:
-          cpus: '1.0'
-          memory: 1G
+ 
   freight-portal:
     build:
       context: .
@@ -80,6 +60,7 @@ services:
         - npmrc
     ports:
       - "${FREIGHT_PORTAL_PORT:-5173}:80"
+  
   freight-backoffice:
     build:
       context: .
@@ -95,6 +76,7 @@ services:
         - npmrc
     ports:
       - "${FREIGHT_BACKOFFICE_PORT:-5183}:80"
+  
   passenger-portal:
     build:
       context: .
@@ -110,17 +92,7 @@ services:
     env_file:
       - apps/edr-passenger-web/portal/.env
     restart: unless-stopped
-    healthcheck:
-      test: ["CMD", "wget", "-qO-", "http://localhost:${PASSENGER_PORTAL_PORT:-5174}/api/health"]
-      interval: 30s
-      timeout: 10s
-      retries: 3
-      start_period: 60s
-    deploy:
-      resources:
-        limits:
-          cpus: '0.5'
-          memory: 512M
+  
   passenger-backoffice:
     build:
       context: .
@@ -136,17 +108,6 @@ services:
     env_file:
       - apps/edr-passenger-web/backoffice/.env
     restart: unless-stopped
-    healthcheck:
-      test: ["CMD", "wget", "-qO-", "http://localhost:${PASSENGER_BACKOFFICE_PORT:-5184}/api/health"]
-      interval: 30s
-      timeout: 10s
-      retries: 3
-      start_period: 60s
-    deploy:
-      resources:
-        limits:
-          cpus: '0.5'
-          memory: 512M
   
   payment-api:
     build:
diff --git a/packages/types/src/freight/index.ts b/packages/types/src/freight/index.ts
index 7e874ee0f..39e8985ee 100644
--- a/packages/types/src/freight/index.ts
+++ b/packages/types/src/freight/index.ts
@@ -327,10 +327,39 @@ export interface IWagonMovement extends BaseEntity {
   bookingId?: string | null;
   kind: WagonMovementKind;
   movedByUserId?: string | null;
+  /** The transfer request this move fulfilled, when it came from one. */
+  transferRequestId?: string | null;
   occurredAt: string;
   note?: string | null;
 }
 
+/**
+ * Lifecycle of a two-person wagon-transfer request. A requester asks for N
+ * wagons of a type to move from one yard to another (count only, no specific
+ * wagons); OCC staff later pick the physical wagons and execute the move.
+ */
+export enum WagonTransferRequestStatus {
+  /** Awaiting OCC fulfilment. */
+  Pending = "PENDING",
+  /** OCC picked the wagons and executed the transfer. */
+  Fulfilled = "FULFILLED",
+  /** Requester or OCC withdrew it before fulfilment. */
+  Cancelled = "CANCELLED",
+}
+
+export interface IWagonTransferRequest extends BaseEntity {
+  fromYardId: string;
+  toYardId: string;
+  wagonTypeId: string;
+  /** How many wagons of `wagonTypeId` to move out of `fromYardId`. */
+  quantity: number;
+  status: WagonTransferRequestStatus;
+  requestedByUserId?: string | null;
+  fulfilledByUserId?: string | null;
+  fulfilledAt?: string | null;
+  note?: string | null;
+}
+
 export enum BulkPricingUnit {
   PerWagon = "PER_WAGON",
   PerTon = "PER_TON",