diff --git a/.github/workflows/deploy.yml b/.github/workflows/deploy.yml
index a8f03027a..d8413bf71 100644
--- a/.github/workflows/deploy.yml
+++ b/.github/workflows/deploy.yml
@@ -69,8 +69,8 @@ jobs:
           fi
 
           echo "$CHANGED" | grep -q "^apps/edr-freight-api/"              && SERVICES+=("freight-api")
-          echo "$CHANGED" | grep -q "^apps/edr-freight-web-portal/"       && SERVICES+=("freight-portal")
-          echo "$CHANGED" | grep -q "^apps/edr-freight-web-backoffice/"   && SERVICES+=("freight-backoffice")
+          echo "$CHANGED" | grep -q "^apps/edr-freight-web/portal/"       && SERVICES+=("freight-portal")
+          echo "$CHANGED" | grep -q "^apps/edr-freight-web/backoffice/"   && SERVICES+=("freight-backoffice")
           echo "$CHANGED" | grep -q "^apps/edr-passenger-api/"            && SERVICES+=("passenger-api")
           echo "$CHANGED" | grep -q "^apps/edr-passenger-web/portal/"     && SERVICES+=("passenger-portal")
           echo "$CHANGED" | grep -q "^apps/edr-passenger-web/backoffice/" && SERVICES+=("passenger-backoffice")
diff --git a/.gitignore b/.gitignore
index bb9b43556..ba46f7fd7 100644
--- a/.gitignore
+++ b/.gitignore
@@ -7,6 +7,7 @@ node_modules/
 coverage/
 *.tsbuildinfo
 **/*.tsbuildinfo
+**/vite.config.ts.timestamp-*.mjs
 
 # env
 .env
diff --git a/apps/edr-freight-api/package.json b/apps/edr-freight-api/package.json
index 3ddef331e..3fcde133e 100644
--- a/apps/edr-freight-api/package.json
+++ b/apps/edr-freight-api/package.json
@@ -13,6 +13,7 @@
     "lint": "eslint src",
     "test": "jest",
     "test:e2e": "jest --config ./test/jest-e2e.json",
+    "seed:wagons": "ts-node -r tsconfig-paths/register src/scripts/seed-edr-wagons.ts",
     "type-check": "tsc --noEmit",
     "seed:demo-scheduling": "ts-node -r tsconfig-paths/register src/scripts/seed-demo-scheduling.ts",
     "seed:freight-demo": "ts-node -r tsconfig-paths/register src/scripts/seed-freight-demo.ts",
diff --git a/apps/edr-freight-api/src/app.module.ts b/apps/edr-freight-api/src/app.module.ts
index b96e1eae6..f58260c44 100644
--- a/apps/edr-freight-api/src/app.module.ts
+++ b/apps/edr-freight-api/src/app.module.ts
@@ -44,9 +44,10 @@ import { EdrOrgSeeder } from "./seed/edr-org.seeder";
 import { DemoUsersSeeder } from "./seed/demo-users.seeder";
 import { FreightStaffUsersSeeder } from "./seed/freight-staff-users.seeder";
 import { PaymentModule } from "./modules/payment/payment.module";
-import { DemoBookingsSeeder } from "./seed/demo-bookings.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 { FreightPermissionKeyMigrationSeeder } from "./seed/freight-permission-key-migration.seeder";
 import { DemoFreightDataSeeder } from "./seed/demo-freight-data.seeder";
 //New Trains, Wagons, Container and Cargo management modules
@@ -55,7 +56,10 @@ import { WagonsModule } from './modules/wagons/wagons.module';
 import { ContainersModule } from './modules/container-management/containers.module';
 import { CargoesModule } from './modules/cargoes/cargoes.module';
 import { RoutesModule } from './modules/routes/routes.module';
+import { WarehousesModule } from './modules/warehouses/warehouses.module';
+import { FacilitiesModule } from './modules/facilities/facilities.module';
 import { OverviewModule } from './modules/overview/overview.module';
+import { VehiclesModule } from './modules/vehicles/vehicles.module';
 
 @Module({
   imports: [
@@ -112,17 +116,21 @@ import { OverviewModule } from './modules/overview/overview.module';
     ContainersModule,
     CargoesModule,
     RoutesModule,
+    FacilitiesModule,
+    WarehousesModule,
     OverviewModule,
+    VehiclesModule,
   ],
   providers: [
     EdrOrgSeeder,
     DemoUsersSeeder,
     FreightStaffUsersSeeder,
-    DemoBookingsSeeder,
     PricingDataSeeder,
     FileUploadSettingsSeeder,
     FreightPermissionKeyMigrationSeeder,
     DemoFreightDataSeeder,
+    IndodeFacilitySeeder,
+    Batch14TestDataSeeder,
   ],
 })
 export class AppModule implements OnApplicationBootstrap {
diff --git a/apps/edr-freight-api/src/config/database.config.ts b/apps/edr-freight-api/src/config/database.config.ts
index 847908bd5..0e7375b19 100644
--- a/apps/edr-freight-api/src/config/database.config.ts
+++ b/apps/edr-freight-api/src/config/database.config.ts
@@ -117,7 +117,7 @@ export default registerAs("database", (): TypeOrmModuleOptions => {
     ],
     migrationsRun: true,
     // Schema changes via migrations only (synchronize breaks ITMLS backfill on existing rows).
-    synchronize: true,
+    synchronize: false,
     logging: process.env.NODE_ENV === "development",
   };
 });
diff --git a/apps/edr-freight-api/src/data-source.ts b/apps/edr-freight-api/src/data-source.ts
index a29fb861e..2ae202ebd 100644
--- a/apps/edr-freight-api/src/data-source.ts
+++ b/apps/edr-freight-api/src/data-source.ts
@@ -6,7 +6,7 @@ import { DataSource } from 'typeorm';
 export const AppDataSource = new DataSource({
   type: 'postgres',
   host: process.env.DB_HOST ?? 'localhost',
-  port: Number(process.env.DB_PORT ?? 5432),
+  port: Number(process.env.DB_PORT ?? 5433),
   username: process.env.DB_USER ?? 'postgres',
   password: process.env.DB_PASSWORD ?? '',
   database: process.env.DB_NAME ?? 'edr_freight',
@@ -14,7 +14,7 @@ export const AppDataSource = new DataSource({
   entities: [__dirname + '/**/*.entity{.ts,.js}'],
   migrations: [__dirname + '/migrations/*{.ts,.js}'],
   synchronize: false,
-  logging: true,
+  logging: process.env.TYPEORM_LOGGING === 'true',
 });
 
 // Optional: call ensurePostgresSchemas before initializing
diff --git a/apps/edr-freight-api/src/migrations/1750000000000-CreateFacilitiesTable.ts b/apps/edr-freight-api/src/migrations/1750000000000-CreateFacilitiesTable.ts
new file mode 100644
index 000000000..32e1ff653
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/1750000000000-CreateFacilitiesTable.ts
@@ -0,0 +1,138 @@
+import { MigrationInterface, QueryRunner, Table, TableIndex } from 'typeorm';
+
+export class CreateFacilitiesTable1750000000000 implements MigrationInterface {
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.createTable(
+      new Table({
+        schema: 'freight',
+        name: 'facilities',
+        columns: [
+          {
+            name: 'id',
+            type: 'uuid',
+            isPrimary: true,
+            generationStrategy: 'uuid',
+            default: 'gen_random_uuid()',
+          },
+          {
+            name: 'code',
+            type: 'varchar',
+            length: '40',
+            isUnique: true,
+          },
+          {
+            name: 'name',
+            type: 'varchar',
+            length: '160',
+          },
+          {
+            name: 'description',
+            type: 'text',
+            isNullable: true,
+          },
+          {
+            name: 'facility_type',
+            type: 'varchar',
+            length: '32',
+          },
+          {
+            name: 'facility_status',
+            type: 'varchar',
+            length: '32',
+            default: "'ACTIVE'",
+          },
+          {
+            name: 'location_name',
+            type: 'varchar',
+            length: '200',
+            isNullable: true,
+          },
+          {
+            name: 'country',
+            type: 'varchar',
+            length: '100',
+            isNullable: true,
+          },
+          {
+            name: 'city',
+            type: 'varchar',
+            length: '100',
+            isNullable: true,
+          },
+          {
+            name: 'address',
+            type: 'text',
+            isNullable: true,
+          },
+          {
+            name: 'latitude',
+            type: 'numeric',
+            precision: 10,
+            scale: 8,
+            isNullable: true,
+          },
+          {
+            name: 'longitude',
+            type: 'numeric',
+            precision: 11,
+            scale: 8,
+            isNullable: true,
+          },
+          {
+            name: 'capacity',
+            type: 'numeric',
+            precision: 14,
+            scale: 3,
+            isNullable: true,
+          },
+          {
+            name: 'is_active',
+            type: 'boolean',
+            default: true,
+          },
+          {
+            name: 'notes',
+            type: 'text',
+            isNullable: true,
+          },
+          {
+            name: 'created_at',
+            type: 'timestamp',
+            default: 'CURRENT_TIMESTAMP',
+          },
+          {
+            name: 'updated_at',
+            type: 'timestamp',
+            default: 'CURRENT_TIMESTAMP',
+          },
+          {
+            name: 'deleted_at',
+            type: 'timestamp',
+            isNullable: true,
+          },
+        ],
+      }),
+    );
+
+    await queryRunner.createIndex(
+      'freight.facilities',
+      new TableIndex({
+        name: 'idx_facilities_code',
+        columnNames: ['code'],
+        isUnique: true,
+      }),
+    );
+
+    await queryRunner.createIndex(
+      'freight.facilities',
+      new TableIndex({
+        name: 'idx_facilities_status',
+        columnNames: ['facility_status'],
+      }),
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.dropTable('freight.facilities');
+  }
+}
diff --git a/apps/edr-freight-api/src/migrations/1750000000001-AddFacilityIdToWarehouses.ts b/apps/edr-freight-api/src/migrations/1750000000001-AddFacilityIdToWarehouses.ts
new file mode 100644
index 000000000..82f2d92fd
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/1750000000001-AddFacilityIdToWarehouses.ts
@@ -0,0 +1,52 @@
+import { MigrationInterface, QueryRunner, TableColumn, TableForeignKey } from 'typeorm';
+
+export class AddFacilityIdToWarehouses1750000000001 implements MigrationInterface {
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    const table = await queryRunner.getTable('freight.warehouses');
+    if (!table) {
+      // warehouses table doesn't exist yet, skip this migration
+      return;
+    }
+
+    const hasColumn = table.columns.some((col) => col.name === 'facility_id');
+    if (hasColumn) {
+      // Column already exists, skip
+      return;
+    }
+
+    await queryRunner.addColumn(
+      'freight.warehouses',
+      new TableColumn({
+        name: 'facility_id',
+        type: 'uuid',
+        isNullable: true,
+      }),
+    );
+
+    await queryRunner.createForeignKey(
+      'freight.warehouses',
+      new TableForeignKey({
+        columnNames: ['facility_id'],
+        referencedColumnNames: ['id'],
+        referencedTableName: 'facilities',
+        referencedSchema: 'freight',
+        onDelete: 'SET NULL',
+      }),
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    const table = await queryRunner.getTable('freight.warehouses');
+    if (!table) {
+      return;
+    }
+    const foreignKey = table.foreignKeys.find((fk) => fk.columnNames.includes('facility_id'));
+    if (foreignKey) {
+      await queryRunner.dropForeignKey('freight.warehouses', foreignKey);
+    }
+    const hasColumn = table.columns.some((col) => col.name === 'facility_id');
+    if (hasColumn) {
+      await queryRunner.dropColumn('freight.warehouses', 'facility_id');
+    }
+  }
+}
diff --git a/apps/edr-freight-api/src/migrations/1750000000002-AddProofOfDeliveryToCargoes.ts b/apps/edr-freight-api/src/migrations/1750000000002-AddProofOfDeliveryToCargoes.ts
new file mode 100644
index 000000000..67957f437
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/1750000000002-AddProofOfDeliveryToCargoes.ts
@@ -0,0 +1,48 @@
+import { MigrationInterface, QueryRunner, TableColumn } from 'typeorm';
+
+/**
+ * Proof of Delivery (customer pickup) capture on cargoes:
+ * receiver name, delivered/picked-up timestamp, and delivery remarks.
+ */
+export class AddProofOfDeliveryToCargoes1750000000002 implements MigrationInterface {
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    const table = await queryRunner.getTable('freight.cargoes');
+    if (!table) {
+      // cargoes table doesn't exist yet, skip this migration
+      return;
+    }
+
+    const columnsToAdd = [
+      { name: 'receiver_name', type: 'varchar', isNullable: true },
+      { name: 'delivered_at', type: 'timestamp', isNullable: true },
+      { name: 'delivery_remarks', type: 'text', isNullable: true },
+    ];
+
+    const columnsToCreate = columnsToAdd.filter(
+      (col) => !table.columns.some((c) => c.name === col.name),
+    );
+
+    if (columnsToCreate.length > 0) {
+      await queryRunner.addColumns(
+        'freight.cargoes',
+        columnsToCreate.map((col) => new TableColumn(col)),
+      );
+    }
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    const table = await queryRunner.getTable('freight.cargoes');
+    if (!table) {
+      return;
+    }
+
+    const columnNames = ['receiver_name', 'delivered_at', 'delivery_remarks'];
+    const columnsToRemove = columnNames.filter((name) =>
+      table.columns.some((c) => c.name === name),
+    );
+
+    if (columnsToRemove.length > 0) {
+      await queryRunner.dropColumns('freight.cargoes', columnsToRemove);
+    }
+  }
+}
diff --git a/apps/edr-freight-api/src/migrations/1750000000003-AddWarehouseInspection.ts b/apps/edr-freight-api/src/migrations/1750000000003-AddWarehouseInspection.ts
new file mode 100644
index 000000000..88ef8d3a5
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/1750000000003-AddWarehouseInspection.ts
@@ -0,0 +1,75 @@
+import { MigrationInterface, QueryRunner, Table, TableColumn } from 'typeorm';
+
+/**
+ * Batch 4.5 — warehouse inspection reports + inventory inspection status.
+ */
+export class AddWarehouseInspection1750000000003 implements MigrationInterface {
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    // inventory.inspection_status
+    const inventoryTable = await queryRunner.getTable('freight.warehouse_inventory');
+    if (inventoryTable) {
+      const hasColumn = inventoryTable.columns.some((col) => col.name === 'inspection_status');
+      if (!hasColumn) {
+        await queryRunner.addColumn(
+          'freight.warehouse_inventory',
+          new TableColumn({ name: 'inspection_status', type: 'varchar', length: '20', isNullable: true }),
+        );
+      }
+    }
+
+    // warehouse_inspection_reports table
+    const inspectionTable = await queryRunner.getTable('freight.warehouse_inspection_reports');
+    if (!inspectionTable) {
+      await queryRunner.createTable(
+        new Table({
+          schema: 'freight',
+          name: 'warehouse_inspection_reports',
+          columns: [
+            { name: 'id', type: 'uuid', isPrimary: true, default: 'uuid_generate_v4()' },
+            { name: 'inventory_id', type: 'uuid' },
+            { name: 'booking_id', type: 'uuid', isNullable: true },
+            { name: 'customer_id', type: 'uuid', isNullable: true },
+            { name: 'report_type', type: 'varchar', length: '32', default: "'INSPECTION'" },
+            { name: 'inspection_status', type: 'varchar', length: '20', default: "'NEEDS_REVIEW'" },
+            { name: 'has_damage', type: 'boolean', default: false },
+            { name: 'damage_description', type: 'text', isNullable: true },
+            { name: 'has_weight_loss', type: 'boolean', default: false },
+            { name: 'expected_weight', type: 'numeric', precision: 14, scale: 3, isNullable: true },
+            { name: 'actual_weight', type: 'numeric', precision: 14, scale: 3, isNullable: true },
+            { name: 'weight_loss', type: 'numeric', precision: 14, scale: 3, isNullable: true },
+            { name: 'weight_loss_unit', type: 'varchar', length: '12', isNullable: true },
+            { name: 'has_missing_items', type: 'boolean', default: false },
+            { name: 'missing_items_description', type: 'text', isNullable: true },
+            { name: 'remarks', type: 'text', isNullable: true },
+            { name: 'inspected_by_id', type: 'uuid', isNullable: true },
+            { name: 'inspected_at', type: 'timestamptz', isNullable: true },
+            { name: 'created_at', type: 'timestamptz', default: 'now()' },
+            { name: 'updated_at', type: 'timestamptz', default: 'now()' },
+            { name: 'deleted_at', type: 'timestamptz', isNullable: true },
+          ],
+          indices: [
+            { name: 'idx_wir_inventory', columnNames: ['inventory_id'] },
+            { name: 'idx_wir_booking', columnNames: ['booking_id'] },
+            { name: 'idx_wir_status', columnNames: ['inspection_status'] },
+          ],
+        }),
+        true,
+      );
+    }
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    const inspectionTable = await queryRunner.getTable('freight.warehouse_inspection_reports');
+    if (inspectionTable) {
+      await queryRunner.dropTable('freight.warehouse_inspection_reports', true);
+    }
+
+    const inventoryTable = await queryRunner.getTable('freight.warehouse_inventory');
+    if (inventoryTable) {
+      const hasColumn = inventoryTable.columns.some((col) => col.name === 'inspection_status');
+      if (hasColumn) {
+        await queryRunner.dropColumn('freight.warehouse_inventory', 'inspection_status');
+      }
+    }
+  }
+}
diff --git a/apps/edr-freight-api/src/migrations/1750200000000-AddPhysicalWagonToTrainSetWagons.ts b/apps/edr-freight-api/src/migrations/1750200000000-AddPhysicalWagonToTrainSetWagons.ts
new file mode 100644
index 000000000..9ce1db6c1
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/1750200000000-AddPhysicalWagonToTrainSetWagons.ts
@@ -0,0 +1,48 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class AddPhysicalWagonToTrainSetWagons1750200000000 implements MigrationInterface {
+  name = 'AddPhysicalWagonToTrainSetWagons1750200000000';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      ALTER TABLE freight.train_set_wagons
+      ADD COLUMN IF NOT EXISTS physical_wagon_id UUID NULL;
+    `);
+
+    await queryRunner.query(`
+      DO $$
+      BEGIN
+        IF NOT EXISTS (
+          SELECT 1
+          FROM information_schema.table_constraints
+          WHERE constraint_schema = 'freight'
+            AND table_name = 'train_set_wagons'
+            AND constraint_name = 'fk_train_set_wagons_physical_wagon'
+        ) THEN
+          ALTER TABLE freight.train_set_wagons
+          ADD CONSTRAINT fk_train_set_wagons_physical_wagon
+          FOREIGN KEY (physical_wagon_id)
+          REFERENCES freight.wagons(id)
+          ON DELETE SET NULL;
+        END IF;
+      END $$;
+    `);
+
+    await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS idx_train_set_wagons_physical_wagon
+      ON freight.train_set_wagons(physical_wagon_id);
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`DROP INDEX IF EXISTS freight.idx_train_set_wagons_physical_wagon;`);
+    await queryRunner.query(`
+      ALTER TABLE freight.train_set_wagons
+      DROP CONSTRAINT IF EXISTS fk_train_set_wagons_physical_wagon;
+    `);
+    await queryRunner.query(`
+      ALTER TABLE freight.train_set_wagons
+      DROP COLUMN IF EXISTS physical_wagon_id;
+    `);
+  }
+}
diff --git a/apps/edr-freight-api/src/migrations/1750300000000-AddCurrentLocationToWagons.ts b/apps/edr-freight-api/src/migrations/1750300000000-AddCurrentLocationToWagons.ts
new file mode 100644
index 000000000..454218fd7
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/1750300000000-AddCurrentLocationToWagons.ts
@@ -0,0 +1,48 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class AddCurrentLocationToWagons1750300000000 implements MigrationInterface {
+  name = 'AddCurrentLocationToWagons1750300000000';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      ALTER TABLE freight.wagons
+      ADD COLUMN IF NOT EXISTS current_location_yard_id UUID NULL;
+    `);
+
+    await queryRunner.query(`
+      DO $$
+      BEGIN
+        IF NOT EXISTS (
+          SELECT 1
+          FROM information_schema.table_constraints
+          WHERE constraint_schema = 'freight'
+            AND table_name = 'wagons'
+            AND constraint_name = 'FK_wagons_current_location_yard_id'
+        ) THEN
+          ALTER TABLE freight.wagons
+          ADD CONSTRAINT "FK_wagons_current_location_yard_id"
+          FOREIGN KEY (current_location_yard_id)
+          REFERENCES freight.yards(id)
+          ON DELETE SET NULL;
+        END IF;
+      END $$;
+    `);
+
+    await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS "IDX_wagons_current_location_yard_id"
+      ON freight.wagons(current_location_yard_id);
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`DROP INDEX IF EXISTS freight."IDX_wagons_current_location_yard_id";`);
+    await queryRunner.query(`
+      ALTER TABLE freight.wagons
+      DROP CONSTRAINT IF EXISTS "FK_wagons_current_location_yard_id";
+    `);
+    await queryRunner.query(`
+      ALTER TABLE freight.wagons
+      DROP COLUMN IF EXISTS current_location_yard_id;
+    `);
+  }
+}
diff --git a/apps/edr-freight-api/src/migrations/1750400000000-SeedEdRWagonFleet.ts b/apps/edr-freight-api/src/migrations/1750400000000-SeedEdRWagonFleet.ts
new file mode 100644
index 000000000..0a4e96276
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/1750400000000-SeedEdRWagonFleet.ts
@@ -0,0 +1,214 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+type FleetRow = {
+  code: string;
+  name: string;
+  count: number;
+  start: number;
+  end: number;
+  capacityTons: number;
+  tareWeight: number;
+  lengthMeters: number;
+  supportedLoadTypes: string[];
+};
+
+const FLEET: FleetRow[] = [
+  {
+    code: 'PW2',
+    name: 'Box wagon',
+    count: 220,
+    start: 1,
+    end: 220,
+    capacityTons: 70,
+    tareWeight: 25.2,
+    lengthMeters: 17.066,
+    supportedLoadTypes: ['BULK', 'GENERAL_CARGO', 'BAGGED_CARGO', 'BOXED_CARGO'],
+  },
+  {
+    code: 'CW4',
+    name: 'Gondola wagon covered',
+    count: 110,
+    start: 221,
+    end: 330,
+    capacityTons: 70,
+    tareWeight: 24.8,
+    lengthMeters: 13.976,
+    supportedLoadTypes: ['CONTAINER'],
+  },
+  {
+    code: 'CW3',
+    name: 'Gondola wagon',
+    count: 20,
+    start: 331,
+    end: 350,
+    capacityTons: 70,
+    tareWeight: 23.4,
+    lengthMeters: 13.976,
+    supportedLoadTypes: ['BULK', 'COAL', 'ORE'],
+  },
+  {
+    code: 'KW2',
+    name: 'Hopper wagon covered',
+    count: 20,
+    start: 351,
+    end: 370,
+    capacityTons: 69,
+    tareWeight: 25.2,
+    lengthMeters: 16.466,
+    supportedLoadTypes: ['BULK', 'GRAIN'],
+  },
+  {
+    code: 'KW3',
+    name: 'Hopper wagon',
+    count: 20,
+    start: 371,
+    end: 390,
+    capacityTons: 70,
+    tareWeight: 24,
+    lengthMeters: 14.4,
+    supportedLoadTypes: ['BULK', 'COAL'],
+  },
+  {
+    code: 'NW5',
+    name: 'Flat wagon container',
+    count: 550,
+    start: 391,
+    end: 940,
+    capacityTons: 70,
+    tareWeight: 0,
+    lengthMeters: 14,
+    supportedLoadTypes: ['CONTAINER'],
+  },
+];
+
+const wagonNumber = (sequence: number) => `ER${String(sequence).padStart(4, '0')}`;
+
+export class SeedEdRWagonFleet1750400000000 implements MigrationInterface {
+  name = 'SeedEdRWagonFleet1750400000000';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      UPDATE freight.wagon_types
+      SET name = 'Flat wagon container',
+          capacity_tons = 70,
+          length_meters = 14.000,
+          supported_load_types = ARRAY['CONTAINER'],
+          max_wagons_per_train = 53,
+          is_active = true,
+          deleted_at = NULL,
+          updated_at = now()
+      WHERE code = 'NW5';
+    `);
+
+    const [defaultLocation] = await queryRunner.query(`
+      SELECT id
+      FROM freight.yards
+      WHERE code IN ('DJIBOUTI', 'DJIB_PORT', 'NAGAD')
+         OR lower(label) LIKE '%djibouti%'
+      ORDER BY
+        CASE code
+          WHEN 'DJIBOUTI' THEN 1
+          WHEN 'DJIB_PORT' THEN 2
+          WHEN 'NAGAD' THEN 3
+          ELSE 4
+        END,
+        display_order ASC
+      LIMIT 1;
+    `);
+    const defaultLocationYardId = defaultLocation?.id ?? null;
+
+    for (const row of FLEET) {
+      await queryRunner.query(
+        `
+          INSERT INTO freight.wagon_types (
+            code,
+            name,
+            capacity_tons,
+            length_meters,
+            max_wagons_per_train,
+            supported_load_types,
+            is_active
+          )
+          VALUES ($1, $2, $3, $4, $5, $6::text[], true)
+          ON CONFLICT (code) DO UPDATE SET
+            name = EXCLUDED.name,
+            capacity_tons = EXCLUDED.capacity_tons,
+            length_meters = EXCLUDED.length_meters,
+            max_wagons_per_train = EXCLUDED.max_wagons_per_train,
+            supported_load_types = EXCLUDED.supported_load_types,
+            is_active = true,
+            deleted_at = NULL,
+            updated_at = now();
+        `,
+        [
+          row.code,
+          row.name,
+          row.capacityTons,
+          row.lengthMeters,
+          row.supportedLoadTypes.includes('CONTAINER') ? 53 : 37,
+          row.supportedLoadTypes,
+        ],
+      );
+
+      const [typeRecord] = await queryRunner.query(
+        `SELECT id FROM freight.wagon_types WHERE code = $1 LIMIT 1;`,
+        [row.code],
+      );
+
+      if (!typeRecord?.id) {
+        throw new Error(`wagon_type_seed_failed:${row.code}`);
+      }
+
+      if (row.end - row.start + 1 !== row.count) {
+        throw new Error(`wagon_range_mismatch:${row.code}`);
+      }
+
+      for (let sequence = row.start; sequence <= row.end; sequence += 1) {
+        await queryRunner.query(
+          `
+            INSERT INTO freight.wagons (
+              wagon_number,
+              wagon_type_id,
+              tare_weight,
+              max_payload_weight,
+              current_location_yard_id,
+              status,
+              notes
+            )
+            VALUES ($1, $2, $3, $4, $5, $6, $7)
+            ON CONFLICT (wagon_number) DO UPDATE SET
+              wagon_type_id = EXCLUDED.wagon_type_id,
+              tare_weight = EXCLUDED.tare_weight,
+              max_payload_weight = EXCLUDED.max_payload_weight,
+              current_location_yard_id = CASE
+                WHEN freight.wagons.train_id IS NULL THEN EXCLUDED.current_location_yard_id
+                ELSE freight.wagons.current_location_yard_id
+              END,
+              status = CASE
+                WHEN freight.wagons.train_id IS NULL THEN EXCLUDED.status
+                ELSE freight.wagons.status
+              END,
+              notes = EXCLUDED.notes,
+              updated_at = now();
+          `,
+          [
+            wagonNumber(sequence),
+            typeRecord.id,
+            row.tareWeight,
+            row.capacityTons,
+            defaultLocationYardId,
+            defaultLocationYardId ? 'IMPORT_READY' : 'AVAILABLE',
+            `Seeded Ethio-Djibouti Railway ${row.code} fleet record.`,
+          ],
+        );
+      }
+    }
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      DELETE FROM freight.wagons
+      WHERE wagon_number BETWEEN 'ER0001' AND 'ER0940';
+    `);
+  }
+}
diff --git a/apps/edr-freight-api/src/migrations/1770000000000-CreateVehiclesTable.ts b/apps/edr-freight-api/src/migrations/1770000000000-CreateVehiclesTable.ts
new file mode 100644
index 000000000..2cf09c9f5
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/1770000000000-CreateVehiclesTable.ts
@@ -0,0 +1,39 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class CreateVehiclesTable1770000000000 implements MigrationInterface {
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      DO $$
+      BEGIN
+        IF NOT EXISTS (SELECT 1 FROM information_schema.tables WHERE table_name = 'vehicles' AND table_schema = 'freight') THEN
+          CREATE TABLE freight.vehicles (
+            id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+            plate_number VARCHAR NOT NULL UNIQUE,
+            registration_number VARCHAR NOT NULL UNIQUE,
+            vehicle_type VARCHAR NOT NULL,
+            manufacturer VARCHAR NOT NULL,
+            model VARCHAR NOT NULL,
+            year INTEGER NOT NULL,
+            fuel_type VARCHAR NOT NULL,
+            capacity NUMERIC NOT NULL,
+            status VARCHAR DEFAULT 'ACTIVE' NOT NULL,
+            description TEXT,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP NOT NULL,
+            updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP NOT NULL,
+            deleted_at TIMESTAMP NULL
+          );
+
+          CREATE INDEX idx_vehicles_plate_number ON freight.vehicles(plate_number);
+          CREATE INDEX idx_vehicles_registration_number ON freight.vehicles(registration_number);
+          CREATE INDEX idx_vehicles_status ON freight.vehicles(status);
+          CREATE INDEX idx_vehicles_vehicle_type ON freight.vehicles(vehicle_type);
+          CREATE INDEX idx_vehicles_manufacturer ON freight.vehicles(manufacturer);
+        END IF;
+      END $$;
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`DROP TABLE IF EXISTS freight.vehicles CASCADE;`);
+  }
+}
diff --git a/apps/edr-freight-api/src/migrations/1790000000000-AddWarehouseAllocationAndFeeRules.ts b/apps/edr-freight-api/src/migrations/1790000000000-AddWarehouseAllocationAndFeeRules.ts
new file mode 100644
index 000000000..05b1259f4
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/1790000000000-AddWarehouseAllocationAndFeeRules.ts
@@ -0,0 +1,125 @@
+import { MigrationInterface, QueryRunner, Table, TableColumn } from 'typeorm';
+
+/**
+ * Batch 5 — warehouse allocation rules, storage/demurrage fee rules,
+ * and demurrage lifecycle timestamps on inventory.
+ */
+export class AddWarehouseAllocationAndFeeRules1790000000000 implements MigrationInterface {
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.createTable(
+      new Table({
+        schema: 'freight',
+        name: 'warehouse_allocation_rules',
+        columns: [
+          { name: 'id', type: 'uuid', isPrimary: true, default: 'uuid_generate_v4()' },
+          { name: 'name', type: 'varchar', length: '160' },
+          { name: 'priority', type: 'int', default: 100 },
+          { name: 'freight_type', type: 'varchar', length: '16', isNullable: true },
+          { name: 'trade_direction', type: 'varchar', length: '16', isNullable: true },
+          { name: 'cargo_type_code', type: 'varchar', length: '50', isNullable: true },
+          { name: 'container_status', type: 'varchar', length: '24', isNullable: true },
+          { name: 'requires_inspection', type: 'boolean', isNullable: true },
+          { name: 'target_facility_code', type: 'varchar', length: '40', isNullable: true },
+          { name: 'target_yard_code', type: 'varchar', length: '40' },
+          { name: 'target_warehouse_code', type: 'varchar', length: '40', isNullable: true },
+          { name: 'target_zone_code', type: 'varchar', length: '40', isNullable: true },
+          { name: 'storage_type', type: 'varchar', length: '80', isNullable: true },
+          { name: 'is_active', type: 'boolean', default: true },
+          { name: 'created_at', type: 'timestamptz', default: 'now()' },
+          { name: 'updated_at', type: 'timestamptz', default: 'now()' },
+          { name: 'deleted_at', type: 'timestamptz', isNullable: true },
+        ],
+        indices: [
+          { name: 'idx_war_priority', columnNames: ['priority'] },
+          { name: 'idx_war_active', columnNames: ['is_active'] },
+        ],
+      }),
+      true,
+    );
+
+    await queryRunner.createTable(
+      new Table({
+        schema: 'freight',
+        name: 'warehouse_fee_rules',
+        columns: [
+          { name: 'id', type: 'uuid', isPrimary: true, default: 'uuid_generate_v4()' },
+          { name: 'name', type: 'varchar', length: '160' },
+          { name: 'rule_type', type: 'varchar', length: '20' },
+          { name: 'priority', type: 'int', default: 100 },
+          { name: 'freight_type', type: 'varchar', length: '16', isNullable: true },
+          { name: 'trade_direction', type: 'varchar', length: '16', isNullable: true },
+          { name: 'cargo_type_code', type: 'varchar', length: '50', isNullable: true },
+          { name: 'container_type', type: 'varchar', length: '40', isNullable: true },
+          { name: 'facility_id', type: 'uuid', isNullable: true },
+          { name: 'warehouse_id', type: 'uuid', isNullable: true },
+          { name: 'yard_id', type: 'uuid', isNullable: true },
+          { name: 'zone_id', type: 'uuid', isNullable: true },
+          { name: 'free_days', type: 'int', default: 0 },
+          { name: 'rate_per_day', type: 'numeric', precision: 14, scale: 2, default: 0 },
+          { name: 'currency', type: 'varchar', length: '8', default: "'USD'" },
+          { name: 'is_active', type: 'boolean', default: true },
+          { name: 'created_at', type: 'timestamptz', default: 'now()' },
+          { name: 'updated_at', type: 'timestamptz', default: 'now()' },
+          { name: 'deleted_at', type: 'timestamptz', isNullable: true },
+        ],
+        indices: [
+          { name: 'idx_wfr_type', columnNames: ['rule_type'] },
+          { name: 'idx_wfr_active', columnNames: ['is_active'] },
+        ],
+      }),
+      true,
+    );
+
+    const inventoryTable = await queryRunner.getTable('freight.warehouse_inventory');
+    if (inventoryTable) {
+      const columnsToAdd = [
+        { name: 'inspection_started_at', type: 'timestamptz', isNullable: true },
+        { name: 'inspection_completed_at', type: 'timestamptz', isNullable: true },
+        { name: 'ready_for_pickup_at', type: 'timestamptz', isNullable: true },
+        { name: 'release_date', type: 'timestamptz', isNullable: true },
+        { name: 'gate_cleared_at', type: 'timestamptz', isNullable: true },
+      ];
+
+      const columnsToCreate = columnsToAdd.filter(
+        (col) => !inventoryTable.columns.some((c) => c.name === col.name),
+      );
+
+      if (columnsToCreate.length > 0) {
+        await queryRunner.addColumns(
+          'freight.warehouse_inventory',
+          columnsToCreate.map((col) => new TableColumn(col)),
+        );
+      }
+    }
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    const inventoryTable = await queryRunner.getTable('freight.warehouse_inventory');
+    if (inventoryTable) {
+      const columnNames = [
+        'inspection_started_at',
+        'inspection_completed_at',
+        'ready_for_pickup_at',
+        'release_date',
+        'gate_cleared_at',
+      ];
+      const columnsToRemove = columnNames.filter((name) =>
+        inventoryTable.columns.some((c) => c.name === name),
+      );
+
+      if (columnsToRemove.length > 0) {
+        await queryRunner.dropColumns('freight.warehouse_inventory', columnsToRemove);
+      }
+    }
+
+    const feeRulesTable = await queryRunner.getTable('freight.warehouse_fee_rules');
+    if (feeRulesTable) {
+      await queryRunner.dropTable('freight.warehouse_fee_rules', true);
+    }
+
+    const allocationRulesTable = await queryRunner.getTable('freight.warehouse_allocation_rules');
+    if (allocationRulesTable) {
+      await queryRunner.dropTable('freight.warehouse_allocation_rules', true);
+    }
+  }
+}
diff --git a/apps/edr-freight-api/src/migrations/1790000000000-CreateWarehouseModule.ts b/apps/edr-freight-api/src/migrations/1790000000000-CreateWarehouseModule.ts
new file mode 100644
index 000000000..b921a7194
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/1790000000000-CreateWarehouseModule.ts
@@ -0,0 +1,124 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class CreateWarehouseModule1790000000000 implements MigrationInterface {
+  name = 'CreateWarehouseModule1790000000000';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      CREATE TABLE IF NOT EXISTS freight.warehouses (
+        id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+        name VARCHAR(160) NOT NULL,
+        code VARCHAR(40) NOT NULL UNIQUE,
+        type VARCHAR(32) NOT NULL,
+        station_id UUID NULL,
+        location_name VARCHAR(200) NULL,
+        capacity_weight NUMERIC(14,3) NULL,
+        capacity_containers INT NULL,
+        current_weight NUMERIC(14,3) NOT NULL DEFAULT 0,
+        current_containers INT NOT NULL DEFAULT 0,
+        status VARCHAR(16) NOT NULL DEFAULT 'ACTIVE',
+        is_active BOOLEAN NOT NULL DEFAULT true,
+        created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+        updated_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+        deleted_at TIMESTAMPTZ NULL
+      );
+    `);
+
+    await queryRunner.query(`
+      CREATE TABLE IF NOT EXISTS freight.warehouse_yards (
+        id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+        warehouse_id UUID NOT NULL REFERENCES freight.warehouses(id) ON DELETE CASCADE,
+        name VARCHAR(160) NOT NULL,
+        code VARCHAR(40) NOT NULL,
+        type VARCHAR(32) NOT NULL,
+        capacity_weight NUMERIC(14,3) NULL,
+        capacity_containers INT NULL,
+        current_weight NUMERIC(14,3) NOT NULL DEFAULT 0,
+        current_containers INT NOT NULL DEFAULT 0,
+        status VARCHAR(16) NOT NULL DEFAULT 'ACTIVE',
+        is_active BOOLEAN NOT NULL DEFAULT true,
+        created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+        updated_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+        deleted_at TIMESTAMPTZ NULL,
+        CONSTRAINT uq_warehouse_yards_code UNIQUE (warehouse_id, code)
+      );
+    `);
+
+    await queryRunner.query(`
+      CREATE TABLE IF NOT EXISTS freight.warehouse_zones (
+        id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+        yard_id UUID NOT NULL REFERENCES freight.warehouse_yards(id) ON DELETE CASCADE,
+        name VARCHAR(160) NOT NULL,
+        code VARCHAR(40) NOT NULL,
+        type VARCHAR(32) NOT NULL,
+        capacity_weight NUMERIC(14,3) NULL,
+        capacity_containers INT NULL,
+        current_weight NUMERIC(14,3) NOT NULL DEFAULT 0,
+        current_containers INT NOT NULL DEFAULT 0,
+        status VARCHAR(16) NOT NULL DEFAULT 'ACTIVE',
+        is_active BOOLEAN NOT NULL DEFAULT true,
+        created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+        updated_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+        deleted_at TIMESTAMPTZ NULL,
+        CONSTRAINT uq_warehouse_zones_code UNIQUE (yard_id, code)
+      );
+    `);
+
+    await queryRunner.query(`
+      CREATE TABLE IF NOT EXISTS freight.warehouse_inventory (
+        id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+        warehouse_id UUID NOT NULL REFERENCES freight.warehouses(id),
+        yard_id UUID NOT NULL REFERENCES freight.warehouse_yards(id),
+        zone_id UUID NOT NULL REFERENCES freight.warehouse_zones(id),
+        booking_id UUID NOT NULL,
+        cargo_id UUID NULL,
+        container_id UUID NULL,
+        goods_id UUID NULL,
+        quantity NUMERIC(12,3) NOT NULL DEFAULT 0,
+        weight NUMERIC(14,3) NOT NULL DEFAULT 0,
+        volume NUMERIC(12,3) NULL,
+        status VARCHAR(32) NOT NULL DEFAULT 'ARRIVED_AT_WAREHOUSE',
+        arrived_at TIMESTAMPTZ NULL,
+        inspected_at TIMESTAMPTZ NULL,
+        ready_for_loading_at TIMESTAMPTZ NULL,
+        notes TEXT NULL,
+        created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+        updated_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+        deleted_at TIMESTAMPTZ NULL
+      );
+    `);
+
+    const indexes: Array<[string, string, string]> = [
+      ['idx_warehouses_type', 'warehouses', 'type'],
+      ['idx_warehouses_status', 'warehouses', 'status'],
+      ['idx_warehouses_station_id', 'warehouses', 'station_id'],
+      ['idx_warehouse_yards_warehouse_id', 'warehouse_yards', 'warehouse_id'],
+      ['idx_warehouse_yards_type', 'warehouse_yards', 'type'],
+      ['idx_warehouse_yards_status', 'warehouse_yards', 'status'],
+      ['idx_warehouse_zones_yard_id', 'warehouse_zones', 'yard_id'],
+      ['idx_warehouse_zones_type', 'warehouse_zones', 'type'],
+      ['idx_warehouse_zones_status', 'warehouse_zones', 'status'],
+      ['idx_warehouse_inventory_warehouse_id', 'warehouse_inventory', 'warehouse_id'],
+      ['idx_warehouse_inventory_yard_id', 'warehouse_inventory', 'yard_id'],
+      ['idx_warehouse_inventory_zone_id', 'warehouse_inventory', 'zone_id'],
+      ['idx_warehouse_inventory_booking_id', 'warehouse_inventory', 'booking_id'],
+      ['idx_warehouse_inventory_cargo_id', 'warehouse_inventory', 'cargo_id'],
+      ['idx_warehouse_inventory_container_id', 'warehouse_inventory', 'container_id'],
+      ['idx_warehouse_inventory_goods_id', 'warehouse_inventory', 'goods_id'],
+      ['idx_warehouse_inventory_status', 'warehouse_inventory', 'status'],
+    ];
+
+    for (const [indexName, table, column] of indexes) {
+      await queryRunner.query(
+        `CREATE INDEX IF NOT EXISTS ${indexName} ON freight.${table}(${column});`,
+      );
+    }
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`DROP TABLE IF EXISTS freight.warehouse_inventory;`);
+    await queryRunner.query(`DROP TABLE IF EXISTS freight.warehouse_zones;`);
+    await queryRunner.query(`DROP TABLE IF EXISTS freight.warehouse_yards;`);
+    await queryRunner.query(`DROP TABLE IF EXISTS freight.warehouses;`);
+  }
+}
diff --git a/apps/edr-freight-api/src/migrations/1790000000001-AddWarehouseFeeInvoices.ts b/apps/edr-freight-api/src/migrations/1790000000001-AddWarehouseFeeInvoices.ts
new file mode 100644
index 000000000..c34eb240a
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/1790000000001-AddWarehouseFeeInvoices.ts
@@ -0,0 +1,88 @@
+import { MigrationInterface, QueryRunner, Table } from 'typeorm';
+
+/** Batch 6 — warehouse fee invoices + invoice items. */
+export class AddWarehouseFeeInvoices1790000000001 implements MigrationInterface {
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.createTable(
+      new Table({
+        schema: 'freight',
+        name: 'warehouse_fee_invoices',
+        columns: [
+          { name: 'id', type: 'uuid', isPrimary: true, default: 'uuid_generate_v4()' },
+          { name: 'invoice_number', type: 'varchar', length: '40', isUnique: true },
+          { name: 'booking_id', type: 'uuid', isNullable: true },
+          { name: 'customer_id', type: 'uuid', isNullable: true },
+          { name: 'inventory_id', type: 'uuid' },
+          { name: 'facility_id', type: 'uuid', isNullable: true },
+          { name: 'warehouse_id', type: 'uuid', isNullable: true },
+          { name: 'yard_id', type: 'uuid', isNullable: true },
+          { name: 'zone_id', type: 'uuid', isNullable: true },
+          { name: 'invoice_type', type: 'varchar', length: '32', default: "'MIXED_WAREHOUSE_FEES'" },
+          { name: 'status', type: 'varchar', length: '20', default: "'DRAFT'" },
+          { name: 'subtotal_amount', type: 'numeric', precision: 14, scale: 2, default: 0 },
+          { name: 'tax_amount', type: 'numeric', precision: 14, scale: 2, default: 0 },
+          { name: 'total_amount', type: 'numeric', precision: 14, scale: 2, default: 0 },
+          { name: 'paid_amount', type: 'numeric', precision: 14, scale: 2, default: 0 },
+          { name: 'balance_amount', type: 'numeric', precision: 14, scale: 2, default: 0 },
+          { name: 'currency', type: 'varchar', length: '8', default: "'USD'" },
+          { name: 'period_start', type: 'timestamptz', isNullable: true },
+          { name: 'period_end', type: 'timestamptz', isNullable: true },
+          { name: 'issued_at', type: 'timestamptz', isNullable: true },
+          { name: 'due_date', type: 'timestamptz', isNullable: true },
+          { name: 'paid_at', type: 'timestamptz', isNullable: true },
+          { name: 'cancelled_at', type: 'timestamptz', isNullable: true },
+          { name: 'payments', type: 'jsonb', default: "'[]'" },
+          { name: 'notes', type: 'text', isNullable: true },
+          { name: 'created_at', type: 'timestamptz', default: 'now()' },
+          { name: 'updated_at', type: 'timestamptz', default: 'now()' },
+          { name: 'deleted_at', type: 'timestamptz', isNullable: true },
+        ],
+        indices: [
+          { name: 'idx_wfi_booking', columnNames: ['booking_id'] },
+          { name: 'idx_wfi_inventory', columnNames: ['inventory_id'] },
+          { name: 'idx_wfi_status', columnNames: ['status'] },
+        ],
+      }),
+      true,
+    );
+
+    await queryRunner.createTable(
+      new Table({
+        schema: 'freight',
+        name: 'warehouse_fee_invoice_items',
+        columns: [
+          { name: 'id', type: 'uuid', isPrimary: true, default: 'uuid_generate_v4()' },
+          { name: 'invoice_id', type: 'uuid' },
+          { name: 'fee_rule_id', type: 'uuid', isNullable: true },
+          { name: 'fee_type', type: 'varchar', length: '32' },
+          { name: 'description', type: 'varchar', length: '255' },
+          { name: 'quantity', type: 'numeric', precision: 12, scale: 2, default: 1 },
+          { name: 'unit_rate', type: 'numeric', precision: 14, scale: 2, default: 0 },
+          { name: 'amount', type: 'numeric', precision: 14, scale: 2, default: 0 },
+          { name: 'currency', type: 'varchar', length: '8', default: "'USD'" },
+          { name: 'chargeable_days', type: 'int', isNullable: true },
+          { name: 'free_days', type: 'int', isNullable: true },
+          { name: 'created_at', type: 'timestamptz', default: 'now()' },
+          { name: 'updated_at', type: 'timestamptz', default: 'now()' },
+          { name: 'deleted_at', type: 'timestamptz', isNullable: true },
+        ],
+        foreignKeys: [
+          {
+            columnNames: ['invoice_id'],
+            referencedSchema: 'freight',
+            referencedTableName: 'warehouse_fee_invoices',
+            referencedColumnNames: ['id'],
+            onDelete: 'CASCADE',
+          },
+        ],
+        indices: [{ name: 'idx_wfii_invoice', columnNames: ['invoice_id'] }],
+      }),
+      true,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.dropTable('freight.warehouse_fee_invoice_items', true);
+    await queryRunner.dropTable('freight.warehouse_fee_invoices', true);
+  }
+}
diff --git a/apps/edr-freight-api/src/migrations/1790000000001-WarehouseBatch2.ts b/apps/edr-freight-api/src/migrations/1790000000001-WarehouseBatch2.ts
new file mode 100644
index 000000000..a1431d7bd
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/1790000000001-WarehouseBatch2.ts
@@ -0,0 +1,123 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class WarehouseBatch21790000000001 implements MigrationInterface {
+  name = 'WarehouseBatch21790000000001';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    // ── Capacity columns (weight + volume) on warehouse / yard / zone ──────
+    for (const table of ['warehouses', 'warehouse_yards', 'warehouse_zones']) {
+      await queryRunner.query(`
+        ALTER TABLE freight.${table}
+        ADD COLUMN IF NOT EXISTS max_weight NUMERIC(14,3) NULL,
+        ADD COLUMN IF NOT EXISTS max_volume NUMERIC(14,3) NULL,
+        ADD COLUMN IF NOT EXISTS current_volume NUMERIC(14,3) NOT NULL DEFAULT 0;
+      `);
+      // Backfill max_weight from the Batch 1 capacity_weight column.
+      await queryRunner.query(`
+        UPDATE freight.${table} SET max_weight = capacity_weight WHERE max_weight IS NULL;
+      `);
+    }
+
+    // ── Inventory lifecycle: migrate Batch 1 statuses to Batch 2 set ───────
+    await queryRunner.query(`
+      ALTER TABLE freight.warehouse_inventory
+      ALTER COLUMN status SET DEFAULT 'RECEIVED';
+    `);
+    await queryRunner.query(`
+      UPDATE freight.warehouse_inventory SET status = 'RECEIVED' WHERE status = 'ARRIVED_AT_WAREHOUSE';
+    `);
+    await queryRunner.query(`
+      UPDATE freight.warehouse_inventory SET status = 'STORED' WHERE status = 'UNDER_INSPECTION';
+    `);
+
+    // ── New lifecycle timestamps ──────────────────────────────────────────
+    await queryRunner.query(`
+      ALTER TABLE freight.warehouse_inventory
+      ADD COLUMN IF NOT EXISTS stored_at TIMESTAMPTZ NULL,
+      ADD COLUMN IF NOT EXISTS reserved_at TIMESTAMPTZ NULL,
+      ADD COLUMN IF NOT EXISTS loaded_at TIMESTAMPTZ NULL,
+      ADD COLUMN IF NOT EXISTS dispatched_at TIMESTAMPTZ NULL;
+    `);
+
+    // booking_id becomes nullable (inventory can exist before booking linkage).
+    await queryRunner.query(`
+      ALTER TABLE freight.warehouse_inventory ALTER COLUMN booking_id DROP NOT NULL;
+    `);
+
+    // ── Movement history ──────────────────────────────────────────────────
+    await queryRunner.query(`
+      CREATE TABLE IF NOT EXISTS freight.warehouse_inventory_movement (
+        id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+        inventory_id UUID NOT NULL REFERENCES freight.warehouse_inventory(id) ON DELETE CASCADE,
+        from_warehouse_id UUID NOT NULL,
+        from_yard_id UUID NOT NULL,
+        from_zone_id UUID NOT NULL,
+        to_warehouse_id UUID NOT NULL,
+        to_yard_id UUID NOT NULL,
+        to_zone_id UUID NOT NULL,
+        remarks TEXT NULL,
+        moved_by VARCHAR(120) NULL,
+        moved_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+        created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+        updated_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+        deleted_at TIMESTAMPTZ NULL
+      );
+    `);
+    await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS idx_warehouse_inventory_movement_inventory_id
+      ON freight.warehouse_inventory_movement(inventory_id);
+    `);
+
+    // ── Activity log ──────────────────────────────────────────────────────
+    await queryRunner.query(`
+      CREATE TABLE IF NOT EXISTS freight.warehouse_activity_log (
+        id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+        inventory_id UUID NULL,
+        warehouse_id UUID NULL,
+        activity_type VARCHAR(40) NOT NULL,
+        description TEXT NULL,
+        performed_by VARCHAR(120) NULL,
+        created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+        updated_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+        deleted_at TIMESTAMPTZ NULL
+      );
+    `);
+    await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS idx_warehouse_activity_log_inventory_id
+      ON freight.warehouse_activity_log(inventory_id);
+    `);
+    await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS idx_warehouse_activity_log_warehouse_id
+      ON freight.warehouse_activity_log(warehouse_id);
+    `);
+    await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS idx_warehouse_activity_log_activity_type
+      ON freight.warehouse_activity_log(activity_type);
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`DROP TABLE IF EXISTS freight.warehouse_activity_log;`);
+    await queryRunner.query(`DROP TABLE IF EXISTS freight.warehouse_inventory_movement;`);
+
+    await queryRunner.query(`
+      ALTER TABLE freight.warehouse_inventory
+      DROP COLUMN IF EXISTS stored_at,
+      DROP COLUMN IF EXISTS reserved_at,
+      DROP COLUMN IF EXISTS loaded_at,
+      DROP COLUMN IF EXISTS dispatched_at;
+    `);
+    await queryRunner.query(`
+      ALTER TABLE freight.warehouse_inventory ALTER COLUMN status SET DEFAULT 'RECEIVED';
+    `);
+
+    for (const table of ['warehouses', 'warehouse_yards', 'warehouse_zones']) {
+      await queryRunner.query(`
+        ALTER TABLE freight.${table}
+        DROP COLUMN IF EXISTS max_weight,
+        DROP COLUMN IF EXISTS max_volume,
+        DROP COLUMN IF EXISTS current_volume;
+      `);
+    }
+  }
+}
diff --git a/apps/edr-freight-api/src/migrations/1790000000002-WarehouseBatch3.ts b/apps/edr-freight-api/src/migrations/1790000000002-WarehouseBatch3.ts
new file mode 100644
index 000000000..4dcc9329c
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/1790000000002-WarehouseBatch3.ts
@@ -0,0 +1,44 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+/**
+ * Batch 3 — Warehouse → Loading → Train Departure visibility.
+ * Adds the warehouse_loadings record (inventory ↔ wagon). Does NOT touch any
+ * scheduling / wagon tables — the warehouse only reads from those.
+ */
+export class WarehouseBatch31790000000002 implements MigrationInterface {
+  name = 'WarehouseBatch31790000000002';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      CREATE TABLE IF NOT EXISTS freight.warehouse_loadings (
+        id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+        warehouse_inventory_id UUID NOT NULL REFERENCES freight.warehouse_inventory(id) ON DELETE CASCADE,
+        booking_id UUID NULL,
+        wagon_id UUID NOT NULL,
+        loaded_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+        loaded_by VARCHAR(120) NULL,
+        loaded_weight NUMERIC(14,3) NULL,
+        notes TEXT NULL,
+        created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+        updated_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+        deleted_at TIMESTAMPTZ NULL
+      );
+    `);
+    await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS idx_warehouse_loadings_inventory_id
+      ON freight.warehouse_loadings(warehouse_inventory_id);
+    `);
+    await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS idx_warehouse_loadings_booking_id
+      ON freight.warehouse_loadings(booking_id);
+    `);
+    await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS idx_warehouse_loadings_wagon_id
+      ON freight.warehouse_loadings(wagon_id);
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`DROP TABLE IF EXISTS freight.warehouse_loadings;`);
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/bookings/entities/booking.entity.ts b/apps/edr-freight-api/src/modules/bookings/entities/booking.entity.ts
index d5e72d860..c5dac1736 100644
--- a/apps/edr-freight-api/src/modules/bookings/entities/booking.entity.ts
+++ b/apps/edr-freight-api/src/modules/bookings/entities/booking.entity.ts
@@ -23,6 +23,9 @@ export const BOOKING_STATUSES = [
   'PENDING_APPROVAL',
   'APPROVED_PENDING_SIGNATURE',
   'APPROVED',
+  'READY_FOR_ASSIGNMENT',
+  'WAGON_ASSIGNED',
+  'INVOICED',
   'CONTRACT_READY',
   'SIGNED_CUSTOMER',
   'FULLY_EXECUTED',
diff --git a/apps/edr-freight-api/src/modules/cargoes/cargoes.service.ts b/apps/edr-freight-api/src/modules/cargoes/cargoes.service.ts
index 6c79f0a76..6f73035b4 100644
--- a/apps/edr-freight-api/src/modules/cargoes/cargoes.service.ts
+++ b/apps/edr-freight-api/src/modules/cargoes/cargoes.service.ts
@@ -157,7 +157,9 @@ export class CargoesService {
     }
 
     cargo.status = 'DELIVERED';
-    if (dto?.deliveryRemarks) cargo.description = dto.deliveryRemarks;
+    cargo.deliveredAt = dto?.pickupDate ? new Date(dto.pickupDate) : new Date();
+    if (dto?.receiverName) cargo.receiverName = dto.receiverName;
+    if (dto?.deliveryRemarks) cargo.deliveryRemarks = dto.deliveryRemarks;
 
     const remaining =
       cargo.containerId != null
diff --git a/apps/edr-freight-api/src/modules/cargoes/dto/deliver-cargo.dto.ts b/apps/edr-freight-api/src/modules/cargoes/dto/deliver-cargo.dto.ts
index 020e4d630..de402a33e 100644
--- a/apps/edr-freight-api/src/modules/cargoes/dto/deliver-cargo.dto.ts
+++ b/apps/edr-freight-api/src/modules/cargoes/dto/deliver-cargo.dto.ts
@@ -1,6 +1,16 @@
-import { IsOptional, IsString } from 'class-validator';
+import { IsDateString, IsOptional, IsString } from 'class-validator';
 
 export class DeliverCargoDto {
+  /** Name of the person who received / picked up the cargo (Proof of Delivery). */
+  @IsOptional()
+  @IsString()
+  receiverName?: string;
+
+  /** When the cargo was picked up / delivered. Defaults to now. */
+  @IsOptional()
+  @IsDateString()
+  pickupDate?: string;
+
   @IsOptional()
   @IsString()
   deliveryRemarks?: string;
diff --git a/apps/edr-freight-api/src/modules/cargoes/entities/cargoes.entity.ts b/apps/edr-freight-api/src/modules/cargoes/entities/cargoes.entity.ts
index ffc4bb26a..685f9b659 100644
--- a/apps/edr-freight-api/src/modules/cargoes/entities/cargoes.entity.ts
+++ b/apps/edr-freight-api/src/modules/cargoes/entities/cargoes.entity.ts
@@ -40,6 +40,16 @@ export class Cargo extends BaseEntity {
   @Column({ name: 'unloaded_at', type: 'timestamp', nullable: true })
   unloadedAt!: Date | null;
 
+  // Proof of Delivery (customer pickup) capture.
+  @Column({ name: 'receiver_name', type: 'varchar', nullable: true })
+  receiverName!: string | null;
+
+  @Column({ name: 'delivered_at', type: 'timestamp', nullable: true })
+  deliveredAt!: Date | null;
+
+  @Column({ name: 'delivery_remarks', type: 'text', nullable: true })
+  deliveryRemarks!: string | null;
+
   @Column({ name: 'wagon_booking_allocation_id', type: 'uuid', nullable: true })
   wagonBookingAllocationId!: string | null;
 
@@ -57,6 +67,7 @@ export class Cargo extends BaseEntity {
   @Column({ name: 'load_type', type: 'varchar', length: 20, nullable: true })
   loadType!: string | null;
 
+  // Relationship to Container
   @ManyToOne(() => Container, (container) => container.cargoes, { onDelete: 'RESTRICT', nullable: true })
   @JoinColumn({ name: 'container_id' })
   container!: Container | null;
diff --git a/apps/edr-freight-api/src/modules/facilities/dto/create-facility.dto.ts b/apps/edr-freight-api/src/modules/facilities/dto/create-facility.dto.ts
new file mode 100644
index 000000000..6a8776312
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/facilities/dto/create-facility.dto.ts
@@ -0,0 +1,18 @@
+import type { FacilityStatus, FacilityType } from '../entities/facility.entity';
+
+export class CreateFacilityDto {
+  code!: string;
+  name!: string;
+  description?: string;
+  facilityType!: FacilityType;
+  facilityStatus?: FacilityStatus;
+  locationName?: string;
+  country?: string;
+  city?: string;
+  address?: string;
+  latitude?: number;
+  longitude?: number;
+  capacity?: number;
+  isActive?: boolean;
+  notes?: string;
+}
diff --git a/apps/edr-freight-api/src/modules/facilities/dto/update-facility.dto.ts b/apps/edr-freight-api/src/modules/facilities/dto/update-facility.dto.ts
new file mode 100644
index 000000000..060aad95e
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/facilities/dto/update-facility.dto.ts
@@ -0,0 +1,18 @@
+import type { FacilityStatus, FacilityType } from '../entities/facility.entity';
+
+export class UpdateFacilityDto {
+  code?: string;
+  name?: string;
+  description?: string;
+  facilityType?: FacilityType;
+  facilityStatus?: FacilityStatus;
+  locationName?: string;
+  country?: string;
+  city?: string;
+  address?: string;
+  latitude?: number;
+  longitude?: number;
+  capacity?: number;
+  isActive?: boolean;
+  notes?: string;
+}
diff --git a/apps/edr-freight-api/src/modules/facilities/entities/facility.entity.ts b/apps/edr-freight-api/src/modules/facilities/entities/facility.entity.ts
new file mode 100644
index 000000000..a3d28c200
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/facilities/entities/facility.entity.ts
@@ -0,0 +1,60 @@
+import { BaseEntity } from '@edr/api-common';
+import { Column, Entity, Index, OneToMany } from 'typeorm';
+
+import { Warehouse } from '../../warehouses/entities/warehouse.entity';
+
+export const FACILITY_TYPES = ['PORT', 'DRY_PORT', 'TERMINAL', 'RAIL_YARD', 'WAREHOUSE_COMPLEX'] as const;
+export type FacilityType = (typeof FACILITY_TYPES)[number];
+
+export const FACILITY_STATUSES = ['ACTIVE', 'INACTIVE', 'UNDER_MAINTENANCE'] as const;
+export type FacilityStatus = (typeof FACILITY_STATUSES)[number];
+
+@Entity({ schema: 'freight', name: 'facilities' })
+@Index(['code'], { unique: true })
+@Index(['facilityStatus'])
+export class Facility extends BaseEntity {
+  @Column({ name: 'code', type: 'varchar', length: 40, unique: true })
+  code!: string;
+
+  @Column({ name: 'name', type: 'varchar', length: 160 })
+  name!: string;
+
+  @Column({ name: 'description', type: 'text', nullable: true })
+  description?: string | null;
+
+  @Column({ name: 'facility_type', type: 'varchar', length: 32 })
+  facilityType!: FacilityType;
+
+  @Column({ name: 'facility_status', type: 'varchar', length: 32, default: 'ACTIVE' })
+  facilityStatus!: FacilityStatus;
+
+  @Column({ name: 'location_name', type: 'varchar', length: 200, nullable: true })
+  locationName?: string | null;
+
+  @Column({ name: 'country', type: 'varchar', length: 100, nullable: true })
+  country?: string | null;
+
+  @Column({ name: 'city', type: 'varchar', length: 100, nullable: true })
+  city?: string | null;
+
+  @Column({ name: 'address', type: 'text', nullable: true })
+  address?: string | null;
+
+  @Column({ name: 'latitude', type: 'numeric', precision: 10, scale: 8, nullable: true })
+  latitude?: number | null;
+
+  @Column({ name: 'longitude', type: 'numeric', precision: 11, scale: 8, nullable: true })
+  longitude?: number | null;
+
+  @Column({ name: 'capacity', type: 'numeric', precision: 14, scale: 3, nullable: true })
+  capacity?: number | null;
+
+  @Column({ name: 'is_active', type: 'boolean', default: true })
+  isActive!: boolean;
+
+  @Column({ name: 'notes', type: 'text', nullable: true })
+  notes?: string | null;
+
+  @OneToMany(() => Warehouse, (warehouse) => warehouse.facility)
+  warehouses?: Warehouse[];
+}
diff --git a/apps/edr-freight-api/src/modules/facilities/facilities.controller.ts b/apps/edr-freight-api/src/modules/facilities/facilities.controller.ts
new file mode 100644
index 000000000..25fbbc365
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/facilities/facilities.controller.ts
@@ -0,0 +1,44 @@
+import { Body, Controller, Delete, Get, HttpCode, Param, Patch, Post } from '@nestjs/common';
+import { ApiOperation, ApiTags } from '@nestjs/swagger';
+
+import { CreateFacilityDto } from './dto/create-facility.dto';
+import { UpdateFacilityDto } from './dto/update-facility.dto';
+import { Facility } from './entities/facility.entity';
+import { FacilitiesService } from './facilities.service';
+
+@ApiTags('Facilities')
+@Controller('facilities')
+export class FacilitiesController {
+  constructor(private readonly facilitiesService: FacilitiesService) {}
+
+  @Post()
+  @ApiOperation({ summary: 'Create a new facility' })
+  async create(@Body() createFacilityDto: CreateFacilityDto): Promise<Facility> {
+    return this.facilitiesService.create(createFacilityDto);
+  }
+
+  @Get()
+  @ApiOperation({ summary: 'List all facilities' })
+  async findAll(): Promise<Facility[]> {
+    return this.facilitiesService.findAll();
+  }
+
+  @Get(':id')
+  @ApiOperation({ summary: 'Get a facility by ID' })
+  async findOne(@Param('id') id: string): Promise<Facility | null> {
+    return this.facilitiesService.findOne(id);
+  }
+
+  @Patch(':id')
+  @ApiOperation({ summary: 'Update a facility' })
+  async update(@Param('id') id: string, @Body() updateFacilityDto: UpdateFacilityDto): Promise<Facility | null> {
+    return this.facilitiesService.update(id, updateFacilityDto);
+  }
+
+  @Delete(':id')
+  @HttpCode(204)
+  @ApiOperation({ summary: 'Delete a facility (soft delete)' })
+  async remove(@Param('id') id: string): Promise<void> {
+    return this.facilitiesService.remove(id);
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/facilities/facilities.module.ts b/apps/edr-freight-api/src/modules/facilities/facilities.module.ts
new file mode 100644
index 000000000..cf9cd2b9f
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/facilities/facilities.module.ts
@@ -0,0 +1,15 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+
+import { Facility } from './entities/facility.entity';
+import { FacilitiesController } from './facilities.controller';
+import { FacilitiesRepository } from './facilities.repository';
+import { FacilitiesService } from './facilities.service';
+
+@Module({
+  imports: [TypeOrmModule.forFeature([Facility])],
+  controllers: [FacilitiesController],
+  providers: [FacilitiesService, FacilitiesRepository],
+  exports: [FacilitiesService, FacilitiesRepository],
+})
+export class FacilitiesModule {}
diff --git a/apps/edr-freight-api/src/modules/facilities/facilities.repository.ts b/apps/edr-freight-api/src/modules/facilities/facilities.repository.ts
new file mode 100644
index 000000000..32b2df232
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/facilities/facilities.repository.ts
@@ -0,0 +1,13 @@
+import { BaseRepository } from '@edr/api-common';
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+
+import { Facility } from './entities/facility.entity';
+
+@Injectable()
+export class FacilitiesRepository extends BaseRepository<Facility> {
+  constructor(@InjectRepository(Facility) repository: Repository<Facility>) {
+    super(repository);
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/facilities/facilities.service.ts b/apps/edr-freight-api/src/modules/facilities/facilities.service.ts
new file mode 100644
index 000000000..5cc0d62d7
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/facilities/facilities.service.ts
@@ -0,0 +1,31 @@
+import { Injectable } from '@nestjs/common';
+
+import { CreateFacilityDto } from './dto/create-facility.dto';
+import { UpdateFacilityDto } from './dto/update-facility.dto';
+import { Facility } from './entities/facility.entity';
+import { FacilitiesRepository } from './facilities.repository';
+
+@Injectable()
+export class FacilitiesService {
+  constructor(private readonly facilitiesRepository: FacilitiesRepository) {}
+
+  async create(createFacilityDto: CreateFacilityDto): Promise<Facility> {
+    return this.facilitiesRepository.create(createFacilityDto);
+  }
+
+  async findAll(): Promise<Facility[]> {
+    return this.facilitiesRepository.findAll({ relations: ['warehouses'] });
+  }
+
+  async findOne(id: string): Promise<Facility | null> {
+    return this.facilitiesRepository.findById(id);
+  }
+
+  async update(id: string, updateFacilityDto: UpdateFacilityDto): Promise<Facility | null> {
+    return this.facilitiesRepository.update(id, updateFacilityDto);
+  }
+
+  async remove(id: string): Promise<void> {
+    return this.facilitiesRepository.softDelete(id);
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/locomotives/entities/locomotive.entity.ts b/apps/edr-freight-api/src/modules/locomotives/entities/locomotive.entity.ts
index 25d32f106..6dcd9ad3e 100644
--- a/apps/edr-freight-api/src/modules/locomotives/entities/locomotive.entity.ts
+++ b/apps/edr-freight-api/src/modules/locomotives/entities/locomotive.entity.ts
@@ -6,6 +6,9 @@ import { Yard } from '../../rule-engine/entities/yard.entity';
 
 export const LOCOMOTIVE_STATUSES = [
   'AVAILABLE',
+  'UNAVAILABLE',
+  'IMPORT_READY',
+  'EXPORT_READY',
   'ASSIGNED',
   'MAINTENANCE',
   'OUT_OF_SERVICE',
diff --git a/apps/edr-freight-api/src/modules/payment/payment-client.service.ts b/apps/edr-freight-api/src/modules/payment/payment-client.service.ts
index 9c92a036d..bcfa643b6 100644
--- a/apps/edr-freight-api/src/modules/payment/payment-client.service.ts
+++ b/apps/edr-freight-api/src/modules/payment/payment-client.service.ts
@@ -18,7 +18,8 @@ import {
 export class PaymentClientService {
     private readonly logger = new Logger(PaymentClientService.name);
     private readonly baseUrl = (
-        process.env.PAYMENT_API_URL ?? "https://paymentcallback.triaplc.com"
+        // process.env.PAYMENT_API_URL ??
+         "https://paymentcallback.triaplc.com"
     ).replace(/\/$/, "");
     private readonly serviceToken = process.env.SERVICE_AUTH_TOKEN ?? "";
 
diff --git a/apps/edr-freight-api/src/modules/train-sets/entities/train-set-wagon.entity.ts b/apps/edr-freight-api/src/modules/train-sets/entities/train-set-wagon.entity.ts
index 455eb405d..a220218e0 100644
--- a/apps/edr-freight-api/src/modules/train-sets/entities/train-set-wagon.entity.ts
+++ b/apps/edr-freight-api/src/modules/train-sets/entities/train-set-wagon.entity.ts
@@ -29,6 +29,13 @@ export class TrainSetWagon extends BaseEntity {
   @Column({ name: 'wagon_type_id', type: 'uuid' })
   wagonTypeId!: string;
 
+  @Column({ name: 'physical_wagon_id', type: 'uuid', nullable: true })
+  physicalWagonId!: string | null;
+
+  @ManyToOne(() => Wagon, { nullable: true, onDelete: 'SET NULL' })
+  @JoinColumn({ name: 'physical_wagon_id' })
+  physicalWagon?: Wagon | null;
+
   @ManyToOne(() => WagonType, (wagonType) => wagonType.trainSetWagons)
   @JoinColumn({ name: 'wagon_type_id' })
   wagonType?: WagonType;
@@ -45,13 +52,6 @@ export class TrainSetWagon extends BaseEntity {
   @Column({ name: 'assigned_weight_tons', type: 'numeric', precision: 10, scale: 3, default: 0 })
   assignedWeightTons!: number;
 
-  @Column({ name: 'physical_wagon_id', type: 'uuid', nullable: true })
-  physicalWagonId?: string | null;
-
-  @ManyToOne(() => Wagon, { nullable: true, onDelete: 'SET NULL' })
-  @JoinColumn({ name: 'physical_wagon_id' })
-  physicalWagon?: Wagon | null;
-
   @Column({ name: 'status', type: 'varchar', length: 20, default: 'PLANNED' })
   status!: string;
 
diff --git a/apps/edr-freight-api/src/modules/vehicles/dto/create-vehicle.dto.ts b/apps/edr-freight-api/src/modules/vehicles/dto/create-vehicle.dto.ts
new file mode 100644
index 000000000..fb5c4e92b
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/vehicles/dto/create-vehicle.dto.ts
@@ -0,0 +1,32 @@
+import { IsString, IsEnum, IsNumber, IsOptional } from 'class-validator';
+import { VehicleType, FuelType, VehicleStatus } from '../entities/vehicle.entity';
+
+export class CreateVehicleDto {
+  @IsString()
+  plateNumber!: string;
+
+  @IsEnum(VehicleType)
+  vehicleType!: VehicleType;
+
+  @IsString()
+  manufacturer!: string;
+
+  @IsString()
+  model!: string;
+
+  @IsNumber()
+  year!: number;
+
+  @IsEnum(FuelType)
+  fuelType!: FuelType;
+
+  @IsNumber()
+  capacity!: number;
+
+  @IsEnum(VehicleStatus)
+  status!: VehicleStatus;
+
+  @IsOptional()
+  @IsString()
+  description?: string;
+}
diff --git a/apps/edr-freight-api/src/modules/vehicles/dto/update-vehicle.dto.ts b/apps/edr-freight-api/src/modules/vehicles/dto/update-vehicle.dto.ts
new file mode 100644
index 000000000..953917b2f
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/vehicles/dto/update-vehicle.dto.ts
@@ -0,0 +1,4 @@
+import { PartialType } from '@nestjs/mapped-types';
+import { CreateVehicleDto } from './create-vehicle.dto';
+
+export class UpdateVehicleDto extends PartialType(CreateVehicleDto) {}
diff --git a/apps/edr-freight-api/src/modules/vehicles/entities/vehicle.entity.ts b/apps/edr-freight-api/src/modules/vehicles/entities/vehicle.entity.ts
new file mode 100644
index 000000000..773e8051a
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/vehicles/entities/vehicle.entity.ts
@@ -0,0 +1,64 @@
+import { Entity, Column, Index } from 'typeorm';
+import { BaseEntity } from '@edr/api-common';
+
+export enum VehicleType {
+  TRUCK = 'TRUCK',
+  VAN = 'VAN',
+  CAR = 'CAR',
+  BUS = 'BUS',
+  TRAILER = 'TRAILER',
+  TANKER = 'TANKER',
+  FLATBED = 'FLATBED',
+}
+
+export enum FuelType {
+  PETROL = 'PETROL',
+  DIESEL = 'DIESEL',
+  ELECTRIC = 'ELECTRIC',
+  HYBRID = 'HYBRID',
+}
+
+export enum VehicleStatus {
+  ACTIVE = 'ACTIVE',
+  MAINTENANCE = 'MAINTENANCE',
+  RETIRED = 'RETIRED',
+  OUT_OF_SERVICE = 'OUT_OF_SERVICE',
+}
+
+@Entity({ name: 'vehicles', schema: 'freight' })
+@Index(['plateNumber'])
+@Index(['registrationNumber'])
+@Index(['status'])
+@Index(['vehicleType'])
+@Index(['manufacturer'])
+export class Vehicle extends BaseEntity {
+  @Column({ name: 'plate_number', unique: true })
+  plateNumber!: string;
+
+  @Column({ name: 'registration_number', unique: true })
+  registrationNumber!: string;
+
+  @Column({ name: 'vehicle_type', type: 'varchar' })
+  vehicleType!: VehicleType;
+
+  @Column()
+  manufacturer!: string;
+
+  @Column()
+  model!: string;
+
+  @Column()
+  year!: number;
+
+  @Column({ name: 'fuel_type', type: 'varchar' })
+  fuelType!: FuelType;
+
+  @Column()
+  capacity!: number;
+
+  @Column({ name: 'status', type: 'varchar', default: VehicleStatus.ACTIVE })
+  status!: VehicleStatus;
+
+  @Column({ type: 'text', nullable: true })
+  description!: string | null;
+}
diff --git a/apps/edr-freight-api/src/modules/vehicles/vehicles.controller.ts b/apps/edr-freight-api/src/modules/vehicles/vehicles.controller.ts
new file mode 100644
index 000000000..24ff2d022
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/vehicles/vehicles.controller.ts
@@ -0,0 +1,74 @@
+import {
+  Controller,
+  Get,
+  Post,
+  Patch,
+  Delete,
+  Param,
+  Body,
+  Query,
+  ParseUUIDPipe,
+} from '@nestjs/common';
+import { ApiBearerAuth, ApiOperation, ApiTags } from '@nestjs/swagger';
+import { FleetManage, FleetView } from '../../common/booking-guards';
+import { VehiclesService } from './vehicles.service';
+import { CreateVehicleDto } from './dto/create-vehicle.dto';
+import { UpdateVehicleDto } from './dto/update-vehicle.dto';
+
+@ApiTags('vehicles')
+@ApiBearerAuth()
+@Controller('vehicles')
+@FleetView()
+export class VehiclesController {
+  constructor(private readonly vehiclesService: VehiclesService) {}
+
+  @Post()
+  @FleetManage()
+  @ApiOperation({ summary: 'Create a new vehicle' })
+  create(@Body() createVehicleDto: CreateVehicleDto) {
+    return this.vehiclesService.create(createVehicleDto);
+  }
+
+  @Get()
+  @ApiOperation({ summary: 'Get all vehicles with filters' })
+  findAll(
+    @Query('search') search?: string,
+    @Query('status') status?: string,
+    @Query('page') page?: string,
+    @Query('limit') limit?: string,
+    @Query('sortBy') sortBy?: string,
+    @Query('sortOrder') sortOrder?: 'ASC' | 'DESC',
+  ) {
+    return this.vehiclesService.findAll({
+      search,
+      status: status as any,
+      page: page ? parseInt(page) : undefined,
+      limit: limit ? parseInt(limit) : undefined,
+      sortBy,
+      sortOrder,
+    });
+  }
+
+  @Get(':id')
+  @ApiOperation({ summary: 'Get vehicle by id' })
+  findOne(@Param('id', ParseUUIDPipe) id: string) {
+    return this.vehiclesService.findById(id);
+  }
+
+  @Patch(':id')
+  @FleetManage()
+  @ApiOperation({ summary: 'Update a vehicle' })
+  update(
+    @Param('id', ParseUUIDPipe) id: string,
+    @Body() updateVehicleDto: UpdateVehicleDto,
+  ) {
+    return this.vehiclesService.update(id, updateVehicleDto);
+  }
+
+  @Delete(':id')
+  @FleetManage()
+  @ApiOperation({ summary: 'Delete a vehicle' })
+  remove(@Param('id', ParseUUIDPipe) id: string) {
+    return this.vehiclesService.remove(id);
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/vehicles/vehicles.module.ts b/apps/edr-freight-api/src/modules/vehicles/vehicles.module.ts
new file mode 100644
index 000000000..07aa4bd2f
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/vehicles/vehicles.module.ts
@@ -0,0 +1,13 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { Vehicle } from './entities/vehicle.entity';
+import { VehiclesService } from './vehicles.service';
+import { VehiclesController } from './vehicles.controller';
+
+@Module({
+  imports: [TypeOrmModule.forFeature([Vehicle])],
+  providers: [VehiclesService],
+  controllers: [VehiclesController],
+  exports: [VehiclesService],
+})
+export class VehiclesModule {}
diff --git a/apps/edr-freight-api/src/modules/vehicles/vehicles.repository.ts b/apps/edr-freight-api/src/modules/vehicles/vehicles.repository.ts
new file mode 100644
index 000000000..9c5bad1e9
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/vehicles/vehicles.repository.ts
@@ -0,0 +1,15 @@
+import { BaseRepository } from '@edr/api-common';
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+import { Vehicle } from './entities/vehicle.entity';
+
+@Injectable()
+export class VehiclesRepository extends BaseRepository<Vehicle> {
+  constructor(
+    @InjectRepository(Vehicle)
+    repository: Repository<Vehicle>,
+  ) {
+    super(repository);
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/vehicles/vehicles.service.ts b/apps/edr-freight-api/src/modules/vehicles/vehicles.service.ts
new file mode 100644
index 000000000..12970a8a8
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/vehicles/vehicles.service.ts
@@ -0,0 +1,109 @@
+import { Injectable, NotFoundException, ConflictException } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+import { CreateVehicleDto } from './dto/create-vehicle.dto';
+import { UpdateVehicleDto } from './dto/update-vehicle.dto';
+import { Vehicle, VehicleStatus } from './entities/vehicle.entity';
+
+@Injectable()
+export class VehiclesService {
+  constructor(
+    @InjectRepository(Vehicle)
+    private readonly vehicleRepo: Repository<Vehicle>,
+  ) {}
+
+  async create(dto: CreateVehicleDto): Promise<Vehicle> {
+    const existing = await this.vehicleRepo.findOne({
+      where: { plateNumber: dto.plateNumber },
+    });
+
+    if (existing) {
+      throw new ConflictException(
+        `Vehicle with plate number ${dto.plateNumber} already exists`,
+      );
+    }
+
+    const registrationNumber = `REG-${dto.vehicleType}-${Date.now()}`;
+    const vehicle = this.vehicleRepo.create({
+      ...dto,
+      registrationNumber,
+    });
+
+    return this.vehicleRepo.save(vehicle);
+  }
+
+  async findAll(query: {
+    search?: string;
+    status?: VehicleStatus | string;
+    page?: number;
+    limit?: number;
+    sortBy?: string;
+    sortOrder?: 'ASC' | 'DESC';
+  } = {}): Promise<{ data: Vehicle[]; total: number; page: number; limit: number }> {
+    const page = query.page || 1;
+    const limit = query.limit || 10;
+    const skip = (page - 1) * limit;
+
+    const where: any = {};
+    if (query.status) where.status = query.status;
+
+    let qb = this.vehicleRepo.createQueryBuilder('v');
+
+    if (query.search) {
+      qb = qb.where(
+        'v.plateNumber ILIKE :search OR v.manufacturer ILIKE :search',
+        { search: `%${query.search}%` },
+      );
+    }
+
+    if (query.status) {
+      qb = qb.andWhere('v.status = :status', { status: query.status });
+    }
+
+    const sortBy = ['plateNumber', 'status', 'year', 'createdAt'].includes(
+      query.sortBy ?? '',
+    )
+      ? query.sortBy
+      : 'createdAt';
+    const sortOrder = (query.sortOrder ?? 'DESC').toUpperCase();
+
+    const [data, total] = await qb
+      .orderBy(`v.${sortBy}`, sortOrder as 'ASC' | 'DESC')
+      .skip(skip)
+      .take(limit)
+      .getManyAndCount();
+
+    return { data, total, page, limit };
+  }
+
+  async findById(id: string): Promise<Vehicle> {
+    const vehicle = await this.vehicleRepo.findOne({ where: { id } });
+    if (!vehicle) {
+      throw new NotFoundException(`Vehicle ${id} not found`);
+    }
+    return vehicle;
+  }
+
+  async update(id: string, dto: UpdateVehicleDto): Promise<Vehicle> {
+    const vehicle = await this.findById(id);
+
+    if (dto.plateNumber && dto.plateNumber !== vehicle.plateNumber) {
+      const existing = await this.vehicleRepo.findOne({
+        where: { plateNumber: dto.plateNumber },
+      });
+      if (existing) {
+        throw new ConflictException(
+          `Vehicle with plate number ${dto.plateNumber} already exists`,
+        );
+      }
+    }
+
+    Object.assign(vehicle, dto);
+    return this.vehicleRepo.save(vehicle);
+  }
+
+  async remove(id: string): Promise<void> {
+    await this.findById(id);
+    await this.vehicleRepo.softDelete(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 914de4cbd..bffe28860 100644
--- a/apps/edr-freight-api/src/modules/wagons/wagons.module.ts
+++ b/apps/edr-freight-api/src/modules/wagons/wagons.module.ts
@@ -2,13 +2,14 @@ import { Module } from '@nestjs/common';
 import { TypeOrmModule } from '@nestjs/typeorm';
 import { Wagon } from './entities/wagon.entity';
 import { Train } from '../trains/entities/train.entity';
+import { Yard } from '../rule-engine/entities/yard.entity';
 import { WagonsController, TrainWagonsReorderController } from './wagons.controller';
 import { WagonsService } from './wagons.service';
 
 @Module({
-  imports: [TypeOrmModule.forFeature([Wagon, Train])],
+  imports: [TypeOrmModule.forFeature([Wagon, Train, Yard])],
   controllers: [WagonsController, TrainWagonsReorderController],
   providers: [WagonsService],
   exports: [WagonsService],
 })
-export class WagonsModule {}
\ No newline at end of file
+export class WagonsModule {}
diff --git a/apps/edr-freight-api/src/modules/warehouses/dto/allocation-rule.dto.ts b/apps/edr-freight-api/src/modules/warehouses/dto/allocation-rule.dto.ts
new file mode 100644
index 000000000..43cd6f61a
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/warehouses/dto/allocation-rule.dto.ts
@@ -0,0 +1,96 @@
+import { ApiProperty, ApiPropertyOptional, PartialType } from '@nestjs/swagger';
+import { IsBoolean, IsInt, IsOptional, IsString } from 'class-validator';
+
+export class CreateAllocationRuleDto {
+  @ApiProperty()
+  @IsString()
+  name!: string;
+
+  @ApiPropertyOptional({ default: 100 })
+  @IsOptional()
+  @IsInt()
+  priority?: number;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsString()
+  freightType?: string;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsString()
+  tradeDirection?: string;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsString()
+  cargoTypeCode?: string;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsString()
+  containerStatus?: string;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsBoolean()
+  requiresInspection?: boolean;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsString()
+  targetFacilityCode?: string;
+
+  @ApiProperty()
+  @IsString()
+  targetYardCode!: string;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsString()
+  targetWarehouseCode?: string;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsString()
+  targetZoneCode?: string;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsString()
+  storageType?: string;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsBoolean()
+  isActive?: boolean;
+}
+
+export class UpdateAllocationRuleDto extends PartialType(CreateAllocationRuleDto) {}
+
+export class AllocationPreviewDto {
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsString()
+  freightType?: string;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsString()
+  tradeDirection?: string;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsString()
+  cargoTypeCode?: string;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsString()
+  containerStatus?: string;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsBoolean()
+  requiresInspection?: boolean;
+}
diff --git a/apps/edr-freight-api/src/modules/warehouses/dto/create-inspection-report.dto.ts b/apps/edr-freight-api/src/modules/warehouses/dto/create-inspection-report.dto.ts
new file mode 100644
index 000000000..cc1350796
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/warehouses/dto/create-inspection-report.dto.ts
@@ -0,0 +1,64 @@
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+import { IsBoolean, IsEnum, IsNumber, IsOptional, IsString, IsUUID } from 'class-validator';
+
+import {
+  INSPECTION_REPORT_TYPES,
+  INSPECTION_STATUSES,
+  InspectionReportType,
+  InspectionStatus,
+} from '../entities/warehouse-inspection-report.entity';
+
+export class CreateInspectionReportDto {
+  @ApiProperty({ enum: INSPECTION_REPORT_TYPES })
+  @IsEnum(INSPECTION_REPORT_TYPES)
+  reportType!: InspectionReportType;
+
+  @ApiProperty({ enum: INSPECTION_STATUSES })
+  @IsEnum(INSPECTION_STATUSES)
+  inspectionStatus!: InspectionStatus;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsBoolean()
+  hasDamage?: boolean;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsString()
+  damageDescription?: string;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsBoolean()
+  hasWeightLoss?: boolean;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsNumber()
+  expectedWeight?: number;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsNumber()
+  actualWeight?: number;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsBoolean()
+  hasMissingItems?: boolean;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsString()
+  missingItemsDescription?: string;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsString()
+  remarks?: string;
+
+  @ApiPropertyOptional({ format: 'uuid' })
+  @IsOptional()
+  @IsUUID()
+  inspectedById?: string;
+}
diff --git a/apps/edr-freight-api/src/modules/warehouses/dto/create-warehouse-yard.dto.ts b/apps/edr-freight-api/src/modules/warehouses/dto/create-warehouse-yard.dto.ts
new file mode 100644
index 000000000..ccdda90d8
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/warehouses/dto/create-warehouse-yard.dto.ts
@@ -0,0 +1,49 @@
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+import { IsEnum, IsNumber, IsOptional, IsString, IsUUID, MaxLength, Min } from 'class-validator';
+
+import { WAREHOUSE_YARD_TYPES, WarehouseYardType } from '../entities/warehouse-yard.entity';
+
+export class CreateWarehouseYardDto {
+  @ApiPropertyOptional({ format: 'uuid', description: 'Optional — taken from the route param when omitted' })
+  @IsOptional()
+  @IsUUID()
+  warehouseId?: string;
+
+  @ApiProperty()
+  @IsString()
+  @MaxLength(160)
+  name!: string;
+
+  @ApiProperty()
+  @IsString()
+  @MaxLength(40)
+  code!: string;
+
+  @ApiProperty({ enum: WAREHOUSE_YARD_TYPES })
+  @IsEnum(WAREHOUSE_YARD_TYPES)
+  type!: WarehouseYardType;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsNumber()
+  @Min(0)
+  capacityWeight?: number;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsNumber()
+  @Min(0)
+  capacityContainers?: number;
+
+  @ApiPropertyOptional({ description: 'Max weight capacity (kg). Defaults to capacityWeight.' })
+  @IsOptional()
+  @IsNumber()
+  @Min(0)
+  maxWeight?: number;
+
+  @ApiPropertyOptional({ description: 'Max volume capacity (m³).' })
+  @IsOptional()
+  @IsNumber()
+  @Min(0)
+  maxVolume?: number;
+}
diff --git a/apps/edr-freight-api/src/modules/warehouses/dto/create-warehouse-zone.dto.ts b/apps/edr-freight-api/src/modules/warehouses/dto/create-warehouse-zone.dto.ts
new file mode 100644
index 000000000..fbb057fd5
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/warehouses/dto/create-warehouse-zone.dto.ts
@@ -0,0 +1,49 @@
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+import { IsEnum, IsNumber, IsOptional, IsString, IsUUID, MaxLength, Min } from 'class-validator';
+
+import { WAREHOUSE_ZONE_TYPES, WarehouseZoneType } from '../entities/warehouse-zone.entity';
+
+export class CreateWarehouseZoneDto {
+  @ApiPropertyOptional({ format: 'uuid', description: 'Optional — taken from the route param when omitted' })
+  @IsOptional()
+  @IsUUID()
+  yardId?: string;
+
+  @ApiProperty()
+  @IsString()
+  @MaxLength(160)
+  name!: string;
+
+  @ApiProperty()
+  @IsString()
+  @MaxLength(40)
+  code!: string;
+
+  @ApiProperty({ enum: WAREHOUSE_ZONE_TYPES })
+  @IsEnum(WAREHOUSE_ZONE_TYPES)
+  type!: WarehouseZoneType;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsNumber()
+  @Min(0)
+  capacityWeight?: number;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsNumber()
+  @Min(0)
+  capacityContainers?: number;
+
+  @ApiPropertyOptional({ description: 'Max weight capacity (kg). Defaults to capacityWeight.' })
+  @IsOptional()
+  @IsNumber()
+  @Min(0)
+  maxWeight?: number;
+
+  @ApiPropertyOptional({ description: 'Max volume capacity (m³).' })
+  @IsOptional()
+  @IsNumber()
+  @Min(0)
+  maxVolume?: number;
+}
diff --git a/apps/edr-freight-api/src/modules/warehouses/dto/create-warehouse.dto.ts b/apps/edr-freight-api/src/modules/warehouses/dto/create-warehouse.dto.ts
new file mode 100644
index 000000000..788c798bf
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/warehouses/dto/create-warehouse.dto.ts
@@ -0,0 +1,60 @@
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+import { IsEnum, IsNumber, IsOptional, IsString, IsUUID, MaxLength, Min } from 'class-validator';
+
+import { WAREHOUSE_TYPES, WarehouseType } from '../entities/warehouse.entity';
+
+export class CreateWarehouseDto {
+  @ApiProperty()
+  @IsString()
+  @MaxLength(160)
+  name!: string;
+
+  @ApiProperty()
+  @IsString()
+  @MaxLength(40)
+  code!: string;
+
+  @ApiProperty({ enum: WAREHOUSE_TYPES })
+  @IsEnum(WAREHOUSE_TYPES)
+  type!: WarehouseType;
+
+  @ApiPropertyOptional({ format: 'uuid' })
+  @IsOptional()
+  @IsUUID()
+  stationId?: string;
+
+  @ApiPropertyOptional({ format: 'uuid', description: 'Parent facility / port this warehouse belongs to.' })
+  @IsOptional()
+  @IsUUID()
+  facilityId?: string;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsString()
+  @MaxLength(200)
+  locationName?: string;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsNumber()
+  @Min(0)
+  capacityWeight?: number;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsNumber()
+  @Min(0)
+  capacityContainers?: number;
+
+  @ApiPropertyOptional({ description: 'Max weight capacity (kg). Defaults to capacityWeight.' })
+  @IsOptional()
+  @IsNumber()
+  @Min(0)
+  maxWeight?: number;
+
+  @ApiPropertyOptional({ description: 'Max volume capacity (m³).' })
+  @IsOptional()
+  @IsNumber()
+  @Min(0)
+  maxVolume?: number;
+}
diff --git a/apps/edr-freight-api/src/modules/warehouses/dto/fee-rule.dto.ts b/apps/edr-freight-api/src/modules/warehouses/dto/fee-rule.dto.ts
new file mode 100644
index 000000000..873f97a6b
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/warehouses/dto/fee-rule.dto.ts
@@ -0,0 +1,76 @@
+import { ApiProperty, ApiPropertyOptional, PartialType } from '@nestjs/swagger';
+import { IsEnum, IsInt, IsNumber, IsOptional, IsString, IsUUID, Min } from 'class-validator';
+
+import { FEE_RULE_TYPES, FeeRuleType } from '../entities/warehouse-fee-rule.entity';
+
+export class CreateFeeRuleDto {
+  @ApiProperty()
+  @IsString()
+  name!: string;
+
+  @ApiProperty({ enum: FEE_RULE_TYPES })
+  @IsEnum(FEE_RULE_TYPES)
+  ruleType!: FeeRuleType;
+
+  @ApiPropertyOptional({ default: 100 })
+  @IsOptional()
+  @IsInt()
+  priority?: number;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsString()
+  freightType?: string;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsString()
+  tradeDirection?: string;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsString()
+  cargoTypeCode?: string;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsString()
+  containerType?: string;
+
+  @ApiPropertyOptional({ format: 'uuid' })
+  @IsOptional()
+  @IsUUID()
+  facilityId?: string;
+
+  @ApiPropertyOptional({ format: 'uuid' })
+  @IsOptional()
+  @IsUUID()
+  warehouseId?: string;
+
+  @ApiPropertyOptional({ format: 'uuid' })
+  @IsOptional()
+  @IsUUID()
+  yardId?: string;
+
+  @ApiPropertyOptional({ format: 'uuid' })
+  @IsOptional()
+  @IsUUID()
+  zoneId?: string;
+
+  @ApiProperty({ description: 'Grace period in days before charging starts.' })
+  @IsInt()
+  @Min(0)
+  freeDays!: number;
+
+  @ApiProperty()
+  @IsNumber()
+  @Min(0)
+  ratePerDay!: number;
+
+  @ApiPropertyOptional({ default: 'USD' })
+  @IsOptional()
+  @IsString()
+  currency?: string;
+}
+
+export class UpdateFeeRuleDto extends PartialType(CreateFeeRuleDto) {}
diff --git a/apps/edr-freight-api/src/modules/warehouses/dto/filter-inventory.dto.ts b/apps/edr-freight-api/src/modules/warehouses/dto/filter-inventory.dto.ts
new file mode 100644
index 000000000..c867eec3c
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/warehouses/dto/filter-inventory.dto.ts
@@ -0,0 +1,54 @@
+import { ApiPropertyOptional } from '@nestjs/swagger';
+import { IsEnum, IsOptional, IsString, IsUUID } from 'class-validator';
+
+import {
+  WAREHOUSE_INVENTORY_STATUSES,
+  WarehouseInventoryStatus,
+} from '../entities/warehouse-inventory.entity';
+
+export class FilterWarehouseInventoryDto {
+  @ApiPropertyOptional({ format: 'uuid' })
+  @IsOptional()
+  @IsUUID()
+  warehouseId?: string;
+
+  @ApiPropertyOptional({ format: 'uuid' })
+  @IsOptional()
+  @IsUUID()
+  yardId?: string;
+
+  @ApiPropertyOptional({ format: 'uuid' })
+  @IsOptional()
+  @IsUUID()
+  zoneId?: string;
+
+  @ApiPropertyOptional({ format: 'uuid' })
+  @IsOptional()
+  @IsUUID()
+  bookingId?: string;
+
+  @ApiPropertyOptional({ format: 'uuid' })
+  @IsOptional()
+  @IsUUID()
+  cargoId?: string;
+
+  @ApiPropertyOptional({ format: 'uuid' })
+  @IsOptional()
+  @IsUUID()
+  containerId?: string;
+
+  @ApiPropertyOptional({ format: 'uuid' })
+  @IsOptional()
+  @IsUUID()
+  goodsId?: string;
+
+  @ApiPropertyOptional({ enum: WAREHOUSE_INVENTORY_STATUSES })
+  @IsOptional()
+  @IsEnum(WAREHOUSE_INVENTORY_STATUSES)
+  status?: WarehouseInventoryStatus;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsString()
+  search?: string;
+}
diff --git a/apps/edr-freight-api/src/modules/warehouses/dto/filter-warehouse.dto.ts b/apps/edr-freight-api/src/modules/warehouses/dto/filter-warehouse.dto.ts
new file mode 100644
index 000000000..f07088ccc
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/warehouses/dto/filter-warehouse.dto.ts
@@ -0,0 +1,26 @@
+import { ApiPropertyOptional } from '@nestjs/swagger';
+import { IsEnum, IsOptional, IsString, IsUUID } from 'class-validator';
+
+import { WAREHOUSE_STATUSES, WAREHOUSE_TYPES, WarehouseStatus, WarehouseType } from '../entities/warehouse.entity';
+
+export class FilterWarehouseDto {
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsString()
+  search?: string;
+
+  @ApiPropertyOptional({ enum: WAREHOUSE_TYPES })
+  @IsOptional()
+  @IsEnum(WAREHOUSE_TYPES)
+  type?: WarehouseType;
+
+  @ApiPropertyOptional({ format: 'uuid' })
+  @IsOptional()
+  @IsUUID()
+  stationId?: string;
+
+  @ApiPropertyOptional({ enum: WAREHOUSE_STATUSES })
+  @IsOptional()
+  @IsEnum(WAREHOUSE_STATUSES)
+  status?: WarehouseStatus;
+}
diff --git a/apps/edr-freight-api/src/modules/warehouses/dto/inquiry-inventory.dto.ts b/apps/edr-freight-api/src/modules/warehouses/dto/inquiry-inventory.dto.ts
new file mode 100644
index 000000000..cba259d00
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/warehouses/dto/inquiry-inventory.dto.ts
@@ -0,0 +1,49 @@
+import { ApiPropertyOptional } from '@nestjs/swagger';
+import { IsEnum, IsOptional, IsString, IsUUID } from 'class-validator';
+
+import {
+  WAREHOUSE_INVENTORY_STATUSES,
+  WarehouseInventoryStatus,
+} from '../entities/warehouse-inventory.entity';
+
+export class InquiryWarehouseInventoryDto {
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsString()
+  bookingNumber?: string;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsString()
+  containerNumber?: string;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsString()
+  cargoType?: string;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsString()
+  goodsName?: string;
+
+  @ApiPropertyOptional({ format: 'uuid' })
+  @IsOptional()
+  @IsUUID()
+  warehouseId?: string;
+
+  @ApiPropertyOptional({ format: 'uuid' })
+  @IsOptional()
+  @IsUUID()
+  yardId?: string;
+
+  @ApiPropertyOptional({ format: 'uuid' })
+  @IsOptional()
+  @IsUUID()
+  zoneId?: string;
+
+  @ApiPropertyOptional({ enum: WAREHOUSE_INVENTORY_STATUSES })
+  @IsOptional()
+  @IsEnum(WAREHOUSE_INVENTORY_STATUSES)
+  status?: WarehouseInventoryStatus;
+}
diff --git a/apps/edr-freight-api/src/modules/warehouses/dto/invoice.dto.ts b/apps/edr-freight-api/src/modules/warehouses/dto/invoice.dto.ts
new file mode 100644
index 000000000..9d25c974a
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/warehouses/dto/invoice.dto.ts
@@ -0,0 +1,31 @@
+import { ApiPropertyOptional } from '@nestjs/swagger';
+import { IsBoolean, IsNumber, IsOptional, IsString, Min } from 'class-validator';
+
+export class GenerateInvoiceDto {
+  @ApiPropertyOptional({ description: 'Create even when the calculated amount is zero.' })
+  @IsOptional()
+  @IsBoolean()
+  confirmZero?: boolean;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsString()
+  performedBy?: string;
+}
+
+export class PayInvoiceBodyDto {
+  @ApiPropertyOptional()
+  @IsNumber()
+  @Min(0.01)
+  amount!: number;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsString()
+  method?: string;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsString()
+  reference?: string;
+}
diff --git a/apps/edr-freight-api/src/modules/warehouses/dto/load-inventory.dto.ts b/apps/edr-freight-api/src/modules/warehouses/dto/load-inventory.dto.ts
new file mode 100644
index 000000000..063bb7d1d
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/warehouses/dto/load-inventory.dto.ts
@@ -0,0 +1,25 @@
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+import { IsNumber, IsOptional, IsString, IsUUID, MaxLength, Min } from 'class-validator';
+
+export class LoadInventoryDto {
+  @ApiProperty({ format: 'uuid', description: 'Physical wagon the item is loaded onto' })
+  @IsUUID()
+  wagonId!: string;
+
+  @ApiPropertyOptional({ description: 'Weight loaded onto the wagon (kg)' })
+  @IsOptional()
+  @IsNumber()
+  @Min(0)
+  loadedWeight?: number;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsString()
+  @MaxLength(120)
+  loadedBy?: string;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsString()
+  notes?: string;
+}
diff --git a/apps/edr-freight-api/src/modules/warehouses/dto/move-inventory.dto.ts b/apps/edr-freight-api/src/modules/warehouses/dto/move-inventory.dto.ts
new file mode 100644
index 000000000..1aae7896f
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/warehouses/dto/move-inventory.dto.ts
@@ -0,0 +1,26 @@
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+import { IsOptional, IsString, IsUUID } from 'class-validator';
+
+export class MoveInventoryDto {
+  @ApiProperty({ format: 'uuid' })
+  @IsUUID()
+  warehouseId!: string;
+
+  @ApiProperty({ format: 'uuid' })
+  @IsUUID()
+  yardId!: string;
+
+  @ApiProperty({ format: 'uuid' })
+  @IsUUID()
+  zoneId!: string;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsString()
+  remarks?: string;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsString()
+  movedBy?: string;
+}
diff --git a/apps/edr-freight-api/src/modules/warehouses/dto/receive-inventory.dto.ts b/apps/edr-freight-api/src/modules/warehouses/dto/receive-inventory.dto.ts
new file mode 100644
index 000000000..46fecb044
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/warehouses/dto/receive-inventory.dto.ts
@@ -0,0 +1,62 @@
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+import { IsNumber, IsOptional, IsString, IsUUID, Min } from 'class-validator';
+
+export class ReceiveWarehouseInventoryDto {
+  @ApiProperty({ format: 'uuid' })
+  @IsUUID()
+  warehouseId!: string;
+
+  @ApiProperty({ format: 'uuid' })
+  @IsUUID()
+  yardId!: string;
+
+  @ApiProperty({ format: 'uuid' })
+  @IsUUID()
+  zoneId!: string;
+
+  @ApiPropertyOptional({ format: 'uuid' })
+  @IsOptional()
+  @IsUUID()
+  bookingId?: string;
+
+  @ApiPropertyOptional({ format: 'uuid' })
+  @IsOptional()
+  @IsUUID()
+  cargoId?: string;
+
+  @ApiPropertyOptional({ format: 'uuid' })
+  @IsOptional()
+  @IsUUID()
+  containerId?: string;
+
+  @ApiPropertyOptional({ format: 'uuid' })
+  @IsOptional()
+  @IsUUID()
+  goodsId?: string;
+
+  @ApiProperty()
+  @IsNumber()
+  @Min(0)
+  quantity!: number;
+
+  @ApiProperty()
+  @IsNumber()
+  @Min(0)
+  weight!: number;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsNumber()
+  @Min(0)
+  volume?: number;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsString()
+  notes?: string;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsString()
+  performedBy?: string;
+}
diff --git a/apps/edr-freight-api/src/modules/warehouses/dto/reserve-inventory.dto.ts b/apps/edr-freight-api/src/modules/warehouses/dto/reserve-inventory.dto.ts
new file mode 100644
index 000000000..f1cb05d9e
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/warehouses/dto/reserve-inventory.dto.ts
@@ -0,0 +1,17 @@
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+import { IsOptional, IsString, IsUUID } from 'class-validator';
+
+export class ReserveInventoryDto {
+  @ApiProperty({ format: 'uuid' })
+  @IsUUID()
+  bookingId!: string;
+
+  @ApiProperty({ format: 'uuid' })
+  @IsUUID()
+  inventoryId!: string;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsString()
+  performedBy?: string;
+}
diff --git a/apps/edr-freight-api/src/modules/warehouses/dto/unload-booking.dto.ts b/apps/edr-freight-api/src/modules/warehouses/dto/unload-booking.dto.ts
new file mode 100644
index 000000000..3138285e2
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/warehouses/dto/unload-booking.dto.ts
@@ -0,0 +1,34 @@
+import { ApiPropertyOptional } from '@nestjs/swagger';
+import { IsDateString, IsOptional, IsString, IsUUID } from 'class-validator';
+
+export class UnloadBookingDto {
+  @ApiPropertyOptional({ format: 'uuid' })
+  @IsOptional()
+  @IsUUID()
+  facilityId?: string;
+
+  @ApiPropertyOptional({ format: 'uuid' })
+  @IsOptional()
+  @IsUUID()
+  warehouseId?: string;
+
+  @ApiPropertyOptional({ format: 'uuid' })
+  @IsOptional()
+  @IsUUID()
+  yardId?: string;
+
+  @ApiPropertyOptional({ format: 'uuid' })
+  @IsOptional()
+  @IsUUID()
+  zoneId?: string;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsDateString()
+  unloadedAt?: string;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsString()
+  notes?: string;
+}
diff --git a/apps/edr-freight-api/src/modules/warehouses/dto/update-inspection-report.dto.ts b/apps/edr-freight-api/src/modules/warehouses/dto/update-inspection-report.dto.ts
new file mode 100644
index 000000000..372008d3b
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/warehouses/dto/update-inspection-report.dto.ts
@@ -0,0 +1,5 @@
+import { PartialType } from '@nestjs/swagger';
+
+import { CreateInspectionReportDto } from './create-inspection-report.dto';
+
+export class UpdateInspectionReportDto extends PartialType(CreateInspectionReportDto) {}
diff --git a/apps/edr-freight-api/src/modules/warehouses/dto/update-warehouse-yard.dto.ts b/apps/edr-freight-api/src/modules/warehouses/dto/update-warehouse-yard.dto.ts
new file mode 100644
index 000000000..717923534
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/warehouses/dto/update-warehouse-yard.dto.ts
@@ -0,0 +1,12 @@
+import { ApiPropertyOptional, PartialType } from '@nestjs/swagger';
+import { IsEnum, IsOptional } from 'class-validator';
+
+import { WAREHOUSE_YARD_STATUSES, WarehouseYardStatus } from '../entities/warehouse-yard.entity';
+import { CreateWarehouseYardDto } from './create-warehouse-yard.dto';
+
+export class UpdateWarehouseYardDto extends PartialType(CreateWarehouseYardDto) {
+  @ApiPropertyOptional({ enum: WAREHOUSE_YARD_STATUSES })
+  @IsOptional()
+  @IsEnum(WAREHOUSE_YARD_STATUSES)
+  status?: WarehouseYardStatus;
+}
diff --git a/apps/edr-freight-api/src/modules/warehouses/dto/update-warehouse-zone.dto.ts b/apps/edr-freight-api/src/modules/warehouses/dto/update-warehouse-zone.dto.ts
new file mode 100644
index 000000000..01cd8301d
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/warehouses/dto/update-warehouse-zone.dto.ts
@@ -0,0 +1,12 @@
+import { ApiPropertyOptional, PartialType } from '@nestjs/swagger';
+import { IsEnum, IsOptional } from 'class-validator';
+
+import { WAREHOUSE_ZONE_STATUSES, WarehouseZoneStatus } from '../entities/warehouse-zone.entity';
+import { CreateWarehouseZoneDto } from './create-warehouse-zone.dto';
+
+export class UpdateWarehouseZoneDto extends PartialType(CreateWarehouseZoneDto) {
+  @ApiPropertyOptional({ enum: WAREHOUSE_ZONE_STATUSES })
+  @IsOptional()
+  @IsEnum(WAREHOUSE_ZONE_STATUSES)
+  status?: WarehouseZoneStatus;
+}
diff --git a/apps/edr-freight-api/src/modules/warehouses/dto/update-warehouse.dto.ts b/apps/edr-freight-api/src/modules/warehouses/dto/update-warehouse.dto.ts
new file mode 100644
index 000000000..e6038fca2
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/warehouses/dto/update-warehouse.dto.ts
@@ -0,0 +1,12 @@
+import { ApiPropertyOptional, PartialType } from '@nestjs/swagger';
+import { IsEnum, IsOptional } from 'class-validator';
+
+import { WAREHOUSE_STATUSES, WarehouseStatus } from '../entities/warehouse.entity';
+import { CreateWarehouseDto } from './create-warehouse.dto';
+
+export class UpdateWarehouseDto extends PartialType(CreateWarehouseDto) {
+  @ApiPropertyOptional({ enum: WAREHOUSE_STATUSES })
+  @IsOptional()
+  @IsEnum(WAREHOUSE_STATUSES)
+  status?: WarehouseStatus;
+}
diff --git a/apps/edr-freight-api/src/modules/warehouses/entities/warehouse-activity-log.entity.ts b/apps/edr-freight-api/src/modules/warehouses/entities/warehouse-activity-log.entity.ts
new file mode 100644
index 000000000..4521bb808
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/warehouses/entities/warehouse-activity-log.entity.ts
@@ -0,0 +1,34 @@
+import { BaseEntity } from '@edr/api-common';
+import { Column, Entity, Index } from 'typeorm';
+
+export const WAREHOUSE_ACTIVITY_TYPES = [
+  'INVENTORY_RECEIVED',
+  'INVENTORY_STORED',
+  'INVENTORY_MOVED',
+  'INVENTORY_RESERVED',
+  'READY_FOR_LOADING',
+  'INVENTORY_LOADED',
+  'INVENTORY_DISPATCHED',
+] as const;
+export type WarehouseActivityType = (typeof WAREHOUSE_ACTIVITY_TYPES)[number];
+
+@Entity({ schema: 'freight', name: 'warehouse_activity_log' })
+@Index(['inventoryId'])
+@Index(['warehouseId'])
+@Index(['activityType'])
+export class WarehouseActivityLog extends BaseEntity {
+  @Column({ name: 'inventory_id', type: 'uuid', nullable: true })
+  inventoryId?: string | null;
+
+  @Column({ name: 'warehouse_id', type: 'uuid', nullable: true })
+  warehouseId?: string | null;
+
+  @Column({ name: 'activity_type', type: 'varchar', length: 40 })
+  activityType!: WarehouseActivityType;
+
+  @Column({ name: 'description', type: 'text', nullable: true })
+  description?: string | null;
+
+  @Column({ name: 'performed_by', type: 'varchar', length: 120, nullable: true })
+  performedBy?: string | null;
+}
diff --git a/apps/edr-freight-api/src/modules/warehouses/entities/warehouse-allocation-rule.entity.ts b/apps/edr-freight-api/src/modules/warehouses/entities/warehouse-allocation-rule.entity.ts
new file mode 100644
index 000000000..a597ecf0e
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/warehouses/entities/warehouse-allocation-rule.entity.ts
@@ -0,0 +1,54 @@
+import { BaseEntity } from '@edr/api-common';
+import { Column, Entity, Index } from 'typeorm';
+
+/**
+ * Batch 5 — deterministic warehouse/yard allocation.
+ * A booking's (freightType, tradeDirection, cargoType, containerStatus, inspection)
+ * is matched against active rules in ascending `priority`; the first match wins and
+ * resolves the target Yard (and optional Warehouse/Zone) by code.
+ */
+@Entity({ schema: 'freight', name: 'warehouse_allocation_rules' })
+@Index(['priority'])
+@Index(['isActive'])
+export class WarehouseAllocationRule extends BaseEntity {
+  @Column({ name: 'name', type: 'varchar', length: 160 })
+  name!: string;
+
+  @Column({ name: 'priority', type: 'int', default: 100 })
+  priority!: number;
+
+  // ── Match criteria (null = wildcard) ──────────────────────────────────────
+  @Column({ name: 'freight_type', type: 'varchar', length: 16, nullable: true })
+  freightType?: string | null; // CONTAINER | BULK
+
+  @Column({ name: 'trade_direction', type: 'varchar', length: 16, nullable: true })
+  tradeDirection?: string | null; // IMPORT | EXPORT | DOMESTIC | BOTH
+
+  @Column({ name: 'cargo_type_code', type: 'varchar', length: 50, nullable: true })
+  cargoTypeCode?: string | null;
+
+  @Column({ name: 'container_status', type: 'varchar', length: 24, nullable: true })
+  containerStatus?: string | null; // e.g. EMPTY | MAINTENANCE
+
+  @Column({ name: 'requires_inspection', type: 'boolean', nullable: true })
+  requiresInspection?: boolean | null;
+
+  // ── Resolved target (by code) ─────────────────────────────────────────────
+  @Column({ name: 'target_facility_code', type: 'varchar', length: 40, nullable: true })
+  targetFacilityCode?: string | null;
+
+  @Column({ name: 'target_yard_code', type: 'varchar', length: 40 })
+  targetYardCode!: string;
+
+  @Column({ name: 'target_warehouse_code', type: 'varchar', length: 40, nullable: true })
+  targetWarehouseCode?: string | null;
+
+  @Column({ name: 'target_zone_code', type: 'varchar', length: 40, nullable: true })
+  targetZoneCode?: string | null;
+
+  @Column({ name: 'storage_type', type: 'varchar', length: 80, nullable: true })
+  storageType?: string | null; // descriptive: "Container terminal import / stack area"
+
+  @Column({ name: 'is_active', type: 'boolean', default: true })
+  isActive!: boolean;
+}
diff --git a/apps/edr-freight-api/src/modules/warehouses/entities/warehouse-fee-invoice-item.entity.ts b/apps/edr-freight-api/src/modules/warehouses/entities/warehouse-fee-invoice-item.entity.ts
new file mode 100644
index 000000000..8b14dcea3
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/warehouses/entities/warehouse-fee-invoice-item.entity.ts
@@ -0,0 +1,50 @@
+import { BaseEntity } from '@edr/api-common';
+import { Column, Entity, Index, JoinColumn, ManyToOne } from 'typeorm';
+
+import { WarehouseFeeInvoice } from './warehouse-fee-invoice.entity';
+
+export const WAREHOUSE_FEE_TYPES = [
+  'CONTAINER_DEMURRAGE',
+  'BULK_DEMURRAGE',
+  'STORAGE_FEE',
+  'HANDLING_FEE',
+] as const;
+export type WarehouseFeeType = (typeof WAREHOUSE_FEE_TYPES)[number];
+
+@Entity({ schema: 'freight', name: 'warehouse_fee_invoice_items' })
+@Index(['invoiceId'])
+export class WarehouseFeeInvoiceItem extends BaseEntity {
+  @Column({ name: 'invoice_id', type: 'uuid' })
+  invoiceId!: string;
+
+  @ManyToOne(() => WarehouseFeeInvoice, { onDelete: 'CASCADE' })
+  @JoinColumn({ name: 'invoice_id' })
+  invoice?: WarehouseFeeInvoice;
+
+  @Column({ name: 'fee_rule_id', type: 'uuid', nullable: true })
+  feeRuleId?: string | null;
+
+  @Column({ name: 'fee_type', type: 'varchar', length: 32 })
+  feeType!: WarehouseFeeType;
+
+  @Column({ name: 'description', type: 'varchar', length: 255 })
+  description!: string;
+
+  @Column({ name: 'quantity', type: 'numeric', precision: 12, scale: 2, default: 1 })
+  quantity!: number;
+
+  @Column({ name: 'unit_rate', type: 'numeric', precision: 14, scale: 2, default: 0 })
+  unitRate!: number;
+
+  @Column({ name: 'amount', type: 'numeric', precision: 14, scale: 2, default: 0 })
+  amount!: number;
+
+  @Column({ name: 'currency', type: 'varchar', length: 8, default: 'USD' })
+  currency!: string;
+
+  @Column({ name: 'chargeable_days', type: 'int', nullable: true })
+  chargeableDays?: number | null;
+
+  @Column({ name: 'free_days', type: 'int', nullable: true })
+  freeDays?: number | null;
+}
diff --git a/apps/edr-freight-api/src/modules/warehouses/entities/warehouse-fee-invoice.entity.ts b/apps/edr-freight-api/src/modules/warehouses/entities/warehouse-fee-invoice.entity.ts
new file mode 100644
index 000000000..e57d626d5
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/warehouses/entities/warehouse-fee-invoice.entity.ts
@@ -0,0 +1,107 @@
+import { BaseEntity } from '@edr/api-common';
+import { Column, Entity, Index } from 'typeorm';
+
+export const WAREHOUSE_INVOICE_TYPES = ['DEMURRAGE', 'STORAGE_FEE', 'MIXED_WAREHOUSE_FEES'] as const;
+export type WarehouseInvoiceType = (typeof WAREHOUSE_INVOICE_TYPES)[number];
+
+export const WAREHOUSE_INVOICE_STATUSES = [
+  'DRAFT',
+  'ISSUED',
+  'PARTIALLY_PAID',
+  'PAID',
+  'CANCELLED',
+] as const;
+export type WarehouseInvoiceStatus = (typeof WAREHOUSE_INVOICE_STATUSES)[number];
+
+/** A single recorded payment against a warehouse fee invoice (history). */
+export interface WarehouseInvoicePayment {
+  amount: number;
+  method?: string | null;
+  reference?: string | null;
+  paidAt: string;
+}
+
+/**
+ * Batch 6 — invoice generated from Batch 5 demurrage/storage fee calculation.
+ * Owns warehouse fees; links to booking/customer/inventory/location so it can
+ * connect to the existing payment module without duplicating it.
+ */
+@Entity({ schema: 'freight', name: 'warehouse_fee_invoices' })
+@Index(['invoiceNumber'], { unique: true })
+@Index(['bookingId'])
+@Index(['inventoryId'])
+@Index(['status'])
+export class WarehouseFeeInvoice extends BaseEntity {
+  @Column({ name: 'invoice_number', type: 'varchar', length: 40, unique: true })
+  invoiceNumber!: string;
+
+  @Column({ name: 'booking_id', type: 'uuid', nullable: true })
+  bookingId?: string | null;
+
+  @Column({ name: 'customer_id', type: 'uuid', nullable: true })
+  customerId?: string | null;
+
+  @Column({ name: 'inventory_id', type: 'uuid' })
+  inventoryId!: string;
+
+  @Column({ name: 'facility_id', type: 'uuid', nullable: true })
+  facilityId?: string | null;
+
+  @Column({ name: 'warehouse_id', type: 'uuid', nullable: true })
+  warehouseId?: string | null;
+
+  @Column({ name: 'yard_id', type: 'uuid', nullable: true })
+  yardId?: string | null;
+
+  @Column({ name: 'zone_id', type: 'uuid', nullable: true })
+  zoneId?: string | null;
+
+  @Column({ name: 'invoice_type', type: 'varchar', length: 32, default: 'MIXED_WAREHOUSE_FEES' })
+  invoiceType!: WarehouseInvoiceType;
+
+  @Column({ name: 'status', type: 'varchar', length: 20, default: 'DRAFT' })
+  status!: WarehouseInvoiceStatus;
+
+  @Column({ name: 'subtotal_amount', type: 'numeric', precision: 14, scale: 2, default: 0 })
+  subtotalAmount!: number;
+
+  @Column({ name: 'tax_amount', type: 'numeric', precision: 14, scale: 2, default: 0 })
+  taxAmount!: number;
+
+  @Column({ name: 'total_amount', type: 'numeric', precision: 14, scale: 2, default: 0 })
+  totalAmount!: number;
+
+  @Column({ name: 'paid_amount', type: 'numeric', precision: 14, scale: 2, default: 0 })
+  paidAmount!: number;
+
+  @Column({ name: 'balance_amount', type: 'numeric', precision: 14, scale: 2, default: 0 })
+  balanceAmount!: number;
+
+  @Column({ name: 'currency', type: 'varchar', length: 8, default: 'USD' })
+  currency!: string;
+
+  /** Charge window covered by this invoice — used to allow a later invoice for a new period. */
+  @Column({ name: 'period_start', type: 'timestamptz', nullable: true })
+  periodStart?: Date | null;
+
+  @Column({ name: 'period_end', type: 'timestamptz', nullable: true })
+  periodEnd?: Date | null;
+
+  @Column({ name: 'issued_at', type: 'timestamptz', nullable: true })
+  issuedAt?: Date | null;
+
+  @Column({ name: 'due_date', type: 'timestamptz', nullable: true })
+  dueDate?: Date | null;
+
+  @Column({ name: 'paid_at', type: 'timestamptz', nullable: true })
+  paidAt?: Date | null;
+
+  @Column({ name: 'cancelled_at', type: 'timestamptz', nullable: true })
+  cancelledAt?: Date | null;
+
+  @Column({ name: 'payments', type: 'jsonb', default: () => "'[]'" })
+  payments!: WarehouseInvoicePayment[];
+
+  @Column({ name: 'notes', type: 'text', nullable: true })
+  notes?: string | null;
+}
diff --git a/apps/edr-freight-api/src/modules/warehouses/entities/warehouse-fee-rule.entity.ts b/apps/edr-freight-api/src/modules/warehouses/entities/warehouse-fee-rule.entity.ts
new file mode 100644
index 000000000..f346be282
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/warehouses/entities/warehouse-fee-rule.entity.ts
@@ -0,0 +1,62 @@
+import { BaseEntity } from '@edr/api-common';
+import { Column, Entity, Index } from 'typeorm';
+
+export const FEE_RULE_TYPES = ['STORAGE_FEE', 'DEMURRAGE_FEE'] as const;
+export type FeeRuleType = (typeof FEE_RULE_TYPES)[number];
+
+/**
+ * Batch 5 — configurable storage / demurrage fee rules (no invoice/payment here — that is Batch 6).
+ * The most specific active rule (highest `specificity` then lowest `priority`) applies to an item.
+ * `freeDays` is the grace period; charging starts the day after it expires.
+ */
+@Entity({ schema: 'freight', name: 'warehouse_fee_rules' })
+@Index(['ruleType'])
+@Index(['isActive'])
+export class WarehouseFeeRule extends BaseEntity {
+  @Column({ name: 'name', type: 'varchar', length: 160 })
+  name!: string;
+
+  @Column({ name: 'rule_type', type: 'varchar', length: 20 })
+  ruleType!: FeeRuleType;
+
+  @Column({ name: 'priority', type: 'int', default: 100 })
+  priority!: number;
+
+  // ── Scope (null = applies to all) ─────────────────────────────────────────
+  @Column({ name: 'freight_type', type: 'varchar', length: 16, nullable: true })
+  freightType?: string | null; // CONTAINER | BULK
+
+  @Column({ name: 'trade_direction', type: 'varchar', length: 16, nullable: true })
+  tradeDirection?: string | null; // IMPORT | EXPORT | DOMESTIC | BOTH
+
+  @Column({ name: 'cargo_type_code', type: 'varchar', length: 50, nullable: true })
+  cargoTypeCode?: string | null;
+
+  @Column({ name: 'container_type', type: 'varchar', length: 40, nullable: true })
+  containerType?: string | null;
+
+  @Column({ name: 'facility_id', type: 'uuid', nullable: true })
+  facilityId?: string | null;
+
+  @Column({ name: 'warehouse_id', type: 'uuid', nullable: true })
+  warehouseId?: string | null;
+
+  @Column({ name: 'yard_id', type: 'uuid', nullable: true })
+  yardId?: string | null;
+
+  @Column({ name: 'zone_id', type: 'uuid', nullable: true })
+  zoneId?: string | null;
+
+  // ── Fee definition ────────────────────────────────────────────────────────
+  @Column({ name: 'free_days', type: 'int', default: 0 })
+  freeDays!: number;
+
+  @Column({ name: 'rate_per_day', type: 'numeric', precision: 14, scale: 2, default: 0 })
+  ratePerDay!: number;
+
+  @Column({ name: 'currency', type: 'varchar', length: 8, default: 'USD' })
+  currency!: string;
+
+  @Column({ name: 'is_active', type: 'boolean', default: true })
+  isActive!: boolean;
+}
diff --git a/apps/edr-freight-api/src/modules/warehouses/entities/warehouse-inspection-report.entity.ts b/apps/edr-freight-api/src/modules/warehouses/entities/warehouse-inspection-report.entity.ts
new file mode 100644
index 000000000..598b8d168
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/warehouses/entities/warehouse-inspection-report.entity.ts
@@ -0,0 +1,77 @@
+import { BaseEntity } from '@edr/api-common';
+import { Column, Entity, Index, JoinColumn, ManyToOne } from 'typeorm';
+
+import { WarehouseInventory } from './warehouse-inventory.entity';
+
+export const INSPECTION_REPORT_TYPES = [
+  'INSPECTION',
+  'DAMAGE',
+  'WEIGHT_LOSS',
+  'MISSING_ITEM',
+  'GENERAL',
+] as const;
+export type InspectionReportType = (typeof INSPECTION_REPORT_TYPES)[number];
+
+export const INSPECTION_STATUSES = ['PASSED', 'FAILED', 'NEEDS_REVIEW'] as const;
+export type InspectionStatus = (typeof INSPECTION_STATUSES)[number];
+
+@Entity({ schema: 'freight', name: 'warehouse_inspection_reports' })
+@Index(['inventoryId'])
+@Index(['bookingId'])
+@Index(['inspectionStatus'])
+export class WarehouseInspectionReport extends BaseEntity {
+  @Column({ name: 'inventory_id', type: 'uuid' })
+  inventoryId!: string;
+
+  @ManyToOne(() => WarehouseInventory)
+  @JoinColumn({ name: 'inventory_id' })
+  inventory?: WarehouseInventory;
+
+  @Column({ name: 'booking_id', type: 'uuid', nullable: true })
+  bookingId?: string | null;
+
+  @Column({ name: 'customer_id', type: 'uuid', nullable: true })
+  customerId?: string | null;
+
+  @Column({ name: 'report_type', type: 'varchar', length: 32, default: 'INSPECTION' })
+  reportType!: InspectionReportType;
+
+  @Column({ name: 'inspection_status', type: 'varchar', length: 20, default: 'NEEDS_REVIEW' })
+  inspectionStatus!: InspectionStatus;
+
+  @Column({ name: 'has_damage', type: 'boolean', default: false })
+  hasDamage!: boolean;
+
+  @Column({ name: 'damage_description', type: 'text', nullable: true })
+  damageDescription?: string | null;
+
+  @Column({ name: 'has_weight_loss', type: 'boolean', default: false })
+  hasWeightLoss!: boolean;
+
+  @Column({ name: 'expected_weight', type: 'numeric', precision: 14, scale: 3, nullable: true })
+  expectedWeight?: number | null;
+
+  @Column({ name: 'actual_weight', type: 'numeric', precision: 14, scale: 3, nullable: true })
+  actualWeight?: number | null;
+
+  @Column({ name: 'weight_loss', type: 'numeric', precision: 14, scale: 3, nullable: true })
+  weightLoss?: number | null;
+
+  @Column({ name: 'weight_loss_unit', type: 'varchar', length: 12, nullable: true })
+  weightLossUnit?: string | null;
+
+  @Column({ name: 'has_missing_items', type: 'boolean', default: false })
+  hasMissingItems!: boolean;
+
+  @Column({ name: 'missing_items_description', type: 'text', nullable: true })
+  missingItemsDescription?: string | null;
+
+  @Column({ name: 'remarks', type: 'text', nullable: true })
+  remarks?: string | null;
+
+  @Column({ name: 'inspected_by_id', type: 'uuid', nullable: true })
+  inspectedById?: string | null;
+
+  @Column({ name: 'inspected_at', type: 'timestamptz', nullable: true })
+  inspectedAt?: Date | null;
+}
diff --git a/apps/edr-freight-api/src/modules/warehouses/entities/warehouse-inventory-movement.entity.ts b/apps/edr-freight-api/src/modules/warehouses/entities/warehouse-inventory-movement.entity.ts
new file mode 100644
index 000000000..4ecfdc0dd
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/warehouses/entities/warehouse-inventory-movement.entity.ts
@@ -0,0 +1,42 @@
+import { BaseEntity } from '@edr/api-common';
+import { Column, Entity, Index, JoinColumn, ManyToOne } from 'typeorm';
+
+import { WarehouseInventory } from './warehouse-inventory.entity';
+
+@Entity({ schema: 'freight', name: 'warehouse_inventory_movement' })
+@Index(['inventoryId'])
+export class WarehouseInventoryMovement extends BaseEntity {
+  @Column({ name: 'inventory_id', type: 'uuid' })
+  inventoryId!: string;
+
+  @ManyToOne(() => WarehouseInventory, { onDelete: 'CASCADE' })
+  @JoinColumn({ name: 'inventory_id' })
+  inventory?: WarehouseInventory;
+
+  @Column({ name: 'from_warehouse_id', type: 'uuid' })
+  fromWarehouseId!: string;
+
+  @Column({ name: 'from_yard_id', type: 'uuid' })
+  fromYardId!: string;
+
+  @Column({ name: 'from_zone_id', type: 'uuid' })
+  fromZoneId!: string;
+
+  @Column({ name: 'to_warehouse_id', type: 'uuid' })
+  toWarehouseId!: string;
+
+  @Column({ name: 'to_yard_id', type: 'uuid' })
+  toYardId!: string;
+
+  @Column({ name: 'to_zone_id', type: 'uuid' })
+  toZoneId!: string;
+
+  @Column({ name: 'remarks', type: 'text', nullable: true })
+  remarks?: string | null;
+
+  @Column({ name: 'moved_by', type: 'varchar', length: 120, nullable: true })
+  movedBy?: string | null;
+
+  @Column({ name: 'moved_at', type: 'timestamptz' })
+  movedAt!: Date;
+}
diff --git a/apps/edr-freight-api/src/modules/warehouses/entities/warehouse-inventory.entity.ts b/apps/edr-freight-api/src/modules/warehouses/entities/warehouse-inventory.entity.ts
new file mode 100644
index 000000000..6c9270987
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/warehouses/entities/warehouse-inventory.entity.ts
@@ -0,0 +1,143 @@
+import { BaseEntity } from '@edr/api-common';
+import { Column, Entity, Index, JoinColumn, ManyToOne } from 'typeorm';
+
+import { Booking } from '../../bookings/entities/booking.entity';
+import { Cargo } from '../../cargoes/entities/cargoes.entity';
+import { Container } from '../../container-management/entities/container.entity';
+import { Warehouse } from './warehouse.entity';
+import { WarehouseYard } from './warehouse-yard.entity';
+import { WarehouseZone } from './warehouse-zone.entity';
+
+// Batch 2 lifecycle. Supersedes the Batch 1 set
+// (ARRIVED_AT_WAREHOUSE / UNDER_INSPECTION / READY_FOR_LOADING) — migrated in place.
+export const WAREHOUSE_INVENTORY_STATUSES = [
+  'RECEIVED',
+  'STORED',
+  'RESERVED',
+  'READY_FOR_LOADING',
+  'LOADED',
+  'DISPATCHED',
+] as const;
+export type WarehouseInventoryStatus = (typeof WAREHOUSE_INVENTORY_STATUSES)[number];
+
+/** Allowed forward transitions for the inventory lifecycle. */
+export const WAREHOUSE_INVENTORY_TRANSITIONS: Record<WarehouseInventoryStatus, WarehouseInventoryStatus[]> = {
+  RECEIVED: ['STORED'],
+  STORED: ['RESERVED'],
+  RESERVED: ['READY_FOR_LOADING'],
+  READY_FOR_LOADING: ['LOADED'],
+  LOADED: ['DISPATCHED'],
+  DISPATCHED: [],
+};
+
+@Entity({ schema: 'freight', name: 'warehouse_inventory' })
+@Index(['warehouseId'])
+@Index(['yardId'])
+@Index(['zoneId'])
+@Index(['bookingId'])
+@Index(['cargoId'])
+@Index(['containerId'])
+@Index(['goodsId'])
+@Index(['status'])
+export class WarehouseInventory extends BaseEntity {
+  @Column({ name: 'warehouse_id', type: 'uuid' })
+  warehouseId!: string;
+
+  @ManyToOne(() => Warehouse)
+  @JoinColumn({ name: 'warehouse_id' })
+  warehouse?: Warehouse;
+
+  @Column({ name: 'yard_id', type: 'uuid' })
+  yardId!: string;
+
+  @ManyToOne(() => WarehouseYard)
+  @JoinColumn({ name: 'yard_id' })
+  yard?: WarehouseYard;
+
+  @Column({ name: 'zone_id', type: 'uuid' })
+  zoneId!: string;
+
+  @ManyToOne(() => WarehouseZone)
+  @JoinColumn({ name: 'zone_id' })
+  zone?: WarehouseZone;
+
+  @Column({ name: 'booking_id', type: 'uuid', nullable: true })
+  bookingId?: string | null;
+
+  @ManyToOne(() => Booking, { nullable: true })
+  @JoinColumn({ name: 'booking_id' })
+  booking?: Booking | null;
+
+  @Column({ name: 'cargo_id', type: 'uuid', nullable: true })
+  cargoId?: string | null;
+
+  @ManyToOne(() => Cargo, { nullable: true })
+  @JoinColumn({ name: 'cargo_id' })
+  cargo?: Cargo | null;
+
+  @Column({ name: 'container_id', type: 'uuid', nullable: true })
+  containerId?: string | null;
+
+  @ManyToOne(() => Container, { nullable: true })
+  @JoinColumn({ name: 'container_id' })
+  container?: Container | null;
+
+  @Column({ name: 'goods_id', type: 'uuid', nullable: true })
+  goodsId?: string | null;
+
+  @Column({ name: 'quantity', type: 'numeric', precision: 12, scale: 3, default: 0 })
+  quantity!: number;
+
+  @Column({ name: 'weight', type: 'numeric', precision: 14, scale: 3, default: 0 })
+  weight!: number;
+
+  @Column({ name: 'volume', type: 'numeric', precision: 12, scale: 3, nullable: true })
+  volume?: number | null;
+
+  @Column({ name: 'status', type: 'varchar', length: 32, default: 'RECEIVED' })
+  status!: WarehouseInventoryStatus;
+
+  // Batch 4.5: latest inspection outcome (PASSED | FAILED | NEEDS_REVIEW). Null = not yet inspected.
+  @Column({ name: 'inspection_status', type: 'varchar', length: 20, nullable: true })
+  inspectionStatus?: string | null;
+
+  @Column({ name: 'arrived_at', type: 'timestamptz', nullable: true })
+  arrivedAt?: Date | null;
+
+  @Column({ name: 'stored_at', type: 'timestamptz', nullable: true })
+  storedAt?: Date | null;
+
+  @Column({ name: 'reserved_at', type: 'timestamptz', nullable: true })
+  reservedAt?: Date | null;
+
+  @Column({ name: 'inspected_at', type: 'timestamptz', nullable: true })
+  inspectedAt?: Date | null;
+
+  @Column({ name: 'ready_for_loading_at', type: 'timestamptz', nullable: true })
+  readyForLoadingAt?: Date | null;
+
+  @Column({ name: 'loaded_at', type: 'timestamptz', nullable: true })
+  loadedAt?: Date | null;
+
+  @Column({ name: 'dispatched_at', type: 'timestamptz', nullable: true })
+  dispatchedAt?: Date | null;
+
+  // Batch 5 — demurrage / storage lifecycle timestamps.
+  @Column({ name: 'inspection_started_at', type: 'timestamptz', nullable: true })
+  inspectionStartedAt?: Date | null;
+
+  @Column({ name: 'inspection_completed_at', type: 'timestamptz', nullable: true })
+  inspectionCompletedAt?: Date | null;
+
+  @Column({ name: 'ready_for_pickup_at', type: 'timestamptz', nullable: true })
+  readyForPickupAt?: Date | null;
+
+  @Column({ name: 'release_date', type: 'timestamptz', nullable: true })
+  releaseDate?: Date | null;
+
+  @Column({ name: 'gate_cleared_at', type: 'timestamptz', nullable: true })
+  gateClearedAt?: Date | null;
+
+  @Column({ name: 'notes', type: 'text', nullable: true })
+  notes?: string | null;
+}
diff --git a/apps/edr-freight-api/src/modules/warehouses/entities/warehouse-loading.entity.ts b/apps/edr-freight-api/src/modules/warehouses/entities/warehouse-loading.entity.ts
new file mode 100644
index 000000000..5f6952aec
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/warehouses/entities/warehouse-loading.entity.ts
@@ -0,0 +1,46 @@
+import { BaseEntity } from '@edr/api-common';
+import { Column, Entity, Index, JoinColumn, ManyToOne } from 'typeorm';
+
+import { Booking } from '../../bookings/entities/booking.entity';
+import { WarehouseInventory } from './warehouse-inventory.entity';
+
+/**
+ * Batch 3 — a record that a warehouse inventory item was physically loaded onto a wagon.
+ * The warehouse OWNS this record. It only READS wagon/schedule data from the scheduling
+ * domain (via SchedulingReadFacade); it never writes to wagons or train schedules.
+ */
+@Entity({ schema: 'freight', name: 'warehouse_loadings' })
+@Index(['warehouseInventoryId'])
+@Index(['bookingId'])
+@Index(['wagonId'])
+export class WarehouseLoading extends BaseEntity {
+  @Column({ name: 'warehouse_inventory_id', type: 'uuid' })
+  warehouseInventoryId!: string;
+
+  @ManyToOne(() => WarehouseInventory)
+  @JoinColumn({ name: 'warehouse_inventory_id' })
+  inventory?: WarehouseInventory;
+
+  @Column({ name: 'booking_id', type: 'uuid', nullable: true })
+  bookingId?: string | null;
+
+  @ManyToOne(() => Booking, { nullable: true })
+  @JoinColumn({ name: 'booking_id' })
+  booking?: Booking | null;
+
+  /** Physical wagon the item was loaded onto. References freight.wagons (read-only link). */
+  @Column({ name: 'wagon_id', type: 'uuid' })
+  wagonId!: string;
+
+  @Column({ name: 'loaded_at', type: 'timestamptz' })
+  loadedAt!: Date;
+
+  @Column({ name: 'loaded_by', type: 'varchar', length: 120, nullable: true })
+  loadedBy?: string | null;
+
+  @Column({ name: 'loaded_weight', type: 'numeric', precision: 14, scale: 3, nullable: true })
+  loadedWeight?: number | null;
+
+  @Column({ name: 'notes', type: 'text', nullable: true })
+  notes?: string | null;
+}
diff --git a/apps/edr-freight-api/src/modules/warehouses/entities/warehouse-yard.entity.ts b/apps/edr-freight-api/src/modules/warehouses/entities/warehouse-yard.entity.ts
new file mode 100644
index 000000000..6e3c93292
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/warehouses/entities/warehouse-yard.entity.ts
@@ -0,0 +1,69 @@
+import { BaseEntity } from '@edr/api-common';
+import { Column, Entity, Index, JoinColumn, ManyToOne, OneToMany } from 'typeorm';
+
+import { Warehouse } from './warehouse.entity';
+import { WarehouseZone } from './warehouse-zone.entity';
+
+export const WAREHOUSE_YARD_TYPES = [
+  'CONTAINER_YARD',
+  'BULK_YARD',
+  'GENERAL_CARGO_YARD',
+  'HAZARDOUS_YARD',
+  'COLD_STORAGE_YARD',
+] as const;
+export type WarehouseYardType = (typeof WAREHOUSE_YARD_TYPES)[number];
+
+export const WAREHOUSE_YARD_STATUSES = ['ACTIVE', 'INACTIVE'] as const;
+export type WarehouseYardStatus = (typeof WAREHOUSE_YARD_STATUSES)[number];
+
+@Entity({ schema: 'freight', name: 'warehouse_yards' })
+@Index(['warehouseId'])
+@Index(['type'])
+@Index(['status'])
+export class WarehouseYard extends BaseEntity {
+  @Column({ name: 'warehouse_id', type: 'uuid' })
+  warehouseId!: string;
+
+  @ManyToOne(() => Warehouse, (warehouse) => warehouse.yards, { onDelete: 'CASCADE' })
+  @JoinColumn({ name: 'warehouse_id' })
+  warehouse?: Warehouse;
+
+  @Column({ name: 'name', type: 'varchar', length: 160 })
+  name!: string;
+
+  @Column({ name: 'code', type: 'varchar', length: 40 })
+  code!: string;
+
+  @Column({ name: 'type', type: 'varchar', length: 32 })
+  type!: WarehouseYardType;
+
+  @Column({ name: 'capacity_weight', type: 'numeric', precision: 14, scale: 3, nullable: true })
+  capacityWeight?: number | null;
+
+  @Column({ name: 'capacity_containers', type: 'int', nullable: true })
+  capacityContainers?: number | null;
+
+  @Column({ name: 'current_weight', type: 'numeric', precision: 14, scale: 3, default: 0 })
+  currentWeight!: number;
+
+  @Column({ name: 'current_containers', type: 'int', default: 0 })
+  currentContainers!: number;
+
+  @Column({ name: 'max_weight', type: 'numeric', precision: 14, scale: 3, nullable: true })
+  maxWeight?: number | null;
+
+  @Column({ name: 'max_volume', type: 'numeric', precision: 14, scale: 3, nullable: true })
+  maxVolume?: number | null;
+
+  @Column({ name: 'current_volume', type: 'numeric', precision: 14, scale: 3, default: 0 })
+  currentVolume!: number;
+
+  @Column({ name: 'status', type: 'varchar', length: 16, default: 'ACTIVE' })
+  status!: WarehouseYardStatus;
+
+  @Column({ name: 'is_active', type: 'boolean', default: true })
+  isActive!: boolean;
+
+  @OneToMany(() => WarehouseZone, (zone) => zone.yard)
+  zones?: WarehouseZone[];
+}
diff --git a/apps/edr-freight-api/src/modules/warehouses/entities/warehouse-zone.entity.ts b/apps/edr-freight-api/src/modules/warehouses/entities/warehouse-zone.entity.ts
new file mode 100644
index 000000000..9cfaad6de
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/warehouses/entities/warehouse-zone.entity.ts
@@ -0,0 +1,65 @@
+import { BaseEntity } from '@edr/api-common';
+import { Column, Entity, Index, JoinColumn, ManyToOne } from 'typeorm';
+
+import { WarehouseYard } from './warehouse-yard.entity';
+
+export const WAREHOUSE_ZONE_TYPES = [
+  'CONTAINER_ZONE',
+  'BULK_ZONE',
+  'GENERAL_CARGO_ZONE',
+  'HAZARDOUS_ZONE',
+  'COLD_STORAGE_ZONE',
+] as const;
+export type WarehouseZoneType = (typeof WAREHOUSE_ZONE_TYPES)[number];
+
+export const WAREHOUSE_ZONE_STATUSES = ['ACTIVE', 'INACTIVE'] as const;
+export type WarehouseZoneStatus = (typeof WAREHOUSE_ZONE_STATUSES)[number];
+
+@Entity({ schema: 'freight', name: 'warehouse_zones' })
+@Index(['yardId'])
+@Index(['type'])
+@Index(['status'])
+export class WarehouseZone extends BaseEntity {
+  @Column({ name: 'yard_id', type: 'uuid' })
+  yardId!: string;
+
+  @ManyToOne(() => WarehouseYard, (yard) => yard.zones, { onDelete: 'CASCADE' })
+  @JoinColumn({ name: 'yard_id' })
+  yard?: WarehouseYard;
+
+  @Column({ name: 'name', type: 'varchar', length: 160 })
+  name!: string;
+
+  @Column({ name: 'code', type: 'varchar', length: 40 })
+  code!: string;
+
+  @Column({ name: 'type', type: 'varchar', length: 32 })
+  type!: WarehouseZoneType;
+
+  @Column({ name: 'capacity_weight', type: 'numeric', precision: 14, scale: 3, nullable: true })
+  capacityWeight?: number | null;
+
+  @Column({ name: 'capacity_containers', type: 'int', nullable: true })
+  capacityContainers?: number | null;
+
+  @Column({ name: 'current_weight', type: 'numeric', precision: 14, scale: 3, default: 0 })
+  currentWeight!: number;
+
+  @Column({ name: 'current_containers', type: 'int', default: 0 })
+  currentContainers!: number;
+
+  @Column({ name: 'max_weight', type: 'numeric', precision: 14, scale: 3, nullable: true })
+  maxWeight?: number | null;
+
+  @Column({ name: 'max_volume', type: 'numeric', precision: 14, scale: 3, nullable: true })
+  maxVolume?: number | null;
+
+  @Column({ name: 'current_volume', type: 'numeric', precision: 14, scale: 3, default: 0 })
+  currentVolume!: number;
+
+  @Column({ name: 'status', type: 'varchar', length: 16, default: 'ACTIVE' })
+  status!: WarehouseZoneStatus;
+
+  @Column({ name: 'is_active', type: 'boolean', default: true })
+  isActive!: boolean;
+}
diff --git a/apps/edr-freight-api/src/modules/warehouses/entities/warehouse.entity.ts b/apps/edr-freight-api/src/modules/warehouses/entities/warehouse.entity.ts
new file mode 100644
index 000000000..9d27ed64a
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/warehouses/entities/warehouse.entity.ts
@@ -0,0 +1,70 @@
+import { BaseEntity } from '@edr/api-common';
+import { Column, Entity, Index, ManyToOne, OneToMany } from 'typeorm';
+
+import { Facility } from '../../facilities/entities/facility.entity';
+import { WarehouseYard } from './warehouse-yard.entity';
+
+export const WAREHOUSE_TYPES = ['OPEN_WAREHOUSE', 'CLOSED_WAREHOUSE'] as const;
+export type WarehouseType = (typeof WAREHOUSE_TYPES)[number];
+
+export const WAREHOUSE_STATUSES = ['ACTIVE', 'INACTIVE'] as const;
+export type WarehouseStatus = (typeof WAREHOUSE_STATUSES)[number];
+
+@Entity({ schema: 'freight', name: 'warehouses' })
+@Index(['code'], { unique: true })
+@Index(['type'])
+@Index(['status'])
+@Index(['stationId'])
+export class Warehouse extends BaseEntity {
+  @Column({ name: 'name', type: 'varchar', length: 160 })
+  name!: string;
+
+  @Column({ name: 'code', type: 'varchar', length: 40, unique: true })
+  code!: string;
+
+  @Column({ name: 'type', type: 'varchar', length: 32 })
+  type!: WarehouseType;
+
+  @Column({ name: 'station_id', type: 'uuid', nullable: true })
+  stationId?: string | null;
+
+  @Column({ name: 'location_name', type: 'varchar', length: 200, nullable: true })
+  locationName?: string | null;
+
+  @Column({ name: 'capacity_weight', type: 'numeric', precision: 14, scale: 3, nullable: true })
+  capacityWeight?: number | null;
+
+  @Column({ name: 'capacity_containers', type: 'int', nullable: true })
+  capacityContainers?: number | null;
+
+  @Column({ name: 'current_weight', type: 'numeric', precision: 14, scale: 3, default: 0 })
+  currentWeight!: number;
+
+  @Column({ name: 'current_containers', type: 'int', default: 0 })
+  currentContainers!: number;
+
+  // Batch 2 capacity (weight + volume). maxWeight backfilled from capacityWeight.
+  @Column({ name: 'max_weight', type: 'numeric', precision: 14, scale: 3, nullable: true })
+  maxWeight?: number | null;
+
+  @Column({ name: 'max_volume', type: 'numeric', precision: 14, scale: 3, nullable: true })
+  maxVolume?: number | null;
+
+  @Column({ name: 'current_volume', type: 'numeric', precision: 14, scale: 3, default: 0 })
+  currentVolume!: number;
+
+  @Column({ name: 'status', type: 'varchar', length: 16, default: 'ACTIVE' })
+  status!: WarehouseStatus;
+
+  @Column({ name: 'is_active', type: 'boolean', default: true })
+  isActive!: boolean;
+
+  @Column({ name: 'facility_id', type: 'uuid', nullable: true })
+  facilityId?: string | null;
+
+  @ManyToOne(() => Facility, (facility) => facility.warehouses, { nullable: true })
+  facility?: Facility | null;
+
+  @OneToMany(() => WarehouseYard, (yard) => yard.warehouse)
+  yards?: WarehouseYard[];
+}
diff --git a/apps/edr-freight-api/src/modules/warehouses/scheduling-read.facade.ts b/apps/edr-freight-api/src/modules/warehouses/scheduling-read.facade.ts
new file mode 100644
index 000000000..de5a791c1
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/warehouses/scheduling-read.facade.ts
@@ -0,0 +1,118 @@
+import { Injectable } from '@nestjs/common';
+import { DataSource } from 'typeorm';
+
+/**
+ * READ-ONLY view into the train-scheduling / wagons domain for the warehouse module.
+ *
+ * IMPORTANT: this facade only ever runs SELECTs. The warehouse must never modify
+ * wagon assignment, rescheduling, import_ready/export_ready, or locomotive flow.
+ * It is intentionally decoupled (raw SQL) so it does not import the scheduling
+ * services/entities and cannot accidentally write to them.
+ */
+export interface WagonView {
+  id: string;
+  wagonNumber: string;
+  status: string;
+  trainId: string | null;
+}
+
+export interface BookingScheduleView {
+  schedule: {
+    id: string;
+    status: string;
+    scheduledDepartureDate: string | null;
+    scheduledArrivalDate: string | null;
+    originStationId: string | null;
+    destinationStationId: string | null;
+  } | null;
+  wagon: {
+    wagonId: string | null;
+    wagonNumber: string | null;
+    sequenceNo: number | null;
+    allocatedWeightTons: number | null;
+  } | null;
+  /** Mirror of schedule.status — the headline "where is the train" indicator. */
+  departureStatus: string | null;
+}
+
+@Injectable()
+export class SchedulingReadFacade {
+  constructor(private readonly dataSource: DataSource) {}
+
+  /** Look up a single physical wagon. Returns null if it does not exist. */
+  async findWagon(wagonId: string): Promise<WagonView | null> {
+    const rows = await this.dataSource.query(
+      `SELECT id, wagon_number AS "wagonNumber", status, train_id AS "trainId"
+       FROM freight.wagons
+       WHERE id = $1 AND deleted_at IS NULL
+       LIMIT 1`,
+      [wagonId],
+    );
+    return rows?.[0] ?? null;
+  }
+
+  /** True when the wagon is already part of a train set (selected by an existing schedule). */
+  async isWagonScheduled(wagonId: string): Promise<boolean> {
+    const rows = await this.dataSource.query(
+      `SELECT 1 FROM freight.train_set_wagons
+       WHERE physical_wagon_id = $1 AND deleted_at IS NULL
+       LIMIT 1`,
+      [wagonId],
+    );
+    return (rows?.length ?? 0) > 0;
+  }
+
+  /** List wagons usable for loading (available, or already assigned to a schedule). */
+  listLoadableWagons(): Promise<WagonView[]> {
+    return this.dataSource.query(
+      `SELECT id, wagon_number AS "wagonNumber", status, train_id AS "trainId"
+       FROM freight.wagons
+       WHERE deleted_at IS NULL
+         AND status NOT IN ('RETIRED', 'MAINTENANCE')
+       ORDER BY wagon_number ASC`,
+    );
+  }
+
+  /**
+   * Given a booking, return its related schedule, wagon assignment and departure status.
+   * All fields are read straight from the scheduling tables — nothing is written.
+   */
+  async getBookingSchedule(bookingId: string): Promise<BookingScheduleView> {
+    const scheduleRows = await this.dataSource.query(
+      `SELECT ts.id,
+              ts.status,
+              ts.scheduled_departure_date AS "scheduledDepartureDate",
+              ts.scheduled_arrival_date   AS "scheduledArrivalDate",
+              ts.origin_station_id        AS "originStationId",
+              ts.destination_station_id   AS "destinationStationId"
+       FROM freight.train_schedule_bookings tsb
+       INNER JOIN freight.train_schedules ts ON ts.id = tsb.train_schedule_id
+       WHERE tsb.booking_id = $1 AND ts.deleted_at IS NULL
+       ORDER BY ts.scheduled_departure_date DESC NULLS LAST
+       LIMIT 1`,
+      [bookingId],
+    );
+    const schedule = scheduleRows?.[0] ?? null;
+
+    const wagonRows = await this.dataSource.query(
+      `SELECT w.id          AS "wagonId",
+              w.wagon_number AS "wagonNumber",
+              tsw.sequence_no AS "sequenceNo",
+              wba.allocated_weight_tons AS "allocatedWeightTons"
+       FROM freight.wagon_booking_allocations wba
+       INNER JOIN freight.train_set_wagons tsw ON tsw.id = wba.train_set_wagon_id
+       LEFT JOIN freight.wagons w ON w.id = tsw.physical_wagon_id
+       WHERE wba.booking_id = $1
+       ORDER BY tsw.sequence_no ASC NULLS LAST
+       LIMIT 1`,
+      [bookingId],
+    );
+    const wagon = wagonRows?.[0] ?? null;
+
+    return {
+      schedule,
+      wagon,
+      departureStatus: schedule?.status ?? null,
+    };
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/warehouses/warehouse-activity-log.repository.ts b/apps/edr-freight-api/src/modules/warehouses/warehouse-activity-log.repository.ts
new file mode 100644
index 000000000..2e4eb7fae
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/warehouses/warehouse-activity-log.repository.ts
@@ -0,0 +1,13 @@
+import { BaseRepository } from '@edr/api-common';
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+
+import { WarehouseActivityLog } from './entities/warehouse-activity-log.entity';
+
+@Injectable()
+export class WarehouseActivityLogRepository extends BaseRepository<WarehouseActivityLog> {
+  constructor(@InjectRepository(WarehouseActivityLog) repository: Repository<WarehouseActivityLog>) {
+    super(repository);
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/warehouses/warehouse-activity-log.service.ts b/apps/edr-freight-api/src/modules/warehouses/warehouse-activity-log.service.ts
new file mode 100644
index 000000000..74c823a03
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/warehouses/warehouse-activity-log.service.ts
@@ -0,0 +1,48 @@
+import { Injectable } from '@nestjs/common';
+import { EntityManager } from 'typeorm';
+
+import {
+  WarehouseActivityLog,
+  WarehouseActivityType,
+} from './entities/warehouse-activity-log.entity';
+import { WarehouseActivityLogRepository } from './warehouse-activity-log.repository';
+
+interface LogInput {
+  activityType: WarehouseActivityType;
+  description?: string;
+  inventoryId?: string | null;
+  warehouseId?: string | null;
+  performedBy?: string | null;
+}
+
+@Injectable()
+export class WarehouseActivityLogService {
+  constructor(private readonly logRepository: WarehouseActivityLogRepository) {}
+
+  /** Persist an activity record. Pass a transaction manager to enrol in the caller's transaction. */
+  async record(input: LogInput, manager?: EntityManager): Promise<void> {
+    const data = {
+      activityType: input.activityType,
+      description: input.description ?? null,
+      inventoryId: input.inventoryId ?? null,
+      warehouseId: input.warehouseId ?? null,
+      performedBy: input.performedBy ?? 'system',
+    };
+
+    if (manager) {
+      await manager.getRepository(WarehouseActivityLog).save(
+        manager.getRepository(WarehouseActivityLog).create(data),
+      );
+      return;
+    }
+
+    await this.logRepository.create(data);
+  }
+
+  findByInventory(inventoryId: string): Promise<WarehouseActivityLog[]> {
+    return this.logRepository.findAll({
+      where: { inventoryId },
+      order: { createdAt: 'DESC' },
+    });
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/warehouses/warehouse-allocation-rule.repository.ts b/apps/edr-freight-api/src/modules/warehouses/warehouse-allocation-rule.repository.ts
new file mode 100644
index 000000000..a066c93f1
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/warehouses/warehouse-allocation-rule.repository.ts
@@ -0,0 +1,15 @@
+import { BaseRepository } from '@edr/api-common';
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+
+import { WarehouseAllocationRule } from './entities/warehouse-allocation-rule.entity';
+
+@Injectable()
+export class WarehouseAllocationRuleRepository extends BaseRepository<WarehouseAllocationRule> {
+  constructor(
+    @InjectRepository(WarehouseAllocationRule) repository: Repository<WarehouseAllocationRule>,
+  ) {
+    super(repository);
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/warehouses/warehouse-allocation.service.ts b/apps/edr-freight-api/src/modules/warehouses/warehouse-allocation.service.ts
new file mode 100644
index 000000000..f110dfcf7
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/warehouses/warehouse-allocation.service.ts
@@ -0,0 +1,120 @@
+import { Injectable, NotFoundException } from '@nestjs/common';
+import { DataSource } from 'typeorm';
+
+import { CreateAllocationRuleDto, UpdateAllocationRuleDto } from './dto/allocation-rule.dto';
+import { WarehouseAllocationRule } from './entities/warehouse-allocation-rule.entity';
+import { WarehouseAllocationRuleRepository } from './warehouse-allocation-rule.repository';
+
+export interface AllocationCriteria {
+  freightType?: string | null; // CONTAINER | BULK
+  tradeDirection?: string | null; // IMPORT | EXPORT | DOMESTIC | BOTH
+  cargoTypeCode?: string | null;
+  containerStatus?: string | null; // EMPTY | MAINTENANCE | ...
+  requiresInspection?: boolean | null;
+}
+
+export interface AllocationResult {
+  warehouseId: string;
+  yardId: string;
+  zoneId: string;
+  facilityId: string | null;
+  rule: { id: string; name: string; storageType: string | null } | null;
+  /** Human-readable path: Facility → Warehouse → Yard → Zone. */
+  path: string;
+}
+
+/**
+ * Batch 5 — deterministic warehouse/yard allocation driven by configurable rules.
+ * Never assigns randomly: matches criteria against active rules by priority and
+ * resolves the target Yard/Warehouse/Zone by code.
+ */
+@Injectable()
+export class WarehouseAllocationService {
+  constructor(
+    private readonly dataSource: DataSource,
+    private readonly ruleRepository: WarehouseAllocationRuleRepository,
+  ) {}
+
+  // ── Rule CRUD ──────────────────────────────────────────────────────────────
+  listRules(): Promise<WarehouseAllocationRule[]> {
+    return this.ruleRepository.findAll({ order: { priority: 'ASC' } });
+  }
+
+  createRule(dto: CreateAllocationRuleDto): Promise<WarehouseAllocationRule> {
+    return this.ruleRepository.create({ isActive: true, priority: 100, ...dto });
+  }
+
+  async updateRule(id: string, dto: UpdateAllocationRuleDto): Promise<WarehouseAllocationRule> {
+    const updated = await this.ruleRepository.update(id, dto);
+    if (!updated) throw new NotFoundException(`Allocation rule ${id} not found`);
+    return updated;
+  }
+
+  deleteRule(id: string): Promise<void> {
+    return this.ruleRepository.softDelete(id);
+  }
+
+  private matches(rule: WarehouseAllocationRule, c: AllocationCriteria): boolean {
+    const eq = (ruleVal?: string | null, inVal?: string | null) =>
+      ruleVal == null || (inVal != null && ruleVal.toUpperCase() === inVal.toUpperCase());
+    return (
+      eq(rule.freightType, c.freightType) &&
+      eq(rule.tradeDirection, c.tradeDirection) &&
+      eq(rule.cargoTypeCode, c.cargoTypeCode) &&
+      eq(rule.containerStatus, c.containerStatus) &&
+      (rule.requiresInspection == null || rule.requiresInspection === Boolean(c.requiresInspection))
+    );
+  }
+
+  /** First active rule (by priority) whose criteria match. */
+  async findMatchingRule(criteria: AllocationCriteria): Promise<WarehouseAllocationRule | null> {
+    const rules = await this.ruleRepository.findAll({
+      where: { isActive: true },
+      order: { priority: 'ASC' },
+    });
+    return rules.find((r) => this.matches(r, criteria)) ?? null;
+  }
+
+  /** Resolve a concrete warehouse/yard/zone for the given criteria, or null if none configured. */
+  async resolveLocation(criteria: AllocationCriteria): Promise<AllocationResult | null> {
+    const rule = await this.findMatchingRule(criteria);
+    const yardCode = rule?.targetYardCode;
+
+    // Resolve yard (by rule code, else first available yard with a zone).
+    const [yard] = await this.dataSource.query(
+      yardCode
+        ? `SELECT y.id, y.warehouse_id AS "warehouseId", y.name FROM freight.warehouse_yards y
+             WHERE y.code = $1 AND y.deleted_at IS NULL LIMIT 1`
+        : `SELECT y.id, y.warehouse_id AS "warehouseId", y.name FROM freight.warehouse_yards y
+             JOIN freight.warehouse_zones z ON z.yard_id = y.id AND z.deleted_at IS NULL
+             WHERE y.deleted_at IS NULL ORDER BY y.created_at ASC LIMIT 1`,
+      yardCode ? [yardCode] : [],
+    );
+    if (!yard) return null;
+
+    // Zone: rule code if given, else first zone in the yard.
+    const [zone] = await this.dataSource.query(
+      rule?.targetZoneCode
+        ? `SELECT z.id, z.name FROM freight.warehouse_zones z WHERE z.code = $1 AND z.deleted_at IS NULL LIMIT 1`
+        : `SELECT z.id, z.name FROM freight.warehouse_zones z WHERE z.yard_id = $1 AND z.deleted_at IS NULL ORDER BY z.created_at ASC LIMIT 1`,
+      rule?.targetZoneCode ? [rule.targetZoneCode] : [yard.id],
+    );
+    if (!zone) return null;
+
+    const [wh] = await this.dataSource.query(
+      `SELECT w.id, w.name, w.facility_id AS "facilityId",
+              (SELECT name FROM freight.facilities f WHERE f.id = w.facility_id) AS "facilityName"
+         FROM freight.warehouses w WHERE w.id = $1 AND w.deleted_at IS NULL LIMIT 1`,
+      [yard.warehouseId],
+    );
+
+    return {
+      warehouseId: yard.warehouseId,
+      yardId: yard.id,
+      zoneId: zone.id,
+      facilityId: wh?.facilityId ?? null,
+      rule: rule ? { id: rule.id, name: rule.name, storageType: rule.storageType ?? null } : null,
+      path: [wh?.facilityName, wh?.name, yard.name, zone.name].filter(Boolean).join(' → '),
+    };
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/warehouses/warehouse-dashboard.service.ts b/apps/edr-freight-api/src/modules/warehouses/warehouse-dashboard.service.ts
new file mode 100644
index 000000000..1bb5b1289
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/warehouses/warehouse-dashboard.service.ts
@@ -0,0 +1,55 @@
+import { Injectable } from '@nestjs/common';
+import { DataSource } from 'typeorm';
+
+import { Warehouse } from './entities/warehouse.entity';
+import { WarehouseInventory } from './entities/warehouse-inventory.entity';
+
+export interface WarehouseDashboard {
+  totalWarehouses: number;
+  totalInventory: number;
+  receivedToday: number;
+  stored: number;
+  reserved: number;
+  readyForLoading: number;
+  loaded: number;
+  dispatched: number;
+}
+
+@Injectable()
+export class WarehouseDashboardService {
+  constructor(private readonly dataSource: DataSource) {}
+
+  async getDashboard(): Promise<WarehouseDashboard> {
+    const warehouseRepo = this.dataSource.getRepository(Warehouse);
+    const inventoryRepo = this.dataSource.getRepository(WarehouseInventory);
+
+    const startOfToday = new Date();
+    startOfToday.setHours(0, 0, 0, 0);
+
+    const [totalWarehouses, totalInventory, stored, reserved, readyForLoading, loaded, dispatched, receivedToday] =
+      await Promise.all([
+        warehouseRepo.count(),
+        inventoryRepo.count(),
+        inventoryRepo.count({ where: { status: 'STORED' } }),
+        inventoryRepo.count({ where: { status: 'RESERVED' } }),
+        inventoryRepo.count({ where: { status: 'READY_FOR_LOADING' } }),
+        inventoryRepo.count({ where: { status: 'LOADED' } }),
+        inventoryRepo.count({ where: { status: 'DISPATCHED' } }),
+        inventoryRepo
+          .createQueryBuilder('inv')
+          .where('inv.arrived_at >= :start', { start: startOfToday })
+          .getCount(),
+      ]);
+
+    return {
+      totalWarehouses,
+      totalInventory,
+      receivedToday,
+      stored,
+      reserved,
+      readyForLoading,
+      loaded,
+      dispatched,
+    };
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/warehouses/warehouse-fee-invoice-item.repository.ts b/apps/edr-freight-api/src/modules/warehouses/warehouse-fee-invoice-item.repository.ts
new file mode 100644
index 000000000..5b5df396e
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/warehouses/warehouse-fee-invoice-item.repository.ts
@@ -0,0 +1,13 @@
+import { BaseRepository } from '@edr/api-common';
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+
+import { WarehouseFeeInvoiceItem } from './entities/warehouse-fee-invoice-item.entity';
+
+@Injectable()
+export class WarehouseFeeInvoiceItemRepository extends BaseRepository<WarehouseFeeInvoiceItem> {
+  constructor(@InjectRepository(WarehouseFeeInvoiceItem) repository: Repository<WarehouseFeeInvoiceItem>) {
+    super(repository);
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/warehouses/warehouse-fee-invoice.repository.ts b/apps/edr-freight-api/src/modules/warehouses/warehouse-fee-invoice.repository.ts
new file mode 100644
index 000000000..97328f46d
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/warehouses/warehouse-fee-invoice.repository.ts
@@ -0,0 +1,13 @@
+import { BaseRepository } from '@edr/api-common';
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+
+import { WarehouseFeeInvoice } from './entities/warehouse-fee-invoice.entity';
+
+@Injectable()
+export class WarehouseFeeInvoiceRepository extends BaseRepository<WarehouseFeeInvoice> {
+  constructor(@InjectRepository(WarehouseFeeInvoice) repository: Repository<WarehouseFeeInvoice>) {
+    super(repository);
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/warehouses/warehouse-fee-rule.repository.ts b/apps/edr-freight-api/src/modules/warehouses/warehouse-fee-rule.repository.ts
new file mode 100644
index 000000000..5b5d3b2ce
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/warehouses/warehouse-fee-rule.repository.ts
@@ -0,0 +1,13 @@
+import { BaseRepository } from '@edr/api-common';
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+
+import { WarehouseFeeRule } from './entities/warehouse-fee-rule.entity';
+
+@Injectable()
+export class WarehouseFeeRuleRepository extends BaseRepository<WarehouseFeeRule> {
+  constructor(@InjectRepository(WarehouseFeeRule) repository: Repository<WarehouseFeeRule>) {
+    super(repository);
+  }
+}
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
new file mode 100644
index 000000000..ccf66deb4
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/warehouses/warehouse-fee.service.ts
@@ -0,0 +1,168 @@
+import { Injectable, NotFoundException } from '@nestjs/common';
+import { DataSource } from 'typeorm';
+
+import { CreateFeeRuleDto, UpdateFeeRuleDto } from './dto/fee-rule.dto';
+import { FeeRuleType, WarehouseFeeRule } from './entities/warehouse-fee-rule.entity';
+import { WarehouseFeeRuleRepository } from './warehouse-fee-rule.repository';
+
+interface ItemAttributes {
+  arrivedAt: Date | null;
+  gateClearedAt: Date | null;
+  releaseDate: Date | null;
+  freightType: string | null;
+  tradeDirection: string | null;
+  cargoTypeCode: string | null;
+  containerTypeCode: string | null;
+  facilityId: string | null;
+  warehouseId: string | null;
+  yardId: string | null;
+  zoneId: string | null;
+}
+
+export interface FeePreview {
+  ruleType: FeeRuleType;
+  ruleId: string | null;
+  ruleName: string | null;
+  freeDays: number;
+  ratePerDay: number;
+  currency: string;
+  startDate: string | null;
+  endDate: string;
+  endIsOpen: boolean; // true when still accruing (no release/gate-clear yet)
+  elapsedDays: number;
+  chargeableDays: number;
+  amount: number;
+}
+
+const MS_PER_DAY = 24 * 60 * 60 * 1000;
+
+@Injectable()
+export class WarehouseFeeService {
+  constructor(
+    private readonly dataSource: DataSource,
+    private readonly feeRuleRepository: WarehouseFeeRuleRepository,
+  ) {}
+
+  // ── Rule CRUD ──────────────────────────────────────────────────────────────
+  listRules(): Promise<WarehouseFeeRule[]> {
+    return this.feeRuleRepository.findAll({ order: { ruleType: 'ASC', priority: 'ASC' } });
+  }
+
+  createRule(dto: CreateFeeRuleDto): Promise<WarehouseFeeRule> {
+    return this.feeRuleRepository.create({ isActive: true, priority: 100, currency: 'USD', ...dto });
+  }
+
+  async updateRule(id: string, dto: UpdateFeeRuleDto): Promise<WarehouseFeeRule> {
+    const updated = await this.feeRuleRepository.update(id, dto);
+    if (!updated) throw new NotFoundException(`Fee rule ${id} not found`);
+    return updated;
+  }
+
+  deleteRule(id: string): Promise<void> {
+    return this.feeRuleRepository.softDelete(id);
+  }
+
+  private async loadItem(inventoryId: string): Promise<ItemAttributes> {
+    const [row] = await this.dataSource.query(
+      `SELECT inv.arrived_at        AS "arrivedAt",
+              inv.gate_cleared_at   AS "gateClearedAt",
+              inv.release_date      AS "releaseDate",
+              inv.warehouse_id      AS "warehouseId",
+              inv.yard_id           AS "yardId",
+              inv.zone_id           AS "zoneId",
+              w.facility_id         AS "facilityId",
+              b.freight_type        AS "freightType",
+              b.trade_direction     AS "tradeDirection",
+              cgt.code              AS "cargoTypeCode",
+              ctt.code              AS "containerTypeCode"
+         FROM freight.warehouse_inventory inv
+         LEFT JOIN freight.warehouses w ON w.id = inv.warehouse_id
+         LEFT JOIN freight.bookings b ON b.id = inv.booking_id
+         LEFT JOIN freight.cargoes cg ON cg.id = inv.cargo_id
+         LEFT JOIN freight.cargo_types cgt ON cgt.id = cg.cargo_type_id
+         LEFT JOIN freight.containers ct ON ct.id = inv.container_id
+         LEFT JOIN freight.container_types ctt ON ctt.id = ct.container_type_id
+        WHERE inv.id = $1 AND inv.deleted_at IS NULL`,
+      [inventoryId],
+    );
+    if (!row) throw new NotFoundException(`Inventory item ${inventoryId} not found`);
+    return row;
+  }
+
+  private matchScore(rule: WarehouseFeeRule, item: ItemAttributes): number | null {
+    // Returns specificity score (#matched non-null scope fields), or null if any constraint fails.
+    let score = 0;
+    const check = (ruleVal: string | null | undefined, itemVal: string | null) => {
+      if (ruleVal == null) return true;
+      if (itemVal != null && ruleVal.toUpperCase() === itemVal.toUpperCase()) {
+        score += 1;
+        return true;
+      }
+      return false;
+    };
+    if (!check(rule.freightType, item.freightType)) return null;
+    if (!check(rule.tradeDirection, item.tradeDirection)) return null;
+    if (!check(rule.cargoTypeCode, item.cargoTypeCode)) return null;
+    if (!check(rule.containerType, item.containerTypeCode)) return null;
+    if (!check(rule.facilityId, item.facilityId)) return null;
+    if (!check(rule.warehouseId, item.warehouseId)) return null;
+    if (!check(rule.yardId, item.yardId)) return null;
+    if (!check(rule.zoneId, item.zoneId)) return null;
+    return score;
+  }
+
+  private bestRule(rules: WarehouseFeeRule[], item: ItemAttributes): WarehouseFeeRule | null {
+    let best: WarehouseFeeRule | null = null;
+    let bestScore = -1;
+    for (const rule of rules) {
+      const score = this.matchScore(rule, item);
+      if (score == null) continue;
+      if (score > bestScore || (score === bestScore && best && rule.priority < best.priority)) {
+        best = rule;
+        bestScore = score;
+      }
+    }
+    return best;
+  }
+
+  private compute(ruleType: FeeRuleType, rule: WarehouseFeeRule | null, item: ItemAttributes, now: Date): FeePreview {
+    const start = item.arrivedAt ? new Date(item.arrivedAt) : null;
+    const endDate = item.gateClearedAt ?? item.releaseDate ?? now;
+    const endIsOpen = !item.gateClearedAt && !item.releaseDate;
+    const freeDays = rule?.freeDays ?? 0;
+    const ratePerDay = Number(rule?.ratePerDay ?? 0);
+
+    const elapsedDays = start
+      ? Math.max(0, Math.ceil((new Date(endDate).getTime() - start.getTime()) / MS_PER_DAY))
+      : 0;
+    const chargeableDays = Math.max(0, elapsedDays - freeDays);
+    const amount = Math.round(chargeableDays * ratePerDay * 100) / 100;
+
+    return {
+      ruleType,
+      ruleId: rule?.id ?? null,
+      ruleName: rule?.name ?? null,
+      freeDays,
+      ratePerDay,
+      currency: rule?.currency ?? 'USD',
+      startDate: start ? start.toISOString() : null,
+      endDate: new Date(endDate).toISOString(),
+      endIsOpen,
+      elapsedDays,
+      chargeableDays,
+      amount,
+    };
+  }
+
+  /** Preview demurrage + storage fees for an inventory item using the most specific active rules. */
+  async previewForInventory(inventoryId: string): Promise<FeePreview[]> {
+    const item = await this.loadItem(inventoryId);
+    const rules = await this.feeRuleRepository.findAll({ where: { isActive: true } });
+    const now = new Date();
+
+    const byType: FeeRuleType[] = ['DEMURRAGE_FEE', 'STORAGE_FEE'];
+    return byType.map((type) =>
+      this.compute(type, this.bestRule(rules.filter((r) => r.ruleType === type), item), item, now),
+    );
+  }
+}
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
new file mode 100644
index 000000000..533b0c6ae
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/warehouses/warehouse-inspection.controller.ts
@@ -0,0 +1,64 @@
+import {
+  Body,
+  Controller,
+  Get,
+  Param,
+  ParseUUIDPipe,
+  Patch,
+  Post,
+  UploadedFiles,
+  UseInterceptors,
+} from '@nestjs/common';
+import { AnyFilesInterceptor } from '@nestjs/platform-express';
+import { ApiBearerAuth, ApiConsumes, ApiOperation, ApiTags } from '@nestjs/swagger';
+
+import { CreateInspectionReportDto } from './dto/create-inspection-report.dto';
+import { UpdateInspectionReportDto } from './dto/update-inspection-report.dto';
+import { WarehouseInspectionService } from './warehouse-inspection.service';
+
+@ApiTags('warehouse-inspection')
+@ApiBearerAuth()
+@Controller()
+export class WarehouseInspectionController {
+  constructor(private readonly inspectionService: WarehouseInspectionService) {}
+
+  @Post('warehouse-inventory/:inventoryId/inspection-reports')
+  @ApiOperation({ summary: 'Create an inspection / damage report for an inventory item' })
+  create(
+    @Param('inventoryId', ParseUUIDPipe) inventoryId: string,
+    @Body() dto: CreateInspectionReportDto,
+  ) {
+    return this.inspectionService.create(inventoryId, dto);
+  }
+
+  @Get('warehouse-inventory/:inventoryId/inspection-reports')
+  @ApiOperation({ summary: 'List inspection reports for an inventory item' })
+  listByInventory(@Param('inventoryId', ParseUUIDPipe) inventoryId: string) {
+    return this.inspectionService.findByInventory(inventoryId);
+  }
+
+  @Get('warehouse-inspection-reports/:id')
+  @ApiOperation({ summary: 'Get an inspection report (with attachments)' })
+  async findOne(@Param('id', ParseUUIDPipe) id: string) {
+    const report = await this.inspectionService.findById(id);
+    const attachments = await this.inspectionService.listAttachments(id);
+    return { ...report, attachments };
+  }
+
+  @Patch('warehouse-inspection-reports/:id')
+  @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')
+  @UseInterceptors(AnyFilesInterceptor())
+  @ApiConsumes('multipart/form-data')
+  @ApiOperation({ summary: 'Upload inspection images / documents' })
+  addAttachments(
+    @Param('id', ParseUUIDPipe) id: string,
+    @UploadedFiles() files: Express.Multer.File[],
+  ) {
+    return this.inspectionService.addAttachments(id, files);
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/warehouses/warehouse-inspection.repository.ts b/apps/edr-freight-api/src/modules/warehouses/warehouse-inspection.repository.ts
new file mode 100644
index 000000000..4cd92e846
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/warehouses/warehouse-inspection.repository.ts
@@ -0,0 +1,15 @@
+import { BaseRepository } from '@edr/api-common';
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+
+import { WarehouseInspectionReport } from './entities/warehouse-inspection-report.entity';
+
+@Injectable()
+export class WarehouseInspectionRepository extends BaseRepository<WarehouseInspectionReport> {
+  constructor(
+    @InjectRepository(WarehouseInspectionReport) repository: Repository<WarehouseInspectionReport>,
+  ) {
+    super(repository);
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/warehouses/warehouse-inspection.service.ts b/apps/edr-freight-api/src/modules/warehouses/warehouse-inspection.service.ts
new file mode 100644
index 000000000..9d1d0f148
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/warehouses/warehouse-inspection.service.ts
@@ -0,0 +1,116 @@
+import { Injectable, NotFoundException } from '@nestjs/common';
+import { DataSource } from 'typeorm';
+
+import { FilesService } from '../files/files.service';
+import { CreateInspectionReportDto } from './dto/create-inspection-report.dto';
+import { UpdateInspectionReportDto } from './dto/update-inspection-report.dto';
+import { WarehouseInspectionReport } from './entities/warehouse-inspection-report.entity';
+import { WarehouseInventory } from './entities/warehouse-inventory.entity';
+import { WarehouseInspectionRepository } from './warehouse-inspection.repository';
+
+const INSPECTION_RESOURCE = 'warehouse-inspection-report';
+
+@Injectable()
+export class WarehouseInspectionService {
+  constructor(
+    private readonly dataSource: DataSource,
+    private readonly inspectionRepository: WarehouseInspectionRepository,
+    private readonly filesService: FilesService,
+  ) {}
+
+  /** Create an inspection report for an inventory item and sync its inspectionStatus. */
+  async create(inventoryId: string, dto: CreateInspectionReportDto): Promise<WarehouseInspectionReport> {
+    const inventoryRepo = this.dataSource.getRepository(WarehouseInventory);
+    const inventory = await inventoryRepo.findOne({ where: { id: inventoryId } });
+    if (!inventory) {
+      throw new NotFoundException(`Inventory item ${inventoryId} not found`);
+    }
+
+    const expected = dto.expectedWeight ?? null;
+    const actual = dto.actualWeight ?? null;
+    const weightLoss = expected !== null && actual !== null ? Math.max(0, expected - actual) : null;
+
+    const report = await this.inspectionRepository.create({
+      inventoryId,
+      bookingId: inventory.bookingId ?? null,
+      reportType: dto.reportType,
+      inspectionStatus: dto.inspectionStatus,
+      hasDamage: dto.hasDamage ?? false,
+      damageDescription: dto.damageDescription ?? null,
+      hasWeightLoss: dto.hasWeightLoss ?? false,
+      expectedWeight: expected,
+      actualWeight: actual,
+      weightLoss,
+      weightLossUnit: weightLoss !== null ? 'kg' : null,
+      hasMissingItems: dto.hasMissingItems ?? false,
+      missingItemsDescription: dto.missingItemsDescription ?? null,
+      remarks: dto.remarks ?? null,
+      inspectedById: dto.inspectedById ?? null,
+      inspectedAt: new Date(),
+    });
+
+    // Mirror the latest outcome onto the inventory item so loading rules can read it.
+    await inventoryRepo.update(inventoryId, {
+      inspectionStatus: dto.inspectionStatus,
+      inspectedAt: new Date(),
+    });
+
+    return report;
+  }
+
+  async findByInventory(inventoryId: string): Promise<WarehouseInspectionReport[]> {
+    return this.inspectionRepository.findAll({
+      where: { inventoryId },
+      order: { createdAt: 'DESC' },
+    });
+  }
+
+  async findById(id: string): Promise<WarehouseInspectionReport> {
+    const report = await this.inspectionRepository.findById(id);
+    if (!report) {
+      throw new NotFoundException(`Inspection report ${id} not found`);
+    }
+    return report;
+  }
+
+  async update(id: string, dto: UpdateInspectionReportDto): Promise<WarehouseInspectionReport> {
+    const report = await this.findById(id);
+
+    const expected = dto.expectedWeight ?? report.expectedWeight ?? null;
+    const actual = dto.actualWeight ?? report.actualWeight ?? null;
+    const weightLoss = expected !== null && actual !== null ? Math.max(0, expected - actual) : report.weightLoss ?? null;
+
+    await this.inspectionRepository.update(id, {
+      ...(dto.reportType ? { reportType: dto.reportType } : {}),
+      ...(dto.inspectionStatus ? { inspectionStatus: dto.inspectionStatus } : {}),
+      ...(dto.hasDamage !== undefined ? { hasDamage: dto.hasDamage } : {}),
+      ...(dto.damageDescription !== undefined ? { damageDescription: dto.damageDescription } : {}),
+      ...(dto.hasWeightLoss !== undefined ? { hasWeightLoss: dto.hasWeightLoss } : {}),
+      expectedWeight: expected,
+      actualWeight: actual,
+      weightLoss,
+      ...(dto.hasMissingItems !== undefined ? { hasMissingItems: dto.hasMissingItems } : {}),
+      ...(dto.missingItemsDescription !== undefined ? { missingItemsDescription: dto.missingItemsDescription } : {}),
+      ...(dto.remarks !== undefined ? { remarks: dto.remarks } : {}),
+    });
+
+    if (dto.inspectionStatus) {
+      await this.dataSource
+        .getRepository(WarehouseInventory)
+        .update(report.inventoryId, { inspectionStatus: dto.inspectionStatus });
+    }
+
+    return this.findById(id);
+  }
+
+  /** Attach uploaded images/documents to a report, reusing the shared Files (MinIO) module. */
+  async addAttachments(reportId: string, files: Express.Multer.File[]) {
+    await this.findById(reportId);
+    if (!files?.length) return [];
+    return this.filesService.uploadMany(reportId, INSPECTION_RESOURCE, files);
+  }
+
+  listAttachments(reportId: string) {
+    return this.filesService.findByResource(reportId, INSPECTION_RESOURCE);
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/warehouses/warehouse-inventory-movement.repository.ts b/apps/edr-freight-api/src/modules/warehouses/warehouse-inventory-movement.repository.ts
new file mode 100644
index 000000000..ccc0bcd41
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/warehouses/warehouse-inventory-movement.repository.ts
@@ -0,0 +1,15 @@
+import { BaseRepository } from '@edr/api-common';
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+
+import { WarehouseInventoryMovement } from './entities/warehouse-inventory-movement.entity';
+
+@Injectable()
+export class WarehouseInventoryMovementRepository extends BaseRepository<WarehouseInventoryMovement> {
+  constructor(
+    @InjectRepository(WarehouseInventoryMovement) repository: Repository<WarehouseInventoryMovement>,
+  ) {
+    super(repository);
+  }
+}
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
new file mode 100644
index 000000000..ce8a2c188
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/warehouses/warehouse-inventory.controller.ts
@@ -0,0 +1,145 @@
+import { Body, Controller, Get, Param, ParseUUIDPipe, Patch, Post, Query } from '@nestjs/common';
+import { ApiBearerAuth, ApiOperation, ApiTags } from '@nestjs/swagger';
+
+import { FilterWarehouseInventoryDto } from './dto/filter-inventory.dto';
+import { InquiryWarehouseInventoryDto } from './dto/inquiry-inventory.dto';
+import { LoadInventoryDto } from './dto/load-inventory.dto';
+import { MoveInventoryDto } from './dto/move-inventory.dto';
+import { ReceiveWarehouseInventoryDto } from './dto/receive-inventory.dto';
+import { ReserveInventoryDto } from './dto/reserve-inventory.dto';
+import { UnloadBookingDto } from './dto/unload-booking.dto';
+import { SchedulingReadFacade } from './scheduling-read.facade';
+import { WarehouseInventoryService } from './warehouse-inventory.service';
+
+@ApiTags('warehouse-inventory')
+@ApiBearerAuth()
+@Controller('warehouse-inventory')
+export class WarehouseInventoryController {
+  constructor(
+    private readonly inventoryService: WarehouseInventoryService,
+    private readonly scheduling: SchedulingReadFacade,
+  ) {}
+
+  @Get()
+  @ApiOperation({ summary: 'List warehouse inventory' })
+  findAll(@Query() filter: FilterWarehouseInventoryDto) {
+    return this.inventoryService.findAll(filter);
+  }
+
+  @Get('ready-for-loading')
+  @ApiOperation({ summary: 'List inventory ready for loading' })
+  findReadyForLoading(@Query() filter: FilterWarehouseInventoryDto) {
+    return this.inventoryService.findReadyForLoading(filter);
+  }
+
+  @Get('inquiry')
+  @ApiOperation({ summary: 'Locate any item inside the warehouse' })
+  inquiry(@Query() filter: InquiryWarehouseInventoryDto) {
+    return this.inventoryService.inquiry(filter);
+  }
+
+  @Get('arrival-queue')
+  @ApiOperation({ summary: 'Arrived bookings awaiting unload / inspection' })
+  arrivalQueue() {
+    return this.inventoryService.arrivalQueue();
+  }
+
+  @Post('auto-unload-arrived')
+  @ApiOperation({ summary: 'Bulk auto-unload all arrived bookings into the warehouse' })
+  autoUnloadArrived() {
+    return this.inventoryService.autoUnloadArrived();
+  }
+
+  @Post('auto-load-ready')
+  @ApiOperation({ summary: 'Auto-load READY_FOR_LOADING inventory with PAID bookings' })
+  autoLoadReady() {
+    return this.inventoryService.autoLoadReady();
+  }
+
+  @Post('bookings/:bookingId/unload')
+  @ApiOperation({ summary: 'Unload a single arrived booking into a location' })
+  unloadBooking(
+    @Param('bookingId', ParseUUIDPipe) bookingId: string,
+    @Body() dto: UnloadBookingDto,
+  ) {
+    return this.inventoryService.unloadBooking(bookingId, dto);
+  }
+
+  @Post(':id/gate-clearance')
+  @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('loadable-wagons')
+  @ApiOperation({ summary: 'List wagons usable for loading (read-only from scheduling)' })
+  loadableWagons() {
+    return this.scheduling.listLoadableWagons();
+  }
+
+  @Get('booking/:bookingId/schedule')
+  @ApiOperation({ summary: 'Read-only schedule + wagon + departure status for a booking' })
+  bookingSchedule(@Param('bookingId', ParseUUIDPipe) bookingId: string) {
+    return this.scheduling.getBookingSchedule(bookingId);
+  }
+
+  @Post('receive')
+  @ApiOperation({ summary: 'Receive inventory at a warehouse location' })
+  receive(@Body() dto: ReceiveWarehouseInventoryDto) {
+    return this.inventoryService.receive(dto);
+  }
+
+  @Post('reserve')
+  @ApiOperation({ summary: 'Reserve stored inventory for a PAID booking' })
+  reserve(@Body() dto: ReserveInventoryDto) {
+    return this.inventoryService.reserve(dto);
+  }
+
+  @Get(':id/movements')
+  @ApiOperation({ summary: 'Inventory movement history' })
+  movements(@Param('id', ParseUUIDPipe) id: string) {
+    return this.inventoryService.findMovements(id);
+  }
+
+  @Get(':id/activity')
+  @ApiOperation({ summary: 'Inventory activity log' })
+  activity(@Param('id', ParseUUIDPipe) id: string) {
+    return this.inventoryService.findActivity(id);
+  }
+
+  @Get(':id/loadings')
+  @ApiOperation({ summary: 'Loading records for an inventory item' })
+  loadings(@Param('id', ParseUUIDPipe) id: string) {
+    return this.inventoryService.findLoadingsByInventory(id);
+  }
+
+  @Post(':id/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')
+  @ApiOperation({ summary: 'Mark received inventory as STORED' })
+  store(@Param('id', ParseUUIDPipe) id: string, @Body('performedBy') performedBy?: string) {
+    return this.inventoryService.store(id, performedBy);
+  }
+
+  @Post(':id/ready-for-loading')
+  @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')
+  @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);
+  }
+
+  @Patch(':id/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.repository.ts b/apps/edr-freight-api/src/modules/warehouses/warehouse-inventory.repository.ts
new file mode 100644
index 000000000..4f249cf53
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/warehouses/warehouse-inventory.repository.ts
@@ -0,0 +1,13 @@
+import { BaseRepository } from '@edr/api-common';
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+
+import { WarehouseInventory } from './entities/warehouse-inventory.entity';
+
+@Injectable()
+export class WarehouseInventoryRepository extends BaseRepository<WarehouseInventory> {
+  constructor(@InjectRepository(WarehouseInventory) repository: Repository<WarehouseInventory>) {
+    super(repository);
+  }
+}
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
new file mode 100644
index 000000000..652be600c
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/warehouses/warehouse-inventory.service.ts
@@ -0,0 +1,940 @@
+import { BadRequestException, Injectable, NotFoundException } from '@nestjs/common';
+import { DataSource, EntityManager, FindManyOptions, ILike } from 'typeorm';
+
+import { FilterWarehouseInventoryDto } from './dto/filter-inventory.dto';
+import { InquiryWarehouseInventoryDto } from './dto/inquiry-inventory.dto';
+import { LoadInventoryDto } from './dto/load-inventory.dto';
+import { MoveInventoryDto } from './dto/move-inventory.dto';
+import { ReceiveWarehouseInventoryDto } from './dto/receive-inventory.dto';
+import { ReserveInventoryDto } from './dto/reserve-inventory.dto';
+import { UnloadBookingDto } from './dto/unload-booking.dto';
+import { WarehouseAllocationService } from './warehouse-allocation.service';
+import { WarehouseInvoiceService } from './warehouse-invoice.service';
+import { WarehouseActivityLog } from './entities/warehouse-activity-log.entity';
+import { WarehouseInventoryMovement } from './entities/warehouse-inventory-movement.entity';
+import {
+  WAREHOUSE_INVENTORY_TRANSITIONS,
+  WarehouseInventory,
+  WarehouseInventoryStatus,
+} from './entities/warehouse-inventory.entity';
+import { WarehouseLoading } from './entities/warehouse-loading.entity';
+import { WarehouseYard } from './entities/warehouse-yard.entity';
+import { WarehouseZone } from './entities/warehouse-zone.entity';
+import { Warehouse } from './entities/warehouse.entity';
+import { SchedulingReadFacade } from './scheduling-read.facade';
+import { WarehouseActivityLogService } from './warehouse-activity-log.service';
+import { WarehouseInventoryRepository } from './warehouse-inventory.repository';
+import { WarehouseLoadingRepository } from './warehouse-loading.repository';
+
+/** Wagon states that may receive a load (besides being part of an existing schedule). */
+const LOADABLE_WAGON_STATUSES = ['AVAILABLE', 'IMPORT_READY', 'EXPORT_READY', 'ASSIGNED'];
+
+export interface InventoryInquiryResult {
+  id: string;
+  bookingId: string | null;
+  bookingNumber: string | null;
+  customerName: string | null;
+  containerNumber: string | null;
+  cargoType: string | null;
+  cargoDescription: string | null;
+  goodsId: string | null;
+  warehouse: { id: string; name: string; code: string } | null;
+  yard: { id: string; name: string; code: string } | null;
+  zone: { id: string; name: string; code: string } | null;
+  status: string;
+  quantity: number;
+  weight: number;
+  arrivedAt: Date | null;
+  readyForLoadingAt: Date | null;
+}
+
+interface LocationNode {
+  maxWeight?: number | null;
+  capacityWeight?: number | null;
+  maxVolume?: number | null;
+  capacityContainers?: number | null;
+  currentWeight: number;
+  currentVolume: number;
+  currentContainers: number;
+}
+
+// ── Batch 4.5 result/queue shapes ────────────────────────────────────────────
+interface ArrivalQueueRow {
+  bookingId: string;
+  bookingReference: string;
+  customer: string | null;
+  cargo: string | null;
+  container: string | null;
+  arrivalDate: Date | null;
+  bookingStatus: string;
+  inventoryId: string | null;
+  currentStatus: string | null;
+  inspectionStatus: string | null;
+  facility: string | null;
+  warehouse: string | null;
+  yard: string | null;
+  zone: string | null;
+}
+
+export interface ArrivalQueueItem {
+  bookingId: string;
+  bookingReference: string;
+  customer: string | null;
+  cargo: string | null;
+  container: string | null;
+  facility: string | null;
+  warehouse: string | null;
+  yard: string | null;
+  zone: string | null;
+  inventoryId: string | null;
+  currentStatus: string | null;
+  arrivalDate: Date | null;
+  inspectionStatus: string | null;
+  unloaded: boolean;
+}
+
+interface DefaultLocation {
+  warehouseId: string;
+  yardId: string;
+  zoneId: string;
+  facilityId: string | null;
+}
+
+export interface AutoUnloadResult {
+  processedCount: number;
+  skippedCount: number;
+  failedCount: number;
+  results: { bookingId: string; inventoryId?: string; status: string; reason?: string }[];
+}
+
+export interface AutoLoadResult {
+  loadedCount: number;
+  skippedCount: number;
+  results: { inventoryId: string; status: string; reason?: string }[];
+}
+
+@Injectable()
+export class WarehouseInventoryService {
+  constructor(
+    private readonly dataSource: DataSource,
+    private readonly inventoryRepository: WarehouseInventoryRepository,
+    private readonly loadingRepository: WarehouseLoadingRepository,
+    private readonly activityLog: WarehouseActivityLogService,
+    private readonly scheduling: SchedulingReadFacade,
+    private readonly allocation: WarehouseAllocationService,
+    private readonly invoices: WarehouseInvoiceService,
+  ) {}
+
+  /**
+   * Batch 6 — final terminal release / gate clearance.
+   * Blocked while an unpaid demurrage/storage invoice exists. Does NOT touch
+   * inspection / storage / loading steps — only the final release.
+   */
+  async gateClearance(id: string, performedBy?: string): Promise<WarehouseInventory> {
+    const item = await this.findById(id);
+    const blocking = await this.invoices.findBlockingInvoice(id);
+    if (blocking) {
+      throw new BadRequestException(
+        'Warehouse demurrage/storage fee must be paid before terminal release.',
+      );
+    }
+    const now = new Date();
+    await this.inventoryRepository.update(id, {
+      gateClearedAt: now,
+      releaseDate: item.releaseDate ?? now,
+    });
+    await this.activityLog.record({
+      activityType: 'INVENTORY_DISPATCHED',
+      inventoryId: id,
+      warehouseId: item.warehouseId,
+      description: 'Gate clearance / terminal release',
+      performedBy,
+    });
+    return this.findById(id);
+  }
+
+  // ── Listing ────────────────────────────────────────────────────────────
+
+  findAll(filter: FilterWarehouseInventoryDto): Promise<WarehouseInventory[]> {
+    const base = {
+      ...(filter.warehouseId ? { warehouseId: filter.warehouseId } : {}),
+      ...(filter.yardId ? { yardId: filter.yardId } : {}),
+      ...(filter.zoneId ? { zoneId: filter.zoneId } : {}),
+      ...(filter.bookingId ? { bookingId: filter.bookingId } : {}),
+      ...(filter.cargoId ? { cargoId: filter.cargoId } : {}),
+      ...(filter.containerId ? { containerId: filter.containerId } : {}),
+      ...(filter.goodsId ? { goodsId: filter.goodsId } : {}),
+      ...(filter.status ? { status: filter.status } : {}),
+    };
+
+    const search = filter.search?.trim();
+    const where: FindManyOptions<WarehouseInventory>['where'] = search
+      ? { ...base, notes: ILike(`%${search}%`) }
+      : base;
+
+    return this.inventoryRepository.findAll({
+      where,
+      relations: { warehouse: { facility: true }, yard: true, zone: true, booking: true },
+      order: { createdAt: 'DESC' },
+    });
+  }
+
+  findReadyForLoading(filter: FilterWarehouseInventoryDto): Promise<WarehouseInventory[]> {
+    return this.findAll({ ...filter, status: 'READY_FOR_LOADING' });
+  }
+
+  async findById(id: string): Promise<WarehouseInventory> {
+    const item = await this.inventoryRepository.findById(id, {
+      relations: { warehouse: true, yard: true, zone: true },
+    });
+
+    if (!item) {
+      throw new NotFoundException(`Inventory item ${id} not found`);
+    }
+
+    return item;
+  }
+
+  // ── Batch 4.5: Arrival / Unload / Load automation ──────────────────────────
+
+  /** Bookings whose goods have arrived and may be unloaded into the warehouse. */
+  private readonly ARRIVED_BOOKING_STATUSES = ['IN_TRANSIT'];
+
+  /** Arrived bookings + their current inventory/inspection state (queue view). */
+  async arrivalQueue(): Promise<ArrivalQueueItem[]> {
+    const rows: ArrivalQueueRow[] = await this.dataSource.query(
+      `SELECT b.id            AS "bookingId",
+              b.reference      AS "bookingReference",
+              company.name     AS "customer",
+              b.cargo_free_text AS "cargo",
+              ct.container_number AS "container",
+              b.scheduled_date AS "arrivalDate",
+              b.status         AS "bookingStatus",
+              inv.id           AS "inventoryId",
+              inv.status       AS "currentStatus",
+              inv.inspection_status AS "inspectionStatus",
+              fac.name         AS "facility",
+              wh.name          AS "warehouse",
+              yard.name        AS "yard",
+              zone.name        AS "zone"
+         FROM freight.bookings b
+         LEFT JOIN freight.companies company ON company.id = b.company_id
+         LEFT JOIN freight.warehouse_inventory inv ON inv.booking_id = b.id AND inv.deleted_at IS NULL
+         LEFT JOIN freight.warehouses wh ON wh.id = inv.warehouse_id
+         LEFT JOIN freight.warehouse_yards yard ON yard.id = inv.yard_id
+         LEFT JOIN freight.warehouse_zones zone ON zone.id = inv.zone_id
+         LEFT JOIN freight.facilities fac ON fac.id = wh.facility_id
+         LEFT JOIN freight.containers ct ON ct.id = inv.container_id
+        WHERE b.status = ANY($1) AND b.deleted_at IS NULL
+        ORDER BY b.scheduled_date DESC NULLS LAST`,
+      [this.ARRIVED_BOOKING_STATUSES],
+    );
+
+    return rows.map((r) => ({
+      bookingId: r.bookingId,
+      bookingReference: r.bookingReference,
+      customer: r.customer ?? null,
+      cargo: r.cargo ?? null,
+      container: r.container ?? null,
+      facility: r.facility ?? null,
+      warehouse: r.warehouse ?? null,
+      yard: r.yard ?? null,
+      zone: r.zone ?? null,
+      inventoryId: r.inventoryId ?? null,
+      currentStatus: r.currentStatus ?? null,
+      arrivalDate: r.arrivalDate ?? null,
+      inspectionStatus: r.inspectionStatus ?? null,
+      unloaded: Boolean(r.inventoryId),
+    }));
+  }
+
+  /** First warehouse that has at least one yard + zone (fallback location for auto-unload). */
+  private async pickDefaultLocation(): Promise<DefaultLocation | null> {
+    const [row]: DefaultLocation[] = await this.dataSource.query(
+      `SELECT wh.id AS "warehouseId", wh.facility_id AS "facilityId",
+              yard.id AS "yardId", zone.id AS "zoneId"
+         FROM freight.warehouses wh
+         JOIN freight.warehouse_yards yard ON yard.warehouse_id = wh.id AND yard.deleted_at IS NULL
+         JOIN freight.warehouse_zones zone ON zone.yard_id = yard.id AND zone.deleted_at IS NULL
+        WHERE wh.deleted_at IS NULL
+        ORDER BY wh.created_at ASC
+        LIMIT 1`,
+    );
+    return row ?? null;
+  }
+
+  /** Bulk-create inventory (RECEIVED) for arrived bookings that are not yet unloaded. */
+  async autoUnloadArrived(): Promise<AutoUnloadResult> {
+    const arrived: {
+      id: string;
+      weight: string | null;
+      freightType: string | null;
+      tradeDirection: string | null;
+      cargoTypeCode: string | null;
+    }[] = await this.dataSource.query(
+      `SELECT b.id, b.cargo_total_weight_vgm AS weight,
+              b.freight_type AS "freightType", b.trade_direction AS "tradeDirection",
+              cgt.code AS "cargoTypeCode"
+         FROM freight.bookings b
+         LEFT JOIN freight.warehouse_inventory inv ON inv.booking_id = b.id AND inv.deleted_at IS NULL
+         LEFT JOIN freight.cargo_types cgt ON cgt.id = b.cargo_type_id
+        WHERE b.status = ANY($1) AND b.deleted_at IS NULL AND inv.id IS NULL`,
+      [this.ARRIVED_BOOKING_STATUSES],
+    );
+
+    const result: AutoUnloadResult = { processedCount: 0, skippedCount: 0, failedCount: 0, results: [] };
+
+    if (arrived.length === 0) return result;
+
+    const fallback = await this.pickDefaultLocation();
+
+    for (const booking of arrived) {
+      try {
+        // Deterministic allocation by rules; fall back to default location if no rule resolves.
+        const allocated = await this.allocation.resolveLocation({
+          freightType: booking.freightType,
+          tradeDirection: booking.tradeDirection,
+          cargoTypeCode: booking.cargoTypeCode,
+        });
+        const location = allocated ?? fallback;
+        if (!location) {
+          result.failedCount += 1;
+          result.results.push({ bookingId: booking.id, status: 'FAILED', reason: 'No warehouse/yard/zone configured' });
+          continue;
+        }
+        const saved = await this.inventoryRepository.create({
+          warehouseId: location.warehouseId,
+          yardId: location.yardId,
+          zoneId: location.zoneId,
+          bookingId: booking.id,
+          quantity: 1,
+          weight: Number(booking.weight) || 0,
+          status: 'RECEIVED',
+          arrivedAt: new Date(),
+          notes: allocated?.rule ? `Auto-unloaded → ${allocated.path}` : 'Auto-unloaded from arrival queue',
+        });
+        result.processedCount += 1;
+        result.results.push({ bookingId: booking.id, inventoryId: saved.id, status: 'PROCESSED' });
+      } catch (error) {
+        result.failedCount += 1;
+        result.results.push({
+          bookingId: booking.id,
+          status: 'FAILED',
+          reason: error instanceof Error ? error.message : String(error),
+        });
+      }
+    }
+
+    return result;
+  }
+
+  /** Unload a single arrived booking into a chosen (or default) location. */
+  async unloadBooking(bookingId: string, dto: UnloadBookingDto): Promise<WarehouseInventory> {
+    const existing = await this.inventoryRepository.findAll({ where: { bookingId } });
+
+    let location: DefaultLocation | null =
+      dto.warehouseId && dto.yardId && dto.zoneId
+        ? { warehouseId: dto.warehouseId, yardId: dto.yardId, zoneId: dto.zoneId, facilityId: dto.facilityId ?? null }
+        : null;
+    if (!location) location = await this.pickDefaultLocation();
+    if (!location) {
+      throw new BadRequestException('No warehouse/yard/zone provided or configured for unloading');
+    }
+
+    const arrivedAt = dto.unloadedAt ? new Date(dto.unloadedAt) : new Date();
+
+    if (existing[0]) {
+      await this.inventoryRepository.update(existing[0].id, {
+        warehouseId: location.warehouseId,
+        yardId: location.yardId,
+        zoneId: location.zoneId,
+        status: 'RECEIVED',
+        arrivedAt,
+        notes: dto.notes ?? existing[0].notes ?? 'Unloaded',
+      });
+      return this.findById(existing[0].id);
+    }
+
+    const saved = await this.inventoryRepository.create({
+      warehouseId: location.warehouseId,
+      yardId: location.yardId,
+      zoneId: location.zoneId,
+      bookingId,
+      quantity: 1,
+      weight: 0,
+      status: 'RECEIVED',
+      arrivedAt,
+      notes: dto.notes ?? 'Unloaded',
+    });
+    return this.findById(saved.id);
+  }
+
+  /** Auto-load all READY_FOR_LOADING inventory whose booking is PAID. Unpaid stay pending. */
+  async autoLoadReady(): Promise<AutoLoadResult> {
+    const ready = await this.inventoryRepository.findAll({ where: { status: 'READY_FOR_LOADING' } });
+    const result: AutoLoadResult = { loadedCount: 0, skippedCount: 0, results: [] };
+
+    for (const item of ready) {
+      const bookingStatus = item.bookingId ? await this.getBookingStatus(item.bookingId) : null;
+      if (bookingStatus !== 'PAID') {
+        result.skippedCount += 1;
+        result.results.push({ inventoryId: item.id, status: 'SKIPPED', reason: 'Booking not PAID' });
+        continue;
+      }
+      await this.dataSource.transaction(async (manager) => {
+        await manager.getRepository(WarehouseInventory).update(item.id, {
+          status: 'LOADED',
+          loadedAt: new Date(),
+        });
+        await this.activityLog.record(
+          {
+            activityType: 'INVENTORY_LOADED',
+            inventoryId: item.id,
+            warehouseId: item.warehouseId,
+            description: 'Auto-loaded (PAID booking)',
+          },
+          manager,
+        );
+      });
+      result.loadedCount += 1;
+      result.results.push({ inventoryId: item.id, status: 'LOADED' });
+    }
+
+    return result;
+  }
+
+  // ── Receive ──────────────────────────────────────────────────────────────
+
+  async receive(dto: ReceiveWarehouseInventoryDto): Promise<WarehouseInventory> {
+    const weight = Number(dto.weight) || 0;
+    const volume = Number(dto.volume) || 0;
+    const containerCount = dto.containerId ? Math.round(Number(dto.quantity) || 0) : 0;
+
+    const id = await this.dataSource.transaction(async (manager) => {
+      const { warehouse, yard, zone } = await this.validateLocation(manager, dto);
+
+      if (dto.bookingId) {
+        await this.assertBookingExists(manager, dto.bookingId);
+      }
+
+      this.assertCapacity('Warehouse', warehouse, weight, volume, containerCount);
+      this.assertCapacity('Yard', yard, weight, volume, containerCount);
+      this.assertCapacity('Zone', zone, weight, volume, containerCount);
+
+      const now = new Date();
+      const saved = await manager.getRepository(WarehouseInventory).save(
+        manager.getRepository(WarehouseInventory).create({
+          warehouseId: dto.warehouseId,
+          yardId: dto.yardId,
+          zoneId: dto.zoneId,
+          bookingId: dto.bookingId ?? null,
+          cargoId: dto.cargoId ?? null,
+          containerId: dto.containerId ?? null,
+          goodsId: dto.goodsId ?? null,
+          quantity: Number(dto.quantity) || 0,
+          weight,
+          volume: dto.volume ?? null,
+          status: 'RECEIVED',
+          arrivedAt: now,
+          notes: dto.notes?.trim() ?? null,
+        }),
+      );
+
+      await this.applyCapacityDelta(manager, dto.warehouseId, dto.yardId, dto.zoneId, weight, volume, containerCount, +1);
+
+      await this.activityLog.record(
+        {
+          activityType: 'INVENTORY_RECEIVED',
+          inventoryId: saved.id,
+          warehouseId: dto.warehouseId,
+          description: `Received ${weight}kg at warehouse location`,
+          performedBy: dto.performedBy,
+        },
+        manager,
+      );
+
+      return saved.id;
+    });
+
+    return this.findById(id);
+  }
+
+  // ── Lifecycle transitions ────────────────────────────────────────────────
+
+  store(id: string, performedBy?: string): Promise<WarehouseInventory> {
+    return this.transition(id, 'STORED', {
+      timestampField: 'storedAt',
+      activityType: 'INVENTORY_STORED',
+      description: 'Inventory stored',
+      performedBy,
+    });
+  }
+
+  async reserve(dto: ReserveInventoryDto): Promise<WarehouseInventory> {
+    const item = await this.findById(dto.inventoryId);
+
+    if (item.status !== 'STORED') {
+      throw new BadRequestException(`Inventory must be STORED to reserve (current: ${item.status})`);
+    }
+
+    const status = await this.getBookingStatus(dto.bookingId);
+    if (!status) {
+      throw new NotFoundException(`Booking ${dto.bookingId} not found`);
+    }
+    if (status !== 'PAID') {
+      throw new BadRequestException(`Booking must be PAID to reserve inventory (current: ${status})`);
+    }
+
+    await this.dataSource.transaction(async (manager) => {
+      await manager.getRepository(WarehouseInventory).update(dto.inventoryId, {
+        status: 'RESERVED',
+        bookingId: dto.bookingId,
+        reservedAt: new Date(),
+      });
+      await this.activityLog.record(
+        {
+          activityType: 'INVENTORY_RESERVED',
+          inventoryId: dto.inventoryId,
+          warehouseId: item.warehouseId,
+          description: `Reserved for booking ${dto.bookingId}`,
+          performedBy: dto.performedBy,
+        },
+        manager,
+      );
+    });
+
+    return this.findById(dto.inventoryId);
+  }
+
+  async readyForLoading(id: string, performedBy?: string): Promise<WarehouseInventory> {
+    const item = await this.findById(id);
+    if (!item.bookingId || !item.warehouseId || !item.yardId || !item.zoneId) {
+      throw new BadRequestException('Inventory must have booking, warehouse, yard and zone before loading prep');
+    }
+    return this.transition(id, 'READY_FOR_LOADING', {
+      timestampField: 'readyForLoadingAt',
+      activityType: 'READY_FOR_LOADING',
+      description: 'Inventory ready for loading',
+      performedBy,
+      preloaded: item,
+    });
+  }
+
+  /**
+   * Load READY_FOR_LOADING inventory onto a wagon. Creates a WarehouseLoading record.
+   * Reads wagon/schedule data read-only — never modifies scheduling.
+   */
+  async load(id: string, dto: LoadInventoryDto): Promise<WarehouseInventory> {
+    const item = await this.findById(id);
+
+    // 1. inventory status must be READY_FOR_LOADING (and not already LOADED).
+    this.assertTransition(item.status, 'LOADED');
+
+    // 2. inventory is at a valid warehouse/yard/zone location.
+    if (!item.warehouseId || !item.yardId || !item.zoneId) {
+      throw new BadRequestException('Inventory must be at a warehouse/yard/zone before loading');
+    }
+
+    // 3. wagon must exist.
+    const wagon = await this.scheduling.findWagon(dto.wagonId);
+    if (!wagon) {
+      throw new NotFoundException(`Wagon ${dto.wagonId} not found`);
+    }
+
+    // 4. wagon must be available, or already selected by an existing train schedule.
+    const scheduled = await this.scheduling.isWagonScheduled(dto.wagonId);
+    if (!LOADABLE_WAGON_STATUSES.includes(wagon.status) && !scheduled) {
+      throw new BadRequestException(
+        `Wagon ${wagon.wagonNumber} is not available for loading (status: ${wagon.status})`,
+      );
+    }
+
+    // 5. inventory must not already have a loading record.
+    const existing = await this.loadingRepository.findAll({ where: { warehouseInventoryId: id } });
+    if (existing.length > 0) {
+      throw new BadRequestException('Inventory has already been loaded');
+    }
+
+    const loadedWeight = dto.loadedWeight ?? (Number(item.weight) || 0);
+
+    await this.dataSource.transaction(async (manager) => {
+      const now = new Date();
+      await manager.getRepository(WarehouseInventory).update(id, {
+        status: 'LOADED',
+        loadedAt: now,
+      });
+
+      await manager.getRepository(WarehouseLoading).save(
+        manager.getRepository(WarehouseLoading).create({
+          warehouseInventoryId: id,
+          bookingId: item.bookingId ?? null,
+          wagonId: dto.wagonId,
+          loadedAt: now,
+          loadedBy: dto.loadedBy ?? null,
+          loadedWeight,
+          notes: dto.notes?.trim() ?? null,
+        }),
+      );
+
+      await this.activityLog.record(
+        {
+          activityType: 'INVENTORY_LOADED',
+          inventoryId: id,
+          warehouseId: item.warehouseId,
+          description: `Loaded onto wagon ${wagon.wagonNumber}`,
+          performedBy: dto.loadedBy,
+        },
+        manager,
+      );
+    });
+
+    return this.findById(id);
+  }
+
+  // ── Loading records (Batch 3) ─────────────────────────────────────────────
+
+  async findLoadings(
+    filter: { bookingId?: string; wagonId?: string },
+  ): Promise<Array<WarehouseLoading & { wagonNumber: string | null }>> {
+    const where = {
+      ...(filter.bookingId ? { bookingId: filter.bookingId } : {}),
+      ...(filter.wagonId ? { wagonId: filter.wagonId } : {}),
+    };
+    const loadings = await this.loadingRepository.findAll({
+      where,
+      relations: { inventory: { warehouse: true, yard: true, zone: true } },
+      order: { loadedAt: 'DESC' },
+    });
+
+    // Enrich with wagon numbers (read-only lookup into the scheduling domain).
+    const wagonIds = [...new Set(loadings.map((l) => l.wagonId))];
+    const wagonNumbers = new Map<string, string>();
+    if (wagonIds.length > 0) {
+      const rows: Array<{ id: string; wagon_number: string }> = await this.dataSource.query(
+        'SELECT id, wagon_number FROM freight.wagons WHERE id = ANY($1)',
+        [wagonIds],
+      );
+      rows.forEach((r) => wagonNumbers.set(r.id, r.wagon_number));
+    }
+
+    return loadings.map((loading) =>
+      Object.assign(loading, { wagonNumber: wagonNumbers.get(loading.wagonId) ?? null }),
+    );
+  }
+
+  findLoadingsByInventory(inventoryId: string): Promise<WarehouseLoading[]> {
+    return this.loadingRepository.findAll({
+      where: { warehouseInventoryId: inventoryId },
+      order: { loadedAt: 'DESC' },
+    });
+  }
+
+  async dispatch(id: string, performedBy?: string): Promise<WarehouseInventory> {
+    const item = await this.findById(id);
+    this.assertTransition(item.status, 'DISPATCHED');
+
+    const weight = Number(item.weight) || 0;
+    const volume = Number(item.volume) || 0;
+    const containerCount = item.containerId ? Math.round(Number(item.quantity) || 0) : 0;
+
+    await this.dataSource.transaction(async (manager) => {
+      await manager.getRepository(WarehouseInventory).update(id, {
+        status: 'DISPATCHED',
+        dispatchedAt: new Date(),
+      });
+      // Item physically leaves the warehouse — free up capacity.
+      await this.applyCapacityDelta(manager, item.warehouseId, item.yardId, item.zoneId, weight, volume, containerCount, -1);
+      await this.activityLog.record(
+        {
+          activityType: 'INVENTORY_DISPATCHED',
+          inventoryId: id,
+          warehouseId: item.warehouseId,
+          description: 'Inventory dispatched',
+          performedBy,
+        },
+        manager,
+      );
+    });
+
+    return this.findById(id);
+  }
+
+  // ── Movement ──────────────────────────────────────────────────────────────
+
+  async move(id: string, dto: MoveInventoryDto): Promise<WarehouseInventory> {
+    const item = await this.findById(id);
+    if (item.status === 'DISPATCHED') {
+      throw new BadRequestException('Dispatched inventory cannot be moved');
+    }
+
+    const weight = Number(item.weight) || 0;
+    const volume = Number(item.volume) || 0;
+    const containerCount = item.containerId ? Math.round(Number(item.quantity) || 0) : 0;
+
+    const from = { warehouseId: item.warehouseId, yardId: item.yardId, zoneId: item.zoneId };
+
+    await this.dataSource.transaction(async (manager) => {
+      const { warehouse } = await this.validateLocation(manager, dto);
+
+      // Capacity check at the destination (item is added there).
+      const dest = await this.loadLocation(manager, dto);
+      this.assertCapacity('Warehouse', dest.warehouse, weight, volume, containerCount);
+      this.assertCapacity('Yard', dest.yard, weight, volume, containerCount);
+      this.assertCapacity('Zone', dest.zone, weight, volume, containerCount);
+
+      // Free the old location, occupy the new one.
+      await this.applyCapacityDelta(manager, from.warehouseId, from.yardId, from.zoneId, weight, volume, containerCount, -1);
+      await this.applyCapacityDelta(manager, dto.warehouseId, dto.yardId, dto.zoneId, weight, volume, containerCount, +1);
+
+      await manager.getRepository(WarehouseInventory).update(id, {
+        warehouseId: dto.warehouseId,
+        yardId: dto.yardId,
+        zoneId: dto.zoneId,
+      });
+
+      await manager.getRepository(WarehouseInventoryMovement).save(
+        manager.getRepository(WarehouseInventoryMovement).create({
+          inventoryId: id,
+          fromWarehouseId: from.warehouseId,
+          fromYardId: from.yardId,
+          fromZoneId: from.zoneId,
+          toWarehouseId: dto.warehouseId,
+          toYardId: dto.yardId,
+          toZoneId: dto.zoneId,
+          remarks: dto.remarks?.trim() ?? null,
+          movedBy: dto.movedBy ?? 'system',
+          movedAt: new Date(),
+        }),
+      );
+
+      await this.activityLog.record(
+        {
+          activityType: 'INVENTORY_MOVED',
+          inventoryId: id,
+          warehouseId: warehouse.id,
+          description: dto.remarks?.trim() || 'Inventory moved',
+          performedBy: dto.movedBy,
+        },
+        manager,
+      );
+    });
+
+    return this.findById(id);
+  }
+
+  findMovements(id: string): Promise<WarehouseInventoryMovement[]> {
+    return this.dataSource.getRepository(WarehouseInventoryMovement).find({
+      where: { inventoryId: id },
+      order: { movedAt: 'DESC' },
+    });
+  }
+
+  findActivity(id: string): Promise<WarehouseActivityLog[]> {
+    return this.activityLog.findByInventory(id);
+  }
+
+  // ── Inquiry (Batch 1) ──────────────────────────────────────────────────
+
+  async inquiry(filter: InquiryWarehouseInventoryDto): Promise<InventoryInquiryResult[]> {
+    const qb = this.dataSource
+      .getRepository(WarehouseInventory)
+      .createQueryBuilder('inv')
+      .leftJoinAndSelect('inv.warehouse', 'warehouse')
+      .leftJoinAndSelect('inv.yard', 'yard')
+      .leftJoinAndSelect('inv.zone', 'zone')
+      .leftJoin('freight.bookings', 'booking', 'booking.id = inv.booking_id')
+      .leftJoin('freight.companies', 'company', 'company.id = booking.company_id')
+      .leftJoin('freight.containers', 'container', 'container.id = inv.container_id')
+      .leftJoin('freight.cargoes', 'cargo', 'cargo.id = inv.cargo_id')
+      .leftJoin('freight.cargo_types', 'cargo_type', 'cargo_type.id = cargo.cargo_type_id')
+      .addSelect('booking.reference', 'b_reference')
+      .addSelect('company.name', 'c_name')
+      .addSelect('container.container_number', 'ct_number')
+      .addSelect('cargo.description', 'cg_description')
+      .addSelect('cargo_type.cargo_type_name', 'cgt_name')
+      .orderBy('inv.created_at', 'DESC');
+
+    if (filter.bookingNumber?.trim()) {
+      qb.andWhere('booking.reference ILIKE :bn', { bn: `%${filter.bookingNumber.trim()}%` });
+    }
+    if (filter.containerNumber?.trim()) {
+      qb.andWhere('container.container_number ILIKE :cn', { cn: `%${filter.containerNumber.trim()}%` });
+    }
+    if (filter.cargoType?.trim()) {
+      qb.andWhere('cargo_type.cargo_type_name ILIKE :ctype', { ctype: `%${filter.cargoType.trim()}%` });
+    }
+    if (filter.goodsName?.trim()) {
+      qb.andWhere('(inv.notes ILIKE :gn OR cargo.description ILIKE :gn)', { gn: `%${filter.goodsName.trim()}%` });
+    }
+    if (filter.warehouseId) qb.andWhere('inv.warehouse_id = :wid', { wid: filter.warehouseId });
+    if (filter.yardId) qb.andWhere('inv.yard_id = :yid', { yid: filter.yardId });
+    if (filter.zoneId) qb.andWhere('inv.zone_id = :zid', { zid: filter.zoneId });
+    if (filter.status) qb.andWhere('inv.status = :status', { status: filter.status });
+
+    const { entities, raw } = await qb.getRawAndEntities();
+
+    return entities.map((inv, index) => {
+      const row = raw[index] ?? {};
+      return {
+        id: inv.id,
+        bookingId: inv.bookingId ?? null,
+        bookingNumber: row.b_reference ?? null,
+        customerName: row.c_name ?? null,
+        containerNumber: row.ct_number ?? null,
+        cargoType: row.cgt_name ?? null,
+        cargoDescription: row.cg_description ?? null,
+        goodsId: inv.goodsId ?? null,
+        warehouse: inv.warehouse
+          ? { id: inv.warehouse.id, name: inv.warehouse.name, code: inv.warehouse.code }
+          : null,
+        yard: inv.yard ? { id: inv.yard.id, name: inv.yard.name, code: inv.yard.code } : null,
+        zone: inv.zone ? { id: inv.zone.id, name: inv.zone.name, code: inv.zone.code } : null,
+        status: inv.status,
+        quantity: Number(inv.quantity),
+        weight: Number(inv.weight),
+        arrivedAt: inv.arrivedAt ?? null,
+        readyForLoadingAt: inv.readyForLoadingAt ?? null,
+      };
+    });
+  }
+
+  // ── Helpers ──────────────────────────────────────────────────────────────
+
+  private async transition(
+    id: string,
+    to: WarehouseInventoryStatus,
+    opts: {
+      timestampField: keyof WarehouseInventory;
+      activityType: Parameters<WarehouseActivityLogService['record']>[0]['activityType'];
+      description: string;
+      performedBy?: string;
+      preloaded?: WarehouseInventory;
+    },
+  ): Promise<WarehouseInventory> {
+    const item = opts.preloaded ?? (await this.findById(id));
+    this.assertTransition(item.status, to);
+
+    await this.dataSource.transaction(async (manager) => {
+      await manager.getRepository(WarehouseInventory).update(id, {
+        status: to,
+        [opts.timestampField]: new Date(),
+      });
+      await this.activityLog.record(
+        {
+          activityType: opts.activityType,
+          inventoryId: id,
+          warehouseId: item.warehouseId,
+          description: opts.description,
+          performedBy: opts.performedBy,
+        },
+        manager,
+      );
+    });
+
+    return this.findById(id);
+  }
+
+  private assertTransition(from: WarehouseInventoryStatus, to: WarehouseInventoryStatus): void {
+    if (!WAREHOUSE_INVENTORY_TRANSITIONS[from]?.includes(to)) {
+      throw new BadRequestException(`Invalid transition ${from} → ${to}`);
+    }
+  }
+
+  private async validateLocation(
+    manager: EntityManager,
+    dto: { warehouseId: string; yardId: string; zoneId: string },
+  ): Promise<{ warehouse: Warehouse; yard: WarehouseYard; zone: WarehouseZone }> {
+    const { warehouse, yard, zone } = await this.loadLocation(manager, dto);
+
+    if (warehouse.status !== 'ACTIVE') throw new BadRequestException('Warehouse is not ACTIVE');
+    if (yard.warehouseId !== warehouse.id) throw new BadRequestException('Yard does not belong to the selected warehouse');
+    if (yard.status !== 'ACTIVE') throw new BadRequestException('Yard is not ACTIVE');
+    if (zone.yardId !== yard.id) throw new BadRequestException('Zone does not belong to the selected yard');
+    if (zone.status !== 'ACTIVE') throw new BadRequestException('Zone is not ACTIVE');
+
+    return { warehouse, yard, zone };
+  }
+
+  private async loadLocation(
+    manager: EntityManager,
+    dto: { warehouseId: string; yardId: string; zoneId: string },
+  ): Promise<{ warehouse: Warehouse; yard: WarehouseYard; zone: WarehouseZone }> {
+    const warehouse = await manager.getRepository(Warehouse).findOne({ where: { id: dto.warehouseId } });
+    if (!warehouse) throw new NotFoundException(`Warehouse ${dto.warehouseId} not found`);
+    const yard = await manager.getRepository(WarehouseYard).findOne({ where: { id: dto.yardId } });
+    if (!yard) throw new NotFoundException(`Yard ${dto.yardId} not found`);
+    const zone = await manager.getRepository(WarehouseZone).findOne({ where: { id: dto.zoneId } });
+    if (!zone) throw new NotFoundException(`Zone ${dto.zoneId} not found`);
+    return { warehouse, yard, zone };
+  }
+
+  private async assertBookingExists(manager: EntityManager, bookingId: string): Promise<void> {
+    const rows = await manager.query(
+      'SELECT id FROM freight.bookings WHERE id = $1 AND deleted_at IS NULL LIMIT 1',
+      [bookingId],
+    );
+    if (!rows || rows.length === 0) {
+      throw new NotFoundException(`Booking ${bookingId} not found`);
+    }
+  }
+
+  private async getBookingStatus(bookingId: string): Promise<string | null> {
+    const rows = await this.dataSource.query(
+      'SELECT status FROM freight.bookings WHERE id = $1 AND deleted_at IS NULL LIMIT 1',
+      [bookingId],
+    );
+    return rows?.[0]?.status ?? null;
+  }
+
+  private assertCapacity(
+    label: string,
+    node: LocationNode,
+    weightAdd: number,
+    volumeAdd: number,
+    containerAdd: number,
+  ): void {
+    const maxWeight = node.maxWeight ?? node.capacityWeight;
+    if (maxWeight != null) {
+      const projected = Number(node.currentWeight) + weightAdd;
+      if (projected > Number(maxWeight)) {
+        throw new BadRequestException(`${label} weight capacity exceeded (${projected} / ${maxWeight})`);
+      }
+    }
+    if (node.maxVolume != null && volumeAdd > 0) {
+      const projected = Number(node.currentVolume) + volumeAdd;
+      if (projected > Number(node.maxVolume)) {
+        throw new BadRequestException(`${label} volume capacity exceeded (${projected} / ${node.maxVolume})`);
+      }
+    }
+    if (node.capacityContainers != null && containerAdd > 0) {
+      const projected = Number(node.currentContainers) + containerAdd;
+      if (projected > Number(node.capacityContainers)) {
+        throw new BadRequestException(`${label} container capacity exceeded (${projected} / ${node.capacityContainers})`);
+      }
+    }
+  }
+
+  private async applyCapacityDelta(
+    manager: EntityManager,
+    warehouseId: string,
+    yardId: string,
+    zoneId: string,
+    weight: number,
+    volume: number,
+    containers: number,
+    sign: 1 | -1,
+  ): Promise<void> {
+    const apply = sign === 1 ? manager.increment.bind(manager) : manager.decrement.bind(manager);
+    const targets: Array<[typeof Warehouse | typeof WarehouseYard | typeof WarehouseZone, string]> = [
+      [Warehouse, warehouseId],
+      [WarehouseYard, yardId],
+      [WarehouseZone, zoneId],
+    ];
+
+    for (const [entity, id] of targets) {
+      if (weight) await apply(entity, { id }, 'currentWeight', weight);
+      if (volume) await apply(entity, { id }, 'currentVolume', volume);
+      if (containers) await apply(entity, { id }, 'currentContainers', containers);
+    }
+  }
+}
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
new file mode 100644
index 000000000..da818b5a3
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/warehouses/warehouse-invoice.controller.ts
@@ -0,0 +1,68 @@
+import { Body, Controller, Get, Param, ParseUUIDPipe, Patch, Post, Query } from '@nestjs/common';
+import { ApiBearerAuth, ApiOperation, ApiTags } from '@nestjs/swagger';
+
+import { GenerateInvoiceDto, PayInvoiceBodyDto } from './dto/invoice.dto';
+import { WarehouseInvoiceService } from './warehouse-invoice.service';
+
+@ApiTags('warehouse-fee-invoices')
+@ApiBearerAuth()
+@Controller()
+export class WarehouseInvoiceController {
+  constructor(private readonly invoiceService: WarehouseInvoiceService) {}
+
+  @Post('warehouse-inventory/:id/generate-fee-invoice')
+  @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);
+  }
+
+  @Get('warehouse-inventory/:id/fee-invoices')
+  @ApiOperation({ summary: 'List fee invoices for an inventory item' })
+  listForInventory(@Param('id', ParseUUIDPipe) id: string) {
+    return this.invoiceService.listForInventory(id);
+  }
+
+  @Get('bookings/:id/warehouse-fee-invoices')
+  @ApiOperation({ summary: 'List warehouse fee invoices for a booking' })
+  listForBooking(@Param('id', ParseUUIDPipe) id: string) {
+    return this.invoiceService.listForBooking(id);
+  }
+
+  @Get('warehouse-fee-invoices')
+  @ApiOperation({ summary: 'List / filter warehouse fee invoices' })
+  findAll(
+    @Query('status') status?: string,
+    @Query('invoiceType') invoiceType?: string,
+    @Query('warehouseId') warehouseId?: string,
+    @Query('facilityId') facilityId?: string,
+    @Query('customerId') customerId?: string,
+    @Query('bookingId') bookingId?: string,
+  ) {
+    return this.invoiceService.findAll({
+      status: status as never,
+      invoiceType: invoiceType as never,
+      warehouseId,
+      facilityId,
+      customerId,
+      bookingId,
+    });
+  }
+
+  @Get('warehouse-fee-invoices/:id')
+  @ApiOperation({ summary: 'Get a warehouse fee invoice with items + payment history' })
+  findOne(@Param('id', ParseUUIDPipe) id: string) {
+    return this.invoiceService.findById(id);
+  }
+
+  @Patch('warehouse-fee-invoices/:id/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')
+  @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-invoice.service.ts b/apps/edr-freight-api/src/modules/warehouses/warehouse-invoice.service.ts
new file mode 100644
index 000000000..d58a74b7d
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/warehouses/warehouse-invoice.service.ts
@@ -0,0 +1,214 @@
+import { BadRequestException, ConflictException, Injectable, NotFoundException } from '@nestjs/common';
+import { DataSource } from 'typeorm';
+
+import {
+  WarehouseFeeInvoice,
+  WarehouseInvoiceStatus,
+  WarehouseInvoiceType,
+} from './entities/warehouse-fee-invoice.entity';
+import { WarehouseFeeType } from './entities/warehouse-fee-invoice-item.entity';
+import { WarehouseFeeInvoiceItemRepository } from './warehouse-fee-invoice-item.repository';
+import { WarehouseFeeInvoiceRepository } from './warehouse-fee-invoice.repository';
+import { WarehouseFeeService } from './warehouse-fee.service';
+
+interface GenerateOptions {
+  confirmZero?: boolean;
+  performedBy?: string;
+}
+
+export interface PayInvoiceDto {
+  amount: number;
+  method?: string;
+  reference?: string;
+}
+
+/** Invoices that still owe money and therefore block terminal release. */
+const BLOCKING_STATUSES: WarehouseInvoiceStatus[] = ['ISSUED', 'PARTIALLY_PAID'];
+const ACTIVE_STATUSES: WarehouseInvoiceStatus[] = ['ISSUED', 'PARTIALLY_PAID', 'PAID'];
+
+@Injectable()
+export class WarehouseInvoiceService {
+  constructor(
+    private readonly dataSource: DataSource,
+    private readonly invoiceRepository: WarehouseFeeInvoiceRepository,
+    private readonly itemRepository: WarehouseFeeInvoiceItemRepository,
+    private readonly feeService: WarehouseFeeService,
+  ) {}
+
+  // ── Generation ───────────────────────────────────────────────────────────
+  async generateForInventory(inventoryId: string, opts: GenerateOptions = {}): Promise<WarehouseFeeInvoice> {
+    const [item] = await this.dataSource.query(
+      `SELECT inv.id, inv.booking_id AS "bookingId", inv.warehouse_id AS "warehouseId",
+              inv.yard_id AS "yardId", inv.zone_id AS "zoneId", inv.arrived_at AS "arrivedAt",
+              w.facility_id AS "facilityId",
+              b.company_id AS "customerId", b.freight_type AS "freightType"
+         FROM freight.warehouse_inventory inv
+         LEFT JOIN freight.warehouses w ON w.id = inv.warehouse_id
+         LEFT JOIN freight.bookings b ON b.id = inv.booking_id
+        WHERE inv.id = $1 AND inv.deleted_at IS NULL`,
+      [inventoryId],
+    );
+    if (!item) throw new NotFoundException(`Inventory item ${inventoryId} not found`);
+
+    // Dedup: only one active (non-cancelled) invoice per inventory item.
+    const active = await this.invoiceRepository.findAll({ where: { inventoryId } });
+    if (active.some((inv) => ACTIVE_STATUSES.includes(inv.status))) {
+      throw new ConflictException(
+        'An active warehouse fee invoice already exists for this item. Cancel it before generating a new one.',
+      );
+    }
+
+    const previews = await this.feeService.previewForInventory(inventoryId);
+    const isContainer = (item.freightType ?? '').toUpperCase() === 'CONTAINER';
+
+    const items = previews
+      .filter((p) => p.amount > 0)
+      .map((p) => {
+        const feeType: WarehouseFeeType =
+          p.ruleType === 'STORAGE_FEE'
+            ? 'STORAGE_FEE'
+            : isContainer
+              ? 'CONTAINER_DEMURRAGE'
+              : 'BULK_DEMURRAGE';
+        return {
+          feeRuleId: p.ruleId,
+          feeType,
+          description:
+            p.ruleType === 'STORAGE_FEE'
+              ? `Storage fee — ${p.chargeableDays} chargeable day(s) after ${p.freeDays} free`
+              : `${isContainer ? 'Container' : 'Bulk'} demurrage — ${p.chargeableDays} chargeable day(s) after ${p.freeDays} free`,
+          quantity: p.chargeableDays,
+          unitRate: p.ratePerDay,
+          amount: p.amount,
+          currency: p.currency,
+          chargeableDays: p.chargeableDays,
+          freeDays: p.freeDays,
+        };
+      });
+
+    const subtotal = items.reduce((s, i) => s + i.amount, 0);
+    const total = subtotal; // tax model can be layered on later
+
+    if (total <= 0 && !opts.confirmZero) {
+      throw new BadRequestException('No payable warehouse fee found for this item.');
+    }
+
+    const hasDemurrage = items.some((i) => i.feeType !== 'STORAGE_FEE');
+    const hasStorage = items.some((i) => i.feeType === 'STORAGE_FEE');
+    const invoiceType: WarehouseInvoiceType =
+      hasDemurrage && hasStorage ? 'MIXED_WAREHOUSE_FEES' : hasStorage ? 'STORAGE_FEE' : 'DEMURRAGE';
+
+    const currency = items[0]?.currency ?? 'USD';
+    const now = new Date();
+    const periodEnd = previews[0] ? new Date(previews[0].endDate) : now;
+
+    const invoice = await this.invoiceRepository.create({
+      invoiceNumber: await this.nextInvoiceNumber(),
+      bookingId: item.bookingId ?? null,
+      customerId: item.customerId ?? null,
+      inventoryId,
+      facilityId: item.facilityId ?? null,
+      warehouseId: item.warehouseId ?? null,
+      yardId: item.yardId ?? null,
+      zoneId: item.zoneId ?? null,
+      invoiceType,
+      status: 'ISSUED',
+      subtotalAmount: subtotal,
+      taxAmount: 0,
+      totalAmount: total,
+      paidAmount: 0,
+      balanceAmount: total,
+      currency,
+      periodStart: item.arrivedAt ?? null,
+      periodEnd,
+      issuedAt: now,
+      payments: [],
+      notes: opts.performedBy ? `Generated by ${opts.performedBy}` : null,
+    });
+
+    for (const it of items) {
+      await this.itemRepository.create({ invoiceId: invoice.id, ...it });
+    }
+
+    return this.findById(invoice.id);
+  }
+
+  /** WHF-YYYYMMDD-00001 — sequential per day. */
+  private async nextInvoiceNumber(): Promise<string> {
+    const now = new Date();
+    const ymd = `${now.getFullYear()}${String(now.getMonth() + 1).padStart(2, '0')}${String(now.getDate()).padStart(2, '0')}`;
+    const prefix = `WHF-${ymd}-`;
+    const [row] = await this.dataSource.query(
+      `SELECT COALESCE(MAX(CAST(split_part(invoice_number, '-', 3) AS int)), 0) AS seq
+         FROM freight.warehouse_fee_invoices WHERE invoice_number LIKE $1`,
+      [`${prefix}%`],
+    );
+    const next = Number(row?.seq ?? 0) + 1;
+    return `${prefix}${String(next).padStart(5, '0')}`;
+  }
+
+  // ── Reads ────────────────────────────────────────────────────────────────
+  async findById(id: string): Promise<WarehouseFeeInvoice & { items: unknown[] }> {
+    const invoice = await this.invoiceRepository.findById(id);
+    if (!invoice) throw new NotFoundException(`Invoice ${id} not found`);
+    const items = await this.itemRepository.findAll({ where: { invoiceId: id } });
+    return { ...invoice, items } as WarehouseFeeInvoice & { items: unknown[] };
+  }
+
+  listForInventory(inventoryId: string): Promise<WarehouseFeeInvoice[]> {
+    return this.invoiceRepository.findAll({ where: { inventoryId }, order: { createdAt: 'DESC' } });
+  }
+
+  listForBooking(bookingId: string): Promise<WarehouseFeeInvoice[]> {
+    return this.invoiceRepository.findAll({ where: { bookingId }, order: { createdAt: 'DESC' } });
+  }
+
+  findAll(filter: Partial<Pick<WarehouseFeeInvoice, 'status' | 'invoiceType' | 'warehouseId' | 'facilityId' | 'customerId' | 'bookingId'>>): Promise<WarehouseFeeInvoice[]> {
+    const where = Object.fromEntries(Object.entries(filter).filter(([, v]) => v != null));
+    return this.invoiceRepository.findAll({ where, order: { createdAt: 'DESC' } });
+  }
+
+  // ── State changes ────────────────────────────────────────────────────────
+  async cancel(id: string): Promise<WarehouseFeeInvoice> {
+    const invoice = await this.invoiceRepository.findById(id);
+    if (!invoice) throw new NotFoundException(`Invoice ${id} not found`);
+    if (invoice.status === 'PAID') throw new BadRequestException('A paid invoice cannot be cancelled.');
+    const updated = await this.invoiceRepository.update(id, { status: 'CANCELLED', cancelledAt: new Date() });
+    return updated as WarehouseFeeInvoice;
+  }
+
+  /** Record a payment against the invoice and sync status (links to existing payment flow). */
+  async pay(id: string, dto: PayInvoiceDto): Promise<WarehouseFeeInvoice> {
+    const invoice = await this.invoiceRepository.findById(id);
+    if (!invoice) throw new NotFoundException(`Invoice ${id} not found`);
+    if (invoice.status === 'CANCELLED') throw new BadRequestException('Cannot pay a cancelled invoice.');
+    if (invoice.status === 'PAID') throw new BadRequestException('Invoice is already fully paid.');
+    if (!(dto.amount > 0)) throw new BadRequestException('Payment amount must be greater than zero.');
+
+    const paidAmount = Number(invoice.paidAmount) + dto.amount;
+    const total = Number(invoice.totalAmount);
+    const balance = Math.max(0, Math.round((total - paidAmount) * 100) / 100);
+    const fullyPaid = paidAmount >= total;
+
+    const payments = [
+      ...(invoice.payments ?? []),
+      { amount: dto.amount, method: dto.method ?? null, reference: dto.reference ?? null, paidAt: new Date().toISOString() },
+    ];
+
+    const updated = await this.invoiceRepository.update(id, {
+      paidAmount: Math.round(paidAmount * 100) / 100,
+      balanceAmount: balance,
+      status: fullyPaid ? 'PAID' : 'PARTIALLY_PAID',
+      paidAt: fullyPaid ? new Date() : invoice.paidAt ?? null,
+      payments,
+    });
+    return updated as WarehouseFeeInvoice;
+  }
+
+  // ── Release blocking ──────────────────────────────────────────────────────
+  /** Returns the first unpaid invoice that blocks terminal release, or null. */
+  async findBlockingInvoice(inventoryId: string): Promise<WarehouseFeeInvoice | null> {
+    const invoices = await this.invoiceRepository.findAll({ where: { inventoryId } });
+    return invoices.find((inv) => BLOCKING_STATUSES.includes(inv.status)) ?? null;
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/warehouses/warehouse-loading.repository.ts b/apps/edr-freight-api/src/modules/warehouses/warehouse-loading.repository.ts
new file mode 100644
index 000000000..45773c0f6
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/warehouses/warehouse-loading.repository.ts
@@ -0,0 +1,13 @@
+import { BaseRepository } from '@edr/api-common';
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+
+import { WarehouseLoading } from './entities/warehouse-loading.entity';
+
+@Injectable()
+export class WarehouseLoadingRepository extends BaseRepository<WarehouseLoading> {
+  constructor(@InjectRepository(WarehouseLoading) repository: Repository<WarehouseLoading>) {
+    super(repository);
+  }
+}
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
new file mode 100644
index 000000000..aab8e18b2
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/warehouses/warehouse-loadings.controller.ts
@@ -0,0 +1,17 @@
+import { Controller, Get, Query } from '@nestjs/common';
+import { ApiBearerAuth, ApiOperation, ApiTags } from '@nestjs/swagger';
+
+import { WarehouseInventoryService } from './warehouse-inventory.service';
+
+@ApiTags('warehouse-loadings')
+@ApiBearerAuth()
+@Controller('warehouse-loadings')
+export class WarehouseLoadingsController {
+  constructor(private readonly inventoryService: WarehouseInventoryService) {}
+
+  @Get()
+  @ApiOperation({ summary: 'List wagon loading records' })
+  findAll(@Query('bookingId') bookingId?: string, @Query('wagonId') wagonId?: string) {
+    return this.inventoryService.findLoadings({ bookingId, wagonId });
+  }
+}
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
new file mode 100644
index 000000000..333597618
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/warehouses/warehouse-rules.controller.ts
@@ -0,0 +1,85 @@
+import { Body, Controller, Delete, Get, HttpCode, Param, ParseUUIDPipe, Patch, Post } from '@nestjs/common';
+import { ApiBearerAuth, ApiOperation, ApiTags } from '@nestjs/swagger';
+
+import {
+  AllocationPreviewDto,
+  CreateAllocationRuleDto,
+  UpdateAllocationRuleDto,
+} from './dto/allocation-rule.dto';
+import { CreateFeeRuleDto, UpdateFeeRuleDto } from './dto/fee-rule.dto';
+import { WarehouseAllocationService } from './warehouse-allocation.service';
+import { WarehouseFeeService } from './warehouse-fee.service';
+
+@ApiTags('warehouse-rules')
+@ApiBearerAuth()
+@Controller()
+export class WarehouseRulesController {
+  constructor(
+    private readonly allocationService: WarehouseAllocationService,
+    private readonly feeService: WarehouseFeeService,
+  ) {}
+
+  // ── Allocation rules ───────────────────────────────────────────────────────
+  @Get('warehouse-allocation-rules')
+  @ApiOperation({ summary: 'List warehouse allocation rules' })
+  listAllocationRules() {
+    return this.allocationService.listRules();
+  }
+
+  @Post('warehouse-allocation-rules')
+  @ApiOperation({ summary: 'Create a warehouse allocation rule' })
+  createAllocationRule(@Body() dto: CreateAllocationRuleDto) {
+    return this.allocationService.createRule(dto);
+  }
+
+  @Patch('warehouse-allocation-rules/:id')
+  @ApiOperation({ summary: 'Update a warehouse allocation rule' })
+  updateAllocationRule(@Param('id', ParseUUIDPipe) id: string, @Body() dto: UpdateAllocationRuleDto) {
+    return this.allocationService.updateRule(id, dto);
+  }
+
+  @Delete('warehouse-allocation-rules/:id')
+  @HttpCode(204)
+  @ApiOperation({ summary: 'Delete a warehouse allocation rule' })
+  deleteAllocationRule(@Param('id', ParseUUIDPipe) id: string) {
+    return this.allocationService.deleteRule(id);
+  }
+
+  @Post('warehouse-allocation/preview')
+  @ApiOperation({ summary: 'Preview the yard/warehouse/zone a booking would be allocated to' })
+  previewAllocation(@Body() dto: AllocationPreviewDto) {
+    return this.allocationService.resolveLocation(dto);
+  }
+
+  // ── Fee rules ────────────────────────────────────────────────────────────────
+  @Get('warehouse-fee-rules')
+  @ApiOperation({ summary: 'List storage / demurrage fee rules' })
+  listFeeRules() {
+    return this.feeService.listRules();
+  }
+
+  @Post('warehouse-fee-rules')
+  @ApiOperation({ summary: 'Create a storage / demurrage fee rule' })
+  createFeeRule(@Body() dto: CreateFeeRuleDto) {
+    return this.feeService.createRule(dto);
+  }
+
+  @Patch('warehouse-fee-rules/:id')
+  @ApiOperation({ summary: 'Update a fee rule' })
+  updateFeeRule(@Param('id', ParseUUIDPipe) id: string, @Body() dto: UpdateFeeRuleDto) {
+    return this.feeService.updateRule(id, dto);
+  }
+
+  @Delete('warehouse-fee-rules/:id')
+  @HttpCode(204)
+  @ApiOperation({ summary: 'Delete a fee rule' })
+  deleteFeeRule(@Param('id', ParseUUIDPipe) id: string) {
+    return this.feeService.deleteRule(id);
+  }
+
+  @Get('warehouse-inventory/:id/fee-preview')
+  @ApiOperation({ summary: 'Preview demurrage + storage fees for an inventory item' })
+  feePreview(@Param('id', ParseUUIDPipe) id: string) {
+    return this.feeService.previewForInventory(id);
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/warehouses/warehouse-scheduling-adapter.service.ts b/apps/edr-freight-api/src/modules/warehouses/warehouse-scheduling-adapter.service.ts
new file mode 100644
index 000000000..dcf685c9f
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/warehouses/warehouse-scheduling-adapter.service.ts
@@ -0,0 +1,63 @@
+import { Injectable } from '@nestjs/common';
+import { DataSource } from 'typeorm';
+
+import { WarehouseInventory } from './entities/warehouse-inventory.entity';
+
+/**
+ * READ-ONLY bridge that exposes warehouse inventory to the Train Scheduling
+ * domain. It only reads warehouse data — it never assigns wagons, creates or
+ * mutates schedules, and is intentionally NOT imported by the scheduling module.
+ */
+@Injectable()
+export class WarehouseSchedulingAdapterService {
+  constructor(private readonly dataSource: DataSource) {}
+
+  private get repo() {
+    return this.dataSource.getRepository(WarehouseInventory);
+  }
+
+  getReadyForLoadingInventory(): Promise<WarehouseInventory[]> {
+    return this.repo.find({
+      where: { status: 'READY_FOR_LOADING' },
+      relations: { warehouse: true, yard: true, zone: true },
+      order: { readyForLoadingAt: 'ASC' },
+    });
+  }
+
+  getReservedInventory(): Promise<WarehouseInventory[]> {
+    return this.repo.find({
+      where: { status: 'RESERVED' },
+      relations: { warehouse: true, yard: true, zone: true },
+      order: { reservedAt: 'ASC' },
+    });
+  }
+
+  getInventoryByBooking(bookingId: string): Promise<WarehouseInventory[]> {
+    return this.repo.find({
+      where: { bookingId },
+      relations: { warehouse: true, yard: true, zone: true },
+      order: { createdAt: 'DESC' },
+    });
+  }
+
+  /**
+   * Inventory whose origin booking runs on the given route. Best-effort, read-only:
+   * matches the route's origin/destination yards against the booking's yards.
+   */
+  async getInventoryByRoute(routeId: string): Promise<WarehouseInventory[]> {
+    return this.repo
+      .createQueryBuilder('inv')
+      .leftJoinAndSelect('inv.warehouse', 'warehouse')
+      .leftJoinAndSelect('inv.yard', 'yard')
+      .leftJoinAndSelect('inv.zone', 'zone')
+      .innerJoin('freight.bookings', 'booking', 'booking.id = inv.booking_id')
+      .innerJoin(
+        'freight.routes',
+        'route',
+        'route.id = :routeId AND (route.origin_yard_id = booking.origin_yard_id OR route.destination_yard_id = booking.destination_yard_id)',
+        { routeId },
+      )
+      .orderBy('inv.created_at', 'DESC')
+      .getMany();
+  }
+}
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
new file mode 100644
index 000000000..3ee0dde82
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/warehouses/warehouse-yards.controller.ts
@@ -0,0 +1,44 @@
+import { Body, Controller, Get, Param, ParseUUIDPipe, Patch, Post } from '@nestjs/common';
+import { ApiBearerAuth, ApiOperation, ApiTags } from '@nestjs/swagger';
+
+import { CreateWarehouseZoneDto } from './dto/create-warehouse-zone.dto';
+import { UpdateWarehouseYardDto } from './dto/update-warehouse-yard.dto';
+import { WarehouseYardsService } from './warehouse-yards.service';
+import { WarehouseZonesService } from './warehouse-zones.service';
+
+@ApiTags('warehouse-yards')
+@ApiBearerAuth()
+@Controller('warehouse-yards')
+export class WarehouseYardsController {
+  constructor(
+    private readonly yardsService: WarehouseYardsService,
+    private readonly zonesService: WarehouseZonesService,
+  ) {}
+
+  @Get(':id')
+  @ApiOperation({ summary: 'Get warehouse yard by ID' })
+  findOne(@Param('id', ParseUUIDPipe) id: string) {
+    return this.yardsService.findById(id);
+  }
+
+  @Patch(':id')
+  @ApiOperation({ summary: 'Update warehouse yard' })
+  update(@Param('id', ParseUUIDPipe) id: string, @Body() dto: UpdateWarehouseYardDto) {
+    return this.yardsService.update(id, dto);
+  }
+
+  @Get(':yardId/zones')
+  @ApiOperation({ summary: 'List zones within a yard' })
+  listZones(@Param('yardId', ParseUUIDPipe) yardId: string) {
+    return this.zonesService.findByYard(yardId);
+  }
+
+  @Post(':yardId/zones')
+  @ApiOperation({ summary: 'Create a zone within a yard' })
+  createZone(
+    @Param('yardId', ParseUUIDPipe) yardId: string,
+    @Body() dto: CreateWarehouseZoneDto,
+  ) {
+    return this.zonesService.create(yardId, dto);
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/warehouses/warehouse-yards.repository.ts b/apps/edr-freight-api/src/modules/warehouses/warehouse-yards.repository.ts
new file mode 100644
index 000000000..99bbdd21f
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/warehouses/warehouse-yards.repository.ts
@@ -0,0 +1,13 @@
+import { BaseRepository } from '@edr/api-common';
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+
+import { WarehouseYard } from './entities/warehouse-yard.entity';
+
+@Injectable()
+export class WarehouseYardsRepository extends BaseRepository<WarehouseYard> {
+  constructor(@InjectRepository(WarehouseYard) repository: Repository<WarehouseYard>) {
+    super(repository);
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/warehouses/warehouse-yards.service.ts b/apps/edr-freight-api/src/modules/warehouses/warehouse-yards.service.ts
new file mode 100644
index 000000000..f65e4593e
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/warehouses/warehouse-yards.service.ts
@@ -0,0 +1,93 @@
+import { ConflictException, Injectable, NotFoundException } from '@nestjs/common';
+
+import { CreateWarehouseYardDto } from './dto/create-warehouse-yard.dto';
+import { UpdateWarehouseYardDto } from './dto/update-warehouse-yard.dto';
+import { WarehouseYard } from './entities/warehouse-yard.entity';
+import { WarehouseYardsRepository } from './warehouse-yards.repository';
+import { WarehousesService } from './warehouses.service';
+
+@Injectable()
+export class WarehouseYardsService {
+  constructor(
+    private readonly yardsRepository: WarehouseYardsRepository,
+    private readonly warehousesService: WarehousesService,
+  ) {}
+
+  findByWarehouse(warehouseId: string): Promise<WarehouseYard[]> {
+    return this.yardsRepository.findAll({
+      where: { warehouseId },
+      relations: { zones: true },
+      order: { code: 'ASC' },
+    });
+  }
+
+  async findById(id: string): Promise<WarehouseYard> {
+    const yard = await this.yardsRepository.findById(id, {
+      relations: { warehouse: true, zones: true },
+    });
+
+    if (!yard) {
+      throw new NotFoundException(`Warehouse yard ${id} not found`);
+    }
+
+    return yard;
+  }
+
+  async create(warehouseId: string, dto: CreateWarehouseYardDto): Promise<WarehouseYard> {
+    // Ensure the parent warehouse exists.
+    await this.warehousesService.findById(warehouseId);
+    await this.assertCodeUnique(warehouseId, dto.code.trim());
+
+    return this.yardsRepository.create({
+      warehouseId,
+      name: dto.name.trim(),
+      code: dto.code.trim(),
+      type: dto.type,
+      capacityWeight: dto.capacityWeight ?? null,
+      capacityContainers: dto.capacityContainers ?? null,
+      maxWeight: dto.maxWeight ?? dto.capacityWeight ?? null,
+      maxVolume: dto.maxVolume ?? null,
+      currentWeight: 0,
+      currentContainers: 0,
+      currentVolume: 0,
+      status: 'ACTIVE',
+      isActive: true,
+    });
+  }
+
+  async update(id: string, dto: UpdateWarehouseYardDto): Promise<WarehouseYard> {
+    const existing = await this.findById(id);
+
+    if (dto.code && dto.code.trim() !== existing.code) {
+      await this.assertCodeUnique(existing.warehouseId, dto.code.trim(), id);
+    }
+
+    const status = dto.status ?? existing.status;
+
+    const updated = await this.yardsRepository.update(id, {
+      name: dto.name?.trim() ?? existing.name,
+      code: dto.code?.trim() ?? existing.code,
+      type: dto.type ?? existing.type,
+      capacityWeight: dto.capacityWeight ?? existing.capacityWeight,
+      capacityContainers: dto.capacityContainers ?? existing.capacityContainers,
+      maxWeight: dto.maxWeight ?? existing.maxWeight,
+      maxVolume: dto.maxVolume ?? existing.maxVolume,
+      status,
+      isActive: status === 'ACTIVE',
+    });
+
+    if (!updated) {
+      throw new NotFoundException(`Warehouse yard ${id} not found`);
+    }
+
+    return this.findById(id);
+  }
+
+  private async assertCodeUnique(warehouseId: string, code: string, ignoreId?: string): Promise<void> {
+    const [existing] = await this.yardsRepository.findAll({ where: { warehouseId, code } });
+
+    if (existing && existing.id !== ignoreId) {
+      throw new ConflictException(`Yard code ${code} already exists in this warehouse`);
+    }
+  }
+}
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
new file mode 100644
index 000000000..30c4407f6
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/warehouses/warehouse-zones.controller.ts
@@ -0,0 +1,24 @@
+import { Body, Controller, Get, Param, ParseUUIDPipe, Patch } from '@nestjs/common';
+import { ApiBearerAuth, ApiOperation, ApiTags } from '@nestjs/swagger';
+
+import { UpdateWarehouseZoneDto } from './dto/update-warehouse-zone.dto';
+import { WarehouseZonesService } from './warehouse-zones.service';
+
+@ApiTags('warehouse-zones')
+@ApiBearerAuth()
+@Controller('warehouse-zones')
+export class WarehouseZonesController {
+  constructor(private readonly zonesService: WarehouseZonesService) {}
+
+  @Get(':id')
+  @ApiOperation({ summary: 'Get warehouse zone by ID' })
+  findOne(@Param('id', ParseUUIDPipe) id: string) {
+    return this.zonesService.findById(id);
+  }
+
+  @Patch(':id')
+  @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/warehouse-zones.repository.ts b/apps/edr-freight-api/src/modules/warehouses/warehouse-zones.repository.ts
new file mode 100644
index 000000000..94580f116
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/warehouses/warehouse-zones.repository.ts
@@ -0,0 +1,13 @@
+import { BaseRepository } from '@edr/api-common';
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+
+import { WarehouseZone } from './entities/warehouse-zone.entity';
+
+@Injectable()
+export class WarehouseZonesRepository extends BaseRepository<WarehouseZone> {
+  constructor(@InjectRepository(WarehouseZone) repository: Repository<WarehouseZone>) {
+    super(repository);
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/warehouses/warehouse-zones.service.ts b/apps/edr-freight-api/src/modules/warehouses/warehouse-zones.service.ts
new file mode 100644
index 000000000..a2f3800cd
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/warehouses/warehouse-zones.service.ts
@@ -0,0 +1,92 @@
+import { ConflictException, Injectable, NotFoundException } from '@nestjs/common';
+
+import { CreateWarehouseZoneDto } from './dto/create-warehouse-zone.dto';
+import { UpdateWarehouseZoneDto } from './dto/update-warehouse-zone.dto';
+import { WarehouseZone } from './entities/warehouse-zone.entity';
+import { WarehouseYardsService } from './warehouse-yards.service';
+import { WarehouseZonesRepository } from './warehouse-zones.repository';
+
+@Injectable()
+export class WarehouseZonesService {
+  constructor(
+    private readonly zonesRepository: WarehouseZonesRepository,
+    private readonly yardsService: WarehouseYardsService,
+  ) {}
+
+  findByYard(yardId: string): Promise<WarehouseZone[]> {
+    return this.zonesRepository.findAll({
+      where: { yardId },
+      order: { code: 'ASC' },
+    });
+  }
+
+  async findById(id: string): Promise<WarehouseZone> {
+    const zone = await this.zonesRepository.findById(id, {
+      relations: { yard: { warehouse: true } },
+    });
+
+    if (!zone) {
+      throw new NotFoundException(`Warehouse zone ${id} not found`);
+    }
+
+    return zone;
+  }
+
+  async create(yardId: string, dto: CreateWarehouseZoneDto): Promise<WarehouseZone> {
+    // Ensure the parent yard exists.
+    await this.yardsService.findById(yardId);
+    await this.assertCodeUnique(yardId, dto.code.trim());
+
+    return this.zonesRepository.create({
+      yardId,
+      name: dto.name.trim(),
+      code: dto.code.trim(),
+      type: dto.type,
+      capacityWeight: dto.capacityWeight ?? null,
+      capacityContainers: dto.capacityContainers ?? null,
+      maxWeight: dto.maxWeight ?? dto.capacityWeight ?? null,
+      maxVolume: dto.maxVolume ?? null,
+      currentWeight: 0,
+      currentContainers: 0,
+      currentVolume: 0,
+      status: 'ACTIVE',
+      isActive: true,
+    });
+  }
+
+  async update(id: string, dto: UpdateWarehouseZoneDto): Promise<WarehouseZone> {
+    const existing = await this.findById(id);
+
+    if (dto.code && dto.code.trim() !== existing.code) {
+      await this.assertCodeUnique(existing.yardId, dto.code.trim(), id);
+    }
+
+    const status = dto.status ?? existing.status;
+
+    const updated = await this.zonesRepository.update(id, {
+      name: dto.name?.trim() ?? existing.name,
+      code: dto.code?.trim() ?? existing.code,
+      type: dto.type ?? existing.type,
+      capacityWeight: dto.capacityWeight ?? existing.capacityWeight,
+      capacityContainers: dto.capacityContainers ?? existing.capacityContainers,
+      maxWeight: dto.maxWeight ?? existing.maxWeight,
+      maxVolume: dto.maxVolume ?? existing.maxVolume,
+      status,
+      isActive: status === 'ACTIVE',
+    });
+
+    if (!updated) {
+      throw new NotFoundException(`Warehouse zone ${id} not found`);
+    }
+
+    return this.findById(id);
+  }
+
+  private async assertCodeUnique(yardId: string, code: string, ignoreId?: string): Promise<void> {
+    const [existing] = await this.zonesRepository.findAll({ where: { yardId, code } });
+
+    if (existing && existing.id !== ignoreId) {
+      throw new ConflictException(`Zone code ${code} already exists in this yard`);
+    }
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/warehouses/warehouses.controller.ts b/apps/edr-freight-api/src/modules/warehouses/warehouses.controller.ts
new file mode 100644
index 000000000..bb7702603
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/warehouses/warehouses.controller.ts
@@ -0,0 +1,66 @@
+import { Body, Controller, Get, Param, ParseUUIDPipe, Patch, Post, Query } from '@nestjs/common';
+import { ApiBearerAuth, ApiOperation, ApiTags } from '@nestjs/swagger';
+
+import { CreateWarehouseDto } from './dto/create-warehouse.dto';
+import { CreateWarehouseYardDto } from './dto/create-warehouse-yard.dto';
+import { FilterWarehouseDto } from './dto/filter-warehouse.dto';
+import { UpdateWarehouseDto } from './dto/update-warehouse.dto';
+import { WarehouseDashboardService } from './warehouse-dashboard.service';
+import { WarehouseYardsService } from './warehouse-yards.service';
+import { WarehousesService } from './warehouses.service';
+
+@ApiTags('warehouses')
+@ApiBearerAuth()
+@Controller('warehouses')
+export class WarehousesController {
+  constructor(
+    private readonly warehousesService: WarehousesService,
+    private readonly yardsService: WarehouseYardsService,
+    private readonly dashboardService: WarehouseDashboardService,
+  ) {}
+
+  @Get()
+  @ApiOperation({ summary: 'List warehouses' })
+  findAll(@Query() filter: FilterWarehouseDto) {
+    return this.warehousesService.findAll(filter);
+  }
+
+  @Get('dashboard')
+  @ApiOperation({ summary: 'Warehouse dashboard metrics' })
+  dashboard() {
+    return this.dashboardService.getDashboard();
+  }
+
+  @Post()
+  @ApiOperation({ summary: 'Create warehouse' })
+  create(@Body() dto: CreateWarehouseDto) {
+    return this.warehousesService.create(dto);
+  }
+
+  @Get(':id')
+  @ApiOperation({ summary: 'Get warehouse by ID' })
+  findOne(@Param('id', ParseUUIDPipe) id: string) {
+    return this.warehousesService.findById(id);
+  }
+
+  @Patch(':id')
+  @ApiOperation({ summary: 'Update warehouse' })
+  update(@Param('id', ParseUUIDPipe) id: string, @Body() dto: UpdateWarehouseDto) {
+    return this.warehousesService.update(id, dto);
+  }
+
+  @Get(':warehouseId/yards')
+  @ApiOperation({ summary: 'List yards within a warehouse' })
+  listYards(@Param('warehouseId', ParseUUIDPipe) warehouseId: string) {
+    return this.yardsService.findByWarehouse(warehouseId);
+  }
+
+  @Post(':warehouseId/yards')
+  @ApiOperation({ summary: 'Create a yard within a warehouse' })
+  createYard(
+    @Param('warehouseId', ParseUUIDPipe) warehouseId: string,
+    @Body() dto: CreateWarehouseYardDto,
+  ) {
+    return this.yardsService.create(warehouseId, dto);
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/warehouses/warehouses.module.ts b/apps/edr-freight-api/src/modules/warehouses/warehouses.module.ts
new file mode 100644
index 000000000..4a08d7f28
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/warehouses/warehouses.module.ts
@@ -0,0 +1,114 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+
+import { FilesModule } from '../files/files.module';
+import { WarehouseActivityLog } from './entities/warehouse-activity-log.entity';
+import { WarehouseAllocationRule } from './entities/warehouse-allocation-rule.entity';
+import { WarehouseFeeInvoice } from './entities/warehouse-fee-invoice.entity';
+import { WarehouseFeeInvoiceItem } from './entities/warehouse-fee-invoice-item.entity';
+import { WarehouseFeeRule } from './entities/warehouse-fee-rule.entity';
+import { WarehouseInspectionReport } from './entities/warehouse-inspection-report.entity';
+import { WarehouseInventory } from './entities/warehouse-inventory.entity';
+import { WarehouseInventoryMovement } from './entities/warehouse-inventory-movement.entity';
+import { WarehouseLoading } from './entities/warehouse-loading.entity';
+import { WarehouseYard } from './entities/warehouse-yard.entity';
+import { WarehouseZone } from './entities/warehouse-zone.entity';
+import { Warehouse } from './entities/warehouse.entity';
+import { SchedulingReadFacade } from './scheduling-read.facade';
+import { WarehouseActivityLogRepository } from './warehouse-activity-log.repository';
+import { WarehouseActivityLogService } from './warehouse-activity-log.service';
+import { WarehouseDashboardService } from './warehouse-dashboard.service';
+import { WarehouseInspectionController } from './warehouse-inspection.controller';
+import { WarehouseInspectionRepository } from './warehouse-inspection.repository';
+import { WarehouseInspectionService } from './warehouse-inspection.service';
+import { WarehouseInventoryController } from './warehouse-inventory.controller';
+import { WarehouseInventoryMovementRepository } from './warehouse-inventory-movement.repository';
+import { WarehouseInventoryRepository } from './warehouse-inventory.repository';
+import { WarehouseInventoryService } from './warehouse-inventory.service';
+import { WarehouseLoadingRepository } from './warehouse-loading.repository';
+import { WarehouseLoadingsController } from './warehouse-loadings.controller';
+import { WarehouseAllocationRuleRepository } from './warehouse-allocation-rule.repository';
+import { WarehouseAllocationService } from './warehouse-allocation.service';
+import { WarehouseFeeRuleRepository } from './warehouse-fee-rule.repository';
+import { WarehouseFeeService } from './warehouse-fee.service';
+import { WarehouseFeeInvoiceItemRepository } from './warehouse-fee-invoice-item.repository';
+import { WarehouseFeeInvoiceRepository } from './warehouse-fee-invoice.repository';
+import { WarehouseInvoiceController } from './warehouse-invoice.controller';
+import { WarehouseInvoiceService } from './warehouse-invoice.service';
+import { WarehouseRulesController } from './warehouse-rules.controller';
+import { WarehouseSchedulingAdapterService } from './warehouse-scheduling-adapter.service';
+import { WarehouseYardsController } from './warehouse-yards.controller';
+import { WarehouseYardsRepository } from './warehouse-yards.repository';
+import { WarehouseYardsService } from './warehouse-yards.service';
+import { WarehouseZonesController } from './warehouse-zones.controller';
+import { WarehouseZonesRepository } from './warehouse-zones.repository';
+import { WarehouseZonesService } from './warehouse-zones.service';
+import { WarehousesController } from './warehouses.controller';
+import { WarehousesRepository } from './warehouses.repository';
+import { WarehousesService } from './warehouses.service';
+
+@Module({
+  imports: [
+    TypeOrmModule.forFeature([
+      Warehouse,
+      WarehouseYard,
+      WarehouseZone,
+      WarehouseInventory,
+      WarehouseInventoryMovement,
+      WarehouseActivityLog,
+      WarehouseLoading,
+      WarehouseInspectionReport,
+      WarehouseAllocationRule,
+      WarehouseFeeRule,
+      WarehouseFeeInvoice,
+      WarehouseFeeInvoiceItem,
+    ]),
+    FilesModule,
+  ],
+  controllers: [
+    WarehousesController,
+    WarehouseYardsController,
+    WarehouseZonesController,
+    WarehouseInventoryController,
+    WarehouseLoadingsController,
+    WarehouseInspectionController,
+    WarehouseRulesController,
+    WarehouseInvoiceController,
+  ],
+  providers: [
+    WarehousesRepository,
+    WarehouseYardsRepository,
+    WarehouseZonesRepository,
+    WarehouseInventoryRepository,
+    WarehouseInventoryMovementRepository,
+    WarehouseActivityLogRepository,
+    WarehouseLoadingRepository,
+    WarehouseInspectionRepository,
+    WarehouseAllocationRuleRepository,
+    WarehouseFeeRuleRepository,
+    WarehouseFeeInvoiceRepository,
+    WarehouseFeeInvoiceItemRepository,
+    WarehousesService,
+    WarehouseYardsService,
+    WarehouseZonesService,
+    WarehouseInventoryService,
+    WarehouseActivityLogService,
+    WarehouseDashboardService,
+    WarehouseInspectionService,
+    WarehouseAllocationService,
+    WarehouseFeeService,
+    WarehouseInvoiceService,
+    WarehouseSchedulingAdapterService,
+    SchedulingReadFacade,
+  ],
+  exports: [
+    WarehousesService,
+    WarehouseYardsService,
+    WarehouseZonesService,
+    WarehouseInventoryService,
+    WarehouseAllocationService,
+    WarehouseFeeService,
+    WarehouseSchedulingAdapterService,
+  ],
+})
+export class WarehousesModule {}
diff --git a/apps/edr-freight-api/src/modules/warehouses/warehouses.repository.ts b/apps/edr-freight-api/src/modules/warehouses/warehouses.repository.ts
new file mode 100644
index 000000000..b88ddab50
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/warehouses/warehouses.repository.ts
@@ -0,0 +1,13 @@
+import { BaseRepository } from '@edr/api-common';
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+
+import { Warehouse } from './entities/warehouse.entity';
+
+@Injectable()
+export class WarehousesRepository extends BaseRepository<Warehouse> {
+  constructor(@InjectRepository(Warehouse) repository: Repository<Warehouse>) {
+    super(repository);
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/warehouses/warehouses.service.ts b/apps/edr-freight-api/src/modules/warehouses/warehouses.service.ts
new file mode 100644
index 000000000..3cbcc6833
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/warehouses/warehouses.service.ts
@@ -0,0 +1,109 @@
+import { ConflictException, Injectable, NotFoundException } from '@nestjs/common';
+import { FindManyOptions, ILike } from 'typeorm';
+
+import { CreateWarehouseDto } from './dto/create-warehouse.dto';
+import { FilterWarehouseDto } from './dto/filter-warehouse.dto';
+import { UpdateWarehouseDto } from './dto/update-warehouse.dto';
+import { Warehouse } from './entities/warehouse.entity';
+import { WarehousesRepository } from './warehouses.repository';
+
+@Injectable()
+export class WarehousesService {
+  constructor(private readonly warehousesRepository: WarehousesRepository) {}
+
+  async findAll(filter: FilterWarehouseDto): Promise<Warehouse[]> {
+    const where: FindManyOptions<Warehouse>['where'] = {
+      ...(filter.type ? { type: filter.type } : {}),
+      ...(filter.stationId ? { stationId: filter.stationId } : {}),
+      ...(filter.status ? { status: filter.status } : {}),
+    };
+
+    const search = filter.search?.trim();
+    const whereClauses = search
+      ? [
+          { ...where, name: ILike(`%${search}%`) },
+          { ...where, code: ILike(`%${search}%`) },
+          { ...where, locationName: ILike(`%${search}%`) },
+        ]
+      : where;
+
+    return this.warehousesRepository.findAll({
+      where: whereClauses,
+      relations: { facility: true },
+      order: { code: 'ASC' },
+    });
+  }
+
+  async findById(id: string): Promise<Warehouse> {
+    const warehouse = await this.warehousesRepository.findById(id, {
+      relations: { facility: true, yards: { zones: true } },
+    });
+
+    if (!warehouse) {
+      throw new NotFoundException(`Warehouse ${id} not found`);
+    }
+
+    return warehouse;
+  }
+
+  async create(dto: CreateWarehouseDto): Promise<Warehouse> {
+    await this.assertCodeUnique(dto.code.trim());
+
+    return this.warehousesRepository.create({
+      name: dto.name.trim(),
+      code: dto.code.trim(),
+      type: dto.type,
+      stationId: dto.stationId ?? null,
+      facilityId: dto.facilityId ?? null,
+      locationName: dto.locationName?.trim() ?? null,
+      capacityWeight: dto.capacityWeight ?? null,
+      capacityContainers: dto.capacityContainers ?? null,
+      maxWeight: dto.maxWeight ?? dto.capacityWeight ?? null,
+      maxVolume: dto.maxVolume ?? null,
+      currentWeight: 0,
+      currentContainers: 0,
+      currentVolume: 0,
+      status: 'ACTIVE',
+      isActive: true,
+    });
+  }
+
+  async update(id: string, dto: UpdateWarehouseDto): Promise<Warehouse> {
+    const existing = await this.findById(id);
+
+    if (dto.code && dto.code.trim() !== existing.code) {
+      await this.assertCodeUnique(dto.code.trim(), id);
+    }
+
+    const status = dto.status ?? existing.status;
+
+    const updated = await this.warehousesRepository.update(id, {
+      name: dto.name?.trim() ?? existing.name,
+      code: dto.code?.trim() ?? existing.code,
+      type: dto.type ?? existing.type,
+      stationId: dto.stationId ?? existing.stationId,
+      facilityId: dto.facilityId ?? existing.facilityId,
+      locationName: dto.locationName?.trim() ?? existing.locationName,
+      capacityWeight: dto.capacityWeight ?? existing.capacityWeight,
+      capacityContainers: dto.capacityContainers ?? existing.capacityContainers,
+      maxWeight: dto.maxWeight ?? existing.maxWeight,
+      maxVolume: dto.maxVolume ?? existing.maxVolume,
+      status,
+      isActive: status === 'ACTIVE',
+    });
+
+    if (!updated) {
+      throw new NotFoundException(`Warehouse ${id} not found`);
+    }
+
+    return this.findById(id);
+  }
+
+  private async assertCodeUnique(code: string, ignoreId?: string): Promise<void> {
+    const [existing] = await this.warehousesRepository.findAll({ where: { code } });
+
+    if (existing && existing.id !== ignoreId) {
+      throw new ConflictException(`Warehouse code ${code} already exists`);
+    }
+  }
+}
diff --git a/apps/edr-freight-api/src/scripts/seed-edr-wagons.ts b/apps/edr-freight-api/src/scripts/seed-edr-wagons.ts
new file mode 100644
index 000000000..b6a6484f8
--- /dev/null
+++ b/apps/edr-freight-api/src/scripts/seed-edr-wagons.ts
@@ -0,0 +1,47 @@
+import { AppDataSource } from '../data-source';
+import { SeedEdRWagonFleet1750400000000 } from '../migrations/1750400000000-SeedEdRWagonFleet';
+
+async function seedEdRWagons() {
+  await AppDataSource.initialize();
+
+  const queryRunner = AppDataSource.createQueryRunner();
+
+  try {
+    await queryRunner.connect();
+    await queryRunner.startTransaction();
+
+    await new SeedEdRWagonFleet1750400000000().up(queryRunner);
+
+    const [summary] = await queryRunner.query(`
+      SELECT
+        COUNT(*)::int AS total,
+        COUNT(*) FILTER (WHERE wt.code = 'PW2')::int AS pw2,
+        COUNT(*) FILTER (WHERE wt.code = 'CW4')::int AS cw4,
+        COUNT(*) FILTER (WHERE wt.code = 'CW3')::int AS cw3,
+        COUNT(*) FILTER (WHERE wt.code = 'KW2')::int AS kw2,
+        COUNT(*) FILTER (WHERE wt.code = 'KW3')::int AS kw3,
+        COUNT(*) FILTER (WHERE wt.code = 'NW5')::int AS nw5,
+        COUNT(*) FILTER (WHERE wt.supported_load_types @> ARRAY['CONTAINER'])::int AS container_ready,
+        COUNT(*) FILTER (WHERE wt.supported_load_types @> ARRAY['BULK'])::int AS bulk_ready,
+        COUNT(*) FILTER (WHERE w.status = 'IMPORT_READY')::int AS import_ready
+      FROM freight.wagons w
+      JOIN freight.wagon_types wt ON wt.id = w.wagon_type_id
+      WHERE w.wagon_number BETWEEN 'ER0001' AND 'ER0940';
+    `);
+
+    await queryRunner.commitTransaction();
+
+    console.log('Seeded EDR wagon fleet:', summary);
+  } catch (error) {
+    await queryRunner.rollbackTransaction();
+    throw error;
+  } finally {
+    await queryRunner.release();
+    await AppDataSource.destroy();
+  }
+}
+
+seedEdRWagons().catch((error) => {
+  console.error('Failed to seed EDR wagon fleet:', error);
+  process.exit(1);
+});
diff --git a/apps/edr-freight-api/src/seed/batch1-4-test-data.seeder.ts b/apps/edr-freight-api/src/seed/batch1-4-test-data.seeder.ts
new file mode 100644
index 000000000..cb4038097
--- /dev/null
+++ b/apps/edr-freight-api/src/seed/batch1-4-test-data.seeder.ts
@@ -0,0 +1,170 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { DataSource } from 'typeorm';
+
+import { Facility } from '../modules/facilities/entities/facility.entity';
+import { Warehouse } from '../modules/warehouses/entities/warehouse.entity';
+import { WarehouseInventory } from '../modules/warehouses/entities/warehouse-inventory.entity';
+import { WarehouseYard } from '../modules/warehouses/entities/warehouse-yard.entity';
+import { WarehouseZone } from '../modules/warehouses/entities/warehouse-zone.entity';
+
+/**
+ * Test data seeder for Batch 1-4 warehouse system.
+ * Creates Indode facility with warehouses, yards, zones, and sample inventory
+ * in all status states (RECEIVED, STORED, RESERVED, READY_FOR_LOADING, LOADED, DISPATCHED).
+ */
+@Injectable()
+export class Batch14TestDataSeeder {
+  private readonly logger = new Logger(Batch14TestDataSeeder.name);
+
+  constructor(private readonly dataSource: DataSource) {}
+
+  async run(): Promise<void> {
+    try {
+      const facilityRepo = this.dataSource.getRepository(Facility);
+      const warehouseRepo = this.dataSource.getRepository(Warehouse);
+      const yardRepo = this.dataSource.getRepository(WarehouseYard);
+      const zoneRepo = this.dataSource.getRepository(WarehouseZone);
+      const inventoryRepo = this.dataSource.getRepository(WarehouseInventory);
+
+      // Check if facility already exists
+      const existingFacility = await facilityRepo.findOne({
+        where: { code: 'INDODE_TEST' },
+      });
+
+      if (existingFacility) {
+        this.logger.log('Batch 1-4 test data already seeded, skipping');
+        return;
+      }
+
+      // Create Facility
+      const facility = await facilityRepo.save(
+        facilityRepo.create({
+          code: 'INDODE_TEST',
+          name: 'Indode Test Facility',
+          facilityType: 'DRY_PORT',
+          facilityStatus: 'ACTIVE',
+          locationName: 'Indode',
+          country: 'Djibouti',
+          city: 'Djibouti',
+          isActive: true,
+          capacity: 100000,
+        }),
+      );
+      this.logger.log(`Created facility: ${facility.code}`);
+
+      // Create Warehouse
+      const warehouse = await warehouseRepo.save(
+        warehouseRepo.create({
+          code: 'TEST_WH_001',
+          name: 'Test Warehouse 1',
+          type: 'OPEN_WAREHOUSE',
+          locationName: 'Test Location',
+          status: 'ACTIVE',
+          isActive: true,
+          facilityId: facility.id,
+          capacityWeight: 50000,
+          capacityContainers: 500,
+          maxWeight: 50000,
+          maxVolume: 10000,
+        }),
+      );
+      this.logger.log(`Created warehouse: ${warehouse.code}`);
+
+      // Create Yards
+      const yard1 = await yardRepo.save(
+        yardRepo.create({
+          warehouseId: warehouse.id,
+          code: 'YARD_001',
+          name: 'Container Yard 1',
+          type: 'CONTAINER_YARD',
+          status: 'ACTIVE',
+          isActive: true,
+          capacityWeight: 25000,
+          capacityContainers: 250,
+          maxWeight: 25000,
+          maxVolume: 5000,
+        }),
+      );
+
+      const yard2 = await yardRepo.save(
+        yardRepo.create({
+          warehouseId: warehouse.id,
+          code: 'YARD_002',
+          name: 'Bulk Yard 1',
+          type: 'BULK_YARD',
+          status: 'ACTIVE',
+          isActive: true,
+          capacityWeight: 25000,
+          capacityContainers: 100,
+          maxWeight: 25000,
+          maxVolume: 5000,
+        }),
+      );
+      this.logger.log(`Created yards: ${yard1.code}, ${yard2.code}`);
+
+      // Create Zones
+      const zone1 = await zoneRepo.save(
+        zoneRepo.create({
+          yardId: yard1.id,
+          code: 'ZONE_001',
+          name: 'Container Zone A',
+          type: 'CONTAINER_ZONE',
+          status: 'ACTIVE',
+          isActive: true,
+          capacityWeight: 12500,
+          capacityContainers: 125,
+          maxWeight: 12500,
+          maxVolume: 2500,
+        }),
+      );
+
+      const zone2 = await zoneRepo.save(
+        zoneRepo.create({
+          yardId: yard2.id,
+          code: 'ZONE_002',
+          name: 'Bulk Zone A',
+          type: 'BULK_ZONE',
+          status: 'ACTIVE',
+          isActive: true,
+          capacityWeight: 12500,
+          capacityContainers: 50,
+          maxWeight: 12500,
+          maxVolume: 2500,
+        }),
+      );
+      this.logger.log(`Created zones: ${zone1.code}, ${zone2.code}`);
+
+      // Create inventory in all statuses for testing
+      const statuses = ['RECEIVED', 'STORED', 'RESERVED', 'READY_FOR_LOADING', 'LOADED', 'DISPATCHED'] as const;
+      const now = new Date();
+
+      for (let i = 0; i < statuses.length; i++) {
+        const status = statuses[i];
+        const zone = i < 3 ? zone1 : zone2;
+
+        await inventoryRepo.save(
+          inventoryRepo.create({
+            warehouseId: warehouse.id,
+            yardId: zone.yardId,
+            zoneId: zone.id,
+            status: status as any,
+            quantity: 100 + i * 10,
+            weight: 500 + i * 50,
+            volume: 100 + i * 10,
+            arrivedAt: new Date(now.getTime() - i * 3600000),
+            storedAt: status !== 'RECEIVED' ? new Date(now.getTime() - (i - 1) * 3600000) : null,
+            reservedAt: ['RESERVED', 'READY_FOR_LOADING', 'LOADED', 'DISPATCHED'].includes(status) ? new Date() : null,
+            readyForLoadingAt: ['READY_FOR_LOADING', 'LOADED', 'DISPATCHED'].includes(status) ? new Date() : null,
+            loadedAt: ['LOADED', 'DISPATCHED'].includes(status) ? new Date() : null,
+            dispatchedAt: status === 'DISPATCHED' ? new Date() : null,
+          }),
+        );
+      }
+      this.logger.log('Created 6 test inventory items in all statuses');
+
+      this.logger.log('✅ Batch 1-4 test data seeded successfully');
+    } catch (error) {
+      this.logger.error(`Batch 1-4 seeder failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+}
diff --git a/apps/edr-freight-api/src/seed/indode-facility.seeder.ts b/apps/edr-freight-api/src/seed/indode-facility.seeder.ts
new file mode 100644
index 000000000..4b4ae23f0
--- /dev/null
+++ b/apps/edr-freight-api/src/seed/indode-facility.seeder.ts
@@ -0,0 +1,186 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { DataSource } from 'typeorm';
+
+import { Facility } from '../modules/facilities/entities/facility.entity';
+import { Warehouse } from '../modules/warehouses/entities/warehouse.entity';
+import { WarehouseYard, type WarehouseYardType } from '../modules/warehouses/entities/warehouse-yard.entity';
+import { WarehouseZone, type WarehouseZoneType } from '../modules/warehouses/entities/warehouse-zone.entity';
+
+const INDODE_FACILITY = {
+  code: 'INDODE_DRY_PORT',
+  name: 'Indode Multipurpose Dry Port',
+  description: 'Main facility for container and cargo handling',
+  facilityType: 'DRY_PORT' as const,
+  facilityStatus: 'ACTIVE' as const,
+  locationName: 'Indode',
+  country: 'Djibouti',
+  city: 'Djibouti',
+  address: 'Indode, Djibouti',
+  latitude: 11.5447,
+  longitude: 43.145,
+  capacity: 50000,
+  isActive: true,
+  notes: 'Primary dry port for container consolidation and distribution',
+};
+
+const WAREHOUSES = [
+  {
+    name: 'Open Warehouse - Indode',
+    code: 'INDODE_OPEN',
+    type: 'OPEN_WAREHOUSE' as const,
+    locationName: 'Indode Open',
+    capacityWeight: 25000,
+    capacityContainers: 500,
+    maxWeight: 25000,
+    maxVolume: 5000,
+    status: 'ACTIVE' as const,
+    isActive: true,
+  },
+  {
+    name: 'Closed Warehouse - Indode',
+    code: 'INDODE_CLOSED',
+    type: 'CLOSED_WAREHOUSE' as const,
+    locationName: 'Indode Closed',
+    capacityWeight: 20000,
+    capacityContainers: 400,
+    maxWeight: 20000,
+    maxVolume: 4000,
+    status: 'ACTIVE' as const,
+    isActive: true,
+  },
+];
+
+const YARD_TYPES = [
+  'CONTAINER_YARD',
+  'BULK_YARD',
+  'GENERAL_CARGO_YARD',
+  'HAZARDOUS_YARD',
+  'COLD_STORAGE_YARD',
+] as const;
+
+@Injectable()
+export class IndodeFacilitySeeder {
+  private readonly logger = new Logger(IndodeFacilitySeeder.name);
+
+  constructor(private readonly dataSource: DataSource) {}
+
+  async run(): Promise<void> {
+    try {
+      await this.dataSource.transaction(async (manager) => {
+        const facilityRepo = manager.getRepository(Facility);
+        const warehouseRepo = manager.getRepository(Warehouse);
+        const yardRepo = manager.getRepository(WarehouseYard);
+        const zoneRepo = manager.getRepository(WarehouseZone);
+
+        // Ensure facility exists
+        const facility = await facilityRepo.findOne({
+          where: { code: INDODE_FACILITY.code },
+        });
+
+        if (facility) {
+          this.logger.log('Indode facility already exists, skipping seed');
+          return;
+        }
+
+        const newFacility = facilityRepo.create(INDODE_FACILITY);
+        const savedFacility = await facilityRepo.save(newFacility);
+        this.logger.log(`Created facility: ${savedFacility.code}`);
+
+        // Create warehouses for the facility
+        for (const warehouseData of WAREHOUSES) {
+          try {
+            const warehouse = await warehouseRepo.findOne({
+              where: { code: warehouseData.code },
+            });
+
+            if (warehouse) {
+              this.logger.log(`Warehouse ${warehouseData.code} already exists, skipping`);
+              continue;
+            }
+
+            const newWarehouse = warehouseRepo.create({
+              ...warehouseData,
+              facilityId: savedFacility.id,
+            });
+            const savedWarehouse = await warehouseRepo.save(newWarehouse);
+            this.logger.log(`Created warehouse: ${savedWarehouse.code} under facility ${savedFacility.code}`);
+
+            // Create 11 yards per warehouse
+            await this.createYardsForWarehouse(yardRepo, zoneRepo, savedWarehouse);
+          } catch (warehouseError) {
+            this.logger.warn(
+              `Failed to create warehouse ${warehouseData.code}: ${warehouseError instanceof Error ? warehouseError.message : String(warehouseError)}`,
+            );
+          }
+        }
+
+        this.logger.log(
+          'Indode Multipurpose Dry Port facility seeded successfully with 2 warehouses and 11 yards each',
+        );
+      });
+    } catch (error) {
+      this.logger.error(
+        `IndodeFacilitySeeder error: ${error instanceof Error ? error.message : String(error)}`,
+      );
+    }
+  }
+
+  private async createYardsForWarehouse(
+    yardRepo: any,
+    zoneRepo: any,
+    warehouse: Warehouse,
+  ): Promise<void> {
+    const baseCapacityWeight = 5000;
+    const baseCapacityContainers = 100;
+    const yardCount = 11;
+
+    for (let i = 0; i < yardCount; i++) {
+      const yardType: WarehouseYardType = i < YARD_TYPES.length ? YARD_TYPES[i] : 'GENERAL_CARGO_YARD';
+      const yardCode = `${warehouse.code}_YARD_${String(i + 1).padStart(2, '0')}`;
+
+      const existingYard = await yardRepo.findOne({ where: { code: yardCode } });
+      if (existingYard) {
+        this.logger.log(`Yard ${yardCode} already exists, skipping`);
+        continue;
+      }
+
+      const yardData = {
+        warehouseId: warehouse.id,
+        name: `${warehouse.code} ${yardType.replace(/_/g, ' ')} ${String(i + 1).padStart(2, '0')}`,
+        code: yardCode,
+        type: yardType,
+        capacityWeight: baseCapacityWeight,
+        capacityContainers: baseCapacityContainers,
+        maxWeight: baseCapacityWeight,
+        maxVolume: baseCapacityWeight / 2,
+        status: 'ACTIVE' as const,
+        isActive: true,
+      };
+
+      const newYard = yardRepo.create(yardData);
+      const savedYard = (await yardRepo.save(newYard)) as WarehouseYard;
+      this.logger.log(`Created yard: ${savedYard.code}`);
+
+      // Create default zone for the yard
+      const zoneType: WarehouseZoneType = yardType.replace('_YARD', '_ZONE') as WarehouseZoneType;
+      const zoneCode = `${savedYard.code}_ZONE_A`;
+
+      const zoneData = {
+        yardId: savedYard.id,
+        name: `${savedYard.name} Zone A`,
+        code: zoneCode,
+        type: zoneType,
+        capacityWeight: (baseCapacityWeight ?? 1000) / 2,
+        capacityContainers: (baseCapacityContainers ?? 100) / 2,
+        maxWeight: (baseCapacityWeight ?? 1000) / 2,
+        maxVolume: (baseCapacityWeight ?? 500) / 2,
+        status: 'ACTIVE' as const,
+        isActive: true,
+      };
+
+      const newZone = zoneRepo.create(zoneData);
+      await zoneRepo.save(newZone);
+      this.logger.log(`Created zone: ${zoneCode}`);
+    }
+  }
+}
diff --git a/apps/edr-freight-web/backoffice/src/App.tsx b/apps/edr-freight-web/backoffice/src/App.tsx
index a384d5956..0c61cc445 100644
--- a/apps/edr-freight-web/backoffice/src/App.tsx
+++ b/apps/edr-freight-web/backoffice/src/App.tsx
@@ -6,12 +6,15 @@ import {
   LayoutGrid,
   Network,
   Paperclip,
+  PackageCheck,
+  Send,
   Settings,
   SlidersHorizontal,
   Train,
   Truck,
   Container,
   Package,
+  PackageOpen,
   Users,
   Wallet,
   //TrainTrack,
@@ -53,6 +56,17 @@ import { FREIGHT_PERMS, hasPermission as hasFreightPermission } from "./lib/perm
 import { RequirePermission } from "./components/auth/RequirePermission";
 import TrainDetailPage from "./pages/trains/TrainDetailPage";
 import RoutesPage from "./pages/fleet/RoutesPage";
+import WarehouseListPage from "./pages/warehouses/WarehouseListPage";
+import WarehouseDetailPage from "./pages/warehouses/WarehouseDetailPage";
+import WarehouseInventoryPage from "./pages/warehouses/WarehouseInventoryPage";
+import InventoryInquiryPage from "./pages/warehouses/InventoryInquiryPage";
+import WarehouseDashboardPage from "./pages/warehouses/WarehouseDashboardPage";
+import LoadingQueuePage from "./pages/warehouses/LoadingQueuePage";
+import LoadedInventoryPage from "./pages/warehouses/LoadedInventoryPage";
+import DispatchQueuePage from "./pages/warehouses/DispatchQueuePage";
+import ArrivalQueuePage from "./pages/warehouses/ArrivalQueuePage";
+import WarehouseRulesPage from "./pages/warehouses/WarehouseRulesPage";
+import WarehouseInvoicesPage from "./pages/warehouses/WarehouseInvoicesPage";
 
 const buildSidebarSections = (demoItems: SidebarItem[]): SidebarSection[] => [
   {
@@ -143,6 +157,61 @@ const buildSidebarSections = (demoItems: SidebarItem[]): SidebarSection[] => [
       // },
     ],
   },
+  {
+    title: "Warehouse Management",
+    items: [
+      {
+        label: "Warehouse Dashboard",
+        href: "/dashboard/warehouse-dashboard",
+        icon: <LayoutDashboard />,
+      },
+      {
+        label: "Warehouses",
+        href: "/dashboard/warehouses",
+        icon: <Container />,
+      },
+      {
+        label: "Inventory",
+        href: "/dashboard/warehouse-inventory",
+        icon: <Package />,
+      },
+      {
+        label: "Arrival Queue",
+        href: "/dashboard/arrival-queue",
+        icon: <PackageOpen />,
+      },
+      {
+        label: "Loading Queue",
+        href: "/dashboard/loading-queue",
+        icon: <Truck />,
+      },
+      {
+        label: "Loaded Inventory",
+        href: "/dashboard/loaded-inventory",
+        icon: <PackageCheck />,
+      },
+      {
+        label: "Dispatch Queue",
+        href: "/dashboard/dispatch-queue",
+        icon: <Send />,
+      },
+      {
+        label: "Inventory Inquiry",
+        href: "/dashboard/inventory-inquiry",
+        icon: <Boxes />,
+      },
+      {
+        label: "Allocation & Fees",
+        href: "/dashboard/warehouse-rules",
+        icon: <SlidersHorizontal />,
+      },
+      {
+        label: "Fee Invoices",
+        href: "/dashboard/warehouse-fee-invoices",
+        icon: <Wallet />,
+      },
+    ],
+  },
   {
     title: "Administration",
     items: [
@@ -303,6 +372,18 @@ const App = () => {
             path="booking-requests/:id/contract"
             element={<BookingContractPage />}
           />
+          <Route path="warehouses" element={<WarehouseListPage />} />
+          <Route path="warehouses/:id" element={<WarehouseDetailPage />} />
+          <Route path="warehouse-inventory" element={<WarehouseInventoryPage />} />
+          <Route path="arrival-queue" element={<ArrivalQueuePage />} />
+          <Route path="loading-queue" element={<LoadingQueuePage />} />
+          <Route path="loaded-inventory" element={<LoadedInventoryPage />} />
+          <Route path="dispatch-queue" element={<DispatchQueuePage />} />
+          <Route path="inventory-inquiry" element={<InventoryInquiryPage />} />
+          <Route path="warehouse-rules" element={<WarehouseRulesPage />} />
+          <Route path="warehouse-fee-invoices" element={<WarehouseInvoicesPage />} />
+          <Route path="warehouse-dashboard" element={<WarehouseDashboardPage />} />
+
           <Route
             path="operations/train-scheduling"
             element={<Navigate to="/dashboard/operations/train-scheduling-v2" replace />}
diff --git a/apps/edr-freight-web/backoffice/src/components/ErrorBoundary.tsx b/apps/edr-freight-web/backoffice/src/components/ErrorBoundary.tsx
new file mode 100644
index 000000000..00635118d
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/components/ErrorBoundary.tsx
@@ -0,0 +1,99 @@
+import { Component, type ErrorInfo, type ReactNode } from "react";
+
+interface ErrorBoundaryProps {
+  children: ReactNode;
+}
+
+interface ErrorBoundaryState {
+  error: Error | null;
+}
+
+/**
+ * App-wide error boundary. Without this, any render-time exception unmounts the
+ * React tree and the user sees a blank white screen. This surfaces the actual
+ * error message + stack so failures are diagnosable in place.
+ */
+export class ErrorBoundary extends Component<ErrorBoundaryProps, ErrorBoundaryState> {
+  state: ErrorBoundaryState = { error: null };
+
+  static getDerivedStateFromError(error: Error): ErrorBoundaryState {
+    return { error };
+  }
+
+  componentDidCatch(error: Error, info: ErrorInfo) {
+    // eslint-disable-next-line no-console
+    console.error("[ErrorBoundary] Uncaught render error:", error, info.componentStack);
+  }
+
+  handleReset = () => this.setState({ error: null });
+
+  render() {
+    const { error } = this.state;
+
+    if (!error) return this.props.children;
+
+    return (
+      <div
+        style={{
+          minHeight: "100vh",
+          display: "flex",
+          alignItems: "center",
+          justifyContent: "center",
+          padding: 24,
+          background: "#f8fafc",
+          fontFamily: "system-ui, sans-serif",
+        }}
+      >
+        <div
+          style={{
+            maxWidth: 720,
+            width: "100%",
+            background: "#fff",
+            border: "1px solid #fecaca",
+            borderRadius: 12,
+            padding: 24,
+            boxShadow: "0 1px 3px rgba(0,0,0,0.08)",
+          }}
+        >
+          <h2 style={{ margin: 0, color: "#b91c1c", fontSize: 18 }}>Something went wrong</h2>
+          <p style={{ color: "#64748b", fontSize: 14 }}>
+            A render error was caught. Details below — share this with the developer.
+          </p>
+          <pre
+            style={{
+              whiteSpace: "pre-wrap",
+              wordBreak: "break-word",
+              background: "#0f172a",
+              color: "#fca5a5",
+              padding: 16,
+              borderRadius: 8,
+              fontSize: 12,
+              maxHeight: 320,
+              overflow: "auto",
+            }}
+          >
+            {error.message}
+            {"\n\n"}
+            {error.stack}
+          </pre>
+          <button
+            type="button"
+            onClick={this.handleReset}
+            style={{
+              marginTop: 12,
+              padding: "8px 16px",
+              border: "none",
+              borderRadius: 8,
+              background: "#0f766e",
+              color: "#fff",
+              cursor: "pointer",
+              fontSize: 14,
+            }}
+          >
+            Dismiss
+          </button>
+        </div>
+      </div>
+    );
+  }
+}
diff --git a/apps/edr-freight-web/backoffice/src/components/cargoes/DeliverCargoDialog.tsx b/apps/edr-freight-web/backoffice/src/components/cargoes/DeliverCargoDialog.tsx
new file mode 100644
index 000000000..caa554a10
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/components/cargoes/DeliverCargoDialog.tsx
@@ -0,0 +1,96 @@
+import { useState } from 'react';
+import { PackageCheck } from 'lucide-react';
+
+import { Button } from '@/components/ui/button';
+import { Dialog, DialogContent, DialogHeader, DialogTitle, DialogTrigger } from '@/components/ui/dialog';
+import { Input } from '@/components/ui/input';
+import { Label } from '@/components/ui/label';
+import { Textarea } from '@/components/ui/textarea';
+import { useDeliverCargo } from '@/hooks/useCargoes';
+import { useToast } from '@/hooks/use-toast';
+
+/**
+ * Customer Pickup + Proof of Delivery capture for a LOADED cargo.
+ * Records receiver name, pickup date and remarks, then marks the cargo DELIVERED.
+ */
+export function DeliverCargoDialog({ cargoId, onSuccess }: { cargoId: string; onSuccess?: () => void }) {
+  const [open, setOpen] = useState(false);
+  const [receiverName, setReceiverName] = useState('');
+  const [pickupDate, setPickupDate] = useState('');
+  const [deliveryRemarks, setDeliveryRemarks] = useState('');
+  const deliver = useDeliverCargo();
+  const { toast } = useToast();
+
+  const handleDeliver = async () => {
+    if (!receiverName.trim()) {
+      toast({ title: 'Receiver name is required', variant: 'destructive' });
+      return;
+    }
+    try {
+      await deliver.mutateAsync({
+        id: cargoId,
+        payload: {
+          receiverName: receiverName.trim(),
+          pickupDate: pickupDate ? new Date(pickupDate).toISOString() : undefined,
+          deliveryRemarks: deliveryRemarks.trim() || undefined,
+        },
+      });
+      toast({ title: 'Delivered', description: 'Proof of delivery recorded; cargo marked delivered.' });
+      setOpen(false);
+      setReceiverName('');
+      setPickupDate('');
+      setDeliveryRemarks('');
+      onSuccess?.();
+    } catch (error) {
+      const message =
+        (error as { response?: { data?: { message?: string } } })?.response?.data?.message ??
+        'Could not record delivery.';
+      toast({ title: 'Delivery failed', description: String(message), variant: 'destructive' });
+    }
+  };
+
+  return (
+    <Dialog open={open} onOpenChange={setOpen}>
+      <DialogTrigger asChild>
+        <Button variant="ghost" size="icon" title="Customer pickup / Proof of delivery">
+          <PackageCheck className="size-4" />
+        </Button>
+      </DialogTrigger>
+      <DialogContent>
+        <DialogHeader>
+          <DialogTitle>Customer Pickup &amp; Proof of Delivery</DialogTitle>
+        </DialogHeader>
+        <div className="space-y-4">
+          <div>
+            <Label>Receiver name*</Label>
+            <Input
+              required
+              value={receiverName}
+              placeholder="Name of person collecting the cargo"
+              onChange={(e) => setReceiverName(e.target.value)}
+            />
+          </div>
+          <div>
+            <Label>Pickup date</Label>
+            <Input
+              type="datetime-local"
+              value={pickupDate}
+              onChange={(e) => setPickupDate(e.target.value)}
+            />
+          </div>
+          <div>
+            <Label>Remarks</Label>
+            <Textarea
+              value={deliveryRemarks}
+              placeholder="Condition on handover, ID checked, etc."
+              onChange={(e) => setDeliveryRemarks(e.target.value)}
+            />
+          </div>
+          <Button onClick={handleDeliver} disabled={deliver.isPending} className="w-full">
+            {deliver.isPending ? 'Recording…' : 'Confirm Pickup & Mark Delivered'}
+          </Button>
+        </div>
+      </DialogContent>
+    </Dialog>
+  );
+}
diff --git a/apps/edr-freight-web/backoffice/src/components/warehouses/ActivityTimeline.tsx b/apps/edr-freight-web/backoffice/src/components/warehouses/ActivityTimeline.tsx
new file mode 100644
index 000000000..49e8828dd
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/components/warehouses/ActivityTimeline.tsx
@@ -0,0 +1,62 @@
+import { Center, Loader, Text, Timeline } from '@mantine/core';
+import {
+  ArrowRightLeft,
+  ClipboardCheck,
+  PackageCheck,
+  PackagePlus,
+  Send,
+  Truck,
+  Warehouse,
+} from 'lucide-react';
+
+import { useInventoryActivity } from '@/hooks/useWarehouses';
+import type { ActivityType } from '@/types/warehouse';
+import { formatDate, humanizeEnum } from './options';
+
+const activityIcon: Record<ActivityType, React.ReactNode> = {
+  INVENTORY_RECEIVED: <PackagePlus size={14} />,
+  INVENTORY_STORED: <Warehouse size={14} />,
+  INVENTORY_MOVED: <ArrowRightLeft size={14} />,
+  INVENTORY_RESERVED: <ClipboardCheck size={14} />,
+  READY_FOR_LOADING: <PackageCheck size={14} />,
+  INVENTORY_LOADED: <Truck size={14} />,
+  INVENTORY_DISPATCHED: <Send size={14} />,
+};
+
+export function ActivityTimeline({ inventoryId }: { inventoryId: string }) {
+  const { data, isLoading } = useInventoryActivity(inventoryId);
+  const items = data ?? [];
+
+  if (isLoading) {
+    return (
+      <Center py="lg">
+        <Loader size="sm" />
+      </Center>
+    );
+  }
+
+  if (items.length === 0) {
+    return (
+      <Text c="dimmed" ta="center" py="md" size="sm">
+        No activity recorded yet.
+      </Text>
+    );
+  }
+
+  return (
+    <Timeline active={items.length} bulletSize={24} lineWidth={2}>
+      {items.map((log) => (
+        <Timeline.Item key={log.id} bullet={activityIcon[log.activityType]} title={humanizeEnum(log.activityType)}>
+          {log.description && (
+            <Text size="sm" c="dimmed">
+              {log.description}
+            </Text>
+          )}
+          <Text size="xs" mt={4} c="dimmed">
+            {log.performedBy ?? 'system'} · {formatDate(log.createdAt)}
+          </Text>
+        </Timeline.Item>
+      ))}
+    </Timeline>
+  );
+}
diff --git a/apps/edr-freight-web/backoffice/src/components/warehouses/BookingSelect.tsx b/apps/edr-freight-web/backoffice/src/components/warehouses/BookingSelect.tsx
new file mode 100644
index 000000000..5da428c29
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/components/warehouses/BookingSelect.tsx
@@ -0,0 +1,41 @@
+import { Select } from '@mantine/core';
+import { useQuery } from '@tanstack/react-query';
+
+import { bookingsService } from '@/services/bookings.service';
+
+interface BookingSelectProps {
+  value: string;
+  onChange: (bookingId: string) => void;
+  label?: string;
+  required?: boolean;
+  /** Comma-separated statuses to restrict the list (e.g. "PAID" for reservations). */
+  statuses?: string;
+}
+
+/** Searchable booking picker — shows the human reference (e.g. BKG-BULK-002), submits the UUID. */
+export function BookingSelect({ value, onChange, label = 'Booking', required, statuses }: BookingSelectProps) {
+  const { data, isLoading } = useQuery({
+    queryKey: ['bookings', 'options', statuses ?? 'all'],
+    queryFn: () =>
+      bookingsService.list({ pageSize: 200, ...(statuses ? { statuses } : {}) }).then((r) => r.items),
+  });
+
+  const options = (data ?? []).map((b) => ({
+    value: b.id,
+    label: b.status ? `${b.reference} · ${b.status}` : b.reference,
+  }));
+
+  return (
+    <Select
+      label={label}
+      required={required}
+      searchable
+      clearable
+      data={options}
+      value={value || null}
+      onChange={(v) => onChange(v ?? '')}
+      placeholder={isLoading ? 'Loading bookings…' : 'Search booking reference'}
+      nothingFoundMessage="No bookings found"
+    />
+  );
+}
diff --git a/apps/edr-freight-web/backoffice/src/components/warehouses/CreateWarehouseModal.tsx b/apps/edr-freight-web/backoffice/src/components/warehouses/CreateWarehouseModal.tsx
new file mode 100644
index 000000000..87d5f2946
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/components/warehouses/CreateWarehouseModal.tsx
@@ -0,0 +1,202 @@
+import { useEffect, useState } from 'react';
+import {
+  Button,
+  Group,
+  Modal,
+  NumberInput,
+  Select,
+  Stack,
+  TextInput,
+} from '@mantine/core';
+
+import { useToast } from '@/hooks/use-toast';
+import { useStations } from '@/hooks/useStations';
+import { useCreateWarehouse, useUpdateWarehouse } from '@/hooks/useWarehouses';
+import type { SaveWarehousePayload, Warehouse, WarehouseType } from '@/types/warehouse';
+import { extractErrorMessage, statusOptions, warehouseTypeOptions } from './options';
+
+interface CreateWarehouseModalProps {
+  opened: boolean;
+  onClose: () => void;
+  warehouse?: Warehouse | null;
+}
+
+interface FormState {
+  name: string;
+  code: string;
+  type: WarehouseType;
+  stationId: string | null;
+  locationName: string;
+  capacityWeight: number | '';
+  capacityContainers: number | '';
+  maxVolume: number | '';
+  status: 'ACTIVE' | 'INACTIVE';
+}
+
+const emptyForm = (): FormState => ({
+  name: '',
+  code: '',
+  type: 'OPEN_WAREHOUSE',
+  stationId: null,
+  locationName: '',
+  capacityWeight: '',
+  capacityContainers: '',
+  maxVolume: '',
+  status: 'ACTIVE',
+});
+
+export function CreateWarehouseModal({ opened, onClose, warehouse }: CreateWarehouseModalProps) {
+  const isEdit = Boolean(warehouse);
+  const { toast } = useToast();
+  const createMutation = useCreateWarehouse();
+  const updateMutation = useUpdateWarehouse();
+  const { data: stations } = useStations();
+  const [form, setForm] = useState<FormState>(emptyForm());
+
+  const stationOptions = (stations ?? []).map((s) => ({ value: s.id, label: `${s.name} (${s.code})` }));
+
+  useEffect(() => {
+    if (opened) {
+      setForm(
+        warehouse
+          ? {
+              name: warehouse.name,
+              code: warehouse.code,
+              type: warehouse.type,
+              stationId: warehouse.stationId ?? null,
+              locationName: warehouse.locationName ?? '',
+              capacityWeight: warehouse.capacityWeight ?? '',
+              capacityContainers: warehouse.capacityContainers ?? '',
+              maxVolume: warehouse.maxVolume ?? '',
+              status: warehouse.status,
+            }
+          : emptyForm(),
+      );
+    }
+  }, [opened, warehouse]);
+
+  const submitting = createMutation.isPending || updateMutation.isPending;
+
+  const handleSubmit = async () => {
+    if (!form.name.trim() || !form.code.trim()) {
+      toast({ variant: 'destructive', title: 'Name and code are required' });
+      return;
+    }
+
+    const payload: SaveWarehousePayload = {
+      name: form.name.trim(),
+      code: form.code.trim(),
+      type: form.type,
+      stationId: form.stationId ?? undefined,
+      locationName: form.locationName.trim() || undefined,
+      capacityWeight: form.capacityWeight === '' ? undefined : Number(form.capacityWeight),
+      capacityContainers: form.capacityContainers === '' ? undefined : Number(form.capacityContainers),
+      maxVolume: form.maxVolume === '' ? undefined : Number(form.maxVolume),
+    };
+
+    try {
+      if (warehouse) {
+        await updateMutation.mutateAsync({ id: warehouse.id, payload: { ...payload, status: form.status } });
+        toast({ title: 'Warehouse updated' });
+      } else {
+        await createMutation.mutateAsync(payload);
+        toast({ title: 'Warehouse created' });
+      }
+      onClose();
+    } catch (error) {
+      toast({ variant: 'destructive', title: 'Save failed', description: extractErrorMessage(error) });
+    }
+  };
+
+  return (
+    <Modal opened={opened} onClose={onClose} title={isEdit ? 'Edit warehouse' : 'Create warehouse'} centered size="lg">
+      <Stack gap="md">
+        <Group grow>
+          <TextInput
+            label="Name"
+            placeholder="Modjo Open Warehouse"
+            required
+            value={form.name}
+            onChange={(e) => { const v = e.currentTarget.value; setForm((f) => ({ ...f, name: v })); }}
+          />
+          <TextInput
+            label="Code"
+            placeholder="MODJO-OW"
+            required
+            value={form.code}
+            onChange={(e) => { const v = e.currentTarget.value; setForm((f) => ({ ...f, code: v })); }}
+          />
+        </Group>
+
+        <Select
+          label="Facility / Port (Station)"
+          placeholder="Select parent station"
+          data={stationOptions}
+          value={form.stationId}
+          onChange={(value) => setForm((f) => ({ ...f, stationId: value }))}
+          searchable
+          clearable
+        />
+
+        <Group grow>
+          <Select
+            label="Type"
+            data={warehouseTypeOptions}
+            value={form.type}
+            onChange={(value) => setForm((f) => ({ ...f, type: (value as WarehouseType) ?? 'OPEN_WAREHOUSE' }))}
+            allowDeselect={false}
+          />
+          {isEdit && (
+            <Select
+              label="Status"
+              data={statusOptions}
+              value={form.status}
+              onChange={(value) => setForm((f) => ({ ...f, status: (value as 'ACTIVE' | 'INACTIVE') ?? 'ACTIVE' }))}
+              allowDeselect={false}
+            />
+          )}
+        </Group>
+
+        <TextInput
+          label="Location name"
+          placeholder="Modjo, Oromia"
+          value={form.locationName}
+          onChange={(e) => { const v = e.currentTarget.value; setForm((f) => ({ ...f, locationName: v })); }}
+        />
+
+        <Group grow>
+          <NumberInput
+            label="Capacity weight (kg)"
+            placeholder="Optional"
+            min={0}
+            value={form.capacityWeight}
+            onChange={(value) => setForm((f) => ({ ...f, capacityWeight: value === '' ? '' : Number(value) }))}
+          />
+          <NumberInput
+            label="Capacity containers"
+            placeholder="Optional"
+            min={0}
+            value={form.capacityContainers}
+            onChange={(value) => setForm((f) => ({ ...f, capacityContainers: value === '' ? '' : Number(value) }))}
+          />
+          <NumberInput
+            label="Max volume (m³)"
+            placeholder="Optional"
+            min={0}
+            value={form.maxVolume}
+            onChange={(value) => setForm((f) => ({ ...f, maxVolume: value === '' ? '' : Number(value) }))}
+          />
+        </Group>
+
+        <Group justify="flex-end" mt="sm">
+          <Button variant="default" onClick={onClose} disabled={submitting}>
+            Cancel
+          </Button>
+          <Button onClick={handleSubmit} loading={submitting}>
+            {isEdit ? 'Save changes' : 'Create warehouse'}
+          </Button>
+        </Group>
+      </Stack>
+    </Modal>
+  );
+}
diff --git a/apps/edr-freight-web/backoffice/src/components/warehouses/CreateYardModal.tsx b/apps/edr-freight-web/backoffice/src/components/warehouses/CreateYardModal.tsx
new file mode 100644
index 000000000..9ef9ef26c
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/components/warehouses/CreateYardModal.tsx
@@ -0,0 +1,166 @@
+import { useEffect, useState } from 'react';
+import { Button, Group, Modal, NumberInput, Select, Stack, TextInput } from '@mantine/core';
+
+import { useToast } from '@/hooks/use-toast';
+import { useCreateYard, useUpdateYard } from '@/hooks/useWarehouses';
+import type { SaveYardPayload, WarehouseYard, WarehouseYardType } from '@/types/warehouse';
+import { extractErrorMessage, statusOptions, yardTypeOptions } from './options';
+
+interface CreateYardModalProps {
+  opened: boolean;
+  onClose: () => void;
+  warehouseId: string;
+  yard?: WarehouseYard | null;
+}
+
+interface FormState {
+  name: string;
+  code: string;
+  type: WarehouseYardType;
+  capacityWeight: number | '';
+  capacityContainers: number | '';
+  maxVolume: number | '';
+  status: 'ACTIVE' | 'INACTIVE';
+}
+
+const emptyForm = (): FormState => ({
+  name: '',
+  code: '',
+  type: 'CONTAINER_YARD',
+  capacityWeight: '',
+  capacityContainers: '',
+  maxVolume: '',
+  status: 'ACTIVE',
+});
+
+export function CreateYardModal({ opened, onClose, warehouseId, yard }: CreateYardModalProps) {
+  const isEdit = Boolean(yard);
+  const { toast } = useToast();
+  const createMutation = useCreateYard();
+  const updateMutation = useUpdateYard();
+  const [form, setForm] = useState<FormState>(emptyForm());
+
+  useEffect(() => {
+    if (opened) {
+      setForm(
+        yard
+          ? {
+              name: yard.name,
+              code: yard.code,
+              type: yard.type,
+              capacityWeight: yard.capacityWeight ?? '',
+              capacityContainers: yard.capacityContainers ?? '',
+              maxVolume: yard.maxVolume ?? '',
+              status: yard.status,
+            }
+          : emptyForm(),
+      );
+    }
+  }, [opened, yard]);
+
+  const submitting = createMutation.isPending || updateMutation.isPending;
+
+  const handleSubmit = async () => {
+    if (!form.name.trim() || !form.code.trim()) {
+      toast({ variant: 'destructive', title: 'Name and code are required' });
+      return;
+    }
+
+    const payload: SaveYardPayload = {
+      name: form.name.trim(),
+      code: form.code.trim(),
+      type: form.type,
+      capacityWeight: form.capacityWeight === '' ? undefined : Number(form.capacityWeight),
+      capacityContainers: form.capacityContainers === '' ? undefined : Number(form.capacityContainers),
+      maxVolume: form.maxVolume === '' ? undefined : Number(form.maxVolume),
+    };
+
+    try {
+      if (yard) {
+        await updateMutation.mutateAsync({ id: yard.id, payload: { ...payload, status: form.status } });
+        toast({ title: 'Yard updated' });
+      } else {
+        await createMutation.mutateAsync({ warehouseId, payload });
+        toast({ title: 'Yard created' });
+      }
+      onClose();
+    } catch (error) {
+      toast({ variant: 'destructive', title: 'Save failed', description: extractErrorMessage(error) });
+    }
+  };
+
+  return (
+    <Modal opened={opened} onClose={onClose} title={isEdit ? 'Edit yard' : 'Create yard'} centered size="lg">
+      <Stack gap="md">
+        <Group grow>
+          <TextInput
+            label="Name"
+            placeholder="Container Yard A"
+            required
+            value={form.name}
+            onChange={(e) => { const v = e.currentTarget.value; setForm((f) => ({ ...f, name: v })); }}
+          />
+          <TextInput
+            label="Code"
+            placeholder="CY-A"
+            required
+            value={form.code}
+            onChange={(e) => { const v = e.currentTarget.value; setForm((f) => ({ ...f, code: v })); }}
+          />
+        </Group>
+
+        <Group grow>
+          <Select
+            label="Type"
+            data={yardTypeOptions}
+            value={form.type}
+            onChange={(value) => setForm((f) => ({ ...f, type: (value as WarehouseYardType) ?? 'CONTAINER_YARD' }))}
+            allowDeselect={false}
+          />
+          {isEdit && (
+            <Select
+              label="Status"
+              data={statusOptions}
+              value={form.status}
+              onChange={(value) => setForm((f) => ({ ...f, status: (value as 'ACTIVE' | 'INACTIVE') ?? 'ACTIVE' }))}
+              allowDeselect={false}
+            />
+          )}
+        </Group>
+
+        <Group grow>
+          <NumberInput
+            label="Capacity weight (kg)"
+            placeholder="Optional"
+            min={0}
+            value={form.capacityWeight}
+            onChange={(value) => setForm((f) => ({ ...f, capacityWeight: value === '' ? '' : Number(value) }))}
+          />
+          <NumberInput
+            label="Capacity containers"
+            placeholder="Optional"
+            min={0}
+            value={form.capacityContainers}
+            onChange={(value) => setForm((f) => ({ ...f, capacityContainers: value === '' ? '' : Number(value) }))}
+          />
+          <NumberInput
+            label="Max volume (m³)"
+            placeholder="Optional"
+            min={0}
+            value={form.maxVolume}
+            onChange={(value) => setForm((f) => ({ ...f, maxVolume: value === '' ? '' : Number(value) }))}
+          />
+        </Group>
+
+        <Group justify="flex-end" mt="sm">
+          <Button variant="default" onClick={onClose} disabled={submitting}>
+            Cancel
+          </Button>
+          <Button onClick={handleSubmit} loading={submitting}>
+            {isEdit ? 'Save changes' : 'Create yard'}
+          </Button>
+        </Group>
+      </Stack>
+    </Modal>
+  );
+}
diff --git a/apps/edr-freight-web/backoffice/src/components/warehouses/CreateZoneModal.tsx b/apps/edr-freight-web/backoffice/src/components/warehouses/CreateZoneModal.tsx
new file mode 100644
index 000000000..7a67e4ff1
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/components/warehouses/CreateZoneModal.tsx
@@ -0,0 +1,166 @@
+import { useEffect, useState } from 'react';
+import { Button, Group, Modal, NumberInput, Select, Stack, TextInput } from '@mantine/core';
+
+import { useToast } from '@/hooks/use-toast';
+import { useCreateZone, useUpdateZone } from '@/hooks/useWarehouses';
+import type { SaveZonePayload, WarehouseZone, WarehouseZoneType } from '@/types/warehouse';
+import { extractErrorMessage, statusOptions, zoneTypeOptions } from './options';
+
+interface CreateZoneModalProps {
+  opened: boolean;
+  onClose: () => void;
+  yardId: string;
+  zone?: WarehouseZone | null;
+}
+
+interface FormState {
+  name: string;
+  code: string;
+  type: WarehouseZoneType;
+  capacityWeight: number | '';
+  capacityContainers: number | '';
+  maxVolume: number | '';
+  status: 'ACTIVE' | 'INACTIVE';
+}
+
+const emptyForm = (): FormState => ({
+  name: '',
+  code: '',
+  type: 'CONTAINER_ZONE',
+  capacityWeight: '',
+  capacityContainers: '',
+  maxVolume: '',
+  status: 'ACTIVE',
+});
+
+export function CreateZoneModal({ opened, onClose, yardId, zone }: CreateZoneModalProps) {
+  const isEdit = Boolean(zone);
+  const { toast } = useToast();
+  const createMutation = useCreateZone();
+  const updateMutation = useUpdateZone();
+  const [form, setForm] = useState<FormState>(emptyForm());
+
+  useEffect(() => {
+    if (opened) {
+      setForm(
+        zone
+          ? {
+              name: zone.name,
+              code: zone.code,
+              type: zone.type,
+              capacityWeight: zone.capacityWeight ?? '',
+              capacityContainers: zone.capacityContainers ?? '',
+              maxVolume: zone.maxVolume ?? '',
+              status: zone.status,
+            }
+          : emptyForm(),
+      );
+    }
+  }, [opened, zone]);
+
+  const submitting = createMutation.isPending || updateMutation.isPending;
+
+  const handleSubmit = async () => {
+    if (!form.name.trim() || !form.code.trim()) {
+      toast({ variant: 'destructive', title: 'Name and code are required' });
+      return;
+    }
+
+    const payload: SaveZonePayload = {
+      name: form.name.trim(),
+      code: form.code.trim(),
+      type: form.type,
+      capacityWeight: form.capacityWeight === '' ? undefined : Number(form.capacityWeight),
+      capacityContainers: form.capacityContainers === '' ? undefined : Number(form.capacityContainers),
+      maxVolume: form.maxVolume === '' ? undefined : Number(form.maxVolume),
+    };
+
+    try {
+      if (zone) {
+        await updateMutation.mutateAsync({ id: zone.id, payload: { ...payload, status: form.status } });
+        toast({ title: 'Zone updated' });
+      } else {
+        await createMutation.mutateAsync({ yardId, payload });
+        toast({ title: 'Zone created' });
+      }
+      onClose();
+    } catch (error) {
+      toast({ variant: 'destructive', title: 'Save failed', description: extractErrorMessage(error) });
+    }
+  };
+
+  return (
+    <Modal opened={opened} onClose={onClose} title={isEdit ? 'Edit zone' : 'Create zone'} centered size="lg">
+      <Stack gap="md">
+        <Group grow>
+          <TextInput
+            label="Name"
+            placeholder="Zone A-01"
+            required
+            value={form.name}
+            onChange={(e) => { const v = e.currentTarget.value; setForm((f) => ({ ...f, name: v })); }}
+          />
+          <TextInput
+            label="Code"
+            placeholder="A-01"
+            required
+            value={form.code}
+            onChange={(e) => { const v = e.currentTarget.value; setForm((f) => ({ ...f, code: v })); }}
+          />
+        </Group>
+
+        <Group grow>
+          <Select
+            label="Type"
+            data={zoneTypeOptions}
+            value={form.type}
+            onChange={(value) => setForm((f) => ({ ...f, type: (value as WarehouseZoneType) ?? 'CONTAINER_ZONE' }))}
+            allowDeselect={false}
+          />
+          {isEdit && (
+            <Select
+              label="Status"
+              data={statusOptions}
+              value={form.status}
+              onChange={(value) => setForm((f) => ({ ...f, status: (value as 'ACTIVE' | 'INACTIVE') ?? 'ACTIVE' }))}
+              allowDeselect={false}
+            />
+          )}
+        </Group>
+
+        <Group grow>
+          <NumberInput
+            label="Capacity weight (kg)"
+            placeholder="Optional"
+            min={0}
+            value={form.capacityWeight}
+            onChange={(value) => setForm((f) => ({ ...f, capacityWeight: value === '' ? '' : Number(value) }))}
+          />
+          <NumberInput
+            label="Capacity containers"
+            placeholder="Optional"
+            min={0}
+            value={form.capacityContainers}
+            onChange={(value) => setForm((f) => ({ ...f, capacityContainers: value === '' ? '' : Number(value) }))}
+          />
+          <NumberInput
+            label="Max volume (m³)"
+            placeholder="Optional"
+            min={0}
+            value={form.maxVolume}
+            onChange={(value) => setForm((f) => ({ ...f, maxVolume: value === '' ? '' : Number(value) }))}
+          />
+        </Group>
+
+        <Group justify="flex-end" mt="sm">
+          <Button variant="default" onClick={onClose} disabled={submitting}>
+            Cancel
+          </Button>
+          <Button onClick={handleSubmit} loading={submitting}>
+            {isEdit ? 'Save changes' : 'Create zone'}
+          </Button>
+        </Group>
+      </Stack>
+    </Modal>
+  );
+}
diff --git a/apps/edr-freight-web/backoffice/src/components/warehouses/FeePreviewModal.tsx b/apps/edr-freight-web/backoffice/src/components/warehouses/FeePreviewModal.tsx
new file mode 100644
index 000000000..1d7a8316d
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/components/warehouses/FeePreviewModal.tsx
@@ -0,0 +1,194 @@
+import { Badge, Button, Card, Divider, Group, Loader, Modal, Stack, Text } from '@mantine/core';
+import { CalendarClock, Coins, DoorOpen, FileText } from 'lucide-react';
+
+import { useToast } from '@/hooks/use-toast';
+import {
+  useFeePreview,
+  useGateClearance,
+  useGenerateInvoice,
+  useInvoicesForInventory,
+} from '@/hooks/useWarehouses';
+import { extractErrorMessage } from './options';
+import type { FeePreview, WarehouseInvoiceStatus } from '@/types/warehouse';
+
+const INVOICE_STATUS_COLOR: Record<WarehouseInvoiceStatus, string> = {
+  DRAFT: 'gray',
+  ISSUED: 'orange',
+  PARTIALLY_PAID: 'yellow',
+  PAID: 'green',
+  CANCELLED: 'gray',
+};
+
+interface FeePreviewModalProps {
+  opened: boolean;
+  onClose: () => void;
+  inventoryId: string | null;
+}
+
+const LABELS: Record<string, { label: string; color: string }> = {
+  DEMURRAGE_FEE: { label: 'Demurrage', color: 'orange' },
+  STORAGE_FEE: { label: 'Storage', color: 'teal' },
+};
+
+function fmtDate(iso: string | null) {
+  if (!iso) return '—';
+  return new Date(iso).toLocaleDateString();
+}
+
+function FeeCard({ fee }: { fee: FeePreview }) {
+  const meta = LABELS[fee.ruleType] ?? { label: fee.ruleType, color: 'gray' };
+  const configured = Boolean(fee.ruleId);
+  return (
+    <Card withBorder radius="md" padding="md" style={{ borderColor: `var(--mantine-color-${meta.color}-3)` }}>
+      <Group justify="space-between" mb="xs">
+        <Group gap="xs">
+          <Coins size={16} />
+          <Text fw={700}>{meta.label}</Text>
+          {fee.endIsOpen && (
+            <Badge size="xs" color={meta.color} variant="light">
+              accruing
+            </Badge>
+          )}
+        </Group>
+        <Text fw={800} size="lg" c={`${meta.color}.7`}>
+          {fee.amount.toLocaleString()} {fee.currency}
+        </Text>
+      </Group>
+
+      {!configured ? (
+        <Text size="xs" c="dimmed">
+          No active {meta.label.toLowerCase()} rule configured — amount shown as 0.
+        </Text>
+      ) : (
+        <Stack gap={4}>
+          <Row label="Rule" value={fee.ruleName ?? '—'} />
+          <Row label="Free days" value={String(fee.freeDays)} />
+          <Row label="Rate / day" value={`${fee.ratePerDay.toLocaleString()} ${fee.currency}`} />
+          <Row label="Period" value={`${fmtDate(fee.startDate)} → ${fmtDate(fee.endDate)}${fee.endIsOpen ? ' (today)' : ''}`} />
+          <Row label="Elapsed days" value={String(fee.elapsedDays)} />
+          <Row label="Chargeable days" value={`${fee.chargeableDays} (after ${fee.freeDays} free)`} />
+        </Stack>
+      )}
+    </Card>
+  );
+}
+
+function Row({ label, value }: { label: string; value: string }) {
+  return (
+    <Group justify="space-between" wrap="nowrap">
+      <Text size="xs" c="dimmed">
+        {label}
+      </Text>
+      <Text size="sm">{value}</Text>
+    </Group>
+  );
+}
+
+/** Batch 5 fee preview + Batch 6 invoice generation / gate clearance for an inventory item. */
+export function FeePreviewModal({ opened, onClose, inventoryId }: FeePreviewModalProps) {
+  const { toast } = useToast();
+  const enabledId = opened ? inventoryId ?? undefined : undefined;
+  const { data, isLoading } = useFeePreview(enabledId);
+  const { data: invoices } = useInvoicesForInventory(enabledId);
+  const generate = useGenerateInvoice();
+  const gateClear = useGateClearance();
+
+  const activeInvoice = (invoices ?? []).find((i) => i.status !== 'CANCELLED');
+
+  const handleGenerate = async (confirmZero = false) => {
+    if (!inventoryId) return;
+    try {
+      const inv = await generate.mutateAsync({ inventoryId, confirmZero });
+      toast({ title: 'Invoice generated', description: `${inv.invoiceNumber} — ${inv.totalAmount} ${inv.currency}` });
+    } catch (error) {
+      const msg = extractErrorMessage(error);
+      if (/no payable warehouse fee/i.test(msg)) {
+        if (window.confirm('No payable warehouse fee found. Create a zero-amount invoice anyway?')) {
+          handleGenerate(true);
+        }
+        return;
+      }
+      toast({ variant: 'destructive', title: 'Generate failed', description: msg });
+    }
+  };
+
+  const handleGateClearance = async () => {
+    if (!inventoryId) return;
+    try {
+      await gateClear.mutateAsync(inventoryId);
+      toast({ title: 'Gate clearance recorded', description: 'Item released from terminal.' });
+      onClose();
+    } catch (error) {
+      toast({ variant: 'destructive', title: 'Release blocked', description: extractErrorMessage(error) });
+    }
+  };
+
+  return (
+    <Modal
+      opened={opened}
+      onClose={onClose}
+      title={
+        <Group gap="xs">
+          <CalendarClock size={18} />
+          <Text fw={700}>Storage &amp; Demurrage Preview</Text>
+        </Group>
+      }
+      centered
+      size="md"
+    >
+      {isLoading ? (
+        <Group justify="center" py="xl">
+          <Loader />
+        </Group>
+      ) : (
+        <Stack gap="md">
+          {(data ?? []).map((fee) => (
+            <FeeCard key={fee.ruleType} fee={fee} />
+          ))}
+
+          <Divider label="Invoice & Release" labelPosition="left" />
+
+          {activeInvoice ? (
+            <Group justify="space-between">
+              <Group gap="xs">
+                <FileText size={16} />
+                <Text size="sm" fw={600}>{activeInvoice.invoiceNumber}</Text>
+                <Badge variant="light" color={INVOICE_STATUS_COLOR[activeInvoice.status]}>
+                  {activeInvoice.status.replace(/_/g, ' ')}
+                </Badge>
+              </Group>
+              <Text size="sm">
+                {Number(activeInvoice.balanceAmount).toLocaleString()} {activeInvoice.currency} due
+              </Text>
+            </Group>
+          ) : (
+            <Button
+              variant="light"
+              color="orange"
+              leftSection={<FileText size={16} />}
+              loading={generate.isPending}
+              onClick={() => handleGenerate(false)}
+            >
+              Generate Fee Invoice
+            </Button>
+          )}
+
+          <Button
+            variant="light"
+            color="green"
+            leftSection={<DoorOpen size={16} />}
+            loading={gateClear.isPending}
+            onClick={handleGateClearance}
+          >
+            Gate Clearance / Release
+          </Button>
+
+          <Text size="xs" c="dimmed">
+            Charges accrue from arrival until gate clearance / release. Final release is blocked while a
+            demurrage/storage invoice is unpaid.
+          </Text>
+        </Stack>
+      )}
+    </Modal>
+  );
+}
diff --git a/apps/edr-freight-web/backoffice/src/components/warehouses/FreightVisual.tsx b/apps/edr-freight-web/backoffice/src/components/warehouses/FreightVisual.tsx
new file mode 100644
index 000000000..6d5f50a99
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/components/warehouses/FreightVisual.tsx
@@ -0,0 +1,184 @@
+import type { CSSProperties, ReactElement } from 'react';
+
+export type FreightVisualVariant =
+  | 'train'
+  | 'warehouse'
+  | 'container'
+  | 'wagon'
+  | 'cargo'
+  | 'route'
+  | 'empty';
+
+interface FreightVisualProps {
+  variant: FreightVisualVariant;
+  /** Pixel size of the (square) artwork. Defaults to 64. */
+  size?: number;
+  style?: CSSProperties;
+  className?: string;
+  title?: string;
+}
+
+/**
+ * Lightweight railway/freight illustrations — minimal, enterprise-logistics style.
+ * Inline SVG (no network cost) using EDR brand colors: green, yellow, dark text,
+ * light gray. Purposely low-contrast so it never overpowers tables/forms.
+ *
+ * Use only in page headers, empty states, and KPI cards.
+ */
+const EDR = {
+  green: '#2F9E44',
+  greenSoft: '#D3F9D8',
+  yellow: '#F59F00',
+  yellowSoft: '#FFF3BF',
+  dark: '#343A40',
+  gray: '#ADB5BD',
+  graySoft: '#E9ECEF',
+};
+
+function Train() {
+  return (
+    <>
+      {/* track */}
+      <rect x="2" y="52" width="60" height="3" rx="1.5" fill={EDR.graySoft} />
+      {/* locomotive body */}
+      <rect x="6" y="20" width="26" height="26" rx="3" fill={EDR.green} />
+      <rect x="10" y="24" width="8" height="8" rx="1.5" fill={EDR.greenSoft} />
+      <rect x="22" y="24" width="6" height="8" rx="1.5" fill={EDR.greenSoft} />
+      {/* cab roof */}
+      <rect x="9" y="15" width="14" height="6" rx="2" fill={EDR.dark} />
+      {/* wagon */}
+      <rect x="36" y="26" width="22" height="20" rx="2.5" fill={EDR.yellow} />
+      <rect x="40" y="30" width="14" height="6" rx="1" fill={EDR.yellowSoft} />
+      {/* wheels */}
+      {[12, 24, 42, 52].map((cx) => (
+        <circle key={cx} cx={cx} cy={48} r={3.2} fill={EDR.dark} />
+      ))}
+    </>
+  );
+}
+
+function Warehouse() {
+  return (
+    <>
+      {/* ground */}
+      <rect x="4" y="50" width="56" height="3" rx="1.5" fill={EDR.graySoft} />
+      {/* roof */}
+      <path d="M10 24 L32 12 L54 24 Z" fill={EDR.green} />
+      {/* body */}
+      <rect x="14" y="24" width="36" height="26" rx="1.5" fill={EDR.greenSoft} />
+      {/* shutter door */}
+      <rect x="26" y="32" width="12" height="18" rx="1" fill={EDR.dark} />
+      <rect x="27.5" y="35" width="9" height="2" fill={EDR.gray} />
+      <rect x="27.5" y="39" width="9" height="2" fill={EDR.gray} />
+      <rect x="27.5" y="43" width="9" height="2" fill={EDR.gray} />
+    </>
+  );
+}
+
+function Container() {
+  return (
+    <>
+      {/* stacked containers */}
+      <rect x="8" y="34" width="22" height="16" rx="1.5" fill={EDR.green} />
+      <rect x="34" y="34" width="22" height="16" rx="1.5" fill={EDR.yellow} />
+      <rect x="20" y="16" width="24" height="16" rx="1.5" fill={EDR.dark} />
+      {/* corrugation lines */}
+      {[12, 16, 20, 24].map((x) => (
+        <rect key={`a${x}`} x={x} y="37" width="1.5" height="10" fill={EDR.greenSoft} />
+      ))}
+      {[38, 42, 46, 50].map((x) => (
+        <rect key={`b${x}`} x={x} y="37" width="1.5" height="10" fill={EDR.yellowSoft} />
+      ))}
+      {[25, 29, 33, 37].map((x) => (
+        <rect key={`c${x}`} x={x} y="19" width="1.5" height="10" fill={EDR.gray} />
+      ))}
+    </>
+  );
+}
+
+function Wagon() {
+  return (
+    <>
+      <rect x="4" y="50" width="56" height="3" rx="1.5" fill={EDR.graySoft} />
+      {/* flatbed wagon */}
+      <rect x="8" y="38" width="48" height="8" rx="1.5" fill={EDR.dark} />
+      {/* cargo on wagon */}
+      <rect x="14" y="22" width="16" height="16" rx="1.5" fill={EDR.green} />
+      <rect x="34" y="26" width="16" height="12" rx="1.5" fill={EDR.yellow} />
+      {/* wheels */}
+      {[16, 26, 40, 50].map((cx) => (
+        <circle key={cx} cx={cx} cy={48} r={3.2} fill={EDR.dark} />
+      ))}
+    </>
+  );
+}
+
+function Cargo() {
+  return (
+    <>
+      {/* cargo boxes */}
+      <rect x="12" y="30" width="20" height="20" rx="2" fill={EDR.yellow} />
+      <rect x="34" y="34" width="18" height="16" rx="2" fill={EDR.green} />
+      {/* tape */}
+      <rect x="21" y="30" width="2" height="20" fill={EDR.yellowSoft} />
+      <rect x="12" y="38" width="20" height="2" fill={EDR.yellowSoft} />
+      <rect x="42" y="34" width="2" height="16" fill={EDR.greenSoft} />
+    </>
+  );
+}
+
+function Route() {
+  return (
+    <>
+      {/* track line with stations */}
+      <rect x="6" y="31" width="52" height="2" rx="1" fill={EDR.gray} />
+      {[10, 22, 34, 46, 58].map((x) => (
+        <rect key={x} x={x - 0.5} y="28" width="1.5" height="8" fill={EDR.graySoft} />
+      ))}
+      <circle cx="10" cy="32" r="5" fill={EDR.green} />
+      <circle cx="54" cy="32" r="5" fill={EDR.yellow} />
+    </>
+  );
+}
+
+function Empty() {
+  return (
+    <>
+      {/* empty open box */}
+      <path d="M14 28 L32 22 L50 28 L50 30 L32 24 L14 30 Z" fill={EDR.gray} />
+      <path d="M14 30 L32 36 L32 50 L14 44 Z" fill={EDR.graySoft} />
+      <path d="M50 30 L32 36 L32 50 L50 44 Z" fill={EDR.graySoft} />
+      <path d="M14 30 L32 24 L50 30 L32 36 Z" fill="#F8F9FA" />
+      <circle cx="32" cy="14" r="2.5" fill={EDR.yellow} />
+    </>
+  );
+}
+
+const VARIANTS: Record<FreightVisualVariant, () => ReactElement> = {
+  train: Train,
+  warehouse: Warehouse,
+  container: Container,
+  wagon: Wagon,
+  cargo: Cargo,
+  route: Route,
+  empty: Empty,
+};
+
+export function FreightVisual({ variant, size = 64, style, className, title }: FreightVisualProps) {
+  const Art = VARIANTS[variant];
+  return (
+    <svg
+      width={size}
+      height={size}
+      viewBox="0 0 64 64"
+      fill="none"
+      role="img"
+      aria-label={title ?? `${variant} illustration`}
+      className={className}
+      style={style}
+    >
+      {title ? <title>{title}</title> : null}
+      <Art />
+    </svg>
+  );
+}
diff --git a/apps/edr-freight-web/backoffice/src/components/warehouses/InspectionReportModal.tsx b/apps/edr-freight-web/backoffice/src/components/warehouses/InspectionReportModal.tsx
new file mode 100644
index 000000000..708b1f662
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/components/warehouses/InspectionReportModal.tsx
@@ -0,0 +1,214 @@
+import { useState } from 'react';
+import {
+  Button,
+  Divider,
+  FileInput,
+  Group,
+  Modal,
+  NumberInput,
+  Select,
+  Switch,
+  Textarea,
+} from '@mantine/core';
+import { Upload } from 'lucide-react';
+
+import { useToast } from '@/hooks/use-toast';
+import { useCreateInspectionReport, useUploadInspectionAttachments } from '@/hooks/useWarehouses';
+import {
+  INSPECTION_REPORT_TYPES,
+  INSPECTION_STATUSES,
+  type InspectionReportType,
+  type InspectionResultStatus,
+} from '@/types/warehouse';
+import { extractErrorMessage } from './options';
+
+interface InspectionReportModalProps {
+  opened: boolean;
+  onClose: () => void;
+  inventoryId: string | null;
+}
+
+const REPORT_TYPE_LABELS: Record<InspectionReportType, string> = {
+  INSPECTION: 'Inspection',
+  DAMAGE: 'Damage',
+  WEIGHT_LOSS: 'Weight loss',
+  MISSING_ITEM: 'Missing item',
+  GENERAL: 'General',
+};
+
+const STATUS_LABELS: Record<InspectionResultStatus, string> = {
+  PASSED: 'Passed',
+  FAILED: 'Failed',
+  NEEDS_REVIEW: 'Needs review',
+};
+
+/** Batch 4.5 — record an inspection / damage report with optional image upload. */
+export function InspectionReportModal({ opened, onClose, inventoryId }: InspectionReportModalProps) {
+  const { toast } = useToast();
+  const createReport = useCreateInspectionReport();
+  const uploadAttachments = useUploadInspectionAttachments();
+
+  const [reportType, setReportType] = useState<InspectionReportType>('INSPECTION');
+  const [inspectionStatus, setInspectionStatus] = useState<InspectionResultStatus>('PASSED');
+  const [hasDamage, setHasDamage] = useState(false);
+  const [damageDescription, setDamageDescription] = useState('');
+  const [hasWeightLoss, setHasWeightLoss] = useState(false);
+  const [expectedWeight, setExpectedWeight] = useState<number | ''>('');
+  const [actualWeight, setActualWeight] = useState<number | ''>('');
+  const [hasMissingItems, setHasMissingItems] = useState(false);
+  const [missingItemsDescription, setMissingItemsDescription] = useState('');
+  const [remarks, setRemarks] = useState('');
+  const [files, setFiles] = useState<File[]>([]);
+
+  const submitting = createReport.isPending || uploadAttachments.isPending;
+
+  const reset = () => {
+    setReportType('INSPECTION');
+    setInspectionStatus('PASSED');
+    setHasDamage(false);
+    setDamageDescription('');
+    setHasWeightLoss(false);
+    setExpectedWeight('');
+    setActualWeight('');
+    setHasMissingItems(false);
+    setMissingItemsDescription('');
+    setRemarks('');
+    setFiles([]);
+  };
+
+  const handleSubmit = async () => {
+    if (!inventoryId) return;
+    try {
+      const report = await createReport.mutateAsync({
+        inventoryId,
+        payload: {
+          reportType,
+          inspectionStatus,
+          hasDamage,
+          damageDescription: damageDescription.trim() || undefined,
+          hasWeightLoss,
+          expectedWeight: expectedWeight === '' ? undefined : Number(expectedWeight),
+          actualWeight: actualWeight === '' ? undefined : Number(actualWeight),
+          hasMissingItems,
+          missingItemsDescription: missingItemsDescription.trim() || undefined,
+          remarks: remarks.trim() || undefined,
+        },
+      });
+
+      if (files.length > 0) {
+        await uploadAttachments.mutateAsync({ reportId: report.id, files });
+      }
+
+      toast({ title: 'Inspection report saved' });
+      reset();
+      onClose();
+    } catch (error) {
+      toast({ variant: 'destructive', title: 'Save failed', description: extractErrorMessage(error) });
+    }
+  };
+
+  return (
+    <Modal opened={opened} onClose={onClose} title="Inspection / Report" centered size="lg">
+      <Group grow>
+        <Select
+          label="Report type"
+          data={INSPECTION_REPORT_TYPES.map((t) => ({ value: t, label: REPORT_TYPE_LABELS[t] }))}
+          value={reportType}
+          onChange={(v) => setReportType((v as InspectionReportType) ?? 'INSPECTION')}
+          allowDeselect={false}
+        />
+        <Select
+          label="Inspection status"
+          data={INSPECTION_STATUSES.map((s) => ({ value: s, label: STATUS_LABELS[s] }))}
+          value={inspectionStatus}
+          onChange={(v) => setInspectionStatus((v as InspectionResultStatus) ?? 'PASSED')}
+          allowDeselect={false}
+        />
+      </Group>
+
+      <Divider my="md" label="Damage" labelPosition="left" />
+      <Switch
+        label="Has damage"
+        checked={hasDamage}
+        onChange={(e) => setHasDamage(e.currentTarget.checked)}
+        color="orange"
+      />
+      {hasDamage && (
+        <Textarea
+          mt="xs"
+          label="Damage description"
+          value={damageDescription}
+          onChange={(e) => setDamageDescription(e.currentTarget.value)}
+        />
+      )}
+
+      <Divider my="md" label="Weight loss" labelPosition="left" />
+      <Switch
+        label="Has weight loss"
+        checked={hasWeightLoss}
+        onChange={(e) => setHasWeightLoss(e.currentTarget.checked)}
+        color="orange"
+      />
+      {hasWeightLoss && (
+        <Group grow mt="xs">
+          <NumberInput
+            label="Expected weight (kg)"
+            min={0}
+            value={expectedWeight}
+            onChange={(v) => setExpectedWeight(v === '' ? '' : Number(v))}
+          />
+          <NumberInput
+            label="Actual weight (kg)"
+            min={0}
+            value={actualWeight}
+            onChange={(v) => setActualWeight(v === '' ? '' : Number(v))}
+          />
+        </Group>
+      )}
+
+      <Divider my="md" label="Missing items" labelPosition="left" />
+      <Switch
+        label="Has missing items"
+        checked={hasMissingItems}
+        onChange={(e) => setHasMissingItems(e.currentTarget.checked)}
+        color="orange"
+      />
+      {hasMissingItems && (
+        <Textarea
+          mt="xs"
+          label="Missing items description"
+          value={missingItemsDescription}
+          onChange={(e) => setMissingItemsDescription(e.currentTarget.value)}
+        />
+      )}
+
+      <Divider my="md" />
+      <Textarea
+        label="Remarks"
+        value={remarks}
+        onChange={(e) => setRemarks(e.currentTarget.value)}
+      />
+
+      <FileInput
+        mt="md"
+        label="Images / documents"
+        placeholder="Upload jpg, png or pdf"
+        accept="image/jpeg,image/png,application/pdf"
+        leftSection={<Upload size={16} />}
+        multiple
+        value={files}
+        onChange={setFiles}
+        clearable
+      />
+
+      <Group justify="flex-end" mt="lg">
+        <Button variant="default" onClick={onClose} disabled={submitting}>
+          Cancel
+        </Button>
+        <Button color="green" onClick={handleSubmit} loading={submitting} disabled={!inventoryId}>
+          Save report
+        </Button>
+      </Group>
+    </Modal>
+  );
+}
diff --git a/apps/edr-freight-web/backoffice/src/components/warehouses/InventoryHistoryModal.tsx b/apps/edr-freight-web/backoffice/src/components/warehouses/InventoryHistoryModal.tsx
new file mode 100644
index 000000000..41edf148d
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/components/warehouses/InventoryHistoryModal.tsx
@@ -0,0 +1,37 @@
+import { Modal, Tabs } from '@mantine/core';
+import { ArrowRightLeft, ListChecks } from 'lucide-react';
+
+import type { WarehouseInventoryItem } from '@/types/warehouse';
+import { ActivityTimeline } from './ActivityTimeline';
+import { InventoryMovementHistoryTable } from './InventoryMovementHistoryTable';
+
+interface InventoryHistoryModalProps {
+  opened: boolean;
+  onClose: () => void;
+  item: WarehouseInventoryItem | null;
+}
+
+export function InventoryHistoryModal({ opened, onClose, item }: InventoryHistoryModalProps) {
+  return (
+    <Modal opened={opened} onClose={onClose} title="Inventory history" centered size="xl">
+      {item && (
+        <Tabs defaultValue="activity">
+          <Tabs.List>
+            <Tabs.Tab value="activity" leftSection={<ListChecks size={16} />}>
+              Activity
+            </Tabs.Tab>
+            <Tabs.Tab value="movements" leftSection={<ArrowRightLeft size={16} />}>
+              Movements
+            </Tabs.Tab>
+          </Tabs.List>
+          <Tabs.Panel value="activity" pt="md">
+            <ActivityTimeline inventoryId={item.id} />
+          </Tabs.Panel>
+          <Tabs.Panel value="movements" pt="md">
+            <InventoryMovementHistoryTable inventoryId={item.id} />
+          </Tabs.Panel>
+        </Tabs>
+      )}
+    </Modal>
+  );
+}
diff --git a/apps/edr-freight-web/backoffice/src/components/warehouses/InventoryMovementHistoryTable.tsx b/apps/edr-freight-web/backoffice/src/components/warehouses/InventoryMovementHistoryTable.tsx
new file mode 100644
index 000000000..352c6bff2
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/components/warehouses/InventoryMovementHistoryTable.tsx
@@ -0,0 +1,64 @@
+import { Center, Loader, Table, Text } from '@mantine/core';
+
+import { useInventoryMovements } from '@/hooks/useWarehouses';
+import { formatDate } from './options';
+
+const shortId = (id?: string | null) => (id ? `${id.slice(0, 8)}…` : '—');
+
+export function InventoryMovementHistoryTable({ inventoryId }: { inventoryId: string }) {
+  const { data, isLoading } = useInventoryMovements(inventoryId);
+  const movements = data ?? [];
+
+  if (isLoading) {
+    return (
+      <Center py="lg">
+        <Loader size="sm" />
+      </Center>
+    );
+  }
+
+  if (movements.length === 0) {
+    return (
+      <Text c="dimmed" ta="center" py="md" size="sm">
+        No movements recorded for this item.
+      </Text>
+    );
+  }
+
+  return (
+    <Table.ScrollContainer minWidth={640}>
+      <Table verticalSpacing="xs" striped>
+        <Table.Thead>
+          <Table.Tr>
+            <Table.Th>From (W / Y / Z)</Table.Th>
+            <Table.Th>To (W / Y / Z)</Table.Th>
+            <Table.Th>Remarks</Table.Th>
+            <Table.Th>By</Table.Th>
+            <Table.Th>When</Table.Th>
+          </Table.Tr>
+        </Table.Thead>
+        <Table.Tbody>
+          {movements.map((m) => (
+            <Table.Tr key={m.id}>
+              <Table.Td>
+                <Text size="xs">
+                  {shortId(m.fromWarehouseId)} / {shortId(m.fromYardId)} / {shortId(m.fromZoneId)}
+                </Text>
+              </Table.Td>
+              <Table.Td>
+                <Text size="xs">
+                  {shortId(m.toWarehouseId)} / {shortId(m.toYardId)} / {shortId(m.toZoneId)}
+                </Text>
+              </Table.Td>
+              <Table.Td>{m.remarks ?? '—'}</Table.Td>
+              <Table.Td>{m.movedBy ?? '—'}</Table.Td>
+              <Table.Td>
+                <Text size="xs">{formatDate(m.movedAt)}</Text>
+              </Table.Td>
+            </Table.Tr>
+          ))}
+        </Table.Tbody>
+      </Table>
+    </Table.ScrollContainer>
+  );
+}
diff --git a/apps/edr-freight-web/backoffice/src/components/warehouses/InventoryWorkbench.tsx b/apps/edr-freight-web/backoffice/src/components/warehouses/InventoryWorkbench.tsx
new file mode 100644
index 000000000..aeeffbdbe
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/components/warehouses/InventoryWorkbench.tsx
@@ -0,0 +1,115 @@
+import { useState } from 'react';
+import { Center, Loader } from '@mantine/core';
+
+import { useToast } from '@/hooks/use-toast';
+import {
+  useDispatchInventory,
+  useMarkReadyForLoading,
+  useStoreInventory,
+} from '@/hooks/useWarehouses';
+import type { InventoryAction, WarehouseInventoryItem } from '@/types/warehouse';
+import { FeePreviewModal } from './FeePreviewModal';
+import { InspectionReportModal } from './InspectionReportModal';
+import { InventoryHistoryModal } from './InventoryHistoryModal';
+import { LoadInventoryModal } from './LoadInventoryModal';
+import { MoveInventoryModal } from './MoveInventoryModal';
+import { ReserveInventoryModal } from './ReserveInventoryModal';
+import { WarehouseInventoryTable } from './WarehouseInventoryTable';
+import { extractErrorMessage } from './options';
+
+interface InventoryWorkbenchProps {
+  items: WarehouseInventoryItem[];
+  isLoading?: boolean;
+}
+
+/** Inventory table + all lifecycle actions (advance / move / reserve / history). */
+export function InventoryWorkbench({ items, isLoading }: InventoryWorkbenchProps) {
+  const { toast } = useToast();
+  const [busyId, setBusyId] = useState<string | null>(null);
+  const [moveItem, setMoveItem] = useState<WarehouseInventoryItem | null>(null);
+  const [reserveItem, setReserveItem] = useState<WarehouseInventoryItem | null>(null);
+  const [loadItem, setLoadItem] = useState<WarehouseInventoryItem | null>(null);
+  const [historyItem, setHistoryItem] = useState<WarehouseInventoryItem | null>(null);
+  const [inspectItem, setInspectItem] = useState<WarehouseInventoryItem | null>(null);
+  const [feeItem, setFeeItem] = useState<WarehouseInventoryItem | null>(null);
+
+  const storeMutation = useStoreInventory();
+  const readyMutation = useMarkReadyForLoading();
+  const dispatchMutation = useDispatchInventory();
+
+  const runDirect = async (item: WarehouseInventoryItem, fn: () => Promise<unknown>, label: string) => {
+    setBusyId(item.id);
+    try {
+      await fn();
+      toast({ title: label });
+    } catch (error) {
+      toast({ variant: 'destructive', title: 'Action failed', description: extractErrorMessage(error) });
+    } finally {
+      setBusyId(null);
+    }
+  };
+
+  const advance = (item: WarehouseInventoryItem, action: InventoryAction) => {
+    switch (action) {
+      case 'store':
+        return runDirect(item, () => storeMutation.mutateAsync(item.id), 'Inventory stored');
+      case 'reserve':
+        setReserveItem(item);
+        return;
+      case 'ready-for-loading':
+        return runDirect(item, () => readyMutation.mutateAsync(item.id), 'Ready for loading');
+      case 'load':
+        setLoadItem(item);
+        return;
+      case 'dispatch':
+        return runDirect(item, () => dispatchMutation.mutateAsync(item.id), 'Inventory dispatched');
+      default:
+        return;
+    }
+  };
+
+  if (isLoading) {
+    return (
+      <Center py="xl">
+        <Loader />
+      </Center>
+    );
+  }
+
+  return (
+    <>
+      <WarehouseInventoryTable
+        items={items}
+        busyId={busyId}
+        onAdvance={advance}
+        onMove={setMoveItem}
+        onHistory={setHistoryItem}
+        onInspect={setInspectItem}
+        onFeePreview={setFeeItem}
+      />
+
+      <MoveInventoryModal opened={Boolean(moveItem)} onClose={() => setMoveItem(null)} item={moveItem} />
+      <ReserveInventoryModal
+        opened={Boolean(reserveItem)}
+        onClose={() => setReserveItem(null)}
+        item={reserveItem}
+      />
+      <LoadInventoryModal opened={Boolean(loadItem)} onClose={() => setLoadItem(null)} item={loadItem} />
+      <InventoryHistoryModal
+        opened={Boolean(historyItem)}
+        onClose={() => setHistoryItem(null)}
+        item={historyItem}
+      />
+      <InspectionReportModal
+        opened={Boolean(inspectItem)}
+        onClose={() => setInspectItem(null)}
+        inventoryId={inspectItem?.id ?? null}
+      />
+      <FeePreviewModal
+        opened={Boolean(feeItem)}
+        onClose={() => setFeeItem(null)}
+        inventoryId={feeItem?.id ?? null}
+      />
+    </>
+  );
+}
diff --git a/apps/edr-freight-web/backoffice/src/components/warehouses/LoadInventoryModal.tsx b/apps/edr-freight-web/backoffice/src/components/warehouses/LoadInventoryModal.tsx
new file mode 100644
index 000000000..8def582cb
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/components/warehouses/LoadInventoryModal.tsx
@@ -0,0 +1,98 @@
+import { useEffect, useState } from 'react';
+import { Alert, Button, Group, Modal, NumberInput, Stack, Text, Textarea } from '@mantine/core';
+import { Info } from 'lucide-react';
+
+import { useToast } from '@/hooks/use-toast';
+import { useLoadInventory } from '@/hooks/useWarehouses';
+import type { WarehouseInventoryItem } from '@/types/warehouse';
+import { WagonSelect } from './WagonSelect';
+import { extractErrorMessage } from './options';
+
+interface LoadInventoryModalProps {
+  opened: boolean;
+  onClose: () => void;
+  item: WarehouseInventoryItem | null;
+}
+
+/** Load READY_FOR_LOADING inventory onto a wagon (creates a loading record). */
+export function LoadInventoryModal({ opened, onClose, item }: LoadInventoryModalProps) {
+  const { toast } = useToast();
+  const loadMutation = useLoadInventory();
+  const [wagonId, setWagonId] = useState('');
+  const [loadedWeight, setLoadedWeight] = useState<number | ''>('');
+  const [notes, setNotes] = useState('');
+
+  useEffect(() => {
+    if (opened) {
+      setWagonId('');
+      setLoadedWeight(item?.weight ?? '');
+      setNotes('');
+    }
+  }, [opened, item]);
+
+  const handleSubmit = async () => {
+    if (!item) return;
+    if (!wagonId.trim()) {
+      toast({ variant: 'destructive', title: 'Select a wagon' });
+      return;
+    }
+    try {
+      await loadMutation.mutateAsync({
+        id: item.id,
+        payload: {
+          wagonId: wagonId.trim(),
+          loadedWeight: loadedWeight === '' ? undefined : Number(loadedWeight),
+          notes: notes.trim() || undefined,
+        },
+      });
+      toast({ title: 'Inventory loaded', description: 'Status set to LOADED' });
+      onClose();
+    } catch (error) {
+      toast({ variant: 'destructive', title: 'Load failed', description: extractErrorMessage(error) });
+    }
+  };
+
+  return (
+    <Modal opened={opened} onClose={onClose} title="Load onto wagon" centered size="md">
+      <Stack gap="md">
+        <Alert icon={<Info size={16} />} color="blue" variant="light">
+          <Text size="sm">
+            The item must be <b>READY_FOR_LOADING</b> and the wagon must be available or already on a
+            train schedule.
+          </Text>
+        </Alert>
+
+        <WagonSelect label="Wagon" required value={wagonId} onChange={setWagonId} />
+
+        <NumberInput
+          label="Loaded weight (kg)"
+          placeholder="Defaults to item weight"
+          min={0}
+          value={loadedWeight}
+          onChange={(v) => setLoadedWeight(v === '' ? '' : Number(v))}
+        />
+
+        <Textarea
+          label="Notes"
+          placeholder="Optional"
+          autosize
+          minRows={2}
+          value={notes}
+          onChange={(e) => {
+            const v = e.currentTarget.value;
+            setNotes(v);
+          }}
+        />
+
+        <Group justify="flex-end" mt="sm">
+          <Button variant="default" onClick={onClose} disabled={loadMutation.isPending}>
+            Cancel
+          </Button>
+          <Button onClick={handleSubmit} loading={loadMutation.isPending}>
+            Load
+          </Button>
+        </Group>
+      </Stack>
+    </Modal>
+  );
+}
diff --git a/apps/edr-freight-web/backoffice/src/components/warehouses/MoveInventoryModal.tsx b/apps/edr-freight-web/backoffice/src/components/warehouses/MoveInventoryModal.tsx
new file mode 100644
index 000000000..b76458d5e
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/components/warehouses/MoveInventoryModal.tsx
@@ -0,0 +1,125 @@
+import { useEffect, useMemo, useState } from 'react';
+import { Button, Group, Modal, Select, Stack, Textarea } from '@mantine/core';
+
+import { useToast } from '@/hooks/use-toast';
+import { useMoveInventory, useWarehouseYards, useWarehouseZones, useWarehouses } from '@/hooks/useWarehouses';
+import type { WarehouseInventoryItem } from '@/types/warehouse';
+import { extractErrorMessage } from './options';
+
+interface MoveInventoryModalProps {
+  opened: boolean;
+  onClose: () => void;
+  item: WarehouseInventoryItem | null;
+}
+
+export function MoveInventoryModal({ opened, onClose, item }: MoveInventoryModalProps) {
+  const { toast } = useToast();
+  const moveMutation = useMoveInventory();
+  const [warehouseId, setWarehouseId] = useState('');
+  const [yardId, setYardId] = useState('');
+  const [zoneId, setZoneId] = useState('');
+  const [remarks, setRemarks] = useState('');
+
+  useEffect(() => {
+    if (opened) {
+      setWarehouseId('');
+      setYardId('');
+      setZoneId('');
+      setRemarks('');
+    }
+  }, [opened]);
+
+  const warehousesQuery = useWarehouses({ status: 'ACTIVE' });
+  const yardsQuery = useWarehouseYards(warehouseId || undefined);
+  const zonesQuery = useWarehouseZones(yardId || undefined);
+
+  const warehouseOptions = useMemo(
+    () => (warehousesQuery.data ?? []).map((w) => ({ value: w.id, label: `${w.name} (${w.code})` })),
+    [warehousesQuery.data],
+  );
+  const yardOptions = useMemo(
+    () => (yardsQuery.data ?? []).filter((y) => y.status === 'ACTIVE').map((y) => ({ value: y.id, label: `${y.name} (${y.code})` })),
+    [yardsQuery.data],
+  );
+  const zoneOptions = useMemo(
+    () => (zonesQuery.data ?? []).filter((z) => z.status === 'ACTIVE').map((z) => ({ value: z.id, label: `${z.name} (${z.code})` })),
+    [zonesQuery.data],
+  );
+
+  const handleSubmit = async () => {
+    if (!item) return;
+    if (!warehouseId || !yardId || !zoneId) {
+      toast({ variant: 'destructive', title: 'Select destination warehouse, yard and zone' });
+      return;
+    }
+    try {
+      await moveMutation.mutateAsync({
+        id: item.id,
+        payload: { warehouseId, yardId, zoneId, remarks: remarks.trim() || undefined },
+      });
+      toast({ title: 'Inventory moved' });
+      onClose();
+    } catch (error) {
+      toast({ variant: 'destructive', title: 'Move failed', description: extractErrorMessage(error) });
+    }
+  };
+
+  return (
+    <Modal opened={opened} onClose={onClose} title="Move inventory" centered size="lg">
+      <Stack gap="md">
+        <Select
+          label="Destination warehouse"
+          placeholder="Select warehouse"
+          required
+          searchable
+          data={warehouseOptions}
+          value={warehouseId || null}
+          onChange={(v) => {
+            setWarehouseId(v ?? '');
+            setYardId('');
+            setZoneId('');
+          }}
+        />
+        <Select
+          label="Destination yard"
+          placeholder={!warehouseId ? 'Select a warehouse first' : 'Select yard'}
+          required
+          searchable
+          disabled={!warehouseId}
+          data={yardOptions}
+          value={yardId || null}
+          onChange={(v) => {
+            setYardId(v ?? '');
+            setZoneId('');
+          }}
+        />
+        <Select
+          label="Destination zone"
+          placeholder={!yardId ? 'Select a yard first' : 'Select zone'}
+          required
+          searchable
+          disabled={!yardId}
+          data={zoneOptions}
+          value={zoneId || null}
+          onChange={(v) => setZoneId(v ?? '')}
+        />
+        <Textarea
+          label="Remarks"
+          placeholder="Reason for the move"
+          autosize
+          minRows={2}
+          value={remarks}
+          onChange={(e) => setRemarks(e.currentTarget.value)}
+        />
+        <Group justify="flex-end" mt="sm">
+          <Button variant="default" onClick={onClose} disabled={moveMutation.isPending}>
+            Cancel
+          </Button>
+          <Button onClick={handleSubmit} loading={moveMutation.isPending}>
+            Move inventory
+          </Button>
+        </Group>
+      </Stack>
+    </Modal>
+  );
+}
diff --git a/apps/edr-freight-web/backoffice/src/components/warehouses/ReceiveInventoryModal.tsx b/apps/edr-freight-web/backoffice/src/components/warehouses/ReceiveInventoryModal.tsx
new file mode 100644
index 000000000..5e914754b
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/components/warehouses/ReceiveInventoryModal.tsx
@@ -0,0 +1,214 @@
+import { useEffect, useMemo, useState } from 'react';
+import { Button, Group, Modal, NumberInput, Select, Stack, Textarea, TextInput } from '@mantine/core';
+
+import { useToast } from '@/hooks/use-toast';
+import {
+  useReceiveInventory,
+  useWarehouseYards,
+  useWarehouseZones,
+  useWarehouses,
+} from '@/hooks/useWarehouses';
+import type { ReceiveInventoryPayload } from '@/types/warehouse';
+import { BookingSelect } from './BookingSelect';
+import { extractErrorMessage } from './options';
+
+interface ReceiveInventoryModalProps {
+  opened: boolean;
+  onClose: () => void;
+  /** When supplied the booking field is locked to this booking. */
+  bookingId?: string;
+  bookingLabel?: string;
+  onReceived?: () => void;
+}
+
+interface FormState {
+  bookingId: string;
+  warehouseId: string;
+  yardId: string;
+  zoneId: string;
+  quantity: number | '';
+  weight: number | '';
+  volume: number | '';
+  notes: string;
+}
+
+const emptyForm = (bookingId?: string): FormState => ({
+  bookingId: bookingId ?? '',
+  warehouseId: '',
+  yardId: '',
+  zoneId: '',
+  quantity: '',
+  weight: '',
+  volume: '',
+  notes: '',
+});
+
+export function ReceiveInventoryModal({
+  opened,
+  onClose,
+  bookingId,
+  bookingLabel,
+  onReceived,
+}: ReceiveInventoryModalProps) {
+  const { toast } = useToast();
+  const receiveMutation = useReceiveInventory();
+  const [form, setForm] = useState<FormState>(emptyForm(bookingId));
+
+  useEffect(() => {
+    if (opened) setForm(emptyForm(bookingId));
+  }, [opened, bookingId]);
+
+  // Cascading data — only ACTIVE warehouses are selectable for receiving.
+  const warehousesQuery = useWarehouses({ status: 'ACTIVE' });
+  const yardsQuery = useWarehouseYards(form.warehouseId || undefined);
+  const zonesQuery = useWarehouseZones(form.yardId || undefined);
+
+  const warehouseOptions = useMemo(
+    () =>
+      (warehousesQuery.data ?? []).map((w) => ({ value: w.id, label: `${w.name} (${w.code})` })),
+    [warehousesQuery.data],
+  );
+  const yardOptions = useMemo(
+    () =>
+      (yardsQuery.data ?? [])
+        .filter((y) => y.status === 'ACTIVE')
+        .map((y) => ({ value: y.id, label: `${y.name} (${y.code})` })),
+    [yardsQuery.data],
+  );
+  const zoneOptions = useMemo(
+    () =>
+      (zonesQuery.data ?? [])
+        .filter((z) => z.status === 'ACTIVE')
+        .map((z) => ({ value: z.id, label: `${z.name} (${z.code})` })),
+    [zonesQuery.data],
+  );
+
+  const submitting = receiveMutation.isPending;
+
+  const handleSubmit = async () => {
+    if (!form.bookingId.trim()) {
+      toast({ variant: 'destructive', title: 'Booking is required' });
+      return;
+    }
+    if (!form.warehouseId || !form.yardId || !form.zoneId) {
+      toast({ variant: 'destructive', title: 'Select warehouse, yard and zone' });
+      return;
+    }
+    if (form.quantity === '' || form.weight === '') {
+      toast({ variant: 'destructive', title: 'Quantity and weight are required' });
+      return;
+    }
+
+    const payload: ReceiveInventoryPayload = {
+      bookingId: form.bookingId.trim(),
+      warehouseId: form.warehouseId,
+      yardId: form.yardId,
+      zoneId: form.zoneId,
+      quantity: Number(form.quantity),
+      weight: Number(form.weight),
+      volume: form.volume === '' ? undefined : Number(form.volume),
+      notes: form.notes.trim() || undefined,
+    };
+
+    try {
+      await receiveMutation.mutateAsync(payload);
+      toast({ title: 'Inventory received', description: 'Status set to ARRIVED_AT_WAREHOUSE' });
+      onReceived?.();
+      onClose();
+    } catch (error) {
+      toast({ variant: 'destructive', title: 'Receive failed', description: extractErrorMessage(error) });
+    }
+  };
+
+  return (
+    <Modal opened={opened} onClose={onClose} title="Receive at warehouse" centered size="lg">
+      <Stack gap="md">
+        {bookingId ? (
+          <TextInput label="Booking" value={bookingLabel ?? bookingId} readOnly />
+        ) : (
+          <BookingSelect
+            label="Booking"
+            value={form.bookingId}
+            onChange={(v) => setForm((f) => ({ ...f, bookingId: v }))}
+          />
+        )}
+
+        <Select
+          label="Warehouse"
+          placeholder={warehousesQuery.isLoading ? 'Loading…' : 'Select warehouse'}
+          required
+          searchable
+          data={warehouseOptions}
+          value={form.warehouseId || null}
+          onChange={(value) =>
+            setForm((f) => ({ ...f, warehouseId: value ?? '', yardId: '', zoneId: '' }))
+          }
+        />
+
+        <Select
+          label="Yard"
+          placeholder={!form.warehouseId ? 'Select a warehouse first' : 'Select yard'}
+          required
+          searchable
+          disabled={!form.warehouseId}
+          data={yardOptions}
+          value={form.yardId || null}
+          onChange={(value) => setForm((f) => ({ ...f, yardId: value ?? '', zoneId: '' }))}
+        />
+
+        <Select
+          label="Zone"
+          placeholder={!form.yardId ? 'Select a yard first' : 'Select zone'}
+          required
+          searchable
+          disabled={!form.yardId}
+          data={zoneOptions}
+          value={form.zoneId || null}
+          onChange={(value) => setForm((f) => ({ ...f, zoneId: value ?? '' }))}
+        />
+
+        <Group grow>
+          <NumberInput
+            label="Quantity"
+            required
+            min={0}
+            value={form.quantity}
+            onChange={(value) => setForm((f) => ({ ...f, quantity: value === '' ? '' : Number(value) }))}
+          />
+          <NumberInput
+            label="Weight (kg)"
+            required
+            min={0}
+            value={form.weight}
+            onChange={(value) => setForm((f) => ({ ...f, weight: value === '' ? '' : Number(value) }))}
+          />
+          <NumberInput
+            label="Volume (m³)"
+            placeholder="Optional"
+            min={0}
+            value={form.volume}
+            onChange={(value) => setForm((f) => ({ ...f, volume: value === '' ? '' : Number(value) }))}
+          />
+        </Group>
+
+        <Textarea
+          label="Notes"
+          placeholder="Optional notes"
+          autosize
+          minRows={2}
+          value={form.notes}
+          onChange={(e) => { const v = e.currentTarget.value; setForm((f) => ({ ...f, notes: v })); }}
+        />
+
+        <Group justify="flex-end" mt="sm">
+          <Button variant="default" onClick={onClose} disabled={submitting}>
+            Cancel
+          </Button>
+          <Button onClick={handleSubmit} loading={submitting}>
+            Receive inventory
+          </Button>
+        </Group>
+      </Stack>
+    </Modal>
+  );
+}
diff --git a/apps/edr-freight-web/backoffice/src/components/warehouses/ReserveInventoryModal.tsx b/apps/edr-freight-web/backoffice/src/components/warehouses/ReserveInventoryModal.tsx
new file mode 100644
index 000000000..7a7ebb55b
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/components/warehouses/ReserveInventoryModal.tsx
@@ -0,0 +1,59 @@
+import { useEffect, useState } from 'react';
+import { Alert, Button, Group, Modal, Stack, Text } from '@mantine/core';
+import { Info } from 'lucide-react';
+
+import { useToast } from '@/hooks/use-toast';
+import { useReserveInventory } from '@/hooks/useWarehouses';
+import type { WarehouseInventoryItem } from '@/types/warehouse';
+import { BookingSelect } from './BookingSelect';
+import { extractErrorMessage } from './options';
+
+interface ReserveInventoryModalProps {
+  opened: boolean;
+  onClose: () => void;
+  item: WarehouseInventoryItem | null;
+}
+
+export function ReserveInventoryModal({ opened, onClose, item }: ReserveInventoryModalProps) {
+  const { toast } = useToast();
+  const reserveMutation = useReserveInventory();
+  const [bookingId, setBookingId] = useState('');
+
+  useEffect(() => {
+    if (opened) setBookingId(item?.bookingId ?? '');
+  }, [opened, item]);
+
+  const handleSubmit = async () => {
+    if (!item) return;
+    if (!bookingId.trim()) {
+      toast({ variant: 'destructive', title: 'Booking is required' });
+      return;
+    }
+    try {
+      await reserveMutation.mutateAsync({ inventoryId: item.id, bookingId: bookingId.trim() });
+      toast({ title: 'Inventory reserved' });
+      onClose();
+    } catch (error) {
+      toast({ variant: 'destructive', title: 'Reserve failed', description: extractErrorMessage(error) });
+    }
+  };
+
+  return (
+    <Modal opened={opened} onClose={onClose} title="Reserve inventory" centered size="md">
+      <Stack gap="md">
+        <Alert icon={<Info size={16} />} color="blue" variant="light">
+          <Text size="sm">The booking must be in <b>PAID</b> status and the inventory must be <b>STORED</b>.</Text>
+        </Alert>
+        <BookingSelect label="Booking (PAID)" required statuses="PAID" value={bookingId} onChange={setBookingId} />
+        <Group justify="flex-end" mt="sm">
+          <Button variant="default" onClick={onClose} disabled={reserveMutation.isPending}>
+            Cancel
+          </Button>
+          <Button onClick={handleSubmit} loading={reserveMutation.isPending}>
+            Reserve
+          </Button>
+        </Group>
+      </Stack>
+    </Modal>
+  );
+}
diff --git a/apps/edr-freight-web/backoffice/src/components/warehouses/VisualEmptyState.tsx b/apps/edr-freight-web/backoffice/src/components/warehouses/VisualEmptyState.tsx
new file mode 100644
index 000000000..5160ceccf
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/components/warehouses/VisualEmptyState.tsx
@@ -0,0 +1,36 @@
+import type { ReactNode } from 'react';
+import { Center, Stack, Text } from '@mantine/core';
+
+import { FreightVisual, type FreightVisualVariant } from './FreightVisual';
+
+interface VisualEmptyStateProps {
+  variant?: FreightVisualVariant;
+  title: string;
+  description?: string;
+  action?: ReactNode;
+}
+
+/** Friendly empty state with a small freight illustration. */
+export function VisualEmptyState({
+  variant = 'empty',
+  title,
+  description,
+  action,
+}: VisualEmptyStateProps) {
+  return (
+    <Center py="xl">
+      <Stack align="center" gap="xs" maw={360}>
+        <FreightVisual variant={variant} size={88} style={{ opacity: 0.85 }} />
+        <Text fw={600} ta="center">
+          {title}
+        </Text>
+        {description && (
+          <Text size="sm" c="dimmed" ta="center">
+            {description}
+          </Text>
+        )}
+        {action}
+      </Stack>
+    </Center>
+  );
+}
diff --git a/apps/edr-freight-web/backoffice/src/components/warehouses/WagonSelect.tsx b/apps/edr-freight-web/backoffice/src/components/warehouses/WagonSelect.tsx
new file mode 100644
index 000000000..d6cc8c2cd
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/components/warehouses/WagonSelect.tsx
@@ -0,0 +1,34 @@
+import { Select } from '@mantine/core';
+
+import { useLoadableWagons } from '@/hooks/useWarehouses';
+
+interface WagonSelectProps {
+  value: string;
+  onChange: (wagonId: string) => void;
+  label?: string;
+  required?: boolean;
+}
+
+/** Searchable wagon picker. Lists wagons that are loadable (read-only from scheduling). */
+export function WagonSelect({ value, onChange, label = 'Wagon', required }: WagonSelectProps) {
+  const { data, isLoading } = useLoadableWagons();
+
+  const options = (data ?? []).map((w) => ({
+    value: w.id,
+    label: `${w.wagonNumber} · ${w.status}`,
+  }));
+
+  return (
+    <Select
+      label={label}
+      required={required}
+      searchable
+      clearable
+      data={options}
+      value={value || null}
+      onChange={(v) => onChange(v ?? '')}
+      placeholder={isLoading ? 'Loading wagons…' : 'Search wagon number'}
+      nothingFoundMessage="No loadable wagons found"
+    />
+  );
+}
diff --git a/apps/edr-freight-web/backoffice/src/components/warehouses/WarehouseCardView.tsx b/apps/edr-freight-web/backoffice/src/components/warehouses/WarehouseCardView.tsx
new file mode 100644
index 000000000..2d3dd2276
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/components/warehouses/WarehouseCardView.tsx
@@ -0,0 +1,90 @@
+import { useMemo } from 'react';
+import { ActionIcon, Card, Group, SimpleGrid, Stack, Text } from '@mantine/core';
+import { Building2, Eye, MapPin, Pencil } from 'lucide-react';
+
+import { useStations } from '@/hooks/useStations';
+import type { Warehouse } from '@/types/warehouse';
+import { WarehouseStatusBadge, WarehouseTypeBadge } from './badges';
+import { formatCapacity } from './options';
+
+interface WarehouseCardViewProps {
+  warehouses: Warehouse[];
+  onView: (warehouse: Warehouse) => void;
+  onEdit: (warehouse: Warehouse) => void;
+}
+
+export function WarehouseCardView({ warehouses, onView, onEdit }: WarehouseCardViewProps) {
+  const { data: stations } = useStations();
+  const stationNameById = useMemo(
+    () => new Map((stations ?? []).map((s) => [s.id, s.name])),
+    [stations],
+  );
+
+  if (warehouses.length === 0) {
+    return (
+      <Text c="dimmed" ta="center" py="xl">
+        No warehouses found.
+      </Text>
+    );
+  }
+
+  return (
+    <SimpleGrid cols={{ base: 1, sm: 2, lg: 3 }} spacing="md">
+      {warehouses.map((warehouse) => (
+        <Card key={warehouse.id} withBorder radius="md" padding="lg">
+          <Stack gap="sm">
+            <Group justify="space-between" wrap="nowrap" align="flex-start">
+              <div>
+                <Text fw={700}>{warehouse.name}</Text>
+                <Text size="xs" c="dimmed">
+                  {warehouse.code}
+                </Text>
+              </div>
+              <WarehouseStatusBadge status={warehouse.status} />
+            </Group>
+
+            <Group gap="xs">
+              <WarehouseTypeBadge type={warehouse.type} />
+            </Group>
+
+            {warehouse.stationId && stationNameById.get(warehouse.stationId) && (
+              <Group gap={6} c="dimmed">
+                <Building2 size={14} />
+                <Text size="sm">{stationNameById.get(warehouse.stationId)}</Text>
+              </Group>
+            )}
+
+            {warehouse.locationName && (
+              <Group gap={6} c="dimmed">
+                <MapPin size={14} />
+                <Text size="sm">{warehouse.locationName}</Text>
+              </Group>
+            )}
+
+            <Group justify="space-between">
+              <Text size="xs" c="dimmed">
+                Weight
+              </Text>
+              <Text size="sm">{formatCapacity(warehouse.currentWeight, warehouse.capacityWeight)}</Text>
+            </Group>
+            <Group justify="space-between">
+              <Text size="xs" c="dimmed">
+                Containers
+              </Text>
+              <Text size="sm">{formatCapacity(warehouse.currentContainers, warehouse.capacityContainers)}</Text>
+            </Group>
+
+            <Group justify="flex-end" gap="xs" mt="xs">
+              <ActionIcon variant="subtle" color="gray" onClick={() => onView(warehouse)} title="View">
+                <Eye size={16} />
+              </ActionIcon>
+              <ActionIcon variant="subtle" color="gray" onClick={() => onEdit(warehouse)} title="Edit">
+                <Pencil size={16} />
+              </ActionIcon>
+            </Group>
+          </Stack>
+        </Card>
+      ))}
+    </SimpleGrid>
+  );
+}
diff --git a/apps/edr-freight-web/backoffice/src/components/warehouses/WarehouseDashboardCharts.tsx b/apps/edr-freight-web/backoffice/src/components/warehouses/WarehouseDashboardCharts.tsx
new file mode 100644
index 000000000..78b0cf1c8
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/components/warehouses/WarehouseDashboardCharts.tsx
@@ -0,0 +1,237 @@
+import { useMemo, useState } from 'react';
+import { Card, Group, SegmentedControl, SimpleGrid, Text, ThemeIcon } from '@mantine/core';
+import { BarChart3, CalendarRange, PieChart as PieChartIcon } from 'lucide-react';
+import {
+  Bar,
+  BarChart,
+  CartesianGrid,
+  Cell,
+  Legend,
+  Pie,
+  PieChart,
+  ResponsiveContainer,
+  Tooltip,
+  XAxis,
+  YAxis,
+} from 'recharts';
+
+import { useWarehouseInventory } from '@/hooks/useWarehouses';
+import type { WarehouseDashboard, WarehouseInventoryItem } from '@/types/warehouse';
+
+interface WarehouseDashboardChartsProps {
+  data?: WarehouseDashboard;
+}
+
+const ORANGE = '#f08c00';
+const GREEN = '#5bbf4a';
+
+/** Inventory lifecycle status series — alternating orange / light green. */
+const STATUS_SERIES = [
+  { key: 'stored', label: 'Stored', color: ORANGE },
+  { key: 'reserved', label: 'Reserved', color: GREEN },
+  { key: 'readyForLoading', label: 'Ready', color: ORANGE },
+  { key: 'loaded', label: 'Loaded', color: GREEN },
+  { key: 'dispatched', label: 'Dispatched', color: ORANGE },
+] as const;
+
+type Granularity = 'week' | 'month' | 'year';
+
+export function WarehouseDashboardCharts({ data }: WarehouseDashboardChartsProps) {
+  const [granularity, setGranularity] = useState<Granularity>('month');
+  const { data: inventory } = useWarehouseInventory();
+
+  const statusData = STATUS_SERIES.map((s) => ({
+    name: s.label,
+    value: data ? Number(data[s.key as keyof WarehouseDashboard] ?? 0) : 0,
+    color: s.color,
+  }));
+  const hasStatus = statusData.some((d) => d.value > 0);
+
+  const trend = useMemo(
+    () => buildTrend(inventory ?? [], granularity),
+    [inventory, granularity],
+  );
+  const hasTrend = trend.some((b) => b.received > 0 || b.dispatched > 0);
+
+  return (
+    <SimpleGrid cols={{ base: 1, lg: 2 }} spacing="md">
+      {/* Time-filtered throughput */}
+      <Card withBorder radius="lg" padding="lg" style={{ gridColumn: '1 / -1' }}>
+        <Group justify="space-between" mb="md" wrap="wrap">
+          <Group gap="sm">
+            <ThemeIcon size="lg" radius="md" style={{ backgroundColor: ORANGE, color: '#fff' }}>
+              <CalendarRange size={20} />
+            </ThemeIcon>
+            <div>
+              <Text fw={700}>Throughput Over Time</Text>
+              <Text size="xs" c="dimmed">
+                Received vs dispatched inventory
+              </Text>
+            </div>
+          </Group>
+          <SegmentedControl
+            value={granularity}
+            onChange={(v) => setGranularity(v as Granularity)}
+            data={[
+              { label: 'Weekly', value: 'week' },
+              { label: 'Monthly', value: 'month' },
+              { label: 'Yearly', value: 'year' },
+            ]}
+          />
+        </Group>
+
+        {hasTrend ? (
+          <ResponsiveContainer width="100%" height={300}>
+            <BarChart data={trend} margin={{ top: 8, right: 8, left: -16, bottom: 0 }}>
+              <CartesianGrid strokeDasharray="3 3" vertical={false} stroke="var(--mantine-color-gray-2)" />
+              <XAxis dataKey="label" tick={{ fontSize: 12 }} />
+              <YAxis allowDecimals={false} tick={{ fontSize: 12 }} />
+              <Tooltip cursor={{ fill: 'var(--mantine-color-gray-1)' }} />
+              <Legend iconType="circle" />
+              <Bar dataKey="received" name="Received" fill={ORANGE} radius={[6, 6, 0, 0]} />
+              <Bar dataKey="dispatched" name="Dispatched" fill={GREEN} radius={[6, 6, 0, 0]} />
+            </BarChart>
+          </ResponsiveContainer>
+        ) : (
+          <EmptyChart />
+        )}
+      </Card>
+
+      {/* Status distribution bar */}
+      <Card withBorder radius="lg" padding="lg">
+        <Group gap="sm" mb="md">
+          <ThemeIcon size="lg" radius="md" style={{ backgroundColor: GREEN, color: '#fff' }}>
+            <BarChart3 size={20} />
+          </ThemeIcon>
+          <div>
+            <Text fw={700}>Inventory by Status</Text>
+            <Text size="xs" c="dimmed">
+              Items at each lifecycle stage
+            </Text>
+          </div>
+        </Group>
+
+        {hasStatus ? (
+          <ResponsiveContainer width="100%" height={280}>
+            <BarChart data={statusData} margin={{ top: 8, right: 8, left: -16, bottom: 0 }}>
+              <CartesianGrid strokeDasharray="3 3" vertical={false} stroke="var(--mantine-color-gray-2)" />
+              <XAxis dataKey="name" tick={{ fontSize: 12 }} />
+              <YAxis allowDecimals={false} tick={{ fontSize: 12 }} />
+              <Tooltip cursor={{ fill: 'var(--mantine-color-gray-1)' }} />
+              <Bar dataKey="value" name="Items" radius={[6, 6, 0, 0]}>
+                {statusData.map((entry) => (
+                  <Cell key={entry.name} fill={entry.color} />
+                ))}
+              </Bar>
+            </BarChart>
+          </ResponsiveContainer>
+        ) : (
+          <EmptyChart />
+        )}
+      </Card>
+
+      {/* Status distribution donut */}
+      <Card withBorder radius="lg" padding="lg">
+        <Group gap="sm" mb="md">
+          <ThemeIcon size="lg" radius="md" style={{ backgroundColor: ORANGE, color: '#fff' }}>
+            <PieChartIcon size={20} />
+          </ThemeIcon>
+          <div>
+            <Text fw={700}>Lifecycle Distribution</Text>
+            <Text size="xs" c="dimmed">
+              Share of inventory across statuses
+            </Text>
+          </div>
+        </Group>
+
+        {hasStatus ? (
+          <ResponsiveContainer width="100%" height={280}>
+            <PieChart>
+              <Pie
+                data={statusData}
+                dataKey="value"
+                nameKey="name"
+                cx="50%"
+                cy="50%"
+                innerRadius={55}
+                outerRadius={95}
+                paddingAngle={2}
+              >
+                {statusData.map((entry, i) => (
+                  <Cell key={entry.name} fill={i % 2 === 0 ? ORANGE : GREEN} />
+                ))}
+              </Pie>
+              <Tooltip />
+              <Legend verticalAlign="bottom" height={36} iconType="circle" />
+            </PieChart>
+          </ResponsiveContainer>
+        ) : (
+          <EmptyChart />
+        )}
+      </Card>
+    </SimpleGrid>
+  );
+}
+
+interface TrendBucket {
+  label: string;
+  received: number;
+  dispatched: number;
+}
+
+/** Bucket inventory by arrived/dispatched timestamps into recent week/month/year periods. */
+function buildTrend(items: WarehouseInventoryItem[], granularity: Granularity): TrendBucket[] {
+  const now = new Date();
+  const buckets: { label: string; start: Date; end: Date }[] = [];
+
+  if (granularity === 'week') {
+    for (let i = 7; i >= 0; i--) {
+      const end = new Date(now);
+      end.setDate(now.getDate() - i * 7);
+      const start = new Date(end);
+      start.setDate(end.getDate() - 7);
+      buckets.push({ label: `W${8 - i}`, start, end });
+    }
+  } else if (granularity === 'month') {
+    for (let i = 11; i >= 0; i--) {
+      const start = new Date(now.getFullYear(), now.getMonth() - i, 1);
+      const end = new Date(now.getFullYear(), now.getMonth() - i + 1, 1);
+      buckets.push({
+        label: start.toLocaleString('en', { month: 'short' }),
+        start,
+        end,
+      });
+    }
+  } else {
+    for (let i = 4; i >= 0; i--) {
+      const year = now.getFullYear() - i;
+      buckets.push({
+        label: String(year),
+        start: new Date(year, 0, 1),
+        end: new Date(year + 1, 0, 1),
+      });
+    }
+  }
+
+  const inRange = (iso: string | null | undefined, start: Date, end: Date) => {
+    if (!iso) return false;
+    const t = new Date(iso).getTime();
+    return t >= start.getTime() && t < end.getTime();
+  };
+
+  return buckets.map((b) => ({
+    label: b.label,
+    received: items.filter((it) => inRange(it.arrivedAt, b.start, b.end)).length,
+    dispatched: items.filter((it) => inRange(it.dispatchedAt, b.start, b.end)).length,
+  }));
+}
+
+function EmptyChart() {
+  return (
+    <Group justify="center" align="center" h={280}>
+      <Text c="dimmed" size="sm">
+        No inventory data to chart yet.
+      </Text>
+    </Group>
+  );
+}
diff --git a/apps/edr-freight-web/backoffice/src/components/warehouses/WarehouseFilters.tsx b/apps/edr-freight-web/backoffice/src/components/warehouses/WarehouseFilters.tsx
new file mode 100644
index 000000000..efcbe39cd
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/components/warehouses/WarehouseFilters.tsx
@@ -0,0 +1,55 @@
+import { Group, SegmentedControl, Select, TextInput } from '@mantine/core';
+import { LayoutGrid, Search, Table as TableIcon } from 'lucide-react';
+
+import type { WarehouseFilter, WarehouseStatus, WarehouseType } from '@/types/warehouse';
+import { statusOptions, warehouseTypeOptions } from './options';
+
+export type WarehouseView = 'table' | 'card';
+
+interface WarehouseFiltersProps {
+  filter: WarehouseFilter;
+  onChange: (next: WarehouseFilter) => void;
+  view: WarehouseView;
+  onViewChange: (view: WarehouseView) => void;
+}
+
+export function WarehouseFilters({ filter, onChange, view, onViewChange }: WarehouseFiltersProps) {
+  return (
+    <Group justify="space-between" wrap="wrap" gap="sm">
+      <Group gap="sm" wrap="wrap">
+        <TextInput
+          placeholder="Search by name, code or location"
+          leftSection={<Search size={16} />}
+          value={filter.search ?? ''}
+          onChange={(e) => onChange({ ...filter, search: e.currentTarget.value || undefined })}
+          w={280}
+        />
+        <Select
+          placeholder="All types"
+          clearable
+          data={warehouseTypeOptions}
+          value={filter.type ?? null}
+          onChange={(value) => onChange({ ...filter, type: (value as WarehouseType) || undefined })}
+          w={190}
+        />
+        <Select
+          placeholder="All statuses"
+          clearable
+          data={statusOptions}
+          value={filter.status ?? null}
+          onChange={(value) => onChange({ ...filter, status: (value as WarehouseStatus) || undefined })}
+          w={160}
+        />
+      </Group>
+
+      <SegmentedControl
+        value={view}
+        onChange={(value) => onViewChange(value as WarehouseView)}
+        data={[
+          { value: 'table', label: <TableIcon size={16} /> },
+          { value: 'card', label: <LayoutGrid size={16} /> },
+        ]}
+      />
+    </Group>
+  );
+}
diff --git a/apps/edr-freight-web/backoffice/src/components/warehouses/WarehouseHero.tsx b/apps/edr-freight-web/backoffice/src/components/warehouses/WarehouseHero.tsx
new file mode 100644
index 000000000..48a6ea2a9
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/components/warehouses/WarehouseHero.tsx
@@ -0,0 +1,57 @@
+import type { ReactNode } from 'react';
+import { Box, Group, Stack, Text, Title } from '@mantine/core';
+
+import { FreightVisual, type FreightVisualVariant } from './FreightVisual';
+
+interface WarehouseHeroProps {
+  title: string;
+  subtitle?: string;
+  /** Primary illustration shown on the right of the hero. */
+  variant?: FreightVisualVariant;
+  /** Optional secondary illustration tucked behind the primary. */
+  secondaryVariant?: FreightVisualVariant;
+  actions?: ReactNode;
+}
+
+/**
+ * Page header hero with a lightweight freight illustration. Low-contrast,
+ * minimal — sets context without overpowering the data below.
+ */
+export function WarehouseHero({
+  title,
+  subtitle,
+  variant = 'warehouse',
+  secondaryVariant,
+  actions,
+}: WarehouseHeroProps) {
+  return (
+    <Box
+      style={{
+        background: 'linear-gradient(135deg, #F8F9FA 0%, #F1F3F5 100%)',
+        border: '1px solid #E9ECEF',
+        borderRadius: 'var(--mantine-radius-md)',
+        padding: 'var(--mantine-spacing-lg)',
+        overflow: 'hidden',
+      }}
+    >
+      <Group justify="space-between" wrap="nowrap" align="center">
+        <Stack gap={4}>
+          <Title order={3}>{title}</Title>
+          {subtitle && (
+            <Text size="sm" c="dimmed">
+              {subtitle}
+            </Text>
+          )}
+          {actions && <Group mt="sm">{actions}</Group>}
+        </Stack>
+
+        <Group gap="xs" wrap="nowrap" style={{ opacity: 0.95 }}>
+          {secondaryVariant && (
+            <FreightVisual variant={secondaryVariant} size={56} style={{ opacity: 0.7 }} />
+          )}
+          <FreightVisual variant={variant} size={84} />
+        </Group>
+      </Group>
+    </Box>
+  );
+}
diff --git a/apps/edr-freight-web/backoffice/src/components/warehouses/WarehouseInfoCard.tsx b/apps/edr-freight-web/backoffice/src/components/warehouses/WarehouseInfoCard.tsx
new file mode 100644
index 000000000..83dcc4d63
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/components/warehouses/WarehouseInfoCard.tsx
@@ -0,0 +1,138 @@
+import { useState } from 'react';
+import { Badge, Button, Card, Divider, Group, Stack, Text } from '@mantine/core';
+import { PackagePlus, Train as TrainIcon, Warehouse as WarehouseIcon } from 'lucide-react';
+
+import { useBookingSchedule, useWarehouseInventory } from '@/hooks/useWarehouses';
+import { InventoryStatusBadge } from './badges';
+import { FreightVisual } from './FreightVisual';
+import { formatDate } from './options';
+import { ReceiveInventoryModal } from './ReceiveInventoryModal';
+
+interface WarehouseInfoCardProps {
+  bookingId: string;
+  bookingReference?: string;
+}
+
+function Row({ label, value }: { label: string; value: React.ReactNode }) {
+  return (
+    <Group justify="space-between" wrap="nowrap">
+      <Text size="sm" c="dimmed">
+        {label}
+      </Text>
+      <Text size="sm" fw={500} ta="right">
+        {value}
+      </Text>
+    </Group>
+  );
+}
+
+export function WarehouseInfoCard({ bookingId, bookingReference }: WarehouseInfoCardProps) {
+  const [modalOpen, setModalOpen] = useState(false);
+  const { data, isLoading } = useWarehouseInventory({ bookingId });
+  const { data: scheduleView } = useBookingSchedule(bookingId);
+
+  const items = data ?? [];
+  const latest = items[0];
+  const schedule = scheduleView?.schedule;
+  const wagon = scheduleView?.wagon;
+  const isLoadedOrDispatched =
+    latest?.status === 'LOADED' || latest?.status === 'DISPATCHED';
+
+  return (
+    <Card withBorder radius="md" padding="lg">
+      <Stack gap="md">
+        <Group justify="space-between">
+          <Group gap="xs">
+            <WarehouseIcon size={18} />
+            <Text fw={700}>Warehouse Information</Text>
+          </Group>
+          {items.length > 0 && (
+            <Badge variant="light" color="gray">
+              {items.length} item{items.length > 1 ? 's' : ''}
+            </Badge>
+          )}
+        </Group>
+
+        <Divider />
+
+        {isLoading ? (
+          <Text size="sm" c="dimmed">
+            Loading…
+          </Text>
+        ) : !latest ? (
+          <Text size="sm" c="dimmed">
+            This booking has not been received at any warehouse yet.
+          </Text>
+        ) : (
+          <Stack gap="xs">
+            <Row label="Warehouse" value={latest.warehouse ? `${latest.warehouse.name} (${latest.warehouse.code})` : '—'} />
+            <Row label="Yard" value={latest.yard ? `${latest.yard.name} (${latest.yard.code})` : '—'} />
+            <Row label="Zone" value={latest.zone ? `${latest.zone.name} (${latest.zone.code})` : '—'} />
+            <Row label="Inventory Status" value={<InventoryStatusBadge status={latest.status} />} />
+            <Row label="Arrived At" value={formatDate(latest.arrivedAt)} />
+            <Row label="Ready For Loading At" value={formatDate(latest.readyForLoadingAt)} />
+            {isLoadedOrDispatched && (
+              <>
+                <Row
+                  label="Wagon"
+                  value={wagon?.wagonNumber ?? '—'}
+                />
+                <Row label="Loaded At" value={formatDate(latest.loadedAt)} />
+                <Row label="Dispatched At" value={formatDate(latest.dispatchedAt)} />
+              </>
+            )}
+          </Stack>
+        )}
+
+        {schedule && (
+          <>
+            <Divider
+              label={
+                <Group gap={6}>
+                  <TrainIcon size={14} />
+                  <Text size="xs" c="dimmed">
+                    Train schedule (read-only)
+                  </Text>
+                </Group>
+              }
+              labelPosition="left"
+            />
+            <Group gap="sm" wrap="nowrap" align="flex-start">
+              <FreightVisual variant="train" size={40} />
+              <Stack gap="xs" style={{ flex: 1 }}>
+                <Row
+                  label="Departure Status"
+                  value={
+                    <Badge variant="light" color="blue" size="sm">
+                      {schedule.status}
+                    </Badge>
+                  }
+                />
+                <Row label="Scheduled Departure" value={formatDate(schedule.scheduledDepartureDate)} />
+                <Row label="Scheduled Arrival" value={formatDate(schedule.scheduledArrivalDate)} />
+                {wagon?.wagonNumber && <Row label="Assigned Wagon" value={wagon.wagonNumber} />}
+                {wagon?.sequenceNo != null && <Row label="Wagon Position" value={`#${wagon.sequenceNo}`} />}
+              </Stack>
+            </Group>
+          </>
+        )}
+
+        <Button
+          variant="light"
+          leftSection={<PackagePlus size={16} />}
+          onClick={() => setModalOpen(true)}
+          fullWidth
+        >
+          Receive At Warehouse
+        </Button>
+      </Stack>
+
+      <ReceiveInventoryModal
+        opened={modalOpen}
+        onClose={() => setModalOpen(false)}
+        bookingId={bookingId}
+        bookingLabel={bookingReference}
+      />
+    </Card>
+  );
+}
diff --git a/apps/edr-freight-web/backoffice/src/components/warehouses/WarehouseInquiryTable.tsx b/apps/edr-freight-web/backoffice/src/components/warehouses/WarehouseInquiryTable.tsx
new file mode 100644
index 000000000..8a282957a
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/components/warehouses/WarehouseInquiryTable.tsx
@@ -0,0 +1,85 @@
+import { Stack, Table, Text } from '@mantine/core';
+
+import type { InventoryInquiryResult } from '@/types/warehouse';
+import { InventoryStatusBadge } from './badges';
+import { formatDate, formatNumber } from './options';
+
+interface WarehouseInquiryTableProps {
+  results: InventoryInquiryResult[];
+}
+
+const itemDescriptor = (result: InventoryInquiryResult) => {
+  if (result.containerNumber) return `Container ${result.containerNumber}`;
+  if (result.cargoType) return `Cargo · ${result.cargoType}`;
+  if (result.cargoDescription) return `Cargo · ${result.cargoDescription}`;
+  if (result.goodsId) return 'Goods';
+  return '—';
+};
+
+export function WarehouseInquiryTable({ results }: WarehouseInquiryTableProps) {
+  if (results.length === 0) {
+    return (
+      <Text c="dimmed" ta="center" py="xl">
+        No matching items. Adjust your search to locate cargo, containers or goods.
+      </Text>
+    );
+  }
+
+  return (
+    <Table.ScrollContainer minWidth={1100}>
+      <Table highlightOnHover verticalSpacing="sm" striped>
+        <Table.Thead>
+          <Table.Tr>
+            <Table.Th>Booking</Table.Th>
+            <Table.Th>Customer</Table.Th>
+            <Table.Th>Item</Table.Th>
+            <Table.Th>Warehouse</Table.Th>
+            <Table.Th>Yard</Table.Th>
+            <Table.Th>Zone</Table.Th>
+            <Table.Th>Status</Table.Th>
+            <Table.Th>Qty</Table.Th>
+            <Table.Th>Weight</Table.Th>
+            <Table.Th>Arrived</Table.Th>
+            <Table.Th>Ready</Table.Th>
+          </Table.Tr>
+        </Table.Thead>
+        <Table.Tbody>
+          {results.map((result) => (
+            <Table.Tr key={result.id}>
+              <Table.Td>
+                <Text size="sm" fw={600}>
+                  {result.bookingNumber ?? result.bookingId.slice(0, 8)}
+                </Text>
+              </Table.Td>
+              <Table.Td>{result.customerName ?? '—'}</Table.Td>
+              <Table.Td>{itemDescriptor(result)}</Table.Td>
+              <Table.Td>
+                <Stack gap={0}>
+                  <Text size="sm">{result.warehouse?.name ?? '—'}</Text>
+                  {result.warehouse?.code && (
+                    <Text size="xs" c="dimmed">
+                      {result.warehouse.code}
+                    </Text>
+                  )}
+                </Stack>
+              </Table.Td>
+              <Table.Td>{result.yard?.name ?? '—'}</Table.Td>
+              <Table.Td>{result.zone?.name ?? '—'}</Table.Td>
+              <Table.Td>
+                <InventoryStatusBadge status={result.status} />
+              </Table.Td>
+              <Table.Td>{formatNumber(result.quantity)}</Table.Td>
+              <Table.Td>{formatNumber(result.weight)}</Table.Td>
+              <Table.Td>
+                <Text size="xs">{formatDate(result.arrivedAt)}</Text>
+              </Table.Td>
+              <Table.Td>
+                <Text size="xs">{formatDate(result.readyForLoadingAt)}</Text>
+              </Table.Td>
+            </Table.Tr>
+          ))}
+        </Table.Tbody>
+      </Table>
+    </Table.ScrollContainer>
+  );
+}
diff --git a/apps/edr-freight-web/backoffice/src/components/warehouses/WarehouseInventoryTable.tsx b/apps/edr-freight-web/backoffice/src/components/warehouses/WarehouseInventoryTable.tsx
new file mode 100644
index 000000000..11d9d323f
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/components/warehouses/WarehouseInventoryTable.tsx
@@ -0,0 +1,154 @@
+import { ActionIcon, Badge, Button, Group, Table, Text, Tooltip } from '@mantine/core';
+import { ArrowRightLeft, ClipboardList, Coins, History } from 'lucide-react';
+
+import type { InventoryAction, WarehouseInventoryItem } from '@/types/warehouse';
+import { INVENTORY_NEXT_ACTION } from '@/types/warehouse';
+import { InventoryStatusBadge } from './badges';
+import { formatDate, formatNumber, humanizeEnum } from './options';
+
+interface WarehouseInventoryTableProps {
+  items: WarehouseInventoryItem[];
+  busyId?: string | null;
+  onAdvance: (item: WarehouseInventoryItem, action: InventoryAction) => void;
+  onMove: (item: WarehouseInventoryItem) => void;
+  onHistory: (item: WarehouseInventoryItem) => void;
+  onInspect?: (item: WarehouseInventoryItem) => void;
+  onFeePreview?: (item: WarehouseInventoryItem) => void;
+}
+
+const itemKind = (item: WarehouseInventoryItem) => {
+  if (item.containerId) return { label: 'Container', color: 'blue' };
+  if (item.cargoId) return { label: 'Cargo', color: 'grape' };
+  if (item.goodsId) return { label: 'Goods', color: 'orange' };
+  return { label: '—', color: 'gray' };
+};
+
+const actionColor: Record<InventoryAction, string> = {
+  store: 'blue',
+  reserve: 'grape',
+  'ready-for-loading': 'cyan',
+  load: 'teal',
+  dispatch: 'green',
+};
+
+export function WarehouseInventoryTable({
+  items,
+  busyId,
+  onAdvance,
+  onMove,
+  onHistory,
+  onInspect,
+  onFeePreview,
+}: WarehouseInventoryTableProps) {
+  if (items.length === 0) {
+    return (
+      <Text c="dimmed" ta="center" py="xl">
+        No inventory items found.
+      </Text>
+    );
+  }
+
+  return (
+    <Table.ScrollContainer minWidth={1150}>
+      <Table highlightOnHover verticalSpacing="sm" striped>
+        <Table.Thead>
+          <Table.Tr>
+            <Table.Th>Booking</Table.Th>
+            <Table.Th>Facility</Table.Th>
+            <Table.Th>Warehouse</Table.Th>
+            <Table.Th>Yard</Table.Th>
+            <Table.Th>Zone</Table.Th>
+            <Table.Th>Item</Table.Th>
+            <Table.Th>Qty</Table.Th>
+            <Table.Th>Weight</Table.Th>
+            <Table.Th>Status</Table.Th>
+            <Table.Th>Arrived</Table.Th>
+            <Table.Th ta="right">Actions</Table.Th>
+          </Table.Tr>
+        </Table.Thead>
+        <Table.Tbody>
+          {items.map((item) => {
+            const kind = itemKind(item);
+            const busy = busyId === item.id;
+            const nextAction = INVENTORY_NEXT_ACTION[item.status];
+            return (
+              <Table.Tr key={item.id}>
+                <Table.Td>
+                  {item.bookingId ? (
+                    <Tooltip label={item.bookingId} withArrow>
+                      <Text size="sm" fw={600}>
+                        {item.bookingId.slice(0, 8)}…
+                      </Text>
+                    </Tooltip>
+                  ) : (
+                    <Text size="sm" c="dimmed">
+                      —
+                    </Text>
+                  )}
+                </Table.Td>
+                <Table.Td>{item.warehouse?.facility?.name ?? '—'}</Table.Td>
+                <Table.Td>{item.warehouse?.code ?? '—'}</Table.Td>
+                <Table.Td>{item.yard?.code ?? '—'}</Table.Td>
+                <Table.Td>{item.zone?.code ?? '—'}</Table.Td>
+                <Table.Td>
+                  <Badge color={kind.color} variant="light" size="sm" radius="md">
+                    {kind.label}
+                  </Badge>
+                </Table.Td>
+                <Table.Td>{formatNumber(item.quantity)}</Table.Td>
+                <Table.Td>{formatNumber(item.weight)}</Table.Td>
+                <Table.Td>
+                  <InventoryStatusBadge status={item.status} />
+                </Table.Td>
+                <Table.Td>
+                  <Text size="xs">{formatDate(item.arrivedAt)}</Text>
+                </Table.Td>
+                <Table.Td>
+                  <Group gap="xs" justify="flex-end" wrap="nowrap">
+                    {nextAction && (
+                      <Button
+                        size="compact-xs"
+                        variant="light"
+                        color={actionColor[nextAction]}
+                        loading={busy}
+                        onClick={() => onAdvance(item, nextAction)}
+                      >
+                        {humanizeEnum(nextAction.replace(/-/g, '_'))}
+                      </Button>
+                    )}
+                    {item.status !== 'DISPATCHED' && (
+                      <Tooltip label="Move" withArrow>
+                        <ActionIcon variant="subtle" color="gray" onClick={() => onMove(item)}>
+                          <ArrowRightLeft size={16} />
+                        </ActionIcon>
+                      </Tooltip>
+                    )}
+                    {onInspect && (
+                      <Tooltip label="Inspection / Report" withArrow>
+                        <ActionIcon variant="subtle" color="orange" onClick={() => onInspect(item)}>
+                          <ClipboardList size={16} />
+                        </ActionIcon>
+                      </Tooltip>
+                    )}
+                    {onFeePreview && (
+                      <Tooltip label="Storage / Demurrage preview" withArrow>
+                        <ActionIcon variant="subtle" color="teal" onClick={() => onFeePreview(item)}>
+                          <Coins size={16} />
+                        </ActionIcon>
+                      </Tooltip>
+                    )}
+                    <Tooltip label="History" withArrow>
+                      <ActionIcon variant="subtle" color="gray" onClick={() => onHistory(item)}>
+                        <History size={16} />
+                      </ActionIcon>
+                    </Tooltip>
+                  </Group>
+                </Table.Td>
+              </Table.Tr>
+            );
+          })}
+        </Table.Tbody>
+      </Table>
+    </Table.ScrollContainer>
+  );
+}
diff --git a/apps/edr-freight-web/backoffice/src/components/warehouses/WarehouseTable.tsx b/apps/edr-freight-web/backoffice/src/components/warehouses/WarehouseTable.tsx
new file mode 100644
index 000000000..fbd3a94c1
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/components/warehouses/WarehouseTable.tsx
@@ -0,0 +1,92 @@
+import { useMemo } from 'react';
+import { ActionIcon, Anchor, Group, Table, Text } from '@mantine/core';
+import { Eye, Pencil } from 'lucide-react';
+
+import { useStations } from '@/hooks/useStations';
+import type { Warehouse } from '@/types/warehouse';
+import { WarehouseStatusBadge, WarehouseTypeBadge } from './badges';
+import { formatCapacity } from './options';
+
+interface WarehouseTableProps {
+  warehouses: Warehouse[];
+  onView: (warehouse: Warehouse) => void;
+  onEdit: (warehouse: Warehouse) => void;
+}
+
+export function WarehouseTable({ warehouses, onView, onEdit }: WarehouseTableProps) {
+  const { data: stations } = useStations();
+  const stationNameById = useMemo(
+    () => new Map((stations ?? []).map((s) => [s.id, s.name])),
+    [stations],
+  );
+
+  if (warehouses.length === 0) {
+    return (
+      <Text c="dimmed" ta="center" py="xl">
+        No warehouses found.
+      </Text>
+    );
+  }
+
+  return (
+    <Table.ScrollContainer minWidth={900}>
+      <Table highlightOnHover verticalSpacing="sm" striped>
+        <Table.Thead>
+          <Table.Tr>
+            <Table.Th>Code</Table.Th>
+            <Table.Th>Name</Table.Th>
+            <Table.Th>Facility</Table.Th>
+            <Table.Th>Type</Table.Th>
+            <Table.Th>Location</Table.Th>
+            <Table.Th>Weight (cur / cap)</Table.Th>
+            <Table.Th>Containers (cur / cap)</Table.Th>
+            <Table.Th>Status</Table.Th>
+            <Table.Th ta="right">Actions</Table.Th>
+          </Table.Tr>
+        </Table.Thead>
+        <Table.Tbody>
+          {warehouses.map((warehouse) => (
+            <Table.Tr key={warehouse.id}>
+              <Table.Td>
+                <Anchor fw={600} size="sm" onClick={() => onView(warehouse)}>
+                  {warehouse.code}
+                </Anchor>
+              </Table.Td>
+              <Table.Td>{warehouse.name}</Table.Td>
+              <Table.Td>
+                {warehouse.stationId && stationNameById.get(warehouse.stationId) ? (
+                  <Text size="sm" fw={500}>
+                    {stationNameById.get(warehouse.stationId)}
+                  </Text>
+                ) : (
+                  <Text size="sm" c="dimmed">
+                    —
+                  </Text>
+                )}
+              </Table.Td>
+              <Table.Td>
+                <WarehouseTypeBadge type={warehouse.type} />
+              </Table.Td>
+              <Table.Td>{warehouse.locationName ?? '—'}</Table.Td>
+              <Table.Td>{formatCapacity(warehouse.currentWeight, warehouse.capacityWeight)}</Table.Td>
+              <Table.Td>{formatCapacity(warehouse.currentContainers, warehouse.capacityContainers)}</Table.Td>
+              <Table.Td>
+                <WarehouseStatusBadge status={warehouse.status} />
+              </Table.Td>
+              <Table.Td>
+                <Group gap="xs" justify="flex-end" wrap="nowrap">
+                  <ActionIcon variant="subtle" color="gray" onClick={() => onView(warehouse)} title="View">
+                    <Eye size={16} />
+                  </ActionIcon>
+                  <ActionIcon variant="subtle" color="gray" onClick={() => onEdit(warehouse)} title="Edit">
+                    <Pencil size={16} />
+                  </ActionIcon>
+                </Group>
+              </Table.Td>
+            </Table.Tr>
+          ))}
+        </Table.Tbody>
+      </Table>
+    </Table.ScrollContainer>
+  );
+}
diff --git a/apps/edr-freight-web/backoffice/src/components/warehouses/badges.tsx b/apps/edr-freight-web/backoffice/src/components/warehouses/badges.tsx
new file mode 100644
index 000000000..c95e566bb
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/components/warehouses/badges.tsx
@@ -0,0 +1,52 @@
+import { Badge } from '@mantine/core';
+
+import type { InventoryStatus, WarehouseStatus, WarehouseType } from '@/types/warehouse';
+
+const humanize = (value: string) =>
+  value
+    .toLowerCase()
+    .split('_')
+    .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+    .join(' ');
+
+const badgeStyle = {
+  fontSize: '0.7rem',
+  letterSpacing: '0.04em',
+  whiteSpace: 'nowrap' as const,
+};
+
+export function WarehouseTypeBadge({ type }: { type: WarehouseType }) {
+  const color = type === 'CLOSED_WAREHOUSE' ? 'indigo' : 'teal';
+  return (
+    <Badge color={color} variant="light" size="sm" radius="md" fw={600} style={badgeStyle}>
+      {humanize(type)}
+    </Badge>
+  );
+}
+
+export function WarehouseStatusBadge({ status }: { status: WarehouseStatus }) {
+  const color = status === 'ACTIVE' ? 'green' : 'gray';
+  return (
+    <Badge color={color} variant="light" size="sm" radius="md" tt="uppercase" fw={600} style={badgeStyle}>
+      {status}
+    </Badge>
+  );
+}
+
+const inventoryStatusColor: Record<InventoryStatus, string> = {
+  RECEIVED: 'yellow',
+  STORED: 'blue',
+  RESERVED: 'grape',
+  READY_FOR_LOADING: 'cyan',
+  LOADED: 'teal',
+  DISPATCHED: 'green',
+};
+
+export function InventoryStatusBadge({ status }: { status: InventoryStatus }) {
+  const color = inventoryStatusColor[status] ?? 'gray';
+  return (
+    <Badge color={color} variant="light" size="sm" radius="md" fw={600} style={badgeStyle}>
+      {humanize(status)}
+    </Badge>
+  );
+}
diff --git a/apps/edr-freight-web/backoffice/src/components/warehouses/index.ts b/apps/edr-freight-web/backoffice/src/components/warehouses/index.ts
new file mode 100644
index 000000000..c0111fbef
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/components/warehouses/index.ts
@@ -0,0 +1,29 @@
+export * from './badges';
+export * from './options';
+export { WarehouseFilters } from './WarehouseFilters';
+export type { WarehouseView } from './WarehouseFilters';
+export { WarehouseTable } from './WarehouseTable';
+export { WarehouseCardView } from './WarehouseCardView';
+export { WarehouseInventoryTable } from './WarehouseInventoryTable';
+export { WarehouseInquiryTable } from './WarehouseInquiryTable';
+export { CreateWarehouseModal } from './CreateWarehouseModal';
+export { CreateYardModal } from './CreateYardModal';
+export { CreateZoneModal } from './CreateZoneModal';
+export { ReceiveInventoryModal } from './ReceiveInventoryModal';
+export { WarehouseInfoCard } from './WarehouseInfoCard';
+export { MoveInventoryModal } from './MoveInventoryModal';
+export { ReserveInventoryModal } from './ReserveInventoryModal';
+export { InventoryMovementHistoryTable } from './InventoryMovementHistoryTable';
+export { ActivityTimeline } from './ActivityTimeline';
+export { InventoryHistoryModal } from './InventoryHistoryModal';
+export { InventoryWorkbench } from './InventoryWorkbench';
+export { BookingSelect } from './BookingSelect';
+export { WagonSelect } from './WagonSelect';
+export { LoadInventoryModal } from './LoadInventoryModal';
+export { FreightVisual } from './FreightVisual';
+export type { FreightVisualVariant } from './FreightVisual';
+export { WarehouseHero } from './WarehouseHero';
+export { VisualEmptyState } from './VisualEmptyState';
+export { WarehouseDashboardCharts } from './WarehouseDashboardCharts';
+export { InspectionReportModal } from './InspectionReportModal';
+export { FeePreviewModal } from './FeePreviewModal';
diff --git a/apps/edr-freight-web/backoffice/src/components/warehouses/options.ts b/apps/edr-freight-web/backoffice/src/components/warehouses/options.ts
new file mode 100644
index 000000000..aba631d33
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/components/warehouses/options.ts
@@ -0,0 +1,56 @@
+import {
+  WAREHOUSE_TYPES,
+  WAREHOUSE_YARD_TYPES,
+  WAREHOUSE_ZONE_TYPES,
+  WAREHOUSE_STATUSES,
+  INVENTORY_STATUSES,
+} from '@/types/warehouse';
+
+export const humanizeEnum = (value: string) =>
+  value
+    .toLowerCase()
+    .split('_')
+    .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+    .join(' ');
+
+const toOptions = (values: readonly string[]) =>
+  values.map((value) => ({ value, label: humanizeEnum(value) }));
+
+export const warehouseTypeOptions = toOptions(WAREHOUSE_TYPES);
+export const yardTypeOptions = toOptions(WAREHOUSE_YARD_TYPES);
+export const zoneTypeOptions = toOptions(WAREHOUSE_ZONE_TYPES);
+export const statusOptions = toOptions(WAREHOUSE_STATUSES);
+export const inventoryStatusOptions = toOptions(INVENTORY_STATUSES);
+
+export const formatNumber = (value: number | null | undefined) => {
+  if (value === null || value === undefined) return '—';
+  const num = Number(value);
+  if (Number.isNaN(num)) return '—';
+  return num.toLocaleString(undefined, { maximumFractionDigits: 3 });
+};
+
+export const formatCapacity = (current: number, capacity: number | null | undefined) => {
+  const cur = formatNumber(current);
+  if (capacity === null || capacity === undefined) return cur;
+  return `${cur} / ${formatNumber(capacity)}`;
+};
+
+export const formatDate = (value: string | null | undefined) => {
+  if (!value) return '—';
+  const date = new Date(value);
+  if (Number.isNaN(date.getTime())) return '—';
+  return date.toLocaleString(undefined, {
+    year: 'numeric',
+    month: 'short',
+    day: 'numeric',
+    hour: '2-digit',
+    minute: '2-digit',
+  });
+};
+
+export const extractErrorMessage = (error: unknown, fallback = 'Something went wrong') => {
+  const responseData = (error as { response?: { data?: unknown } })?.response?.data;
+  const data = responseData && typeof responseData === 'object' ? (responseData as Record<string, unknown>) : undefined;
+  const rawMessage = data?.message ?? data?.error ?? (error as Error)?.message;
+  return Array.isArray(rawMessage) ? rawMessage.join(', ') : rawMessage ? String(rawMessage) : fallback;
+};
diff --git a/apps/edr-freight-web/backoffice/src/constants/URLS.ts b/apps/edr-freight-web/backoffice/src/constants/URLS.ts
index c87cf300c..ab023d1b3 100644
--- a/apps/edr-freight-web/backoffice/src/constants/URLS.ts
+++ b/apps/edr-freight-web/backoffice/src/constants/URLS.ts
@@ -259,4 +259,77 @@ export const URL_CONSTANTS = {
     CONTAINER_TYPES: '/api/reference/container-types',
     CURRENCIES: '/api/reference/currencies',
   },
+
+  FACILITIES: {
+    BASE: '/facilities',
+    BY_ID: (id: string) => `/facilities/${id}`,
+  },
+
+  WAREHOUSES: {
+    BASE: '/warehouses',
+    DASHBOARD: '/warehouses/dashboard',
+    BY_ID: (id: string) => `/warehouses/${id}`,
+    YARDS: (warehouseId: string) => `/warehouses/${warehouseId}/yards`,
+  },
+
+  WAREHOUSE_YARDS: {
+    BY_ID: (id: string) => `/warehouse-yards/${id}`,
+    ZONES: (yardId: string) => `/warehouse-yards/${yardId}/zones`,
+  },
+
+  WAREHOUSE_ZONES: {
+    BY_ID: (id: string) => `/warehouse-zones/${id}`,
+  },
+
+  WAREHOUSE_INVENTORY: {
+    BASE: '/warehouse-inventory',
+    RECEIVE: '/warehouse-inventory/receive',
+    RESERVE: '/warehouse-inventory/reserve',
+    ARRIVAL_QUEUE: '/warehouse-inventory/arrival-queue',
+    AUTO_UNLOAD_ARRIVED: '/warehouse-inventory/auto-unload-arrived',
+    AUTO_LOAD_READY: '/warehouse-inventory/auto-load-ready',
+    UNLOAD_BOOKING: (bookingId: string) => `/warehouse-inventory/bookings/${bookingId}/unload`,
+    INSPECTION_REPORTS: (inventoryId: string) => `/warehouse-inventory/${inventoryId}/inspection-reports`,
+    READY_FOR_LOADING: '/warehouse-inventory/ready-for-loading',
+    INQUIRY: '/warehouse-inventory/inquiry',
+    LOADABLE_WAGONS: '/warehouse-inventory/loadable-wagons',
+    BOOKING_SCHEDULE: (bookingId: string) => `/warehouse-inventory/booking/${bookingId}/schedule`,
+    MOVE: (id: string) => `/warehouse-inventory/${id}/move`,
+    MOVEMENTS: (id: string) => `/warehouse-inventory/${id}/movements`,
+    ACTIVITY: (id: string) => `/warehouse-inventory/${id}/activity`,
+    LOADINGS: (id: string) => `/warehouse-inventory/${id}/loadings`,
+    STORE: (id: string) => `/warehouse-inventory/${id}/store`,
+    MARK_READY: (id: string) => `/warehouse-inventory/${id}/ready-for-loading`,
+    LOAD: (id: string) => `/warehouse-inventory/${id}/load`,
+    DISPATCH: (id: string) => `/warehouse-inventory/${id}/dispatch`,
+  },
+
+  WAREHOUSE_LOADINGS: {
+    BASE: '/warehouse-loadings',
+  },
+
+  WAREHOUSE_INSPECTION: {
+    BY_ID: (id: string) => `/warehouse-inspection-reports/${id}`,
+    ATTACHMENTS: (id: string) => `/warehouse-inspection-reports/${id}/attachments`,
+  },
+
+  WAREHOUSE_RULES: {
+    ALLOCATION: '/warehouse-allocation-rules',
+    ALLOCATION_BY_ID: (id: string) => `/warehouse-allocation-rules/${id}`,
+    ALLOCATION_PREVIEW: '/warehouse-allocation/preview',
+    FEES: '/warehouse-fee-rules',
+    FEES_BY_ID: (id: string) => `/warehouse-fee-rules/${id}`,
+    FEE_PREVIEW: (inventoryId: string) => `/warehouse-inventory/${inventoryId}/fee-preview`,
+  },
+
+  WAREHOUSE_INVOICES: {
+    BASE: '/warehouse-fee-invoices',
+    BY_ID: (id: string) => `/warehouse-fee-invoices/${id}`,
+    CANCEL: (id: string) => `/warehouse-fee-invoices/${id}/cancel`,
+    PAY: (id: string) => `/warehouse-fee-invoices/${id}/pay`,
+    GENERATE: (inventoryId: string) => `/warehouse-inventory/${inventoryId}/generate-fee-invoice`,
+    FOR_INVENTORY: (inventoryId: string) => `/warehouse-inventory/${inventoryId}/fee-invoices`,
+    FOR_BOOKING: (bookingId: string) => `/bookings/${bookingId}/warehouse-fee-invoices`,
+    GATE_CLEARANCE: (inventoryId: string) => `/warehouse-inventory/${inventoryId}/gate-clearance`,
+  },
 };
diff --git a/apps/edr-freight-web/backoffice/src/hooks/useCargoes.ts b/apps/edr-freight-web/backoffice/src/hooks/useCargoes.ts
index 12e257520..3c1cdf517 100644
--- a/apps/edr-freight-web/backoffice/src/hooks/useCargoes.ts
+++ b/apps/edr-freight-web/backoffice/src/hooks/useCargoes.ts
@@ -1,5 +1,5 @@
 import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
-import { cargoService } from '@/services/cargoService';
+import { cargoService, type DeliverCargoPayload } from '@/services/cargoService';
 
 export const cargoKeys = {
   all: ['cargoes'] as const,
@@ -53,7 +53,8 @@ export function useLoadCargo() {
 export function useDeliverCargo() {
   const qc = useQueryClient();
   return useMutation({
-    mutationFn: (id: string) => cargoService.deliver(id),
+    mutationFn: ({ id, payload }: { id: string; payload?: DeliverCargoPayload }) =>
+      cargoService.deliver(id, payload),
     onSuccess: () => qc.invalidateQueries({ queryKey: cargoKeys.all })
   });
 }
diff --git a/apps/edr-freight-web/backoffice/src/hooks/useFacilities.ts b/apps/edr-freight-web/backoffice/src/hooks/useFacilities.ts
new file mode 100644
index 000000000..481378ba7
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/hooks/useFacilities.ts
@@ -0,0 +1,16 @@
+import { useQuery } from '@tanstack/react-query';
+
+import { facilityService } from '@/services/facility.service';
+
+export const facilityKeys = {
+  all: ['facilities'] as const,
+  list: () => ['facilities', 'list'] as const,
+  detail: (id: string) => ['facilities', 'detail', id] as const,
+};
+
+export function useFacilities() {
+  return useQuery({
+    queryKey: facilityKeys.list(),
+    queryFn: () => facilityService.list().then((r) => r.data),
+  });
+}
diff --git a/apps/edr-freight-web/backoffice/src/hooks/useStations.ts b/apps/edr-freight-web/backoffice/src/hooks/useStations.ts
new file mode 100644
index 000000000..b7ab95d0a
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/hooks/useStations.ts
@@ -0,0 +1,16 @@
+import { useQuery } from '@tanstack/react-query';
+
+import { trainSchedulingService } from '@/services/trainScheduling.service';
+import { QUERY_KEYS } from '@/constants/QUERY_KEYS';
+
+/**
+ * The 21 network stations / yards, sourced from the existing booking
+ * reference-data API. Reused as the parent "Facility / Port" for warehouses.
+ */
+export function useStations() {
+  return useQuery({
+    queryKey: QUERY_KEYS.TRAIN_SCHEDULING.stations(),
+    queryFn: () => trainSchedulingService.getStations(),
+    staleTime: 5 * 60 * 1000,
+  });
+}
diff --git a/apps/edr-freight-web/backoffice/src/hooks/useWarehouses.ts b/apps/edr-freight-web/backoffice/src/hooks/useWarehouses.ts
new file mode 100644
index 000000000..afd34d2b7
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/hooks/useWarehouses.ts
@@ -0,0 +1,410 @@
+import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
+
+import { warehouseService } from '@/services/warehouse.service';
+import type {
+  InspectionReportPayload,
+  SaveAllocationRulePayload,
+  SaveFeeRulePayload,
+  WarehouseInvoiceFilter,
+  PayInvoicePayload,
+  InventoryFilter,
+  InventoryInquiryFilter,
+  LoadInventoryPayload,
+  MoveInventoryPayload,
+  ReceiveInventoryPayload,
+  ReserveInventoryPayload,
+  SaveWarehousePayload,
+  SaveYardPayload,
+  SaveZonePayload,
+  WarehouseFilter,
+} from '@/types/warehouse';
+
+export const warehouseKeys = {
+  all: ['warehouses'] as const,
+  list: (filter?: WarehouseFilter) => ['warehouses', 'list', filter ?? {}] as const,
+  detail: (id: string) => ['warehouses', 'detail', id] as const,
+  yards: (warehouseId: string) => ['warehouses', warehouseId, 'yards'] as const,
+  zones: (yardId: string) => ['warehouse-yards', yardId, 'zones'] as const,
+  inventory: (filter?: InventoryFilter) => ['warehouse-inventory', 'list', filter ?? {}] as const,
+  inquiry: (filter: InventoryInquiryFilter) => ['warehouse-inventory', 'inquiry', filter] as const,
+};
+
+// ── Warehouses ─────────────────────────────────────────────────────────────
+
+export function useWarehouses(filter?: WarehouseFilter) {
+  return useQuery({
+    queryKey: warehouseKeys.list(filter),
+    queryFn: () => warehouseService.list(filter).then((r) => r.data),
+  });
+}
+
+export function useWarehouse(id?: string) {
+  return useQuery({
+    queryKey: warehouseKeys.detail(id ?? ''),
+    queryFn: () => warehouseService.getById(id as string).then((r) => r.data),
+    enabled: Boolean(id),
+  });
+}
+
+export function useCreateWarehouse() {
+  const qc = useQueryClient();
+  return useMutation({
+    mutationFn: (payload: SaveWarehousePayload) => warehouseService.create(payload),
+    onSuccess: () => qc.invalidateQueries({ queryKey: warehouseKeys.all }),
+  });
+}
+
+export function useUpdateWarehouse() {
+  const qc = useQueryClient();
+  return useMutation({
+    mutationFn: ({ id, payload }: { id: string; payload: Partial<SaveWarehousePayload> }) =>
+      warehouseService.update(id, payload),
+    onSuccess: (_, { id }) => {
+      qc.invalidateQueries({ queryKey: warehouseKeys.all });
+      qc.invalidateQueries({ queryKey: warehouseKeys.detail(id) });
+    },
+  });
+}
+
+// ── Yards ────────────────────────────────────────────────────────────────
+
+export function useWarehouseYards(warehouseId?: string) {
+  return useQuery({
+    queryKey: warehouseKeys.yards(warehouseId ?? ''),
+    queryFn: () => warehouseService.listYards(warehouseId as string).then((r) => r.data),
+    enabled: Boolean(warehouseId),
+  });
+}
+
+export function useCreateYard() {
+  const qc = useQueryClient();
+  return useMutation({
+    mutationFn: ({ warehouseId, payload }: { warehouseId: string; payload: SaveYardPayload }) =>
+      warehouseService.createYard(warehouseId, payload),
+    onSuccess: (_, { warehouseId }) => {
+      qc.invalidateQueries({ queryKey: warehouseKeys.yards(warehouseId) });
+      qc.invalidateQueries({ queryKey: warehouseKeys.detail(warehouseId) });
+    },
+  });
+}
+
+export function useUpdateYard() {
+  const qc = useQueryClient();
+  return useMutation({
+    mutationFn: ({ id, payload }: { id: string; payload: Partial<SaveYardPayload> }) =>
+      warehouseService.updateYard(id, payload),
+    onSuccess: () => qc.invalidateQueries({ queryKey: warehouseKeys.all }),
+  });
+}
+
+// ── Zones ──────────────────────────────────────────────────────────────────
+
+export function useWarehouseZones(yardId?: string) {
+  return useQuery({
+    queryKey: warehouseKeys.zones(yardId ?? ''),
+    queryFn: () => warehouseService.listZones(yardId as string).then((r) => r.data),
+    enabled: Boolean(yardId),
+  });
+}
+
+export function useCreateZone() {
+  const qc = useQueryClient();
+  return useMutation({
+    mutationFn: ({ yardId, payload }: { yardId: string; payload: SaveZonePayload }) =>
+      warehouseService.createZone(yardId, payload),
+    onSuccess: (_, { yardId }) => qc.invalidateQueries({ queryKey: warehouseKeys.zones(yardId) }),
+  });
+}
+
+export function useUpdateZone() {
+  const qc = useQueryClient();
+  return useMutation({
+    mutationFn: ({ id, payload }: { id: string; payload: Partial<SaveZonePayload> }) =>
+      warehouseService.updateZone(id, payload),
+    onSuccess: () => qc.invalidateQueries({ queryKey: ['warehouse-yards'] }),
+  });
+}
+
+// ── Inventory ──────────────────────────────────────────────────────────────
+
+export function useWarehouseInventory(filter?: InventoryFilter) {
+  return useQuery({
+    queryKey: warehouseKeys.inventory(filter),
+    queryFn: () => warehouseService.listInventory(filter).then((r) => r.data),
+  });
+}
+
+export function useReceiveInventory() {
+  const qc = useQueryClient();
+  return useMutation({
+    mutationFn: (payload: ReceiveInventoryPayload) => warehouseService.receiveInventory(payload),
+    onSuccess: () => {
+      qc.invalidateQueries({ queryKey: ['warehouse-inventory'] });
+      qc.invalidateQueries({ queryKey: warehouseKeys.all });
+    },
+  });
+}
+
+function useInventoryMutation<TArgs>(fn: (args: TArgs) => Promise<unknown>) {
+  const qc = useQueryClient();
+  return useMutation({
+    mutationFn: fn,
+    onSuccess: () => {
+      qc.invalidateQueries({ queryKey: ['warehouse-inventory'] });
+      qc.invalidateQueries({ queryKey: ['warehouse-loadings'] });
+      qc.invalidateQueries({ queryKey: warehouseKeys.all });
+    },
+  });
+}
+
+export const useStoreInventory = () => useInventoryMutation((id: string) => warehouseService.store(id));
+export const useReserveInventory = () =>
+  useInventoryMutation((payload: ReserveInventoryPayload) => warehouseService.reserve(payload));
+export const useMarkReadyForLoading = () =>
+  useInventoryMutation((id: string) => warehouseService.markReadyForLoading(id));
+export const useLoadInventory = () =>
+  useInventoryMutation((args: { id: string; payload: LoadInventoryPayload }) =>
+    warehouseService.load(args.id, args.payload),
+  );
+export const useDispatchInventory = () => useInventoryMutation((id: string) => warehouseService.dispatch(id));
+export const useMoveInventory = () =>
+  useInventoryMutation((args: { id: string; payload: MoveInventoryPayload }) =>
+    warehouseService.move(args.id, args.payload),
+  );
+
+// ── Loading (Batch 3) ────────────────────────────────────────────────────────
+
+export function useLoadableWagons(enabled = true) {
+  return useQuery({
+    queryKey: ['warehouse', 'loadable-wagons'],
+    queryFn: () => warehouseService.loadableWagons().then((r) => r.data),
+    enabled,
+  });
+}
+
+export function useWarehouseLoadings(params?: { bookingId?: string; wagonId?: string }) {
+  return useQuery({
+    queryKey: ['warehouse-loadings', params ?? {}],
+    queryFn: () => warehouseService.loadings(params).then((r) => r.data),
+  });
+}
+
+export function useBookingSchedule(bookingId?: string) {
+  return useQuery({
+    queryKey: ['warehouse', 'booking-schedule', bookingId ?? ''],
+    queryFn: () => warehouseService.bookingSchedule(bookingId as string).then((r) => r.data),
+    enabled: Boolean(bookingId),
+  });
+}
+
+export function useInventoryMovements(id?: string) {
+  return useQuery({
+    queryKey: ['warehouse-inventory', id, 'movements'],
+    queryFn: () => warehouseService.movements(id as string).then((r) => r.data),
+    enabled: Boolean(id),
+  });
+}
+
+export function useInventoryActivity(id?: string) {
+  return useQuery({
+    queryKey: ['warehouse-inventory', id, 'activity'],
+    queryFn: () => warehouseService.activity(id as string).then((r) => r.data),
+    enabled: Boolean(id),
+  });
+}
+
+export function useWarehouseDashboard() {
+  return useQuery({
+    queryKey: ['warehouses', 'dashboard'],
+    queryFn: () => warehouseService.dashboard().then((r) => r.data),
+  });
+}
+
+export function useInventoryInquiry(filter: InventoryInquiryFilter, enabled = true) {
+  return useQuery({
+    queryKey: warehouseKeys.inquiry(filter),
+    queryFn: () => warehouseService.inquiry(filter).then((r) => r.data),
+    enabled,
+  });
+}
+
+// ── Batch 4.5: Arrival / Unload / Inspection ────────────────────────────────
+
+export function useArrivalQueue() {
+  return useQuery({
+    queryKey: ['warehouse-inventory', 'arrival-queue'],
+    queryFn: () => warehouseService.arrivalQueue().then((r) => r.data),
+  });
+}
+
+function useArrivalInvalidation() {
+  const qc = useQueryClient();
+  return () => {
+    qc.invalidateQueries({ queryKey: ['warehouse-inventory'] });
+    qc.invalidateQueries({ queryKey: warehouseKeys.all });
+  };
+}
+
+export function useAutoUnloadArrived() {
+  const onSuccess = useArrivalInvalidation();
+  return useMutation({ mutationFn: () => warehouseService.autoUnloadArrived(), onSuccess });
+}
+
+export function useAutoLoadReady() {
+  const onSuccess = useArrivalInvalidation();
+  return useMutation({ mutationFn: () => warehouseService.autoLoadReady(), onSuccess });
+}
+
+export function useUnloadBooking() {
+  const onSuccess = useArrivalInvalidation();
+  return useMutation({
+    mutationFn: (args: { bookingId: string; payload?: Record<string, unknown> }) =>
+      warehouseService.unloadBooking(args.bookingId, args.payload),
+    onSuccess,
+  });
+}
+
+export function useInspectionReports(inventoryId?: string) {
+  return useQuery({
+    queryKey: ['warehouse-inventory', inventoryId, 'inspection-reports'],
+    queryFn: () => warehouseService.listInspectionReports(inventoryId as string).then((r) => r.data),
+    enabled: Boolean(inventoryId),
+  });
+}
+
+export function useCreateInspectionReport() {
+  const qc = useQueryClient();
+  return useMutation({
+    mutationFn: ({ inventoryId, payload }: { inventoryId: string; payload: InspectionReportPayload }) =>
+      warehouseService.createInspectionReport(inventoryId, payload).then((r) => r.data),
+    onSuccess: (_, { inventoryId }) => {
+      qc.invalidateQueries({ queryKey: ['warehouse-inventory', inventoryId, 'inspection-reports'] });
+      qc.invalidateQueries({ queryKey: ['warehouse-inventory'] });
+    },
+  });
+}
+
+export function useUploadInspectionAttachments() {
+  return useMutation({
+    mutationFn: ({ reportId, files }: { reportId: string; files: File[] }) =>
+      warehouseService.uploadInspectionAttachments(reportId, files),
+  });
+}
+
+// ── Batch 5: Allocation + Fee rules / preview ───────────────────────────────
+
+export function useAllocationRules() {
+  return useQuery({
+    queryKey: ['warehouse-allocation-rules'],
+    queryFn: () => warehouseService.listAllocationRules().then((r) => r.data),
+  });
+}
+
+export function useFeeRules() {
+  return useQuery({
+    queryKey: ['warehouse-fee-rules'],
+    queryFn: () => warehouseService.listFeeRules().then((r) => r.data),
+  });
+}
+
+function useRuleMutation<TArgs>(fn: (args: TArgs) => Promise<unknown>, keys: string[]) {
+  const qc = useQueryClient();
+  return useMutation({
+    mutationFn: fn,
+    onSuccess: () => keys.forEach((k) => qc.invalidateQueries({ queryKey: [k] })),
+  });
+}
+
+export const useCreateAllocationRule = () =>
+  useRuleMutation(
+    (payload: SaveAllocationRulePayload) => warehouseService.createAllocationRule(payload),
+    ['warehouse-allocation-rules'],
+  );
+export const useUpdateAllocationRule = () =>
+  useRuleMutation(
+    (args: { id: string; payload: Partial<SaveAllocationRulePayload> }) =>
+      warehouseService.updateAllocationRule(args.id, args.payload),
+    ['warehouse-allocation-rules'],
+  );
+export const useDeleteAllocationRule = () =>
+  useRuleMutation((id: string) => warehouseService.deleteAllocationRule(id), ['warehouse-allocation-rules']);
+
+export const useCreateFeeRule = () =>
+  useRuleMutation((payload: SaveFeeRulePayload) => warehouseService.createFeeRule(payload), ['warehouse-fee-rules']);
+export const useUpdateFeeRule = () =>
+  useRuleMutation(
+    (args: { id: string; payload: Partial<SaveFeeRulePayload> }) =>
+      warehouseService.updateFeeRule(args.id, args.payload),
+    ['warehouse-fee-rules'],
+  );
+export const useDeleteFeeRule = () =>
+  useRuleMutation((id: string) => warehouseService.deleteFeeRule(id), ['warehouse-fee-rules']);
+
+export function useFeePreview(inventoryId?: string) {
+  return useQuery({
+    queryKey: ['warehouse-inventory', inventoryId, 'fee-preview'],
+    queryFn: () => warehouseService.feePreview(inventoryId as string).then((r) => r.data),
+    enabled: Boolean(inventoryId),
+  });
+}
+
+// ── Batch 6: Warehouse fee invoices ─────────────────────────────────────────
+
+export function useWarehouseInvoices(filter?: WarehouseInvoiceFilter) {
+  return useQuery({
+    queryKey: ['warehouse-fee-invoices', filter ?? {}],
+    queryFn: () => warehouseService.listInvoices(filter).then((r) => r.data),
+  });
+}
+
+export function useWarehouseInvoice(id?: string) {
+  return useQuery({
+    queryKey: ['warehouse-fee-invoices', 'detail', id],
+    queryFn: () => warehouseService.getInvoice(id as string).then((r) => r.data),
+    enabled: Boolean(id),
+  });
+}
+
+export function useInvoicesForInventory(inventoryId?: string) {
+  return useQuery({
+    queryKey: ['warehouse-inventory', inventoryId, 'fee-invoices'],
+    queryFn: () => warehouseService.invoicesForInventory(inventoryId as string).then((r) => r.data),
+    enabled: Boolean(inventoryId),
+  });
+}
+
+function useInvoiceInvalidation() {
+  const qc = useQueryClient();
+  return () => {
+    qc.invalidateQueries({ queryKey: ['warehouse-fee-invoices'] });
+    qc.invalidateQueries({ queryKey: ['warehouse-inventory'] });
+  };
+}
+
+export function useGenerateInvoice() {
+  const onSuccess = useInvoiceInvalidation();
+  return useMutation({
+    mutationFn: ({ inventoryId, confirmZero }: { inventoryId: string; confirmZero?: boolean }) =>
+      warehouseService.generateInvoice(inventoryId, confirmZero).then((r) => r.data),
+    onSuccess,
+  });
+}
+
+export function useCancelInvoice() {
+  const onSuccess = useInvoiceInvalidation();
+  return useMutation({ mutationFn: (id: string) => warehouseService.cancelInvoice(id), onSuccess });
+}
+
+export function usePayInvoice() {
+  const onSuccess = useInvoiceInvalidation();
+  return useMutation({
+    mutationFn: ({ id, payload }: { id: string; payload: PayInvoicePayload }) =>
+      warehouseService.payInvoice(id, payload),
+    onSuccess,
+  });
+}
+
+export function useGateClearance() {
+  const onSuccess = useInvoiceInvalidation();
+  return useMutation({ mutationFn: (inventoryId: string) => warehouseService.gateClearance(inventoryId), onSuccess });
+}
diff --git a/apps/edr-freight-web/backoffice/src/main.tsx b/apps/edr-freight-web/backoffice/src/main.tsx
index 99b60895a..3af3f0758 100644
--- a/apps/edr-freight-web/backoffice/src/main.tsx
+++ b/apps/edr-freight-web/backoffice/src/main.tsx
@@ -10,6 +10,7 @@ import "@edr/ui-common/theme.css";
 import { Toaster } from "react-hot-toast";
 
 import App from "./App";
+import { ErrorBoundary } from "./components/ErrorBoundary";
 import { AuthProvider } from "./auth/AuthProvider";
 import { queryClient } from "./lib/queryClient";
 import { freightMantineTheme } from "./theme/freight-brand";
@@ -48,7 +49,9 @@ createRoot(rootElement).render(
       <StrictMode>
         <BrowserRouter>
           <AuthProvider>
-            <App />
+            <ErrorBoundary>
+              <App />
+            </ErrorBoundary>
             <Toaster position="top-right" />
           </AuthProvider>
         </BrowserRouter>
diff --git a/apps/edr-freight-web/backoffice/src/pages/bookings/BookingRequestDetailPage.tsx b/apps/edr-freight-web/backoffice/src/pages/bookings/BookingRequestDetailPage.tsx
index 73de7ee8f..e1dedc304 100644
--- a/apps/edr-freight-web/backoffice/src/pages/bookings/BookingRequestDetailPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/bookings/BookingRequestDetailPage.tsx
@@ -29,6 +29,7 @@ import {
   BookingDocumentsCard,
   type BookingFileView,
 } from "@/components/bookings/detail";
+import { WarehouseInfoCard } from "@/components/warehouses";
 import { getStatusMeta } from "@/features/bookings/booking-status.config";
 import { toBookingListRow } from "@/features/bookings/mapBookingListRow";
 import { downloadBookingFile } from "@/services/files.service";
@@ -184,6 +185,7 @@ export default function BookingRequestDetailPage() {
                 <Stack gap="lg">
                   <BookingCompanyCard booking={booking} />
                   <BookingPricingSummary booking={booking} />
+                  <WarehouseInfoCard bookingId={booking.id} bookingReference={booking.reference} />
                   <BookingActionsToolbar booking={booking} mutations={mutations} />
                   {showContractButton && (
                     <Button
diff --git a/apps/edr-freight-web/backoffice/src/pages/fleet/FleetCrudPages.tsx b/apps/edr-freight-web/backoffice/src/pages/fleet/FleetCrudPages.tsx
index 6d41abba0..48ab5e429 100644
--- a/apps/edr-freight-web/backoffice/src/pages/fleet/FleetCrudPages.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/fleet/FleetCrudPages.tsx
@@ -1,5 +1,24 @@
 import { FormEvent, ReactNode, useMemo, useState } from 'react';
 import { Edit, Eye, Plus, Search, Trash2 } from 'lucide-react';
+import {
+  ActionIcon,
+  Badge as MantineBadge,
+  Box,
+  Button as MantineButton,
+  Group,
+  Modal,
+  NumberInput,
+  Pagination,
+  Paper,
+  ScrollArea,
+  Select as MantineSelect,
+  SimpleGrid,
+  Stack,
+  Table as MantineTable,
+  Text,
+  TextInput,
+  Title,
+} from '@mantine/core';
 
 import { Badge } from '@/components/ui/badge';
 import { Button } from '@/components/ui/button';
@@ -31,6 +50,7 @@ import {
   useUpdateContainer,
 } from '@/hooks/useContainers';
 import { useCreateTrain, useDeleteTrain, useTrains, useUpdateTrain } from '@/hooks/useTrains';
+import { useRouteYards } from '@/hooks/useRoutes';
 import { useCreateWagon, useDeleteWagon, useUpdateWagon, useWagons } from '@/hooks/useWagons';
 import {
   useCreateLocomotive,
@@ -39,6 +59,7 @@ import {
   useUpdateLocomotive,
 } from '@/hooks/useLocomotives';
 import type { Cargo } from '@/services/cargoService';
+import { DeliverCargoDialog } from '@/components/cargoes/DeliverCargoDialog';
 import type { Container } from '@/services/containerService';
 import type { Locomotive } from '@/services/locomotives.service';
 import type { Train } from '@/services/trains.service';
@@ -84,6 +105,8 @@ type FleetCrudPageProps<T extends { id: string }> = {
   removeConfirmMessage?: string;
   removeSuccessMessage?: string;
   hideViewAction?: boolean;
+  /** Optional custom actions rendered before the view/edit/delete buttons in each row. */
+  rowActions?: (item: T) => React.ReactNode;
 };
 
 const normalizePayload = (values: Record<string, FormValue>) =>
@@ -165,6 +188,7 @@ function FleetCrudPage<T extends { id: string }>({
   removeConfirmMessage,
   removeSuccessMessage,
   hideViewAction = false,
+  rowActions,
 }: FleetCrudPageProps<T>) {
   const [search, setSearch] = useState('');
   const [page, setPage] = useState(1);
@@ -333,6 +357,7 @@ function FleetCrudPage<T extends { id: string }>({
                 ))}
                 <TableCell>
                   <div className="flex justify-end gap-1">
+                    {rowActions?.(item)}
                     {!hideViewAction ? (
                       <Button variant="ghost" size="icon" onClick={() => setViewing(item)} title="View">
                         <Eye className="size-4" />
@@ -522,74 +547,366 @@ export function TrainMasterDataPage() {
 
 export function WagonTypesCrudPage() {
   const query = useWagonTypes();
+  const create = useCreateWagonType();
+  const update = useUpdateWagonType();
+  const remove = useDeleteWagonType();
+  const { toast } = useToast();
+  const [search, setSearch] = useState('');
+  const [page, setPage] = useState(1);
+  const [sortKey, setSortKey] = useState<keyof WagonType>('code');
+  const [sortDirection, setSortDirection] = useState<'asc' | 'desc'>('asc');
+  const [formOpen, setFormOpen] = useState(false);
+  const [editing, setEditing] = useState<WagonType | null>(null);
+  const [viewing, setViewing] = useState<WagonType | null>(null);
+  const [form, setForm] = useState<Record<string, FormValue>>({
+    code: '',
+    name: '',
+    capacityTons: 0,
+    lengthMeters: 0,
+    maxWagonsPerTrain: '',
+    supportedLoadTypes: '',
+    isActive: true,
+  });
+  const [fieldErrors, setFieldErrors] = useState<Record<string, string>>({});
+
+  const pageSize = 10;
+  const filtered = useMemo(() => {
+    const queryText = search.trim().toLowerCase();
+    const rows = query.data ?? [];
+    if (!queryText) return rows;
+    return rows.filter((type) =>
+      [type.code, type.name, type.supportedLoadTypes?.join(' '), type.isActive ? 'active' : 'inactive']
+        .join(' ')
+        .toLowerCase()
+        .includes(queryText),
+    );
+  }, [query.data, search]);
+
+  const sorted = useMemo(() => {
+    return [...filtered].sort((left, right) => {
+      const result = String(left[sortKey] ?? '').localeCompare(String(right[sortKey] ?? ''), undefined, {
+        numeric: true,
+      });
+      return sortDirection === 'asc' ? result : -result;
+    });
+  }, [filtered, sortDirection, sortKey]);
+
+  const pageCount = Math.max(1, Math.ceil(sorted.length / pageSize));
+  const paged = sorted.slice((page - 1) * pageSize, page * pageSize);
+  const isSaving = create.isPending || update.isPending;
+
+  const toggleSort = (key: keyof WagonType) => {
+    setPage(1);
+    if (sortKey === key) {
+      setSortDirection((current) => (current === 'asc' ? 'desc' : 'asc'));
+      return;
+    }
+    setSortKey(key);
+    setSortDirection('asc');
+  };
+
+  const closeForm = () => {
+    setFormOpen(false);
+    setEditing(null);
+    setFieldErrors({});
+    setForm({
+      code: '',
+      name: '',
+      capacityTons: 0,
+      lengthMeters: 0,
+      maxWagonsPerTrain: '',
+      supportedLoadTypes: '',
+      isActive: true,
+    });
+  };
+
+  const openEdit = (type: WagonType) => {
+    setEditing(type);
+    setFieldErrors({});
+    setForm({
+      code: type.code ?? '',
+      name: type.name ?? '',
+      capacityTons: type.capacityTons ?? 0,
+      lengthMeters: type.lengthMeters ?? 0,
+      maxWagonsPerTrain: type.maxWagonsPerTrain ?? '',
+      supportedLoadTypes: type.supportedLoadTypes?.join(', ') ?? '',
+      isActive: type.isActive,
+    });
+    setFormOpen(true);
+  };
+
+  const validateWagonType = () => {
+    const errors: Record<string, string> = {};
+    if (!String(form.code ?? '').trim()) errors.code = 'Code is required';
+    if (!String(form.name ?? '').trim()) errors.name = 'Name is required';
+    if (!Number.isFinite(Number(form.capacityTons))) errors.capacityTons = 'Capacity must be a valid number';
+    if (!Number.isFinite(Number(form.lengthMeters))) errors.lengthMeters = 'Length must be a valid number';
+    return errors;
+  };
+
+  const handleSubmit = async (event: FormEvent) => {
+    event.preventDefault();
+    const errors = validateWagonType();
+    if (Object.keys(errors).length > 0) {
+      setFieldErrors(errors);
+      toast({ title: 'Save failed', description: Object.values(errors)[0], variant: 'destructive' });
+      return;
+    }
+
+    const payload = normalizePayload(form);
+    setFieldErrors({});
+
+    try {
+      if (editing) {
+        await update.mutateAsync({ id: editing.id, data: payload });
+        toast({ title: 'Wagon Type updated' });
+      } else {
+        await create.mutateAsync(payload);
+        toast({ title: 'Wagon Type created' });
+      }
+      closeForm();
+    } catch (error) {
+      const { message, fieldErrors: backendFieldErrors } = extractBackendErrors(error);
+      setFieldErrors(backendFieldErrors);
+      toast({ title: 'Save failed', description: message, variant: 'destructive' });
+    }
+  };
+
+  const handleDelete = async (type: WagonType) => {
+    if (!window.confirm('Delete this wagon type?')) return;
+    try {
+      await remove.mutateAsync(type.id);
+      toast({ title: 'Wagon Type deleted' });
+    } catch {
+      toast({ title: 'Delete failed', description: 'This wagon type may still be referenced.', variant: 'destructive' });
+    }
+  };
+
+  const sortLabel = (key: keyof WagonType) => (sortKey === key ? (sortDirection === 'asc' ? ' ASC' : ' DESC') : '');
 
   return (
-    <FleetCrudPage<WagonType>
-      title="Wagon Types"
-      description="Manage wagon type capacities and load compatibility used by wagon master data."
-      addLabel="Add Wagon Type"
-      data={query.data}
-      isLoading={query.isLoading}
-      create={useCreateWagonType()}
-      update={useUpdateWagonType()}
-      remove={useDeleteWagonType()}
-      searchText={(type) =>
-        [type.code, type.name, type.supportedLoadTypes?.join(' '), String(type.isActive)].join(' ')
-      }
-      columns={[
-        { key: 'code', label: 'Code' },
-        { key: 'name', label: 'Name' },
-        { key: 'capacityTons', label: 'Capacity (tons)' },
-        { key: 'lengthMeters', label: 'Length (m)' },
-        {
-          key: 'supportedLoadTypes',
-          label: 'Load types',
-          render: (type) => type.supportedLoadTypes?.join(', ') || '-',
-        },
-        { key: 'isActive', label: 'Status', render: (type) => activeBadge(type.isActive) },
-      ]}
-      fields={[
-        { key: 'code', label: 'Code', required: true },
-        { key: 'name', label: 'Name', required: true },
-        { key: 'capacityTons', label: 'Capacity (tons)', type: 'number', required: true },
-        { key: 'lengthMeters', label: 'Length (meters)', type: 'number', required: true },
-        { key: 'maxWagonsPerTrain', label: 'Max wagons per train', type: 'number' },
-        {
-          key: 'supportedLoadTypes',
-          label: 'Supported load types',
-          placeholder: 'container, break-bulk',
-        },
-        {
-          key: 'isActive',
-          label: 'Status',
-          type: 'select',
-          options: [
-            { value: 'true', label: 'Active' },
-            { value: 'false', label: 'Inactive' },
-          ],
-          onValueChange: (value) => ({ isActive: value === 'true' }),
-        },
-      ]}
-      emptyValues={{
-        code: '',
-        name: '',
-        capacityTons: 0,
-        lengthMeters: 0,
-        maxWagonsPerTrain: '',
-        supportedLoadTypes: '',
-        isActive: true,
-      }}
-    />
+    <Box p="lg">
+      <Stack gap="md">
+        <Group justify="space-between" align="flex-end">
+          <Box>
+            <Title order={2}>Wagon Types</Title>
+            <Text size="sm" c="dimmed" mt={4}>
+              Manage wagon type capacities and load compatibility used by wagon master data.
+            </Text>
+          </Box>
+          <MantineButton
+            leftSection={<Plus size={16} />}
+            onClick={() => {
+              closeForm();
+              setFormOpen(true);
+            }}
+          >
+            Add Wagon Type
+          </MantineButton>
+        </Group>
+
+        <TextInput
+          maw={420}
+          leftSection={<Search size={16} />}
+          placeholder="Search wagon types"
+          value={search}
+          onChange={(event) => {
+            setSearch(event.currentTarget.value);
+            setPage(1);
+          }}
+        />
+
+        <Paper withBorder radius="md">
+          <ScrollArea>
+            <MantineTable striped highlightOnHover verticalSpacing="sm" miw={900}>
+              <MantineTable.Thead>
+                <MantineTable.Tr>
+                  <MantineTable.Th>
+                    <MantineButton variant="subtle" size="compact-sm" onClick={() => toggleSort('code')}>
+                      Code{sortLabel('code')}
+                    </MantineButton>
+                  </MantineTable.Th>
+                  <MantineTable.Th>
+                    <MantineButton variant="subtle" size="compact-sm" onClick={() => toggleSort('name')}>
+                      Name{sortLabel('name')}
+                    </MantineButton>
+                  </MantineTable.Th>
+                  <MantineTable.Th>
+                    <MantineButton variant="subtle" size="compact-sm" onClick={() => toggleSort('capacityTons')}>
+                      Capacity (tons){sortLabel('capacityTons')}
+                    </MantineButton>
+                  </MantineTable.Th>
+                  <MantineTable.Th>Length (m)</MantineTable.Th>
+                  <MantineTable.Th>Load types</MantineTable.Th>
+                  <MantineTable.Th>Status</MantineTable.Th>
+                  <MantineTable.Th ta="right">Actions</MantineTable.Th>
+                </MantineTable.Tr>
+              </MantineTable.Thead>
+              <MantineTable.Tbody>
+                {paged.map((type) => (
+                  <MantineTable.Tr key={type.id}>
+                    <MantineTable.Td fw={600}>{type.code}</MantineTable.Td>
+                    <MantineTable.Td>{type.name}</MantineTable.Td>
+                    <MantineTable.Td>{type.capacityTons}</MantineTable.Td>
+                    <MantineTable.Td>{type.lengthMeters}</MantineTable.Td>
+                    <MantineTable.Td>{type.supportedLoadTypes?.join(', ') || '-'}</MantineTable.Td>
+                    <MantineTable.Td>
+                      <MantineBadge color={type.isActive === false ? 'gray' : 'green'} variant="light">
+                        {type.isActive === false ? 'Inactive' : 'Active'}
+                      </MantineBadge>
+                    </MantineTable.Td>
+                    <MantineTable.Td>
+                      <Group gap="xs" justify="flex-end">
+                        <ActionIcon variant="subtle" aria-label="View wagon type" onClick={() => setViewing(type)}>
+                          <Eye size={16} />
+                        </ActionIcon>
+                        <ActionIcon variant="subtle" aria-label="Edit wagon type" onClick={() => openEdit(type)}>
+                          <Edit size={16} />
+                        </ActionIcon>
+                        <ActionIcon
+                          color="red"
+                          variant="subtle"
+                          aria-label="Delete wagon type"
+                          onClick={() => handleDelete(type)}
+                        >
+                          <Trash2 size={16} />
+                        </ActionIcon>
+                      </Group>
+                    </MantineTable.Td>
+                  </MantineTable.Tr>
+                ))}
+                {!query.isLoading && filtered.length === 0 ? (
+                  <MantineTable.Tr>
+                    <MantineTable.Td colSpan={7}>
+                      <Text ta="center" c="dimmed" py="xl">
+                        No wagon types found.
+                      </Text>
+                    </MantineTable.Td>
+                  </MantineTable.Tr>
+                ) : null}
+                {query.isLoading ? (
+                  <MantineTable.Tr>
+                    <MantineTable.Td colSpan={7}>
+                      <Text ta="center" c="dimmed" py="xl">
+                        Loading...
+                      </Text>
+                    </MantineTable.Td>
+                  </MantineTable.Tr>
+                ) : null}
+              </MantineTable.Tbody>
+            </MantineTable>
+          </ScrollArea>
+        </Paper>
+
+        <Group justify="space-between">
+          <Text size="sm" c="dimmed">
+            Showing {sorted.length === 0 ? 0 : (page - 1) * pageSize + 1}-{Math.min(page * pageSize, sorted.length)} of{' '}
+            {sorted.length}
+          </Text>
+          <Pagination total={pageCount} value={page} onChange={setPage} size="sm" />
+        </Group>
+      </Stack>
+
+      <Modal opened={formOpen} onClose={closeForm} title={editing ? 'Edit Wagon Type' : 'Add Wagon Type'} centered>
+        <form onSubmit={handleSubmit}>
+          <Stack>
+            <SimpleGrid cols={{ base: 1, sm: 2 }}>
+              <TextInput
+                label="Code"
+                required
+                value={String(form.code ?? '')}
+                error={fieldErrors.code}
+                onChange={(event) => setForm((current) => ({ ...current, code: event.currentTarget.value }))}
+              />
+              <TextInput
+                label="Name"
+                required
+                value={String(form.name ?? '')}
+                error={fieldErrors.name}
+                onChange={(event) => setForm((current) => ({ ...current, name: event.currentTarget.value }))}
+              />
+              <NumberInput
+                label="Capacity (tons)"
+                required
+                min={0}
+                value={Number(form.capacityTons ?? 0)}
+                error={fieldErrors.capacityTons}
+                onChange={(value) => setForm((current) => ({ ...current, capacityTons: value }))}
+              />
+              <NumberInput
+                label="Length (meters)"
+                required
+                min={0}
+                value={Number(form.lengthMeters ?? 0)}
+                error={fieldErrors.lengthMeters}
+                onChange={(value) => setForm((current) => ({ ...current, lengthMeters: value }))}
+              />
+              <NumberInput
+                label="Max wagons per train"
+                min={0}
+                value={form.maxWagonsPerTrain === '' ? '' : Number(form.maxWagonsPerTrain)}
+                onChange={(value) => setForm((current) => ({ ...current, maxWagonsPerTrain: value }))}
+              />
+              <MantineSelect
+                label="Status"
+                value={form.isActive ? 'true' : 'false'}
+                data={[
+                  { value: 'true', label: 'Active' },
+                  { value: 'false', label: 'Inactive' },
+                ]}
+                onChange={(value) => setForm((current) => ({ ...current, isActive: value !== 'false' }))}
+              />
+            </SimpleGrid>
+            <TextInput
+              label="Supported load types"
+              placeholder="container, break-bulk"
+              value={Array.isArray(form.supportedLoadTypes) ? form.supportedLoadTypes.join(', ') : String(form.supportedLoadTypes ?? '')}
+              onChange={(event) => setForm((current) => ({ ...current, supportedLoadTypes: event.currentTarget.value }))}
+            />
+            <Group justify="flex-end">
+              <MantineButton variant="default" type="button" onClick={closeForm}>
+                Cancel
+              </MantineButton>
+              <MantineButton type="submit" loading={isSaving}>
+                Save
+              </MantineButton>
+            </Group>
+          </Stack>
+        </form>
+      </Modal>
+
+      <Modal opened={Boolean(viewing)} onClose={() => setViewing(null)} title="Wagon Type details" centered>
+        <Stack gap="xs">
+          {viewing
+            ? Object.entries(viewing).map(([key, value]) => (
+                <Group key={key} justify="space-between" align="flex-start" wrap="nowrap">
+                  <Text size="sm" fw={600}>
+                    {key}
+                  </Text>
+                  <Text size="sm" c="dimmed" ta="right">
+                    {Array.isArray(value) ? value.join(', ') : value == null ? '-' : String(value)}
+                  </Text>
+                </Group>
+              ))
+            : null}
+        </Stack>
+      </Modal>
+    </Box>
   );
 }
 
 export function WagonsCrudPage() {
   const query = useWagons();
   const { data: wagonTypes = [] } = useWagonTypes();
+  const { data: yards = [] } = useRouteYards();
   const wagonTypeOptions = wagonTypes.map((type: any) => ({
     value: type.id,
     label: `${type.code} - ${type.name}`,
   }));
+  const yardOptions = yards.map((yard: any) => ({
+    value: yard.id,
+    label: `${yard.label ?? yard.code} (${yard.country ?? '-'})`,
+  }));
   return (
     <FleetCrudPage<Wagon>
       title="Wagons"
@@ -600,10 +917,26 @@ export function WagonsCrudPage() {
       create={useCreateWagon()}
       update={useUpdateWagon()}
       remove={useDeleteWagon()}
-      searchText={(wagon) => [wagon.wagonNumber, wagon.wagonTypeId, wagon.trainId, wagon.status].join(' ')}
+      searchText={(wagon) => [
+        wagon.wagonNumber,
+        wagon.wagonTypeId,
+        wagon.trainId,
+        wagon.status,
+        wagon.currentLocationYard?.label,
+        wagon.currentLocationYard?.code,
+        wagon.currentLocationYard?.country,
+      ].join(' ')}
       columns={[
         { key: 'wagonNumber', label: 'Number' },
         { key: 'wagonTypeId', label: 'Type', render: (wagon) => optionLabel(wagonTypeOptions, wagon.wagonTypeId) },
+        {
+          key: 'currentLocationYardId',
+          label: 'Location',
+          render: (wagon) =>
+            wagon.currentLocationYard
+              ? `${wagon.currentLocationYard.label ?? wagon.currentLocationYard.code} (${wagon.currentLocationYard.country ?? '-'})`
+              : '-',
+        },
         { key: 'maxPayloadWeight', label: 'Max payload' },
         { key: 'status', label: 'Status', render: (wagon) => statusBadge(wagon.status) },
       ]}
@@ -621,12 +954,31 @@ export function WagonsCrudPage() {
             return { maxPayloadWeight: Number(selectedType.capacityTons) };
           },
         },
+        {
+          key: 'currentLocationYardId',
+          label: 'Wagon location',
+          type: 'select',
+          required: true,
+          options: yardOptions,
+        },
         { key: 'tareWeight', label: 'Tare weight', type: 'number', required: true },
         { key: 'maxPayloadWeight', label: 'Max payload weight', type: 'number', required: true },
-        { key: 'status', label: 'Status' },
+        {
+          key: 'status',
+          label: 'Status',
+          type: 'select',
+          options: [
+            { value: 'AVAILABLE', label: 'Available' },
+            { value: 'IMPORT_READY', label: 'Import ready' },
+            { value: 'EXPORT_READY', label: 'Export ready' },
+            { value: 'ASSIGNED', label: 'Assigned' },
+            { value: 'MAINTENANCE', label: 'Maintenance' },
+            { value: 'RETIRED', label: 'Retired' },
+          ],
+        },
         { key: 'notes', label: 'Notes' },
       ]}
-      emptyValues={{ wagonNumber: '', wagonTypeId: '', tareWeight: 0, maxPayloadWeight: 0, status: 'AVAILABLE', notes: '' }}
+      emptyValues={{ wagonNumber: '', wagonTypeId: '', currentLocationYardId: '', tareWeight: 0, maxPayloadWeight: 0, status: 'AVAILABLE', notes: '' }}
     />
   );
 }
@@ -718,7 +1070,18 @@ export function CargoesCrudPage() {
         { key: 'quantity', label: 'Quantity' },
         { key: 'weight', label: 'Weight' },
         { key: 'status', label: 'Status', render: (cargo) => statusBadge(cargo.status) },
+        {
+          key: 'receiverName',
+          label: 'Proof of delivery',
+          render: (cargo) =>
+            cargo.status === 'DELIVERED' && cargo.receiverName
+              ? `${cargo.receiverName}${cargo.deliveredAt ? ` · ${new Date(cargo.deliveredAt).toLocaleDateString()}` : ''}`
+              : '—',
+        },
       ]}
+      rowActions={(cargo) =>
+        cargo.status === 'LOADED' ? <DeliverCargoDialog cargoId={cargo.id} /> : null
+      }
       fields={[
         { key: 'cargoReference', label: 'Cargo reference', required: true },
         { key: 'shipmentId', label: 'Shipment ID', required: true },
diff --git a/apps/edr-freight-web/backoffice/src/pages/warehouses/ArrivalQueuePage.tsx b/apps/edr-freight-web/backoffice/src/pages/warehouses/ArrivalQueuePage.tsx
new file mode 100644
index 000000000..c05f2c626
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/pages/warehouses/ArrivalQueuePage.tsx
@@ -0,0 +1,200 @@
+import { useState } from 'react';
+import { useNavigate } from 'react-router-dom';
+import {
+  Badge,
+  Button,
+  Card,
+  Container,
+  Group,
+  Loader,
+  Stack,
+  Table,
+  Text,
+} from '@mantine/core';
+import { ClipboardList, Eye, PackageOpen, Truck } from 'lucide-react';
+
+import Breadcrumbs from '@/components/ui/Breadcrumbs';
+import {
+  InspectionReportModal,
+  VisualEmptyState,
+  WarehouseHero,
+  formatDate,
+} from '@/components/warehouses';
+import { useArrivalQueue, useAutoUnloadArrived, useUnloadBooking } from '@/hooks/useWarehouses';
+import { useToast } from '@/hooks/use-toast';
+import type { ArrivalQueueItem } from '@/types/warehouse';
+
+function inspectionBadge(status: string | null) {
+  if (!status) return <Badge variant="light" color="gray" size="sm">Not inspected</Badge>;
+  const color = status === 'PASSED' ? 'green' : status === 'FAILED' ? 'red' : 'orange';
+  return <Badge variant="light" color={color} size="sm">{status.replace(/_/g, ' ')}</Badge>;
+}
+
+/** Batch 4.5 — arrived bookings awaiting unload / inspection. */
+export default function ArrivalQueuePage() {
+  const navigate = useNavigate();
+  const { toast } = useToast();
+  const { data, isLoading } = useArrivalQueue();
+  const autoUnload = useAutoUnloadArrived();
+  const unloadOne = useUnloadBooking();
+  const [inspectInventoryId, setInspectInventoryId] = useState<string | null>(null);
+
+  const items = data ?? [];
+
+  const handleAutoUnload = async () => {
+    try {
+      const res = await autoUnload.mutateAsync();
+      const r = res.data;
+      toast({
+        title: 'Auto-unload complete',
+        description: `Processed ${r.processedCount}, skipped ${r.skippedCount}, failed ${r.failedCount}.`,
+      });
+    } catch {
+      toast({ variant: 'destructive', title: 'Auto-unload failed' });
+    }
+  };
+
+  const handleUnloadOne = async (item: ArrivalQueueItem) => {
+    try {
+      await unloadOne.mutateAsync({ bookingId: item.bookingId });
+      toast({ title: 'Booking unloaded', description: `${item.bookingReference} stored as RECEIVED.` });
+    } catch {
+      toast({ variant: 'destructive', title: 'Unload failed' });
+    }
+  };
+
+  return (
+    <Container size="xxl" py="lg">
+      <Breadcrumbs items={[{ label: 'Arrival queue' }]} />
+
+      <Stack gap="lg" mt="sm">
+        <WarehouseHero
+          variant="container"
+          secondaryVariant="warehouse"
+          title="Arrival / Unloading Queue"
+          subtitle="Arrived bookings ready to unload, store and inspect."
+        />
+
+        <Card withBorder radius="md" padding="lg">
+          <Group justify="space-between" mb="md">
+            <Text fw={600}>{items.length} arrived booking(s)</Text>
+            <Button
+              color="orange"
+              leftSection={<PackageOpen size={16} />}
+              loading={autoUnload.isPending}
+              onClick={handleAutoUnload}
+            >
+              Auto Unload Arrived Bookings
+            </Button>
+          </Group>
+
+          {isLoading ? (
+            <Group justify="center" py="xl">
+              <Loader />
+            </Group>
+          ) : items.length === 0 ? (
+            <VisualEmptyState
+              variant="container"
+              title="No arrived bookings"
+              description="Bookings in transit that arrive appear here for unloading and inspection."
+            />
+          ) : (
+            <Table.ScrollContainer minWidth={1100}>
+              <Table verticalSpacing="sm" highlightOnHover striped>
+                <Table.Thead>
+                  <Table.Tr>
+                    <Table.Th>Booking</Table.Th>
+                    <Table.Th>Customer</Table.Th>
+                    <Table.Th>Cargo / Container</Table.Th>
+                    <Table.Th>Arrival</Table.Th>
+                    <Table.Th>Facility</Table.Th>
+                    <Table.Th>Warehouse</Table.Th>
+                    <Table.Th>Yard</Table.Th>
+                    <Table.Th>Zone</Table.Th>
+                    <Table.Th>Status</Table.Th>
+                    <Table.Th>Inspection</Table.Th>
+                    <Table.Th ta="right">Actions</Table.Th>
+                  </Table.Tr>
+                </Table.Thead>
+                <Table.Tbody>
+                  {items.map((item) => (
+                    <Table.Tr key={item.bookingId}>
+                      <Table.Td>
+                        <Text fw={600} size="sm">{item.bookingReference}</Text>
+                      </Table.Td>
+                      <Table.Td>{item.customer ?? '—'}</Table.Td>
+                      <Table.Td>{item.container ?? item.cargo ?? '—'}</Table.Td>
+                      <Table.Td>
+                        <Text size="xs">{formatDate(item.arrivalDate)}</Text>
+                      </Table.Td>
+                      <Table.Td>{item.facility ?? '—'}</Table.Td>
+                      <Table.Td>{item.warehouse ?? '—'}</Table.Td>
+                      <Table.Td>{item.yard ?? '—'}</Table.Td>
+                      <Table.Td>{item.zone ?? '—'}</Table.Td>
+                      <Table.Td>
+                        {item.unloaded ? (
+                          <Badge variant="light" color="green" size="sm">
+                            {item.currentStatus ?? 'RECEIVED'}
+                          </Badge>
+                        ) : (
+                          <Badge variant="light" color="orange" size="sm">
+                            Not unloaded
+                          </Badge>
+                        )}
+                      </Table.Td>
+                      <Table.Td>{inspectionBadge(item.inspectionStatus)}</Table.Td>
+                      <Table.Td>
+                        <Group gap="xs" justify="flex-end" wrap="nowrap">
+                          {!item.unloaded && (
+                            <Button
+                              size="compact-xs"
+                              variant="light"
+                              color="orange"
+                              leftSection={<Truck size={14} />}
+                              loading={unloadOne.isPending}
+                              onClick={() => handleUnloadOne(item)}
+                            >
+                              Unload
+                            </Button>
+                          )}
+                          {item.inventoryId && (
+                            <Button
+                              size="compact-xs"
+                              variant="light"
+                              color="green"
+                              leftSection={<ClipboardList size={14} />}
+                              onClick={() => setInspectInventoryId(item.inventoryId)}
+                            >
+                              Inspect
+                            </Button>
+                          )}
+                          {item.inventoryId && (
+                            <Button
+                              size="compact-xs"
+                              variant="subtle"
+                              color="gray"
+                              leftSection={<Eye size={14} />}
+                              onClick={() => navigate('/dashboard/warehouse-inventory')}
+                            >
+                              Inventory
+                            </Button>
+                          )}
+                        </Group>
+                      </Table.Td>
+                    </Table.Tr>
+                  ))}
+                </Table.Tbody>
+              </Table>
+            </Table.ScrollContainer>
+          )}
+        </Card>
+      </Stack>
+
+      <InspectionReportModal
+        opened={Boolean(inspectInventoryId)}
+        onClose={() => setInspectInventoryId(null)}
+        inventoryId={inspectInventoryId}
+      />
+    </Container>
+  );
+}
diff --git a/apps/edr-freight-web/backoffice/src/pages/warehouses/DispatchQueuePage.tsx b/apps/edr-freight-web/backoffice/src/pages/warehouses/DispatchQueuePage.tsx
new file mode 100644
index 000000000..58e630fbf
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/pages/warehouses/DispatchQueuePage.tsx
@@ -0,0 +1,38 @@
+import { Card, Container, Stack } from '@mantine/core';
+
+import Breadcrumbs from '@/components/ui/Breadcrumbs';
+import { InventoryWorkbench, VisualEmptyState, WarehouseHero } from '@/components/warehouses';
+import { useWarehouseInventory } from '@/hooks/useWarehouses';
+
+/** Items that are LOADED and awaiting dispatch (train departure). */
+export default function DispatchQueuePage() {
+  const { data, isLoading } = useWarehouseInventory({ status: 'LOADED' });
+  const items = data ?? [];
+
+  return (
+    <Container size="xxl" py="lg">
+      <Breadcrumbs items={[{ label: 'Dispatch queue' }]} />
+
+      <Stack gap="lg" mt="sm">
+        <WarehouseHero
+          variant="train"
+          secondaryVariant="route"
+          title="Dispatch Queue"
+          subtitle="Loaded inventory awaiting train departure. Mark items dispatched once they leave."
+        />
+
+        <Card withBorder radius="md" padding="lg">
+          {!isLoading && items.length === 0 ? (
+            <VisualEmptyState
+              variant="train"
+              title="Nothing to dispatch"
+              description="Loaded items appear here, ready to mark as dispatched."
+            />
+          ) : (
+            <InventoryWorkbench items={items} isLoading={isLoading} />
+          )}
+        </Card>
+      </Stack>
+    </Container>
+  );
+}
diff --git a/apps/edr-freight-web/backoffice/src/pages/warehouses/InventoryInquiryPage.tsx b/apps/edr-freight-web/backoffice/src/pages/warehouses/InventoryInquiryPage.tsx
new file mode 100644
index 000000000..0995796da
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/pages/warehouses/InventoryInquiryPage.tsx
@@ -0,0 +1,155 @@
+import { useMemo, useState } from 'react';
+import { Button, Card, Center, Container, Group, Loader, Select, Stack, Text, TextInput, Title } from '@mantine/core';
+import { Search } from 'lucide-react';
+
+import Breadcrumbs from '@/components/ui/Breadcrumbs';
+import { VisualEmptyState, WarehouseInquiryTable, inventoryStatusOptions } from '@/components/warehouses';
+import {
+  useInventoryInquiry,
+  useWarehouseYards,
+  useWarehouseZones,
+  useWarehouses,
+} from '@/hooks/useWarehouses';
+import type { InventoryInquiryFilter, InventoryStatus } from '@/types/warehouse';
+
+export default function InventoryInquiryPage() {
+  const [draft, setDraft] = useState<InventoryInquiryFilter>({});
+  const [applied, setApplied] = useState<InventoryInquiryFilter>({});
+
+  const warehousesQuery = useWarehouses();
+  const yardsQuery = useWarehouseYards(draft.warehouseId);
+  const zonesQuery = useWarehouseZones(draft.yardId);
+
+  const { data, isFetching } = useInventoryInquiry(applied);
+  const results = data ?? [];
+
+  const warehouseOptions = useMemo(
+    () => (warehousesQuery.data ?? []).map((w) => ({ value: w.id, label: `${w.name} (${w.code})` })),
+    [warehousesQuery.data],
+  );
+  const yardOptions = useMemo(
+    () => (yardsQuery.data ?? []).map((y) => ({ value: y.id, label: `${y.name} (${y.code})` })),
+    [yardsQuery.data],
+  );
+  const zoneOptions = useMemo(
+    () => (zonesQuery.data ?? []).map((z) => ({ value: z.id, label: `${z.name} (${z.code})` })),
+    [zonesQuery.data],
+  );
+
+  const runSearch = () => setApplied(draft);
+  const reset = () => {
+    setDraft({});
+    setApplied({});
+  };
+
+  return (
+    <Container size="xxl" py="lg">
+      <Breadcrumbs items={[{ label: 'Inventory inquiry' }]} />
+
+      <Stack gap="lg" mt="sm">
+        <div>
+          <Title order={2}>Inventory Inquiry</Title>
+          <Text c="dimmed" size="sm">
+            Locate any cargo, container or goods inside the warehouse network.
+          </Text>
+        </div>
+
+        <Card withBorder radius="md" padding="lg">
+          <Stack gap="md">
+            <Group gap="sm" wrap="wrap">
+              <TextInput
+                label="Booking number"
+                placeholder="e.g. BKG-00123"
+                value={draft.bookingNumber ?? ''}
+                onChange={(e) => { const v = e.currentTarget.value; setDraft((f) => ({ ...f, bookingNumber: v || undefined })); }}
+                w={200}
+              />
+              <TextInput
+                label="Container number"
+                placeholder="e.g. MSKU1234567"
+                value={draft.containerNumber ?? ''}
+                onChange={(e) => { const v = e.currentTarget.value; setDraft((f) => ({ ...f, containerNumber: v || undefined })); }}
+                w={200}
+              />
+              <TextInput
+                label="Goods name"
+                placeholder="e.g. Coffee"
+                value={draft.goodsName ?? ''}
+                onChange={(e) => { const v = e.currentTarget.value; setDraft((f) => ({ ...f, goodsName: v || undefined })); }}
+                w={180}
+              />
+              <Select
+                label="Warehouse"
+                placeholder="Any"
+                clearable
+                searchable
+                data={warehouseOptions}
+                value={draft.warehouseId ?? null}
+                onChange={(value) =>
+                  setDraft((f) => ({ ...f, warehouseId: value ?? undefined, yardId: undefined, zoneId: undefined }))
+                }
+                w={200}
+              />
+              <Select
+                label="Yard"
+                placeholder="Any"
+                clearable
+                searchable
+                disabled={!draft.warehouseId}
+                data={yardOptions}
+                value={draft.yardId ?? null}
+                onChange={(value) => setDraft((f) => ({ ...f, yardId: value ?? undefined, zoneId: undefined }))}
+                w={180}
+              />
+              <Select
+                label="Zone"
+                placeholder="Any"
+                clearable
+                searchable
+                disabled={!draft.yardId}
+                data={zoneOptions}
+                value={draft.zoneId ?? null}
+                onChange={(value) => setDraft((f) => ({ ...f, zoneId: value ?? undefined }))}
+                w={180}
+              />
+              <Select
+                label="Status"
+                placeholder="Any"
+                clearable
+                data={inventoryStatusOptions}
+                value={draft.status ?? null}
+                onChange={(value) => setDraft((f) => ({ ...f, status: (value as InventoryStatus) ?? undefined }))}
+                w={180}
+              />
+            </Group>
+
+            <Group>
+              <Button leftSection={<Search size={16} />} onClick={runSearch}>
+                Search
+              </Button>
+              <Button variant="default" onClick={reset}>
+                Reset
+              </Button>
+            </Group>
+          </Stack>
+        </Card>
+
+        <Card withBorder radius="md" padding="lg">
+          {isFetching ? (
+            <Center py="xl">
+              <Loader />
+            </Center>
+          ) : results.length === 0 ? (
+            <VisualEmptyState
+              variant="container"
+              title="No items found"
+              description="Adjust your filters and search to locate cargo, containers or goods across the warehouse network."
+            />
+          ) : (
+            <WarehouseInquiryTable results={results} />
+          )}
+        </Card>
+      </Stack>
+    </Container>
+  );
+}
diff --git a/apps/edr-freight-web/backoffice/src/pages/warehouses/LoadedInventoryPage.tsx b/apps/edr-freight-web/backoffice/src/pages/warehouses/LoadedInventoryPage.tsx
new file mode 100644
index 000000000..5cea3de20
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/pages/warehouses/LoadedInventoryPage.tsx
@@ -0,0 +1,86 @@
+import { Badge, Card, Container, Group, Loader, Stack, Table, Text } from '@mantine/core';
+
+import Breadcrumbs from '@/components/ui/Breadcrumbs';
+import { FreightVisual, VisualEmptyState, WarehouseHero, formatDate, formatNumber } from '@/components/warehouses';
+import { useWarehouseLoadings } from '@/hooks/useWarehouses';
+
+/** Record of every inventory item loaded onto a wagon. */
+export default function LoadedInventoryPage() {
+  const { data, isLoading } = useWarehouseLoadings();
+  const loadings = data ?? [];
+
+  return (
+    <Container size="xxl" py="lg">
+      <Breadcrumbs items={[{ label: 'Loaded inventory' }]} />
+
+      <Stack gap="lg" mt="sm">
+        <WarehouseHero
+          variant="container"
+          secondaryVariant="wagon"
+          title="Loaded Inventory"
+          subtitle="Items loaded onto wagons, with their loading records."
+        />
+
+        <Card withBorder radius="md" padding="lg">
+          {isLoading ? (
+            <Group justify="center" py="xl">
+              <Loader />
+            </Group>
+          ) : loadings.length === 0 ? (
+            <VisualEmptyState
+              variant="container"
+              title="No loaded inventory yet"
+              description="Once items are loaded onto a wagon, their records show here."
+            />
+          ) : (
+            <Table.ScrollContainer minWidth={760}>
+              <Table verticalSpacing="sm" highlightOnHover>
+                <Table.Thead>
+                  <Table.Tr>
+                    <Table.Th>Wagon</Table.Th>
+                    <Table.Th>Warehouse</Table.Th>
+                    <Table.Th>Zone</Table.Th>
+                    <Table.Th>Loaded Weight (kg)</Table.Th>
+                    <Table.Th>Loaded At</Table.Th>
+                    <Table.Th>Status</Table.Th>
+                  </Table.Tr>
+                </Table.Thead>
+                <Table.Tbody>
+                  {loadings.map((l) => (
+                    <Table.Tr key={l.id}>
+                      <Table.Td>
+                        <Group gap={6} wrap="nowrap">
+                          <FreightVisual variant="wagon" size={22} />
+                          <Text fw={600} size="sm">
+                            {l.wagonNumber ?? l.wagonId.slice(0, 8)}
+                          </Text>
+                        </Group>
+                      </Table.Td>
+                      <Table.Td>
+                        {l.inventory?.warehouse
+                          ? `${l.inventory.warehouse.name} (${l.inventory.warehouse.code})`
+                          : '—'}
+                      </Table.Td>
+                      <Table.Td>{l.inventory?.zone ? l.inventory.zone.name : '—'}</Table.Td>
+                      <Table.Td>{formatNumber(l.loadedWeight)}</Table.Td>
+                      <Table.Td>{formatDate(l.loadedAt)}</Table.Td>
+                      <Table.Td>
+                        <Badge
+                          variant="light"
+                          color={l.inventory?.status === 'DISPATCHED' ? 'green' : 'teal'}
+                          size="sm"
+                        >
+                          {l.inventory?.status ?? 'LOADED'}
+                        </Badge>
+                      </Table.Td>
+                    </Table.Tr>
+                  ))}
+                </Table.Tbody>
+              </Table>
+            </Table.ScrollContainer>
+          )}
+        </Card>
+      </Stack>
+    </Container>
+  );
+}
diff --git a/apps/edr-freight-web/backoffice/src/pages/warehouses/LoadingQueuePage.tsx b/apps/edr-freight-web/backoffice/src/pages/warehouses/LoadingQueuePage.tsx
new file mode 100644
index 000000000..7bc363c09
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/pages/warehouses/LoadingQueuePage.tsx
@@ -0,0 +1,247 @@
+import { useMemo } from 'react';
+import { useNavigate } from 'react-router-dom';
+import { Badge, Button, Card, Container, Group, Stack, Table, Tabs, Text } from '@mantine/core';
+import { CreditCard, Eye, Truck } from 'lucide-react';
+
+import Breadcrumbs from '@/components/ui/Breadcrumbs';
+import {
+  InventoryWorkbench,
+  VisualEmptyState,
+  WarehouseHero,
+  formatNumber,
+} from '@/components/warehouses';
+import { useAutoLoadReady, useWarehouseInventory } from '@/hooks/useWarehouses';
+import { useToast } from '@/hooks/use-toast';
+import type { WarehouseInventoryItem } from '@/types/warehouse';
+
+const isPaid = (item: WarehouseInventoryItem) => item.booking?.status === 'PAID';
+
+/**
+ * Loading Queue — manage inventory through the loading workflow.
+ * Tabs:
+ *   - Ready to Load: READY_FOR_LOADING + booking PAID (can Mark as Loaded)
+ *   - Pending Payment: READY_FOR_LOADING + booking not PAID (no Load action)
+ *   - Loaded Inventory: LOADED (can Dispatch)
+ *   - Dispatch Queue: LOADED (can Dispatch)
+ */
+export default function LoadingQueuePage() {
+  const navigate = useNavigate();
+  const { toast } = useToast();
+  const autoLoad = useAutoLoadReady();
+  const { data: readyData, isLoading: readyLoading } = useWarehouseInventory({
+    status: 'READY_FOR_LOADING',
+  });
+  const { data: loadedData, isLoading: loadedLoading } = useWarehouseInventory({ status: 'LOADED' });
+
+  const handleAutoLoad = async () => {
+    try {
+      const res = await autoLoad.mutateAsync();
+      const r = res.data;
+      toast({
+        title: 'Auto-load complete',
+        description: `Loaded ${r.loadedCount} PAID item(s); skipped ${r.skippedCount} (unpaid stay pending).`,
+      });
+    } catch {
+      toast({ variant: 'destructive', title: 'Auto-load failed' });
+    }
+  };
+
+  const readyItems = readyData ?? [];
+  const loadedItems = loadedData ?? [];
+
+  const paidItems = useMemo(() => readyItems.filter(isPaid), [readyItems]);
+  const unpaidItems = useMemo(() => readyItems.filter((i) => !isPaid(i)), [readyItems]);
+
+  return (
+    <Container size="xxl" py="lg">
+      <Breadcrumbs items={[{ label: 'Loading queue' }]} />
+
+      <Stack gap="lg" mt="sm">
+        <WarehouseHero
+          variant="wagon"
+          secondaryVariant="cargo"
+          title="Loading Queue"
+          subtitle="Manage bookings and inventory through the loading workflow."
+        />
+
+        <Group justify="flex-end">
+          <Button
+            color="green"
+            leftSection={<Truck size={16} />}
+            loading={autoLoad.isPending}
+            onClick={handleAutoLoad}
+          >
+            Auto Load Ready Items
+          </Button>
+        </Group>
+
+        <Card withBorder radius="md" padding="lg">
+          <Tabs defaultValue="ready">
+            <Tabs.List>
+              <Tabs.Tab
+                value="ready"
+                leftSection={
+                  <Badge size="xs" color="green">
+                    {paidItems.length}
+                  </Badge>
+                }
+              >
+                Ready to Load
+              </Tabs.Tab>
+              <Tabs.Tab
+                value="pending"
+                leftSection={
+                  <Badge size="xs" color="orange">
+                    {unpaidItems.length}
+                  </Badge>
+                }
+              >
+                Pending Payment
+              </Tabs.Tab>
+              <Tabs.Tab
+                value="loaded"
+                leftSection={
+                  <Badge size="xs" color="teal">
+                    {loadedItems.length}
+                  </Badge>
+                }
+              >
+                Loaded Inventory
+              </Tabs.Tab>
+              <Tabs.Tab
+                value="dispatch"
+                leftSection={
+                  <Badge size="xs" color="blue">
+                    {loadedItems.length}
+                  </Badge>
+                }
+              >
+                Dispatch Queue
+              </Tabs.Tab>
+            </Tabs.List>
+
+            {/* Ready to Load — PAID bookings, can be marked Loaded */}
+            <Tabs.Panel value="ready" pt="md">
+              {!readyLoading && paidItems.length === 0 ? (
+                <VisualEmptyState
+                  variant="wagon"
+                  title="Nothing ready to load"
+                  description="Paid bookings marked Ready For Loading appear here, ready to load onto a wagon."
+                />
+              ) : (
+                <InventoryWorkbench items={paidItems} isLoading={readyLoading} />
+              )}
+            </Tabs.Panel>
+
+            {/* Pending Payment — unpaid bookings, read-only (no Load action) */}
+            <Tabs.Panel value="pending" pt="md">
+              {!readyLoading && unpaidItems.length === 0 ? (
+                <VisualEmptyState
+                  variant="cargo"
+                  title="No unpaid bookings"
+                  description="Ready-for-loading items whose booking is not yet PAID appear here."
+                />
+              ) : (
+                <PendingPaymentTable items={unpaidItems} onNavigate={navigate} />
+              )}
+            </Tabs.Panel>
+
+            {/* Loaded Inventory — LOADED items, can Dispatch */}
+            <Tabs.Panel value="loaded" pt="md">
+              {!loadedLoading && loadedItems.length === 0 ? (
+                <VisualEmptyState
+                  variant="container"
+                  title="No loaded inventory yet"
+                  description="Items loaded onto a wagon appear here, ready to dispatch."
+                />
+              ) : (
+                <InventoryWorkbench items={loadedItems} isLoading={loadedLoading} />
+              )}
+            </Tabs.Panel>
+
+            {/* Dispatch Queue — LOADED items awaiting departure */}
+            <Tabs.Panel value="dispatch" pt="md">
+              {!loadedLoading && loadedItems.length === 0 ? (
+                <VisualEmptyState
+                  variant="train"
+                  title="Nothing to dispatch"
+                  description="Loaded items appear here, ready to mark as dispatched."
+                />
+              ) : (
+                <InventoryWorkbench items={loadedItems} isLoading={loadedLoading} />
+              )}
+            </Tabs.Panel>
+          </Tabs>
+        </Card>
+      </Stack>
+    </Container>
+  );
+}
+
+interface PendingPaymentTableProps {
+  items: WarehouseInventoryItem[];
+  onNavigate: (path: string) => void;
+}
+
+/** Read-only view of unpaid ready-for-loading items. No Mark-as-Loaded action. */
+function PendingPaymentTable({ items, onNavigate }: PendingPaymentTableProps) {
+  return (
+    <Table.ScrollContainer minWidth={820}>
+      <Table verticalSpacing="sm" highlightOnHover striped>
+        <Table.Thead>
+          <Table.Tr>
+            <Table.Th>Booking</Table.Th>
+            <Table.Th>Warehouse</Table.Th>
+            <Table.Th>Zone</Table.Th>
+            <Table.Th>Weight (kg)</Table.Th>
+            <Table.Th>Payment</Table.Th>
+            <Table.Th ta="right">Actions</Table.Th>
+          </Table.Tr>
+        </Table.Thead>
+        <Table.Tbody>
+          {items.map((item) => (
+            <Table.Tr key={item.id}>
+              <Table.Td>
+                <Text fw={600} size="sm">
+                  {item.booking?.reference ?? item.bookingId?.slice(0, 8) ?? '—'}
+                </Text>
+              </Table.Td>
+              <Table.Td>{item.warehouse?.code ?? '—'}</Table.Td>
+              <Table.Td>{item.zone?.code ?? '—'}</Table.Td>
+              <Table.Td>{formatNumber(item.weight)}</Table.Td>
+              <Table.Td>
+                <Badge color="orange" variant="light" size="sm">
+                  {item.booking?.status ?? item.booking?.paymentStatus ?? 'UNPAID'}
+                </Badge>
+              </Table.Td>
+              <Table.Td>
+                <Group gap="xs" justify="flex-end" wrap="nowrap">
+                  <Button
+                    size="compact-xs"
+                    variant="light"
+                    color="gray"
+                    leftSection={<Eye size={14} />}
+                    disabled={!item.bookingId}
+                    onClick={() => item.bookingId && onNavigate(`/dashboard/booking-requests/${item.bookingId}`)}
+                  >
+                    Booking
+                  </Button>
+                  <Button
+                    size="compact-xs"
+                    variant="light"
+                    color="orange"
+                    leftSection={<CreditCard size={14} />}
+                    disabled={!item.bookingId}
+                    onClick={() => item.bookingId && onNavigate(`/dashboard/booking-requests/${item.bookingId}`)}
+                  >
+                    Payment
+                  </Button>
+                </Group>
+              </Table.Td>
+            </Table.Tr>
+          ))}
+        </Table.Tbody>
+      </Table>
+    </Table.ScrollContainer>
+  );
+}
diff --git a/apps/edr-freight-web/backoffice/src/pages/warehouses/WarehouseDashboardPage.tsx b/apps/edr-freight-web/backoffice/src/pages/warehouses/WarehouseDashboardPage.tsx
new file mode 100644
index 000000000..9002bcedd
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/pages/warehouses/WarehouseDashboardPage.tsx
@@ -0,0 +1,115 @@
+import { useNavigate } from 'react-router-dom';
+import { Card, Center, Container, Group, Loader, SimpleGrid, Stack, Text, ThemeIcon } from '@mantine/core';
+import {
+  ClipboardCheck,
+  PackageCheck,
+  PackagePlus,
+  Send,
+  Truck,
+  Warehouse as WarehouseIcon,
+  Boxes,
+  Layers,
+} from 'lucide-react';
+
+import Breadcrumbs from '@/components/ui/Breadcrumbs';
+import { WarehouseDashboardCharts, WarehouseHero } from '@/components/warehouses';
+import { useWarehouseDashboard } from '@/hooks/useWarehouses';
+import type { WarehouseDashboard } from '@/types/warehouse';
+
+/** Brand palette: alternating orange + light green. */
+const ORANGE = { solid: '#f08c00', soft: '#fff4e6', border: '#ffd8a8', text: '#e8590c' };
+const GREEN = { solid: '#5bbf4a', soft: '#ebfbee', border: '#b2f2bb', text: '#2f9e44' };
+
+interface Metric {
+  key: keyof WarehouseDashboard;
+  label: string;
+  icon: React.ReactNode;
+  /** Route to navigate to when the card is clicked. */
+  to: string;
+  theme: typeof ORANGE;
+}
+
+const METRICS: Metric[] = [
+  { key: 'totalWarehouses', label: 'Total Warehouses', icon: <WarehouseIcon size={22} />, to: '/dashboard/warehouses', theme: ORANGE },
+  { key: 'totalInventory', label: 'Total Inventory', icon: <Boxes size={22} />, to: '/dashboard/warehouse-inventory', theme: GREEN },
+  { key: 'receivedToday', label: 'Received Today', icon: <PackagePlus size={22} />, to: '/dashboard/warehouse-inventory?status=RECEIVED', theme: ORANGE },
+  { key: 'stored', label: 'Stored', icon: <Layers size={22} />, to: '/dashboard/warehouse-inventory?status=STORED', theme: GREEN },
+  { key: 'reserved', label: 'Reserved', icon: <ClipboardCheck size={22} />, to: '/dashboard/warehouse-inventory?status=RESERVED', theme: ORANGE },
+  { key: 'readyForLoading', label: 'Ready For Loading', icon: <PackageCheck size={22} />, to: '/dashboard/loading-queue', theme: GREEN },
+  { key: 'loaded', label: 'Loaded', icon: <Truck size={22} />, to: '/dashboard/loaded-inventory', theme: ORANGE },
+  { key: 'dispatched', label: 'Dispatched', icon: <Send size={22} />, to: '/dashboard/dispatch-queue', theme: GREEN },
+];
+
+export default function WarehouseDashboardPage() {
+  const navigate = useNavigate();
+  const { data, isLoading } = useWarehouseDashboard();
+
+  return (
+    <Container size="xxl" py="lg">
+      <Breadcrumbs items={[{ label: 'Warehouse dashboard' }]} />
+
+      <Stack gap="lg" mt="sm">
+        <WarehouseHero
+          variant="train"
+          secondaryVariant="warehouse"
+          title="Warehouse Dashboard"
+          subtitle="Live overview of warehouse capacity and inventory lifecycle."
+        />
+
+        {isLoading ? (
+          <Center py="xl">
+            <Loader />
+          </Center>
+        ) : (
+          <>
+          <SimpleGrid cols={{ base: 1, xs: 2, md: 4 }} spacing="md">
+            {METRICS.map((metric) => (
+              <Card
+                key={metric.key}
+                radius="lg"
+                padding="lg"
+                onClick={() => navigate(metric.to)}
+                style={{
+                  cursor: 'pointer',
+                  background: `linear-gradient(135deg, ${metric.theme.soft} 0%, #ffffff 75%)`,
+                  border: `1px solid ${metric.theme.border}`,
+                  transition: 'box-shadow 150ms ease, transform 150ms ease',
+                }}
+                onMouseEnter={(e) => {
+                  e.currentTarget.style.boxShadow = `0 10px 24px -12px ${metric.theme.solid}`;
+                  e.currentTarget.style.transform = 'translateY(-3px)';
+                }}
+                onMouseLeave={(e) => {
+                  e.currentTarget.style.boxShadow = '';
+                  e.currentTarget.style.transform = '';
+                }}
+              >
+                <Group justify="space-between" align="flex-start" wrap="nowrap">
+                  <div>
+                    <Text size="xs" c="dimmed" tt="uppercase" fw={700} style={{ letterSpacing: 0.4 }}>
+                      {metric.label}
+                    </Text>
+                    <Text fw={800} size="32px" mt={8} style={{ color: metric.theme.text, lineHeight: 1.1 }}>
+                      {data ? data[metric.key] : 0}
+                    </Text>
+                  </div>
+                  <ThemeIcon
+                    variant="filled"
+                    size={46}
+                    radius="md"
+                    style={{ backgroundColor: metric.theme.solid, color: '#fff' }}
+                  >
+                    {metric.icon}
+                  </ThemeIcon>
+                </Group>
+              </Card>
+            ))}
+          </SimpleGrid>
+
+          <WarehouseDashboardCharts data={data} />
+          </>
+        )}
+      </Stack>
+    </Container>
+  );
+}
diff --git a/apps/edr-freight-web/backoffice/src/pages/warehouses/WarehouseDetailPage.tsx b/apps/edr-freight-web/backoffice/src/pages/warehouses/WarehouseDetailPage.tsx
new file mode 100644
index 000000000..0d352d205
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/pages/warehouses/WarehouseDetailPage.tsx
@@ -0,0 +1,332 @@
+import { useMemo, useState } from 'react';
+import { useNavigate, useParams } from 'react-router-dom';
+import {
+  ActionIcon,
+  Button,
+  Card,
+  Center,
+  Container,
+  Group,
+  Loader,
+  SimpleGrid,
+  Stack,
+  Select,
+  Table,
+  Tabs,
+  Text,
+  Title,
+} from '@mantine/core';
+import { ArrowLeft, Boxes, LayoutGrid, Package, Pencil, Plus } from 'lucide-react';
+
+import Breadcrumbs from '@/components/ui/Breadcrumbs';
+import {
+  CreateYardModal,
+  CreateZoneModal,
+  InventoryWorkbench,
+  WarehouseStatusBadge,
+  WarehouseTypeBadge,
+  formatCapacity,
+  humanizeEnum,
+} from '@/components/warehouses';
+import {
+  useWarehouse,
+  useWarehouseInventory,
+  useWarehouseYards,
+  useWarehouseZones,
+} from '@/hooks/useWarehouses';
+import type { WarehouseYard, WarehouseZone } from '@/types/warehouse';
+
+function StatCard({ label, value }: { label: string; value: string }) {
+  return (
+    <Card withBorder radius="md" padding="md">
+      <Text size="xs" c="dimmed" tt="uppercase" fw={600}>
+        {label}
+      </Text>
+      <Text fw={700} size="lg" mt={4}>
+        {value}
+      </Text>
+    </Card>
+  );
+}
+
+export default function WarehouseDetailPage() {
+  const { id } = useParams<{ id: string }>();
+  const navigate = useNavigate();
+
+  const { data: warehouse, isLoading } = useWarehouse(id);
+  const yardsQuery = useWarehouseYards(id);
+
+  const [yardModalOpen, setYardModalOpen] = useState(false);
+  const [editingYard, setEditingYard] = useState<WarehouseYard | null>(null);
+
+  const [zoneModalOpen, setZoneModalOpen] = useState(false);
+  const [editingZone, setEditingZone] = useState<WarehouseZone | null>(null);
+  const [selectedYardId, setSelectedYardId] = useState<string | null>(null);
+
+  const zonesQuery = useWarehouseZones(selectedYardId ?? undefined);
+
+  const inventoryQuery = useWarehouseInventory(id ? { warehouseId: id } : undefined);
+
+  const yards = yardsQuery.data ?? [];
+  const yardOptions = useMemo(
+    () => yards.map((y) => ({ value: y.id, label: `${y.name} (${y.code})` })),
+    [yards],
+  );
+
+  if (isLoading) {
+    return (
+      <Center mih="60vh">
+        <Loader />
+      </Center>
+    );
+  }
+
+  if (!warehouse) {
+    return (
+      <Container size="sm" py="xl">
+        <Stack align="center" gap="md">
+          <Text fw={700}>Warehouse not found</Text>
+          <Button variant="default" leftSection={<ArrowLeft size={16} />} onClick={() => navigate('/dashboard/warehouses')}>
+            Back to warehouses
+          </Button>
+        </Stack>
+      </Container>
+    );
+  }
+
+  return (
+    <Container size="xxl" py="lg">
+      <Breadcrumbs
+        items={[
+          { label: 'Warehouses', href: '/dashboard/warehouses' },
+          { label: warehouse.name },
+        ]}
+      />
+
+      <Stack gap="lg" mt="sm">
+        <Group justify="space-between" align="flex-start">
+          <Group gap="md" align="center">
+            <ActionIcon variant="subtle" color="gray" onClick={() => navigate('/dashboard/warehouses')}>
+              <ArrowLeft size={18} />
+            </ActionIcon>
+            <div>
+              <Group gap="sm">
+                <Title order={2}>{warehouse.name}</Title>
+                <WarehouseTypeBadge type={warehouse.type} />
+                <WarehouseStatusBadge status={warehouse.status} />
+              </Group>
+              <Text c="dimmed" size="sm">
+                {warehouse.code}
+                {warehouse.locationName ? ` · ${warehouse.locationName}` : ''}
+              </Text>
+            </div>
+          </Group>
+        </Group>
+
+        <Tabs defaultValue="overview">
+          <Tabs.List>
+            <Tabs.Tab value="overview" leftSection={<LayoutGrid size={16} />}>
+              Overview
+            </Tabs.Tab>
+            <Tabs.Tab value="yards" leftSection={<Boxes size={16} />}>
+              Yards
+            </Tabs.Tab>
+            <Tabs.Tab value="zones" leftSection={<LayoutGrid size={16} />}>
+              Zones
+            </Tabs.Tab>
+            <Tabs.Tab value="inventory" leftSection={<Package size={16} />}>
+              Inventory
+            </Tabs.Tab>
+          </Tabs.List>
+
+          {/* OVERVIEW */}
+          <Tabs.Panel value="overview" pt="lg">
+            <SimpleGrid cols={{ base: 1, sm: 2, lg: 4 }} spacing="md">
+              <StatCard label="Type" value={humanizeEnum(warehouse.type)} />
+              <StatCard label="Yards" value={String(yards.length)} />
+              <StatCard
+                label="Weight (cur / cap)"
+                value={formatCapacity(warehouse.currentWeight, warehouse.capacityWeight)}
+              />
+              <StatCard
+                label="Containers (cur / cap)"
+                value={formatCapacity(warehouse.currentContainers, warehouse.capacityContainers)}
+              />
+            </SimpleGrid>
+          </Tabs.Panel>
+
+          {/* YARDS */}
+          <Tabs.Panel value="yards" pt="lg">
+            <Card withBorder radius="md" padding="lg">
+              <Stack gap="md">
+                <Group justify="space-between">
+                  <Text fw={600}>Yards</Text>
+                  <Button
+                    size="sm"
+                    leftSection={<Plus size={16} />}
+                    onClick={() => {
+                      setEditingYard(null);
+                      setYardModalOpen(true);
+                    }}
+                  >
+                    Create Yard
+                  </Button>
+                </Group>
+
+                {yards.length === 0 ? (
+                  <Text c="dimmed" ta="center" py="lg">
+                    No yards yet.
+                  </Text>
+                ) : (
+                  <Table highlightOnHover verticalSpacing="sm" striped>
+                    <Table.Thead>
+                      <Table.Tr>
+                        <Table.Th>Name</Table.Th>
+                        <Table.Th>Code</Table.Th>
+                        <Table.Th>Type</Table.Th>
+                        <Table.Th>Weight (cur / cap)</Table.Th>
+                        <Table.Th>Containers (cur / cap)</Table.Th>
+                        <Table.Th>Status</Table.Th>
+                        <Table.Th ta="right">Actions</Table.Th>
+                      </Table.Tr>
+                    </Table.Thead>
+                    <Table.Tbody>
+                      {yards.map((yard) => (
+                        <Table.Tr key={yard.id}>
+                          <Table.Td>{yard.name}</Table.Td>
+                          <Table.Td>{yard.code}</Table.Td>
+                          <Table.Td>{humanizeEnum(yard.type)}</Table.Td>
+                          <Table.Td>{formatCapacity(yard.currentWeight, yard.capacityWeight)}</Table.Td>
+                          <Table.Td>{formatCapacity(yard.currentContainers, yard.capacityContainers)}</Table.Td>
+                          <Table.Td>
+                            <WarehouseStatusBadge status={yard.status} />
+                          </Table.Td>
+                          <Table.Td ta="right">
+                            <ActionIcon
+                              variant="subtle"
+                              color="gray"
+                              onClick={() => {
+                                setEditingYard(yard);
+                                setYardModalOpen(true);
+                              }}
+                            >
+                              <Pencil size={16} />
+                            </ActionIcon>
+                          </Table.Td>
+                        </Table.Tr>
+                      ))}
+                    </Table.Tbody>
+                  </Table>
+                )}
+              </Stack>
+            </Card>
+          </Tabs.Panel>
+
+          {/* ZONES */}
+          <Tabs.Panel value="zones" pt="lg">
+            <Card withBorder radius="md" padding="lg">
+              <Stack gap="md">
+                <Group justify="space-between" align="flex-end">
+                  <Select
+                    label="Yard"
+                    placeholder="Select a yard"
+                    data={yardOptions}
+                    value={selectedYardId}
+                    onChange={setSelectedYardId}
+                    w={280}
+                    searchable
+                  />
+                  <Button
+                    size="sm"
+                    leftSection={<Plus size={16} />}
+                    disabled={!selectedYardId}
+                    onClick={() => {
+                      setEditingZone(null);
+                      setZoneModalOpen(true);
+                    }}
+                  >
+                    Create Zone
+                  </Button>
+                </Group>
+
+                {!selectedYardId ? (
+                  <Text c="dimmed" ta="center" py="lg">
+                    Select a yard to view its zones.
+                  </Text>
+                ) : (zonesQuery.data ?? []).length === 0 ? (
+                  <Text c="dimmed" ta="center" py="lg">
+                    No zones in this yard yet.
+                  </Text>
+                ) : (
+                  <Table highlightOnHover verticalSpacing="sm" striped>
+                    <Table.Thead>
+                      <Table.Tr>
+                        <Table.Th>Name</Table.Th>
+                        <Table.Th>Code</Table.Th>
+                        <Table.Th>Type</Table.Th>
+                        <Table.Th>Weight (cur / cap)</Table.Th>
+                        <Table.Th>Containers (cur / cap)</Table.Th>
+                        <Table.Th>Status</Table.Th>
+                        <Table.Th ta="right">Actions</Table.Th>
+                      </Table.Tr>
+                    </Table.Thead>
+                    <Table.Tbody>
+                      {(zonesQuery.data ?? []).map((zone) => (
+                        <Table.Tr key={zone.id}>
+                          <Table.Td>{zone.name}</Table.Td>
+                          <Table.Td>{zone.code}</Table.Td>
+                          <Table.Td>{humanizeEnum(zone.type)}</Table.Td>
+                          <Table.Td>{formatCapacity(zone.currentWeight, zone.capacityWeight)}</Table.Td>
+                          <Table.Td>{formatCapacity(zone.currentContainers, zone.capacityContainers)}</Table.Td>
+                          <Table.Td>
+                            <WarehouseStatusBadge status={zone.status} />
+                          </Table.Td>
+                          <Table.Td ta="right">
+                            <ActionIcon
+                              variant="subtle"
+                              color="gray"
+                              onClick={() => {
+                                setEditingZone(zone);
+                                setZoneModalOpen(true);
+                              }}
+                            >
+                              <Pencil size={16} />
+                            </ActionIcon>
+                          </Table.Td>
+                        </Table.Tr>
+                      ))}
+                    </Table.Tbody>
+                  </Table>
+                )}
+              </Stack>
+            </Card>
+          </Tabs.Panel>
+
+          {/* INVENTORY */}
+          <Tabs.Panel value="inventory" pt="lg">
+            <Card withBorder radius="md" padding="lg">
+              <InventoryWorkbench items={inventoryQuery.data ?? []} isLoading={inventoryQuery.isLoading} />
+            </Card>
+          </Tabs.Panel>
+        </Tabs>
+      </Stack>
+
+      {id && (
+        <CreateYardModal
+          opened={yardModalOpen}
+          onClose={() => setYardModalOpen(false)}
+          warehouseId={id}
+          yard={editingYard}
+        />
+      )}
+      {selectedYardId && (
+        <CreateZoneModal
+          opened={zoneModalOpen}
+          onClose={() => setZoneModalOpen(false)}
+          yardId={selectedYardId}
+          zone={editingZone}
+        />
+      )}
+    </Container>
+  );
+}
diff --git a/apps/edr-freight-web/backoffice/src/pages/warehouses/WarehouseInventoryPage.tsx b/apps/edr-freight-web/backoffice/src/pages/warehouses/WarehouseInventoryPage.tsx
new file mode 100644
index 000000000..8831037d1
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/pages/warehouses/WarehouseInventoryPage.tsx
@@ -0,0 +1,130 @@
+import { useMemo, useState } from 'react';
+import { useSearchParams } from 'react-router-dom';
+import { Button, Card, Container, Group, Select, Stack, Text, TextInput, Title } from '@mantine/core';
+import { useDebouncedValue } from '@mantine/hooks';
+import { PackagePlus, Search } from 'lucide-react';
+
+import Breadcrumbs from '@/components/ui/Breadcrumbs';
+import {
+  InventoryWorkbench,
+  ReceiveInventoryModal,
+  inventoryStatusOptions,
+} from '@/components/warehouses';
+import {
+  useWarehouseInventory,
+  useWarehouseYards,
+  useWarehouseZones,
+  useWarehouses,
+} from '@/hooks/useWarehouses';
+import type { InventoryFilter, InventoryStatus } from '@/types/warehouse';
+
+export default function WarehouseInventoryPage() {
+  const [searchParams] = useSearchParams();
+  const initialStatus = (searchParams.get('status') as InventoryStatus | null) ?? undefined;
+  const [filter, setFilter] = useState<InventoryFilter>(
+    initialStatus ? { status: initialStatus } : {},
+  );
+  const [search, setSearch] = useState('');
+  const [modalOpen, setModalOpen] = useState(false);
+
+  const [debouncedSearch] = useDebouncedValue(search, 300);
+  const queryFilter = useMemo<InventoryFilter>(
+    () => ({ ...filter, search: debouncedSearch || undefined }),
+    [filter, debouncedSearch],
+  );
+
+  const warehousesQuery = useWarehouses();
+  const yardsQuery = useWarehouseYards(filter.warehouseId);
+  const zonesQuery = useWarehouseZones(filter.yardId);
+  const inventoryQuery = useWarehouseInventory(queryFilter);
+
+  const warehouseOptions = useMemo(
+    () => (warehousesQuery.data ?? []).map((w) => ({ value: w.id, label: `${w.name} (${w.code})` })),
+    [warehousesQuery.data],
+  );
+  const yardOptions = useMemo(
+    () => (yardsQuery.data ?? []).map((y) => ({ value: y.id, label: `${y.name} (${y.code})` })),
+    [yardsQuery.data],
+  );
+  const zoneOptions = useMemo(
+    () => (zonesQuery.data ?? []).map((z) => ({ value: z.id, label: `${z.name} (${z.code})` })),
+    [zonesQuery.data],
+  );
+
+  return (
+    <Container size="xxl" py="lg">
+      <Breadcrumbs items={[{ label: 'Warehouse inventory' }]} />
+
+      <Stack gap="lg" mt="sm">
+        <Group justify="space-between" align="flex-end">
+          <div>
+            <Title order={2}>Warehouse Inventory</Title>
+            <Text c="dimmed" size="sm">
+              Track received items through the storage, reservation, loading and dispatch lifecycle.
+            </Text>
+          </div>
+          <Button leftSection={<PackagePlus size={16} />} onClick={() => setModalOpen(true)}>
+            Receive Inventory
+          </Button>
+        </Group>
+
+        <Card withBorder radius="md" padding="lg">
+          <Stack gap="md">
+            <Group gap="sm" wrap="wrap">
+              <TextInput
+                placeholder="Search notes"
+                leftSection={<Search size={16} />}
+                value={search}
+                onChange={(e) => setSearch(e.currentTarget.value)}
+                w={220}
+              />
+              <Select
+                placeholder="All warehouses"
+                clearable
+                searchable
+                data={warehouseOptions}
+                value={filter.warehouseId ?? null}
+                onChange={(value) =>
+                  setFilter((f) => ({ ...f, warehouseId: value ?? undefined, yardId: undefined, zoneId: undefined }))
+                }
+                w={220}
+              />
+              <Select
+                placeholder="All yards"
+                clearable
+                searchable
+                disabled={!filter.warehouseId}
+                data={yardOptions}
+                value={filter.yardId ?? null}
+                onChange={(value) => setFilter((f) => ({ ...f, yardId: value ?? undefined, zoneId: undefined }))}
+                w={200}
+              />
+              <Select
+                placeholder="All zones"
+                clearable
+                searchable
+                disabled={!filter.yardId}
+                data={zoneOptions}
+                value={filter.zoneId ?? null}
+                onChange={(value) => setFilter((f) => ({ ...f, zoneId: value ?? undefined }))}
+                w={200}
+              />
+              <Select
+                placeholder="All statuses"
+                clearable
+                data={inventoryStatusOptions}
+                value={filter.status ?? null}
+                onChange={(value) => setFilter((f) => ({ ...f, status: (value as InventoryStatus) ?? undefined }))}
+                w={200}
+              />
+            </Group>
+
+            <InventoryWorkbench items={inventoryQuery.data ?? []} isLoading={inventoryQuery.isLoading} />
+          </Stack>
+        </Card>
+      </Stack>
+
+      <ReceiveInventoryModal opened={modalOpen} onClose={() => setModalOpen(false)} />
+    </Container>
+  );
+}
diff --git a/apps/edr-freight-web/backoffice/src/pages/warehouses/WarehouseInvoicesPage.tsx b/apps/edr-freight-web/backoffice/src/pages/warehouses/WarehouseInvoicesPage.tsx
new file mode 100644
index 000000000..3f680bf0f
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/pages/warehouses/WarehouseInvoicesPage.tsx
@@ -0,0 +1,238 @@
+import { useMemo, useState } from 'react';
+import {
+  ActionIcon,
+  Badge,
+  Button,
+  Card,
+  Container,
+  Divider,
+  Group,
+  Loader,
+  Modal,
+  NumberInput,
+  Select,
+  Stack,
+  Table,
+  Text,
+  TextInput,
+} from '@mantine/core';
+import { Ban, CreditCard, Eye, Search } from 'lucide-react';
+
+import Breadcrumbs from '@/components/ui/Breadcrumbs';
+import { WarehouseHero } from '@/components/warehouses';
+import { useToast } from '@/hooks/use-toast';
+import {
+  useCancelInvoice,
+  usePayInvoice,
+  useWarehouseInvoice,
+  useWarehouseInvoices,
+} from '@/hooks/useWarehouses';
+import {
+  WAREHOUSE_INVOICE_STATUSES,
+  type WarehouseFeeInvoice,
+  type WarehouseInvoiceStatus,
+} from '@/types/warehouse';
+
+const STATUS_COLOR: Record<WarehouseInvoiceStatus, string> = {
+  DRAFT: 'gray',
+  ISSUED: 'orange',
+  PARTIALLY_PAID: 'yellow',
+  PAID: 'green',
+  CANCELLED: 'gray',
+};
+
+const fmt = (n: number, c: string) => `${Number(n).toLocaleString()} ${c}`;
+const fmtDate = (d?: string | null) => (d ? new Date(d).toLocaleDateString() : '—');
+
+export default function WarehouseInvoicesPage() {
+  const [status, setStatus] = useState<WarehouseInvoiceStatus | null>(null);
+  const [search, setSearch] = useState('');
+  const [detailId, setDetailId] = useState<string | null>(null);
+
+  const { data, isLoading } = useWarehouseInvoices(status ? { status } : undefined);
+  const invoices = data ?? [];
+
+  const filtered = useMemo(() => {
+    const q = search.trim().toLowerCase();
+    if (!q) return invoices;
+    return invoices.filter((i) => [i.invoiceNumber, i.bookingId, i.customerId].join(' ').toLowerCase().includes(q));
+  }, [invoices, search]);
+
+  return (
+    <Container size="xxl" py="lg">
+      <Breadcrumbs items={[{ label: 'Warehouse fee invoices' }]} />
+      <Stack gap="lg" mt="sm">
+        <WarehouseHero
+          variant="container"
+          secondaryVariant="warehouse"
+          title="Warehouse Fee Invoices"
+          subtitle="Demurrage & storage invoices generated from warehouse fee rules."
+        />
+
+        <Card withBorder radius="md" padding="lg">
+          <Group justify="space-between" mb="md" wrap="wrap">
+            <TextInput
+              placeholder="Search invoice no / booking / customer"
+              leftSection={<Search size={16} />}
+              value={search}
+              onChange={(e) => setSearch(e.currentTarget.value)}
+              w={320}
+            />
+            <Select
+              placeholder="All statuses"
+              data={WAREHOUSE_INVOICE_STATUSES.map((s) => ({ value: s, label: s.replace(/_/g, ' ') }))}
+              value={status}
+              onChange={(v) => setStatus((v as WarehouseInvoiceStatus) ?? null)}
+              clearable
+              w={200}
+            />
+          </Group>
+
+          {isLoading ? (
+            <Group justify="center" py="xl"><Loader /></Group>
+          ) : filtered.length === 0 ? (
+            <Text c="dimmed" ta="center" py="xl">No invoices found.</Text>
+          ) : (
+            <Table.ScrollContainer minWidth={1000}>
+              <Table striped highlightOnHover verticalSpacing="sm">
+                <Table.Thead>
+                  <Table.Tr>
+                    <Table.Th>Invoice No</Table.Th><Table.Th>Type</Table.Th><Table.Th>Total</Table.Th>
+                    <Table.Th>Paid</Table.Th><Table.Th>Balance</Table.Th><Table.Th>Status</Table.Th>
+                    <Table.Th>Issued</Table.Th><Table.Th ta="right">Actions</Table.Th>
+                  </Table.Tr>
+                </Table.Thead>
+                <Table.Tbody>
+                  {filtered.map((inv) => (
+                    <Table.Tr key={inv.id}>
+                      <Table.Td><Text fw={600} size="sm">{inv.invoiceNumber}</Text></Table.Td>
+                      <Table.Td>{inv.invoiceType.replace(/_/g, ' ')}</Table.Td>
+                      <Table.Td>{fmt(inv.totalAmount, inv.currency)}</Table.Td>
+                      <Table.Td>{fmt(inv.paidAmount, inv.currency)}</Table.Td>
+                      <Table.Td>{fmt(inv.balanceAmount, inv.currency)}</Table.Td>
+                      <Table.Td><Badge variant="light" color={STATUS_COLOR[inv.status]}>{inv.status.replace(/_/g, ' ')}</Badge></Table.Td>
+                      <Table.Td><Text size="xs">{fmtDate(inv.issuedAt)}</Text></Table.Td>
+                      <Table.Td ta="right">
+                        <ActionIcon variant="subtle" color="gray" onClick={() => setDetailId(inv.id)} title="View">
+                          <Eye size={16} />
+                        </ActionIcon>
+                      </Table.Td>
+                    </Table.Tr>
+                  ))}
+                </Table.Tbody>
+              </Table>
+            </Table.ScrollContainer>
+          )}
+        </Card>
+      </Stack>
+
+      <InvoiceDetailModal id={detailId} onClose={() => setDetailId(null)} />
+    </Container>
+  );
+}
+
+function InvoiceDetailModal({ id, onClose }: { id: string | null; onClose: () => void }) {
+  const { toast } = useToast();
+  const { data: inv, isLoading } = useWarehouseInvoice(id ?? undefined);
+  const pay = usePayInvoice();
+  const cancel = useCancelInvoice();
+  const [payAmount, setPayAmount] = useState<number | ''>('');
+
+  const canPay = inv && (inv.status === 'ISSUED' || inv.status === 'PARTIALLY_PAID');
+
+  const handlePay = async () => {
+    if (!inv || !payAmount) return;
+    try {
+      await pay.mutateAsync({ id: inv.id, payload: { amount: Number(payAmount), method: 'MANUAL' } });
+      toast({ title: 'Payment recorded' });
+      setPayAmount('');
+    } catch (e) {
+      toast({ variant: 'destructive', title: 'Payment failed', description: (e as Error)?.message });
+    }
+  };
+
+  const handleCancel = async () => {
+    if (!inv) return;
+    try {
+      await cancel.mutateAsync(inv.id);
+      toast({ title: 'Invoice cancelled' });
+      onClose();
+    } catch (e) {
+      toast({ variant: 'destructive', title: 'Cancel failed', description: (e as Error)?.message });
+    }
+  };
+
+  return (
+    <Modal opened={Boolean(id)} onClose={onClose} title="Fee invoice" centered size="lg">
+      {isLoading || !inv ? (
+        <Group justify="center" py="xl"><Loader /></Group>
+      ) : (
+        <Stack gap="sm">
+          <Group justify="space-between">
+            <Text fw={700} size="lg">{inv.invoiceNumber}</Text>
+            <Badge variant="light" color={STATUS_COLOR[inv.status]} size="lg">{inv.status.replace(/_/g, ' ')}</Badge>
+          </Group>
+
+          <Table withRowBorders={false} verticalSpacing={4}>
+            <Table.Tbody>
+              {(inv.items ?? []).map((it) => (
+                <Table.Tr key={it.id}>
+                  <Table.Td>
+                    <Text size="sm">{it.description}</Text>
+                    <Text size="xs" c="dimmed">{it.feeType.replace(/_/g, ' ')} · {it.chargeableDays ?? 0} day(s) @ {fmt(it.unitRate, it.currency)}</Text>
+                  </Table.Td>
+                  <Table.Td ta="right"><Text fw={600}>{fmt(it.amount, it.currency)}</Text></Table.Td>
+                </Table.Tr>
+              ))}
+            </Table.Tbody>
+          </Table>
+
+          <Divider />
+          <Group justify="space-between"><Text size="sm" c="dimmed">Subtotal</Text><Text>{fmt(inv.subtotalAmount, inv.currency)}</Text></Group>
+          <Group justify="space-between"><Text size="sm" c="dimmed">Tax</Text><Text>{fmt(inv.taxAmount, inv.currency)}</Text></Group>
+          <Group justify="space-between"><Text fw={700}>Total</Text><Text fw={700}>{fmt(inv.totalAmount, inv.currency)}</Text></Group>
+          <Group justify="space-between"><Text size="sm" c="dimmed">Paid</Text><Text>{fmt(inv.paidAmount, inv.currency)}</Text></Group>
+          <Group justify="space-between"><Text fw={600}>Balance</Text><Text fw={600}>{fmt(inv.balanceAmount, inv.currency)}</Text></Group>
+
+          {(inv.payments ?? []).length > 0 && (
+            <>
+              <Divider label="Payment history" labelPosition="left" />
+              {(inv.payments ?? []).map((p, i) => (
+                <Group key={i} justify="space-between">
+                  <Text size="xs" c="dimmed">{fmtDate(p.paidAt)} · {p.method ?? '—'}{p.reference ? ` · ${p.reference}` : ''}</Text>
+                  <Text size="sm">{fmt(p.amount, inv.currency)}</Text>
+                </Group>
+              ))}
+            </>
+          )}
+
+          {canPay && (
+            <>
+              <Divider label="Record payment" labelPosition="left" />
+              <Group align="flex-end">
+                <NumberInput
+                  label="Amount"
+                  min={0}
+                  value={payAmount}
+                  onChange={(v) => setPayAmount(v === '' ? '' : Number(v))}
+                  style={{ flex: 1 }}
+                />
+                <Button color="green" leftSection={<CreditCard size={16} />} loading={pay.isPending} onClick={handlePay}>
+                  Pay
+                </Button>
+              </Group>
+            </>
+          )}
+
+          <Group justify="flex-end" mt="sm">
+            {inv.status !== 'PAID' && inv.status !== 'CANCELLED' && (
+              <Button variant="light" color="red" leftSection={<Ban size={16} />} loading={cancel.isPending} onClick={handleCancel}>
+                Cancel invoice
+              </Button>
+            )}
+          </Group>
+        </Stack>
+      )}
+    </Modal>
+  );
+}
diff --git a/apps/edr-freight-web/backoffice/src/pages/warehouses/WarehouseListPage.tsx b/apps/edr-freight-web/backoffice/src/pages/warehouses/WarehouseListPage.tsx
new file mode 100644
index 000000000..b0d71834e
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/pages/warehouses/WarehouseListPage.tsx
@@ -0,0 +1,85 @@
+import { useMemo, useState } from 'react';
+import { useNavigate } from 'react-router-dom';
+import { Button, Card, Center, Container, Group, Loader, Stack, Text, Title } from '@mantine/core';
+import { useDebouncedValue } from '@mantine/hooks';
+import { Plus } from 'lucide-react';
+
+import Breadcrumbs from '@/components/ui/Breadcrumbs';
+import {
+  CreateWarehouseModal,
+  WarehouseCardView,
+  WarehouseFilters,
+  WarehouseTable,
+  type WarehouseView,
+} from '@/components/warehouses';
+import { useWarehouses } from '@/hooks/useWarehouses';
+import type { Warehouse, WarehouseFilter } from '@/types/warehouse';
+
+export default function WarehouseListPage() {
+  const navigate = useNavigate();
+  const [filter, setFilter] = useState<WarehouseFilter>({});
+  const [view, setView] = useState<WarehouseView>('table');
+  const [modalOpen, setModalOpen] = useState(false);
+  const [editing, setEditing] = useState<Warehouse | null>(null);
+
+  const [debouncedSearch] = useDebouncedValue(filter.search, 300);
+  const queryFilter = useMemo<WarehouseFilter>(
+    () => ({ ...filter, search: debouncedSearch }),
+    [filter, debouncedSearch],
+  );
+
+  const { data, isLoading, isError } = useWarehouses(queryFilter);
+  const warehouses = data ?? [];
+
+  const openCreate = () => {
+    setEditing(null);
+    setModalOpen(true);
+  };
+  const openEdit = (warehouse: Warehouse) => {
+    setEditing(warehouse);
+    setModalOpen(true);
+  };
+  const openDetail = (warehouse: Warehouse) => navigate(`/dashboard/warehouses/${warehouse.id}`);
+
+  return (
+    <Container size="xxl" py="lg">
+      <Breadcrumbs items={[{ label: 'Warehouses' }]} />
+
+      <Stack gap="lg" mt="sm">
+        <Group justify="space-between" align="flex-end">
+          <div>
+            <Title order={2}>Warehouses</Title>
+            <Text c="dimmed" size="sm">
+              Manage warehouses, yards and zones.
+            </Text>
+          </div>
+          <Button leftSection={<Plus size={16} />} onClick={openCreate}>
+            Create Warehouse
+          </Button>
+        </Group>
+
+        <Card withBorder radius="md" padding="lg">
+          <Stack gap="md">
+            <WarehouseFilters filter={filter} onChange={setFilter} view={view} onViewChange={setView} />
+
+            {isLoading ? (
+              <Center py="xl">
+                <Loader />
+              </Center>
+            ) : isError ? (
+              <Text c="red" ta="center" py="xl">
+                Failed to load warehouses.
+              </Text>
+            ) : view === 'table' ? (
+              <WarehouseTable warehouses={warehouses} onView={openDetail} onEdit={openEdit} />
+            ) : (
+              <WarehouseCardView warehouses={warehouses} onView={openDetail} onEdit={openEdit} />
+            )}
+          </Stack>
+        </Card>
+      </Stack>
+
+      <CreateWarehouseModal opened={modalOpen} onClose={() => setModalOpen(false)} warehouse={editing} />
+    </Container>
+  );
+}
diff --git a/apps/edr-freight-web/backoffice/src/pages/warehouses/WarehouseRulesPage.tsx b/apps/edr-freight-web/backoffice/src/pages/warehouses/WarehouseRulesPage.tsx
new file mode 100644
index 000000000..1bfce1de1
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/pages/warehouses/WarehouseRulesPage.tsx
@@ -0,0 +1,285 @@
+import { useState } from 'react';
+import {
+  ActionIcon,
+  Badge,
+  Button,
+  Card,
+  Container,
+  Group,
+  Loader,
+  Modal,
+  NumberInput,
+  Select,
+  Stack,
+  Table,
+  Tabs,
+  Text,
+  TextInput,
+} from '@mantine/core';
+import { Plus, Trash2 } from 'lucide-react';
+
+import Breadcrumbs from '@/components/ui/Breadcrumbs';
+import { WarehouseHero } from '@/components/warehouses';
+import { useToast } from '@/hooks/use-toast';
+import {
+  useAllocationRules,
+  useCreateAllocationRule,
+  useCreateFeeRule,
+  useDeleteAllocationRule,
+  useDeleteFeeRule,
+  useFeeRules,
+} from '@/hooks/useWarehouses';
+import { FEE_RULE_TYPES, type FeeRuleType } from '@/types/warehouse';
+
+const FREIGHT = [
+  { value: 'CONTAINER', label: 'Container' },
+  { value: 'BULK', label: 'Bulk' },
+];
+const TRADE = [
+  { value: 'IMPORT', label: 'Import' },
+  { value: 'EXPORT', label: 'Export' },
+  { value: 'DOMESTIC', label: 'Domestic' },
+];
+
+const clean = (s: string) => s.trim() || undefined;
+
+export default function WarehouseRulesPage() {
+  return (
+    <Container size="xxl" py="lg">
+      <Breadcrumbs items={[{ label: 'Warehouse rules' }]} />
+      <Stack gap="lg" mt="sm">
+        <WarehouseHero
+          variant="warehouse"
+          secondaryVariant="container"
+          title="Allocation & Fee Rules"
+          subtitle="Configure deterministic yard allocation and storage / demurrage free time and rates."
+        />
+        <Card withBorder radius="md" padding="lg">
+          <Tabs defaultValue="allocation">
+            <Tabs.List>
+              <Tabs.Tab value="allocation">Allocation Rules</Tabs.Tab>
+              <Tabs.Tab value="fees">Storage / Demurrage Fees</Tabs.Tab>
+            </Tabs.List>
+            <Tabs.Panel value="allocation" pt="md">
+              <AllocationRules />
+            </Tabs.Panel>
+            <Tabs.Panel value="fees" pt="md">
+              <FeeRules />
+            </Tabs.Panel>
+          </Tabs>
+        </Card>
+      </Stack>
+    </Container>
+  );
+}
+
+function AllocationRules() {
+  const { toast } = useToast();
+  const { data, isLoading } = useAllocationRules();
+  const create = useCreateAllocationRule();
+  const remove = useDeleteAllocationRule();
+  const [open, setOpen] = useState(false);
+  const [form, setForm] = useState({
+    name: '',
+    priority: 100,
+    freightType: '',
+    tradeDirection: '',
+    cargoTypeCode: '',
+    containerStatus: '',
+    targetYardCode: '',
+    storageType: '',
+  });
+  const rules = data ?? [];
+
+  const submit = async () => {
+    if (!form.name.trim() || !form.targetYardCode.trim()) {
+      toast({ variant: 'destructive', title: 'Name and target yard code are required' });
+      return;
+    }
+    await create.mutateAsync({
+      name: form.name.trim(),
+      priority: form.priority,
+      freightType: clean(form.freightType) ?? null,
+      tradeDirection: clean(form.tradeDirection) ?? null,
+      cargoTypeCode: clean(form.cargoTypeCode) ?? null,
+      containerStatus: clean(form.containerStatus) ?? null,
+      targetYardCode: form.targetYardCode.trim(),
+      storageType: clean(form.storageType) ?? null,
+      isActive: true,
+    } as never);
+    toast({ title: 'Allocation rule created' });
+    setOpen(false);
+    setForm({ name: '', priority: 100, freightType: '', tradeDirection: '', cargoTypeCode: '', containerStatus: '', targetYardCode: '', storageType: '' });
+  };
+
+  return (
+    <>
+      <Group justify="space-between" mb="sm">
+        <Text c="dimmed" size="sm">{rules.length} rule(s) — matched by ascending priority</Text>
+        <Button color="orange" leftSection={<Plus size={16} />} onClick={() => setOpen(true)}>New allocation rule</Button>
+      </Group>
+      {isLoading ? (
+        <Group justify="center" py="xl"><Loader /></Group>
+      ) : (
+        <Table.ScrollContainer minWidth={900}>
+          <Table striped highlightOnHover verticalSpacing="sm">
+            <Table.Thead>
+              <Table.Tr>
+                <Table.Th>Priority</Table.Th><Table.Th>Name</Table.Th><Table.Th>Freight</Table.Th>
+                <Table.Th>Trade</Table.Th><Table.Th>Cargo code</Table.Th><Table.Th>Target yard</Table.Th>
+                <Table.Th>Active</Table.Th><Table.Th ta="right">Actions</Table.Th>
+              </Table.Tr>
+            </Table.Thead>
+            <Table.Tbody>
+              {rules.map((r) => (
+                <Table.Tr key={r.id}>
+                  <Table.Td>{r.priority}</Table.Td>
+                  <Table.Td>{r.name}</Table.Td>
+                  <Table.Td>{r.freightType ?? '—'}</Table.Td>
+                  <Table.Td>{r.tradeDirection ?? '—'}</Table.Td>
+                  <Table.Td>{r.cargoTypeCode ?? '—'}</Table.Td>
+                  <Table.Td><Badge variant="light">{r.targetYardCode}</Badge></Table.Td>
+                  <Table.Td><Badge color={r.isActive ? 'green' : 'gray'} variant="light">{r.isActive ? 'Yes' : 'No'}</Badge></Table.Td>
+                  <Table.Td ta="right">
+                    <ActionIcon variant="subtle" color="red" onClick={() => remove.mutate(r.id)} title="Delete">
+                      <Trash2 size={16} />
+                    </ActionIcon>
+                  </Table.Td>
+                </Table.Tr>
+              ))}
+            </Table.Tbody>
+          </Table>
+        </Table.ScrollContainer>
+      )}
+
+      <Modal opened={open} onClose={() => setOpen(false)} title="New allocation rule" centered size="lg">
+        <Stack gap="sm">
+          <Group grow>
+            <TextInput label="Name" required value={form.name} onChange={(e) => setForm((f) => ({ ...f, name: e.currentTarget.value }))} />
+            <NumberInput label="Priority" value={form.priority} onChange={(v) => setForm((f) => ({ ...f, priority: Number(v) || 100 }))} />
+          </Group>
+          <Group grow>
+            <Select label="Freight type" data={FREIGHT} value={form.freightType || null} onChange={(v) => setForm((f) => ({ ...f, freightType: v ?? '' }))} clearable />
+            <Select label="Trade direction" data={TRADE} value={form.tradeDirection || null} onChange={(v) => setForm((f) => ({ ...f, tradeDirection: v ?? '' }))} clearable />
+          </Group>
+          <Group grow>
+            <TextInput label="Cargo type code" value={form.cargoTypeCode} onChange={(e) => setForm((f) => ({ ...f, cargoTypeCode: e.currentTarget.value }))} />
+            <TextInput label="Container status" placeholder="e.g. MAINTENANCE" value={form.containerStatus} onChange={(e) => setForm((f) => ({ ...f, containerStatus: e.currentTarget.value }))} />
+          </Group>
+          <Group grow>
+            <TextInput label="Target yard code" required value={form.targetYardCode} onChange={(e) => setForm((f) => ({ ...f, targetYardCode: e.currentTarget.value }))} />
+            <TextInput label="Storage type" value={form.storageType} onChange={(e) => setForm((f) => ({ ...f, storageType: e.currentTarget.value }))} />
+          </Group>
+          <Group justify="flex-end" mt="sm">
+            <Button variant="default" onClick={() => setOpen(false)}>Cancel</Button>
+            <Button color="orange" loading={create.isPending} onClick={submit}>Create</Button>
+          </Group>
+        </Stack>
+      </Modal>
+    </>
+  );
+}
+
+function FeeRules() {
+  const { toast } = useToast();
+  const { data, isLoading } = useFeeRules();
+  const create = useCreateFeeRule();
+  const remove = useDeleteFeeRule();
+  const [open, setOpen] = useState(false);
+  const [form, setForm] = useState({
+    name: '',
+    ruleType: 'DEMURRAGE_FEE' as FeeRuleType,
+    freightType: '',
+    tradeDirection: '',
+    cargoTypeCode: '',
+    freeDays: 3,
+    ratePerDay: 0,
+    currency: 'USD',
+  });
+  const rules = data ?? [];
+
+  const submit = async () => {
+    if (!form.name.trim()) {
+      toast({ variant: 'destructive', title: 'Name is required' });
+      return;
+    }
+    await create.mutateAsync({
+      name: form.name.trim(),
+      ruleType: form.ruleType,
+      freightType: clean(form.freightType) ?? null,
+      tradeDirection: clean(form.tradeDirection) ?? null,
+      cargoTypeCode: clean(form.cargoTypeCode) ?? null,
+      freeDays: form.freeDays,
+      ratePerDay: form.ratePerDay,
+      currency: form.currency || 'USD',
+      isActive: true,
+    } as never);
+    toast({ title: 'Fee rule created' });
+    setOpen(false);
+  };
+
+  return (
+    <>
+      <Group justify="space-between" mb="sm">
+        <Text c="dimmed" size="sm">{rules.length} rule(s) — most specific match applies</Text>
+        <Button color="teal" leftSection={<Plus size={16} />} onClick={() => setOpen(true)}>New fee rule</Button>
+      </Group>
+      {isLoading ? (
+        <Group justify="center" py="xl"><Loader /></Group>
+      ) : (
+        <Table.ScrollContainer minWidth={900}>
+          <Table striped highlightOnHover verticalSpacing="sm">
+            <Table.Thead>
+              <Table.Tr>
+                <Table.Th>Type</Table.Th><Table.Th>Name</Table.Th><Table.Th>Freight</Table.Th>
+                <Table.Th>Trade</Table.Th><Table.Th>Free days</Table.Th><Table.Th>Rate / day</Table.Th>
+                <Table.Th>Active</Table.Th><Table.Th ta="right">Actions</Table.Th>
+              </Table.Tr>
+            </Table.Thead>
+            <Table.Tbody>
+              {rules.map((r) => (
+                <Table.Tr key={r.id}>
+                  <Table.Td><Badge color={r.ruleType === 'DEMURRAGE_FEE' ? 'orange' : 'teal'} variant="light">{r.ruleType === 'DEMURRAGE_FEE' ? 'Demurrage' : 'Storage'}</Badge></Table.Td>
+                  <Table.Td>{r.name}</Table.Td>
+                  <Table.Td>{r.freightType ?? '—'}</Table.Td>
+                  <Table.Td>{r.tradeDirection ?? '—'}</Table.Td>
+                  <Table.Td>{r.freeDays}</Table.Td>
+                  <Table.Td>{Number(r.ratePerDay).toLocaleString()} {r.currency}</Table.Td>
+                  <Table.Td><Badge color={r.isActive ? 'green' : 'gray'} variant="light">{r.isActive ? 'Yes' : 'No'}</Badge></Table.Td>
+                  <Table.Td ta="right">
+                    <ActionIcon variant="subtle" color="red" onClick={() => remove.mutate(r.id)} title="Delete">
+                      <Trash2 size={16} />
+                    </ActionIcon>
+                  </Table.Td>
+                </Table.Tr>
+              ))}
+            </Table.Tbody>
+          </Table>
+        </Table.ScrollContainer>
+      )}
+
+      <Modal opened={open} onClose={() => setOpen(false)} title="New fee rule" centered size="lg">
+        <Stack gap="sm">
+          <Group grow>
+            <TextInput label="Name" required value={form.name} onChange={(e) => setForm((f) => ({ ...f, name: e.currentTarget.value }))} />
+            <Select label="Rule type" data={FEE_RULE_TYPES.map((t) => ({ value: t, label: t === 'DEMURRAGE_FEE' ? 'Demurrage' : 'Storage' }))} value={form.ruleType} onChange={(v) => setForm((f) => ({ ...f, ruleType: (v as FeeRuleType) ?? 'DEMURRAGE_FEE' }))} allowDeselect={false} />
+          </Group>
+          <Group grow>
+            <Select label="Freight type" data={FREIGHT} value={form.freightType || null} onChange={(v) => setForm((f) => ({ ...f, freightType: v ?? '' }))} clearable />
+            <Select label="Trade direction" data={TRADE} value={form.tradeDirection || null} onChange={(v) => setForm((f) => ({ ...f, tradeDirection: v ?? '' }))} clearable />
+            <TextInput label="Cargo type code" value={form.cargoTypeCode} onChange={(e) => setForm((f) => ({ ...f, cargoTypeCode: e.currentTarget.value }))} />
+          </Group>
+          <Group grow>
+            <NumberInput label="Free days" min={0} value={form.freeDays} onChange={(v) => setForm((f) => ({ ...f, freeDays: Number(v) || 0 }))} />
+            <NumberInput label="Rate / day" min={0} value={form.ratePerDay} onChange={(v) => setForm((f) => ({ ...f, ratePerDay: Number(v) || 0 }))} />
+            <TextInput label="Currency" value={form.currency} onChange={(e) => setForm((f) => ({ ...f, currency: e.currentTarget.value }))} />
+          </Group>
+          <Group justify="flex-end" mt="sm">
+            <Button variant="default" onClick={() => setOpen(false)}>Cancel</Button>
+            <Button color="teal" loading={create.isPending} onClick={submit}>Create</Button>
+          </Group>
+        </Stack>
+      </Modal>
+    </>
+  );
+}
diff --git a/apps/edr-freight-web/backoffice/src/services/cargoService.ts b/apps/edr-freight-web/backoffice/src/services/cargoService.ts
index 2e36f4aa3..a7451f28a 100644
--- a/apps/edr-freight-web/backoffice/src/services/cargoService.ts
+++ b/apps/edr-freight-web/backoffice/src/services/cargoService.ts
@@ -15,6 +15,15 @@ export interface Cargo {
   status: 'PENDING' | 'LOADED' | 'IN_TRANSIT' | 'DELIVERED' | 'UNLOADED';
   loadedAt?: string;
   unloadedAt?: string;
+  receiverName?: string | null;
+  deliveredAt?: string | null;
+  deliveryRemarks?: string | null;
+}
+
+export interface DeliverCargoPayload {
+  receiverName?: string;
+  pickupDate?: string;
+  deliveryRemarks?: string;
 }
 
 export const cargoService = {
@@ -26,6 +35,7 @@ export const cargoService = {
   delete: (id: string) => apiClient.delete(`/cargoes/${id}`),
   load: (cargoId: string, quantity: number, weight: number, volume?: number) =>
     apiClient.post(`/cargoes/${cargoId}/load`, { quantity, weight, volume }),
-  deliver: (cargoId: string) => apiClient.post(`/cargoes/${cargoId}/deliver`),
+  deliver: (cargoId: string, payload?: DeliverCargoPayload) =>
+    apiClient.post(`/cargoes/${cargoId}/deliver`, payload ?? {}),
   unload: (cargoId: string) => apiClient.post(`/cargoes/${cargoId}/unload`),
 };
diff --git a/apps/edr-freight-web/backoffice/src/services/facility.service.ts b/apps/edr-freight-web/backoffice/src/services/facility.service.ts
new file mode 100644
index 000000000..43477f59a
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/services/facility.service.ts
@@ -0,0 +1,9 @@
+import { api as apiClient } from '../auth/http';
+
+import { URL_CONSTANTS } from '@/constants/URLS';
+import type { Facility } from '@/types/warehouse';
+
+export const facilityService = {
+  list: () => apiClient.get<Facility[]>(URL_CONSTANTS.FACILITIES.BASE),
+  getById: (id: string) => apiClient.get<Facility>(URL_CONSTANTS.FACILITIES.BY_ID(id)),
+};
diff --git a/apps/edr-freight-web/backoffice/src/services/locomotives.service.ts b/apps/edr-freight-web/backoffice/src/services/locomotives.service.ts
index 5defd7a74..f904eec5c 100644
--- a/apps/edr-freight-web/backoffice/src/services/locomotives.service.ts
+++ b/apps/edr-freight-web/backoffice/src/services/locomotives.service.ts
@@ -5,6 +5,9 @@ import { URL_CONSTANTS } from '@/constants/URLS';
 export type LocomotiveType = 'DIESEL' | 'ELECTRIC';
 export type LocomotiveStatus =
   | 'AVAILABLE'
+  | 'UNAVAILABLE'
+  | 'IMPORT_READY'
+  | 'EXPORT_READY'
   | 'MAINTENANCE'
   | 'ASSIGNED'
   | 'OUT_OF_SERVICE';
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 8a33e7738..da7b2b509 100644
--- a/apps/edr-freight-web/backoffice/src/services/wagon.service.ts
+++ b/apps/edr-freight-web/backoffice/src/services/wagon.service.ts
@@ -8,6 +8,19 @@ export interface Wagon {
   wagonTypeId: string;
   trainId: string | null;
   sequenceNumber: number | null;
+  currentLocationYardId: string | null;
+  currentLocationYard?: {
+    id: string;
+    code: string;
+    label: string;
+    country?: string;
+  } | null;
+  wagonType?: {
+    id: string;
+    code: string;
+    name: string;
+    supportedLoadTypes?: string[];
+  } | null;
   tareWeight: number;
   maxPayloadWeight: number;
   status: Freight.WagonStatus;
diff --git a/apps/edr-freight-web/backoffice/src/services/warehouse.service.ts b/apps/edr-freight-web/backoffice/src/services/warehouse.service.ts
new file mode 100644
index 000000000..f40d604b9
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/services/warehouse.service.ts
@@ -0,0 +1,199 @@
+import { api as apiClient } from '../auth/http';
+
+import { URL_CONSTANTS } from '@/constants/URLS';
+import type {
+  AllocationCriteria,
+  AllocationPreviewResult,
+  AllocationRule,
+  ArrivalQueueItem,
+  AutoLoadResult,
+  AutoUnloadResult,
+  FeePreview,
+  FeeRule,
+  InspectionAttachment,
+  InspectionReport,
+  InspectionReportPayload,
+  SaveAllocationRulePayload,
+  SaveFeeRulePayload,
+  WarehouseFeeInvoice,
+  WarehouseInvoiceFilter,
+  PayInvoicePayload,
+  BookingScheduleView,
+  InventoryFilter,
+  InventoryInquiryFilter,
+  InventoryInquiryResult,
+  InventoryMovement,
+  LoadableWagon,
+  LoadInventoryPayload,
+  MoveInventoryPayload,
+  ReceiveInventoryPayload,
+  ReserveInventoryPayload,
+  SaveWarehousePayload,
+  SaveYardPayload,
+  SaveZonePayload,
+  Warehouse,
+  WarehouseActivityLog,
+  WarehouseDashboard,
+  WarehouseFilter,
+  WarehouseInventoryItem,
+  WarehouseLoading,
+  WarehouseYard,
+  WarehouseZone,
+} from '@/types/warehouse';
+
+const cleanParams = (params: object) =>
+  Object.fromEntries(
+    Object.entries(params).filter(([, value]) => value !== undefined && value !== '' && value !== null),
+  );
+
+export const warehouseService = {
+  // ── Warehouses ──────────────────────────────────────────────────────────
+  list: (filter?: WarehouseFilter) =>
+    apiClient.get<Warehouse[]>(URL_CONSTANTS.WAREHOUSES.BASE, {
+      params: cleanParams(filter ?? {}),
+    }),
+  dashboard: () => apiClient.get<WarehouseDashboard>(URL_CONSTANTS.WAREHOUSES.DASHBOARD),
+  getById: (id: string) => apiClient.get<Warehouse>(URL_CONSTANTS.WAREHOUSES.BY_ID(id)),
+  create: (payload: SaveWarehousePayload) =>
+    apiClient.post<Warehouse>(URL_CONSTANTS.WAREHOUSES.BASE, payload),
+  update: (id: string, payload: Partial<SaveWarehousePayload>) =>
+    apiClient.patch<Warehouse>(URL_CONSTANTS.WAREHOUSES.BY_ID(id), payload),
+
+  // ── Yards ────────────────────────────────────────────────────────────────
+  listYards: (warehouseId: string) =>
+    apiClient.get<WarehouseYard[]>(URL_CONSTANTS.WAREHOUSES.YARDS(warehouseId)),
+  createYard: (warehouseId: string, payload: SaveYardPayload) =>
+    apiClient.post<WarehouseYard>(URL_CONSTANTS.WAREHOUSES.YARDS(warehouseId), payload),
+  getYard: (id: string) => apiClient.get<WarehouseYard>(URL_CONSTANTS.WAREHOUSE_YARDS.BY_ID(id)),
+  updateYard: (id: string, payload: Partial<SaveYardPayload>) =>
+    apiClient.patch<WarehouseYard>(URL_CONSTANTS.WAREHOUSE_YARDS.BY_ID(id), payload),
+
+  // ── Zones ──────────────────────────────────────────────────────────────
+  listZones: (yardId: string) =>
+    apiClient.get<WarehouseZone[]>(URL_CONSTANTS.WAREHOUSE_YARDS.ZONES(yardId)),
+  createZone: (yardId: string, payload: SaveZonePayload) =>
+    apiClient.post<WarehouseZone>(URL_CONSTANTS.WAREHOUSE_YARDS.ZONES(yardId), payload),
+  getZone: (id: string) => apiClient.get<WarehouseZone>(URL_CONSTANTS.WAREHOUSE_ZONES.BY_ID(id)),
+  updateZone: (id: string, payload: Partial<SaveZonePayload>) =>
+    apiClient.patch<WarehouseZone>(URL_CONSTANTS.WAREHOUSE_ZONES.BY_ID(id), payload),
+
+  // ── Inventory ──────────────────────────────────────────────────────────
+  listInventory: (filter?: InventoryFilter) =>
+    apiClient.get<WarehouseInventoryItem[]>(URL_CONSTANTS.WAREHOUSE_INVENTORY.BASE, {
+      params: cleanParams(filter ?? {}),
+    }),
+  receiveInventory: (payload: ReceiveInventoryPayload) =>
+    apiClient.post<WarehouseInventoryItem>(URL_CONSTANTS.WAREHOUSE_INVENTORY.RECEIVE, payload),
+  listReadyForLoading: (filter?: InventoryFilter) =>
+    apiClient.get<WarehouseInventoryItem[]>(URL_CONSTANTS.WAREHOUSE_INVENTORY.READY_FOR_LOADING, {
+      params: cleanParams(filter ?? {}),
+    }),
+  inquiry: (filter: InventoryInquiryFilter) =>
+    apiClient.get<InventoryInquiryResult[]>(URL_CONSTANTS.WAREHOUSE_INVENTORY.INQUIRY, {
+      params: cleanParams(filter ?? {}),
+    }),
+
+  // ── Lifecycle (Batch 2) ──────────────────────────────────────────────────
+  store: (id: string) =>
+    apiClient.post<WarehouseInventoryItem>(URL_CONSTANTS.WAREHOUSE_INVENTORY.STORE(id)),
+  reserve: (payload: ReserveInventoryPayload) =>
+    apiClient.post<WarehouseInventoryItem>(URL_CONSTANTS.WAREHOUSE_INVENTORY.RESERVE, payload),
+  markReadyForLoading: (id: string) =>
+    apiClient.post<WarehouseInventoryItem>(URL_CONSTANTS.WAREHOUSE_INVENTORY.MARK_READY(id)),
+  load: (id: string, payload: LoadInventoryPayload) =>
+    apiClient.post<WarehouseInventoryItem>(URL_CONSTANTS.WAREHOUSE_INVENTORY.LOAD(id), payload),
+  dispatch: (id: string) =>
+    apiClient.patch<WarehouseInventoryItem>(URL_CONSTANTS.WAREHOUSE_INVENTORY.DISPATCH(id)),
+  move: (id: string, payload: MoveInventoryPayload) =>
+    apiClient.post<WarehouseInventoryItem>(URL_CONSTANTS.WAREHOUSE_INVENTORY.MOVE(id), payload),
+  movements: (id: string) =>
+    apiClient.get<InventoryMovement[]>(URL_CONSTANTS.WAREHOUSE_INVENTORY.MOVEMENTS(id)),
+  activity: (id: string) =>
+    apiClient.get<WarehouseActivityLog[]>(URL_CONSTANTS.WAREHOUSE_INVENTORY.ACTIVITY(id)),
+
+  // ── Loading (Batch 3) ─────────────────────────────────────────────────────
+  loadableWagons: () =>
+    apiClient.get<LoadableWagon[]>(URL_CONSTANTS.WAREHOUSE_INVENTORY.LOADABLE_WAGONS),
+  bookingSchedule: (bookingId: string) =>
+    apiClient.get<BookingScheduleView>(URL_CONSTANTS.WAREHOUSE_INVENTORY.BOOKING_SCHEDULE(bookingId)),
+  inventoryLoadings: (id: string) =>
+    apiClient.get<WarehouseLoading[]>(URL_CONSTANTS.WAREHOUSE_INVENTORY.LOADINGS(id)),
+  loadings: (params?: { bookingId?: string; wagonId?: string }) =>
+    apiClient.get<WarehouseLoading[]>(URL_CONSTANTS.WAREHOUSE_LOADINGS.BASE, {
+      params: cleanParams(params ?? {}),
+    }),
+
+  // ── Batch 4.5: Arrival / Unload / Load automation ──────────────────────────
+  arrivalQueue: () =>
+    apiClient.get<ArrivalQueueItem[]>(URL_CONSTANTS.WAREHOUSE_INVENTORY.ARRIVAL_QUEUE),
+  autoUnloadArrived: () =>
+    apiClient.post<AutoUnloadResult>(URL_CONSTANTS.WAREHOUSE_INVENTORY.AUTO_UNLOAD_ARRIVED),
+  autoLoadReady: () =>
+    apiClient.post<AutoLoadResult>(URL_CONSTANTS.WAREHOUSE_INVENTORY.AUTO_LOAD_READY),
+  unloadBooking: (bookingId: string, payload?: Record<string, unknown>) =>
+    apiClient.post<WarehouseInventoryItem>(
+      URL_CONSTANTS.WAREHOUSE_INVENTORY.UNLOAD_BOOKING(bookingId),
+      payload ?? {},
+    ),
+
+  // ── Batch 4.5: Inspection reports ──────────────────────────────────────────
+  listInspectionReports: (inventoryId: string) =>
+    apiClient.get<InspectionReport[]>(URL_CONSTANTS.WAREHOUSE_INVENTORY.INSPECTION_REPORTS(inventoryId)),
+  createInspectionReport: (inventoryId: string, payload: InspectionReportPayload) =>
+    apiClient.post<InspectionReport>(
+      URL_CONSTANTS.WAREHOUSE_INVENTORY.INSPECTION_REPORTS(inventoryId),
+      payload,
+    ),
+  getInspectionReport: (id: string) =>
+    apiClient.get<InspectionReport>(URL_CONSTANTS.WAREHOUSE_INSPECTION.BY_ID(id)),
+  uploadInspectionAttachments: (id: string, files: File[]) => {
+    const form = new FormData();
+    files.forEach((file) => form.append('files', file));
+    return apiClient.post<InspectionAttachment[]>(
+      URL_CONSTANTS.WAREHOUSE_INSPECTION.ATTACHMENTS(id),
+      form,
+      { headers: { 'Content-Type': 'multipart/form-data' } },
+    );
+  },
+
+  // ── Batch 5: Allocation + Fee rules / previews ─────────────────────────────
+  listAllocationRules: () =>
+    apiClient.get<AllocationRule[]>(URL_CONSTANTS.WAREHOUSE_RULES.ALLOCATION),
+  createAllocationRule: (payload: SaveAllocationRulePayload) =>
+    apiClient.post<AllocationRule>(URL_CONSTANTS.WAREHOUSE_RULES.ALLOCATION, payload),
+  updateAllocationRule: (id: string, payload: Partial<SaveAllocationRulePayload>) =>
+    apiClient.patch<AllocationRule>(URL_CONSTANTS.WAREHOUSE_RULES.ALLOCATION_BY_ID(id), payload),
+  deleteAllocationRule: (id: string) =>
+    apiClient.delete(URL_CONSTANTS.WAREHOUSE_RULES.ALLOCATION_BY_ID(id)),
+  previewAllocation: (criteria: AllocationCriteria) =>
+    apiClient.post<AllocationPreviewResult | null>(URL_CONSTANTS.WAREHOUSE_RULES.ALLOCATION_PREVIEW, criteria),
+
+  listFeeRules: () => apiClient.get<FeeRule[]>(URL_CONSTANTS.WAREHOUSE_RULES.FEES),
+  createFeeRule: (payload: SaveFeeRulePayload) =>
+    apiClient.post<FeeRule>(URL_CONSTANTS.WAREHOUSE_RULES.FEES, payload),
+  updateFeeRule: (id: string, payload: Partial<SaveFeeRulePayload>) =>
+    apiClient.patch<FeeRule>(URL_CONSTANTS.WAREHOUSE_RULES.FEES_BY_ID(id), payload),
+  deleteFeeRule: (id: string) => apiClient.delete(URL_CONSTANTS.WAREHOUSE_RULES.FEES_BY_ID(id)),
+  feePreview: (inventoryId: string) =>
+    apiClient.get<FeePreview[]>(URL_CONSTANTS.WAREHOUSE_RULES.FEE_PREVIEW(inventoryId)),
+
+  // ── Batch 6: Warehouse fee invoices ────────────────────────────────────────
+  listInvoices: (filter?: WarehouseInvoiceFilter) =>
+    apiClient.get<WarehouseFeeInvoice[]>(URL_CONSTANTS.WAREHOUSE_INVOICES.BASE, {
+      params: cleanParams(filter ?? {}),
+    }),
+  getInvoice: (id: string) =>
+    apiClient.get<WarehouseFeeInvoice>(URL_CONSTANTS.WAREHOUSE_INVOICES.BY_ID(id)),
+  invoicesForInventory: (inventoryId: string) =>
+    apiClient.get<WarehouseFeeInvoice[]>(URL_CONSTANTS.WAREHOUSE_INVOICES.FOR_INVENTORY(inventoryId)),
+  invoicesForBooking: (bookingId: string) =>
+    apiClient.get<WarehouseFeeInvoice[]>(URL_CONSTANTS.WAREHOUSE_INVOICES.FOR_BOOKING(bookingId)),
+  generateInvoice: (inventoryId: string, confirmZero = false) =>
+    apiClient.post<WarehouseFeeInvoice>(URL_CONSTANTS.WAREHOUSE_INVOICES.GENERATE(inventoryId), { confirmZero }),
+  cancelInvoice: (id: string) =>
+    apiClient.patch<WarehouseFeeInvoice>(URL_CONSTANTS.WAREHOUSE_INVOICES.CANCEL(id)),
+  payInvoice: (id: string, payload: PayInvoicePayload) =>
+    apiClient.post<WarehouseFeeInvoice>(URL_CONSTANTS.WAREHOUSE_INVOICES.PAY(id), payload),
+  gateClearance: (inventoryId: string) =>
+    apiClient.post<WarehouseInventoryItem>(URL_CONSTANTS.WAREHOUSE_INVOICES.GATE_CLEARANCE(inventoryId), {}),
+};
diff --git a/apps/edr-freight-web/backoffice/src/types/booking.ts b/apps/edr-freight-web/backoffice/src/types/booking.ts
index f419ee70a..660ca7e74 100644
--- a/apps/edr-freight-web/backoffice/src/types/booking.ts
+++ b/apps/edr-freight-web/backoffice/src/types/booking.ts
@@ -6,6 +6,9 @@ export const BOOKING_STATUSES = [
   "PENDING_APPROVAL",
   "APPROVED_PENDING_SIGNATURE",
   "APPROVED",
+  "READY_FOR_ASSIGNMENT",
+  "WAGON_ASSIGNED",
+  "INVOICED",
   "CONTRACT_READY",
   "SIGNED_CUSTOMER",
   "FULLY_EXECUTED",
diff --git a/apps/edr-freight-web/backoffice/src/types/warehouse.ts b/apps/edr-freight-web/backoffice/src/types/warehouse.ts
new file mode 100644
index 000000000..15b67c3da
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/types/warehouse.ts
@@ -0,0 +1,596 @@
+export const WAREHOUSE_TYPES = ['OPEN_WAREHOUSE', 'CLOSED_WAREHOUSE'] as const;
+export type WarehouseType = (typeof WAREHOUSE_TYPES)[number];
+
+export const WAREHOUSE_STATUSES = ['ACTIVE', 'INACTIVE'] as const;
+export type WarehouseStatus = (typeof WAREHOUSE_STATUSES)[number];
+
+export const WAREHOUSE_YARD_TYPES = [
+  'CONTAINER_YARD',
+  'BULK_YARD',
+  'GENERAL_CARGO_YARD',
+  'HAZARDOUS_YARD',
+  'COLD_STORAGE_YARD',
+] as const;
+export type WarehouseYardType = (typeof WAREHOUSE_YARD_TYPES)[number];
+
+export const WAREHOUSE_ZONE_TYPES = [
+  'CONTAINER_ZONE',
+  'BULK_ZONE',
+  'GENERAL_CARGO_ZONE',
+  'HAZARDOUS_ZONE',
+  'COLD_STORAGE_ZONE',
+] as const;
+export type WarehouseZoneType = (typeof WAREHOUSE_ZONE_TYPES)[number];
+
+export const INVENTORY_STATUSES = [
+  'RECEIVED',
+  'STORED',
+  'RESERVED',
+  'READY_FOR_LOADING',
+  'LOADED',
+  'DISPATCHED',
+] as const;
+export type InventoryStatus = (typeof INVENTORY_STATUSES)[number];
+
+/** Next allowed lifecycle action keyed by current status. */
+export const INVENTORY_NEXT_ACTION: Record<InventoryStatus, InventoryAction | null> = {
+  RECEIVED: 'store',
+  STORED: 'reserve',
+  RESERVED: 'ready-for-loading',
+  READY_FOR_LOADING: 'load',
+  LOADED: 'dispatch',
+  DISPATCHED: null,
+};
+
+export type InventoryAction = 'store' | 'reserve' | 'ready-for-loading' | 'load' | 'dispatch';
+
+export interface WarehouseZone {
+  id: string;
+  yardId: string;
+  name: string;
+  code: string;
+  type: WarehouseZoneType;
+  capacityWeight: number | null;
+  capacityContainers: number | null;
+  maxWeight: number | null;
+  maxVolume: number | null;
+  currentWeight: number;
+  currentContainers: number;
+  currentVolume: number;
+  status: WarehouseStatus;
+  isActive: boolean;
+}
+
+export interface WarehouseYard {
+  id: string;
+  warehouseId: string;
+  name: string;
+  code: string;
+  type: WarehouseYardType;
+  capacityWeight: number | null;
+  capacityContainers: number | null;
+  maxWeight: number | null;
+  maxVolume: number | null;
+  currentWeight: number;
+  currentContainers: number;
+  currentVolume: number;
+  status: WarehouseStatus;
+  isActive: boolean;
+  zones?: WarehouseZone[];
+}
+
+export const FACILITY_TYPES = [
+  'PORT',
+  'DRY_PORT',
+  'TERMINAL',
+  'RAIL_YARD',
+  'WAREHOUSE_COMPLEX',
+] as const;
+export type FacilityType = (typeof FACILITY_TYPES)[number];
+
+export interface Facility {
+  id: string;
+  code: string;
+  name: string;
+  facilityType: FacilityType;
+  facilityStatus?: string;
+  locationName?: string | null;
+  city?: string | null;
+  country?: string | null;
+  isActive?: boolean;
+}
+
+export interface Warehouse {
+  id: string;
+  name: string;
+  code: string;
+  type: WarehouseType;
+  stationId: string | null;
+  facilityId: string | null;
+  facility?: Facility | null;
+  locationName: string | null;
+  capacityWeight: number | null;
+  capacityContainers: number | null;
+  maxWeight: number | null;
+  maxVolume: number | null;
+  currentWeight: number;
+  currentContainers: number;
+  currentVolume: number;
+  status: WarehouseStatus;
+  isActive: boolean;
+  yards?: WarehouseYard[];
+  createdAt?: string;
+  updatedAt?: string;
+}
+
+export interface WarehouseInventoryItem {
+  id: string;
+  warehouseId: string;
+  yardId: string;
+  zoneId: string;
+  bookingId: string | null;
+  cargoId: string | null;
+  containerId: string | null;
+  goodsId: string | null;
+  quantity: number;
+  weight: number;
+  volume: number | null;
+  status: InventoryStatus;
+  arrivedAt: string | null;
+  storedAt: string | null;
+  reservedAt: string | null;
+  inspectedAt: string | null;
+  readyForLoadingAt: string | null;
+  loadedAt: string | null;
+  dispatchedAt: string | null;
+  notes: string | null;
+  warehouse?: Warehouse | null;
+  yard?: WarehouseYard | null;
+  zone?: WarehouseZone | null;
+  booking?: InventoryBookingRef | null;
+}
+
+/** Slim booking shape returned alongside inventory for the loading queue. */
+export interface InventoryBookingRef {
+  id: string;
+  reference?: string | null;
+  status?: string | null;
+  paymentStatus?: string | null;
+}
+
+export interface InventoryMovement {
+  id: string;
+  inventoryId: string;
+  fromWarehouseId: string;
+  fromYardId: string;
+  fromZoneId: string;
+  toWarehouseId: string;
+  toYardId: string;
+  toZoneId: string;
+  remarks: string | null;
+  movedBy: string | null;
+  movedAt: string;
+}
+
+export const ACTIVITY_TYPES = [
+  'INVENTORY_RECEIVED',
+  'INVENTORY_STORED',
+  'INVENTORY_MOVED',
+  'INVENTORY_RESERVED',
+  'READY_FOR_LOADING',
+  'INVENTORY_LOADED',
+  'INVENTORY_DISPATCHED',
+] as const;
+export type ActivityType = (typeof ACTIVITY_TYPES)[number];
+
+export interface WarehouseActivityLog {
+  id: string;
+  inventoryId: string | null;
+  warehouseId: string | null;
+  activityType: ActivityType;
+  description: string | null;
+  performedBy: string | null;
+  createdAt: string;
+}
+
+export interface WarehouseDashboard {
+  totalWarehouses: number;
+  totalInventory: number;
+  receivedToday: number;
+  stored: number;
+  reserved: number;
+  readyForLoading: number;
+  loaded: number;
+  dispatched: number;
+}
+
+// ── Loading (Batch 3) ────────────────────────────────────────────────────────
+
+export interface WarehouseLoading {
+  id: string;
+  warehouseInventoryId: string;
+  bookingId: string | null;
+  wagonId: string;
+  wagonNumber?: string | null;
+  loadedAt: string;
+  loadedBy: string | null;
+  loadedWeight: number | null;
+  notes: string | null;
+  inventory?: WarehouseInventoryItem | null;
+}
+
+export interface LoadInventoryPayload {
+  wagonId: string;
+  loadedWeight?: number;
+  loadedBy?: string;
+  notes?: string;
+}
+
+/** Read-only wagon view exposed by the scheduling facade. */
+export interface LoadableWagon {
+  id: string;
+  wagonNumber: string;
+  status: string;
+  trainId: string | null;
+}
+
+/** Read-only schedule + wagon + departure status for a booking. */
+export interface BookingScheduleView {
+  schedule: {
+    id: string;
+    status: string;
+    scheduledDepartureDate: string | null;
+    scheduledArrivalDate: string | null;
+    originStationId: string | null;
+    destinationStationId: string | null;
+  } | null;
+  wagon: {
+    wagonId: string | null;
+    wagonNumber: string | null;
+    sequenceNo: number | null;
+    allocatedWeightTons: number | null;
+  } | null;
+  departureStatus: string | null;
+}
+
+export interface MoveInventoryPayload {
+  warehouseId: string;
+  yardId: string;
+  zoneId: string;
+  remarks?: string;
+}
+
+export interface ReserveInventoryPayload {
+  bookingId: string;
+  inventoryId: string;
+}
+
+export interface InventoryInquiryResult {
+  id: string;
+  bookingId: string;
+  bookingNumber: string | null;
+  customerName: string | null;
+  containerNumber: string | null;
+  cargoType: string | null;
+  cargoDescription: string | null;
+  goodsId: string | null;
+  warehouse: { id: string; name: string; code: string } | null;
+  yard: { id: string; name: string; code: string } | null;
+  zone: { id: string; name: string; code: string } | null;
+  status: InventoryStatus;
+  quantity: number;
+  weight: number;
+  arrivedAt: string | null;
+  readyForLoadingAt: string | null;
+}
+
+// ── Batch 4.5: Arrival / Unload / Inspection ────────────────────────────────
+
+export interface ArrivalQueueItem {
+  bookingId: string;
+  bookingReference: string;
+  customer: string | null;
+  cargo: string | null;
+  container: string | null;
+  facility: string | null;
+  warehouse: string | null;
+  yard: string | null;
+  zone: string | null;
+  inventoryId: string | null;
+  currentStatus: string | null;
+  arrivalDate: string | null;
+  inspectionStatus: string | null;
+  unloaded: boolean;
+}
+
+export interface AutoUnloadResult {
+  processedCount: number;
+  skippedCount: number;
+  failedCount: number;
+  results: { bookingId: string; inventoryId?: string; status: string; reason?: string }[];
+}
+
+export interface AutoLoadResult {
+  loadedCount: number;
+  skippedCount: number;
+  results: { inventoryId: string; status: string; reason?: string }[];
+}
+
+export const INSPECTION_REPORT_TYPES = [
+  'INSPECTION',
+  'DAMAGE',
+  'WEIGHT_LOSS',
+  'MISSING_ITEM',
+  'GENERAL',
+] as const;
+export type InspectionReportType = (typeof INSPECTION_REPORT_TYPES)[number];
+
+export const INSPECTION_STATUSES = ['PASSED', 'FAILED', 'NEEDS_REVIEW'] as const;
+export type InspectionResultStatus = (typeof INSPECTION_STATUSES)[number];
+
+export interface InspectionReportPayload {
+  reportType: InspectionReportType;
+  inspectionStatus: InspectionResultStatus;
+  hasDamage?: boolean;
+  damageDescription?: string;
+  hasWeightLoss?: boolean;
+  expectedWeight?: number;
+  actualWeight?: number;
+  hasMissingItems?: boolean;
+  missingItemsDescription?: string;
+  remarks?: string;
+}
+
+export interface InspectionAttachment {
+  id: string;
+  name: string;
+  url: string;
+  mimeType: string;
+  size: number;
+}
+
+export interface InspectionReport extends InspectionReportPayload {
+  id: string;
+  inventoryId: string;
+  bookingId: string | null;
+  weightLoss?: number | null;
+  inspectedAt: string | null;
+  createdAt: string;
+  attachments?: InspectionAttachment[];
+}
+
+// ── Batch 5: Allocation + Fee rules / preview ───────────────────────────────
+
+export interface AllocationRule {
+  id: string;
+  name: string;
+  priority: number;
+  freightType?: string | null;
+  tradeDirection?: string | null;
+  cargoTypeCode?: string | null;
+  containerStatus?: string | null;
+  requiresInspection?: boolean | null;
+  targetFacilityCode?: string | null;
+  targetYardCode: string;
+  targetWarehouseCode?: string | null;
+  targetZoneCode?: string | null;
+  storageType?: string | null;
+  isActive: boolean;
+}
+export type SaveAllocationRulePayload = Omit<AllocationRule, 'id'>;
+
+export const FEE_RULE_TYPES = ['STORAGE_FEE', 'DEMURRAGE_FEE'] as const;
+export type FeeRuleType = (typeof FEE_RULE_TYPES)[number];
+
+export interface FeeRule {
+  id: string;
+  name: string;
+  ruleType: FeeRuleType;
+  priority: number;
+  freightType?: string | null;
+  tradeDirection?: string | null;
+  cargoTypeCode?: string | null;
+  containerType?: string | null;
+  facilityId?: string | null;
+  warehouseId?: string | null;
+  yardId?: string | null;
+  zoneId?: string | null;
+  freeDays: number;
+  ratePerDay: number;
+  currency: string;
+  isActive: boolean;
+}
+export type SaveFeeRulePayload = Omit<FeeRule, 'id'>;
+
+export interface FeePreview {
+  ruleType: FeeRuleType;
+  ruleId: string | null;
+  ruleName: string | null;
+  freeDays: number;
+  ratePerDay: number;
+  currency: string;
+  startDate: string | null;
+  endDate: string;
+  endIsOpen: boolean;
+  elapsedDays: number;
+  chargeableDays: number;
+  amount: number;
+}
+
+export interface AllocationPreviewResult {
+  warehouseId: string;
+  yardId: string;
+  zoneId: string;
+  facilityId: string | null;
+  rule: { id: string; name: string; storageType: string | null } | null;
+  path: string;
+}
+
+export interface AllocationCriteria {
+  freightType?: string;
+  tradeDirection?: string;
+  cargoTypeCode?: string;
+  containerStatus?: string;
+  requiresInspection?: boolean;
+}
+
+// ── Batch 6: Warehouse fee invoices ─────────────────────────────────────────
+
+export const WAREHOUSE_INVOICE_STATUSES = [
+  'DRAFT',
+  'ISSUED',
+  'PARTIALLY_PAID',
+  'PAID',
+  'CANCELLED',
+] as const;
+export type WarehouseInvoiceStatus = (typeof WAREHOUSE_INVOICE_STATUSES)[number];
+
+export const WAREHOUSE_INVOICE_TYPES = ['DEMURRAGE', 'STORAGE_FEE', 'MIXED_WAREHOUSE_FEES'] as const;
+export type WarehouseInvoiceType = (typeof WAREHOUSE_INVOICE_TYPES)[number];
+
+export interface WarehouseInvoicePaymentRecord {
+  amount: number;
+  method?: string | null;
+  reference?: string | null;
+  paidAt: string;
+}
+
+export interface WarehouseFeeInvoiceItem {
+  id: string;
+  invoiceId: string;
+  feeRuleId?: string | null;
+  feeType: string;
+  description: string;
+  quantity: number;
+  unitRate: number;
+  amount: number;
+  currency: string;
+  chargeableDays?: number | null;
+  freeDays?: number | null;
+}
+
+export interface WarehouseFeeInvoice {
+  id: string;
+  invoiceNumber: string;
+  bookingId?: string | null;
+  customerId?: string | null;
+  inventoryId: string;
+  facilityId?: string | null;
+  warehouseId?: string | null;
+  yardId?: string | null;
+  zoneId?: string | null;
+  invoiceType: WarehouseInvoiceType;
+  status: WarehouseInvoiceStatus;
+  subtotalAmount: number;
+  taxAmount: number;
+  totalAmount: number;
+  paidAmount: number;
+  balanceAmount: number;
+  currency: string;
+  periodStart?: string | null;
+  periodEnd?: string | null;
+  issuedAt?: string | null;
+  dueDate?: string | null;
+  paidAt?: string | null;
+  cancelledAt?: string | null;
+  payments?: WarehouseInvoicePaymentRecord[];
+  notes?: string | null;
+  items?: WarehouseFeeInvoiceItem[];
+}
+
+export interface WarehouseInvoiceFilter {
+  status?: WarehouseInvoiceStatus;
+  invoiceType?: WarehouseInvoiceType;
+  warehouseId?: string;
+  facilityId?: string;
+  customerId?: string;
+  bookingId?: string;
+}
+
+export interface PayInvoicePayload {
+  amount: number;
+  method?: string;
+  reference?: string;
+}
+
+// ── Payloads ───────────────────────────────────────────────────────────────
+
+export interface SaveWarehousePayload {
+  name: string;
+  code: string;
+  type: WarehouseType;
+  stationId?: string;
+  facilityId?: string;
+  locationName?: string;
+  capacityWeight?: number;
+  capacityContainers?: number;
+  maxWeight?: number;
+  maxVolume?: number;
+  status?: WarehouseStatus;
+}
+
+export interface SaveYardPayload {
+  name: string;
+  code: string;
+  type: WarehouseYardType;
+  capacityWeight?: number;
+  capacityContainers?: number;
+  maxWeight?: number;
+  maxVolume?: number;
+  status?: WarehouseStatus;
+}
+
+export interface SaveZonePayload {
+  name: string;
+  code: string;
+  type: WarehouseZoneType;
+  capacityWeight?: number;
+  capacityContainers?: number;
+  maxWeight?: number;
+  maxVolume?: number;
+  status?: WarehouseStatus;
+}
+
+export interface ReceiveInventoryPayload {
+  warehouseId: string;
+  yardId: string;
+  zoneId: string;
+  bookingId: string;
+  cargoId?: string;
+  containerId?: string;
+  goodsId?: string;
+  quantity: number;
+  weight: number;
+  volume?: number;
+  notes?: string;
+}
+
+export interface WarehouseFilter {
+  search?: string;
+  type?: WarehouseType;
+  stationId?: string;
+  status?: WarehouseStatus;
+}
+
+export interface InventoryFilter {
+  warehouseId?: string;
+  yardId?: string;
+  zoneId?: string;
+  bookingId?: string;
+  cargoId?: string;
+  containerId?: string;
+  goodsId?: string;
+  status?: InventoryStatus;
+  search?: string;
+}
+
+export interface InventoryInquiryFilter {
+  bookingNumber?: string;
+  containerNumber?: string;
+  cargoType?: string;
+  goodsName?: string;
+  warehouseId?: string;
+  yardId?: string;
+  zoneId?: string;
+  status?: InventoryStatus;
+}
diff --git a/apps/edr-freight-web/backoffice/vite.config.ts.timestamp-1779977728892-a0ba1f5e8e96b.mjs b/apps/edr-freight-web/backoffice/vite.config.ts.timestamp-1779977728892-a0ba1f5e8e96b.mjs
deleted file mode 100644
index 50f04e63d..000000000
--- a/apps/edr-freight-web/backoffice/vite.config.ts.timestamp-1779977728892-a0ba1f5e8e96b.mjs
+++ /dev/null
@@ -1,24 +0,0 @@
-// vite.config.ts
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { defineConfig } from "file:///C:/laragon/www/edr-platform/node_modules/.pnpm/vite@5.4.21_@types+node@20.19.41_lightningcss@1.32.0_terser@5.48.0/node_modules/vite/dist/node/index.js";
-import react from "file:///C:/laragon/www/edr-platform/node_modules/.pnpm/@vitejs+plugin-react@4.7.0_vite@5.4.21_@types+node@20.19.41_lightningcss@1.32.0_terser@5.48.0_/node_modules/@vitejs/plugin-react/dist/index.js";
-import tailwindcss from "file:///C:/laragon/www/edr-platform/node_modules/.pnpm/@tailwindcss+vite@4.3.0_vite@5.4.21_@types+node@20.19.41_lightningcss@1.32.0_terser@5.48.0_/node_modules/@tailwindcss/vite/dist/index.mjs";
-var __vite_injected_original_import_meta_url = "file:///C:/laragon/www/edr-platform/apps/edr-freight-web/backoffice/vite.config.ts";
-var __dirname = path.dirname(fileURLToPath(__vite_injected_original_import_meta_url));
-var vite_config_default = defineConfig({
-  plugins: [react(), tailwindcss()],
-  resolve: {
-    alias: {
-      "@": path.resolve(__dirname, "./src")
-    }
-  },
-  server: {
-    port: 5183,
-    host: "0.0.0.0"
-  }
-});
-export {
-  vite_config_default as default
-};
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsidml0ZS5jb25maWcudHMiXSwKICAic291cmNlc0NvbnRlbnQiOiBbImNvbnN0IF9fdml0ZV9pbmplY3RlZF9vcmlnaW5hbF9kaXJuYW1lID0gXCJDOlxcXFxsYXJhZ29uXFxcXHd3d1xcXFxlZHItcGxhdGZvcm1cXFxcYXBwc1xcXFxlZHItZnJlaWdodC13ZWJcXFxcYmFja29mZmljZVwiO2NvbnN0IF9fdml0ZV9pbmplY3RlZF9vcmlnaW5hbF9maWxlbmFtZSA9IFwiQzpcXFxcbGFyYWdvblxcXFx3d3dcXFxcZWRyLXBsYXRmb3JtXFxcXGFwcHNcXFxcZWRyLWZyZWlnaHQtd2ViXFxcXGJhY2tvZmZpY2VcXFxcdml0ZS5jb25maWcudHNcIjtjb25zdCBfX3ZpdGVfaW5qZWN0ZWRfb3JpZ2luYWxfaW1wb3J0X21ldGFfdXJsID0gXCJmaWxlOi8vL0M6L2xhcmFnb24vd3d3L2Vkci1wbGF0Zm9ybS9hcHBzL2Vkci1mcmVpZ2h0LXdlYi9iYWNrb2ZmaWNlL3ZpdGUuY29uZmlnLnRzXCI7aW1wb3J0IHBhdGggZnJvbSBcIm5vZGU6cGF0aFwiO1xyXG5pbXBvcnQgeyBmaWxlVVJMVG9QYXRoIH0gZnJvbSBcIm5vZGU6dXJsXCI7XHJcblxyXG5pbXBvcnQgeyBkZWZpbmVDb25maWcgfSBmcm9tIFwidml0ZVwiO1xyXG5pbXBvcnQgcmVhY3QgZnJvbSBcIkB2aXRlanMvcGx1Z2luLXJlYWN0XCI7XHJcbmltcG9ydCB0YWlsd2luZGNzcyBmcm9tIFwiQHRhaWx3aW5kY3NzL3ZpdGVcIjtcclxuXHJcbmNvbnN0IF9fZGlybmFtZSA9IHBhdGguZGlybmFtZShmaWxlVVJMVG9QYXRoKGltcG9ydC5tZXRhLnVybCkpO1xyXG5cclxuZXhwb3J0IGRlZmF1bHQgZGVmaW5lQ29uZmlnKHtcclxuICBwbHVnaW5zOiBbcmVhY3QoKSwgdGFpbHdpbmRjc3MoKV0sXHJcbiAgcmVzb2x2ZToge1xyXG4gICAgYWxpYXM6IHtcclxuICAgICAgXCJAXCI6IHBhdGgucmVzb2x2ZShfX2Rpcm5hbWUsIFwiLi9zcmNcIiksXHJcbiAgICB9LFxyXG4gIH0sXHJcbiAgc2VydmVyOiB7XHJcbiAgICBwb3J0OiA1MTgzLFxyXG4gICAgaG9zdDogXCIwLjAuMC4wXCIsXHJcbiAgfSxcclxufSk7XHJcbiJdLAogICJtYXBwaW5ncyI6ICI7QUFBaVgsT0FBTyxVQUFVO0FBQ2xZLFNBQVMscUJBQXFCO0FBRTlCLFNBQVMsb0JBQW9CO0FBQzdCLE9BQU8sV0FBVztBQUNsQixPQUFPLGlCQUFpQjtBQUxtTixJQUFNLDJDQUEyQztBQU81UixJQUFNLFlBQVksS0FBSyxRQUFRLGNBQWMsd0NBQWUsQ0FBQztBQUU3RCxJQUFPLHNCQUFRLGFBQWE7QUFBQSxFQUMxQixTQUFTLENBQUMsTUFBTSxHQUFHLFlBQVksQ0FBQztBQUFBLEVBQ2hDLFNBQVM7QUFBQSxJQUNQLE9BQU87QUFBQSxNQUNMLEtBQUssS0FBSyxRQUFRLFdBQVcsT0FBTztBQUFBLElBQ3RDO0FBQUEsRUFDRjtBQUFBLEVBQ0EsUUFBUTtBQUFBLElBQ04sTUFBTTtBQUFBLElBQ04sTUFBTTtBQUFBLEVBQ1I7QUFDRixDQUFDOyIsCiAgIm5hbWVzIjogW10KfQo=
diff --git a/apps/edr-freight-web/backoffice/vite.config.ts.timestamp-1780317361001-2bf9ba3b755ae8.mjs b/apps/edr-freight-web/backoffice/vite.config.ts.timestamp-1780317361001-2bf9ba3b755ae8.mjs
deleted file mode 100644
index 33631e002..000000000
--- a/apps/edr-freight-web/backoffice/vite.config.ts.timestamp-1780317361001-2bf9ba3b755ae8.mjs
+++ /dev/null
@@ -1,24 +0,0 @@
-// vite.config.ts
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { defineConfig } from "file:///home/marshal/Desktop/EDR/edr-platform/node_modules/.pnpm/vite@5.4.21_@types+node@20.19.41_lightningcss@1.32.0_terser@5.48.0/node_modules/vite/dist/node/index.js";
-import react from "file:///home/marshal/Desktop/EDR/edr-platform/node_modules/.pnpm/@vitejs+plugin-react@4.7.0_vite@5.4.21_@types+node@20.19.41_lightningcss@1.32.0_terser@5.48.0_/node_modules/@vitejs/plugin-react/dist/index.js";
-import tailwindcss from "file:///home/marshal/Desktop/EDR/edr-platform/node_modules/.pnpm/@tailwindcss+vite@4.3.0_vite@5.4.21_@types+node@20.19.41_lightningcss@1.32.0_terser@5.48.0_/node_modules/@tailwindcss/vite/dist/index.mjs";
-var __vite_injected_original_import_meta_url = "file:///home/marshal/Desktop/EDR/edr-platform/apps/edr-freight-web/backoffice/vite.config.ts";
-var __dirname = path.dirname(fileURLToPath(__vite_injected_original_import_meta_url));
-var vite_config_default = defineConfig({
-  plugins: [react(), tailwindcss()],
-  resolve: {
-    alias: {
-      "@": path.resolve(__dirname, "./src")
-    }
-  },
-  server: {
-    port: 5183,
-    host: "0.0.0.0"
-  }
-});
-export {
-  vite_config_default as default
-};
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsidml0ZS5jb25maWcudHMiXSwKICAic291cmNlc0NvbnRlbnQiOiBbImNvbnN0IF9fdml0ZV9pbmplY3RlZF9vcmlnaW5hbF9kaXJuYW1lID0gXCIvaG9tZS9tYXJzaGFsL0Rlc2t0b3AvRURSL2Vkci1wbGF0Zm9ybS9hcHBzL2Vkci1mcmVpZ2h0LXdlYi9iYWNrb2ZmaWNlXCI7Y29uc3QgX192aXRlX2luamVjdGVkX29yaWdpbmFsX2ZpbGVuYW1lID0gXCIvaG9tZS9tYXJzaGFsL0Rlc2t0b3AvRURSL2Vkci1wbGF0Zm9ybS9hcHBzL2Vkci1mcmVpZ2h0LXdlYi9iYWNrb2ZmaWNlL3ZpdGUuY29uZmlnLnRzXCI7Y29uc3QgX192aXRlX2luamVjdGVkX29yaWdpbmFsX2ltcG9ydF9tZXRhX3VybCA9IFwiZmlsZTovLy9ob21lL21hcnNoYWwvRGVza3RvcC9FRFIvZWRyLXBsYXRmb3JtL2FwcHMvZWRyLWZyZWlnaHQtd2ViL2JhY2tvZmZpY2Uvdml0ZS5jb25maWcudHNcIjtpbXBvcnQgcGF0aCBmcm9tIFwibm9kZTpwYXRoXCI7XG5pbXBvcnQgeyBmaWxlVVJMVG9QYXRoIH0gZnJvbSBcIm5vZGU6dXJsXCI7XG5cbmltcG9ydCB7IGRlZmluZUNvbmZpZyB9IGZyb20gXCJ2aXRlXCI7XG5pbXBvcnQgcmVhY3QgZnJvbSBcIkB2aXRlanMvcGx1Z2luLXJlYWN0XCI7XG5pbXBvcnQgdGFpbHdpbmRjc3MgZnJvbSBcIkB0YWlsd2luZGNzcy92aXRlXCI7XG5cbmNvbnN0IF9fZGlybmFtZSA9IHBhdGguZGlybmFtZShmaWxlVVJMVG9QYXRoKGltcG9ydC5tZXRhLnVybCkpO1xuXG5leHBvcnQgZGVmYXVsdCBkZWZpbmVDb25maWcoe1xuICBwbHVnaW5zOiBbcmVhY3QoKSwgdGFpbHdpbmRjc3MoKV0sXG4gIHJlc29sdmU6IHtcbiAgICBhbGlhczoge1xuICAgICAgXCJAXCI6IHBhdGgucmVzb2x2ZShfX2Rpcm5hbWUsIFwiLi9zcmNcIiksXG4gICAgfSxcbiAgfSxcbiAgc2VydmVyOiB7XG4gICAgcG9ydDogNTE4MyxcbiAgICBob3N0OiBcIjAuMC4wLjBcIixcbiAgfSxcbn0pO1xuIl0sCiAgIm1hcHBpbmdzIjogIjtBQUFvWSxPQUFPLFVBQVU7QUFDclosU0FBUyxxQkFBcUI7QUFFOUIsU0FBUyxvQkFBb0I7QUFDN0IsT0FBTyxXQUFXO0FBQ2xCLE9BQU8saUJBQWlCO0FBTDROLElBQU0sMkNBQTJDO0FBT3JTLElBQU0sWUFBWSxLQUFLLFFBQVEsY0FBYyx3Q0FBZSxDQUFDO0FBRTdELElBQU8sc0JBQVEsYUFBYTtBQUFBLEVBQzFCLFNBQVMsQ0FBQyxNQUFNLEdBQUcsWUFBWSxDQUFDO0FBQUEsRUFDaEMsU0FBUztBQUFBLElBQ1AsT0FBTztBQUFBLE1BQ0wsS0FBSyxLQUFLLFFBQVEsV0FBVyxPQUFPO0FBQUEsSUFDdEM7QUFBQSxFQUNGO0FBQUEsRUFDQSxRQUFRO0FBQUEsSUFDTixNQUFNO0FBQUEsSUFDTixNQUFNO0FBQUEsRUFDUjtBQUNGLENBQUM7IiwKICAibmFtZXMiOiBbXQp9Cg==
diff --git a/apps/edr-passenger-api/prisma/migrations/20260626_fix_missing_booking_columns/migration.sql b/apps/edr-passenger-api/prisma/migrations/20260626_fix_missing_booking_columns/migration.sql
new file mode 100644
index 000000000..4f828f075
--- /dev/null
+++ b/apps/edr-passenger-api/prisma/migrations/20260626_fix_missing_booking_columns/migration.sql
@@ -0,0 +1,38 @@
+-- Fix missing columns from 20260617 migration (failed due to missing schema prefix)
+ALTER TABLE "passenger"."Booking"
+  ADD COLUMN IF NOT EXISTS "returnScheduleId"             TEXT,
+  ADD COLUMN IF NOT EXISTS "returnOriginStationId"        TEXT,
+  ADD COLUMN IF NOT EXISTS "returnDestinationStationId"   TEXT,
+  ADD COLUMN IF NOT EXISTS "returnHoldId"                 TEXT,
+  ADD COLUMN IF NOT EXISTS "returnSeatClassId"            TEXT;
+
+ALTER TABLE "passenger"."SeatClass" ALTER COLUMN "baseFareMinor" SET DEFAULT 0;
+ALTER TABLE "passenger"."Ticket" ALTER COLUMN "status" SET DEFAULT 'ACTIVE';
+
+CREATE INDEX IF NOT EXISTS "Booking_bookingType_idx" ON "passenger"."Booking"("bookingType");
+
+-- Transit leg-2 columns (never migrated)
+ALTER TABLE "passenger"."Booking"
+  ADD COLUMN IF NOT EXISTS "leg2ScheduleId"              TEXT,
+  ADD COLUMN IF NOT EXISTS "leg2OriginStationId"         TEXT,
+  ADD COLUMN IF NOT EXISTS "leg2DestinationStationId"    TEXT,
+  ADD COLUMN IF NOT EXISTS "leg2SeatClassId"             TEXT,
+  ADD COLUMN IF NOT EXISTS "returnLeg2ScheduleId"        TEXT,
+  ADD COLUMN IF NOT EXISTS "returnLeg2OriginStationId"   TEXT,
+  ADD COLUMN IF NOT EXISTS "returnLeg2DestStationId"     TEXT,
+  ADD COLUMN IF NOT EXISTS "returnLeg2SeatClassId"       TEXT;
+
+-- ReturnLegStatus enum + columns (from 20260625 migration, may have also failed)
+DO $$ BEGIN
+  CREATE TYPE "passenger"."ReturnLegStatus" AS ENUM (
+    'NOT_APPLICABLE', 'BOTH_USED', 'OUTBOUND_ONLY', 'INBOUND_ONLY', 'NEITHER_USED'
+  );
+EXCEPTION WHEN duplicate_object THEN NULL; END $$;
+
+ALTER TABLE "passenger"."Booking"
+  ADD COLUMN IF NOT EXISTS "returnLegStatus"   "passenger"."ReturnLegStatus" NOT NULL DEFAULT 'NOT_APPLICABLE',
+  ADD COLUMN IF NOT EXISTS "outboundBoardedAt" TIMESTAMP(3),
+  ADD COLUMN IF NOT EXISTS "returnBoardedAt"   TIMESTAMP(3);
+
+ALTER TABLE "passenger"."GateValidationLog"
+  ADD COLUMN IF NOT EXISTS "leg" TEXT;
diff --git a/apps/edr-passenger-api/src/main.ts b/apps/edr-passenger-api/src/main.ts
index 298e37c01..928789c04 100644
--- a/apps/edr-passenger-api/src/main.ts
+++ b/apps/edr-passenger-api/src/main.ts
@@ -35,14 +35,16 @@ async function bootstrap() {
 Enterprise-grade REST API for the Ethio-Djibouti Railway passenger booking and management platform. Built with NestJS, TypeScript, PostgreSQL, and Prisma ORM.
 
 ## Latest Updates
-- **Round-Trip Leg Tracking:** returnLegStatus on every booking tracks outbound/return leg usage (NEITHER_USED, OUTBOUND_ONLY, INBOUND_ONLY, BOTH_USED). Gate validation accepts a leg field (OUTBOUND or RETURN).
+- **TRANSIT & ROUND_TRIP_TRANSIT Booking Types:** Full multi-leg booking support. TRANSIT = single journey via connecting train (single PNR). ROUND_TRIP_TRANSIT = round trip where one or both directions use a connecting train (4 holds, 4 seat sets).
+- **returnSeatId on Passenger Payloads:** For ROUND_TRIP and ROUND_TRIP_TRANSIT bookings each passenger object must include \`returnSeatId\` (the seat on the return leg-1). Guest and authenticated booking endpoints both enforce this.
+- **Unified Booking Type Matrix:** bookingType field on Booking now accepts ONE_WAY | ROUND_TRIP | TRANSIT | ROUND_TRIP_TRANSIT across all create endpoints (POST /bookings and POST /bookings/guest).
+- **Round-Trip Leg Tracking:** returnLegStatus on every booking tracks outbound/return leg usage (NEITHER_USED, OUTBOUND_ONLY, INBOUND_ONLY, BOTH_USED). Gate validation accepts a leg field (OUTBOUND | RETURN | LEG1 | LEG2 | OUTBOUND_LEG1 | OUTBOUND_LEG2 | RETURN_LEG1 | RETURN_LEG2).
 - **Auto No-Show Detection:** Cron marks OUTBOUND_ONLY 30 min after return departure when return leg was never scanned.
 - **Offline Batch Validation:** validateOfflineBatch now accepts leg per entry and handles both legs of a round-trip in one batch.
 - **Booking Filters:** GET /bookings now accepts ?returnLegStatus= to filter no-show/inbound-only cases in back-office.
 - **Sequence Ordering:** Stations and coaches now sorted by sequence field for consistent UI display.
 - **User Profile Data:** Gender, DOB, passport, and national ID fields for comprehensive passenger profiles.
 - **Seat Class Fees:** Premium charges and insurance fees per seat class for transparent pricing.
-- **Booking Types:** Support for ONE_WAY and ROUND_TRIP booking categories.
 - **Multi-Currency Display:** Bookings track display currency and converted amounts.
 - **Ticket Lifecycle:** Tickets now include validatedAt, outboundBoardedAt, returnBoardedAt for complete audit trail.
 
@@ -61,11 +63,13 @@ Enterprise-grade REST API for the Ethio-Djibouti Railway passenger booking and m
 - Multi-segment journey support
 - Cross-border journeys via Dire Dawa transit (Ethiopia to Djibouti)
 - Round-trip booking with return journey scheduling
+- Transit booking (single journey via connecting train, single PNR, single ticket)
+- Round-trip transit booking (round trip where one or both directions use a connecting train)
 - Coach type selection with seat class and pricing options
-- NEW: Booking type tracking (ONE_WAY vs ROUND_TRIP)
-- NEW: Display currency and converted pricing per booking
-- NEW: returnLegStatus field tracks which legs of a round-trip were used
-- NEW: GET /bookings?returnLegStatus=OUTBOUND_ONLY filters no-show returns in back-office
+- Booking type field: ONE_WAY | ROUND_TRIP | TRANSIT | ROUND_TRIP_TRANSIT
+- Display currency and converted pricing per booking
+- returnLegStatus field tracks which legs of a round-trip were used
+- GET /bookings?returnLegStatus=OUTBOUND_ONLY filters no-show returns in back-office
 
 ### Passenger Verification
 1. Ethiopian Nationals:
@@ -111,21 +115,33 @@ Enterprise-grade REST API for the Ethio-Djibouti Railway passenger booking and m
 - NEW: Gate validation accepts leg (OUTBOUND or RETURN) for round-trip tickets
 - NEW: Complete audit trail per leg for compliance and reporting
 
-### Round-Trip Leg Tracking (NEW)
+### Booking Type Matrix
+
+| bookingType | Holds required | Passenger seat fields | Legs in DB |
+|---|---|---|---|
+| ONE_WAY | holdId | seatId | 1 |
+| ROUND_TRIP | holdId + returnHoldId | seatId + returnSeatId | 2 (leg=1 outbound, leg=2 return) |
+| TRANSIT | holdId + leg2HoldId | seatId + leg2SeatId | 2 (leg=1, leg=2 on same direction) |
+| ROUND_TRIP_TRANSIT | holdId + leg2HoldId + returnHoldId + returnLeg2HoldId | seatId + leg2SeatId + returnSeatId + returnLeg2SeatId | 4 |
+
+### Round-Trip Leg Tracking
 - returnLegStatus on Booking: NOT_APPLICABLE, NEITHER_USED, OUTBOUND_ONLY, INBOUND_ONLY, BOTH_USED
-- Gate validation POST /tickets/:ref/validate accepts optional leg field (OUTBOUND or RETURN)
+- Gate validation POST /tickets/:ref/validate accepts optional leg field:
+  - ONE_WAY: omit
+  - TRANSIT: LEG1 | LEG2
+  - ROUND_TRIP: OUTBOUND | RETURN
+  - ROUND_TRIP_TRANSIT: OUTBOUND_LEG1 | OUTBOUND_LEG2 | RETURN_LEG1 | RETURN_LEG2
 - Auto no-show cron: sets OUTBOUND_ONLY 30 min after return departure when return leg unscanned
 - Back-office filter: GET /bookings?returnLegStatus=OUTBOUND_ONLY surfaces no-shows
 - Offline batch: validateOfflineBatch accepts leg per entry, handles both legs of same booking
 
-### Round-Trip Booking
-- One-way and round-trip journey options
-- Flexible return date selection
-- Combined pricing for outbound + return legs
-- Separate seat management per leg
-- Independent modification/cancellation per leg
-- Return journey tracking and notifications
-- NEW: Booking type stored for analytics and reporting
+### Round-Trip & Transit Bookings
+- ONE_WAY and ROUND_TRIP for direct routes
+- TRANSIT for single connecting journey (Dire Dawa hub), single PNR
+- ROUND_TRIP_TRANSIT for round trips via connecting trains
+- Combined pricing: total = sum of all leg base fares, single promo/loyalty deduction
+- Separate seat management per leg; each leg stored with its scheduleId and leg number
+- returnLegStatus tracks which legs have been boarded for no-show management
 
 ### Loyalty Program
 - 4 tiers: Bronze, Silver, Gold, Platinum
@@ -198,26 +214,37 @@ Used for agent, fraud, and reporting endpoints. Requires corporate IAM token.
 ## Passenger Booking Flow
 
 ### Step 1: Search Trips
-\`POST /search\` with origin, destination, date, passenger counts, and nationality
+\`POST /search\` with origin, destination, date, passenger counts, and nationality.
+For round-trips also pass \`journeyType=ROUND_TRIP\` and \`returnDate\`.
 
 ### Step 2: Get Fare Quote
-\`POST /search/fare-quote\` with passenger counts and display currency
+\`POST /search/fare-quote\` with passenger counts and display currency.
+For round-trips also pass \`returnScheduleId\`, \`returnOriginStationId\`, \`returnDestinationStationId\`.
 
 ### Step 3: Passenger Information & Verification
 **For Ethiopian Passengers:**
-\`POST /passengers/verify-fayda\` - Automatic Fayda verification for adults (5+ years)
+\`POST /passengers/verify-fayda\` — Automatic Fayda verification for adults (5+ years)
 
 **For International Passengers:**
-\`POST /passengers/register-international\` - Passport information collection
+\`POST /passengers/register-international\` — Passport information collection
 
 ### Step 4: View Seat Map
-\`GET /seats/seatmap/{scheduleId}\` - Show available coaches and seats
+\`GET /seats/seatmap/{scheduleId}\` — Show available coaches and seats.
+For round-trips, call this twice: once for outbound scheduleId, once for return scheduleId.
 
-### Step 5: Login & Hold Seats
-\`POST /auth/login\` then \`POST /seats/hold\` to reserve seats for 15 minutes
+### Step 5: Hold Seats
+\`POST /seats/hold\` to reserve seats for 15 minutes.
+- ONE_WAY / TRANSIT outbound leg: one hold call → \`holdId\`
+- TRANSIT leg-2: second hold call → \`leg2HoldId\`
+- ROUND_TRIP return: second hold call → \`returnHoldId\`
+- ROUND_TRIP_TRANSIT: four hold calls → \`holdId\`, \`leg2HoldId\`, \`returnHoldId\`, \`returnLeg2HoldId\`
 
 ### Step 6: Create Booking
-\`POST /bookings/guest\` with verified passenger details and held seats
+Choose the right endpoint and bookingType:
+- **ONE_WAY** → \`POST /bookings/guest\` or \`POST /bookings\` with \`bookingType: ONE_WAY\`, passenger \`seatId\`
+- **ROUND_TRIP** → same endpoint with \`bookingType: ROUND_TRIP\`, \`returnScheduleId/returnHoldId/returnOriginStationId/returnDestinationStationId\`, passenger \`seatId + returnSeatId\`
+- **TRANSIT** → same endpoint with \`bookingType: TRANSIT\`, \`leg2ScheduleId/leg2HoldId/transitStationId/leg2DestinationStationId\`, passenger \`seatId + leg2SeatId\`
+- **ROUND_TRIP_TRANSIT** → same endpoint with \`bookingType: ROUND_TRIP_TRANSIT\`, all 4 sets of schedule/hold/station fields, passenger \`seatId + leg2SeatId + returnSeatId + returnLeg2SeatId\`
 
 ### Step 7: Process Payment
 \`POST /payments/telebirr\` (Ethiopian) or \`POST /payments/waafi\` (Djiboutian)
@@ -268,7 +295,7 @@ Payment providers send notifications to:
     .addTag("Agents", "Counter booking, shift management, commission tracking, and reconciliation")
     .addTag("Audit", "User activity logging, system changes, compliance tracking, and audit trails")
     .addTag("Auth", "Passenger registration, login, OTP, password reset, and profile management")
-    .addTag("Booking", "Complete booking lifecycle: create, modify, cancel, guest checkout. Supports returnLegStatus filter for round-trip no-show management")
+    .addTag("Booking", "Complete booking lifecycle: create, modify, cancel, guest checkout. Supports ONE_WAY | ROUND_TRIP | TRANSIT | ROUND_TRIP_TRANSIT booking types. returnLegStatus filter for round-trip no-show management")
     .addTag("Config", "System settings, feature flags, and configuration management")
     .addTag("Currencies", "Multi-currency support, exchange rates, and currency conversion")
     .addTag("Dashboard", "Home screen aggregations: trips, loyalty, wallet, notifications")
@@ -285,7 +312,6 @@ Payment providers send notifications to:
     .addTag("Payment Webhooks", "Payment provider webhook handlers and transaction confirmation")
     .addTag("Promotions", "Promo codes, campaigns, discounts, and redemption tracking")
     .addTag("Reports", "Revenue analytics, occupancy reports, agent sales, and KPI dashboards")
-    .addTag("Round Trip", "Round-trip bookings, return scheduling, combined pricing, and management (NEW)")
     .addTag("Routes", "Route templates with ordered stops, fare rules, and baggage allowance")
     .addTag("Schedule", "Trip schedules, availability windows, status tracking, and timing")
     .addTag("Search", "Trip search, fare quotes, coach types, and real-time availability")
@@ -294,8 +320,8 @@ Payment providers send notifications to:
     .addTag("Segment-based Seats", "Multi-leg journey seats, segment allocation, and per-leg availability")
     .addTag("Stations", "Station directory, location data, baggage facilities, and amenities")
     .addTag("Support", "FAQ management, search, live chat conversations, and ticket resolution")
-    .addTag("Tickets", "QR/barcode generation, PDF tickets, gate validation with per-leg tracking (OUTBOUND/RETURN), and audit trails")
-    .addTag("Transit Stops", "Cross-border journey management, Dire Dawa hub, multi-leg routing (NEW)")
+    .addTag("Tickets", "QR/barcode generation, PDF tickets, gate validation with per-leg tracking (OUTBOUND/RETURN/LEG1/LEG2/OUTBOUND_LEG1/OUTBOUND_LEG2/RETURN_LEG1/RETURN_LEG2), and audit trails")
+    .addTag("Transit Stops", "Cross-border journey management, Dire Dawa hub, TRANSIT and ROUND_TRIP_TRANSIT bookings")
     .addTag("Wallet", "Balance management, top-ups, withdrawals, and transaction ledger")
     //.addServer('http://localhost:4000', 'Development')
     // .addServer("https://api.edr-platform.com", "Production")
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 561e36c43..54dcea344 100644
--- a/apps/edr-passenger-api/src/modules/bookings/bookings.controller.ts
+++ b/apps/edr-passenger-api/src/modules/bookings/bookings.controller.ts
@@ -1,5 +1,5 @@
 import { Body, Controller, Delete, Get, Param, Post, Patch, UseGuards, Query, Req, BadRequestException } from '@nestjs/common';
-import { ApiTags, ApiOperation, ApiBearerAuth, ApiResponse, ApiQuery } from '@nestjs/swagger';
+import { ApiTags, ApiOperation, ApiBearerAuth, ApiResponse, ApiQuery, ApiBody } from '@nestjs/swagger';
 import { BookingsService } from './bookings.service';
 import { GuestBookingService } from './guest-booking.service';
 import { CreateBookingDto, ModifyBookingDto, CancelBookingDto } from './bookings.dto';
@@ -100,35 +100,153 @@ export class BookingsController {
   
   @Post('guest')
   @ApiOperation({ 
-    summary: 'Create guest booking without login (optional account creation)',
-    description: `Creates a booking without requiring login. Features:
-    
-**Guest Checkout:**
-- No login required
-- Contact details from first passenger
-- Booking confirmation sent to email/phone
+    summary: 'Create guest booking — ONE_WAY | ROUND_TRIP | TRANSIT | ROUND_TRIP_TRANSIT (no login required)',
+    description: `Creates a booking without requiring login. Supports all four booking types.
 
-**Optional Account Creation:**
-- Set createAccount=true with password
-- Account created using first passenger details
-- Automatic login after booking
-- Loyalty points and wallet created
+**bookingType: ONE_WAY (default)**
+- scheduleId, holdId, originStationId, destinationStationId, seatClassId
+- passengers[]: { seatId, passengerName, dateOfBirth, idDocumentType, … }
 
-**Passenger Details Storage:**
-- savePassengerDetails=true: Save for future bookings
-- Stored by userId (if account created) or deviceId
-- Retrieve saved passengers for quick booking
+**bookingType: ROUND_TRIP**
+- Above + returnScheduleId, returnHoldId, returnOriginStationId, returnDestinationStationId, returnSeatClassId
+- passengers[]: each must include returnSeatId (seat on the return leg)
 
-**Verifayda Verification:**
-- Ethiopian nationals: National ID verified via Verifayda
-- Other nationals: Passport details (no verification)
+**bookingType: TRANSIT**
+- scheduleId/holdId (leg-1) + leg2ScheduleId, leg2HoldId, transitStationId, leg2DestinationStationId
+- passengers[]: each must include leg2SeatId
 
-**Age-Based Pricing:**
-- ADULT (≥5 years): Full fare
-- CHILD (<5 years): First child FREE, subsequent children full fare`
+**bookingType: ROUND_TRIP_TRANSIT**
+- All TRANSIT outbound fields + returnScheduleId/returnHoldId/returnOriginStationId/returnDestinationStationId/returnLeg2ScheduleId/returnLeg2HoldId/returnTransitStationId/returnLeg2DestinationStationId
+- passengers[]: each must include leg2SeatId, returnSeatId, returnLeg2SeatId
+
+**Optional account creation:** set createAccount=true with password — creates account from first passenger details, loyalty + wallet initialised.
+
+**Verifayda:** Ethiopian nationals verified; international passengers require passportNumber + passportCountry.`
   })
-  @ApiResponse({ status: 201, description: 'Booking created successfully' })
-  @ApiResponse({ status: 400, description: 'Verifayda verification failed or invalid data' })
+  @ApiBody({
+    type: CreateGuestBookingDto,
+    examples: {
+      ONE_WAY: {
+        summary: 'ONE_WAY — single direct journey (guest)',
+        value: {
+          scheduleId: 'schedule-uuid',
+          holdId: 'hold-uuid',
+          originStationId: 'station-uuid',
+          destinationStationId: 'station-uuid',
+          seatClassId: 'seat-class-uuid',
+          bookingType: 'ONE_WAY',
+          displayCurrency: 'ETB',
+          passengers: [{
+            seatId: 'seat-uuid',
+            passengerName: 'Abebe Kebede',
+            dateOfBirth: '1990-05-15',
+            idDocumentType: 'NATIONAL_ID',
+            idDocumentNumber: 'ET123456789',
+            nationality: 'Ethiopian',
+            phone: '+251911234567',
+            email: 'abebe@email.com',
+          }],
+          savePassengerDetails: true,
+          deviceId: 'device-uuid-123',
+        },
+      },
+      ROUND_TRIP: {
+        summary: 'ROUND_TRIP — outbound + return, single PNR (guest)',
+        value: {
+          scheduleId: 'outbound-schedule-uuid',
+          holdId: 'outbound-hold-uuid',
+          originStationId: 'addis-station-uuid',
+          destinationStationId: 'djibouti-station-uuid',
+          seatClassId: 'seat-class-uuid',
+          bookingType: 'ROUND_TRIP',
+          returnScheduleId: 'return-schedule-uuid',
+          returnHoldId: 'return-hold-uuid',
+          returnOriginStationId: 'djibouti-station-uuid',
+          returnDestinationStationId: 'addis-station-uuid',
+          returnSeatClassId: 'seat-class-uuid',
+          displayCurrency: 'ETB',
+          passengers: [{
+            seatId: 'outbound-seat-uuid',
+            returnSeatId: 'return-seat-uuid',
+            passengerName: 'Abebe Kebede',
+            dateOfBirth: '1990-05-15',
+            idDocumentType: 'NATIONAL_ID',
+            idDocumentNumber: 'ET123456789',
+            nationality: 'Ethiopian',
+            phone: '+251911234567',
+          }],
+          savePassengerDetails: true,
+          deviceId: 'device-uuid-123',
+        },
+      },
+      TRANSIT: {
+        summary: 'TRANSIT — connecting train, single PNR (guest)',
+        value: {
+          scheduleId: 'leg1-schedule-uuid',
+          holdId: 'leg1-hold-uuid',
+          originStationId: 'addis-station-uuid',
+          destinationStationId: 'diredawa-station-uuid',
+          seatClassId: 'seat-class-uuid',
+          bookingType: 'TRANSIT',
+          leg2ScheduleId: 'leg2-schedule-uuid',
+          leg2HoldId: 'leg2-hold-uuid',
+          transitStationId: 'diredawa-station-uuid',
+          leg2DestinationStationId: 'djibouti-station-uuid',
+          displayCurrency: 'ETB',
+          passengers: [{
+            seatId: 'leg1-seat-uuid',
+            leg2SeatId: 'leg2-seat-uuid',
+            passengerName: 'Abebe Kebede',
+            dateOfBirth: '1990-05-15',
+            idDocumentType: 'NATIONAL_ID',
+            idDocumentNumber: 'ET123456789',
+            nationality: 'Ethiopian',
+            phone: '+251911234567',
+          }],
+          deviceId: 'device-uuid-123',
+        },
+      },
+      ROUND_TRIP_TRANSIT: {
+        summary: 'ROUND_TRIP_TRANSIT — round trip via connecting trains, 4 holds (guest)',
+        value: {
+          scheduleId: 'ob-leg1-schedule-uuid',
+          holdId: 'ob-leg1-hold-uuid',
+          originStationId: 'addis-station-uuid',
+          destinationStationId: 'diredawa-station-uuid',
+          seatClassId: 'seat-class-uuid',
+          bookingType: 'ROUND_TRIP_TRANSIT',
+          leg2ScheduleId: 'ob-leg2-schedule-uuid',
+          leg2HoldId: 'ob-leg2-hold-uuid',
+          transitStationId: 'diredawa-station-uuid',
+          leg2DestinationStationId: 'djibouti-station-uuid',
+          returnScheduleId: 'ret-leg1-schedule-uuid',
+          returnHoldId: 'ret-leg1-hold-uuid',
+          returnOriginStationId: 'djibouti-station-uuid',
+          returnDestinationStationId: 'diredawa-station-uuid',
+          returnLeg2ScheduleId: 'ret-leg2-schedule-uuid',
+          returnLeg2HoldId: 'ret-leg2-hold-uuid',
+          returnTransitStationId: 'diredawa-station-uuid',
+          returnLeg2DestinationStationId: 'addis-station-uuid',
+          displayCurrency: 'ETB',
+          passengers: [{
+            seatId: 'ob-leg1-seat-uuid',
+            leg2SeatId: 'ob-leg2-seat-uuid',
+            returnSeatId: 'ret-leg1-seat-uuid',
+            returnLeg2SeatId: 'ret-leg2-seat-uuid',
+            passengerName: 'Abebe Kebede',
+            dateOfBirth: '1990-05-15',
+            idDocumentType: 'NATIONAL_ID',
+            idDocumentNumber: 'ET123456789',
+            nationality: 'Ethiopian',
+            phone: '+251911234567',
+          }],
+          deviceId: 'device-uuid-123',
+        },
+      },
+    },
+  })
+  @ApiResponse({ status: 201, description: 'Booking created successfully with fareBreakdown' })
+  @ApiResponse({ status: 400, description: 'Missing required seat IDs for bookingType, or Verifayda verification failed' })
   createGuest(@Body() dto: CreateGuestBookingDto) { 
     return this.guestService.createGuestBooking(dto); 
   }
@@ -147,24 +265,149 @@ export class BookingsController {
   @UseGuards(JwtGuard)
   @ApiBearerAuth('JWT-auth')
   @ApiOperation({ 
-    summary: 'Create booking (one-way or round-trip)',
-    description: `Creates a one-way or round-trip booking for logged-in users.
-    
-ONE_WAY booking:
-- scheduleId, holdId, originStationId, destinationStationId
-- passengers: array of PassengerInputDto with seatId
-- Single PNR, single payment
+    summary: 'Create booking — ONE_WAY | ROUND_TRIP | TRANSIT | ROUND_TRIP_TRANSIT',
+    description: `Creates a booking for a logged-in passenger. bookingType controls which fields are required.
 
-ROUND_TRIP booking:
-- Outbound: scheduleId, holdId, originStationId, destinationStationId, seatClassId
-- Return: returnScheduleId, returnHoldId, returnOriginStationId, returnDestinationStationId, returnSeatClassId
-- passengers: array of RoundTripPassengerDto with outboundSeatId and returnSeatId
-- Combined PNR, single payment for both legs
-- Fare = outbound_fare + return_fare, single total, single promo, single loyalty deduction`
+**ONE_WAY**
+- scheduleId, holdId, originStationId, destinationStationId, seatClassId
+- passengers[]: { seatId, passengerName, dateOfBirth, idDocumentType, … }
+
+**ROUND_TRIP**
+- Above + returnScheduleId, returnHoldId, returnOriginStationId, returnDestinationStationId, returnSeatClassId
+- passengers[]: { seatId (outbound), returnSeatId (return), passengerName, … }
+- Combined fare = outbound fare + return fare; single promo/loyalty deduction
+
+**TRANSIT** (connecting train, single PNR)
+- scheduleId/holdId for leg-1 + leg2ScheduleId, leg2HoldId, transitStationId, leg2DestinationStationId
+- passengers[]: { seatId (leg-1), leg2SeatId (leg-2), passengerName, … }
+
+**ROUND_TRIP_TRANSIT** (round trip, each direction via connecting train)
+- All TRANSIT outbound fields + returnScheduleId, returnHoldId, returnOriginStationId, returnDestinationStationId, returnLeg2ScheduleId, returnLeg2HoldId, returnTransitStationId, returnLeg2DestinationStationId
+- passengers[]: { seatId, leg2SeatId, returnSeatId, returnLeg2SeatId, passengerName, … }
+- 4 holds required, 4 seat sets per passenger, single PNR, single payment
+
+**Age-Based Pricing (all types)**
+- ADULT (≥5 years): full fare per leg
+- CHILD (<5 years): first child FREE per booking, subsequent children full fare`
+  })
+  @ApiBody({
+    type: CreateBookingDto,
+    examples: {
+      ONE_WAY: {
+        summary: 'ONE_WAY — single direct journey',
+        value: {
+          passengerId: 'passenger-uuid',
+          scheduleId: 'schedule-uuid',
+          holdId: 'hold-uuid',
+          originStationId: 'station-uuid',
+          destinationStationId: 'station-uuid',
+          seatClassId: 'seat-class-uuid',
+          bookingType: 'ONE_WAY',
+          displayCurrency: 'ETB',
+          passengers: [{
+            seatId: 'seat-uuid',
+            passengerName: 'Abebe Kebede',
+            dateOfBirth: '1990-05-15',
+            idDocumentType: 'NATIONAL_ID',
+            idDocumentNumber: 'ET123456789',
+            nationality: 'Ethiopian',
+          }],
+        },
+      },
+      ROUND_TRIP: {
+        summary: 'ROUND_TRIP — outbound + return, single PNR',
+        value: {
+          passengerId: 'passenger-uuid',
+          scheduleId: 'outbound-schedule-uuid',
+          holdId: 'outbound-hold-uuid',
+          originStationId: 'addis-station-uuid',
+          destinationStationId: 'djibouti-station-uuid',
+          seatClassId: 'seat-class-uuid',
+          bookingType: 'ROUND_TRIP',
+          returnScheduleId: 'return-schedule-uuid',
+          returnHoldId: 'return-hold-uuid',
+          returnOriginStationId: 'djibouti-station-uuid',
+          returnDestinationStationId: 'addis-station-uuid',
+          returnSeatClassId: 'seat-class-uuid',
+          displayCurrency: 'ETB',
+          passengers: [{
+            seatId: 'outbound-seat-uuid',
+            returnSeatId: 'return-seat-uuid',
+            passengerName: 'Abebe Kebede',
+            dateOfBirth: '1990-05-15',
+            idDocumentType: 'NATIONAL_ID',
+            idDocumentNumber: 'ET123456789',
+            nationality: 'Ethiopian',
+          }],
+        },
+      },
+      TRANSIT: {
+        summary: 'TRANSIT — connecting train, single PNR',
+        value: {
+          passengerId: 'passenger-uuid',
+          scheduleId: 'leg1-schedule-uuid',
+          holdId: 'leg1-hold-uuid',
+          originStationId: 'addis-station-uuid',
+          destinationStationId: 'diredawa-station-uuid',
+          seatClassId: 'seat-class-uuid',
+          bookingType: 'TRANSIT',
+          leg2ScheduleId: 'leg2-schedule-uuid',
+          leg2HoldId: 'leg2-hold-uuid',
+          transitStationId: 'diredawa-station-uuid',
+          leg2DestinationStationId: 'djibouti-station-uuid',
+          displayCurrency: 'ETB',
+          passengers: [{
+            seatId: 'leg1-seat-uuid',
+            leg2SeatId: 'leg2-seat-uuid',
+            passengerName: 'Abebe Kebede',
+            dateOfBirth: '1990-05-15',
+            idDocumentType: 'NATIONAL_ID',
+            idDocumentNumber: 'ET123456789',
+            nationality: 'Ethiopian',
+          }],
+        },
+      },
+      ROUND_TRIP_TRANSIT: {
+        summary: 'ROUND_TRIP_TRANSIT — round trip via connecting trains, 4 holds',
+        value: {
+          passengerId: 'passenger-uuid',
+          scheduleId: 'ob-leg1-schedule-uuid',
+          holdId: 'ob-leg1-hold-uuid',
+          originStationId: 'addis-station-uuid',
+          destinationStationId: 'diredawa-station-uuid',
+          seatClassId: 'seat-class-uuid',
+          bookingType: 'ROUND_TRIP_TRANSIT',
+          leg2ScheduleId: 'ob-leg2-schedule-uuid',
+          leg2HoldId: 'ob-leg2-hold-uuid',
+          transitStationId: 'diredawa-station-uuid',
+          leg2DestinationStationId: 'djibouti-station-uuid',
+          returnScheduleId: 'ret-leg1-schedule-uuid',
+          returnHoldId: 'ret-leg1-hold-uuid',
+          returnOriginStationId: 'djibouti-station-uuid',
+          returnDestinationStationId: 'diredawa-station-uuid',
+          returnLeg2ScheduleId: 'ret-leg2-schedule-uuid',
+          returnLeg2HoldId: 'ret-leg2-hold-uuid',
+          returnTransitStationId: 'diredawa-station-uuid',
+          returnLeg2DestinationStationId: 'addis-station-uuid',
+          displayCurrency: 'ETB',
+          passengers: [{
+            seatId: 'ob-leg1-seat-uuid',
+            leg2SeatId: 'ob-leg2-seat-uuid',
+            returnSeatId: 'ret-leg1-seat-uuid',
+            returnLeg2SeatId: 'ret-leg2-seat-uuid',
+            passengerName: 'Abebe Kebede',
+            dateOfBirth: '1990-05-15',
+            idDocumentType: 'NATIONAL_ID',
+            idDocumentNumber: 'ET123456789',
+            nationality: 'Ethiopian',
+          }],
+        },
+      },
+    },
   })
   @ApiResponse({ status: 201, description: 'Booking created with fare breakdown' })
-  @ApiResponse({ status: 400, description: 'Verifayda verification failed or invalid passenger data' })
-  @ApiResponse({ status: 404, description: 'Trip or seat hold not found' })
+  @ApiResponse({ status: 400, description: 'Missing required fields for bookingType, or Verifayda verification failed' })
+  @ApiResponse({ status: 404, description: 'Schedule or seat hold not found' })
   create(@Body() dto: CreateBookingDto) { 
     return this.service.create(dto); 
   }
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 a5ebf717c..52603e776 100644
--- a/apps/edr-passenger-api/src/modules/bookings/bookings.dto.ts
+++ b/apps/edr-passenger-api/src/modules/bookings/bookings.dto.ts
@@ -4,8 +4,10 @@ import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
 import { Currency, IdDocumentType } from '@prisma/client';
 
 export class PassengerInputDto {
-  @ApiProperty() @IsString() seatId: string;
-  @ApiPropertyOptional({ description: '**TRANSIT / ROUND_TRIP_TRANSIT:** Seat ID on leg-2 schedule' }) @IsOptional() @IsString() leg2SeatId?: string;
+  @ApiProperty({ example: 'seat-uuid', description: 'Outbound / leg-1 seat ID (all booking types)' }) @IsString() seatId: string;
+  @ApiPropertyOptional({ example: 'leg2-seat-uuid', description: '**TRANSIT / ROUND_TRIP_TRANSIT:** Outbound leg-2 seat ID' }) @IsOptional() @IsString() leg2SeatId?: string;
+  @ApiPropertyOptional({ example: 'return-seat-uuid', description: '**ROUND_TRIP / ROUND_TRIP_TRANSIT:** Return leg-1 seat ID' }) @IsOptional() @IsString() returnSeatId?: string;
+  @ApiPropertyOptional({ example: 'ret-leg2-seat-uuid', description: '**ROUND_TRIP_TRANSIT:** Return leg-2 seat ID' }) @IsOptional() @IsString() returnLeg2SeatId?: string;
   @ApiProperty({ example: 'Abebe Kebede' }) @IsString() passengerName: string;
   @ApiProperty({ example: '1990-05-15', description: 'Date of birth (YYYY-MM-DD) for age calculation. Age <5 = CHILD (first free), Age ≥5 = ADULT (full fare)' }) @IsDateString() dateOfBirth: string;
   @ApiProperty({ example: 'NATIONAL_ID', enum: IdDocumentType, description: 'NATIONAL_ID for Ethiopians (Verifayda verified), PASSPORT for others' }) @IsEnum(IdDocumentType) idDocumentType: IdDocumentType;
@@ -76,16 +78,16 @@ export class CreateBookingDto {
   @ApiProperty({ description: 'Passenger ID' }) 
   @IsString() passengerId: string;
   
-  @ApiProperty({ description: 'Outbound schedule ID' }) 
+  @ApiProperty({ description: 'Outbound / leg-1 schedule ID' }) 
   @IsString() scheduleId: string;
   
-  @ApiProperty({ description: 'Outbound seat hold ID' }) 
+  @ApiProperty({ description: 'Outbound / leg-1 seat hold ID' }) 
   @IsString() holdId: string;
   
-  @ApiProperty({ example: 'station-uuid', description: 'Outbound origin station UUID (must match the hold)' }) 
+  @ApiProperty({ example: 'station-uuid', description: 'Outbound origin station UUID' }) 
   @IsString() originStationId: string;
   
-  @ApiProperty({ example: 'station-uuid', description: 'Outbound destination station UUID (must match the hold)' }) 
+  @ApiProperty({ example: 'station-uuid', description: 'Outbound destination station UUID' }) 
   @IsString() destinationStationId: string;
   
   @ApiProperty({ example: 'seat-class-uuid', description: 'Outbound seat class UUID (Economy Regular, Economy Bed, VIP Bed)' })
@@ -94,14 +96,32 @@ export class CreateBookingDto {
   @ApiProperty({ 
     example: 'ONE_WAY', 
     enum: ['ONE_WAY', 'ROUND_TRIP', 'TRANSIT', 'ROUND_TRIP_TRANSIT'],
-    description: `Booking type:\n\n**ONE_WAY:** Single journey\n\n**ROUND_TRIP:** Outbound + return, single PNR\n\n**TRANSIT:** Single journey via connecting train, single PNR, single ticket\n\n**ROUND_TRIP_TRANSIT:** Round trip where one or both directions use a connecting train`,
+    description: `Booking type:
+
+**ONE_WAY:** Single direct journey — needs: scheduleId, holdId. Passenger: seatId.
+
+**ROUND_TRIP:** Outbound + return, single PNR — needs above + returnScheduleId, returnHoldId, returnOriginStationId, returnDestinationStationId. Passenger: seatId + returnSeatId.
+
+**TRANSIT:** Single journey via connecting train, single PNR — needs above + leg2ScheduleId, leg2HoldId, transitStationId, leg2DestinationStationId. Passenger: seatId + leg2SeatId.
+
+**ROUND_TRIP_TRANSIT:** Round trip via connecting trains — needs all 4 hold sets + all station fields. Passenger: seatId + leg2SeatId + returnSeatId + returnLeg2SeatId.`,
     default: 'ONE_WAY'
   }) 
   @IsOptional() @IsString() bookingType?: string;
   
   @ApiProperty({ 
     type: [PassengerInputDto], 
-    description: `Passenger array - type depends on bookingType:\n\n**For ONE_WAY:** PassengerInputDto[]\n- Each passenger has: seatId, passengerName, dateOfBirth, etc.\n\n**For ROUND_TRIP:** RoundTripPassengerDto[]\n- Each passenger has: outboundSeatId, returnSeatId, passengerName, dateOfBirth, etc.\n\n**Age-based pricing:** First child (<5 years) travels FREE, subsequent children pay full fare`
+    description: `Passenger array — required seat fields vary by bookingType:
+
+**ONE_WAY:** { seatId, passengerName, dateOfBirth, idDocumentType, … }
+
+**ROUND_TRIP:** { seatId (outbound leg-1), returnSeatId (return leg-1), passengerName, … }
+
+**TRANSIT:** { seatId (leg-1), leg2SeatId (leg-2), passengerName, … }
+
+**ROUND_TRIP_TRANSIT:** { seatId, leg2SeatId, returnSeatId, returnLeg2SeatId, passengerName, … }
+
+**Age-based pricing:** First child (<5 years) travels FREE, subsequent children pay full fare.`
   }) 
   @IsArray() @ValidateNested({ each: true }) @Type(() => PassengerInputDto) 
   passengers: PassengerInputDto[];
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 3e0d6a61a..b40a5c0ee 100644
--- a/apps/edr-passenger-api/src/modules/bookings/bookings.service.ts
+++ b/apps/edr-passenger-api/src/modules/bookings/bookings.service.ts
@@ -202,7 +202,7 @@ export class BookingsService {
     }
     
     if (status) where.status = status;
-    if (returnLegStatus) where.returnLegStatus = returnLegStatus;
+    if (returnLegStatus) (where as any).returnLegStatus = returnLegStatus;
     
     const [items, total] = await Promise.all([
       this.prisma.booking.findMany({
@@ -233,6 +233,8 @@ export class BookingsService {
         contactPhone: booking.contactPhone,
         bookingType: booking.bookingType,
         returnLegStatus: (booking as any).returnLegStatus ?? null,
+        adultCount: booking.adultCount,
+        childCount: booking.childCount,
         createdAt: booking.createdAt,
         passenger: booking.passenger?.user,
         schedule: {
diff --git a/apps/edr-passenger-api/src/modules/bookings/guest-booking.dto.ts b/apps/edr-passenger-api/src/modules/bookings/guest-booking.dto.ts
index ba4af04b4..d3d1e206d 100644
--- a/apps/edr-passenger-api/src/modules/bookings/guest-booking.dto.ts
+++ b/apps/edr-passenger-api/src/modules/bookings/guest-booking.dto.ts
@@ -4,16 +4,16 @@ import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
 import { Currency, IdDocumentType } from '@prisma/client';
 
 export class GuestPassengerDto {
-  @ApiProperty({ example: 'seat-id-uuid', description: 'Outbound seat ID (or only seat for ONE_WAY)' }) 
+  @ApiProperty({ example: 'seat-uuid', description: 'Outbound / leg-1 seat ID (all booking types)' }) 
   @IsString() seatId: string;
 
-  @ApiPropertyOptional({ example: 'seat-id-uuid', description: 'Return seat ID (ROUND_TRIP / ROUND_TRIP_TRANSIT outbound leg-1)' })
+  @ApiPropertyOptional({ example: 'return-seat-uuid', description: '**ROUND_TRIP / ROUND_TRIP_TRANSIT:** Return leg-1 seat ID. Required for ROUND_TRIP and ROUND_TRIP_TRANSIT.' })
   @IsOptional() @IsString() returnSeatId?: string;
 
-  @ApiPropertyOptional({ example: 'seat-id-uuid', description: 'Leg-2 seat ID (TRANSIT / ROUND_TRIP_TRANSIT outbound leg-2)' })
+  @ApiPropertyOptional({ example: 'leg2-seat-uuid', description: '**TRANSIT / ROUND_TRIP_TRANSIT:** Outbound leg-2 seat ID. Required for TRANSIT and ROUND_TRIP_TRANSIT.' })
   @IsOptional() @IsString() leg2SeatId?: string;
 
-  @ApiPropertyOptional({ example: 'seat-id-uuid', description: 'ROUND_TRIP_TRANSIT: return journey leg-2 seat ID' })
+  @ApiPropertyOptional({ example: 'ret-leg2-seat-uuid', description: '**ROUND_TRIP_TRANSIT:** Return leg-2 seat ID. Required for ROUND_TRIP_TRANSIT.' })
   @IsOptional() @IsString() returnLeg2SeatId?: string;
 
   @ApiProperty({ example: 'Abebe Kebede' }) 
@@ -45,7 +45,16 @@ export class GuestPassengerDto {
 }
 
 export class CreateGuestBookingDto {
-  @ApiPropertyOptional({ example: 'ONE_WAY', enum: ['ONE_WAY', 'ROUND_TRIP', 'TRANSIT', 'ROUND_TRIP_TRANSIT'], default: 'ONE_WAY' })
+  @ApiPropertyOptional({ 
+    example: 'ONE_WAY', 
+    enum: ['ONE_WAY', 'ROUND_TRIP', 'TRANSIT', 'ROUND_TRIP_TRANSIT'], 
+    default: 'ONE_WAY',
+    description: `Booking type:
+**ONE_WAY:** scheduleId + holdId. Passenger: seatId.
+**ROUND_TRIP:** above + returnScheduleId/returnHoldId/returnOriginStationId/returnDestinationStationId. Passenger: seatId + returnSeatId.
+**TRANSIT:** above + leg2ScheduleId/leg2HoldId/transitStationId/leg2DestinationStationId. Passenger: seatId + leg2SeatId.
+**ROUND_TRIP_TRANSIT:** all 4 hold sets + all station fields. Passenger: seatId + leg2SeatId + returnSeatId + returnLeg2SeatId.`
+  })
   @IsOptional() @IsString() bookingType?: 'ONE_WAY' | 'ROUND_TRIP' | 'TRANSIT' | 'ROUND_TRIP_TRANSIT';
 
   @ApiProperty({ example: 'schedule-uuid', description: 'Outbound / leg-1 schedule UUID' }) 
@@ -108,7 +117,14 @@ export class CreateGuestBookingDto {
   @ApiPropertyOptional({ example: 'seat-class-uuid', description: 'ROUND_TRIP_TRANSIT: return leg-2 seat class UUID' })
   @IsOptional() @IsString() returnLeg2SeatClassId?: string;
 
-  @ApiProperty({ type: [GuestPassengerDto], description: 'Array of passengers. For ROUND_TRIP each passenger must include returnSeatId.' }) 
+  @ApiProperty({ 
+    type: [GuestPassengerDto], 
+    description: `Passenger array. Required seat fields vary by bookingType:
+- ONE_WAY: seatId
+- ROUND_TRIP: seatId + returnSeatId
+- TRANSIT: seatId + leg2SeatId
+- ROUND_TRIP_TRANSIT: seatId + leg2SeatId + returnSeatId + returnLeg2SeatId` 
+  }) 
   @IsArray() @ValidateNested({ each: true }) @Type(() => GuestPassengerDto) passengers: GuestPassengerDto[];
 
   @ApiPropertyOptional({ example: 'WEEKEND15' }) 
diff --git a/apps/edr-passenger-api/src/modules/notifications/dtos/sms.dto.ts b/apps/edr-passenger-api/src/modules/notifications/dtos/sms.dto.ts
index 2841597fc..e50cf6c64 100644
--- a/apps/edr-passenger-api/src/modules/notifications/dtos/sms.dto.ts
+++ b/apps/edr-passenger-api/src/modules/notifications/dtos/sms.dto.ts
@@ -19,6 +19,24 @@ export class SendMessage {
   from?: string;
 }
 
+export class SingleMessageDto {
+  @ApiProperty({
+    description: 'Recipient phone number',
+    example: '+1234567890',
+  })
+  @IsString()
+  @IsNotEmpty()
+  to: string;
+
+  @ApiProperty({
+    description: 'Message content',
+    example: 'Test Single SMS from',
+  })
+  @IsString()
+  @IsNotEmpty()
+  sms: string;
+}
+
 export class BulkMessagesDto {
   @ApiProperty({ type: [SendMessage] })
   @IsArray()
diff --git a/apps/edr-passenger-api/src/modules/notifications/email-client.service.ts b/apps/edr-passenger-api/src/modules/notifications/email-client.service.ts
index f925920cb..34879ed0a 100644
--- a/apps/edr-passenger-api/src/modules/notifications/email-client.service.ts
+++ b/apps/edr-passenger-api/src/modules/notifications/email-client.service.ts
@@ -1,29 +1,39 @@
-import { Inject, Injectable, Logger, OnApplicationBootstrap } from '@nestjs/common';
-import { ClientProxy } from '@nestjs/microservices';
-import { SendEmail } from './dtos/email.dto';
+import {
+  Inject,
+  Injectable,
+  Logger,
+  OnApplicationBootstrap,
+} from "@nestjs/common";
+import { ClientProxy } from "@nestjs/microservices";
+import { SendEmail } from "./dtos/email.dto";
 
 @Injectable()
 export class EmailClientService implements OnApplicationBootstrap {
   private readonly logger = new Logger(EmailClientService.name);
 
   constructor(
-    @Inject('EMAIL_SERVICE')
+    @Inject("EMAIL_SERVICE")
     private readonly emailServiceClient: ClientProxy,
   ) {}
 
-  private readonly enabled = process.env.RABBITMQ_ENABLED !== 'false';
+  private readonly enabled = process.env.RABBITMQ_ENABLED !== "false";
 
   async onApplicationBootstrap() {
     if (!this.enabled) return;
     this.emailServiceClient
       .connect()
-      .then(() => this.logger.log('Connected to Email service'))
-      .catch((err) => this.logger.error('Error connecting to Email service', err));
+      .then(() => this.logger.log("Connected to Email service"))
+      .catch((err) =>
+        this.logger.error("Error connecting to Email service", err),
+      );
   }
 
   async sendEmail(dto: SendEmail) {
     if (!this.enabled) return {};
-    this.emailServiceClient.emit('send-email', { ...dto, appKey: 'EDR-PASSENGER-API' });
+    this.emailServiceClient.emit("send-email", {
+      ...dto,
+      appKey: "IFHCRS-LICENSE-MANAGEMENT",
+    });
     return {};
   }
 }
diff --git a/apps/edr-passenger-api/src/modules/notifications/notifications.controller.ts b/apps/edr-passenger-api/src/modules/notifications/notifications.controller.ts
index 0b7798a04..b622e3b7d 100644
--- a/apps/edr-passenger-api/src/modules/notifications/notifications.controller.ts
+++ b/apps/edr-passenger-api/src/modules/notifications/notifications.controller.ts
@@ -7,7 +7,7 @@ import { TestNotificationDto } from './notifications.dto';
 import { EmailClientService } from './email-client.service';
 import { SmsClientService } from './sms-client.service';
 import { SendEmail } from './dtos/email.dto';
-import { BulkMessagesDto, SendMessage } from './dtos/sms.dto';
+import { BulkMessagesDto, SingleMessageDto } from './dtos/sms.dto';
 
 @ApiTags('Notifications')
 @Controller('notifications')
@@ -51,8 +51,8 @@ export class NotificationsController {
   @UseGuards(IamGuard)
   @IamRoles('ADMIN', 'STAFF')
   @ApiOperation({ summary: 'Send a direct SMS via the SMS microservice' })
-  @ApiBody({ type: SendMessage })
-  sendSms(@Body() dto: SendMessage) {
+  @ApiBody({ type: SingleMessageDto })
+  sendSms(@Body() dto: SingleMessageDto) {
     return this.smsClient.sendSms(dto);
   }
 
diff --git a/apps/edr-passenger-api/src/modules/notifications/notifications.service.ts b/apps/edr-passenger-api/src/modules/notifications/notifications.service.ts
index 595633e93..8960f1a87 100644
--- a/apps/edr-passenger-api/src/modules/notifications/notifications.service.ts
+++ b/apps/edr-passenger-api/src/modules/notifications/notifications.service.ts
@@ -21,7 +21,7 @@ export class NotificationsService {
   ) {
     this.channels = new Map<NotificationChannelType, NotificationChannel>([
       ['EMAIL', { send: (to, subject, body) => this.emailClient.sendEmail({ to, subject, text: body }).then(() => true) }],
-      ['SMS', { send: (to, _subject, body) => this.smsClient.sendSms({ to, message: body }).then(() => true) }],
+      ['SMS', { send: (to, _subject, body) => this.smsClient.sendSms({ to, sms: body }).then(() => true) }],
       ['PUSH', this.pushAdapter as NotificationChannel],
     ]);
   }
diff --git a/apps/edr-passenger-api/src/modules/notifications/sms-client.service.ts b/apps/edr-passenger-api/src/modules/notifications/sms-client.service.ts
index 7b18212cb..ef2758686 100644
--- a/apps/edr-passenger-api/src/modules/notifications/sms-client.service.ts
+++ b/apps/edr-passenger-api/src/modules/notifications/sms-client.service.ts
@@ -3,42 +3,48 @@ import {
   Injectable,
   Logger,
   OnApplicationBootstrap,
-} from '@nestjs/common';
-import { ClientProxy } from '@nestjs/microservices';
-import { BulkMessagesDto, SendMessage } from './dtos/sms.dto';
+} from "@nestjs/common";
+import { ClientProxy } from "@nestjs/microservices";
+import { BulkMessagesDto, SingleMessageDto } from "./dtos/sms.dto";
 
 @Injectable()
 export class SmsClientService implements OnApplicationBootstrap {
   private readonly logger = new Logger(SmsClientService.name);
 
   constructor(
-    @Inject('SMS_SERVICE')
+    @Inject("SMS_SERVICE")
     private smsClient: ClientProxy,
   ) {}
 
-  private readonly enabled = process.env.RABBITMQ_ENABLED !== 'false';
+  private readonly enabled = process.env.RABBITMQ_ENABLED !== "false";
 
   async onApplicationBootstrap() {
     if (!this.enabled) return;
     this.smsClient
       .connect()
       .then(() => {
-        this.logger.log('connected to SMS service');
+        this.logger.log("connected to SMS service");
       })
       .catch((err) => {
-        console.error('Error happened at SMS service', err);
+        console.error("Error happened at SMS service", err);
       });
   }
 
-  async sendSms(dto: SendMessage) {
+  async sendSms(dto: SingleMessageDto) {
     if (!this.enabled) return {};
-    this.smsClient.emit('send-sms', { ...dto, appKey: 'EDR-PASSENGER-API' });
+    this.smsClient.emit("send-sms", {
+      ...dto,
+      appKey: "IFHCRS-LICENSE-MANAGEMENT",
+    });
     return {};
   }
 
   async sendBulkMessages(dto: BulkMessagesDto) {
     if (!this.enabled) return {};
-    this.smsClient.emit('ozeking-bulk-sms', { ...dto, appKey: 'EDR-PASSENGER-API' });
+    this.smsClient.emit("ozeking-bulk-sms", {
+      ...dto,
+      appKey: "IFHCRS-LICENSE-MANAGEMENT",
+    });
     return {};
   }
 }
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 12d9e5626..7171b56ad 100644
--- a/apps/edr-passenger-api/src/modules/passengers/passengers.service.ts
+++ b/apps/edr-passenger-api/src/modules/passengers/passengers.service.ts
@@ -21,10 +21,11 @@ export class PassengersService {
     const { search, verified, page = 1, pageSize = 20 } = filters;
     const skip = (page - 1) * pageSize;
     
-    const where: any = {};
+    const where: any = { user: { role: 'PASSENGER' } };
     
     if (search) {
       where.user = {
+        ...where.user,
         OR: [
           { fullName: { contains: search, mode: 'insensitive' } },
           { email: { contains: search, mode: 'insensitive' } },
@@ -68,7 +69,7 @@ export class PassengersService {
           userId: passenger.userId,
           fullName: user.fullName,
           email: user.email,
-          phone: user.phone,
+      phone: user.phone?.startsWith('+guest-') ? null : user.phone,
           nationalId: user.nationalId,
           nationality: user.nationality,
           dateOfBirth: user.dateOfBirth ?? null,
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 88f9666bd..21060b595 100644
--- a/apps/edr-passenger-api/src/modules/seats/seats.service.ts
+++ b/apps/edr-passenger-api/src/modules/seats/seats.service.ts
@@ -547,16 +547,14 @@ export class SeatsService {
 
   @Cron(CronExpression.EVERY_MINUTE)
   async expireHolds() {
-    const expired = await this.prisma.seatHold.findMany({ where: { expiresAt: { lt: new Date() } } });
-    for (const hold of expired) { 
+    const now = new Date();
+    const expired = await this.prisma.seatHold.findMany({ where: { expiresAt: { lt: now } } });
+    if (expired.length === 0) return;
+
+    const expiredIds = expired.map(h => h.id);
+    for (const hold of expired) {
       await this.releaseSeats(hold.seatIds);
-      try {
-        await this.prisma.seatHold.delete({ where: { id: hold.id } });
-      } catch (err) {
-        if (err instanceof Error && !err.message.includes('P2025')) {
-          throw err;
-        }
-      }
     }
+    await this.prisma.seatHold.deleteMany({ where: { id: { in: expiredIds } } });
   }
 }
diff --git a/apps/edr-passenger-api/src/modules/tickets/tickets.controller.ts b/apps/edr-passenger-api/src/modules/tickets/tickets.controller.ts
index 568801213..d4d68ad1f 100644
--- a/apps/edr-passenger-api/src/modules/tickets/tickets.controller.ts
+++ b/apps/edr-passenger-api/src/modules/tickets/tickets.controller.ts
@@ -31,18 +31,27 @@ export class TicketsController {
   @ApiBearerAuth('JWT-auth')
   @ApiOperation({ summary: 'List all tickets with optional filters' })
   @ApiQuery({ name: 'search', required: false })
-  @ApiQuery({ name: 'status', required: false, description: 'ACTIVE | USED | CANCELLED' })
+  @ApiQuery({ name: 'status', required: false })
+  @ApiQuery({ name: 'originStationId', required: false })
+  @ApiQuery({ name: 'destinationStationId', required: false })
+  @ApiQuery({ name: 'arrivalDate', required: false })
   @ApiQuery({ name: 'skip', required: false })
   @ApiQuery({ name: 'take', required: false })
   listTickets(
     @Query('search') search?: string,
     @Query('status') status?: string,
+    @Query('originStationId') originStationId?: string,
+    @Query('destinationStationId') destinationStationId?: string,
+    @Query('arrivalDate') arrivalDate?: string,
     @Query('skip') skip?: string,
     @Query('take') take?: string,
   ) {
     return this.service.listTickets({
       search,
       status,
+      originStationId,
+      destinationStationId,
+      arrivalDate,
       skip: skip ? parseInt(skip) : 0,
       take: take ? parseInt(take) : 50,
     });
@@ -60,17 +69,8 @@ export class TicketsController {
   }
 
   @Get(':bookingRef')
-  @UseGuards(JwtGuard)
-  @ApiBearerAuth('JWT-auth')
   @ApiOperation({ 
-    summary: 'Get ticket with QR code and passenger details',
-    description: `Returns ticket information including:
-- QR code for gate scanning
-- Barcode for offline validation
-- Passenger details (name, age category, nationality)
-- Journey details (origin, destination, seat, coach)
-- Fare breakdown with currency
-- PDF download link`
+    summary: 'Get ticket with QR code and passenger details (public)',
   })
   getByRef(@Param('bookingRef') ref: string) { 
     return this.service.getByRef(ref); 
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 83abf0cc2..2c57a59e3 100644
--- a/apps/edr-passenger-api/src/modules/tickets/tickets.service.ts
+++ b/apps/edr-passenger-api/src/modules/tickets/tickets.service.ts
@@ -14,7 +14,7 @@ interface OfflineValidation {
 export class TicketsService {
   constructor(private prisma: PrismaService) {}
 
-  async listTickets(filters: { search?: string; status?: string; skip: number; take: number }) {
+  async listTickets(filters: { search?: string; status?: string; originStationId?: string; destinationStationId?: string; arrivalDate?: string; skip: number; take: number }) {
     const where: any = {};
     if (filters.search) {
       where.OR = [
@@ -24,7 +24,19 @@ export class TicketsService {
       ];
     }
     if (filters.status) {
-      where.booking = { status: filters.status };
+      where.booking = { ...where.booking, status: filters.status };
+    }
+    if (filters.originStationId) {
+      where.booking = { ...where.booking, schedule: { ...where.booking?.schedule, originStationId: filters.originStationId } };
+    }
+    if (filters.destinationStationId) {
+      where.booking = { ...where.booking, schedule: { ...where.booking?.schedule, destinationStationId: filters.destinationStationId } };
+    }
+    if (filters.arrivalDate) {
+      const start = new Date(filters.arrivalDate);
+      const end = new Date(filters.arrivalDate);
+      end.setDate(end.getDate() + 1);
+      where.booking = { ...where.booking, schedule: { ...where.booking?.schedule, arrivalAt: { gte: start, lt: end } } };
     }
     const tickets = await this.prisma.ticket.findMany({
       where,
@@ -32,7 +44,7 @@ export class TicketsService {
         booking: {
           include: {
             schedule: { include: { originStation: true, destinationStation: true, train: true } },
-            seats: { include: { seat: { include: { coach: true } } } },
+            seats: { include: { seat: { include: { coach: { include: { coachType: true } } } } } },
             passenger: { include: { user: true } },
           },
         },
@@ -235,7 +247,16 @@ export class TicketsService {
     };
   }
 
-  async validate(bookingRef: string, validatorId: string, gateId?: string, leg?: string) {
+  async validate(ticketIdOrRef: string, validatorId: string, gateId?: string, leg?: string) {
+    // Accept either a ticket UUID or a bookingRef
+    let bookingRef = ticketIdOrRef;
+    const isUuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(ticketIdOrRef);
+    if (isUuid) {
+      const ticket = await this.prisma.ticket.findUnique({ where: { id: ticketIdOrRef }, select: { bookingRef: true } });
+      if (!ticket) throw new NotFoundException('Ticket not found');
+      bookingRef = ticket.bookingRef;
+    }
+    const resolvedValidatorId = validatorId || 'BACKOFFICE';
     const booking = await this.prisma.booking.findUnique({ where: { bookingRef } });
     if (!booking) throw new NotFoundException('Booking not found');
     const ticket = await this.prisma.ticket.findUnique({ where: { bookingId: booking.id } });
@@ -247,11 +268,10 @@ export class TicketsService {
     // ── ONE_WAY / TRANSIT (single scan) ───────────────────────────────────
     if (type === 'ONE_WAY') {
       if (ticket.validatedAt) {
-        await this.prisma.gateValidationLog.create({ data: { ticketId: ticket.id, validatorId, gateId, status: 'REJECTED', reason: 'ALREADY_VALIDATED' } });
-        throw new BadRequestException('Ticket already validated');
+        return { validated: true, ticketId: ticket.id, validatedAt: ticket.validatedAt, alreadyValidated: true };
       }
-      await this.prisma.ticket.update({ where: { id: ticket.id }, data: { validatedAt: now, validatorId } });
-      await this.prisma.gateValidationLog.create({ data: { ticketId: ticket.id, validatorId, gateId, status: 'APPROVED' } });
+      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' } });
       return { validated: true, ticketId: ticket.id, validatedAt: now };
     }
 
@@ -264,28 +284,32 @@ export class TicketsService {
       const logs = await this.prisma.gateValidationLog.findMany({ where: { ticketId: ticket.id, status: 'APPROVED' } });
       const alreadyValidated = logs.some(l => l.leg === resolvedLeg);
       if (alreadyValidated) {
-        await this.prisma.gateValidationLog.create({ data: { ticketId: ticket.id, validatorId, gateId, leg: resolvedLeg, status: 'REJECTED', reason: `${resolvedLeg}_ALREADY_USED` } as any });
+        await this.prisma.gateValidationLog.create({ data: { ticketId: ticket.id, validatorId: resolvedValidatorId, gateId, leg: resolvedLeg, status: 'REJECTED', reason: `${resolvedLeg}_ALREADY_USED` } as any });
         throw new BadRequestException(`${resolvedLeg} already validated`);
       }
-      if (!ticket.validatedAt) await this.prisma.ticket.update({ where: { id: ticket.id }, data: { validatedAt: now, validatorId } });
-      await this.prisma.gateValidationLog.create({ data: { ticketId: ticket.id, validatorId, gateId, leg: resolvedLeg, status: 'APPROVED' } as any });
+      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 });
       return { validated: true, ticketId: ticket.id, leg: resolvedLeg, validatedAt: now };
     }
 
     // ── ROUND_TRIP — leg=OUTBOUND or leg=RETURN ────────────────────────
     if (type === 'ROUND_TRIP') {
-      const resolvedLeg = (leg ?? 'OUTBOUND').toUpperCase();
+      let resolvedLeg = (leg ?? '').toUpperCase();
+      // Auto-detect next unused leg when called from backoffice without a leg param
+      if (!resolvedLeg) {
+        resolvedLeg = !(booking as any).outboundBoardedAt ? 'OUTBOUND' : 'RETURN';
+      }
       const bookingData: Record<string, any> = {};
       if (resolvedLeg === 'OUTBOUND') {
         if ((booking as any).outboundBoardedAt) {
-          await this.prisma.gateValidationLog.create({ data: { ticketId: ticket.id, validatorId, gateId, leg: resolvedLeg, status: 'REJECTED', reason: 'OUTBOUND_ALREADY_USED' } as any });
+          await this.prisma.gateValidationLog.create({ data: { ticketId: ticket.id, validatorId: resolvedValidatorId, gateId, leg: resolvedLeg, status: 'REJECTED', reason: 'OUTBOUND_ALREADY_USED' } as any });
           throw new BadRequestException('Outbound leg already used');
         }
         bookingData.outboundBoardedAt = now;
-        if (!ticket.validatedAt) await this.prisma.ticket.update({ where: { id: ticket.id }, data: { validatedAt: now, validatorId } });
+        if (!ticket.validatedAt) await this.prisma.ticket.update({ where: { id: ticket.id }, data: { validatedAt: now, validatorId: resolvedValidatorId } });
       } else if (resolvedLeg === 'RETURN') {
         if ((booking as any).returnBoardedAt) {
-          await this.prisma.gateValidationLog.create({ data: { ticketId: ticket.id, validatorId, gateId, leg: resolvedLeg, status: 'REJECTED', reason: 'RETURN_ALREADY_USED' } as any });
+          await this.prisma.gateValidationLog.create({ data: { ticketId: ticket.id, validatorId: resolvedValidatorId, gateId, leg: resolvedLeg, status: 'REJECTED', reason: 'RETURN_ALREADY_USED' } as any });
           throw new BadRequestException('Return leg already used');
         }
         bookingData.returnBoardedAt = now;
@@ -298,7 +322,7 @@ export class TicketsService {
       else if (outboundUsed && !returnUsed)  bookingData.returnLegStatus = 'OUTBOUND_ONLY';
       else if (!outboundUsed && returnUsed)  bookingData.returnLegStatus = 'INBOUND_ONLY';
       await this.prisma.booking.update({ where: { id: booking.id }, data: bookingData });
-      await this.prisma.gateValidationLog.create({ data: { ticketId: ticket.id, validatorId, gateId, leg: resolvedLeg, status: 'APPROVED' } as any });
+      await this.prisma.gateValidationLog.create({ data: { ticketId: ticket.id, validatorId: resolvedValidatorId, gateId, leg: resolvedLeg, status: 'APPROVED' } as any });
       return { validated: true, ticketId: ticket.id, leg: resolvedLeg, validatedAt: now };
     }
 
@@ -311,7 +335,7 @@ export class TicketsService {
       }
       const logs = await this.prisma.gateValidationLog.findMany({ where: { ticketId: ticket.id, status: 'APPROVED' } });
       if (logs.some(l => l.leg === resolvedLeg)) {
-        await this.prisma.gateValidationLog.create({ data: { ticketId: ticket.id, validatorId, gateId, leg: resolvedLeg, status: 'REJECTED', reason: `${resolvedLeg}_ALREADY_USED` } as any });
+        await this.prisma.gateValidationLog.create({ data: { ticketId: ticket.id, validatorId: resolvedValidatorId, gateId, leg: resolvedLeg, status: 'REJECTED', reason: `${resolvedLeg}_ALREADY_USED` } as any });
         throw new BadRequestException(`${resolvedLeg} already validated`);
       }
       const bookingData: Record<string, any> = {};
@@ -327,18 +351,17 @@ export class TicketsService {
       else if (allOutboundDone && !allReturnDone) bookingData.returnLegStatus = 'OUTBOUND_ONLY';
       else if (!allOutboundDone && allReturnDone) bookingData.returnLegStatus = 'INBOUND_ONLY';
       if (Object.keys(bookingData).length) await this.prisma.booking.update({ where: { id: booking.id }, data: bookingData });
-      if (!ticket.validatedAt) await this.prisma.ticket.update({ where: { id: ticket.id }, data: { validatedAt: now, validatorId } });
-      await this.prisma.gateValidationLog.create({ data: { ticketId: ticket.id, validatorId, gateId, leg: resolvedLeg, status: 'APPROVED' } as any });
+      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 });
       return { validated: true, ticketId: ticket.id, leg: resolvedLeg, validatedAt: now };
     }
 
     // Fallback for unknown booking types — single scan
     if (ticket.validatedAt) {
-      await this.prisma.gateValidationLog.create({ data: { ticketId: ticket.id, validatorId, gateId, status: 'REJECTED', reason: 'ALREADY_VALIDATED' } });
-      throw new BadRequestException('Ticket already validated');
+      return { validated: true, ticketId: ticket.id, validatedAt: ticket.validatedAt, alreadyValidated: true };
     }
-    await this.prisma.ticket.update({ where: { id: ticket.id }, data: { validatedAt: now, validatorId } });
-    await this.prisma.gateValidationLog.create({ data: { ticketId: ticket.id, validatorId, gateId, status: 'APPROVED' } });
+    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' } });
     return { validated: true, ticketId: ticket.id, validatedAt: now };
   }
 
@@ -354,7 +377,7 @@ export class TicketsService {
       where: { scheduleId: tripId, status: 'CONFIRMED' },
       include: {
         ticket: true,
-        seats: { include: { seat: { include: { coach: true } } } },
+        seats: { include: { seat: { include: { coach: { include: { coachType: true } } } } } },
         passenger: { include: { user: true } },
       },
     });
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 36fd20281..7b43fb677 100644
--- a/apps/edr-passenger-web/backoffice/src/app/bookings/page.tsx
+++ b/apps/edr-passenger-web/backoffice/src/app/bookings/page.tsx
@@ -24,6 +24,19 @@ export default function BookingsPage() {
   const [deleteConfirmOpen, setDeleteConfirmOpen] = useState(false);
   const [bookingToDelete, setBookingToDelete] = useState<any>(null);
   const [successMessage, setSuccessMessage] = useState('');
+  const [exportModalOpen, setExportModalOpen] = useState(false);
+  const [exportDateFrom, setExportDateFrom] = useState('');
+  const [exportDateTo, setExportDateTo] = useState('');
+  const [exportColumns, setExportColumns] = useState<Record<string, boolean>>({
+    bookingRef: true,
+    passenger: true,
+    status: true,
+    bookingType: false,
+    passengerCount: false,
+    totalMinor: true,
+    paymentStatus: true,
+    createdAt: true,
+  });
 
   const queryClient = useQueryClient();
 
@@ -80,22 +93,23 @@ export default function BookingsPage() {
     }
   };
 
-  const handleExportBookings = async () => {
-    const selectedColumns = prompt(
-      'Select columns to export (comma-separated):\n\n' +
-      'Available: bookingRef, passenger, status, bookingType, passengerCount, totalMinor, paymentStatus, createdAt\n\n' +
-      'Default: bookingRef, passenger, status, totalMinor, paymentStatus, createdAt',
-      'bookingRef, passenger, status, totalMinor, paymentStatus, createdAt'
-    );
-    
-    if (!selectedColumns) return;
-    
-    const cols = selectedColumns.split(',').map(c => c.trim());
+  const confirmExport = () => {
+    const cols = Object.entries(exportColumns).filter(([, v]) => v).map(([k]) => k);
+    if (cols.length === 0) { alert('Please select at least one column'); return; }
+
+    const exportItems = (data?.items || []).filter((b: any) => {
+      if (!exportDateFrom && !exportDateTo) return true;
+      const d = b.createdAt ? new Date(b.createdAt).toISOString().split('T')[0] : null;
+      if (exportDateFrom && (!d || d < exportDateFrom)) return false;
+      if (exportDateTo && (!d || d > exportDateTo)) return false;
+      return true;
+    });
+
     const csv = [
       cols.join(','),
-      ...data?.items?.map((booking: any) => {
+      ...exportItems.map((booking: any) => {
         const values = cols.map(col => {
-          switch(col) {
+          switch (col) {
             case 'bookingRef': return booking.bookingRef;
             case 'passenger': return booking.passenger?.fullName || booking.contactEmail || 'Guest';
             case 'status': return booking.status;
@@ -108,28 +122,29 @@ export default function BookingsPage() {
           }
         });
         return values.map(v => `"${v}"`).join(',');
-      }) || []
+      }),
     ].join('\n');
-    
+
     const blob = new Blob([csv], { type: 'text/csv' });
     const url = window.URL.createObjectURL(blob);
     const a = document.createElement('a');
     a.href = url;
     a.download = `bookings-${new Date().toISOString().split('T')[0]}.csv`;
     a.click();
+    setExportModalOpen(false);
   };
 
   const columns = [
-    { 
-      key: 'bookingRef', 
+    {
+      key: 'bookingRef',
       label: 'Reference',
       sortable: true,
       render: (booking: any) => (
         <span className="font-mono font-semibold">{booking.bookingRef}</span>
       ),
     },
-    { 
-      key: 'passenger', 
+    {
+      key: 'passenger',
       label: 'Passenger',
       render: (booking: any) => (
         <div>
@@ -138,32 +153,39 @@ export default function BookingsPage() {
         </div>
       ),
     },
-    { 
-      key: 'bookingType', 
+    {
+      key: 'bookingType',
       label: 'Type',
       sortable: true,
       render: (booking: any) => booking.bookingType || 'ONE_WAY',
     },
-    { 
+    {
       key: 'passengerCount',
       label: 'Passengers',
-      render: (booking: any) => `${(booking.adultCount || 0) + (booking.childCount || 0)}`,
+      render: (booking: any) => {
+        const adults = booking.adultCount || 0;
+        const children = booking.childCount || 0;
+        if (adults === 0 && children === 0) return '—';
+        const parts = [`Adult: ${adults}`];
+        if (children > 0) parts.push(`Child: ${children}`);
+        return parts.join(' / ');
+      },
     },
-    { 
-      key: 'status', 
+    {
+      key: 'status',
       label: 'Status',
       render: (booking: any) => (
         <Badge variant="status" status={booking.status}>{booking.status}</Badge>
       ),
     },
-    { 
-      key: 'totalMinor', 
+    {
+      key: 'totalMinor',
       label: 'Amount',
       sortable: true,
       render: (booking: any) => formatCurrency(booking.totalMinor, booking.currency),
     },
-    { 
-      key: 'paymentStatus', 
+    {
+      key: 'paymentStatus',
       label: 'Payment',
       render: (booking: any) => (
         <Badge variant="status" status={booking.paymentIntent?.status || 'PENDING'}>
@@ -171,8 +193,8 @@ export default function BookingsPage() {
         </Badge>
       ),
     },
-    { 
-      key: 'createdAt', 
+    {
+      key: 'createdAt',
       label: 'Created',
       sortable: true,
       render: (booking: any) => formatDateTime(booking.createdAt),
@@ -208,7 +230,7 @@ export default function BookingsPage() {
           <h1 className="text-2xl font-bold">Bookings</h1>
           <p className="text-muted-foreground">Manage all passenger bookings</p>
         </div>
-        <ActionButton variant="export" icon={Download} onClick={handleExportBookings}>Export</ActionButton>
+        <ActionButton variant="export" icon={Download} onClick={() => setExportModalOpen(true)}>Export</ActionButton>
       </div>
 
       <div className="card">
@@ -253,7 +275,7 @@ export default function BookingsPage() {
           loading={isLoading}
           emptyMessage="No bookings found"
         />
-        
+
         {data?.meta && (
           <Pagination
             currentPage={data.meta.page}
@@ -264,15 +286,9 @@ export default function BookingsPage() {
       </div>
 
       {/* Booking Details Modal */}
-      <Modal
-        isOpen={!!selectedBooking}
-        onClose={() => setSelectedBooking(null)}
-        title="Booking Details"
-        size="xl"
-      >
+      <Modal isOpen={!!selectedBooking} onClose={() => setSelectedBooking(null)} title="Booking Details" size="xl">
         {selectedBooking && (
           <div className="space-y-6">
-            {/* Booking Information */}
             <div className="grid grid-cols-1 md:grid-cols-2 gap-4">
               <div>
                 <label className="text-sm font-medium text-muted-foreground">Booking Reference</label>
@@ -281,9 +297,7 @@ export default function BookingsPage() {
               <div>
                 <label className="text-sm font-medium text-muted-foreground">Status</label>
                 <div className="mt-1">
-                  <Badge variant="status" status={selectedBooking.status}>
-                    {selectedBooking.status}
-                  </Badge>
+                  <Badge variant="status" status={selectedBooking.status}>{selectedBooking.status}</Badge>
                 </div>
               </div>
               <div>
@@ -298,7 +312,6 @@ export default function BookingsPage() {
 
             <hr className="border-muted" />
 
-            {/* Passenger Information */}
             <div>
               <h3 className="text-lg font-semibold mb-3">Passenger Information</h3>
               <div className="grid grid-cols-1 md:grid-cols-2 gap-4">
@@ -323,7 +336,6 @@ export default function BookingsPage() {
 
             <hr className="border-muted" />
 
-            {/* Booking Details */}
             <div>
               <h3 className="text-lg font-semibold mb-3">Journey Details</h3>
               <div className="grid grid-cols-1 md:grid-cols-2 gap-4">
@@ -348,7 +360,6 @@ export default function BookingsPage() {
 
             <hr className="border-muted" />
 
-            {/* Payment Information */}
             <div>
               <h3 className="text-lg font-semibold mb-3">Payment Information</h3>
               <div className="grid grid-cols-1 md:grid-cols-2 gap-4">
@@ -377,7 +388,6 @@ export default function BookingsPage() {
 
             <hr className="border-muted" />
 
-            {/* Additional Information */}
             <div>
               <h3 className="text-lg font-semibold mb-3">Additional Information</h3>
               <div className="grid grid-cols-1 md:grid-cols-2 gap-4">
@@ -393,12 +403,7 @@ export default function BookingsPage() {
             </div>
 
             <div className="flex justify-end gap-2 pt-4">
-              <ActionButton
-                variant="secondary"
-                onClick={() => setSelectedBooking(null)}
-              >
-                Close
-              </ActionButton>
+              <ActionButton variant="secondary" onClick={() => setSelectedBooking(null)}>Close</ActionButton>
             </div>
           </div>
         )}
@@ -407,10 +412,7 @@ export default function BookingsPage() {
       {/* Delete Confirmation Dialog */}
       <ConfirmDialog
         isOpen={deleteConfirmOpen}
-        onClose={() => {
-          setDeleteConfirmOpen(false);
-          setBookingToDelete(null);
-        }}
+        onClose={() => { setDeleteConfirmOpen(false); setBookingToDelete(null); }}
         onConfirm={handleConfirmDelete}
         title="Delete Booking"
         message={`Are you sure you want to permanently delete booking ${bookingToDelete?.bookingRef}? This action cannot be undone and will release all associated seats.`}
@@ -419,6 +421,53 @@ export default function BookingsPage() {
         isLoading={deleteMutation.isPending}
         isDanger={true}
       />
+
+      {/* Export Modal */}
+      <Modal isOpen={exportModalOpen} onClose={() => setExportModalOpen(false)} title="Export Bookings" size="md">
+        <div className="space-y-4">
+          <div className="grid grid-cols-2 gap-4">
+            <div>
+              <label className="label">Date From (Created)</label>
+              <input type="date" className="input" value={exportDateFrom} onChange={(e) => setExportDateFrom(e.target.value)} />
+            </div>
+            <div>
+              <label className="label">Date To (Created)</label>
+              <input type="date" className="input" value={exportDateTo} onChange={(e) => setExportDateTo(e.target.value)} />
+            </div>
+          </div>
+
+          <div>
+            <p className="text-sm font-medium mb-2">Select Columns</p>
+            <div className="space-y-2 max-h-56 overflow-y-auto">
+              {[
+                { key: 'bookingRef', label: 'Booking Reference' },
+                { key: 'passenger', label: 'Passenger' },
+                { key: 'status', label: 'Status' },
+                { key: 'bookingType', label: 'Booking Type' },
+                { key: 'passengerCount', label: 'Passenger Count' },
+                { key: 'totalMinor', label: 'Amount' },
+                { key: 'paymentStatus', label: 'Payment Status' },
+                { key: 'createdAt', label: 'Created At' },
+              ].map((col) => (
+                <label key={col.key} className="flex items-center gap-3 p-2 hover:bg-gray-50 dark:hover:bg-gray-900/50 rounded cursor-pointer">
+                  <input
+                    type="checkbox"
+                    checked={exportColumns[col.key] || false}
+                    onChange={(e) => setExportColumns({ ...exportColumns, [col.key]: e.target.checked })}
+                    className="w-4 h-4 rounded border-gray-300"
+                  />
+                  <span className="text-sm font-medium">{col.label}</span>
+                </label>
+              ))}
+            </div>
+          </div>
+
+          <div className="flex justify-end gap-2 pt-4 border-t">
+            <ActionButton variant="secondary" onClick={() => setExportModalOpen(false)}>Cancel</ActionButton>
+            <ActionButton onClick={confirmExport}>Export CSV</ActionButton>
+          </div>
+        </div>
+      </Modal>
     </div>
   );
 }
diff --git a/apps/edr-passenger-web/backoffice/src/app/passengers/page.tsx b/apps/edr-passenger-web/backoffice/src/app/passengers/page.tsx
index 2c8e50a0e..ab588b085 100644
--- a/apps/edr-passenger-web/backoffice/src/app/passengers/page.tsx
+++ b/apps/edr-passenger-web/backoffice/src/app/passengers/page.tsx
@@ -22,6 +22,12 @@ export default function PassengersPage() {
   });
   const [selectedPassenger, setSelectedPassenger] = useState<any>(null);
   const [deleteConfirm, setDeleteConfirm] = useState<{ isOpen: boolean; passenger: any | null }>({ isOpen: false, passenger: null });
+  const [exportModalOpen, setExportModalOpen] = useState(false);
+  const [exportDateFrom, setExportDateFrom] = useState('');
+  const [exportDateTo, setExportDateTo] = useState('');
+  const [exportColumns, setExportColumns] = useState<Record<string, boolean>>({
+    fullName: true, email: true, phone: true, gender: true, nationality: true, verified: true,
+  });
 
   const queryClient = useQueryClient();
 
@@ -52,22 +58,23 @@ export default function PassengersPage() {
     console.error('Passengers API Error:', error);
   }
 
-  const handleExportPassengers = async () => {
-    const selectedColumns = prompt(
-      'Select columns to export (comma-separated):\n\n' +
-      'Available: fullName, email, phone, dateOfBirth, gender, nationality, verified\n\n' +
-      'Default: fullName, email, phone, gender, nationality, verified',
-      'fullName, email, phone, gender, nationality, verified'
-    );
-    
-    if (!selectedColumns) return;
-    
-    const cols = selectedColumns.split(',').map(c => c.trim());
+  const confirmExportPassengers = () => {
+    const cols = Object.entries(exportColumns).filter(([, v]) => v).map(([k]) => k);
+    if (cols.length === 0) { alert('Please select at least one column'); return; }
+
+    const exportItems = (data?.items || []).filter((p: any) => {
+      if (!exportDateFrom && !exportDateTo) return true;
+      const d = p.createdAt ? new Date(p.createdAt).toISOString().split('T')[0] : null;
+      if (exportDateFrom && (!d || d < exportDateFrom)) return false;
+      if (exportDateTo && (!d || d > exportDateTo)) return false;
+      return true;
+    });
+
     const csv = [
       cols.join(','),
-      ...data?.items?.map((passenger: any) => {
+      ...exportItems.map((passenger: any) => {
         const values = cols.map(col => {
-          switch(col) {
+          switch (col) {
             case 'fullName': return passenger.fullName;
             case 'email': return passenger.email || '';
             case 'phone': return passenger.phone || '';
@@ -79,15 +86,16 @@ export default function PassengersPage() {
           }
         });
         return values.map(v => `"${v}"`).join(',');
-      }) || []
+      }),
     ].join('\n');
-    
+
     const blob = new Blob([csv], { type: 'text/csv' });
     const url = window.URL.createObjectURL(blob);
     const a = document.createElement('a');
     a.href = url;
     a.download = `passengers-${new Date().toISOString().split('T')[0]}.csv`;
     a.click();
+    setExportModalOpen(false);
   };
 
   const columns = [
@@ -160,7 +168,7 @@ export default function PassengersPage() {
           <p className="text-muted-foreground">Manage passenger profiles and verification</p>
         </div>
         <div className="flex gap-2">
-          <ActionButton variant="export" icon={Download} onClick={handleExportPassengers}>Export</ActionButton>
+          <ActionButton variant="export" icon={Download} onClick={() => setExportModalOpen(true)}>Export</ActionButton>
         </div>
       </div>
 
@@ -381,6 +389,51 @@ export default function PassengersPage() {
           </div>
         )}
       </Modal>
+      {/* Export Modal */}
+      <Modal isOpen={exportModalOpen} onClose={() => setExportModalOpen(false)} title="Export Passengers" size="md">
+        <div className="space-y-4">
+          <div className="grid grid-cols-2 gap-4">
+            <div>
+              <label className="label">Date From (Registered)</label>
+              <input type="date" className="input" value={exportDateFrom} onChange={(e) => setExportDateFrom(e.target.value)} />
+            </div>
+            <div>
+              <label className="label">Date To (Registered)</label>
+              <input type="date" className="input" value={exportDateTo} onChange={(e) => setExportDateTo(e.target.value)} />
+            </div>
+          </div>
+
+          <div>
+            <p className="text-sm font-medium mb-2">Select Columns</p>
+            <div className="space-y-2 max-h-56 overflow-y-auto">
+              {[
+                { key: 'fullName', label: 'Full Name' },
+                { key: 'email', label: 'Email' },
+                { key: 'phone', label: 'Phone' },
+                { key: 'dateOfBirth', label: 'Date of Birth' },
+                { key: 'gender', label: 'Gender' },
+                { key: 'nationality', label: 'Nationality' },
+                { key: 'verified', label: 'Verified' },
+              ].map((col) => (
+                <label key={col.key} className="flex items-center gap-3 p-2 hover:bg-gray-50 dark:hover:bg-gray-900/50 rounded cursor-pointer">
+                  <input
+                    type="checkbox"
+                    checked={exportColumns[col.key] || false}
+                    onChange={(e) => setExportColumns({ ...exportColumns, [col.key]: e.target.checked })}
+                    className="w-4 h-4 rounded border-gray-300"
+                  />
+                  <span className="text-sm font-medium">{col.label}</span>
+                </label>
+              ))}
+            </div>
+          </div>
+
+          <div className="flex justify-end gap-2 pt-4 border-t">
+            <ActionButton variant="secondary" onClick={() => setExportModalOpen(false)}>Cancel</ActionButton>
+            <ActionButton onClick={confirmExportPassengers}>Export CSV</ActionButton>
+          </div>
+        </div>
+      </Modal>
     </div>
   );
 }
diff --git a/apps/edr-passenger-web/backoffice/src/app/payments/page.tsx b/apps/edr-passenger-web/backoffice/src/app/payments/page.tsx
index 69ef22859..2c1c8bcf5 100644
--- a/apps/edr-passenger-web/backoffice/src/app/payments/page.tsx
+++ b/apps/edr-passenger-web/backoffice/src/app/payments/page.tsx
@@ -6,27 +6,76 @@ import { Download } from 'lucide-react';
 import DataTable from '@/components/ui/DataTable';
 import Badge from '@/components/ui/Badge';
 import ActionButton from '@/components/ui/ActionButton';
+import Modal from '@/components/ui/Modal';
 import { paymentsApi } from '@/lib/api';
 import { formatDateTime, formatCurrency } from '@/lib/utils';
 
 export default function PaymentsPage() {
   const [filters, setFilters] = useState({ search: '', status: '', method: '' });
+  const [exportModalOpen, setExportModalOpen] = useState(false);
+  const [exportDateFrom, setExportDateFrom] = useState('');
+  const [exportDateTo, setExportDateTo] = useState('');
+  const [exportColumns, setExportColumns] = useState<Record<string, boolean>>({
+    reference: true, booking: true, amount: true, method: true, status: true, createdAt: true,
+  });
 
   const { data, isLoading } = useQuery({
     queryKey: ['payments', filters],
-    queryFn: () => paymentsApi.getAll(filters),
+    queryFn: () => paymentsApi.getAll({
+      search: filters.search || undefined,
+      status: filters.status || undefined,
+      method: filters.method || undefined,
+    }),
   });
 
-  const columns = [
-      { key: 'reference', label: 'Reference', render: (payment: any) => <span className="font-mono">{payment.reference || payment.id?.substring(0, 8)}</span> },
-      { key: 'booking', label: 'Booking', render: (payment: any) => payment.booking?.bookingRef || 'N/A' },
-      { key: 'amount', label: 'Amount', render: (payment: any) => formatCurrency(payment.amountMinor, payment.currency) },
-      { key: 'method', label: 'Method', render: (payment: any) => <Badge>{payment.method}</Badge> },
-      { key: 'status', label: 'Status', render: (payment: any) => <Badge variant="status" status={payment.status}>{payment.status}</Badge> },
-      { key: 'createdAt', label: 'Created', render: (payment: any) => formatDateTime(payment.createdAt) },
-    ];
+  const confirmExport = () => {
+    const cols = Object.entries(exportColumns).filter(([, v]) => v).map(([k]) => k);
+    if (cols.length === 0) { alert('Please select at least one column'); return; }
 
-  const actions: any[] = [];
+    const items = ((data as any)?.items || (Array.isArray(data) ? data : [])) as any[];
+    const exportItems = items.filter((p: any) => {
+      if (!exportDateFrom && !exportDateTo) return true;
+      const d = p.createdAt ? new Date(p.createdAt).toISOString().split('T')[0] : null;
+      if (exportDateFrom && (!d || d < exportDateFrom)) return false;
+      if (exportDateTo && (!d || d > exportDateTo)) return false;
+      return true;
+    });
+
+    const csv = [
+      cols.join(','),
+      ...exportItems.map((payment: any) => {
+        const values = cols.map(col => {
+          switch (col) {
+            case 'reference': return payment.reference || payment.id?.substring(0, 8) || '';
+            case 'booking': return payment.booking?.bookingRef || 'N/A';
+            case 'amount': return formatCurrency(payment.amountMinor, payment.currency);
+            case 'method': return payment.method || '';
+            case 'status': return payment.status || '';
+            case 'createdAt': return payment.createdAt || '';
+            default: return '';
+          }
+        });
+        return values.map(v => `"${v}"`).join(',');
+      }),
+    ].join('\n');
+
+    const blob = new Blob([csv], { type: 'text/csv' });
+    const url = window.URL.createObjectURL(blob);
+    const a = document.createElement('a');
+    a.href = url;
+    a.download = `payments-${new Date().toISOString().split('T')[0]}.csv`;
+    a.click();
+    setExportModalOpen(false);
+  };
+
+  const columns = [
+    { key: 'reference', label: 'Reference', render: (payment: any) => <span className="font-mono">{payment.reference || payment.id?.substring(0, 8)}</span> },
+    { key: 'booking', label: 'Booking', render: (payment: any) => payment.booking?.bookingRef || 'N/A' },
+    { key: 'amount', label: 'Amount', render: (payment: any) => formatCurrency(payment.amountMinor, payment.currency) },
+    { key: 'method', label: 'Method', render: (payment: any) => <Badge>{payment.method}</Badge> },
+    { key: 'status', label: 'Status', render: (payment: any) => <Badge variant="status" status={payment.status}>{payment.status}</Badge> },
+    { key: 'createdAt', label: 'Created', render: (payment: any) => formatDateTime(payment.createdAt) },
+  ];
 
   return (
     <div className="space-y-6">
@@ -35,36 +84,91 @@ export default function PaymentsPage() {
           <h1 className="text-2xl font-bold text-foreground">Payments</h1>
           <p className="text-muted-foreground">Manage payment transactions and refunds</p>
         </div>
-        <ActionButton icon={Download} variant="secondary">Export</ActionButton>
+        <ActionButton icon={Download} variant="secondary" onClick={() => setExportModalOpen(true)}>Export</ActionButton>
       </div>
 
       <div className="card">
         <div className="grid grid-cols-1 md:grid-cols-3 gap-4">
-          
-      <div>
-        <label className="label">Search</label>
-        <input type="text" placeholder="Search..." className="input" value={filters.search} onChange={(e) => setFilters({ ...filters, search: e.target.value })} />
-      </div>
-      <div>
-        <label className="label">Status</label>
-        <select className="input" value={filters.status} onChange={(e) => setFilters({ ...filters, status: e.target.value })}>
-          <option value="">All Status</option>
-          <option value="PENDING">Pending</option>
-          <option value="COMPLETED">Completed</option>
-          <option value="FAILED">Failed</option>
-        </select>
-      </div>
-    
+          <div>
+            <label className="label">Search</label>
+            <input type="text" placeholder="Search..." className="input" value={filters.search} onChange={(e) => setFilters({ ...filters, search: e.target.value })} />
+          </div>
+          <div>
+            <label className="label">Status</label>
+            <select className="input" value={filters.status} onChange={(e) => setFilters({ ...filters, status: e.target.value })}>
+              <option value="">All Status</option>
+              <option value="PENDING">Pending</option>
+              <option value="COMPLETED">Completed</option>
+              <option value="FAILED">Failed</option>
+            </select>
+          </div>
+          <div>
+            <label className="label">Method</label>
+            <select className="input" value={filters.method} onChange={(e) => setFilters({ ...filters, method: e.target.value })}>
+              <option value="">All Methods</option>
+              <option value="TELEBIRR">Telebirr</option>
+              <option value="CBE_BIRR">CBE Birr</option>
+              <option value="EBIRR">eBirr</option>
+              <option value="CARD">Card</option>
+              <option value="WALLET">Wallet</option>
+              <option value="CASH">Cash</option>
+            </select>
+          </div>
         </div>
       </div>
 
       <DataTable
         data={(data as any)?.items || (Array.isArray(data) ? data : [])}
         columns={columns}
-        actions={actions}
+        actions={[]}
         loading={isLoading}
         emptyMessage="No payments found"
       />
+
+      {/* Export Modal */}
+      <Modal isOpen={exportModalOpen} onClose={() => setExportModalOpen(false)} title="Export Payments" size="md">
+        <div className="space-y-4">
+          <div className="grid grid-cols-2 gap-4">
+            <div>
+              <label className="label">Date From</label>
+              <input type="date" className="input" value={exportDateFrom} onChange={(e) => setExportDateFrom(e.target.value)} />
+            </div>
+            <div>
+              <label className="label">Date To</label>
+              <input type="date" className="input" value={exportDateTo} onChange={(e) => setExportDateTo(e.target.value)} />
+            </div>
+          </div>
+
+          <div>
+            <p className="text-sm font-medium mb-2">Select Columns</p>
+            <div className="space-y-2">
+              {[
+                { key: 'reference', label: 'Reference' },
+                { key: 'booking', label: 'Booking Reference' },
+                { key: 'amount', label: 'Amount' },
+                { key: 'method', label: 'Payment Method' },
+                { key: 'status', label: 'Status' },
+                { key: 'createdAt', label: 'Created At' },
+              ].map((col) => (
+                <label key={col.key} className="flex items-center gap-3 p-2 hover:bg-gray-50 dark:hover:bg-gray-900/50 rounded cursor-pointer">
+                  <input
+                    type="checkbox"
+                    checked={exportColumns[col.key] || false}
+                    onChange={(e) => setExportColumns({ ...exportColumns, [col.key]: e.target.checked })}
+                    className="w-4 h-4 rounded border-gray-300"
+                  />
+                  <span className="text-sm font-medium">{col.label}</span>
+                </label>
+              ))}
+            </div>
+          </div>
+
+          <div className="flex justify-end gap-2 pt-4 border-t">
+            <ActionButton variant="secondary" onClick={() => setExportModalOpen(false)}>Cancel</ActionButton>
+            <ActionButton onClick={confirmExport}>Export CSV</ActionButton>
+          </div>
+        </div>
+      </Modal>
     </div>
   );
 }
diff --git a/apps/edr-passenger-web/backoffice/src/app/seats/page.tsx b/apps/edr-passenger-web/backoffice/src/app/seats/page.tsx
index 78879e96e..cb26bd431 100644
--- a/apps/edr-passenger-web/backoffice/src/app/seats/page.tsx
+++ b/apps/edr-passenger-web/backoffice/src/app/seats/page.tsx
@@ -228,7 +228,7 @@ export default function SeatsPage() {
 
     const hasBedPositionData = validSeats.some((s: any) => s.bedPosition);
 
-    if (isBedCoach && hasBedPositionData) {
+    if (isBedCoach) {
       const arrangement = parseSeatArrangement(coach.seatArrangement);
       const seatsPerRow = arrangement[0] + (arrangement[1] || 0);
       const allSeatsForLayout = [...validSeats, ...removedSeats];
diff --git a/apps/edr-passenger-web/backoffice/src/app/tickets/page.tsx b/apps/edr-passenger-web/backoffice/src/app/tickets/page.tsx
index 6a0364473..39bcdb64a 100644
--- a/apps/edr-passenger-web/backoffice/src/app/tickets/page.tsx
+++ b/apps/edr-passenger-web/backoffice/src/app/tickets/page.tsx
@@ -9,11 +9,11 @@ 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 { ticketsApi, apiClient, schedulesApi, stationsApi } from '@/lib/api';
+import { ticketsApi, apiClient, stationsApi } from '@/lib/api';
 import { formatDateTime, formatCurrency } from '@/lib/utils';
 
 export default function TicketsPage() {
-  const [filters, setFilters] = useState({ search: '', status: '', originStationId: '', destinationStationId: '', tripDate: '' });
+  const [filters, setFilters] = useState({ search: '', status: '', originStationId: '', destinationStationId: '', arrivalDate: '' });
   const [deleteConfirmOpen, setDeleteConfirmOpen] = useState(false);
   const [ticketToDelete, setTicketToDelete] = useState<any>(null);
   const [boardConfirmOpen, setBoardConfirmOpen] = useState(false);
@@ -22,6 +22,8 @@ export default function TicketsPage() {
   const [detailsModalOpen, setDetailsModalOpen] = useState(false);
   const [selectedTicket, setSelectedTicket] = useState<any>(null);
   const [exportModalOpen, setExportModalOpen] = useState(false);
+  const [exportDateFrom, setExportDateFrom] = useState('');
+  const [exportDateTo, setExportDateTo] = useState('');
   const [selectedColumns, setSelectedColumns] = useState<Record<string, boolean>>({
     ticketNumber: true,
     booking: true,
@@ -35,7 +37,15 @@ export default function TicketsPage() {
 
   const { data, isLoading, error } = useQuery({
     queryKey: ['tickets', filters],
-    queryFn: () => ticketsApi.getAll({ ...filters, skip: 0, take: 50 }),
+    queryFn: () => ticketsApi.getAll({
+      search: filters.search || undefined,
+      status: filters.status || undefined,
+      originStationId: filters.originStationId || undefined,
+      destinationStationId: filters.destinationStationId || undefined,
+      arrivalDate: filters.arrivalDate || undefined,
+      skip: 0,
+      take: 50,
+    }),
   });
 
   const { data: stationsData } = useQuery({
@@ -94,25 +104,31 @@ export default function TicketsPage() {
     }
   };
 
-  const handleExportTickets = async () => {
-    setExportModalOpen(true);
-  };
-
   const confirmExport = () => {
     const cols = Object.entries(selectedColumns)
       .filter(([, selected]) => selected)
       .map(([col]) => col);
-    
+
     if (cols.length === 0) {
       alert('Please select at least one column');
       return;
     }
 
+    const exportItems = (data?.items || []).filter((ticket: any) => {
+      if (!exportDateFrom && !exportDateTo) return true;
+      const d = ticket.schedule?.arrivalAt
+        ? new Date(ticket.schedule.arrivalAt).toISOString().split('T')[0]
+        : null;
+      if (exportDateFrom && (!d || d < exportDateFrom)) return false;
+      if (exportDateTo && (!d || d > exportDateTo)) return false;
+      return true;
+    });
+
     const csv = [
       cols.join(','),
-      ...data?.items?.map((ticket: any) => {
+      ...exportItems.map((ticket: any) => {
         const values = cols.map(col => {
-          switch(col) {
+          switch (col) {
             case 'ticketNumber': return ticket.ticketNumber || '';
             case 'booking': return ticket.booking?.bookingRef || '';
             case 'trip': return `${ticket.schedule?.originStation?.name || ''}-${ticket.schedule?.destinationStation?.name || ''}`;
@@ -126,9 +142,9 @@ export default function TicketsPage() {
           }
         });
         return values.map(v => `"${v}"`).join(',');
-      }) || []
+      }),
     ].join('\n');
-    
+
     const blob = new Blob([csv], { type: 'text/csv' });
     const url = window.URL.createObjectURL(blob);
     const a = document.createElement('a');
@@ -175,12 +191,12 @@ export default function TicketsPage() {
     },
     {
       key: 'seat',
-      label: 'Seat',
+      label: 'Seat/Bed',
       sortable: true,
       render: (ticket: any) => (
         <div>
-          <div className="font-mono font-semibold">Coach {ticket.seat?.coach?.number || 'N/A'} - Seat {ticket.seat?.seatNumber || 'N/A'}</div>
-          <div className="text-xs text-muted-foreground">{ticket.seat?.coach?.coachType?.name || 'N/A'}</div>
+          <div className="font-mono font-semibold">{ticket.seat?.coach?.number || 'N/A'} - {ticket.seat?.seatNumber || 'N/A'}</div>
+          <div className="text-xs text-muted-foreground">{ticket.seat?.coach?.coachType?.type || 'N/A'}</div>
         </div>
       ),
     },
@@ -264,7 +280,7 @@ export default function TicketsPage() {
           <h1 className="text-2xl font-bold text-foreground">Tickets</h1>
           <p className="text-muted-foreground">Manage tickets and validations</p>
         </div>
-        <ActionButton icon={Download} variant="secondary" onClick={handleExportTickets}>Export</ActionButton>
+        <ActionButton icon={Download} variant="secondary" onClick={() => setExportModalOpen(true)}>Export</ActionButton>
       </div>
 
       {/* Filters */}
@@ -317,12 +333,12 @@ export default function TicketsPage() {
             </select>
           </div>
           <div>
-            <label className="label">Trip Date</label>
+            <label className="label">Arrival Date</label>
             <input
               type="date"
               className="input"
-              value={filters.tripDate}
-              onChange={(e) => setFilters({ ...filters, tripDate: e.target.value })}
+              value={filters.arrivalDate}
+              onChange={(e) => setFilters({ ...filters, arrivalDate: e.target.value })}
             />
           </div>
           <div>
@@ -353,10 +369,7 @@ export default function TicketsPage() {
       {/* Board Confirmation Dialog */}
       <ConfirmDialog
         isOpen={boardConfirmOpen}
-        onClose={() => {
-          setBoardConfirmOpen(false);
-          setTicketToBoard(null);
-        }}
+        onClose={() => { setBoardConfirmOpen(false); setTicketToBoard(null); }}
         onConfirm={handleConfirmBoard}
         title="Board Ticket"
         message={`Are you sure you want to board ticket ${ticketToBoard?.ticketNumber}? This will mark the ticket as USED.`}
@@ -368,10 +381,7 @@ export default function TicketsPage() {
       {/* Delete Confirmation Dialog */}
       <ConfirmDialog
         isOpen={deleteConfirmOpen}
-        onClose={() => {
-          setDeleteConfirmOpen(false);
-          setTicketToDelete(null);
-        }}
+        onClose={() => { setDeleteConfirmOpen(false); setTicketToDelete(null); }}
         onConfirm={handleConfirmDelete}
         title="Delete Ticket"
         message={`Are you sure you want to permanently delete ticket ${ticketToDelete?.ticketNumber}? This action cannot be undone.`}
@@ -384,10 +394,7 @@ export default function TicketsPage() {
       {/* Ticket Details Modal */}
       <Modal
         isOpen={detailsModalOpen}
-        onClose={() => {
-          setDetailsModalOpen(false);
-          setSelectedTicket(null);
-        }}
+        onClose={() => { setDetailsModalOpen(false); setSelectedTicket(null); }}
         title="Ticket Details"
         size="lg"
       >
@@ -488,13 +495,7 @@ export default function TicketsPage() {
             )}
 
             <div className="flex justify-end gap-2 pt-4">
-              <ActionButton
-                variant="secondary"
-                onClick={() => {
-                  setDetailsModalOpen(false);
-                  setSelectedTicket(null);
-                }}
-              >
+              <ActionButton variant="secondary" onClick={() => { setDetailsModalOpen(false); setSelectedTicket(null); }}>
                 Close
               </ActionButton>
             </div>
@@ -502,49 +503,55 @@ export default function TicketsPage() {
         )}
       </Modal>
 
-      {/* Export Columns Modal */}
+      {/* Export Modal */}
       <Modal
         isOpen={exportModalOpen}
         onClose={() => setExportModalOpen(false)}
-        title="Export Tickets - Select Columns"
+        title="Export Tickets"
         size="md"
       >
         <div className="space-y-4">
-          <p className="text-sm text-muted-foreground">Select which columns to include in the export</p>
-          
-          <div className="space-y-3 max-h-96 overflow-y-auto">
-            {[
-              { key: 'ticketNumber', label: 'Ticket Number' },
-              { key: 'booking', label: 'Booking Reference & Passenger' },
-              { key: 'trip', label: 'Trip (Origin → Destination)' },
-              { key: 'coach', label: 'Coach Number' },
-              { key: 'seat', label: 'Seat Number' },
-              { key: 'seatClass', label: 'Seat Class' },
-              { key: 'amount', label: 'Amount' },
-              { key: 'status', label: 'Status' },
-              { key: 'boarded', label: 'Boarded Status' },
-            ].map((col) => (
-              <label key={col.key} className="flex items-center gap-3 p-2 hover:bg-gray-50 dark:hover:bg-gray-900/50 rounded cursor-pointer">
-                <input
-                  type="checkbox"
-                  checked={selectedColumns[col.key] || false}
-                  onChange={(e) =>
-                    setSelectedColumns({ ...selectedColumns, [col.key]: e.target.checked })
-                  }
-                  className="w-4 h-4 rounded border-gray-300"
-                />
-                <span className="text-sm font-medium">{col.label}</span>
-              </label>
-            ))}
+          <div className="grid grid-cols-2 gap-4">
+            <div>
+              <label className="label">Date From (Arrival)</label>
+              <input type="date" className="input" value={exportDateFrom} onChange={(e) => setExportDateFrom(e.target.value)} />
+            </div>
+            <div>
+              <label className="label">Date To (Arrival)</label>
+              <input type="date" className="input" value={exportDateTo} onChange={(e) => setExportDateTo(e.target.value)} />
+            </div>
+          </div>
+
+          <div>
+            <p className="text-sm font-medium mb-2">Select Columns</p>
+            <div className="space-y-2 max-h-56 overflow-y-auto">
+              {[
+                { key: 'ticketNumber', label: 'Ticket Number' },
+                { key: 'booking', label: 'Booking Reference & Passenger' },
+                { key: 'trip', label: 'Trip (Origin → Destination)' },
+                { key: 'coach', label: 'Coach Number' },
+                { key: 'seat', label: 'Seat Number' },
+                { key: 'seatClass', label: 'Seat Class' },
+                { key: 'amount', label: 'Amount' },
+                { key: 'status', label: 'Status' },
+                { key: 'boarded', label: 'Boarded Status' },
+              ].map((col) => (
+                <label key={col.key} className="flex items-center gap-3 p-2 hover:bg-gray-50 dark:hover:bg-gray-900/50 rounded cursor-pointer">
+                  <input
+                    type="checkbox"
+                    checked={selectedColumns[col.key] || false}
+                    onChange={(e) => setSelectedColumns({ ...selectedColumns, [col.key]: e.target.checked })}
+                    className="w-4 h-4 rounded border-gray-300"
+                  />
+                  <span className="text-sm font-medium">{col.label}</span>
+                </label>
+              ))}
+            </div>
           </div>
 
           <div className="flex justify-end gap-2 pt-4 border-t">
-            <ActionButton variant="secondary" onClick={() => setExportModalOpen(false)}>
-              Cancel
-            </ActionButton>
-            <ActionButton onClick={confirmExport}>
-              Export CSV
-            </ActionButton>
+            <ActionButton variant="secondary" onClick={() => setExportModalOpen(false)}>Cancel</ActionButton>
+            <ActionButton onClick={confirmExport}>Export CSV</ActionButton>
           </div>
         </div>
       </Modal>
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 d3e75d7d9..d51410dff 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
@@ -285,6 +285,7 @@ export default function ReviewPage() {
             const isEthiopian = p.nationality === 'ETHIOPIAN' || p.nationality === 'Ethiopian';
             return {
               seatId: isRoundTrip ? (p as any).outboundSeatId : (p.seatId || ''),
+              ...(isRoundTrip && { returnSeatId: (p as any).inboundSeatId || '' }),
               passengerName: p.name,
               dateOfBirth: p.dateOfBirth,
               idDocumentType: isEthiopian ? 'NATIONAL_ID' : 'PASSPORT',
@@ -323,6 +324,7 @@ export default function ReviewPage() {
             const isEthiopian = p.nationality === 'ETHIOPIAN' || p.nationality === 'Ethiopian';
             return {
               seatId: isRoundTrip ? (p as any).outboundSeatId : (p.seatId || ''),
+              ...(isRoundTrip && { returnSeatId: (p as any).inboundSeatId || '' }),
               passengerName: p.name,
               dateOfBirth: p.dateOfBirth,
               idDocumentType: isEthiopian ? 'NATIONAL_ID' : 'PASSPORT',
diff --git a/apps/edr-payment-api/src/config/app.config.ts b/apps/edr-payment-api/src/config/app.config.ts
index c1128a872..041c47ac6 100644
--- a/apps/edr-payment-api/src/config/app.config.ts
+++ b/apps/edr-payment-api/src/config/app.config.ts
@@ -10,10 +10,10 @@ export default registerAs("app", () => ({
   serviceAuthToken: process.env.SERVICE_AUTH_TOKEN ?? "",
   reconciliation: {
     /** How often the stale-intent sweep runs. */
-    sweepIntervalMs: parseInt(
-      process.env.RECONCILE_SWEEP_INTERVAL_MS ?? "60000",
-      10,
-    ),
+    // TODO(demo): revert to the env-driven line below after the demo. Temporarily FORCED to 30s
+    // here so the .env (RECONCILE_SWEEP_INTERVAL_MS) cannot override it.
+    // sweepIntervalMs: parseInt(process.env.RECONCILE_SWEEP_INTERVAL_MS ?? "60000", 10),
+    sweepIntervalMs: 30_000,
     /** An intent is "stale" when non-terminal and untouched for this long. */
     staleAfterMs: parseInt(process.env.RECONCILE_STALE_AFTER_MS ?? "60000", 10),
     batchSize: parseInt(process.env.RECONCILE_BATCH_SIZE ?? "20", 10),
diff --git a/apps/edr-payment-api/src/config/waafi.config.ts b/apps/edr-payment-api/src/config/waafi.config.ts
index 05624922f..cfe2102f7 100644
--- a/apps/edr-payment-api/src/config/waafi.config.ts
+++ b/apps/edr-payment-api/src/config/waafi.config.ts
@@ -13,7 +13,10 @@ export default registerAs("waafi", () => ({
   // Wallet payment method (EVC/ZAAD/Sahal) — MWALLET_ACCOUNT requires the payer phone up front.
   paymentMethod: process.env.WAAFI_PAYMENT_METHOD ?? "MWALLET_ACCOUNT",
   // Waafi has no ETB; when set this overrides the asserted currency (USD/DJF/SLSH).
-  currency: process.env.WAAFI_CURRENCY ?? "DJF",
+  // TODO(demo): revert to the env-driven line below after the demo. Temporarily FORCED to USD
+  // here so the .env (WAAFI_CURRENCY) cannot override it.
+  // currency: process.env.WAAFI_CURRENCY ?? "DJF",
+  currency: "USD",
   // Browser redirect targets after the hosted page completes/fails (UX only; webhook is source of truth).
   successUrl: process.env.WAAFI_HPP_SUCCESS_URL ?? "",
   failureUrl: process.env.WAAFI_HPP_FAILURE_URL ?? "",
diff --git a/apps/edr-payment-api/src/modules/reconciliation/reconciliation.service.ts b/apps/edr-payment-api/src/modules/reconciliation/reconciliation.service.ts
index b74c9b899..98595f8f2 100644
--- a/apps/edr-payment-api/src/modules/reconciliation/reconciliation.service.ts
+++ b/apps/edr-payment-api/src/modules/reconciliation/reconciliation.service.ts
@@ -42,7 +42,7 @@ export class ReconciliationService implements OnModuleInit, OnModuleDestroy {
     private readonly cacBankProvider: CacBankProvider,
   ) {
     this.intervalMs =
-      config.get<number>("app.reconciliation.sweepIntervalMs") ?? 60_000;
+      config.get<number>("app.reconciliation.sweepIntervalMs") ?? 30_000;
     this.staleAfterMs =
       config.get<number>("app.reconciliation.staleAfterMs") ?? 60_000;
     this.batchSize = config.get<number>("app.reconciliation.batchSize") ?? 20;
diff --git a/package.json b/package.json
index 575de8c41..8dfa9b5c0 100644
--- a/package.json
+++ b/package.json
@@ -5,7 +5,13 @@
   "scripts": {
     "dev": "turbo run dev",
     "dev:freight": "turbo run dev --filter=@edr/freight-api... --filter=@edr/freight-portal... --filter=@edr/freight-backoffice... --filter=@edr/ui-common...",
+    "dev:freight:api": "turbo run dev --filter=@edr/freight-api",
+    "dev:freight:portal": "turbo run dev --filter=@edr/freight-portal",
+    "dev:freight:backoffice": "turbo run dev --filter=@edr/freight-backoffice",
     "dev:passenger": "turbo run dev --filter=@edr/passenger-api... --filter=@edr/passenger-portal... --filter=@edr/passenger-backoffice...",
+    "dev:passenger:api": "turbo run dev --filter=@edr/passenger-api",
+    "dev:passenger:portal": "turbo run dev --filter=@edr/passenger-portal",
+    "dev:passenger:backoffice": "turbo run dev --filter=@edr/passenger-backoffice",
     "dev:payment": "turbo run dev --filter=@edr/payment-api...",
     "build": "turbo run build",
     "build:freight": "turbo run build --filter=@edr/freight-api... --filter=@edr/freight-portal... --filter=@edr/freight-backoffice...",
diff --git a/turbo.json b/turbo.json
index 548b6d7a9..18f5d7459 100644
--- a/turbo.json
+++ b/turbo.json
@@ -1,5 +1,6 @@
 {
   "$schema": "https://turbo.build/schema.json",
+  "concurrency": "12",
   "tasks": {
     "build": {
       "dependsOn": ["^build"],