diff --git a/apps/edr-freight-api/src/app.module.ts b/apps/edr-freight-api/src/app.module.ts
index 73e28205e..0e7949d7e 100644
--- a/apps/edr-freight-api/src/app.module.ts
+++ b/apps/edr-freight-api/src/app.module.ts
@@ -89,6 +89,8 @@ import { CargoesModule } from "./modules/cargoes/cargoes.module";
 import { RoutesModule } from "./modules/routes/routes.module";
 import { WarehousesModule } from "./modules/warehouses/warehouses.module";
 import { OverviewModule } from "./modules/overview/overview.module";
+import { ReportsModule } from "./modules/reports/reports.module";
+import { UserTradeAccessModule } from "./modules/user-trade-access/user-trade-access.module";
 import { VehiclesModule } from "./modules/vehicles/vehicles.module";
 import { DriversModule } from "./modules/drivers/drivers.module";
 import { FuelModule } from "./modules/fuel/fuel.module";
@@ -206,6 +208,8 @@ import { LoginAudienceMiddleware } from "./modules/auth/login-audience.middlewar
     RoutesModule,
     WarehousesModule,
     OverviewModule,
+    ReportsModule,
+    UserTradeAccessModule,
     VehiclesModule,
     DriversModule,
     FuelModule,
diff --git a/apps/edr-freight-api/src/migrations/3150000000000-CreateUserTradeAccess.ts b/apps/edr-freight-api/src/migrations/3150000000000-CreateUserTradeAccess.ts
new file mode 100644
index 000000000..9e7cba924
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/3150000000000-CreateUserTradeAccess.ts
@@ -0,0 +1,43 @@
+import { MigrationInterface, QueryRunner, Table, TableIndex } from 'typeorm';
+
+/**
+ * Per-backoffice-user trade-direction scope (import / export / intercity).
+ * A user with no row (or all three directions) is unrestricted. Admins
+ * (super_admin / organization_admin) bypass the scope entirely.
+ */
+export class CreateUserTradeAccess3150000000000 implements MigrationInterface {
+  name = 'CreateUserTradeAccess3150000000000';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.createTable(
+      new Table({
+        schema: 'freight',
+        name: 'user_trade_access',
+        columns: [
+          { name: 'id', type: 'uuid', isPrimary: true, generationStrategy: 'uuid', default: 'gen_random_uuid()' },
+          // IAM user id (iam.users) — no FK, iam schema is externally owned.
+          { name: 'user_id', type: 'uuid', isUnique: true },
+          // Comma-separated subset of IMPORT,EXPORT,DOMESTIC (simple-array).
+          { name: 'directions', type: 'text', default: "''" },
+          { name: 'updated_by_id', type: 'uuid', isNullable: true },
+          { name: 'created_at', type: 'timestamptz', default: 'now()' },
+          { name: 'updated_at', type: 'timestamptz', default: 'now()' },
+          { name: 'deleted_at', type: 'timestamptz', isNullable: true },
+        ],
+      }),
+      true,
+    );
+
+    await queryRunner.createIndex(
+      'freight.user_trade_access',
+      new TableIndex({
+        name: 'idx_user_trade_access_user_id',
+        columnNames: ['user_id'],
+      }),
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.dropTable('freight.user_trade_access', true);
+  }
+}
diff --git a/apps/edr-freight-api/src/migrations/3170000000000-YardFacilityOriginDestination.ts b/apps/edr-freight-api/src/migrations/3170000000000-YardFacilityOriginDestination.ts
new file mode 100644
index 000000000..fb361b702
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/3170000000000-YardFacilityOriginDestination.ts
@@ -0,0 +1,45 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+/**
+ * Handling a freight type is not the same as handling it in both directions. A
+ * facility can be equipped to load containers onto a train but have no yard
+ * space to receive and stage inbound ones, so the origin and destination sides
+ * are stated independently per freight type.
+ *
+ * Backfilled from `handles_container` / `handles_bulk` so every existing row
+ * keeps its current behaviour: a facility that handles a type today handles it
+ * on both sides until someone narrows it in the backoffice. New rows default
+ * false — an unconfigured facility offers nothing rather than silently
+ * offering everything.
+ */
+export class YardFacilityOriginDestination3170000000000 implements MigrationInterface {
+  name = 'YardFacilityOriginDestination3170000000000';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      ALTER TABLE freight.yard_facilities
+        ADD COLUMN IF NOT EXISTS has_container_facility_origin      boolean NOT NULL DEFAULT false,
+        ADD COLUMN IF NOT EXISTS has_bulk_facility_origin           boolean NOT NULL DEFAULT false,
+        ADD COLUMN IF NOT EXISTS has_container_facility_destination boolean NOT NULL DEFAULT false,
+        ADD COLUMN IF NOT EXISTS has_bulk_facility_destination      boolean NOT NULL DEFAULT false
+    `);
+
+    await queryRunner.query(`
+      UPDATE freight.yard_facilities
+         SET has_container_facility_origin      = handles_container,
+             has_container_facility_destination = handles_container,
+             has_bulk_facility_origin           = handles_bulk,
+             has_bulk_facility_destination      = handles_bulk
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      ALTER TABLE freight.yard_facilities
+        DROP COLUMN IF EXISTS has_container_facility_origin,
+        DROP COLUMN IF EXISTS has_bulk_facility_origin,
+        DROP COLUMN IF EXISTS has_container_facility_destination,
+        DROP COLUMN IF EXISTS has_bulk_facility_destination
+    `);
+  }
+}
diff --git a/apps/edr-freight-api/src/migrations/3180000000000-PortYardFacilityRecords.ts b/apps/edr-freight-api/src/migrations/3180000000000-PortYardFacilityRecords.ts
new file mode 100644
index 000000000..f07252959
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/3180000000000-PortYardFacilityRecords.ts
@@ -0,0 +1,40 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+/**
+ * 3170 backfilled the per-side facility flags onto EXISTING yard_facilities
+ * rows, but the Djibouti port yards (Negad, the Doraleh terminals) are flagged
+ * `has_facility` without ever getting a facility record — the seeder only
+ * covers the inland intercity facilities. With the contract route picker now
+ * gating on the per-side flags, those yards report false on every side and
+ * vanish: import contracts lose all origin options, exports all destinations.
+ *
+ * Give every facility-flagged yard that has no live record one with both
+ * freight types open on both sides — exactly the offerability these yards had
+ * before the gate existed. Ops can narrow a port from the backoffice yards
+ * page, which now edits these flags.
+ */
+export class PortYardFacilityRecords3180000000000 implements MigrationInterface {
+  name = 'PortYardFacilityRecords3180000000000';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      INSERT INTO freight.yard_facilities
+        (yard_id, has_warehouse, handles_container, handles_bulk,
+         has_container_facility_origin, has_bulk_facility_origin,
+         has_container_facility_destination, has_bulk_facility_destination)
+      SELECT y.id, false, true, true, true, true, true, true
+        FROM freight.yards y
+       WHERE y.deleted_at IS NULL
+         AND y.has_facility = true
+         AND NOT EXISTS (
+           SELECT 1 FROM freight.yard_facilities f
+            WHERE f.yard_id = y.id AND f.deleted_at IS NULL
+         )
+    `);
+  }
+
+  public async down(): Promise<void> {
+    // Data seed — the inserted rows are indistinguishable from operator edits
+    // afterwards, so reversing would risk deleting real configuration.
+  }
+}
diff --git a/apps/edr-freight-api/src/migrations/3190000000000-AddCargoTypeTonsPerWagonMap.ts b/apps/edr-freight-api/src/migrations/3190000000000-AddCargoTypeTonsPerWagonMap.ts
new file mode 100644
index 000000000..04fb6c1aa
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/3190000000000-AddCargoTypeTonsPerWagonMap.ts
@@ -0,0 +1,25 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+/**
+ * PER_TON (bulk) cargo can have a loading limit BELOW the wagon's rated
+ * capacity: sugar rides 50T on a 70T wagon (density/stowage/policy), so 200T
+ * needs 4 wagons, not the 3 that raw capacity implies. Stored as a jsonb map
+ * { [wagonTypeId]: maxTons } on cargo_types — the PER_TON mirror of
+ * items_per_wagon_map. Unset (or no key) means the wagon's full rated capacity,
+ * so existing cargo types keep their current behaviour with no backfill.
+ */
+export class AddCargoTypeTonsPerWagonMap3190000000000 implements MigrationInterface {
+  name = 'AddCargoTypeTonsPerWagonMap3190000000000';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "freight"."cargo_types" ADD COLUMN IF NOT EXISTS "tons_per_wagon_map" jsonb`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "freight"."cargo_types" DROP COLUMN IF EXISTS "tons_per_wagon_map"`,
+    );
+  }
+}
diff --git a/apps/edr-freight-api/src/migrations/3200000000000-AddScheduleWindowRuleCustom.ts b/apps/edr-freight-api/src/migrations/3200000000000-AddScheduleWindowRuleCustom.ts
new file mode 100644
index 000000000..821c67135
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/3200000000000-AddScheduleWindowRuleCustom.ts
@@ -0,0 +1,28 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+/**
+ * Marks a train schedule whose booking-window rule was configured by staff at
+ * creation rather than inherited from the live global rules.
+ *
+ * Without this flag `restampPendingWindows` — which re-derives EVERY still
+ * PRE_WINDOW schedule from the current global config after a global-rules edit —
+ * would silently overwrite those hand-picked settings, which is precisely what
+ * the per-schedule configuration exists to prevent.
+ *
+ * Defaults false, so every existing schedule keeps following the global rules.
+ */
+export class AddScheduleWindowRuleCustom3200000000000 implements MigrationInterface {
+  name = 'AddScheduleWindowRuleCustom3200000000000';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "freight"."train_schedules" ADD COLUMN IF NOT EXISTS "window_rule_custom" boolean NOT NULL DEFAULT false`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "freight"."train_schedules" DROP COLUMN IF EXISTS "window_rule_custom"`,
+    );
+  }
+}
diff --git a/apps/edr-freight-api/src/migrations/3210000000000-EmptyContainerReturnedBy.ts b/apps/edr-freight-api/src/migrations/3210000000000-EmptyContainerReturnedBy.ts
new file mode 100644
index 000000000..b6f23b19e
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/3210000000000-EmptyContainerReturnedBy.ts
@@ -0,0 +1,19 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class EmptyContainerReturnedBy3210000000000 implements MigrationInterface {
+  name = 'EmptyContainerReturnedBy3210000000000';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      ALTER TABLE freight.empty_container_returns
+      ADD COLUMN IF NOT EXISTS returned_by varchar(20) NULL
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      ALTER TABLE freight.empty_container_returns
+      DROP COLUMN IF EXISTS returned_by
+    `);
+  }
+}
diff --git a/apps/edr-freight-api/src/migrations/3220000000000-EmptyContainerReturnStatusHistory.ts b/apps/edr-freight-api/src/migrations/3220000000000-EmptyContainerReturnStatusHistory.ts
new file mode 100644
index 000000000..da9267713
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/3220000000000-EmptyContainerReturnStatusHistory.ts
@@ -0,0 +1,26 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class EmptyContainerReturnStatusHistory3220000000000 implements MigrationInterface {
+  name = 'EmptyContainerReturnStatusHistory3220000000000';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      ALTER TABLE freight.empty_container_returns
+      ADD COLUMN IF NOT EXISTS status_history jsonb NOT NULL DEFAULT '[]'::jsonb
+    `);
+    await queryRunner.query(`
+      UPDATE freight.empty_container_returns
+      SET status_history = jsonb_build_array(
+        jsonb_build_object('status', status, 'changedAt', created_at, 'performedBy', performed_by)
+      )
+      WHERE status_history = '[]'::jsonb
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      ALTER TABLE freight.empty_container_returns
+      DROP COLUMN IF EXISTS status_history
+    `);
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/auth/dto/list-users-query.dto.ts b/apps/edr-freight-api/src/modules/auth/dto/list-users-query.dto.ts
new file mode 100644
index 000000000..2325568e9
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/auth/dto/list-users-query.dto.ts
@@ -0,0 +1,38 @@
+import { ApiPropertyOptional } from '@nestjs/swagger';
+import { EUserStatus, EUserType } from '@tria-plc/api-common/utils/enums/user.enum';
+import { Transform, TransformFnParams } from 'class-transformer';
+import { IsBoolean, IsEnum, IsIn, IsOptional } from 'class-validator';
+
+import { PaginationQueryDto } from '../../../common/dto/pagination-query.dto';
+
+/** Query-string booleans arrive as strings; implicit conversion is off app-wide. */
+const toOptionalBoolean = ({ value }: TransformFnParams): boolean | undefined =>
+  value === undefined || value === null || value === ''
+    ? undefined
+    : value === true || value === 'true';
+
+export class ListUsersQueryDto extends PaginationQueryDto {
+  @ApiPropertyOptional({ enum: EUserType })
+  @IsOptional()
+  @IsEnum(EUserType)
+  userType?: EUserType;
+
+  @ApiPropertyOptional({ enum: EUserStatus })
+  @IsOptional()
+  @IsEnum(EUserStatus)
+  userStatus?: EUserStatus;
+
+  @ApiPropertyOptional({ description: 'Filter by active flag.' })
+  @IsOptional()
+  @Transform(toOptionalBoolean)
+  @IsBoolean()
+  isActive?: boolean;
+
+  @ApiPropertyOptional({
+    enum: ['username', 'email', 'createdAt'],
+    default: 'username',
+  })
+  @IsOptional()
+  @IsIn(['username', 'email', 'createdAt'])
+  sortBy?: string;
+}
diff --git a/apps/edr-freight-api/src/modules/auth/freight-auth.module.ts b/apps/edr-freight-api/src/modules/auth/freight-auth.module.ts
index 10dbd0b37..ff8f803b9 100644
--- a/apps/edr-freight-api/src/modules/auth/freight-auth.module.ts
+++ b/apps/edr-freight-api/src/modules/auth/freight-auth.module.ts
@@ -19,6 +19,8 @@ import { ForgotPasswordController } from './forgot-password.controller';
 import { ForgotPasswordService } from './forgot-password.service';
 import { FreightMeController } from './freight-me.controller';
 import { FreightMeService } from './freight-me.service';
+import { ListUsersController } from './list-users.controller';
+import { ListUsersService } from './list-users.service';
 
 @Module({
   imports: [
@@ -39,8 +41,10 @@ import { FreightMeService } from './freight-me.service';
     CheckAvailabilityController,
     ForgotPasswordController,
     CustomerResetController,
+    ListUsersController,
   ],
   providers: [
+    ListUsersService,
     FreightMeService,
     AccountService,
     CheckAvailabilityService,
diff --git a/apps/edr-freight-api/src/modules/auth/list-users.controller.ts b/apps/edr-freight-api/src/modules/auth/list-users.controller.ts
new file mode 100644
index 000000000..e7fbfd771
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/auth/list-users.controller.ts
@@ -0,0 +1,22 @@
+import { Controller, Get, Query } from '@nestjs/common';
+import { ApiBearerAuth, ApiOperation, ApiTags } from '@nestjs/swagger';
+
+import { ListUsersQueryDto } from './dto/list-users-query.dto';
+import { ListUsersService } from './list-users.service';
+import { StaffReference } from '../../common/booking-guards';
+
+@ApiTags('auth')
+@Controller('staff/users')
+@ApiBearerAuth()
+export class ListUsersController {
+  constructor(private readonly service: ListUsersService) {}
+
+  @Get()
+  @StaffReference()
+  @ApiOperation({
+    summary: 'List IAM users (paginated) for backoffice pickers',
+  })
+  findAll(@Query() query: ListUsersQueryDto) {
+    return this.service.findAll(query);
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/auth/list-users.service.ts b/apps/edr-freight-api/src/modules/auth/list-users.service.ts
new file mode 100644
index 000000000..cf7e22be2
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/auth/list-users.service.ts
@@ -0,0 +1,69 @@
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { PaginatedResponse } from '@edr/types';
+import { User } from '@tria-plc/iamapi-common/entities/iam/user/user.entity';
+import { Repository } from 'typeorm';
+
+import { ListUsersQueryDto } from './dto/list-users-query.dto';
+import { paginateQuery } from '../../common/utils/pagination.util';
+
+/**
+ * Read-only listing of `iam.users` for backoffice pickers.
+ *
+ * Exists because `@tria-plc/iamapi-common@1.0.0`'s `GET /users/filter` pairs a
+ * `@QueryParams()` pagination DTO with a plain `@Query()` DTO that does not
+ * declare `skip`/`take`/`orderBy`; the global whitelist pipe then 400s on the
+ * very params the route's own paginator reads. Drop this once IAM ships a fix.
+ */
+@Injectable()
+export class ListUsersService {
+  constructor(
+    @InjectRepository(User) private readonly users: Repository<User>,
+  ) {}
+
+  findAll(query: ListUsersQueryDto): Promise<PaginatedResponse<User>> {
+    const sortBy = query.sortBy ?? 'username';
+    const qb = this.users
+      .createQueryBuilder('user')
+      // Explicit select: never widen this to `user` — the entity's lazy
+      // relations include credentials and sessions.
+      .select([
+        'user.id',
+        'user.name',
+        'user.username',
+        'user.email',
+        'user.phoneNumber',
+        'user.userType',
+        'user.status',
+        'user.isActive',
+        'user.createdAt',
+      ])
+      .orderBy(`user.${sortBy}`, query.sortOrder ?? 'ASC');
+
+    if (query.userType) {
+      qb.andWhere('user.userType = :userType', { userType: query.userType });
+    }
+    if (query.userStatus) {
+      qb.andWhere('user.status = :userStatus', { userStatus: query.userStatus });
+    }
+    if (query.isActive !== undefined) {
+      qb.andWhere('user.isActive = :isActive', { isActive: query.isActive });
+    }
+    if (query.search) {
+      // `name` is localized jsonb ({ en, am, … }), not a string — match its
+      // values rather than casting the whole object to text.
+      qb.andWhere(
+        `(user.username ILIKE :search
+          OR user.email ILIKE :search
+          OR user.phone_number ILIKE :search
+          OR EXISTS (
+            SELECT 1 FROM jsonb_each_text(user.name) AS n(k, v)
+            WHERE n.v ILIKE :search
+          ))`,
+        { search: `%${query.search}%` },
+      );
+    }
+
+    return paginateQuery(qb, query);
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/backoffice/backoffice.service.ts b/apps/edr-freight-api/src/modules/backoffice/backoffice.service.ts
index d49cc304e..49384922e 100644
--- a/apps/edr-freight-api/src/modules/backoffice/backoffice.service.ts
+++ b/apps/edr-freight-api/src/modules/backoffice/backoffice.service.ts
@@ -59,6 +59,30 @@ export class BackofficeService {
     ];
   }
 
+  /**
+   * IAM user ids of current employees (any org) holding ANY of the given
+   * permission keys — used by the notification recipients resolver's
+   * `permissionKeys` selector for department/role-scoped targeting.
+   */
+  async getEmployeeUserIdsByPermission(
+    permissionKeys: string[],
+  ): Promise<string[]> {
+    if (!permissionKeys.length) return [];
+    const rows: { userId: string | null }[] = await this.employeeRepository
+      .createQueryBuilder("employee")
+      .innerJoin("employee.employeePositions", "employeePosition")
+      .innerJoin("employeePosition.position", "position")
+      .innerJoin("position.positionPermission", "positionPermission")
+      .innerJoin("positionPermission.permission", "permission")
+      .where("employee.isCurrent = :isCurrent", { isCurrent: true })
+      .andWhere("permission.key IN (:...permissionKeys)", { permissionKeys })
+      .select("DISTINCT employee.user_id", "userId")
+      .getRawMany();
+    return rows
+      .map((r) => r.userId)
+      .filter((id): id is string => Boolean(id));
+  }
+
   async createOrganizationUser(
     organizationId: string,
     dto: CreateOrganizationUserDto,
diff --git a/apps/edr-freight-api/src/modules/billing/billing.controller.ts b/apps/edr-freight-api/src/modules/billing/billing.controller.ts
index b9f0a74c0..49772316a 100644
--- a/apps/edr-freight-api/src/modules/billing/billing.controller.ts
+++ b/apps/edr-freight-api/src/modules/billing/billing.controller.ts
@@ -9,7 +9,11 @@ import {
 import { ApiBearerAuth, ApiOperation, ApiTags } from "@nestjs/swagger";
 import type { Response } from "express";
 
+import { CurrentUser } from "@edr/api-common";
+import type { TCurrentUser } from "@tria-plc/api-common/modules/auth/types/current-user.type";
+
 import { BookingView } from "../../common/booking-guards";
+import { UserTradeAccessService } from "../user-trade-access/user-trade-access.service";
 import { BillingService } from "./billing.service";
 import { FilterInvoiceDto } from "./dto/filter-invoice.dto";
 
@@ -18,14 +22,26 @@ import { FilterInvoiceDto } from "./dto/filter-invoice.dto";
 @BookingView()
 @ApiBearerAuth()
 export class BillingController {
-  constructor(private readonly billingService: BillingService) {}
+  constructor(
+    private readonly billingService: BillingService,
+    private readonly userTradeAccessService: UserTradeAccessService,
+  ) {}
 
   @Get("invoices")
   @ApiOperation({
     summary: "List invoices (paginated, filterable by company/status/search)",
   })
-  findAll(@Query() query: FilterInvoiceDto) {
-    return this.billingService.findAllPaginated(query);
+  async findAll(
+    @Query() query: FilterInvoiceDto,
+    @CurrentUser() user: TCurrentUser,
+  ) {
+    // Per-user trade-direction scope, applied via each invoice's source booking.
+    const allowed =
+      await this.userTradeAccessService.resolveAllowedDirections(user);
+    return this.billingService.findAllPaginated({
+      ...query,
+      tradeDirections: allowed ?? undefined,
+    });
   }
 
   @Get("invoices/:id")
diff --git a/apps/edr-freight-api/src/modules/billing/billing.module.ts b/apps/edr-freight-api/src/modules/billing/billing.module.ts
index 771156fd3..a67e6f6ba 100644
--- a/apps/edr-freight-api/src/modules/billing/billing.module.ts
+++ b/apps/edr-freight-api/src/modules/billing/billing.module.ts
@@ -4,6 +4,7 @@ import { TypeOrmModule } from "@nestjs/typeorm";
 import { BillingController } from "./billing.controller";
 import { PortalBillingController } from "./portal-billing.controller";
 import { PaymentController } from "./payment.controller";
+import { UserTradeAccessModule } from "../user-trade-access/user-trade-access.module";
 import { BillingService } from "./billing.service";
 import { DocumentsModule } from "./documents/documents.module";
 import { Invoice } from "./entities/invoice.entity";
@@ -19,6 +20,7 @@ import { CompaniesModule } from "../companies/companies.module";
     forwardRef(() => PaymentModule),
     CompaniesModule,
     DocumentsModule,
+    UserTradeAccessModule,
   ],
   controllers: [BillingController, PortalBillingController, PaymentController],
   providers: [BillingService, InvoiceRepository, InvoiceLineRepository],
diff --git a/apps/edr-freight-api/src/modules/billing/billing.service.ts b/apps/edr-freight-api/src/modules/billing/billing.service.ts
index 24046aa5c..bd2355df5 100644
--- a/apps/edr-freight-api/src/modules/billing/billing.service.ts
+++ b/apps/edr-freight-api/src/modules/billing/billing.service.ts
@@ -11,6 +11,7 @@ import { EventEmitter2 } from "@nestjs/event-emitter";
 import { DataSource, EntityManager, In } from "typeorm";
 
 import { CompaniesService } from "../companies/companies.service";
+import { applyBookingRefDirectionScope } from "../user-trade-access/trade-scope.util";
 import { PaymentService } from "../payment/payment.service";
 import { InitiateResponseDto, IntentStatusDto } from "../payment/payments.dto";
 import {
@@ -167,6 +168,8 @@ export class BillingService {
       search?: string;
       page?: number;
       pageSize?: number;
+      /** Per-user trade-direction scope, applied via the source booking. */
+      tradeDirections?: string[];
     } = {},
   ): Promise<{ items: Invoice[]; total: number }> {
     const page = filter.page && filter.page > 0 ? filter.page : 1;
@@ -196,6 +199,14 @@ export class BillingService {
       );
     }
 
+    if (filter.tradeDirections) {
+      applyBookingRefDirectionScope(
+        qb,
+        "invoice.source_id",
+        filter.tradeDirections,
+      );
+    }
+
     const [items, total] = await qb.getManyAndCount();
     return { items, total };
   }
diff --git a/apps/edr-freight-api/src/modules/bookings/booking-pricing.service.ts b/apps/edr-freight-api/src/modules/bookings/booking-pricing.service.ts
index b44c1c5e0..9bbe6bed5 100644
--- a/apps/edr-freight-api/src/modules/bookings/booking-pricing.service.ts
+++ b/apps/edr-freight-api/src/modules/bookings/booking-pricing.service.ts
@@ -16,7 +16,7 @@ import {
   containersPerWagonForSize,
   wagonsPerUnitForSize,
 } from '../rule-engine/container-type.util';
-import { bulkItemWagonsForAllowedTypes } from '../train-scheduling/train-capacity.util';
+import { bulkWagonsForAllowedTypes } from '../train-scheduling/train-capacity.util';
 import { BookingsRepository } from './bookings.repository';
 import { wagonRemainder } from './consolidation.service';
 import { GeneratePriceResponseDto, PriceLineItemDto } from './dto/generate-price-response.dto';
@@ -1190,8 +1190,10 @@ export class BookingPricingService {
       // Break-bulk (PER_ITEM): `tons` above is the item count; size by
       // indivisible items instead of pretending the count is tonnage. Best
       // count across allowed wagon types, each capped by its items-fit.
-      const byItems = bulkItemWagonsForAllowedTypes(booking, cargo, capacity);
-      if (byItems > 0) return byItems;
+      // PER_TON cargo may cap tons per wagon below the rating (sugar 50T on a
+      // 70T wagon) — 200T then prices 4 wagons, not 3.
+      const byWagons = bulkWagonsForAllowedTypes(booking, cargo, capacity);
+      if (byWagons > 0) return byWagons;
       return Math.max(1, Math.ceil(tons / capacity));
     } catch {
       return null;
diff --git a/apps/edr-freight-api/src/modules/bookings/booking-reference-data.service.ts b/apps/edr-freight-api/src/modules/bookings/booking-reference-data.service.ts
index 06268342b..2c60b8771 100644
--- a/apps/edr-freight-api/src/modules/bookings/booking-reference-data.service.ts
+++ b/apps/edr-freight-api/src/modules/bookings/booking-reference-data.service.ts
@@ -22,6 +22,7 @@ import {
   IYardsRepository,
   YARDS_REPOSITORY,
 } from "../rule-engine/interfaces/yards.repository.interface";
+import { YardFacilitiesService } from "../rule-engine/services/yard-facilities.service";
 import {
   BookingReferenceCargoTypeChildDto,
   BookingReferenceCargoTypeGroupDto,
@@ -170,11 +171,18 @@ export class BookingReferenceDataService {
     private readonly shippingLinesRepository: IShippingLinesRepository,
     @Inject(CARGO_TYPES_REPOSITORY)
     private readonly cargoTypesRepository: ICargoTypesRepository,
+    private readonly yardFacilitiesService: YardFacilitiesService,
   ) { }
 
   async getReferenceData(): Promise<BookingReferenceDataDto> {
-    const [yards, containerTypes, serviceTypes, shippingLines, cargoTypes] =
-      await Promise.all([
+    const [
+      yards,
+      containerTypes,
+      serviceTypes,
+      shippingLines,
+      cargoTypes,
+      facilityYards,
+    ] = await Promise.all([
         this.yardsRepository.findAll({
           where: { isActive: true },
           order: { displayOrder: "ASC", code: "ASC" },
@@ -195,17 +203,30 @@ export class BookingReferenceDataService {
           where: { isActive: true },
           order: { displayOrder: "ASC", code: "ASC" },
         }),
+        this.yardFacilitiesService.listFacilityYards(),
       ]);
 
+    // Every active yard is still listed; a yard with no facility record simply
+    // reports no capability, so the forms drop it from the pickers themselves.
+    const facilityByYardId = new Map(facilityYards.map((f) => [f.yardId, f]));
+
     return {
-      yard: yards.map(
-        (y): BookingReferenceYardDto => ({
+      yard: yards.map((y): BookingReferenceYardDto => {
+        const facility = facilityByYardId.get(y.id);
+        return {
           id: y.id,
           name: y.label,
           code: y.code,
           country: y.country,
-        }),
-      ),
+          hasContainerFacilityOrigin:
+            facility?.hasContainerFacilityOrigin ?? false,
+          hasBulkFacilityOrigin: facility?.hasBulkFacilityOrigin ?? false,
+          hasContainerFacilityDestination:
+            facility?.hasContainerFacilityDestination ?? false,
+          hasBulkFacilityDestination:
+            facility?.hasBulkFacilityDestination ?? false,
+        };
+      }),
       containers: groupContainersBySize(containerTypes),
       service: serviceTypes.map(
         (s): BookingReferenceServiceDto => ({
diff --git a/apps/edr-freight-api/src/modules/bookings/booking-transition.service.ts b/apps/edr-freight-api/src/modules/bookings/booking-transition.service.ts
index 149875e6e..181c47b2d 100644
--- a/apps/edr-freight-api/src/modules/bookings/booking-transition.service.ts
+++ b/apps/edr-freight-api/src/modules/bookings/booking-transition.service.ts
@@ -927,13 +927,6 @@ export class BookingTransitionService {
       "OPERATION_CHANGES_REQUESTED",
     ]);
 
-    // A company sitting on another unpaid hold commits nothing new — this is
-    // the moment export capacity locks, so the lock applies here too.
-    // Government bookings allocate without paying and are exempt.
-    if (!booking.isGovernment) {
-      await this.bookingsService.assertNoUnpaidHold(booking.companyId);
-    }
-
     // A bare initiated instance (clearance-first flow) carries no cargo or
     // price — it must go through the contract completion endpoint, which
     // persists cargo, prices, invoices and only then lands here itself.
diff --git a/apps/edr-freight-api/src/modules/bookings/bookings.controller.ts b/apps/edr-freight-api/src/modules/bookings/bookings.controller.ts
index 7b1f34f36..837d0d801 100644
--- a/apps/edr-freight-api/src/modules/bookings/bookings.controller.ts
+++ b/apps/edr-freight-api/src/modules/bookings/bookings.controller.ts
@@ -43,6 +43,8 @@ import {
   RoAmendmentDto,
 } from '../contracts/dto/phased-clearance.dto';
 import { BookingReferenceDataService } from './booking-reference-data.service';
+import { scopedDirections } from '../user-trade-access/trade-scope.util';
+import { UserTradeAccessService } from '../user-trade-access/user-trade-access.service';
 import { BookingsService } from './bookings.service';
 import { BookingReferenceDataDto } from './dto/booking-reference-data.dto';
 import { CreateBookingDto } from './dto/create-booking.dto';
@@ -150,6 +152,7 @@ export class BookingsController {
     private readonly containerReceiptService: ContainerReceiptService,
     private readonly firstMileService: FirstMileService,
     private readonly lastMileService: LastMileService,
+    private readonly userTradeAccessService: UserTradeAccessService,
   ) {}
 
   @Post()
@@ -217,7 +220,16 @@ export class BookingsController {
     // Staff (backoffice) see every booking. Customers (portal) are always
     // force-scoped to their own company, regardless of any companyId they pass.
     if (hasFreightPermission(user, FREIGHT_PERMS.bookings.view)) {
-      return this.bookingsService.findAll(filter);
+      // Per-user trade-direction scope (import/export/intercity checkboxes).
+      const allowed =
+        await this.userTradeAccessService.resolveAllowedDirections(user);
+      const dirs = scopedDirections(allowed, filter.tradeDirection);
+      return this.bookingsService.findAll(
+        filter,
+        undefined,
+        undefined,
+        dirs ?? undefined,
+      );
     }
     // Global Logistics has clearance:view but NOT bookings:view — it is scoped
     // to the customs document-clearance queue only and never sees the general
diff --git a/apps/edr-freight-api/src/modules/bookings/bookings.module.ts b/apps/edr-freight-api/src/modules/bookings/bookings.module.ts
index 38d7d2ac6..2063bb01d 100644
--- a/apps/edr-freight-api/src/modules/bookings/bookings.module.ts
+++ b/apps/edr-freight-api/src/modules/bookings/bookings.module.ts
@@ -1,4 +1,5 @@
 import { Module, forwardRef } from "@nestjs/common";
+import { UserTradeAccessModule } from "../user-trade-access/user-trade-access.module";
 import { ConfigService } from "@nestjs/config";
 import { TypeOrmModule } from "@nestjs/typeorm";
 import { ExchangeModule, ExchangeOptions } from "@edr/api-common";
@@ -80,6 +81,7 @@ import { VehiclesModule } from "../vehicles/vehicles.module";
     MinioModule,
     VehiclesModule,
     CompaniesModule,
+    UserTradeAccessModule,
     // CustomersModule,
     RuleEngineModule,
     FileUploadSettingsModule,
diff --git a/apps/edr-freight-api/src/modules/bookings/bookings.repository.ts b/apps/edr-freight-api/src/modules/bookings/bookings.repository.ts
index 78004f024..35f84e419 100644
--- a/apps/edr-freight-api/src/modules/bookings/bookings.repository.ts
+++ b/apps/edr-freight-api/src/modules/bookings/bookings.repository.ts
@@ -17,6 +17,7 @@ import { ContainerType } from '../rule-engine/entities/container-type.entity';
 import { Contract } from '../contracts/entities/contract.entity';
 import { ContractRateSnapshot } from '../contracts/entities/contract-rate-snapshot.entity';
 import { ContractRoute } from '../contracts/entities/contract-route.entity';
+import { applyDirectionScope } from '../user-trade-access/trade-scope.util';
 import { BookingCargoModifier } from './entities/booking-cargo-modifier.entity';
 import {
   BookingDocumentReview,
@@ -64,6 +65,8 @@ export interface BookingListFilterOptions {
   freightType?: string;
   bookingType?: string;
   tradeDirection?: string;
+  /** Per-user trade-direction scope — `[]` matches nothing. */
+  tradeDirections?: string[];
   paymentCurrency?: string;
   paymentStatus?: string;
   excludePaymentStatus?: string;
@@ -1000,6 +1003,9 @@ export class BookingsRepository extends BaseRepository<Booking> {
         tradeDirection: options.tradeDirection,
       });
     }
+    if (options.tradeDirections) {
+      applyDirectionScope(qb, 'booking.trade_direction', options.tradeDirections);
+    }
     if (options.paymentCurrency) {
       qb.andWhere('booking.payment_currency = :paymentCurrency', {
         paymentCurrency: options.paymentCurrency,
@@ -1390,16 +1396,6 @@ export class BookingsRepository extends BaseRepository<Booking> {
       .getMany();
   }
 
-  /** Open unpaid holds (wagons reserved, pay window running) for a company. */
-  countUnpaidHoldsForCompany(companyId: string): Promise<number> {
-    return this.repository.count({
-      where: {
-        companyId,
-        status: In(['SELECTED_FOR_BATCH', 'AWAITING_PAYMENT']),
-      },
-    });
-  }
-
   /** Bookings currently reserved (SELECTED_FOR_BATCH) against a schedule. */
   findReservedForSchedule(scheduleId: string): Promise<Booking[]> {
     return this.repository
diff --git a/apps/edr-freight-api/src/modules/bookings/bookings.service.ts b/apps/edr-freight-api/src/modules/bookings/bookings.service.ts
index b8f73dfc8..12c56ac13 100644
--- a/apps/edr-freight-api/src/modules/bookings/bookings.service.ts
+++ b/apps/edr-freight-api/src/modules/bookings/bookings.service.ts
@@ -28,6 +28,7 @@ import { EventEmitter2 } from '@nestjs/event-emitter';
 import { DataSource, In } from 'typeorm';
 
 import { deriveTradeDirection } from '../../common/derive-trade-direction.util';
+import { assertExportReceivedWithGrn } from '../../common/export-received-gate';
 import { Yard } from '../rule-engine/entities/yard.entity';
 import { ServiceType } from '../rule-engine/entities/service-type.entity';
 import { TrainSchedule } from '../train-schedules/entities/train-schedule.entity';
@@ -239,6 +240,10 @@ export class BookingsService {
    */
   async carriageAcceptanceSheet(bookingId: string): Promise<{ filename: string; buffer: Buffer }> {
     const booking = await this.findById(bookingId);
+    // The sheet attests that EDR has taken custody. For export that happens at
+    // cargo receipt (GRN), so the GRN is required even when wagons are already
+    // allocated — an allocation is a plan, not possession.
+    await assertExportReceivedWithGrn(this.dataSource, booking);
     let wagons: CarriageAcceptanceWagonRow[] = await this.dataSource.query(
       `SELECT tsw.sequence_no                  AS "sequenceNo",
               COALESCE(wt.code, wt.name)       AS "wagonType",
@@ -291,7 +296,10 @@ export class BookingsService {
                  LEFT JOIN freight.containers c
                    ON c.id = inv.container_id AND c.deleted_at IS NULL
                 WHERE inv.booking_id = $1 AND inv.deleted_at IS NULL
-                  AND COALESCE(NULLIF(TRIM(inv.grn_number), ''), '') <> ''
+                  AND COALESCE(
+                        NULLIF(TRIM(inv.grn_number), ''),
+                        substring(inv.notes FROM 'GRN Number: ([^\\n\\r]+)')
+                      ) IS NOT NULL
                 ORDER BY inv.created_at`,
               [bookingId],
             )
@@ -909,24 +917,6 @@ export class BookingsService {
     return result.booking;
   }
 
-  /**
-   * A company with an open unpaid hold (SELECTED_FOR_BATCH — wagons reserved,
-   * pay window running) may not take more capacity until it pays or the hold
-   * dies: otherwise one customer can lock a train's wagons over and over
-   * without ever paying. EXPIRED / CANCELLED holds free the lock.
-   */
-  async assertNoUnpaidHold(companyId?: string | null): Promise<void> {
-    if (!companyId) return;
-    const holds =
-      await this.bookingsRepository.countUnpaidHoldsForCompany(companyId);
-    if (holds > 0) {
-      throw new ConflictException(
-        'You already have a booking waiting for payment. Pay it or cancel it ' +
-          'before making a new booking.',
-      );
-    }
-  }
-
   /** Create a new freight booking. */
   async create(
     dto: CreateBookingDto,
@@ -989,10 +979,6 @@ export class BookingsService {
       companyId = company.id;
     }
 
-    // Government bookings allocate without paying, so the unpaid-hold lock
-    // only applies to commercial companies.
-    if (!isGovernment) await this.assertNoUnpaidHold(companyId);
-
     if (dto.trainScheduleId) {
       // Staff manual pin: the schedule must be OPEN and on the same route.
       const schedule = await this.dataSource
@@ -1619,6 +1605,7 @@ export class BookingsService {
     filter: FilterBookingDto,
     forceCompanyId?: string,
     forceCompanyProfileId?: string,
+    tradeDirections?: string[],
   ): Promise<PaginatedBookings> {
     const page = filter.page ?? 1;
     const pageSize = filter.pageSize ?? 20;
@@ -1638,6 +1625,7 @@ export class BookingsService {
       // ANDs both, so cross-company access is impossible.
       companyId: forceCompanyId ?? filter.companyId,
       companyProfileId: forceCompanyProfileId ?? filter.companyProfileId,
+      tradeDirections,
       contractType: filter.contractType,
       serviceTypeId: filter.serviceTypeId,
       cargoTypeId: filter.cargoTypeId,
diff --git a/apps/edr-freight-api/src/modules/bookings/dto/booking-reference-data.dto.ts b/apps/edr-freight-api/src/modules/bookings/dto/booking-reference-data.dto.ts
index a793cc558..4c51d85a6 100644
--- a/apps/edr-freight-api/src/modules/bookings/dto/booking-reference-data.dto.ts
+++ b/apps/edr-freight-api/src/modules/bookings/dto/booking-reference-data.dto.ts
@@ -13,6 +13,18 @@ export class BookingReferenceYardDto {
 
   @ApiProperty({ example: 'Ethiopia' })
   country!: string;
+
+  @ApiProperty({ description: 'Can load containers onto a train here.' })
+  hasContainerFacilityOrigin!: boolean;
+
+  @ApiProperty({ description: 'Can load bulk cargo onto a train here.' })
+  hasBulkFacilityOrigin!: boolean;
+
+  @ApiProperty({ description: 'Can receive containers off a train here.' })
+  hasContainerFacilityDestination!: boolean;
+
+  @ApiProperty({ description: 'Can receive bulk cargo off a train here.' })
+  hasBulkFacilityDestination!: boolean;
 }
 
 export class BookingReferenceContainerTypeDto {
diff --git a/apps/edr-freight-api/src/modules/contracts/contract-booking.service.ts b/apps/edr-freight-api/src/modules/contracts/contract-booking.service.ts
index 8da28e400..7e0a23e3f 100644
--- a/apps/edr-freight-api/src/modules/contracts/contract-booking.service.ts
+++ b/apps/edr-freight-api/src/modules/contracts/contract-booking.service.ts
@@ -109,23 +109,6 @@ export class ContractBookingService {
     private readonly bookingTransitionService: BookingTransitionService,
   ) {}
 
-  /**
-   * Mirrors BookingsService.assertNoUnpaidHold for the contract booking paths:
-   * a company sitting on an unpaid hold (SELECTED_FOR_BATCH) books nothing new
-   * until it pays or the hold dies.
-   */
-  private async assertNoUnpaidHold(companyId?: string | null): Promise<void> {
-    if (!companyId) return;
-    const holds =
-      await this.bookingsRepository.countUnpaidHoldsForCompany(companyId);
-    if (holds > 0) {
-      throw new ConflictException(
-        'You already have a booking waiting for payment. Pay it or cancel it ' +
-          'before making a new booking.',
-      );
-    }
-  }
-
   async createUnderContract(
     contractId: string,
     dto: CreateBookingUnderContractDto,
@@ -186,8 +169,6 @@ export class ContractBookingService {
     // remainder; the customer cannot start any other booking on the contract.
     // If the remainder splits again the same rule repeats until the cap is
     // exhausted and the contract completes.
-    await this.assertNoUnpaidHold(contract.companyId);
-
     if (contract.contractKind === 'ONE_TIME') {
       if (await this.hasSplitBooking(contractId)) {
         await this.assertExactRemainder(contract, dto);
@@ -475,7 +456,6 @@ export class ContractBookingService {
         );
       }
     }
-    await this.assertNoUnpaidHold(contract.companyId);
 
     const route = await this.resolveRoute(contract, dto.contractRouteId);
 
diff --git a/apps/edr-freight-api/src/modules/contracts/contracts.controller.ts b/apps/edr-freight-api/src/modules/contracts/contracts.controller.ts
index 8c004ade0..ec61fdd4a 100644
--- a/apps/edr-freight-api/src/modules/contracts/contracts.controller.ts
+++ b/apps/edr-freight-api/src/modules/contracts/contracts.controller.ts
@@ -59,6 +59,8 @@ import { GlOperationsService } from './gl-operations.service';
 import { BookingRequestService } from './booking-request.service';
 import { SignaturesService } from '../signatures/signatures.service';
 import { BookingsService } from '../bookings/bookings.service';
+import { scopedDirections } from '../user-trade-access/trade-scope.util';
+import { UserTradeAccessService } from '../user-trade-access/user-trade-access.service';
 import { CreateContractDto } from './dto/create-contract.dto';
 import { UpdateContractDto } from './dto/update-contract.dto';
 import { FilterContractDto } from './dto/filter-contract.dto';
@@ -108,6 +110,7 @@ export class ContractsController {
     private readonly glOperationsService: GlOperationsService,
     private readonly bookingRequestService: BookingRequestService,
     private readonly signaturesService: SignaturesService,
+    private readonly userTradeAccessService: UserTradeAccessService,
     private readonly bookingClearanceService: BookingClearanceService,
     private readonly bookingsService: BookingsService,
   ) {}
@@ -210,7 +213,16 @@ export class ContractsController {
       hasFreightPermission(user, FREIGHT_PERMS.bookings.view) ||
       hasFreightPermission(user, FREIGHT_PERMS.contracts.view)
     ) {
-      return this.contractsService.findAll(filter);
+      // Per-user trade-direction scope (import/export/intercity checkboxes).
+      const allowed =
+        await this.userTradeAccessService.resolveAllowedDirections(user);
+      const dirs = scopedDirections(allowed, filter.tradeDirection);
+      return this.contractsService.findAll(
+        filter,
+        undefined,
+        undefined,
+        dirs ?? undefined,
+      );
     }
     const userId = user?.id;
     if (!userId) throw new UnauthorizedException('Authentication required');
diff --git a/apps/edr-freight-api/src/modules/contracts/contracts.module.ts b/apps/edr-freight-api/src/modules/contracts/contracts.module.ts
index 658acf39d..0e60462a4 100644
--- a/apps/edr-freight-api/src/modules/contracts/contracts.module.ts
+++ b/apps/edr-freight-api/src/modules/contracts/contracts.module.ts
@@ -1,4 +1,5 @@
 import { Module, forwardRef } from '@nestjs/common';
+import { UserTradeAccessModule } from '../user-trade-access/user-trade-access.module';
 import { ConfigService } from '@nestjs/config';
 import { TypeOrmModule } from '@nestjs/typeorm';
 import { ExchangeModule, ExchangeOptions } from '@edr/api-common';
@@ -89,6 +90,7 @@ import { ContractDocumentViewModelBuilder } from '../../contracts/contract-docum
     NotificationsModule,
     NotificationInboxModule,
     CompaniesModule,
+    UserTradeAccessModule,
     // Provides the admin-editable contract document templates consumed by
     // ContractDocumentViewModelBuilder when rendering contract PDFs.
     ContractTemplatesModule,
diff --git a/apps/edr-freight-api/src/modules/contracts/contracts.repository.ts b/apps/edr-freight-api/src/modules/contracts/contracts.repository.ts
index 49ef3a29f..a7fddd816 100644
--- a/apps/edr-freight-api/src/modules/contracts/contracts.repository.ts
+++ b/apps/edr-freight-api/src/modules/contracts/contracts.repository.ts
@@ -5,6 +5,7 @@ import { DataSource, In, IsNull, Repository, SelectQueryBuilder } from 'typeorm'
 
 import { Booking } from '../bookings/entities/booking.entity';
 import { FileRecord } from '../files/entities/file.entity';
+import { applyDirectionScope } from '../user-trade-access/trade-scope.util';
 import { Contract } from './entities/contract.entity';
 import { ContractApprovalStep } from './entities/contract-approval-step.entity';
 import { ContractClearanceCycle } from './entities/contract-clearance-cycle.entity';
@@ -38,6 +39,8 @@ export interface ContractListFilterOptions {
   serviceTypeId?: string;
   freightType?: string;
   tradeDirection?: string;
+  /** Per-user trade-direction scope — `[]` matches nothing. */
+  tradeDirections?: string[];
   paymentCurrency?: string;
   customsClearingEnabled?: boolean;
   /** true → only contracts with at least one uploaded clearance document. */
@@ -436,6 +439,9 @@ export class ContractsRepository extends BaseRepository<Contract> {
         tradeDirection: options.tradeDirection,
       });
     }
+    if (options.tradeDirections) {
+      applyDirectionScope(qb, 'contract.trade_direction', options.tradeDirections);
+    }
     if (options.paymentCurrency) {
       qb.andWhere('contract.payment_currency = :paymentCurrency', {
         paymentCurrency: options.paymentCurrency,
diff --git a/apps/edr-freight-api/src/modules/contracts/contracts.service.ts b/apps/edr-freight-api/src/modules/contracts/contracts.service.ts
index 5c0b5e29e..6e170f126 100644
--- a/apps/edr-freight-api/src/modules/contracts/contracts.service.ts
+++ b/apps/edr-freight-api/src/modules/contracts/contracts.service.ts
@@ -748,6 +748,7 @@ export class ContractsService {
     filter: FilterContractDto,
     forceCompanyId?: string,
     forceCompanyProfileId?: string,
+    tradeDirections?: string[],
   ): Promise<PaginatedContracts> {
     const page = filter.page ?? 1;
     const pageSize = filter.pageSize ?? 20;
@@ -763,6 +764,7 @@ export class ContractsService {
       serviceTypeId: filter.serviceTypeId,
       freightType: filter.freightType,
       tradeDirection: filter.tradeDirection,
+      tradeDirections,
       paymentCurrency: filter.paymentCurrency,
       createdFrom: filter.createdFrom,
       createdTo: filter.createdTo,
diff --git a/apps/edr-freight-api/src/modules/import-operations/dto/import-operations.dto.ts b/apps/edr-freight-api/src/modules/import-operations/dto/import-operations.dto.ts
index 1cf4c72e5..b3ec979b4 100644
--- a/apps/edr-freight-api/src/modules/import-operations/dto/import-operations.dto.ts
+++ b/apps/edr-freight-api/src/modules/import-operations/dto/import-operations.dto.ts
@@ -169,6 +169,11 @@ export class CreateEmptyContainerReturnDto {
   @IsOptional()
   @IsString()
   performedBy?: string;
+
+  @ApiPropertyOptional({ enum: ['EDR', 'CUSTOMER'] })
+  @IsOptional()
+  @IsIn(['EDR', 'CUSTOMER'])
+  returnedBy?: 'EDR' | 'CUSTOMER';
 }
 
 export class UpdateEmptyContainerReturnStatusDto extends ImportOperationActionDto {
diff --git a/apps/edr-freight-api/src/modules/import-operations/entities/empty-container-return.entity.ts b/apps/edr-freight-api/src/modules/import-operations/entities/empty-container-return.entity.ts
index 727aee322..2538a204b 100644
--- a/apps/edr-freight-api/src/modules/import-operations/entities/empty-container-return.entity.ts
+++ b/apps/edr-freight-api/src/modules/import-operations/entities/empty-container-return.entity.ts
@@ -53,4 +53,14 @@ export class EmptyContainerReturn extends BaseEntity {
 
   @Column({ name: 'performed_by', type: 'varchar', length: 120, nullable: true })
   performedBy?: string | null;
+
+  @Column({ name: 'returned_by', type: 'varchar', length: 20, nullable: true })
+  returnedBy?: 'EDR' | 'CUSTOMER' | null;
+
+  @Column({ name: 'status_history', type: 'jsonb', default: () => "'[]'" })
+  statusHistory!: Array<{
+    status: EmptyContainerReturnStatus;
+    changedAt: string;
+    performedBy: string | null;
+  }>;
 }
diff --git a/apps/edr-freight-api/src/modules/import-operations/import-operations.service.ts b/apps/edr-freight-api/src/modules/import-operations/import-operations.service.ts
index bbc1228a5..bd40e2ab1 100644
--- a/apps/edr-freight-api/src/modules/import-operations/import-operations.service.ts
+++ b/apps/edr-freight-api/src/modules/import-operations/import-operations.service.ts
@@ -149,18 +149,23 @@ export class ImportOperationsService {
   }
 
   async createEmptyReturn(dto: CreateEmptyContainerReturnDto) {
+    const returnDate = dto.returnDate ? new Date(dto.returnDate) : new Date();
     return this.emptyReturns.save(
       this.emptyReturns.create({
         containerNumber: dto.containerNumber,
         bookingId: dto.bookingId ?? null,
         customerId: dto.customerId ?? null,
-        returnDate: dto.returnDate ? new Date(dto.returnDate) : new Date(),
+        returnDate,
         facility: dto.facility ?? null,
         yard: dto.yard ?? null,
         zone: dto.zone ?? null,
         condition: dto.condition ?? null,
         handoverNote: dto.handoverNote ?? null,
         performedBy: dto.performedBy ?? null,
+        returnedBy: dto.returnedBy ?? null,
+        statusHistory: [
+          { status: 'RETURNED', changedAt: returnDate.toISOString(), performedBy: dto.performedBy ?? null },
+        ],
       }),
     );
   }
@@ -175,6 +180,10 @@ export class ImportOperationsService {
       wagonAllocationReference: dto.wagonAllocationReference ?? row.wagonAllocationReference ?? null,
       handoverNote: dto.handoverNote ?? row.handoverNote ?? null,
       performedBy: dto.performedBy ?? row.performedBy ?? null,
+      statusHistory: [
+        ...(row.statusHistory ?? []),
+        { status: dto.status, changedAt: new Date().toISOString(), performedBy: dto.performedBy ?? row.performedBy ?? null },
+      ],
     });
     return this.emptyReturns.findOneOrFail({ where: { id } });
   }
diff --git a/apps/edr-freight-api/src/modules/notification-inbox/notification-recipients.service.ts b/apps/edr-freight-api/src/modules/notification-inbox/notification-recipients.service.ts
index be7964a3d..e3e711d19 100644
--- a/apps/edr-freight-api/src/modules/notification-inbox/notification-recipients.service.ts
+++ b/apps/edr-freight-api/src/modules/notification-inbox/notification-recipients.service.ts
@@ -13,9 +13,8 @@ import { ExternalProfileRepository } from "../companies/external-profile.reposit
  * - `companyId`        → all portal users linked to the company (external_profiles).
  * - `companyProfileId` → resolved to its company, then to that company's users.
  * - `organizationId`   → all current employees of the org (backoffice staff).
- *
- * NOTE: permission-scoped staff targeting is intentionally unsupported — freight
- * has no "users-by-permission" lookup. Target explicit userIds or an org instead.
+ * - `permissionKeys`   → current employees (any org) holding any of these
+ *   permission keys (e.g. department/role-scoped targeting).
  */
 @Injectable()
 export class NotificationRecipientsService {
@@ -82,6 +81,20 @@ export class NotificationRecipientsService {
       }
     }
 
+    if (recipients.permissionKeys?.length) {
+      try {
+        for (const uid of await this.backoffice.getEmployeeUserIdsByPermission(
+          recipients.permissionKeys,
+        )) {
+          ids.add(uid);
+        }
+      } catch (err) {
+        this.logger.warn(
+          `Failed to resolve permissionKeys recipients: ${(err as Error).message}`,
+        );
+      }
+    }
+
     return [...ids];
   }
 }
diff --git a/apps/edr-freight-api/src/modules/overview/dto/overview-response.dto.ts b/apps/edr-freight-api/src/modules/overview/dto/overview-response.dto.ts
index ab914deff..005dad08a 100644
--- a/apps/edr-freight-api/src/modules/overview/dto/overview-response.dto.ts
+++ b/apps/edr-freight-api/src/modules/overview/dto/overview-response.dto.ts
@@ -1,6 +1,7 @@
 import { ApiProperty } from '@nestjs/swagger';
 
 export class OverviewBookingKpisDto {
+  @ApiProperty() total!: number;
   @ApiProperty() totalActive!: number;
   @ApiProperty() needsAction!: number;
   @ApiProperty() urgent!: number;
@@ -9,6 +10,7 @@ export class OverviewBookingKpisDto {
 }
 
 export class OverviewContractKpisDto {
+  @ApiProperty() total!: number;
   @ApiProperty() totalActive!: number;
   @ApiProperty() needsAction!: number;
   @ApiProperty() inApproval!: number;
@@ -21,6 +23,8 @@ export class OverviewOperationsKpisDto {
   @ApiProperty() wagonsAvailable!: number;
   @ApiProperty() containersInTransit!: number;
   @ApiProperty() cargoesLoaded!: number;
+  @ApiProperty() schedulesUpcoming!: number;
+  @ApiProperty() dispatchedToday!: number;
 }
 
 export class OverviewCustomerKpisDto {
diff --git a/apps/edr-freight-api/src/modules/overview/dto/overview-tab-response.dto.ts b/apps/edr-freight-api/src/modules/overview/dto/overview-tab-response.dto.ts
index d4e5c2782..7c60a91a6 100644
--- a/apps/edr-freight-api/src/modules/overview/dto/overview-tab-response.dto.ts
+++ b/apps/edr-freight-api/src/modules/overview/dto/overview-tab-response.dto.ts
@@ -104,10 +104,40 @@ export class OverviewBillingTabDto {
   generatedAt!: string;
 }
 
+export class OverviewDirectionTrendPointDto {
+  @ApiProperty({ example: '2026-08-01' }) date!: string;
+  @ApiProperty() importCount!: number;
+  @ApiProperty() exportCount!: number;
+  @ApiProperty() domesticCount!: number;
+}
+
+export class OverviewTonnagePointDto {
+  @ApiProperty() label!: string;
+  @ApiProperty() tons!: number;
+}
+
 export class OverviewOperationsTabDto {
   @ApiProperty({ type: OverviewOperationsKpisDto })
   kpis!: OverviewOperationsKpisDto;
 
+  @ApiProperty({ type: [OverviewDirectionTrendPointDto] })
+  departureTrend!: OverviewDirectionTrendPointDto[];
+
+  @ApiProperty({ type: [OverviewStatusCountDto] })
+  scheduleStatusBreakdown!: OverviewStatusCountDto[];
+
+  @ApiProperty({ type: [OverviewLabelCountDto] })
+  wagonsByType!: OverviewLabelCountDto[];
+
+  @ApiProperty({ type: [OverviewLabelCountDto] })
+  wagonsByYard!: OverviewLabelCountDto[];
+
+  @ApiProperty({ type: [OverviewLabelCountDto] })
+  containersBySize!: OverviewLabelCountDto[];
+
+  @ApiProperty({ type: [OverviewTonnagePointDto] })
+  cargoTonnageByType!: OverviewTonnagePointDto[];
+
   @ApiProperty({ type: [OverviewStatusCountDto] })
   trainStatusBreakdown!: OverviewStatusCountDto[];
 
diff --git a/apps/edr-freight-api/src/modules/overview/overview.controller.ts b/apps/edr-freight-api/src/modules/overview/overview.controller.ts
index e63cc5d01..661350f49 100644
--- a/apps/edr-freight-api/src/modules/overview/overview.controller.ts
+++ b/apps/edr-freight-api/src/modules/overview/overview.controller.ts
@@ -5,6 +5,8 @@ import {
   ApiOperation,
   ApiTags,
 } from '@nestjs/swagger';
+import { CurrentUser } from '@edr/api-common';
+import type { TCurrentUser } from '@tria-plc/api-common/modules/auth/types/current-user.type';
 
 import { BookingView } from '../../common/booking-guards';
 import { OverviewQueryDto } from './dto/overview-query.dto';
@@ -18,59 +20,105 @@ import {
   OverviewStaffTabDto,
 } from './dto/overview-tab-response.dto';
 import { OverviewService } from './overview.service';
+import { UserTradeAccessService } from '../user-trade-access/user-trade-access.service';
 
 @ApiTags('Overview')
 @ApiBearerAuth()
 @Controller('overview')
 export class OverviewController {
-  constructor(private readonly overviewService: OverviewService) {}
+  constructor(
+    private readonly overviewService: OverviewService,
+    private readonly userTradeAccessService: UserTradeAccessService,
+  ) {}
 
   @Get()
   @BookingView()
   @ApiOperation({ summary: 'Aggregated dashboard summary for backoffice overview' })
   @ApiOkResponse({ type: OverviewResponseDto })
-  getDashboard(@Query() query: OverviewQueryDto): Promise<OverviewResponseDto> {
-    return this.overviewService.getDashboard(query.range ?? '30d');
+  async getDashboard(
+    @Query() query: OverviewQueryDto,
+    @CurrentUser() user: TCurrentUser,
+  ): Promise<OverviewResponseDto> {
+    const allowed =
+      await this.userTradeAccessService.resolveAllowedDirections(user);
+    return this.overviewService.getDashboard(
+      query.range ?? '30d',
+      allowed ?? undefined,
+    );
   }
 
   @Get('bookings')
   @BookingView()
   @ApiOperation({ summary: 'Bookings tab metrics and charts' })
   @ApiOkResponse({ type: OverviewBookingsTabDto })
-  getBookingsTab(@Query() query: OverviewQueryDto): Promise<OverviewBookingsTabDto> {
-    return this.overviewService.getBookingsTab(query.range ?? '30d');
+  async getBookingsTab(
+    @Query() query: OverviewQueryDto,
+    @CurrentUser() user: TCurrentUser,
+  ): Promise<OverviewBookingsTabDto> {
+    const allowed =
+      await this.userTradeAccessService.resolveAllowedDirections(user);
+    return this.overviewService.getBookingsTab(
+      query.range ?? '30d',
+      allowed ?? undefined,
+    );
   }
 
   @Get('contracts')
   @BookingView()
   @ApiOperation({ summary: 'Contracts tab metrics and charts' })
   @ApiOkResponse({ type: OverviewContractsTabDto })
-  getContractsTab(@Query() query: OverviewQueryDto): Promise<OverviewContractsTabDto> {
-    return this.overviewService.getContractsTab(query.range ?? '30d');
+  async getContractsTab(
+    @Query() query: OverviewQueryDto,
+    @CurrentUser() user: TCurrentUser,
+  ): Promise<OverviewContractsTabDto> {
+    const allowed =
+      await this.userTradeAccessService.resolveAllowedDirections(user);
+    return this.overviewService.getContractsTab(
+      query.range ?? '30d',
+      allowed ?? undefined,
+    );
   }
 
   @Get('billing')
   @BookingView()
   @ApiOperation({ summary: 'Billing tab metrics and charts' })
   @ApiOkResponse({ type: OverviewBillingTabDto })
-  getBillingTab(@Query() query: OverviewQueryDto): Promise<OverviewBillingTabDto> {
-    return this.overviewService.getBillingTab(query.range ?? '30d');
+  async getBillingTab(
+    @Query() query: OverviewQueryDto,
+    @CurrentUser() user: TCurrentUser,
+  ): Promise<OverviewBillingTabDto> {
+    const allowed =
+      await this.userTradeAccessService.resolveAllowedDirections(user);
+    return this.overviewService.getBillingTab(
+      query.range ?? '30d',
+      allowed ?? undefined,
+    );
   }
 
   @Get('operations')
   @BookingView()
   @ApiOperation({ summary: 'Operations tab metrics and charts' })
   @ApiOkResponse({ type: OverviewOperationsTabDto })
-  getOperationsTab(): Promise<OverviewOperationsTabDto> {
-    return this.overviewService.getOperationsTab();
+  getOperationsTab(
+    @Query() query: OverviewQueryDto,
+  ): Promise<OverviewOperationsTabDto> {
+    return this.overviewService.getOperationsTab(query.range ?? '30d');
   }
 
   @Get('customers')
   @BookingView()
   @ApiOperation({ summary: 'Customers tab metrics and charts' })
   @ApiOkResponse({ type: OverviewCustomersTabDto })
-  getCustomersTab(@Query() query: OverviewQueryDto): Promise<OverviewCustomersTabDto> {
-    return this.overviewService.getCustomersTab(query.range ?? '30d');
+  async getCustomersTab(
+    @Query() query: OverviewQueryDto,
+    @CurrentUser() user: TCurrentUser,
+  ): Promise<OverviewCustomersTabDto> {
+    const allowed =
+      await this.userTradeAccessService.resolveAllowedDirections(user);
+    return this.overviewService.getCustomersTab(
+      query.range ?? '30d',
+      allowed ?? undefined,
+    );
   }
 
   @Get('staff')
diff --git a/apps/edr-freight-api/src/modules/overview/overview.module.ts b/apps/edr-freight-api/src/modules/overview/overview.module.ts
index 43fcdac0f..a20f75ed2 100644
--- a/apps/edr-freight-api/src/modules/overview/overview.module.ts
+++ b/apps/edr-freight-api/src/modules/overview/overview.module.ts
@@ -9,8 +9,10 @@ import { Container } from "../container-management/entities/container.entity";
 import { Company } from "../companies/entities/company.entity";
 import { Contract } from "../contracts/entities/contract.entity";
 import { PaymentEntity } from "../payment/entities/payment.entity";
+import { TrainSchedule } from "../train-schedules/entities/train-schedule.entity";
 import { Train } from "../trains/entities/train.entity";
 import { Wagon } from "../wagons/entities/wagon.entity";
+import { UserTradeAccessModule } from "../user-trade-access/user-trade-access.module";
 import { OverviewController } from "./overview.controller";
 import { OverviewRepository } from "./overview.repository";
 import { OverviewService } from "./overview.service";
@@ -22,6 +24,7 @@ import { OverviewService } from "./overview.service";
       PaymentEntity,
       Company,
       Train,
+      TrainSchedule,
       Wagon,
       Container,
       Cargo,
@@ -29,6 +32,7 @@ import { OverviewService } from "./overview.service";
       Employee,
       User,
     ]),
+    UserTradeAccessModule,
   ],
   controllers: [OverviewController],
   providers: [OverviewService, OverviewRepository],
diff --git a/apps/edr-freight-api/src/modules/overview/overview.repository.ts b/apps/edr-freight-api/src/modules/overview/overview.repository.ts
index 4e56f415f..c61320d8c 100644
--- a/apps/edr-freight-api/src/modules/overview/overview.repository.ts
+++ b/apps/edr-freight-api/src/modules/overview/overview.repository.ts
@@ -11,7 +11,12 @@ import { Cargo } from "../cargoes/entities/cargoes.entity";
 import { Container } from "../container-management/entities/container.entity";
 import { Contract } from "../contracts/entities/contract.entity";
 import { PaymentEntity } from "../payment/entities/payment.entity";
+import { CargoType } from "../rule-engine/entities/cargo-type.entity";
+import { ContainerType } from "../rule-engine/entities/container-type.entity";
+import { Yard } from "../rule-engine/entities/yard.entity";
+import { TrainSchedule } from "../train-schedules/entities/train-schedule.entity";
 import { Train } from "../trains/entities/train.entity";
+import { WagonType } from "../wagon-types/entities/wagon-type.entity";
 import { Wagon } from "../wagons/entities/wagon.entity";
 import {
   OVERVIEW_CLOSED_STATUSES,
@@ -24,12 +29,17 @@ import {
   OVERVIEW_URGENT_PRIORITY_THRESHOLD,
 } from "./overview.constants";
 import { Company } from "../companies/entities/company.entity";
+import {
+  bookingRefScopeSql,
+  directionScopeSql,
+} from "../user-trade-access/trade-scope.util";
 
 /** Bookings carry a contract_kind column; GENERAL = umbrella contract row, not a shipment. */
 const EXCLUDE_GENERAL_CONTRACT_BOOKINGS =
   "(booking.contract_kind IS NULL OR booking.contract_kind <> 'GENERAL')";
 
 export type OverviewBookingKpisRow = {
+  total: number;
   totalActive: number;
   needsAction: number;
   urgent: number;
@@ -49,6 +59,7 @@ export type OverviewRecentBookingRow = {
 };
 
 export type OverviewContractKpisRow = {
+  total: number;
   totalActive: number;
   needsAction: number;
   inApproval: number;
@@ -79,6 +90,8 @@ export class OverviewRepository {
     private readonly companyRepository: Repository<Company>,
     @InjectRepository(Train)
     private readonly trainRepository: Repository<Train>,
+    @InjectRepository(TrainSchedule)
+    private readonly trainScheduleRepository: Repository<TrainSchedule>,
     @InjectRepository(Wagon)
     private readonly wagonRepository: Repository<Wagon>,
     @InjectRepository(Container)
@@ -93,10 +106,12 @@ export class OverviewRepository {
     private readonly userRepository: Repository<User>,
   ) { }
 
-  async getBookingKpis(): Promise<OverviewBookingKpisRow> {
+  async getBookingKpis(dirs?: string[]): Promise<OverviewBookingKpisRow> {
+    const scope = directionScopeSql("booking.trade_direction", dirs);
     const row = await this.bookingRepository
       .createQueryBuilder("booking")
-      .select(
+      .select("COUNT(*)::int", "total")
+      .addSelect(
         `COUNT(*) FILTER (WHERE booking.status NOT IN (:...closedStatuses) AND booking.status != 'DRAFT')::int`,
         "totalActive",
       )
@@ -118,6 +133,7 @@ export class OverviewRepository {
       )
       .where("booking.deleted_at IS NULL")
       .andWhere(EXCLUDE_GENERAL_CONTRACT_BOOKINGS)
+      .andWhere(scope.sql, scope.params)
       .setParameters({
         closedStatuses: [...OVERVIEW_CLOSED_STATUSES],
         needsActionStatuses: [...OVERVIEW_NEEDS_ACTION_STATUSES],
@@ -127,6 +143,7 @@ export class OverviewRepository {
       .getRawOne<Record<string, string>>();
 
     return {
+      total: Number(row?.total ?? 0),
       totalActive: Number(row?.totalActive ?? 0),
       needsAction: Number(row?.needsAction ?? 0),
       urgent: Number(row?.urgent ?? 0),
@@ -140,9 +157,17 @@ export class OverviewRepository {
     wagonsAvailable: number;
     containersInTransit: number;
     cargoesLoaded: number;
+    schedulesUpcoming: number;
+    dispatchedToday: number;
   }> {
-    const [trainsActive, wagonsAvailable, containersInTransit, cargoesLoaded] =
-      await Promise.all([
+    const [
+      trainsActive,
+      wagonsAvailable,
+      containersInTransit,
+      cargoesLoaded,
+      schedulesUpcoming,
+      dispatchedToday,
+    ] = await Promise.all([
         this.trainRepository
           .createQueryBuilder("train")
           .where("train.deleted_at IS NULL")
@@ -172,6 +197,22 @@ export class OverviewRepository {
             statuses: ["LOADED", "IN_TRANSIT"],
           })
           .getCount(),
+        this.trainScheduleRepository
+          .createQueryBuilder("schedule")
+          .where("schedule.deleted_at IS NULL")
+          .andWhere("schedule.status = :status", {
+            status: Freight.TrainScheduleStatus.Scheduled,
+          })
+          .andWhere("schedule.scheduled_departure_date >= CURRENT_DATE")
+          .getCount(),
+        this.trainScheduleRepository
+          .createQueryBuilder("schedule")
+          .where("schedule.deleted_at IS NULL")
+          .andWhere("schedule.status = :status", {
+            status: Freight.TrainScheduleStatus.Dispatched,
+          })
+          .andWhere("schedule.scheduled_departure_date::date = CURRENT_DATE")
+          .getCount(),
       ]);
 
     return {
@@ -179,6 +220,8 @@ export class OverviewRepository {
       wagonsAvailable,
       containersInTransit,
       cargoesLoaded,
+      schedulesUpcoming,
+      dispatchedToday,
     };
   }
 
@@ -202,12 +245,13 @@ export class OverviewRepository {
     };
   }
 
-  async getBillingKpis(): Promise<{
+  async getBillingKpis(dirs?: string[]): Promise<{
     revenueMtdEtb: number;
     revenueMtdUsd: number;
     pendingPayments: number;
     successfulPaymentsMtd: number;
   }> {
+    const scope = bookingRefScopeSql("payment.ref_id", dirs);
     const revenueRow = await this.paymentRepository
       .createQueryBuilder("payment")
       .select(
@@ -223,6 +267,7 @@ export class OverviewRepository {
       .andWhere(
         `COALESCE(payment.paid_at, payment.created_at) >= date_trunc('month', CURRENT_DATE)`,
       )
+      .andWhere(scope.sql, scope.params)
       .getRawOne<Record<string, string>>();
 
     const pendingPayments = await this.paymentRepository
@@ -230,6 +275,7 @@ export class OverviewRepository {
       .where("payment.status IN (:...statuses)", {
         statuses: ["action-required", "processing"],
       })
+      .andWhere(scope.sql, scope.params)
       .getCount();
 
     return {
@@ -261,13 +307,16 @@ export class OverviewRepository {
 
   async getBookingTrend(
     days: number,
+    dirs?: string[],
   ): Promise<{ date: string; count: number }[]> {
+    const scope = directionScopeSql("booking.trade_direction", dirs);
     const rows = await this.bookingRepository
       .createQueryBuilder("booking")
       .select(`to_char(booking.created_at::date, 'YYYY-MM-DD')`, "date")
       .addSelect("COUNT(*)::int", "count")
       .where("booking.deleted_at IS NULL")
       .andWhere(EXCLUDE_GENERAL_CONTRACT_BOOKINGS)
+      .andWhere(scope.sql, scope.params)
       .andWhere(`booking.created_at >= CURRENT_DATE - :days::int + 1`, { days })
       .groupBy("booking.created_at::date")
       .orderBy("booking.created_at::date", "ASC")
@@ -279,13 +328,15 @@ export class OverviewRepository {
     }));
   }
 
-  async getStatusCounts(): Promise<Record<string, number>> {
+  async getStatusCounts(dirs?: string[]): Promise<Record<string, number>> {
+    const scope = directionScopeSql("booking.trade_direction", dirs);
     const rows = await this.bookingRepository
       .createQueryBuilder("booking")
       .select("booking.status", "status")
       .addSelect("COUNT(*)::int", "count")
       .where("booking.deleted_at IS NULL")
       .andWhere(EXCLUDE_GENERAL_CONTRACT_BOOKINGS)
+      .andWhere(scope.sql, scope.params)
       .groupBy("booking.status")
       .getRawMany<{ status: string; count: string }>();
 
@@ -296,7 +347,9 @@ export class OverviewRepository {
 
   async getPaymentTrend(
     days: number,
+    dirs?: string[],
   ): Promise<{ date: string; amountEtb: number; amountUsd: number }[]> {
+    const scope = bookingRefScopeSql("payment.ref_id", dirs);
     const rows = await this.paymentRepository
       .createQueryBuilder("payment")
       .select(
@@ -316,6 +369,7 @@ export class OverviewRepository {
         `COALESCE(payment.paid_at, payment.created_at) >= CURRENT_DATE - :days::int + 1`,
         { days },
       )
+      .andWhere(scope.sql, scope.params)
       .groupBy(`COALESCE(payment.paid_at, payment.created_at)::date`)
       .orderBy(`COALESCE(payment.paid_at, payment.created_at)::date`, "ASC")
       .getRawMany<{ date: string; amountEtb: string; amountUsd: string }>();
@@ -327,7 +381,11 @@ export class OverviewRepository {
     }));
   }
 
-  async getRecentBookings(limit: number): Promise<OverviewRecentBookingRow[]> {
+  async getRecentBookings(
+    limit: number,
+    dirs?: string[],
+  ): Promise<OverviewRecentBookingRow[]> {
+    const scope = directionScopeSql("booking.trade_direction", dirs);
     const rows = await this.bookingRepository
       .createQueryBuilder("booking")
       .leftJoin("booking.company", "company")
@@ -341,6 +399,7 @@ export class OverviewRepository {
       .addSelect("booking.created_at", "createdAt")
       .where("booking.deleted_at IS NULL")
       .andWhere(EXCLUDE_GENERAL_CONTRACT_BOOKINGS)
+      .andWhere(scope.sql, scope.params)
       .orderBy("booking.created_at", "DESC")
       .limit(limit)
       .getRawMany<{
@@ -366,9 +425,10 @@ export class OverviewRepository {
     }));
   }
 
-  async getBookingsByFreightType(): Promise<
-    { label: string; count: number }[]
-  > {
+  async getBookingsByFreightType(
+    dirs?: string[],
+  ): Promise<{ label: string; count: number }[]> {
+    const scope = directionScopeSql("booking.trade_direction", dirs);
     const rows = await this.bookingRepository
       .createQueryBuilder("booking")
       .select("booking.freight_type", "label")
@@ -376,6 +436,7 @@ export class OverviewRepository {
       .where("booking.deleted_at IS NULL")
       .andWhere(EXCLUDE_GENERAL_CONTRACT_BOOKINGS)
       .andWhere("booking.status != 'DRAFT'")
+      .andWhere(scope.sql, scope.params)
       .groupBy("booking.freight_type")
       .orderBy("count", "DESC")
       .getRawMany<{ label: string; count: string }>();
@@ -386,7 +447,10 @@ export class OverviewRepository {
     }));
   }
 
-  async getBookingsByCurrency(): Promise<{ label: string; count: number }[]> {
+  async getBookingsByCurrency(
+    dirs?: string[],
+  ): Promise<{ label: string; count: number }[]> {
+    const scope = directionScopeSql("booking.trade_direction", dirs);
     const rows = await this.bookingRepository
       .createQueryBuilder("booking")
       .select("booking.payment_currency", "label")
@@ -394,6 +458,7 @@ export class OverviewRepository {
       .where("booking.deleted_at IS NULL")
       .andWhere(EXCLUDE_GENERAL_CONTRACT_BOOKINGS)
       .andWhere("booking.status != 'DRAFT'")
+      .andWhere(scope.sql, scope.params)
       .groupBy("booking.payment_currency")
       .orderBy("count", "DESC")
       .getRawMany<{ label: string; count: string }>();
@@ -404,11 +469,15 @@ export class OverviewRepository {
     }));
   }
 
-  async getPaymentsByStatus(): Promise<{ status: string; count: number }[]> {
+  async getPaymentsByStatus(
+    dirs?: string[],
+  ): Promise<{ status: string; count: number }[]> {
+    const scope = bookingRefScopeSql("payment.ref_id", dirs);
     const rows = await this.paymentRepository
       .createQueryBuilder("payment")
       .select("payment.status", "status")
       .addSelect("COUNT(*)::int", "count")
+      .where(scope.sql, scope.params)
       .groupBy("payment.status")
       .orderBy("count", "DESC")
       .getRawMany<{ status: string; count: string }>();
@@ -419,9 +488,12 @@ export class OverviewRepository {
     }));
   }
 
-  async getPaymentsByMethod(): Promise<
+  async getPaymentsByMethod(
+    dirs?: string[],
+  ): Promise<
     { method: string; count: number; amountEtb: number; amountUsd: number }[]
   > {
+    const scope = bookingRefScopeSql("payment.ref_id", dirs);
     const rows = await this.paymentRepository
       .createQueryBuilder("payment")
       .select("payment.method", "method")
@@ -434,6 +506,7 @@ export class OverviewRepository {
         `COALESCE(SUM(payment.amount) FILTER (WHERE payment.currency = 'USD' AND payment.status = 'success'), 0)`,
         "amountUsd",
       )
+      .where(scope.sql, scope.params)
       .groupBy("payment.method")
       .orderBy("count", "DESC")
       .getRawMany<{
@@ -451,9 +524,10 @@ export class OverviewRepository {
     }));
   }
 
-  async getRevenueByCurrency(): Promise<
-    { currency: string; amount: number }[]
-  > {
+  async getRevenueByCurrency(
+    dirs?: string[],
+  ): Promise<{ currency: string; amount: number }[]> {
+    const scope = bookingRefScopeSql("payment.ref_id", dirs);
     const rows = await this.paymentRepository
       .createQueryBuilder("payment")
       .select("payment.currency", "currency")
@@ -462,6 +536,7 @@ export class OverviewRepository {
       .andWhere(
         `COALESCE(payment.paid_at, payment.created_at) >= date_trunc('month', CURRENT_DATE)`,
       )
+      .andWhere(scope.sql, scope.params)
       .groupBy("payment.currency")
       .getRawMany<{ currency: string; amount: string }>();
 
@@ -495,6 +570,141 @@ export class OverviewRepository {
     return this.statusBreakdown(this.cargoRepository, "cargo");
   }
 
+  async getScheduleStatusBreakdown(): Promise<
+    { status: string; count: number }[]
+  > {
+    return this.statusBreakdown(this.trainScheduleRepository, "schedule");
+  }
+
+  /** Scheduled departures per day over the range, split by trade direction. */
+  async getDepartureTrend(days: number): Promise<
+    {
+      date: string;
+      importCount: number;
+      exportCount: number;
+      domesticCount: number;
+    }[]
+  > {
+    const rows = await this.trainScheduleRepository
+      .createQueryBuilder("schedule")
+      .select(
+        `to_char(schedule.scheduled_departure_date::date, 'YYYY-MM-DD')`,
+        "date",
+      )
+      .addSelect(
+        `COUNT(*) FILTER (WHERE schedule.direction = 'IMPORT')::int`,
+        "importCount",
+      )
+      .addSelect(
+        `COUNT(*) FILTER (WHERE schedule.direction = 'EXPORT')::int`,
+        "exportCount",
+      )
+      .addSelect(
+        `COUNT(*) FILTER (WHERE schedule.direction NOT IN ('IMPORT', 'EXPORT') OR schedule.direction IS NULL)::int`,
+        "domesticCount",
+      )
+      .where("schedule.deleted_at IS NULL")
+      .andWhere("schedule.status != :draft", {
+        draft: Freight.TrainScheduleStatus.Draft,
+      })
+      .andWhere(
+        `schedule.scheduled_departure_date >= CURRENT_DATE - :days::int + 1`,
+        { days },
+      )
+      .andWhere(
+        `schedule.scheduled_departure_date < CURRENT_DATE + :ahead::int`,
+        { ahead: 8 },
+      )
+      .groupBy("schedule.scheduled_departure_date::date")
+      .orderBy("schedule.scheduled_departure_date::date", "ASC")
+      .getRawMany<{
+        date: string;
+        importCount: string;
+        exportCount: string;
+        domesticCount: string;
+      }>();
+
+    return rows.map((row) => ({
+      date: row.date,
+      importCount: Number(row.importCount),
+      exportCount: Number(row.exportCount),
+      domesticCount: Number(row.domesticCount),
+    }));
+  }
+
+  async getWagonsByType(): Promise<{ label: string; count: number }[]> {
+    const rows = await this.wagonRepository
+      .createQueryBuilder("wagon")
+      .leftJoin(WagonType, "wagon_type", "wagon_type.id = wagon.wagon_type_id")
+      .select(`COALESCE(wagon_type.name, 'Unknown')`, "label")
+      .addSelect("COUNT(*)::int", "count")
+      .where("wagon.deleted_at IS NULL")
+      .groupBy("wagon_type.name")
+      .orderBy("count", "DESC")
+      .getRawMany<{ label: string; count: string }>();
+
+    return rows.map((row) => ({ label: row.label, count: Number(row.count) }));
+  }
+
+  async getWagonsByYard(limit: number): Promise<
+    { label: string; count: number }[]
+  > {
+    const rows = await this.wagonRepository
+      .createQueryBuilder("wagon")
+      .innerJoin(Yard, "yard", "yard.id = wagon.current_yard_id")
+      .select("yard.label", "label")
+      .addSelect("COUNT(*)::int", "count")
+      .where("wagon.deleted_at IS NULL")
+      .groupBy("yard.label")
+      .orderBy("count", "DESC")
+      .limit(limit)
+      .getRawMany<{ label: string; count: string }>();
+
+    return rows.map((row) => ({ label: row.label, count: Number(row.count) }));
+  }
+
+  async getContainersBySize(): Promise<{ label: string; count: number }[]> {
+    const rows = await this.containerRepository
+      .createQueryBuilder("container")
+      .leftJoin(
+        ContainerType,
+        "container_type",
+        "container_type.id = container.container_type_id",
+      )
+      .select(
+        `COALESCE(container_type.size_ft::text || ' ft', container_type.code, 'Unknown')`,
+        "label",
+      )
+      .addSelect("COUNT(*)::int", "count")
+      .where("container.deleted_at IS NULL")
+      .groupBy("container_type.size_ft")
+      .addGroupBy("container_type.code")
+      .orderBy("count", "DESC")
+      .getRawMany<{ label: string; count: string }>();
+
+    return rows.map((row) => ({ label: row.label, count: Number(row.count) }));
+  }
+
+  /** Total cargo weight (tons) grouped by cargo type, heaviest first. */
+  async getCargoTonnageByType(limit: number): Promise<
+    { label: string; tons: number }[]
+  > {
+    const rows = await this.cargoRepository
+      .createQueryBuilder("cargo")
+      .leftJoin(CargoType, "cargo_type", "cargo_type.id = cargo.cargo_type_id")
+      .select(`COALESCE(cargo_type.cargo_type_name, 'Other')`, "label")
+      .addSelect(`ROUND(COALESCE(SUM(cargo.weight), 0) / 1000, 1)`, "tons")
+      .where("cargo.deleted_at IS NULL")
+      .groupBy("cargo_type.cargo_type_name")
+      .orderBy("tons", "DESC")
+      .limit(limit)
+      .getRawMany<{ label: string; tons: string }>();
+
+    return rows
+      .map((row) => ({ label: row.label, tons: Number(row.tons) }))
+      .filter((row) => row.tons > 0);
+  }
+
   private async statusBreakdown(
     repository: Repository<ObjectLiteral>,
     alias: string,
@@ -556,7 +766,9 @@ export class OverviewRepository {
 
   async getTopCustomersByBookings(
     limit: number,
+    dirs?: string[],
   ): Promise<{ label: string; count: number }[]> {
+    const scope = directionScopeSql("booking.trade_direction", dirs);
     const rows = await this.bookingRepository
       .createQueryBuilder("booking")
       .leftJoin("booking.company", "company")
@@ -564,6 +776,7 @@ export class OverviewRepository {
       .addSelect("COUNT(*)::int", "count")
       .where("booking.deleted_at IS NULL")
       .andWhere("booking.status != 'DRAFT'")
+      .andWhere(scope.sql, scope.params)
       .groupBy("company.name")
       .orderBy("count", "DESC")
       .limit(limit)
@@ -632,10 +845,12 @@ export class OverviewRepository {
 
   // ── Contracts (overview Contract tab) ──────────────────────────────────────
 
-  async getContractKpis(): Promise<OverviewContractKpisRow> {
+  async getContractKpis(dirs?: string[]): Promise<OverviewContractKpisRow> {
+    const scope = directionScopeSql("contract.trade_direction", dirs);
     const row = await this.contractRepository
       .createQueryBuilder("contract")
-      .select(
+      .select("COUNT(*)::int", "total")
+      .addSelect(
         `COUNT(*) FILTER (WHERE contract.status NOT IN (:...closedStatuses) AND contract.status != 'DRAFT')::int`,
         "totalActive",
       )
@@ -656,6 +871,7 @@ export class OverviewRepository {
         "createdToday",
       )
       .where("contract.deleted_at IS NULL")
+      .andWhere(scope.sql, scope.params)
       .setParameters({
         closedStatuses: [...OVERVIEW_CONTRACT_CLOSED_STATUSES],
         needsActionStatuses: [...OVERVIEW_CONTRACT_NEEDS_ACTION_STATUSES],
@@ -665,6 +881,7 @@ export class OverviewRepository {
       .getRawOne<Record<string, string>>();
 
     return {
+      total: Number(row?.total ?? 0),
       totalActive: Number(row?.totalActive ?? 0),
       needsAction: Number(row?.needsAction ?? 0),
       inApproval: Number(row?.inApproval ?? 0),
@@ -673,24 +890,33 @@ export class OverviewRepository {
     };
   }
 
-  async getContractStatusCounts(): Promise<Record<string, number>> {
+  async getContractStatusCounts(
+    dirs?: string[],
+  ): Promise<Record<string, number>> {
+    const scope = directionScopeSql("contract.trade_direction", dirs);
     const rows = await this.contractRepository
       .createQueryBuilder("contract")
       .select("contract.status", "status")
       .addSelect("COUNT(*)::int", "count")
       .where("contract.deleted_at IS NULL")
+      .andWhere(scope.sql, scope.params)
       .groupBy("contract.status")
       .getRawMany<{ status: string; count: string }>();
 
     return Object.fromEntries(rows.map((row) => [row.status, Number(row.count)]));
   }
 
-  async getContractTrend(days: number): Promise<{ date: string; count: number }[]> {
+  async getContractTrend(
+    days: number,
+    dirs?: string[],
+  ): Promise<{ date: string; count: number }[]> {
+    const scope = directionScopeSql("contract.trade_direction", dirs);
     const rows = await this.contractRepository
       .createQueryBuilder("contract")
       .select(`to_char(contract.created_at::date, 'YYYY-MM-DD')`, "date")
       .addSelect("COUNT(*)::int", "count")
       .where("contract.deleted_at IS NULL")
+      .andWhere(scope.sql, scope.params)
       .andWhere(`contract.created_at >= CURRENT_DATE - :days::int + 1`, { days })
       .groupBy("contract.created_at::date")
       .orderBy("contract.created_at::date", "ASC")
@@ -699,13 +925,17 @@ export class OverviewRepository {
     return rows.map((row) => ({ date: row.date, count: Number(row.count) }));
   }
 
-  async getContractsByKind(): Promise<{ label: string; count: number }[]> {
+  async getContractsByKind(
+    dirs?: string[],
+  ): Promise<{ label: string; count: number }[]> {
+    const scope = directionScopeSql("contract.trade_direction", dirs);
     const rows = await this.contractRepository
       .createQueryBuilder("contract")
       .select("contract.contract_kind", "label")
       .addSelect("COUNT(*)::int", "count")
       .where("contract.deleted_at IS NULL")
       .andWhere("contract.status != 'DRAFT'")
+      .andWhere(scope.sql, scope.params)
       .groupBy("contract.contract_kind")
       .orderBy("count", "DESC")
       .getRawMany<{ label: string; count: string }>();
@@ -713,13 +943,17 @@ export class OverviewRepository {
     return rows.map((row) => ({ label: row.label, count: Number(row.count) }));
   }
 
-  async getContractsByFreightType(): Promise<{ label: string; count: number }[]> {
+  async getContractsByFreightType(
+    dirs?: string[],
+  ): Promise<{ label: string; count: number }[]> {
+    const scope = directionScopeSql("contract.trade_direction", dirs);
     const rows = await this.contractRepository
       .createQueryBuilder("contract")
       .select("contract.freight_type", "label")
       .addSelect("COUNT(*)::int", "count")
       .where("contract.deleted_at IS NULL")
       .andWhere("contract.status != 'DRAFT'")
+      .andWhere(scope.sql, scope.params)
       .groupBy("contract.freight_type")
       .orderBy("count", "DESC")
       .getRawMany<{ label: string; count: string }>();
@@ -727,7 +961,11 @@ export class OverviewRepository {
     return rows.map((row) => ({ label: row.label, count: Number(row.count) }));
   }
 
-  async getRecentContracts(limit: number): Promise<OverviewRecentContractRow[]> {
+  async getRecentContracts(
+    limit: number,
+    dirs?: string[],
+  ): Promise<OverviewRecentContractRow[]> {
+    const scope = directionScopeSql("contract.trade_direction", dirs);
     const rows = await this.contractRepository
       .createQueryBuilder("contract")
       .leftJoin("contract.company", "company")
@@ -741,6 +979,7 @@ export class OverviewRepository {
       .addSelect("contract.contract_valid_until", "validUntil")
       .addSelect("contract.created_at", "createdAt")
       .where("contract.deleted_at IS NULL")
+      .andWhere(scope.sql, scope.params)
       .orderBy("contract.created_at", "DESC")
       .limit(limit)
       .getRawMany<{
diff --git a/apps/edr-freight-api/src/modules/overview/overview.service.ts b/apps/edr-freight-api/src/modules/overview/overview.service.ts
index 8a7b71b69..399bf4f72 100644
--- a/apps/edr-freight-api/src/modules/overview/overview.service.ts
+++ b/apps/edr-freight-api/src/modules/overview/overview.service.ts
@@ -40,7 +40,10 @@ export class OverviewService {
     return { bookingsByPipeline, bookingsByStatus };
   }
 
-  async getDashboard(range: OverviewRangeQuery = '30d'): Promise<OverviewResponseDto> {
+  async getDashboard(
+    range: OverviewRangeQuery = '30d',
+    dirs?: string[],
+  ): Promise<OverviewResponseDto> {
     const days = OVERVIEW_RANGE_DAYS[range];
 
     const [
@@ -55,16 +58,16 @@ export class OverviewService {
       paymentTrend,
       recentBookings,
     ] = await Promise.all([
-      this.overviewRepository.getBookingKpis(),
-      this.overviewRepository.getContractKpis(),
+      this.overviewRepository.getBookingKpis(dirs),
+      this.overviewRepository.getContractKpis(dirs),
       this.overviewRepository.getOperationsKpis(),
       this.overviewRepository.getCustomerKpis(),
-      this.overviewRepository.getBillingKpis(),
+      this.overviewRepository.getBillingKpis(dirs),
       this.overviewRepository.getStaffKpis(),
-      this.overviewRepository.getBookingTrend(days),
-      this.overviewRepository.getStatusCounts(),
-      this.overviewRepository.getPaymentTrend(days),
-      this.overviewRepository.getRecentBookings(8),
+      this.overviewRepository.getBookingTrend(days, dirs),
+      this.overviewRepository.getStatusCounts(dirs),
+      this.overviewRepository.getPaymentTrend(days, dirs),
+      this.overviewRepository.getRecentBookings(8, dirs),
     ]);
 
     const { bookingsByPipeline, bookingsByStatus } =
@@ -91,7 +94,10 @@ export class OverviewService {
     };
   }
 
-  async getBookingsTab(range: OverviewRangeQuery = '30d'): Promise<OverviewBookingsTabDto> {
+  async getBookingsTab(
+    range: OverviewRangeQuery = '30d',
+    dirs?: string[],
+  ): Promise<OverviewBookingsTabDto> {
     const days = OVERVIEW_RANGE_DAYS[range];
 
     const [
@@ -102,12 +108,12 @@ export class OverviewService {
       bookingsByCurrency,
       recentBookings,
     ] = await Promise.all([
-      this.overviewRepository.getBookingKpis(),
-      this.overviewRepository.getBookingTrend(days),
-      this.overviewRepository.getStatusCounts(),
-      this.overviewRepository.getBookingsByFreightType(),
-      this.overviewRepository.getBookingsByCurrency(),
-      this.overviewRepository.getRecentBookings(8),
+      this.overviewRepository.getBookingKpis(dirs),
+      this.overviewRepository.getBookingTrend(days, dirs),
+      this.overviewRepository.getStatusCounts(dirs),
+      this.overviewRepository.getBookingsByFreightType(dirs),
+      this.overviewRepository.getBookingsByCurrency(dirs),
+      this.overviewRepository.getRecentBookings(8, dirs),
     ]);
 
     const { bookingsByPipeline, bookingsByStatus } =
@@ -130,6 +136,7 @@ export class OverviewService {
 
   async getContractsTab(
     range: OverviewRangeQuery = '30d',
+    dirs?: string[],
   ): Promise<OverviewContractsTabDto> {
     const days = OVERVIEW_RANGE_DAYS[range];
 
@@ -141,12 +148,12 @@ export class OverviewService {
       contractsByFreightType,
       recentContracts,
     ] = await Promise.all([
-      this.overviewRepository.getContractKpis(),
-      this.overviewRepository.getContractTrend(days),
-      this.overviewRepository.getContractStatusCounts(),
-      this.overviewRepository.getContractsByKind(),
-      this.overviewRepository.getContractsByFreightType(),
-      this.overviewRepository.getRecentContracts(8),
+      this.overviewRepository.getContractKpis(dirs),
+      this.overviewRepository.getContractTrend(days, dirs),
+      this.overviewRepository.getContractStatusCounts(dirs),
+      this.overviewRepository.getContractsByKind(dirs),
+      this.overviewRepository.getContractsByFreightType(dirs),
+      this.overviewRepository.getRecentContracts(8, dirs),
     ]);
 
     const contractsByStatus = Object.entries(statusCounts)
@@ -170,16 +177,19 @@ export class OverviewService {
     };
   }
 
-  async getBillingTab(range: OverviewRangeQuery = '30d'): Promise<OverviewBillingTabDto> {
+  async getBillingTab(
+    range: OverviewRangeQuery = '30d',
+    dirs?: string[],
+  ): Promise<OverviewBillingTabDto> {
     const days = OVERVIEW_RANGE_DAYS[range];
 
     const [kpis, paymentTrend, paymentsByStatus, paymentsByMethod, revenueByCurrency] =
       await Promise.all([
-        this.overviewRepository.getBillingKpis(),
-        this.overviewRepository.getPaymentTrend(days),
-        this.overviewRepository.getPaymentsByStatus(),
-        this.overviewRepository.getPaymentsByMethod(),
-        this.overviewRepository.getRevenueByCurrency(),
+        this.overviewRepository.getBillingKpis(dirs),
+        this.overviewRepository.getPaymentTrend(days, dirs),
+        this.overviewRepository.getPaymentsByStatus(dirs),
+        this.overviewRepository.getPaymentsByMethod(dirs),
+        this.overviewRepository.getRevenueByCurrency(dirs),
       ]);
 
     return {
@@ -192,15 +202,31 @@ export class OverviewService {
     };
   }
 
-  async getOperationsTab(): Promise<OverviewOperationsTabDto> {
+  async getOperationsTab(
+    range: OverviewRangeQuery = '30d',
+  ): Promise<OverviewOperationsTabDto> {
+    const days = OVERVIEW_RANGE_DAYS[range];
+
     const [
       kpis,
+      departureTrend,
+      scheduleStatusBreakdown,
+      wagonsByType,
+      wagonsByYard,
+      containersBySize,
+      cargoTonnageByType,
       trainStatusBreakdown,
       wagonStatusBreakdown,
       containerStatusBreakdown,
       cargoStatusBreakdown,
     ] = await Promise.all([
       this.overviewRepository.getOperationsKpis(),
+      this.overviewRepository.getDepartureTrend(days),
+      this.overviewRepository.getScheduleStatusBreakdown(),
+      this.overviewRepository.getWagonsByType(),
+      this.overviewRepository.getWagonsByYard(8),
+      this.overviewRepository.getContainersBySize(),
+      this.overviewRepository.getCargoTonnageByType(8),
       this.overviewRepository.getTrainStatusBreakdown(),
       this.overviewRepository.getWagonStatusBreakdown(),
       this.overviewRepository.getContainerStatusBreakdown(),
@@ -209,6 +235,12 @@ export class OverviewService {
 
     return {
       kpis,
+      departureTrend,
+      scheduleStatusBreakdown,
+      wagonsByType,
+      wagonsByYard,
+      containersBySize,
+      cargoTonnageByType,
       trainStatusBreakdown,
       wagonStatusBreakdown,
       containerStatusBreakdown,
@@ -217,7 +249,10 @@ export class OverviewService {
     };
   }
 
-  async getCustomersTab(range: OverviewRangeQuery = '30d'): Promise<OverviewCustomersTabDto> {
+  async getCustomersTab(
+    range: OverviewRangeQuery = '30d',
+    dirs?: string[],
+  ): Promise<OverviewCustomersTabDto> {
     const days = OVERVIEW_RANGE_DAYS[range];
 
     const [kpis, customerGrowthTrend, customersByType, topCustomersByBookings] =
@@ -225,7 +260,7 @@ export class OverviewService {
         this.overviewRepository.getCustomerKpis(),
         this.overviewRepository.getCustomerGrowthTrend(days),
         this.overviewRepository.getCustomersByType(),
-        this.overviewRepository.getTopCustomersByBookings(8),
+        this.overviewRepository.getTopCustomersByBookings(8, dirs),
       ]);
 
     return {
diff --git a/apps/edr-freight-api/src/modules/payment/internal-payment.controller.ts b/apps/edr-freight-api/src/modules/payment/internal-payment.controller.ts
index 94c1268f6..b7dfa3c7e 100644
--- a/apps/edr-freight-api/src/modules/payment/internal-payment.controller.ts
+++ b/apps/edr-freight-api/src/modules/payment/internal-payment.controller.ts
@@ -16,10 +16,10 @@ import {
   BillQueryRequestDto,
   BillQueryResponseDto,
 } from "./internal-payment.dto";
+import { Public } from "@edr/api-common";
 import { PaymentService } from "./payment.service";
 import { BillingService } from "../billing/billing.service";
 import { ServiceAuthGuard } from "../../common/guards/service-auth.guard";
-import { Public } from "@edr/api-common";
 
 /**
  * Consumer side of the payment microservice's outbox relay. Only the payment service may
diff --git a/apps/edr-freight-api/src/modules/payment/payment.controller.ts b/apps/edr-freight-api/src/modules/payment/payment.controller.ts
index 2ae62d4f3..3602657de 100644
--- a/apps/edr-freight-api/src/modules/payment/payment.controller.ts
+++ b/apps/edr-freight-api/src/modules/payment/payment.controller.ts
@@ -15,8 +15,10 @@ import {
     ApiProduces,
 } from "@nestjs/swagger";
 import { Response } from "express";
-import { Public } from "@edr/api-common";
+import { CurrentUser, Public } from "@edr/api-common";
+import type { TCurrentUser } from "@tria-plc/api-common/modules/auth/types/current-user.type";
 import { BookingStaff, BookingView } from "../../common/booking-guards";
+import { UserTradeAccessService } from "../user-trade-access/user-trade-access.service";
 import { FREIGHT_PERMS } from "../../seed/freight-permissions.registry";
 import { PaymentService } from "./payment.service";
 import { IntentStatusDto } from "./payments.dto";
@@ -24,7 +26,10 @@ import { IntentStatusDto } from "./payments.dto";
 @ApiTags("Payment")
 @Controller("payments")
 export class PaymentController {
-    constructor(private readonly paymentService: PaymentService) { }
+    constructor(
+        private readonly paymentService: PaymentService,
+        private readonly userTradeAccessService: UserTradeAccessService,
+    ) { }
 
     // Customer-detail payments tab — same one-of rule as the bookings tab.
     @Get("by-company/:companyId/customer-view")
@@ -52,18 +57,23 @@ export class PaymentController {
     @ApiQuery({ name: "page", required: false })
     @ApiQuery({ name: "pageSize", required: false })
     async getAll(
+        @CurrentUser() user: TCurrentUser,
         @Query("search") search?: string,
         @Query("status") status?: string,
         @Query("method") method?: string,
         @Query("page") page?: string,
         @Query("pageSize") pageSize?: string,
     ) {
+        // Per-user trade-direction scope, applied via the booking in ref_id.
+        const allowed =
+            await this.userTradeAccessService.resolveAllowedDirections(user);
         return this.paymentService.getAll({
             search,
             status,
             method,
             page: page ? parseInt(page) : 1,
             pageSize: pageSize ? parseInt(pageSize) : 10,
+            tradeDirections: allowed ?? undefined,
         });
     }
 
diff --git a/apps/edr-freight-api/src/modules/payment/payment.module.ts b/apps/edr-freight-api/src/modules/payment/payment.module.ts
index 961aa32bd..220250d93 100644
--- a/apps/edr-freight-api/src/modules/payment/payment.module.ts
+++ b/apps/edr-freight-api/src/modules/payment/payment.module.ts
@@ -13,6 +13,7 @@ import {
 
 import { ServiceAuthGuard } from "../../common/guards/service-auth.guard";
 import { BillingModule } from "../billing/billing.module";
+import { UserTradeAccessModule } from "../user-trade-access/user-trade-access.module";
 // import { FirstMileModule } from "../first-mile/first-mile.module";
 // import { TrainSchedulingModule } from "../train-scheduling/train-scheduling.module";
 import { PaymentRefundEntity } from "./entities/payment-refund.entity";
@@ -64,6 +65,7 @@ function rabbitMQImport(): DynamicModule[] {
             timeout: Number(process.env.PAYMENT_API_HTTP_TIMEOUT_MS) || 60_000,
         }),
         ConfigModule,
+        UserTradeAccessModule,
         forwardRef(() => BillingModule),
         // forwardRef(() => TrainSchedulingModule),
         // FirstMileModule,
diff --git a/apps/edr-freight-api/src/modules/payment/payment.service.ts b/apps/edr-freight-api/src/modules/payment/payment.service.ts
index 669c7c27b..99c4aca46 100644
--- a/apps/edr-freight-api/src/modules/payment/payment.service.ts
+++ b/apps/edr-freight-api/src/modules/payment/payment.service.ts
@@ -7,6 +7,7 @@ import {
   Logger,
   NotFoundException,
 } from "@nestjs/common";
+import { applyBookingRefDirectionScope } from "../user-trade-access/trade-scope.util";
 import { PaymentEntity } from "./entities/payment.entity";
 import { PaymentRepository } from "./payment.repository";
 import { PaymentClientService } from "./payment-client.service";
@@ -110,6 +111,8 @@ export class PaymentService {
     method?: string;
     page?: number;
     pageSize?: number;
+    /** Per-user trade-direction scope, applied via the booking in ref_id. */
+    tradeDirections?: string[];
   }) {
     const { search, status, method, page = 1, pageSize = 10 } = filters;
     const skip = (page - 1) * pageSize;
@@ -128,6 +131,9 @@ export class PaymentService {
     if (method) {
       qb.andWhere("payment.method = :method", { method });
     }
+    if (filters.tradeDirections) {
+      applyBookingRefDirectionScope(qb, "payment.ref_id", filters.tradeDirections);
+    }
 
     const [items, total] = await qb
       .orderBy("payment.createdAt", "DESC")
diff --git a/apps/edr-freight-api/src/modules/reports/dto/report-query.dto.ts b/apps/edr-freight-api/src/modules/reports/dto/report-query.dto.ts
new file mode 100644
index 000000000..82b1a76ef
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/reports/dto/report-query.dto.ts
@@ -0,0 +1,54 @@
+import { ApiPropertyOptional } from '@nestjs/swagger';
+import { IsIn, IsOptional, IsString } from 'class-validator';
+
+export class ReportQueryDto {
+  @ApiPropertyOptional({ description: 'Inclusive start date (YYYY-MM-DD). Default: 30 days ago.' })
+  @IsOptional()
+  @IsString()
+  dateFrom?: string;
+
+  @ApiPropertyOptional({ description: 'Inclusive end date (YYYY-MM-DD). Default: today.' })
+  @IsOptional()
+  @IsString()
+  dateTo?: string;
+
+  @ApiPropertyOptional({ enum: ['day', 'week', 'month'], default: 'day' })
+  @IsOptional()
+  @IsIn(['day', 'week', 'month'])
+  granularity?: 'day' | 'week' | 'month';
+
+  @ApiPropertyOptional({ description: 'Comma-separated company UUIDs' })
+  @IsOptional()
+  @IsString()
+  companyIds?: string;
+
+  @ApiPropertyOptional({ description: 'Comma-separated route UUIDs' })
+  @IsOptional()
+  @IsString()
+  routeIds?: string;
+
+  @ApiPropertyOptional({ description: 'Comma-separated yard UUIDs (matches origin or destination)' })
+  @IsOptional()
+  @IsString()
+  yardIds?: string;
+
+  @ApiPropertyOptional({ description: 'Comma-separated cargo type UUIDs' })
+  @IsOptional()
+  @IsString()
+  cargoTypeIds?: string;
+
+  @ApiPropertyOptional({ description: 'Comma-separated status values (report-specific)' })
+  @IsOptional()
+  @IsString()
+  statuses?: string;
+
+  @ApiPropertyOptional({ description: 'Trade direction filter' })
+  @IsOptional()
+  @IsString()
+  direction?: string;
+
+  @ApiPropertyOptional({ enum: ['CONTAINER', 'BULK'] })
+  @IsOptional()
+  @IsIn(['CONTAINER', 'BULK'])
+  freightType?: string;
+}
diff --git a/apps/edr-freight-api/src/modules/reports/dto/report-result.dto.ts b/apps/edr-freight-api/src/modules/reports/dto/report-result.dto.ts
new file mode 100644
index 000000000..cc1c215af
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/reports/dto/report-result.dto.ts
@@ -0,0 +1,24 @@
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+
+export class ReportKpiDto {
+  @ApiProperty()
+  label!: string;
+
+  @ApiProperty()
+  value!: number;
+
+  @ApiPropertyOptional()
+  unit?: string;
+}
+
+export class ReportResultDto {
+  @ApiProperty({ type: [ReportKpiDto] })
+  kpis!: ReportKpiDto[];
+
+  @ApiProperty({
+    type: 'array',
+    items: { type: 'object', additionalProperties: true },
+    description: 'Report rows; columns vary per report key',
+  })
+  rows!: Record<string, unknown>[];
+}
diff --git a/apps/edr-freight-api/src/modules/reports/report-queries.ts b/apps/edr-freight-api/src/modules/reports/report-queries.ts
new file mode 100644
index 000000000..9e4a6f617
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/reports/report-queries.ts
@@ -0,0 +1,669 @@
+import { DataSource } from 'typeorm';
+
+export interface ReportFilters {
+  /** ISO timestamp, inclusive lower bound. null = no lower bound (all time). */
+  dateFrom: string | null;
+  /** ISO timestamp, exclusive upper bound. null = no upper bound. */
+  dateTo: string | null;
+  granularity: 'day' | 'week' | 'month';
+  companyIds: string[] | null;
+  routeIds: string[] | null;
+  yardIds: string[] | null;
+  cargoTypeIds: string[] | null;
+  statuses: string[] | null;
+  /** Trade-scope-resolved directions. null = unrestricted, [] = show nothing. */
+  directions: string[] | null;
+  freightType: string | null;
+}
+
+export interface ReportKpi {
+  label: string;
+  value: number;
+  unit?: string;
+}
+
+export interface ReportResult {
+  kpis: ReportKpi[];
+  rows: Record<string, unknown>[];
+}
+
+type ReportQuery = (ds: DataSource, f: ReportFilters) => Promise<ReportResult>;
+
+// For PER_ITEM bulk bookings cargo_total_weight_vgm holds an item COUNT, and
+// the real tonnage lives in bulk_total_weight_tons — hence the COALESCE order.
+const TONS = 'COALESCE(b.bulk_total_weight_tons, b.cargo_total_weight_vgm)';
+// adjusted_total_amount silently overrides total_amount when set.
+const REVENUE = 'COALESCE(b.adjusted_total_amount, b.total_amount)';
+// GENERAL contract_kind rows are umbrella contracts, not shipments; counting
+// them double-counts every child booking (same guard as overview.repository).
+const NOT_UMBRELLA = "(b.contract_kind IS NULL OR b.contract_kind <> 'GENERAL')";
+const DEAD_STATUSES = "'DRAFT','CANCELLED','REJECTED','EXPIRED'";
+
+const num = (v: unknown): number => (v === null || v === undefined ? 0 : Number(v));
+const sum = (rows: Record<string, unknown>[], col: string): number =>
+  rows.reduce((acc, r) => acc + num(r[col]), 0);
+
+/**
+ * Shared WHERE for booking-based reports (alias `b`).
+ * Params occupy $1..$8 in this fixed order; report SQL continues at $9.
+ */
+function bookingWhere(f: ReportFilters): { where: string; params: unknown[] } {
+  return {
+    where: `
+      b.deleted_at IS NULL
+      AND ${NOT_UMBRELLA}
+      AND ($1::timestamptz IS NULL OR b.created_at >= $1)
+      AND ($2::timestamptz IS NULL OR b.created_at < $2)
+      AND ($3::uuid[] IS NULL OR b.company_id = ANY($3))
+      AND ($4::uuid[] IS NULL OR b.cargo_type_id = ANY($4))
+      AND ($5::text[] IS NULL OR b.trade_direction = ANY($5))
+      AND ($6::text IS NULL OR b.freight_type = $6)
+      AND (CASE WHEN $7::text[] IS NULL
+            THEN b.status NOT IN (${DEAD_STATUSES})
+            ELSE b.status = ANY($7) END)
+      AND ($8::uuid[] IS NULL OR b.origin_yard_id = ANY($8) OR b.destination_yard_id = ANY($8))`,
+    params: [
+      f.dateFrom,
+      f.dateTo,
+      f.companyIds,
+      f.cargoTypeIds,
+      f.directions,
+      f.freightType,
+      f.statuses,
+      f.yardIds,
+    ],
+  };
+}
+
+/**
+ * Direction scope for rows that reference a booking through a varchar id
+ * column (invoices.source_id, payments.ref_id). Rows not pointing at a
+ * booking stay visible — they carry no direction to scope by.
+ * (Positional-param port of trade-scope.util's bookingRefScopeSql.)
+ */
+const refDirScope = (refColumn: string, param: string): string => `
+  (${param}::text[] IS NULL OR NOT EXISTS (
+    SELECT 1 FROM freight.bookings sb
+    WHERE sb.id::text = ${refColumn} AND NOT (sb.trade_direction = ANY(${param}))))`;
+
+const bookingsTrend: ReportQuery = async (ds, f) => {
+  const { where, params } = bookingWhere(f);
+  const rows = await ds.query(
+    `SELECT to_char(date_trunc($9, b.created_at), 'YYYY-MM-DD') AS period,
+            COUNT(*)::int AS bookings,
+            ROUND(COALESCE(SUM(${TONS}), 0))::float8 AS tons,
+            ROUND(COALESCE(SUM(${REVENUE}), 0))::float8 AS revenue
+     FROM freight.bookings b
+     WHERE ${where}
+     GROUP BY 1 ORDER BY 1`,
+    [...params, f.granularity],
+  );
+  return {
+    kpis: [
+      { label: 'Bookings', value: sum(rows, 'bookings') },
+      { label: 'Tonnage', value: sum(rows, 'tons'), unit: 't' },
+      { label: 'Revenue', value: sum(rows, 'revenue'), unit: 'ETB' },
+    ],
+    rows,
+  };
+};
+
+const revenueByCustomer: ReportQuery = async (ds, f) => {
+  const { where, params } = bookingWhere(f);
+  const rows = await ds.query(
+    `SELECT c.name AS customer,
+            COUNT(*)::int AS bookings,
+            ROUND(COALESCE(SUM(${TONS}), 0))::float8 AS tons,
+            ROUND(COALESCE(SUM(${REVENUE}), 0))::float8 AS revenue
+     FROM freight.bookings b
+     JOIN freight.companies c ON c.id = b.company_id
+     WHERE ${where}
+     GROUP BY c.name ORDER BY revenue DESC LIMIT 100`,
+    params,
+  );
+  const total = sum(rows, 'revenue');
+  return {
+    kpis: [
+      { label: 'Customers', value: rows.length },
+      { label: 'Revenue', value: total, unit: 'ETB' },
+      {
+        label: 'Top customer share',
+        value: total > 0 ? Math.round((num(rows[0]?.revenue) / total) * 100) : 0,
+        unit: '%',
+      },
+    ],
+    rows,
+  };
+};
+
+const revenueByLane: ReportQuery = async (ds, f) => {
+  const { where, params } = bookingWhere(f);
+  const rows = await ds.query(
+    `SELECT o.label AS origin, d.label AS destination,
+            COUNT(*)::int AS bookings,
+            ROUND(COALESCE(SUM(${TONS}), 0))::float8 AS tons,
+            ROUND(COALESCE(SUM(${REVENUE}), 0))::float8 AS revenue
+     FROM freight.bookings b
+     JOIN freight.yards o ON o.id = b.origin_yard_id
+     JOIN freight.yards d ON d.id = b.destination_yard_id
+     WHERE ${where}
+     GROUP BY 1, 2 ORDER BY revenue DESC LIMIT 100`,
+    params,
+  );
+  return {
+    kpis: [
+      { label: 'Lanes', value: rows.length },
+      { label: 'Tonnage', value: sum(rows, 'tons'), unit: 't' },
+      { label: 'Revenue', value: sum(rows, 'revenue'), unit: 'ETB' },
+    ],
+    rows,
+  };
+};
+
+const contractUtilization: ReportQuery = async (ds, f) => {
+  const rows = await ds.query(
+    `SELECT ct.reference, c.name AS customer, ct.status, ct.contract_kind AS kind,
+            to_char(ct.contract_valid_from, 'YYYY-MM-DD') AS valid_from,
+            to_char(ct.contract_valid_until, 'YYYY-MM-DD') AS valid_until,
+            cap.committed::float8 AS committed,
+            booked.tons::float8 AS booked_tons,
+            booked.cnt AS bookings,
+            CASE WHEN cap.committed > 0
+                 THEN ROUND(booked.tons / cap.committed * 100)::float8 END AS utilization_pct
+     FROM freight.contracts ct
+     LEFT JOIN freight.companies c ON c.id = ct.company_id
+     LEFT JOIN LATERAL (
+       SELECT COALESCE(SUM(s.quantity_cap), 0) AS committed
+       FROM freight.contract_cargo_scope s
+       WHERE s.contract_id = ct.id AND s.deleted_at IS NULL) cap ON true
+     LEFT JOIN LATERAL (
+       SELECT COALESCE(SUM(${TONS}), 0) AS tons, COUNT(*)::int AS cnt
+       FROM freight.bookings b
+       WHERE b.contract_id = ct.id AND b.deleted_at IS NULL
+         AND b.status NOT IN (${DEAD_STATUSES})) booked ON true
+     WHERE ct.deleted_at IS NULL
+       AND ct.status NOT IN ('DRAFT')
+       AND ct.contract_valid_from < COALESCE($2::timestamptz, 'infinity')
+       AND (ct.contract_valid_until IS NULL
+            OR ct.contract_valid_until >= COALESCE($1::timestamptz, '-infinity'))
+       AND ($3::uuid[] IS NULL OR ct.company_id = ANY($3))
+       AND ($4::text[] IS NULL OR ct.trade_direction = ANY($4))
+       AND ($5::text[] IS NULL OR ct.status = ANY($5))
+     ORDER BY utilization_pct DESC NULLS LAST LIMIT 200`,
+    [f.dateFrom, f.dateTo, f.companyIds, f.directions, f.statuses],
+  );
+  const capped = rows.filter((r: Record<string, unknown>) => num(r.committed) > 0);
+  return {
+    kpis: [
+      { label: 'Contracts', value: rows.length },
+      {
+        label: 'Avg utilization',
+        value: capped.length
+          ? Math.round(sum(capped, 'utilization_pct') / capped.length)
+          : 0,
+        unit: '%',
+      },
+      { label: 'Booked tonnage', value: sum(rows, 'booked_tons'), unit: 't' },
+    ],
+    rows,
+  };
+};
+
+// ponytail: 60-min departure grace is a constant; make it a query param if ops
+// ever wants a configurable threshold.
+const trainOnTime: ReportQuery = async (ds, f) => {
+  const rows = await ds.query(
+    `SELECT o.label AS origin, d.label AS destination,
+            COUNT(*)::int AS trips,
+            COUNT(*) FILTER (WHERE ts.actual_departure_at IS NOT NULL)::int AS departed,
+            ROUND(AVG(EXTRACT(EPOCH FROM (ts.actual_departure_at - ts.scheduled_departure_date)) / 60)
+              FILTER (WHERE ts.actual_departure_at IS NOT NULL))::float8 AS avg_dep_delay_min,
+            ROUND(AVG(EXTRACT(EPOCH FROM (ts.actual_arrival_at - ts.scheduled_arrival_date)) / 60)
+              FILTER (WHERE ts.actual_arrival_at IS NOT NULL
+                        AND ts.scheduled_arrival_date IS NOT NULL))::float8 AS avg_arr_delay_min,
+            ROUND(100.0 * COUNT(*) FILTER (WHERE ts.actual_departure_at
+                                             <= ts.scheduled_departure_date + interval '60 minutes')
+              / NULLIF(COUNT(*) FILTER (WHERE ts.actual_departure_at IS NOT NULL), 0))::float8 AS on_time_pct
+     FROM freight.train_schedules ts
+     JOIN freight.yards o ON o.id = ts.origin_station_id
+     JOIN freight.yards d ON d.id = ts.destination_station_id
+     WHERE ts.deleted_at IS NULL
+       AND ts.status IN ('DISPATCHED', 'ARRIVED')
+       AND ($1::timestamptz IS NULL OR ts.scheduled_departure_date >= $1)
+       AND ($2::timestamptz IS NULL OR ts.scheduled_departure_date < $2)
+       AND ($3::uuid[] IS NULL OR ts.route_id = ANY($3))
+       AND ($4::text[] IS NULL OR ts.direction = ANY($4))
+       AND ($5::uuid[] IS NULL OR ts.origin_station_id = ANY($5) OR ts.destination_station_id = ANY($5))
+     GROUP BY 1, 2 ORDER BY trips DESC`,
+    [f.dateFrom, f.dateTo, f.routeIds, f.directions, f.yardIds],
+  );
+  const departed = sum(rows, 'departed');
+  const weighted = rows.reduce(
+    (acc: number, r: Record<string, unknown>) =>
+      acc + (num(r.on_time_pct) * num(r.departed)) / 100,
+    0,
+  );
+  return {
+    kpis: [
+      { label: 'Trips', value: sum(rows, 'trips') },
+      {
+        label: 'On-time departures',
+        value: departed > 0 ? Math.round((weighted / departed) * 100) : 0,
+        unit: '%',
+      },
+      {
+        label: 'Avg departure delay',
+        value: rows.length ? Math.round(sum(rows, 'avg_dep_delay_min') / rows.length) : 0,
+        unit: 'min',
+      },
+    ],
+    rows,
+  };
+};
+
+const scheduleFillRate: ReportQuery = async (ds, f) => {
+  const rows = await ds.query(
+    `SELECT ts.train_number, ts.reference,
+            to_char(ts.scheduled_departure_date, 'YYYY-MM-DD') AS departure,
+            o.label AS origin, d.label AS destination, ts.direction, ts.status,
+            ts.max_wagons, tset.wagon_count,
+            ROUND(w.cap_tons)::float8 AS capacity_tons,
+            ROUND(w.booked_tons)::float8 AS booked_tons,
+            CASE WHEN w.cap_tons > 0
+                 THEN ROUND(w.booked_tons / w.cap_tons * 100)::float8 END AS fill_pct
+     FROM freight.train_schedules ts
+     JOIN freight.yards o ON o.id = ts.origin_station_id
+     JOIN freight.yards d ON d.id = ts.destination_station_id
+     LEFT JOIN freight.train_sets tset ON tset.id = ts.train_set_id
+     LEFT JOIN LATERAL (
+       SELECT COALESCE(SUM(tw.capacity_tons), 0) AS cap_tons,
+              COALESCE(SUM(tw.assigned_weight_tons), 0) AS booked_tons
+       FROM freight.train_set_wagons tw
+       WHERE tw.train_set_id = ts.train_set_id AND tw.deleted_at IS NULL) w ON true
+     WHERE ts.deleted_at IS NULL
+       AND ts.status <> 'CANCELLED'
+       AND ($1::timestamptz IS NULL OR ts.scheduled_departure_date >= $1)
+       AND ($2::timestamptz IS NULL OR ts.scheduled_departure_date < $2)
+       AND ($3::uuid[] IS NULL OR ts.route_id = ANY($3))
+       AND ($4::text[] IS NULL OR ts.direction = ANY($4))
+       AND ($5::uuid[] IS NULL OR ts.origin_station_id = ANY($5) OR ts.destination_station_id = ANY($5))
+     ORDER BY ts.scheduled_departure_date DESC LIMIT 200`,
+    [f.dateFrom, f.dateTo, f.routeIds, f.directions, f.yardIds],
+  );
+  const withCap = rows.filter((r: Record<string, unknown>) => num(r.capacity_tons) > 0);
+  const capTons = sum(withCap, 'capacity_tons');
+  return {
+    kpis: [
+      { label: 'Schedules', value: rows.length },
+      {
+        label: 'Avg fill rate',
+        value: capTons > 0 ? Math.round((sum(withCap, 'booked_tons') / capTons) * 100) : 0,
+        unit: '%',
+      },
+      { label: 'Booked tonnage', value: sum(rows, 'booked_tons'), unit: 't' },
+    ],
+    rows,
+  };
+};
+
+const tripsPerRoute: ReportQuery = async (ds, f) => {
+  const rows = await ds.query(
+    `SELECT o.label AS origin, d.label AS destination, ts.direction,
+            COUNT(*)::int AS trips,
+            ROUND(COALESCE(SUM(w.booked_tons), 0))::float8 AS tons_hauled,
+            ROUND(COALESCE(AVG(w.booked_tons), 0))::float8 AS avg_tons_per_trip
+     FROM freight.train_schedules ts
+     JOIN freight.yards o ON o.id = ts.origin_station_id
+     JOIN freight.yards d ON d.id = ts.destination_station_id
+     LEFT JOIN LATERAL (
+       SELECT COALESCE(SUM(tw.assigned_weight_tons), 0) AS booked_tons
+       FROM freight.train_set_wagons tw
+       WHERE tw.train_set_id = ts.train_set_id AND tw.deleted_at IS NULL) w ON true
+     WHERE ts.deleted_at IS NULL
+       AND ts.status IN ('DISPATCHED', 'ARRIVED')
+       AND ($1::timestamptz IS NULL OR ts.scheduled_departure_date >= $1)
+       AND ($2::timestamptz IS NULL OR ts.scheduled_departure_date < $2)
+       AND ($3::uuid[] IS NULL OR ts.route_id = ANY($3))
+       AND ($4::text[] IS NULL OR ts.direction = ANY($4))
+       AND ($5::uuid[] IS NULL OR ts.origin_station_id = ANY($5) OR ts.destination_station_id = ANY($5))
+     GROUP BY 1, 2, 3 ORDER BY trips DESC`,
+    [f.dateFrom, f.dateTo, f.routeIds, f.directions, f.yardIds],
+  );
+  return {
+    kpis: [
+      { label: 'Trips', value: sum(rows, 'trips') },
+      { label: 'Routes served', value: rows.length },
+      { label: 'Tonnage hauled', value: sum(rows, 'tons_hauled'), unit: 't' },
+    ],
+    rows,
+  };
+};
+
+const invoicedVsCollected: ReportQuery = async (ds, f) => {
+  const rows = await ds.query(
+    `SELECT to_char(date_trunc($5, COALESCE(i.issued_at, i.created_at)), 'YYYY-MM-DD') AS period,
+            COUNT(*)::int AS invoices,
+            ROUND(SUM(i.total_amount))::float8 AS invoiced,
+            ROUND(SUM(i.paid_amount))::float8 AS collected,
+            ROUND(SUM(i.balance_amount))::float8 AS outstanding
+     FROM freight.invoices i
+     WHERE i.deleted_at IS NULL
+       AND i.status NOT IN ('DRAFT', 'CANCELLED')
+       AND ($1::timestamptz IS NULL OR COALESCE(i.issued_at, i.created_at) >= $1)
+       AND ($2::timestamptz IS NULL OR COALESCE(i.issued_at, i.created_at) < $2)
+       AND ($3::uuid[] IS NULL OR i.company_id = ANY($3))
+       AND ${refDirScope('i.source_id', '$4')}
+     GROUP BY 1 ORDER BY 1`,
+    [f.dateFrom, f.dateTo, f.companyIds, f.directions, f.granularity],
+  );
+  const invoiced = sum(rows, 'invoiced');
+  const collected = sum(rows, 'collected');
+  return {
+    kpis: [
+      { label: 'Invoiced', value: invoiced, unit: 'ETB' },
+      { label: 'Collected', value: collected, unit: 'ETB' },
+      {
+        label: 'Collection rate',
+        value: invoiced > 0 ? Math.round((collected / invoiced) * 100) : 0,
+        unit: '%',
+      },
+      { label: 'Outstanding', value: sum(rows, 'outstanding'), unit: 'ETB' },
+    ],
+    rows,
+  };
+};
+
+// Aging is an as-of snapshot: dateTo is the as-of moment (default now),
+// dateFrom is ignored.
+const agingReceivables: ReportQuery = async (ds, f) => {
+  const rows = await ds.query(
+    `SELECT c.name AS customer,
+            COUNT(*)::int AS invoices,
+            ROUND(SUM(i.balance_amount))::float8 AS outstanding,
+            ROUND(COALESCE(SUM(i.balance_amount) FILTER (WHERE i.due_at >= COALESCE($1::timestamptz, now())), 0))::float8 AS current,
+            ROUND(COALESCE(SUM(i.balance_amount) FILTER (WHERE i.due_at < COALESCE($1::timestamptz, now())
+              AND i.due_at >= COALESCE($1::timestamptz, now()) - interval '30 days'), 0))::float8 AS overdue_0_30,
+            ROUND(COALESCE(SUM(i.balance_amount) FILTER (WHERE i.due_at < COALESCE($1::timestamptz, now()) - interval '30 days'
+              AND i.due_at >= COALESCE($1::timestamptz, now()) - interval '60 days'), 0))::float8 AS overdue_31_60,
+            ROUND(COALESCE(SUM(i.balance_amount) FILTER (WHERE i.due_at < COALESCE($1::timestamptz, now()) - interval '60 days'
+              AND i.due_at >= COALESCE($1::timestamptz, now()) - interval '90 days'), 0))::float8 AS overdue_61_90,
+            ROUND(COALESCE(SUM(i.balance_amount) FILTER (WHERE i.due_at < COALESCE($1::timestamptz, now()) - interval '90 days'), 0))::float8 AS overdue_90_plus
+     FROM freight.invoices i
+     JOIN freight.companies c ON c.id = i.company_id
+     WHERE i.deleted_at IS NULL
+       AND i.status IN ('ISSUED', 'PENDING', 'PARTIALLY_PAID', 'OVERDUE')
+       AND i.balance_amount > 0
+       AND ($1::timestamptz IS NULL OR i.created_at < $1)
+       AND ($2::uuid[] IS NULL OR i.company_id = ANY($2))
+       AND ${refDirScope('i.source_id', '$3')}
+     GROUP BY 1 ORDER BY outstanding DESC LIMIT 200`,
+    [f.dateTo, f.companyIds, f.directions],
+  );
+  const outstanding = sum(rows, 'outstanding');
+  return {
+    kpis: [
+      { label: 'Outstanding', value: outstanding, unit: 'ETB' },
+      { label: 'Overdue', value: outstanding - sum(rows, 'current'), unit: 'ETB' },
+      { label: 'Customers with balance', value: rows.length },
+    ],
+    rows,
+  };
+};
+
+const revenueByPaymentMethod: ReportQuery = async (ds, f) => {
+  // payments.status values are lowercase-hyphenated ('success'), unlike every
+  // other status enum in the schema. No deleted_at on this table.
+  const rows = await ds.query(
+    `SELECT p.method::text AS method,
+            COUNT(*)::int AS payments,
+            ROUND(SUM(p.amount))::float8 AS amount
+     FROM freight.payments p
+     WHERE p.status = 'success'
+       AND ($1::timestamptz IS NULL OR p.created_at >= $1)
+       AND ($2::timestamptz IS NULL OR p.created_at < $2)
+       AND ${refDirScope('p.ref_id', '$3')}
+     GROUP BY 1 ORDER BY amount DESC`,
+    [f.dateFrom, f.dateTo, f.directions],
+  );
+  const total = sum(rows, 'amount');
+  return {
+    kpis: [
+      { label: 'Collected', value: total, unit: 'ETB' },
+      { label: 'Payments', value: sum(rows, 'payments') },
+      {
+        label: 'Top method share',
+        value: total > 0 ? Math.round((num(rows[0]?.amount) / total) * 100) : 0,
+        unit: '%',
+      },
+    ],
+    rows,
+  };
+};
+
+// ---------------------------------------------------------------------------
+// Record-level list exports. Same engine, raw rows instead of aggregates.
+// ponytail: flat LIMIT 5000 per list — stream/paginate the export if a table
+// ever outgrows that.
+const LIST_LIMIT = 5000;
+
+const bookingsList: ReportQuery = async (ds, f) => {
+  const { where, params } = bookingWhere(f);
+  const rows = await ds.query(
+    `SELECT b.reference,
+            to_char(b.created_at, 'YYYY-MM-DD') AS created,
+            c.name AS customer, b.status, b.freight_type,
+            b.trade_direction AS direction,
+            o.label AS origin, d.label AS destination,
+            COALESCE(cty.cargo_type_name, b.cargo_free_text) AS cargo,
+            ROUND(${TONS})::float8 AS tons,
+            ROUND(${REVENUE})::float8 AS amount,
+            b.payment_status, b.scheduling_status
+     FROM freight.bookings b
+     JOIN freight.companies c ON c.id = b.company_id
+     JOIN freight.yards o ON o.id = b.origin_yard_id
+     JOIN freight.yards d ON d.id = b.destination_yard_id
+     LEFT JOIN freight.cargo_types cty ON cty.id = b.cargo_type_id
+     WHERE ${where}
+     ORDER BY b.created_at DESC LIMIT ${LIST_LIMIT}`,
+    params,
+  );
+  return {
+    kpis: [
+      { label: 'Bookings', value: rows.length },
+      { label: 'Tonnage', value: sum(rows, 'tons'), unit: 't' },
+      { label: 'Amount', value: sum(rows, 'amount'), unit: 'ETB' },
+    ],
+    rows,
+  };
+};
+
+const contractsList: ReportQuery = async (ds, f) => {
+  const rows = await ds.query(
+    `SELECT ct.reference, c.name AS customer, ct.contract_kind AS kind,
+            ct.status, ct.trade_direction AS direction, ct.freight_type,
+            to_char(ct.contract_valid_from, 'YYYY-MM-DD') AS valid_from,
+            to_char(ct.contract_valid_until, 'YYYY-MM-DD') AS valid_until,
+            to_char(ct.created_at, 'YYYY-MM-DD') AS created
+     FROM freight.contracts ct
+     LEFT JOIN freight.companies c ON c.id = ct.company_id
+     WHERE ct.deleted_at IS NULL
+       AND ($1::timestamptz IS NULL OR ct.created_at >= $1)
+       AND ($2::timestamptz IS NULL OR ct.created_at < $2)
+       AND ($3::uuid[] IS NULL OR ct.company_id = ANY($3))
+       AND ($4::text[] IS NULL OR ct.trade_direction = ANY($4))
+       AND ($5::text[] IS NULL OR ct.status = ANY($5))
+     ORDER BY ct.created_at DESC LIMIT ${LIST_LIMIT}`,
+    [f.dateFrom, f.dateTo, f.companyIds, f.directions, f.statuses],
+  );
+  const active = rows.filter((r: Record<string, unknown>) =>
+    ['CONTRACT_ACTIVE', 'ACTIVE_SHIPMENT_IN_PROGRESS'].includes(String(r.status)),
+  ).length;
+  return {
+    kpis: [
+      { label: 'Contracts', value: rows.length },
+      { label: 'Active', value: active },
+    ],
+    rows,
+  };
+};
+
+const schedulesList: ReportQuery = async (ds, f) => {
+  const rows = await ds.query(
+    `SELECT ts.train_number, ts.reference, ts.direction, ts.status,
+            o.label AS origin, d.label AS destination,
+            to_char(ts.scheduled_departure_date, 'YYYY-MM-DD HH24:MI') AS scheduled_departure,
+            to_char(ts.actual_departure_at, 'YYYY-MM-DD HH24:MI') AS actual_departure,
+            to_char(ts.scheduled_arrival_date, 'YYYY-MM-DD HH24:MI') AS scheduled_arrival,
+            to_char(ts.actual_arrival_at, 'YYYY-MM-DD HH24:MI') AS actual_arrival,
+            ts.max_wagons, tset.wagon_count
+     FROM freight.train_schedules ts
+     JOIN freight.yards o ON o.id = ts.origin_station_id
+     JOIN freight.yards d ON d.id = ts.destination_station_id
+     LEFT JOIN freight.train_sets tset ON tset.id = ts.train_set_id
+     WHERE ts.deleted_at IS NULL
+       AND ($1::timestamptz IS NULL OR ts.scheduled_departure_date >= $1)
+       AND ($2::timestamptz IS NULL OR ts.scheduled_departure_date < $2)
+       AND ($3::text[] IS NULL OR ts.direction = ANY($3))
+       AND ($4::text[] IS NULL OR ts.status = ANY($4))
+       AND ($5::uuid[] IS NULL OR ts.origin_station_id = ANY($5) OR ts.destination_station_id = ANY($5))
+     ORDER BY ts.scheduled_departure_date DESC LIMIT ${LIST_LIMIT}`,
+    [f.dateFrom, f.dateTo, f.directions, f.statuses, f.yardIds],
+  );
+  const count = (s: string) =>
+    rows.filter((r: Record<string, unknown>) => r.status === s).length;
+  return {
+    kpis: [
+      { label: 'Schedules', value: rows.length },
+      { label: 'Dispatched', value: count('DISPATCHED') },
+      { label: 'Arrived', value: count('ARRIVED') },
+    ],
+    rows,
+  };
+};
+
+const fleetWagons: ReportQuery = async (ds, f) => {
+  const rows = await ds.query(
+    `SELECT w.wagon_number, wt.name AS type,
+            wt.capacity_tons::float8 AS capacity_tons,
+            w.status, y.label AS current_yard
+     FROM freight.wagons w
+     JOIN freight.wagon_types wt ON wt.id = w.wagon_type_id
+     LEFT JOIN freight.yards y ON y.id = w.current_yard_id
+     WHERE w.deleted_at IS NULL
+       AND ($1::text[] IS NULL OR w.status = ANY($1))
+       AND ($2::uuid[] IS NULL OR w.current_yard_id = ANY($2))
+     ORDER BY w.wagon_number LIMIT ${LIST_LIMIT}`,
+    [f.statuses, f.yardIds],
+  );
+  const count = (s: string) =>
+    rows.filter((r: Record<string, unknown>) => r.status === s).length;
+  return {
+    kpis: [
+      { label: 'Wagons', value: rows.length },
+      { label: 'Available', value: count('AVAILABLE') },
+      { label: 'Assigned', value: count('ASSIGNED') },
+      { label: 'Maintenance', value: count('MAINTENANCE') },
+    ],
+    rows,
+  };
+};
+
+const fleetLocomotives: ReportQuery = async (ds, f) => {
+  const rows = await ds.query(
+    `SELECT l.code, l.name, l.locomotive_type,
+            l.max_pull_weight_tons::float8 AS max_pull_tons,
+            l.status, y.label AS current_yard
+     FROM freight.locomotives l
+     LEFT JOIN freight.yards y ON y.id = l.current_yard_id
+     WHERE l.deleted_at IS NULL
+       AND ($1::text[] IS NULL OR l.status = ANY($1))
+       AND ($2::uuid[] IS NULL OR l.current_yard_id = ANY($2))
+     ORDER BY l.code LIMIT ${LIST_LIMIT}`,
+    [f.statuses, f.yardIds],
+  );
+  const available = rows.filter(
+    (r: Record<string, unknown>) => r.status === 'AVAILABLE',
+  ).length;
+  return {
+    kpis: [
+      { label: 'Locomotives', value: rows.length },
+      { label: 'Available', value: available },
+    ],
+    rows,
+  };
+};
+
+const customersList: ReportQuery = async (ds, f) => {
+  const rows = await ds.query(
+    `SELECT c.name, c.type, c.kind, c.status, c.tin,
+            to_char(c.approved_at, 'YYYY-MM-DD') AS approved,
+            to_char(c.created_at, 'YYYY-MM-DD') AS created
+     FROM freight.companies c
+     WHERE c.deleted_at IS NULL
+       AND ($1::timestamptz IS NULL OR c.created_at >= $1)
+       AND ($2::timestamptz IS NULL OR c.created_at < $2)
+       AND ($3::text[] IS NULL OR c.status = ANY($3))
+     ORDER BY c.created_at DESC LIMIT ${LIST_LIMIT}`,
+    [f.dateFrom, f.dateTo, f.statuses],
+  );
+  const active = rows.filter(
+    (r: Record<string, unknown>) => r.status === 'active',
+  ).length;
+  return {
+    kpis: [
+      { label: 'Customers', value: rows.length },
+      { label: 'Active', value: active },
+    ],
+    rows,
+  };
+};
+
+const paymentsList: ReportQuery = async (ds, f) => {
+  // No deleted_at on freight.payments; statuses are lowercase-hyphenated.
+  const rows = await ds.query(
+    `SELECT to_char(p.created_at, 'YYYY-MM-DD HH24:MI') AS created,
+            p.method::text AS method, p.status::text AS status,
+            p.currency::text AS currency,
+            ROUND(p.amount)::float8 AS amount,
+            p.transaction_id, p.merchant_order_id,
+            to_char(p.paid_at, 'YYYY-MM-DD') AS paid
+     FROM freight.payments p
+     WHERE ($1::timestamptz IS NULL OR p.created_at >= $1)
+       AND ($2::timestamptz IS NULL OR p.created_at < $2)
+       AND ($3::text[] IS NULL OR p.status::text = ANY($3))
+       AND ${refDirScope('p.ref_id', '$4')}
+     ORDER BY p.created_at DESC LIMIT ${LIST_LIMIT}`,
+    [f.dateFrom, f.dateTo, f.statuses, f.directions],
+  );
+  const success = rows.filter(
+    (r: Record<string, unknown>) => r.status === 'success',
+  );
+  return {
+    kpis: [
+      { label: 'Payments', value: rows.length },
+      { label: 'Successful', value: success.length },
+      { label: 'Collected', value: sum(success, 'amount'), unit: 'ETB' },
+    ],
+    rows,
+  };
+};
+
+export const REPORT_QUERIES: Record<string, ReportQuery> = {
+  'bookings-list': bookingsList,
+  'contracts-list': contractsList,
+  'schedules-list': schedulesList,
+  'fleet-wagons': fleetWagons,
+  'fleet-locomotives': fleetLocomotives,
+  'customers-list': customersList,
+  'payments-list': paymentsList,
+  'bookings-trend': bookingsTrend,
+  'revenue-by-customer': revenueByCustomer,
+  'revenue-by-lane': revenueByLane,
+  'contract-utilization': contractUtilization,
+  'train-on-time': trainOnTime,
+  'schedule-fill-rate': scheduleFillRate,
+  'trips-per-route': tripsPerRoute,
+  'invoiced-vs-collected': invoicedVsCollected,
+  'aging-receivables': agingReceivables,
+  'revenue-by-payment-method': revenueByPaymentMethod,
+};
diff --git a/apps/edr-freight-api/src/modules/reports/reports.controller.ts b/apps/edr-freight-api/src/modules/reports/reports.controller.ts
new file mode 100644
index 000000000..bc2671680
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/reports/reports.controller.ts
@@ -0,0 +1,33 @@
+import { Controller, Get, Param, Query } from '@nestjs/common';
+import { ApiBearerAuth, ApiOkResponse, ApiOperation, ApiTags } from '@nestjs/swagger';
+import { CurrentUser } from '@edr/api-common';
+import type { TCurrentUser } from '@tria-plc/api-common/modules/auth/types/current-user.type';
+
+import { BookingView } from '../../common/booking-guards';
+import { UserTradeAccessService } from '../user-trade-access/user-trade-access.service';
+import { ReportQueryDto } from './dto/report-query.dto';
+import { ReportResultDto } from './dto/report-result.dto';
+import { ReportsService } from './reports.service';
+
+@ApiTags('Reports')
+@ApiBearerAuth()
+@Controller('reports')
+export class ReportsController {
+  constructor(
+    private readonly reportsService: ReportsService,
+    private readonly userTradeAccessService: UserTradeAccessService,
+  ) {}
+
+  @Get(':key')
+  @BookingView()
+  @ApiOperation({ summary: 'Run a canned report by key with optional filters' })
+  @ApiOkResponse({ type: ReportResultDto })
+  async run(
+    @Param('key') key: string,
+    @Query() query: ReportQueryDto,
+    @CurrentUser() user: TCurrentUser,
+  ): Promise<ReportResultDto> {
+    const allowed = await this.userTradeAccessService.resolveAllowedDirections(user);
+    return this.reportsService.run(key, query, allowed);
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/reports/reports.module.ts b/apps/edr-freight-api/src/modules/reports/reports.module.ts
new file mode 100644
index 000000000..a7fe792a5
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/reports/reports.module.ts
@@ -0,0 +1,13 @@
+import { Module } from '@nestjs/common';
+
+import { UserTradeAccessModule } from '../user-trade-access/user-trade-access.module';
+import { ReportsController } from './reports.controller';
+import { ReportsRepository } from './reports.repository';
+import { ReportsService } from './reports.service';
+
+@Module({
+  imports: [UserTradeAccessModule],
+  controllers: [ReportsController],
+  providers: [ReportsService, ReportsRepository],
+})
+export class ReportsModule {}
diff --git a/apps/edr-freight-api/src/modules/reports/reports.repository.ts b/apps/edr-freight-api/src/modules/reports/reports.repository.ts
new file mode 100644
index 000000000..65f154b22
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/reports/reports.repository.ts
@@ -0,0 +1,14 @@
+import { Injectable } from '@nestjs/common';
+import { InjectDataSource } from '@nestjs/typeorm';
+import { DataSource } from 'typeorm';
+
+import { REPORT_QUERIES, ReportFilters, ReportResult } from './report-queries';
+
+@Injectable()
+export class ReportsRepository {
+  constructor(@InjectDataSource() private readonly dataSource: DataSource) {}
+
+  run(key: keyof typeof REPORT_QUERIES, filters: ReportFilters): Promise<ReportResult> {
+    return REPORT_QUERIES[key](this.dataSource, filters);
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/reports/reports.service.ts b/apps/edr-freight-api/src/modules/reports/reports.service.ts
new file mode 100644
index 000000000..04e6e9a60
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/reports/reports.service.ts
@@ -0,0 +1,46 @@
+import { Injectable, NotFoundException } from '@nestjs/common';
+
+import { scopedDirections } from '../user-trade-access/trade-scope.util';
+import { ReportQueryDto } from './dto/report-query.dto';
+import { REPORT_QUERIES, ReportFilters, ReportResult } from './report-queries';
+import { ReportsRepository } from './reports.repository';
+import type { Freight } from '@edr/types';
+
+const DAY_MS = 24 * 60 * 60 * 1000;
+
+const list = (csv?: string): string[] | null => {
+  const items = csv?.split(',').map((s) => s.trim()).filter(Boolean) ?? [];
+  return items.length ? items : null;
+};
+
+@Injectable()
+export class ReportsService {
+  constructor(private readonly repository: ReportsRepository) {}
+
+  run(
+    key: string,
+    dto: ReportQueryDto,
+    allowedDirections: Freight.ScheduleTradeDirection[] | null,
+  ): Promise<ReportResult> {
+    if (!(key in REPORT_QUERIES)) {
+      throw new NotFoundException(`Unknown report: ${key}`);
+    }
+    // No default range: absent dates mean all time, so exports cover everything.
+    const to = dto.dateTo ? new Date(dto.dateTo) : null;
+    const from = dto.dateFrom ? new Date(dto.dateFrom) : null;
+    const filters: ReportFilters = {
+      dateFrom: from ? from.toISOString() : null,
+      // dateTo is inclusive in the API; queries treat the bound as exclusive.
+      dateTo: to ? new Date(to.getTime() + DAY_MS).toISOString() : null,
+      granularity: dto.granularity ?? 'day',
+      companyIds: list(dto.companyIds),
+      routeIds: list(dto.routeIds),
+      yardIds: list(dto.yardIds),
+      cargoTypeIds: list(dto.cargoTypeIds),
+      statuses: list(dto.statuses),
+      directions: scopedDirections(allowedDirections, dto.direction),
+      freightType: dto.freightType ?? null,
+    };
+    return this.repository.run(key, filters);
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/rule-engine/dto/create-cargo-type.dto.ts b/apps/edr-freight-api/src/modules/rule-engine/dto/create-cargo-type.dto.ts
index 6d9cb82a2..eefc560e8 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/dto/create-cargo-type.dto.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/dto/create-cargo-type.dto.ts
@@ -44,6 +44,19 @@ export class CreateCargoTypeDto {
   @IsObject()
   itemsPerWagonMap?: Record<string, number> | null;
 
+  @ApiPropertyOptional({
+    description:
+      'PER_TON cargo only: the most tons of this cargo one wagon may carry, keyed by ' +
+      'wagon-type id (e.g. { "<nw5-id>": 50 } loads sugar 50T on a 70T wagon, so 200T ' +
+      'takes 4 wagons). Optional — omit a wagon type to use its full rated capacity. ' +
+      'Rejected when it exceeds that wagon type\'s rated capacity.',
+    type: 'object',
+    additionalProperties: { type: 'number', minimum: 0.001 },
+  })
+  @IsOptional()
+  @IsObject()
+  tonsPerWagonMap?: Record<string, number> | null;
+
   @ApiPropertyOptional({ default: false })
   @IsOptional()
   @IsBoolean()
diff --git a/apps/edr-freight-api/src/modules/rule-engine/dto/create-yard.dto.ts b/apps/edr-freight-api/src/modules/rule-engine/dto/create-yard.dto.ts
index 295e9e72b..94dbd2fb8 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/dto/create-yard.dto.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/dto/create-yard.dto.ts
@@ -26,6 +26,38 @@ export class CreateYardDto {
   @IsBoolean()
   hasFacility?: boolean;
 
+  @ApiPropertyOptional({
+    default: false,
+    description: 'Facility can load containers onto a train (contract origin side)',
+  })
+  @IsOptional()
+  @IsBoolean()
+  hasContainerFacilityOrigin?: boolean;
+
+  @ApiPropertyOptional({
+    default: false,
+    description: 'Facility can load bulk onto a train (contract origin side)',
+  })
+  @IsOptional()
+  @IsBoolean()
+  hasBulkFacilityOrigin?: boolean;
+
+  @ApiPropertyOptional({
+    default: false,
+    description: 'Facility can receive containers off a train (contract destination side)',
+  })
+  @IsOptional()
+  @IsBoolean()
+  hasContainerFacilityDestination?: boolean;
+
+  @ApiPropertyOptional({
+    default: false,
+    description: 'Facility can receive bulk off a train (contract destination side)',
+  })
+  @IsOptional()
+  @IsBoolean()
+  hasBulkFacilityDestination?: boolean;
+
   @ApiPropertyOptional({ default: 1, description: 'UI display sort order' })
   @IsOptional()
   @IsInt()
diff --git a/apps/edr-freight-api/src/modules/rule-engine/entities/cargo-type.entity.ts b/apps/edr-freight-api/src/modules/rule-engine/entities/cargo-type.entity.ts
index b096613bf..e685f3a2d 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/entities/cargo-type.entity.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/entities/cargo-type.entity.ts
@@ -60,6 +60,17 @@ export class CargoType extends BaseEntity {
   @Column({ name: 'items_per_wagon_map', type: 'jsonb', nullable: true })
   itemsPerWagonMap?: Record<string, number> | null;
 
+  /**
+   * PER_TON (bulk) only: the most tons of THIS cargo that may ride one wagon of
+   * each allowed type, keyed by wagon-type id (e.g. sugar → { NW5: 50 } on a
+   * 70T wagon). Caps both the wagon count and how much each wagon is loaded, so
+   * 200T of sugar takes 4 wagons at 50T rather than 3 at 70T. A missing key (or
+   * a null map) means the wagon's full rated capacity — unlike itemsPerWagonMap
+   * this is optional, so cargo without a loading limit is unaffected.
+   */
+  @Column({ name: 'tons_per_wagon_map', type: 'jsonb', nullable: true })
+  tonsPerWagonMap?: Record<string, number> | null;
+
   @Column({ name: 'requires_director_approval', type: 'boolean', default: false })
   requiresDirectorApproval!: boolean;
 
diff --git a/apps/edr-freight-api/src/modules/rule-engine/entities/yard-facility.entity.ts b/apps/edr-freight-api/src/modules/rule-engine/entities/yard-facility.entity.ts
index 5712eed03..9c69f0135 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/entities/yard-facility.entity.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/entities/yard-facility.entity.ts
@@ -37,6 +37,27 @@ export class YardFacility extends BaseEntity {
   @Column({ name: 'handles_bulk', type: 'boolean', default: true })
   handlesBulk!: boolean;
 
+  /**
+   * Per-side capability. Loading a type onto a train and receiving it off one
+   * need different ground: a facility can be equipped to send containers but
+   * have no space to stage arriving ones. `handles_container` / `handles_bulk`
+   * stay the coarse "is this type handled here at all" switch; these four say
+   * on which side. A yard is offered as a contract origin for a freight type
+   * when it handles the type AND the matching `_origin` flag is set, and as a
+   * destination on the same rule with `_destination`.
+   */
+  @Column({ name: 'has_container_facility_origin', type: 'boolean', default: false })
+  hasContainerFacilityOrigin!: boolean;
+
+  @Column({ name: 'has_bulk_facility_origin', type: 'boolean', default: false })
+  hasBulkFacilityOrigin!: boolean;
+
+  @Column({ name: 'has_container_facility_destination', type: 'boolean', default: false })
+  hasContainerFacilityDestination!: boolean;
+
+  @Column({ name: 'has_bulk_facility_destination', type: 'boolean', default: false })
+  hasBulkFacilityDestination!: boolean;
+
   @Column({ name: 'equipment_notes', type: 'text', nullable: true })
   equipmentNotes?: string | null;
 
diff --git a/apps/edr-freight-api/src/modules/rule-engine/rule-engine.module.ts b/apps/edr-freight-api/src/modules/rule-engine/rule-engine.module.ts
index 691992c54..2e1fd8090 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/rule-engine.module.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/rule-engine.module.ts
@@ -68,6 +68,7 @@ import { YardFacilitiesService } from './services/yard-facilities.service';
 import { RuleEngineService } from './rule-engine.service';
 
 import { NotificationInboxModule } from '../notification-inbox/notification-inbox.module';
+import { WagonTypesModule } from '../wagon-types/wagon-types.module';
 
 import { BookingCargoModifier } from '../bookings/entities/booking-cargo-modifier.entity';
 import { BookingContainer } from '../bookings/entities/booking-container.entity';
@@ -96,6 +97,9 @@ import { BookingRateSnapshot } from '../bookings/entities/booking-rate-snapshot.
     ]),
     // Team notifications for the priority-rule approval workflow.
     NotificationInboxModule,
+    // Rated wagon capacities — cargo types validate their per-wagon tonnage cap
+    // against them (a cap above the rating is a typo, not a policy).
+    WagonTypesModule,
   ],
   controllers: [
     CargoTypesController,
diff --git a/apps/edr-freight-api/src/modules/rule-engine/services/cargo-types.service.ts b/apps/edr-freight-api/src/modules/rule-engine/services/cargo-types.service.ts
index 34287a023..1f25b0823 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/services/cargo-types.service.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/services/cargo-types.service.ts
@@ -6,6 +6,7 @@ import {
   Injectable,
   NotFoundException,
 } from '@nestjs/common';
+import { In } from 'typeorm';
 import { generateCode } from '../../../common/utils/generate-code.util';
 import { CreateCargoTypeDto } from '../dto/create-cargo-type.dto';
 import { ListCargoTypesQueryDto } from '../dto/list-rule-engine-query.dto';
@@ -13,6 +14,7 @@ import { ReorderItemsDto } from '../dto/reorder-items.dto';
 import { UpdateCargoTypeDto } from '../dto/update-cargo-type.dto';
 import { CargoType } from '../entities/cargo-type.entity';
 import { WagonType } from '../../wagon-types/entities/wagon-type.entity';
+import { WagonTypesRepository } from '../../wagon-types/wagon-types.repository';
 import {
   CARGO_TYPES_REPOSITORY,
   ICargoTypesRepository,
@@ -27,6 +29,7 @@ export class CargoTypesService {
     private readonly repository: ICargoTypesRepository,
     @Inject(RATES_REPOSITORY)
     private readonly ratesRepository: IRatesRepository,
+    private readonly wagonTypesRepository: WagonTypesRepository,
     private readonly displayOrder: DisplayOrderService,
   ) {}
 
@@ -75,6 +78,63 @@ export class CargoTypesService {
     return map;
   }
 
+  /**
+   * PER_TON (bulk) cargo may cap how many tons ride one wagon, BELOW that
+   * wagon's rated capacity: sugar at 50T on a 70T wagon means 200T takes 4
+   * wagons, not 3. Unlike the PER_ITEM fit this is optional — an absent key
+   * means the full rated capacity, so existing cargo types are unaffected.
+   *
+   * A cap ABOVE the rated capacity is rejected: nobody loads 90T on a 70T
+   * wagon, so it is a typo, and silently clamping it would leave the config
+   * screen showing a number the trains never honour. (Allocation clamps too, via
+   * `bulkTonsPerWagon`, for caps left stale by a later wagon-type edit — this
+   * check cannot see those, since the cargo type is never re-saved.)
+   *
+   * Returns the map trimmed to the allowed wagon types, or null when the cargo
+   * is not PER_TON / nothing is capped.
+   */
+  private async resolveTonsPerWagonMap(input: {
+    unitOfMeasure?: CargoUnitOfMeasure | null;
+    wagonTypeIds: string[];
+    tonsPerWagonMap?: Record<string, number> | null;
+  }): Promise<Record<string, number> | null> {
+    if (input.unitOfMeasure !== CargoUnitOfMeasure.PerTon || !input.wagonTypeIds.length) {
+      return null;
+    }
+    const capped = input.wagonTypeIds.filter(
+      (id) => input.tonsPerWagonMap?.[id] !== undefined && input.tonsPerWagonMap[id] !== null,
+    );
+    if (!capped.length) return null;
+
+    const wagonTypes = await this.wagonTypesRepository.findAll({
+      where: { id: In(capped) },
+    });
+    const capacityById = new Map(
+      wagonTypes.map((wt) => [wt.id, Number(wt.capacityTons) || 0]),
+    );
+
+    const map: Record<string, number> = {};
+    for (const wagonTypeId of capped) {
+      const tons = Number(input.tonsPerWagonMap?.[wagonTypeId]);
+      if (!Number.isFinite(tons) || tons <= 0) {
+        throw new BadRequestException(
+          `tonsPerWagonMap for wagon type ${wagonTypeId} must be a number greater than 0`,
+        );
+      }
+      const capacity = capacityById.get(wagonTypeId);
+      if (capacity === undefined) {
+        throw new BadRequestException(`Wagon type ${wagonTypeId} not found`);
+      }
+      if (capacity > 0 && tons > capacity) {
+        throw new BadRequestException(
+          `Max tons per wagon (${tons}T) exceeds wagon type ${wagonTypeId} rated capacity ${capacity}T`,
+        );
+      }
+      map[wagonTypeId] = tons;
+    }
+    return map;
+  }
+
   /** Create a new cargo type. */
   async create(dto: CreateCargoTypeDto): Promise<CargoType> {
     const code = generateCode(dto.cargoTypeName);
@@ -90,6 +150,12 @@ export class CargoTypesService {
       insertAfterId: dto.insertAfterId,
     });
 
+    const tonsPerWagonMap = await this.resolveTonsPerWagonMap({
+      unitOfMeasure: dto.unitOfMeasure ?? null,
+      wagonTypeIds: dto.wagonTypeIds ?? [],
+      tonsPerWagonMap: dto.tonsPerWagonMap,
+    });
+
     return this.repository.create({
       code,
       cargoTypeName: dto.cargoTypeName,
@@ -104,6 +170,7 @@ export class CargoTypesService {
         wagonTypeIds: dto.wagonTypeIds ?? [],
         itemsPerWagonMap: dto.itemsPerWagonMap,
       }),
+      tonsPerWagonMap,
       displayOrder,
     });
   }
@@ -116,12 +183,32 @@ export class CargoTypesService {
       const parent = await this.repository.findById(dto.parentGroupId);
       if (!parent) throw new NotFoundException(`Parent cargo type ${dto.parentGroupId} not found`);
     }
-    const { wagonTypeIds, itemsPerWagonMap, insertAfterId: _insertAfterId, ...columns } = dto;
+    const {
+      wagonTypeIds,
+      itemsPerWagonMap,
+      tonsPerWagonMap,
+      insertAfterId: _insertAfterId,
+      ...columns
+    } = dto;
     // Re-validate the fit map whenever anything it depends on moves — a partial
     // update merges with the stored values so e.g. adding a wagon type without
     // its fit still 400s. Untouched fields leave the stored map alone.
     const touchesItemsFit =
       wagonTypeIds !== undefined || itemsPerWagonMap !== undefined || dto.unitOfMeasure !== undefined;
+    // Same merge rule for the tonnage cap: re-resolve whenever the uom, the
+    // allowed wagon types, or the caps themselves move, so a wagon type added
+    // without a cap keeps its full rated capacity and a uom flip drops stale caps.
+    const touchesTonsCap =
+      wagonTypeIds !== undefined || tonsPerWagonMap !== undefined || dto.unitOfMeasure !== undefined;
+    const resolvedTonsPerWagonMap = touchesTonsCap
+      ? await this.resolveTonsPerWagonMap({
+          unitOfMeasure:
+            dto.unitOfMeasure !== undefined ? dto.unitOfMeasure : existing.unitOfMeasure,
+          wagonTypeIds: wagonTypeIds ?? (existing.wagonTypes ?? []).map((wt) => wt.id),
+          tonsPerWagonMap:
+            tonsPerWagonMap !== undefined ? tonsPerWagonMap : existing.tonsPerWagonMap,
+        })
+      : undefined;
     const updated = await this.repository.update(id, {
       ...columns,
       ...(wagonTypeIds
@@ -138,6 +225,7 @@ export class CargoTypesService {
             }),
           }
         : {}),
+      ...(touchesTonsCap ? { tonsPerWagonMap: resolvedTonsPerWagonMap } : {}),
     });
     if (!updated) throw new NotFoundException(`Cargo type ${id} not found`);
     // A uom flip renames how existing rates bill (PER_TON ↔ PER_ITEM name the
diff --git a/apps/edr-freight-api/src/modules/rule-engine/services/yard-facilities.service.ts b/apps/edr-freight-api/src/modules/rule-engine/services/yard-facilities.service.ts
index 4b69c328f..9602125bb 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/services/yard-facilities.service.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/services/yard-facilities.service.ts
@@ -13,6 +13,30 @@ export interface YardFacilityInfo {
   /** Containers need a reach stacker/gantry — not every facility has one. */
   handlesContainer: boolean;
   handlesBulk: boolean;
+  /**
+   * The same capability split by side of the trip — loading onto a train and
+   * receiving off one need different ground. Always false where the coarse
+   * `handles*` flag for that type is false.
+   */
+  hasContainerFacilityOrigin: boolean;
+  hasBulkFacilityOrigin: boolean;
+  hasContainerFacilityDestination: boolean;
+  hasBulkFacilityDestination: boolean;
+}
+
+/** Which side of the trip a yard is being considered for. */
+export type YardSide = 'ORIGIN' | 'DESTINATION';
+
+/**
+ * The four per-side capability flags as stored — NOT gated on the coarse
+ * `handles*` switches. The yards config page edits the stored values; gating
+ * is applied only when the flows resolve capability (see `toInfo`).
+ */
+export interface YardSideFlags {
+  hasContainerFacilityOrigin: boolean;
+  hasBulkFacilityOrigin: boolean;
+  hasContainerFacilityDestination: boolean;
+  hasBulkFacilityDestination: boolean;
 }
 
 /**
@@ -38,7 +62,11 @@ export class YardFacilitiesService {
            y.has_facility      AS "hasFacility",
            f.has_warehouse     AS "hasWarehouse",
            f.handles_container AS "handlesContainer",
-           f.handles_bulk      AS "handlesBulk"
+           f.handles_bulk      AS "handlesBulk",
+           f.has_container_facility_origin      AS "hasContainerFacilityOrigin",
+           f.has_bulk_facility_origin           AS "hasBulkFacilityOrigin",
+           f.has_container_facility_destination AS "hasContainerFacilityDestination",
+           f.has_bulk_facility_destination      AS "hasBulkFacilityDestination"
       FROM freight.yards y
       LEFT JOIN freight.yard_facilities f
         ON f.yard_id = y.id AND f.deleted_at IS NULL AND f.is_active = true`;
@@ -51,17 +79,33 @@ export class YardFacilitiesService {
     hasWarehouse: boolean | null;
     handlesContainer: boolean | null;
     handlesBulk: boolean | null;
+    hasContainerFacilityOrigin: boolean | null;
+    hasBulkFacilityOrigin: boolean | null;
+    hasContainerFacilityDestination: boolean | null;
+    hasBulkFacilityDestination: boolean | null;
   }): YardFacilityInfo {
     // No facility record means no capability, whatever the flag says.
     const hasFacility = Boolean(row.hasFacility);
+    const handlesContainer = hasFacility && Boolean(row.handlesContainer);
+    const handlesBulk = hasFacility && Boolean(row.handlesBulk);
     return {
       yardId: row.yardId,
       yardCode: row.yardCode,
       yardLabel: row.yardLabel,
       hasFacility,
       hasWarehouse: hasFacility && Boolean(row.hasWarehouse),
-      handlesContainer: hasFacility && Boolean(row.handlesContainer),
-      handlesBulk: hasFacility && Boolean(row.handlesBulk),
+      handlesContainer,
+      handlesBulk,
+      // Gated on the coarse flag so the two can't contradict each other: a
+      // per-side flag left set on a type the facility no longer handles at all
+      // never resurrects that type.
+      hasContainerFacilityOrigin:
+        handlesContainer && Boolean(row.hasContainerFacilityOrigin),
+      hasBulkFacilityOrigin: handlesBulk && Boolean(row.hasBulkFacilityOrigin),
+      hasContainerFacilityDestination:
+        handlesContainer && Boolean(row.hasContainerFacilityDestination),
+      hasBulkFacilityDestination:
+        handlesBulk && Boolean(row.hasBulkFacilityDestination),
     };
   }
 
@@ -84,6 +128,61 @@ export class YardFacilitiesService {
     return rows.map((r: Parameters<typeof this.toInfo>[0]) => this.toInfo(r));
   }
 
+  /** Stored per-side flags for a set of yards, keyed by yard id. Yards with no facility record are absent. */
+  async sideFlagsForYards(yardIds: string[]): Promise<Map<string, YardSideFlags>> {
+    if (yardIds.length === 0) return new Map();
+    const rows: Array<YardSideFlags & { yardId: string }> = await this.dataSource.query(
+      `SELECT yard_id                            AS "yardId",
+              has_container_facility_origin      AS "hasContainerFacilityOrigin",
+              has_bulk_facility_origin           AS "hasBulkFacilityOrigin",
+              has_container_facility_destination AS "hasContainerFacilityDestination",
+              has_bulk_facility_destination      AS "hasBulkFacilityDestination"
+         FROM freight.yard_facilities
+        WHERE deleted_at IS NULL AND yard_id = ANY($1)`,
+      [yardIds],
+    );
+    return new Map(
+      rows.map((r) => [
+        r.yardId,
+        {
+          hasContainerFacilityOrigin: r.hasContainerFacilityOrigin,
+          hasBulkFacilityOrigin: r.hasBulkFacilityOrigin,
+          hasContainerFacilityDestination: r.hasContainerFacilityDestination,
+          hasBulkFacilityDestination: r.hasBulkFacilityDestination,
+        },
+      ]),
+    );
+  }
+
+  /**
+   * Write per-side flags from the yards config form, creating the facility
+   * record if the yard doesn't have one yet (backoffice-created yards don't).
+   * Flags left undefined keep their stored value; on first insert they default
+   * false — an unconfigured facility offers nothing.
+   */
+  async upsertSideFlags(yardId: string, flags: Partial<YardSideFlags>): Promise<void> {
+    await this.dataSource.query(
+      `INSERT INTO freight.yard_facilities
+         (yard_id, has_container_facility_origin, has_bulk_facility_origin,
+          has_container_facility_destination, has_bulk_facility_destination)
+       VALUES ($1, COALESCE($2, false), COALESCE($3, false), COALESCE($4, false), COALESCE($5, false))
+       ON CONFLICT (yard_id) WHERE deleted_at IS NULL
+       DO UPDATE SET
+         has_container_facility_origin      = COALESCE($2, yard_facilities.has_container_facility_origin),
+         has_bulk_facility_origin           = COALESCE($3, yard_facilities.has_bulk_facility_origin),
+         has_container_facility_destination = COALESCE($4, yard_facilities.has_container_facility_destination),
+         has_bulk_facility_destination      = COALESCE($5, yard_facilities.has_bulk_facility_destination),
+         updated_at = now()`,
+      [
+        yardId,
+        flags.hasContainerFacilityOrigin ?? null,
+        flags.hasBulkFacilityOrigin ?? null,
+        flags.hasContainerFacilityDestination ?? null,
+        flags.hasBulkFacilityDestination ?? null,
+      ],
+    );
+  }
+
   /**
    * Can this facility lift this cargo? Keeps the freight-type rule in one place
    * so callers can't get it subtly wrong.
@@ -97,4 +196,26 @@ export class YardFacilitiesService {
       ? facility.handlesContainer
       : facility.handlesBulk;
   }
+
+  /**
+   * Can this facility take this cargo on this side of the trip? The rule behind
+   * the contract's origin/destination yard pickers — keep it here so the API
+   * and the forms can't drift apart on what is offerable.
+   */
+  canHandleFreightOnSide(
+    facility: YardFacilityInfo | null,
+    freightType: string | null | undefined,
+    side: YardSide,
+  ): boolean {
+    if (!facility?.hasFacility) return false;
+    const isContainer = String(freightType).toUpperCase() === 'CONTAINER';
+    if (side === 'ORIGIN') {
+      return isContainer
+        ? facility.hasContainerFacilityOrigin
+        : facility.hasBulkFacilityOrigin;
+    }
+    return isContainer
+      ? facility.hasContainerFacilityDestination
+      : facility.hasBulkFacilityDestination;
+  }
 }
diff --git a/apps/edr-freight-api/src/modules/rule-engine/services/yards.duplicate-label.spec.ts b/apps/edr-freight-api/src/modules/rule-engine/services/yards.duplicate-label.spec.ts
index 8affab199..0ec9fe282 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/services/yards.duplicate-label.spec.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/services/yards.duplicate-label.spec.ts
@@ -16,6 +16,10 @@ const service = (): YardsService =>
       update: async (_id: string, d: Partial<Yard>) => d as Yard,
     } as never,
     { resolveCreateOrder: async () => 1 } as never,
+    {
+      sideFlagsForYards: async () => new Map(),
+      upsertSideFlags: async () => undefined,
+    } as never,
   );
 
 describe('duplicate yard labels are rejected', () => {
diff --git a/apps/edr-freight-api/src/modules/rule-engine/services/yards.service.ts b/apps/edr-freight-api/src/modules/rule-engine/services/yards.service.ts
index 7dd29ded1..995a901ab 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/services/yards.service.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/services/yards.service.ts
@@ -8,6 +8,24 @@ import { UpdateYardDto } from '../dto/update-yard.dto';
 import { Yard } from '../entities/yard.entity';
 import { IYardsRepository, YARDS_REPOSITORY } from '../interfaces/yards.repository.interface';
 import { DisplayOrderService } from './display-order.service';
+import { YardFacilitiesService, YardSideFlags } from './yard-facilities.service';
+
+/** Yard rows the config page lists/edits carry the stored per-side facility flags. */
+export type YardWithSideFlags = Yard & YardSideFlags;
+
+const SIDE_FLAG_KEYS = [
+  'hasContainerFacilityOrigin',
+  'hasBulkFacilityOrigin',
+  'hasContainerFacilityDestination',
+  'hasBulkFacilityDestination',
+] as const;
+
+const NO_FLAGS: YardSideFlags = {
+  hasContainerFacilityOrigin: false,
+  hasBulkFacilityOrigin: false,
+  hasContainerFacilityDestination: false,
+  hasBulkFacilityDestination: false,
+};
 
 @Injectable()
 export class YardsService {
@@ -15,18 +33,34 @@ export class YardsService {
     @Inject(YARDS_REPOSITORY)
     private readonly repository: IYardsRepository,
     private readonly displayOrder: DisplayOrderService,
+    private readonly facilities: YardFacilitiesService,
   ) {}
 
   /** List yards — standard paginated envelope with server-side search. */
-  async findAll(query: ListYardsQueryDto): Promise<PaginatedResponse<Yard>> {
-    return this.repository.findPaged(query);
+  async findAll(query: ListYardsQueryDto): Promise<PaginatedResponse<YardWithSideFlags>> {
+    const page = await this.repository.findPaged(query);
+    const flags = await this.facilities.sideFlagsForYards(page.items.map((y) => y.id));
+    return {
+      ...page,
+      items: page.items.map((y) => ({ ...y, ...NO_FLAGS, ...flags.get(y.id) })),
+    };
   }
 
   /** Get a yard by ID. */
-  async findById(id: string): Promise<Yard> {
+  async findById(id: string): Promise<YardWithSideFlags> {
     const entity = await this.repository.findById(id);
     if (!entity) throw new NotFoundException(`Yard ${id} not found`);
-    return entity;
+    const flags = await this.facilities.sideFlagsForYards([id]);
+    return { ...entity, ...NO_FLAGS, ...flags.get(id) };
+  }
+
+  /** The per-side facility flags present in the dto, or null when none were sent. */
+  private pickSideFlags(dto: Partial<CreateYardDto>): Partial<YardSideFlags> | null {
+    const flags: Partial<YardSideFlags> = {};
+    for (const key of SIDE_FLAG_KEYS) {
+      if (dto[key] !== undefined) flags[key] = dto[key];
+    }
+    return Object.keys(flags).length > 0 ? flags : null;
   }
 
   /** Create a yard. */
@@ -43,7 +77,7 @@ export class YardsService {
       insertAfterId: dto.insertAfterId,
     });
 
-    return this.repository.create({
+    const yard = await this.repository.create({
       code,
       label: dto.label,
       country: dto.country,
@@ -51,15 +85,28 @@ export class YardsService {
       hasFacility: dto.hasFacility ?? false,
       displayOrder,
     });
+
+    const flags = this.pickSideFlags(dto);
+    if (flags) await this.facilities.upsertSideFlags(yard.id, flags);
+    return this.findById(yard.id);
   }
 
   /** Update a yard. */
   async update(id: string, dto: UpdateYardDto): Promise<Yard> {
     await this.findById(id);
     if (dto.label !== undefined) await this.assertLabelAvailable(dto.label, id);
-    const updated = await this.repository.update(id, dto);
-    if (!updated) throw new NotFoundException(`Yard ${id} not found`);
-    return updated;
+
+    // Per-side flags live on yard_facilities, not the yards row — split them out.
+    const flags = this.pickSideFlags(dto);
+    const yardDto = { ...dto };
+    for (const key of SIDE_FLAG_KEYS) delete yardDto[key];
+
+    if (Object.keys(yardDto).length > 0) {
+      const updated = await this.repository.update(id, yardDto);
+      if (!updated) throw new NotFoundException(`Yard ${id} not found`);
+    }
+    if (flags) await this.facilities.upsertSideFlags(id, flags);
+    return this.findById(id);
   }
 
   /** No two active yards may share a label (case/whitespace-insensitive). */
diff --git a/apps/edr-freight-api/src/modules/signatures/dto/save-signature.dto.ts b/apps/edr-freight-api/src/modules/signatures/dto/save-signature.dto.ts
index a1f245e23..6d7898b53 100644
--- a/apps/edr-freight-api/src/modules/signatures/dto/save-signature.dto.ts
+++ b/apps/edr-freight-api/src/modules/signatures/dto/save-signature.dto.ts
@@ -7,12 +7,14 @@ export class SaveSignatureDto {
   @MinLength(1)
   signerDisplayName!: string;
 
-  @ApiProperty({
-    description: 'PNG signature image as base64 (with or without data URL prefix)',
+  @ApiPropertyOptional({
+    description:
+      'PNG signature image as base64 (with or without data URL prefix). Omit to keep the existing saved signature (stamp-only update).',
   })
+  @IsOptional()
   @IsString()
   @MinLength(20)
-  signatureImageBase64!: string;
+  signatureImageBase64?: string;
 
   @ApiPropertyOptional({
     description:
diff --git a/apps/edr-freight-api/src/modules/signatures/signatures.service.ts b/apps/edr-freight-api/src/modules/signatures/signatures.service.ts
index 836888dab..d346457a0 100644
--- a/apps/edr-freight-api/src/modules/signatures/signatures.service.ts
+++ b/apps/edr-freight-api/src/modules/signatures/signatures.service.ts
@@ -12,7 +12,8 @@ import { SavedSignatureDto } from './dto/save-signature.dto';
 export interface UpsertSignatureInput {
   userId: string;
   signerDisplayName: string;
-  signatureImageBase64: string;
+  /** Optional; omitted = keep the existing saved signature (stamp-only update). */
+  signatureImageBase64?: string;
   /** Optional company stamp/seal; omitted = keep the existing saved stamp. */
   stampImageBase64?: string;
 }
@@ -46,12 +47,14 @@ export class SignaturesService {
     const previousFileId = existing?.signatureFileId ?? null;
     const previousStampFileId = existing?.stampFileId ?? null;
 
-    const fileRecord = await this.filesService.upload({
-      resourceId: input.userId,
-      resource: 'saved_signatures',
-      code: 'signature',
-      file: this.toUploadFile('signature', input.userId, input.signatureImageBase64),
-    });
+    const fileRecord = input.signatureImageBase64
+      ? await this.filesService.upload({
+          resourceId: input.userId,
+          resource: 'saved_signatures',
+          code: 'signature',
+          file: this.toUploadFile('signature', input.userId, input.signatureImageBase64),
+        })
+      : null;
 
     const stampRecord = input.stampImageBase64
       ? await this.filesService.upload({
@@ -65,13 +68,13 @@ export class SignaturesService {
     const saved = await this.signaturesRepository.upsert({
       userId: input.userId,
       signerDisplayName: input.signerDisplayName,
-      signatureFileId: fileRecord.id,
-      // Omitted stamp keeps whatever was saved before.
+      // Omitted image keeps whatever was saved before.
+      ...(fileRecord ? { signatureFileId: fileRecord.id } : {}),
       ...(stampRecord ? { stampFileId: stampRecord.id } : {}),
     });
 
     const staleIds = [
-      previousFileId !== fileRecord.id ? previousFileId : null,
+      fileRecord && previousFileId !== fileRecord.id ? previousFileId : null,
       stampRecord && previousStampFileId !== stampRecord.id
         ? previousStampFileId
         : null,
diff --git a/apps/edr-freight-api/src/modules/train-schedules/entities/train-schedule.entity.ts b/apps/edr-freight-api/src/modules/train-schedules/entities/train-schedule.entity.ts
index 0581f6000..5730120e9 100644
--- a/apps/edr-freight-api/src/modules/train-schedules/entities/train-schedule.entity.ts
+++ b/apps/edr-freight-api/src/modules/train-schedules/entities/train-schedule.entity.ts
@@ -161,6 +161,15 @@ export class TrainSchedule extends BaseEntity {
   @Column({ name: 'rule_payment_window_minutes', type: 'int', nullable: true })
   rulePaymentWindowMinutes?: number | null;
 
+  /**
+   * Staff configured this schedule's booking window by hand (at creation or via
+   * the per-schedule override) instead of inheriting the live global rules.
+   * `restampPendingWindows` skips these, so a later global-rules edit cannot
+   * silently overwrite the hand-picked settings.
+   */
+  @Column({ name: 'window_rule_custom', type: 'boolean', default: false })
+  windowRuleCustom!: boolean;
+
   @Column({ name: 'rule_import_window_lead_days', type: 'int', nullable: true })
   ruleImportWindowLeadDays?: number | null;
 
diff --git a/apps/edr-freight-api/src/modules/train-scheduling/booking-batch.service.ts b/apps/edr-freight-api/src/modules/train-scheduling/booking-batch.service.ts
index 77a3f8e55..966e051d3 100644
--- a/apps/edr-freight-api/src/modules/train-scheduling/booking-batch.service.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/booking-batch.service.ts
@@ -73,6 +73,7 @@ import {
   bookingCargoTons,
   bulkItemsFitFor,
   bulkItemWagonsRequired,
+  bulkTonsPerWagon,
   bookingGrossWeightTons,
   deriveTrainCapacityFromLocomotive,
   sizePartialOfferWagons,
@@ -152,6 +153,14 @@ export interface ExportTrainOption {
   }>;
 }
 
+/** A train a paid-unallocated booking can board (route + capacity verified). */
+export interface AllocationCandidate {
+  id: string;
+  reference: string | null;
+  direction: string | null;
+  scheduledDepartureDate: Date;
+}
+
 /** A day-level pool key: all trains on this route departing on this EAT day. */
 interface RouteDayGroup {
   originYardId: string;
@@ -1448,6 +1457,7 @@ export class BookingBatchService implements OnModuleInit {
    */
   async getBatchBoard(
     query: BatchBoardQueryDto = {},
+    allowedDirections?: string[],
   ): Promise<BatchBoardListResponse> {
     // Board cards are heavy (per-schedule booking summaries), so the default
     // page is smaller than the toolkit-wide 20.
@@ -1455,6 +1465,11 @@ export class BookingBatchService implements OnModuleInit {
       defaultPageSize: 12,
     });
 
+    // The board is IMPORT-only — a user scoped away from IMPORT sees nothing.
+    if (allowedDirections && !allowedDirections.includes("IMPORT")) {
+      return { items: [], meta: buildPaginationMeta(0, page, pageSize) };
+    }
+
     // Status filter: any subset of the lifecycle. Omitted = all statuses, so
     // arrived / cancelled / dispatched schedules stay visible as history.
     const allowedStatuses = new Set<string>(BATCH_BOARD_STATUSES);
@@ -3027,6 +3042,7 @@ export class BookingBatchService implements OnModuleInit {
           : booking.status;
       await manager.getRepository(Booking).update(bookingId, {
         trainScheduleId: newScheduleId,
+        scheduledDate: schedule.scheduledDepartureDate,
         status: restoredStatus,
         // A paid booking still hunting for a wagon keeps its flag through the
         // move — it only clears when wagons are actually assigned.
@@ -3045,6 +3061,104 @@ export class BookingBatchService implements OnModuleInit {
     this.notifyBoardChanged(newScheduleId, "booking_moved");
   }
 
+  /**
+   * Trains a paid-but-unallocated booking can board right now: OPEN window,
+   * future departure, route covers the booking's leg, and remaining corridor
+   * capacity fits it. Split by the booking's own scheduled day so the UI can
+   * offer one-click same-day allocation vs an explicit "another date" choice.
+   */
+  async allocationCandidates(bookingId: string): Promise<{
+    sameDay: AllocationCandidate[];
+    otherDays: AllocationCandidate[];
+  }> {
+    const booking = await this.dataSource.getRepository(Booking).findOne({
+      where: { id: bookingId },
+      relations: {
+        bookingContainers: { containerType: true },
+        // wagonTypes drives the break-bulk items-per-wagon fit — size the
+        // booking exactly as the intercity accept check does.
+        cargoType: { wagonTypes: true },
+      },
+    });
+    if (!booking) throw new NotFoundException(`Booking ${bookingId} not found`);
+    const schedules = await this.trainSchedulesRepository.findAll({
+      where: [
+        { status: TrainScheduleStatusEnum.Draft },
+        { status: TrainScheduleStatusEnum.Scheduled },
+      ],
+    });
+    const today = eatDay(new Date());
+    const bookingDay = booking.scheduledDate ? eatDay(booking.scheduledDate) : null;
+    const sameDay: AllocationCandidate[] = [];
+    const otherDays: AllocationCandidate[] = [];
+    for (const s of schedules) {
+      if (!s.scheduledDepartureDate || eatDay(s.scheduledDepartureDate) < today) continue;
+      if (s.bookingWindowStatus !== "OPEN") continue;
+      if (s.id === booking.trainScheduleId) continue;
+      const stops = await this.stopsForSchedule(s);
+      const fromIdx = stops.indexOf(booking.originYardId);
+      const toIdx = stops.indexOf(booking.destinationYardId);
+      if (fromIdx < 0 || toIdx < 0 || fromIdx >= toIdx) continue;
+      // ponytail: full capacity build per candidate is heavy; the set is small
+      // (future OPEN trains on the booking's route) — precompute if it grows.
+      const cap = await this.intercityCapacity(s.id);
+      if (!cap) continue;
+      const leg = cap.budget.legForYards(booking.originYardId, booking.destinationYardId);
+      if (!cap.budget.fits(cap.needFor(booking), leg)) continue;
+      const candidate: AllocationCandidate = {
+        id: s.id,
+        reference: s.reference ?? s.trainNumber ?? null,
+        direction: s.direction ?? null,
+        scheduledDepartureDate: s.scheduledDepartureDate,
+      };
+      (eatDay(s.scheduledDepartureDate) === bookingDay ? sameDay : otherDays).push(candidate);
+    }
+    const byDate = (a: AllocationCandidate, b: AllocationCandidate) =>
+      new Date(a.scheduledDepartureDate).getTime() - new Date(b.scheduledDepartureDate).getTime();
+    sameDay.sort(byDate);
+    otherDays.sort(byDate);
+    return { sameDay, otherDays };
+  }
+
+  /**
+   * Place a PAID booking that lost (or never got) its train: re-point via
+   * moveToSchedule (window/route validation + day sync), then allocate it
+   * immediately — payment already landed, so no new pay window opens. The
+   * customer gets an in-app notice when the new train departs on a different
+   * day than their original choice.
+   */
+  async allocatePaid(bookingId: string, scheduleId: string): Promise<void> {
+    const before = await this.dataSource
+      .getRepository(Booking)
+      .findOne({ where: { id: bookingId } });
+    if (!before) throw new NotFoundException(`Booking ${bookingId} not found`);
+    if (before.paymentStatus !== "PAID" && before.status !== "PAID") {
+      throw new BadRequestException(
+        "Booking is not paid — use the regular scheduling flow",
+      );
+    }
+    const previousDay = before.scheduledDate ? eatDay(before.scheduledDate) : null;
+    await this.moveToSchedule(bookingId, scheduleId);
+    const fresh = await this.dataSource.getRepository(Booking).findOne({
+      where: { id: bookingId },
+      relations: { bookingContainers: { containerType: true }, cargoType: true },
+    });
+    if (!fresh) return;
+    if (!(await this.holdIfWagonShort(scheduleId, fresh))) {
+      await this.allocate(scheduleId, fresh, "paid");
+    }
+    const schedule = await this.dataSource
+      .getRepository(TrainSchedule)
+      .findOne({ where: { id: scheduleId } });
+    if (
+      previousDay &&
+      schedule?.scheduledDepartureDate &&
+      eatDay(schedule.scheduledDepartureDate) !== previousDay
+    ) {
+      this.notifier.allocatedOtherDay(fresh, schedule.scheduledDepartureDate);
+    }
+  }
+
   /**
    * One reminder per hold, shortly before its pay deadline (the window tick
    * calls this every pass; `payment_reminder_sent_at` dedups). Skips paid
@@ -3531,6 +3645,16 @@ export class BookingBatchService implements OnModuleInit {
         }
         return;
       }
+      // Paid but detached from any train (staff removed it from an allocation,
+      // or a sweep caught it unpinned): money was taken, so it must board — it
+      // stays paid-unallocated for staff to place via the allocate action.
+      if (paid) {
+        this.logger.log(
+          `[BATCH] expire skipped for ${booking.reference} — payment landed ` +
+            `but no train attached; left paid-unallocated for manual placement`,
+        );
+        return;
+      }
       // Reconcile-before-expire (only when a pay window was actually open):
       // no webhook arrived, so ask the gateway DIRECTLY whether the money
       // landed. A late capture found there is registered as SUCCEEDED and
@@ -3859,12 +3983,26 @@ export class BookingBatchService implements OnModuleInit {
       // booking can use — don't kill it for nothing.
       const overlaps = victimLeg.fromEdge < leg.toEdge && leg.fromEdge < victimLeg.toEdge;
       if (!overlaps) continue;
+      const victimPaid =
+        victim.paymentStatus === "PAID" || victim.status === "PAID";
       await this.dataSource.transaction(async (manager) => {
         await this.trainScheduleBookingsRepository.deleteByScheduleAndBooking(
           scheduleId,
           victim.id,
           manager,
         );
+        if (victimPaid) {
+          // Paid bookings are never expired — money was taken, so it boards.
+          // Detach it so it surfaces in the paid-unallocated queue for staff
+          // to re-place; the settled invoice stays untouched.
+          await manager.getRepository(Booking).update(victim.id, {
+            trainScheduleId: null,
+            schedulingStatus: "ELIGIBLE",
+            paymentDeadline: null,
+            selectedForBatchAt: null,
+          } as never);
+          return;
+        }
         await manager.getRepository(Booking).update(victim.id, {
           status: "EXPIRED",
           schedulingStatus: "ELIGIBLE",
@@ -4106,8 +4244,15 @@ export class BookingBatchService implements OnModuleInit {
 
     const capacityTons = this.dimsFor(booking, wagonDims).capacityTons;
     const cargoTons = bookingCargoTons(booking);
+    // PER_TON cargo may cap tons per wagon below the rating (sugar 50T on a 70T
+    // wagon), so divide by the cap where one is configured for this type.
+    const tonsPerWagon = bulkTonsPerWagon(
+      booking.cargoType,
+      booking.cargoType?.wagonTypes?.[0]?.id,
+      capacityTons,
+    );
     const byWeight =
-      cargoTons > 0 && capacityTons > 0 ? Math.ceil(cargoTons / capacityTons) : 0;
+      cargoTons > 0 && tonsPerWagon > 0 ? Math.ceil(cargoTons / tonsPerWagon) : 0;
 
     // Break-bulk (PER_ITEM): indivisible items can need more wagons than raw
     // tonnage suggests (floor items-per-wagon loses the fractional capacity).
@@ -4175,6 +4320,13 @@ export class BookingBatchService implements OnModuleInit {
       .filter((o) => o.wagonTypeId && (stockByTypeId.get(o.wagonTypeId) ?? 0) > 0)
       .map((o) => {
         const wagonTypeId = o.wagonTypeId as string;
+        // Each type sized on its OWN per-wagon tonnage cap, not just its rating
+        // — a type capped lower swallows less per wagon.
+        const tonsPerWagon = bulkTonsPerWagon(
+          booking.cargoType,
+          wagonTypeId,
+          o.dims.capacityTons,
+        );
         const wagonsIfAlone = Math.max(
           1,
           bulkItemWagonsRequired(
@@ -4182,8 +4334,8 @@ export class BookingBatchService implements OnModuleInit {
             o.dims.capacityTons,
             bulkItemsFitFor(booking.cargoType, wagonTypeId),
           ) ||
-            (o.dims.capacityTons > 0
-              ? Math.ceil(bookingCargoTons(booking) / o.dims.capacityTons)
+            (tonsPerWagon > 0
+              ? Math.ceil(bookingCargoTons(booking) / tonsPerWagon)
               : total),
         );
         return {
diff --git a/apps/edr-freight-api/src/modules/train-scheduling/booking-journey.service.spec.ts b/apps/edr-freight-api/src/modules/train-scheduling/booking-journey.service.spec.ts
new file mode 100644
index 000000000..0a8cc99fe
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/train-scheduling/booking-journey.service.spec.ts
@@ -0,0 +1,145 @@
+import { BookingJourneyService } from './booking-journey.service';
+
+/**
+ * autoPlaceOnFreedWagons: intercity cargo boards the wagons freed by earlier
+ * unloads. Exercised directly with a stubbed EntityManager — the surrounding
+ * loadBooking flow is integration-tested through the running app.
+ */
+describe('BookingJourneyService.autoPlaceOnFreedWagons', () => {
+  const service = new BookingJourneyService(
+    {} as never, // dataSource
+    {} as never, // yardFacilities
+    {} as never, // facilityHandling
+    { emit: jest.fn() } as never, // events
+  );
+
+  const schedule = { id: 'sched-1', trainSetId: 'ts-1' };
+  const booking = {
+    id: 'booking-1',
+    reference: 'BK-1',
+    cargoTotalWeightVgm: 50,
+    freightType: 'CONTAINER',
+  };
+
+  const makeManager = (slots: unknown[], existingAllocs: unknown[] = []) => {
+    const savedAllocs: Array<Record<string, unknown>> = [];
+    const savedItems: Array<Record<string, unknown>> = [];
+    const allocQb = {
+      innerJoinAndSelect: jest.fn().mockReturnThis(),
+      innerJoin: jest.fn().mockReturnThis(),
+      where: jest.fn().mockReturnThis(),
+      getMany: jest.fn().mockResolvedValue(existingAllocs),
+    };
+    const slotQb = {
+      leftJoinAndSelect: jest.fn().mockReturnThis(),
+      innerJoin: jest.fn().mockReturnThis(),
+      where: jest.fn().mockReturnThis(),
+      orderBy: jest.fn().mockReturnThis(),
+      getMany: jest.fn().mockResolvedValue(slots),
+    };
+    let allocId = 0;
+    const manager = {
+      getRepository: jest.fn((entity: { name?: string }) => {
+        const name = entity?.name;
+        if (name === 'WagonBookingAllocation') {
+          return {
+            createQueryBuilder: jest.fn(() => allocQb),
+            create: jest.fn((v: Record<string, unknown>) => v),
+            save: jest.fn(async (v: Record<string, unknown>) => {
+              const row = { ...v, id: `alloc-${++allocId}` };
+              savedAllocs.push(row);
+              return row;
+            }),
+            update: jest.fn(),
+          };
+        }
+        if (name === 'TrainSetWagon') {
+          return { createQueryBuilder: jest.fn(() => slotQb) };
+        }
+        if (name === 'BookingContainer') {
+          return {
+            find: jest.fn().mockResolvedValue([
+              {
+                id: 'line-1',
+                containerNumber: 'LINE-001',
+                containerTypeId: 'ct-20',
+                units: [{ containerNumber: 'UNIT-001' }, { containerNumber: 'UNIT-002' }],
+              },
+            ]),
+          };
+        }
+        if (name === 'WagonAllocationContainerItem') {
+          return {
+            create: jest.fn((v: Record<string, unknown>) => v),
+            save: jest.fn(async (v: Record<string, unknown>) => {
+              savedItems.push(v);
+              return v;
+            }),
+          };
+        }
+        throw new Error(`Unexpected repository ${name}`);
+      }),
+    };
+    return { manager, savedAllocs, savedItems };
+  };
+
+  const call = (manager: unknown) =>
+    (service as never as {
+      autoPlaceOnFreedWagons: (m: unknown, s: unknown, b: unknown) => Promise<void>;
+    }).autoPlaceOnFreedWagons(manager, schedule, booking);
+
+  it('places the booking on freed slots in consist order, with container items', async () => {
+    const slots = [
+      // Active cargo still riding — NOT freed.
+      { id: 'slot-1', sequenceNo: 1, capacityTons: 60, allocations: [{ status: 'LOADED' }] },
+      // Freed by an earlier unload.
+      { id: 'slot-2', sequenceNo: 2, capacityTons: 60, allocations: [{ status: 'DEPARTED' }] },
+      { id: 'slot-3', sequenceNo: 3, capacityTons: 60, allocations: [] },
+    ];
+    const { manager, savedAllocs, savedItems } = makeManager(slots);
+
+    await call(manager);
+
+    // 50 t fits on the first freed slot alone.
+    expect(savedAllocs).toHaveLength(1);
+    expect(savedAllocs[0]).toMatchObject({
+      trainSetWagonId: 'slot-2',
+      bookingId: 'booking-1',
+      allocatedWeightTons: 50,
+      status: 'LOADED',
+    });
+    // One item per physical unit, on the first allocation.
+    expect(savedItems.map((i) => i.containerNumber)).toEqual(['UNIT-001', 'UNIT-002']);
+    expect(savedItems.every((i) => i.wagonBookingAllocationId === 'alloc-1')).toBe(true);
+  });
+
+  it('spills over onto the next freed slot when one is not enough', async () => {
+    const slots = [
+      { id: 'slot-2', sequenceNo: 2, capacityTons: 30, allocations: [{ status: 'DEPARTED' }] },
+      { id: 'slot-3', sequenceNo: 3, capacityTons: 30, allocations: [] },
+    ];
+    const { manager, savedAllocs } = makeManager(slots);
+
+    await call(manager);
+
+    expect(savedAllocs.map((a) => [a.trainSetWagonId, a.allocatedWeightTons])).toEqual([
+      ['slot-2', 30],
+      ['slot-3', 20],
+    ]);
+  });
+
+  it('does nothing when the booking already has allocations', async () => {
+    const { manager, savedAllocs } = makeManager([], [{ id: 'existing' }]);
+    await call(manager);
+    expect(savedAllocs).toHaveLength(0);
+  });
+
+  it('loads without allocation when no wagon is free', async () => {
+    const slots = [
+      { id: 'slot-1', sequenceNo: 1, capacityTons: 60, allocations: [{ status: 'LOADED' }] },
+    ];
+    const { manager, savedAllocs } = makeManager(slots);
+    await expect(call(manager)).resolves.toBeUndefined();
+    expect(savedAllocs).toHaveLength(0);
+  });
+});
diff --git a/apps/edr-freight-api/src/modules/train-scheduling/booking-journey.service.ts b/apps/edr-freight-api/src/modules/train-scheduling/booking-journey.service.ts
index 87e756ba6..8668b4f75 100644
--- a/apps/edr-freight-api/src/modules/train-scheduling/booking-journey.service.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/booking-journey.service.ts
@@ -13,6 +13,8 @@ import { Freight } from '@edr/types';
 import { YardFacilitiesService } from '../rule-engine/services/yard-facilities.service';
 import { FacilityHandlingService } from './facility-handling.service';
 import { Booking } from '../bookings/entities/booking.entity';
+import { BookingContainer } from '../bookings/entities/booking-container.entity';
+import { WagonAllocationContainerItem } from '../train-schedules/entities/wagon-allocation-container-item.entity';
 import { ClearanceMilestoneService } from '../contracts/clearance-milestone.service';
 import { Yard } from '../rule-engine/entities/yard.entity';
 import { TrainSetWagon } from '../train-sets/entities/train-set-wagon.entity';
@@ -82,6 +84,11 @@ export class BookingJourneyService {
         loadedAt: now,
         loadedByUserId: userId ?? null,
       } as never);
+      // Intercity cargo rides the wagons freed by earlier unloads along the
+      // corridor — place it before the status flip so it boards with a wagon.
+      if (booking.tradeDirection === 'DOMESTIC') {
+        await this.autoPlaceOnFreedWagons(manager, schedule, booking);
+      }
       await this.setAllocationStatuses(manager, scheduleId, bookingId, 'LOADED');
       // Keep the schedule↔booking link's tracking flag in sync — the dispatch
       // readiness warnings and workspace badges read loading_status, not loadedAt.
@@ -327,19 +334,48 @@ export class BookingJourneyService {
         RETURNING b.id, b.trade_direction`,
       [schedule.id, schedule.destinationStationId, now],
     );
+    if (rows.length === 0) return [];
+
+    // The facility took the cargo off the train at the final yard — raise its
+    // GRN, same as the per-booking unloadBooking() path does. Only when that
+    // yard also has a warehouse (or has no facility at all, e.g. Kality) does
+    // WarehouseInventoryService additionally get to allocate a warehouse/yard/
+    // zone row: a pure facility yard (Dire Dawa, Modjo, Sebeta, Adama) is
+    // fully represented by the facility event alone — there is nothing there
+    // for warehouse_inventory's NOT NULL warehouse/yard/zone to point at.
+    const facility = await this.yardFacilities.facilityForYard(schedule.destinationStationId);
+    const bookings = await manager
+      .getRepository(Booking)
+      .find({ where: { id: In(rows.map((r) => r.id)) }, relations: ['company'] });
+    const bookingById = new Map(bookings.map((b) => [b.id, b]));
+
     for (const row of rows) {
       // Intercity rows just completed — let a ONE_TIME contract close on delivery.
       if (row.trade_direction === 'DOMESTIC') {
         this.events.emit('booking.completed', { bookingId: row.id });
       }
+
+      const booking = bookingById.get(row.id);
+      if (booking) {
+        await this.facilityHandling.recordHandling(manager, {
+          booking,
+          yardId: schedule.destinationStationId,
+          trainScheduleId: schedule.id,
+          eventType: 'UNLOAD',
+          occurredAt: now,
+        });
+      }
+
       // Same event the per-booking unloadBooking() path emits — WarehouseInventoryService
       // listens for this to auto-create the warehouse_inventory row (import/intercity only,
       // it filters EXPORT itself). The bulk SQL update above skipped this entirely, so
       // bookings caught by this fallback never left "awaiting unload".
-      this.events.emit('booking.unloadedAtYard', {
-        bookingId: row.id,
-        tradeDirection: row.trade_direction,
-      });
+      if (row.trade_direction !== 'EXPORT' && (!facility?.hasFacility || facility.hasWarehouse)) {
+        this.events.emit('booking.unloadedAtYard', {
+          bookingId: row.id,
+          tradeDirection: row.trade_direction,
+        });
+      }
     }
     return rows.map((r) => r.id);
   }
@@ -435,6 +471,100 @@ export class BookingJourneyService {
     }
   }
 
+  /**
+   * INTERCITY ONLY. Intercity cargo does not get its own wagons — it rides the
+   * slots freed by cargo already unloaded along the corridor (e.g. import
+   * containers uncoupled at Dire Dawa). Staff pinning is a pre-dispatch tool,
+   * so a DOMESTIC booking loaded mid-corridor is auto-placed here: greedy over
+   * on-train slots (not DEPARTED) with no active cargo (every allocation
+   * DEPARTED, or none), in consist order, by capacity. Container numbers are
+   * copied onto the first allocation so the marshalling document and its
+   * 40ft/20ft tally stay truthful. When nothing is free the load proceeds
+   * unallocated — the marshalling document then lists the booking as on board
+   * without a recorded wagon.
+   * ponytail: remainder over free capacity is dumped on the last used slot
+   * (paper overload beats missing cargo); upgrade path is a capacity guard in
+   * the intercity accept step.
+   */
+  private async autoPlaceOnFreedWagons(
+    manager: EntityManager,
+    schedule: TrainSchedule,
+    booking: Booking,
+  ): Promise<void> {
+    const existing = await this.allocationsForBooking(manager, schedule.id, booking.id);
+    if (existing.length) return;
+
+    const slots = await manager
+      .getRepository(TrainSetWagon)
+      .createQueryBuilder('slot')
+      .leftJoinAndSelect('slot.allocations', 'alloc')
+      .innerJoin(
+        TrainSchedule,
+        'schedule',
+        'schedule.train_set_id = slot.train_set_id AND schedule.id = :scheduleId',
+        { scheduleId: schedule.id },
+      )
+      .where(`slot.status != 'DEPARTED'`)
+      .orderBy('slot.sequence_no', 'ASC')
+      .getMany();
+    const freed = slots.filter((slot) =>
+      (slot.allocations ?? []).every((a) => a.status === 'DEPARTED'),
+    );
+    if (!freed.length) {
+      this.logger.warn(
+        `No freed wagon for intercity booking ${booking.reference} on schedule ${schedule.id} — loading without wagon allocation`,
+      );
+      return;
+    }
+
+    let remaining = Number(booking.cargoTotalWeightVgm) || 0;
+    const allocRepo = manager.getRepository(WagonBookingAllocation);
+    const created: WagonBookingAllocation[] = [];
+    for (const slot of freed) {
+      const capacity = Number(slot.capacityTons) || remaining || 1;
+      const take = Math.min(remaining || capacity, capacity);
+      created.push(
+        await allocRepo.save(
+          allocRepo.create({
+            trainSetWagonId: slot.id,
+            bookingId: booking.id,
+            allocatedWeightTons: take,
+            loadType: booking.freightType ?? null,
+            status: 'LOADED',
+          }),
+        ),
+      );
+      remaining = Math.max(0, remaining - take);
+      if (remaining <= 0) break;
+    }
+    if (remaining > 0 && created.length) {
+      await allocRepo.update(created[created.length - 1].id, {
+        allocatedWeightTons: () => `allocated_weight_tons + ${remaining}`,
+      } as never);
+    }
+
+    // Container numbers onto the first allocation, from the booking's container
+    // lines (per physical unit when recorded, else per line).
+    const lines = await manager
+      .getRepository(BookingContainer)
+      .find({ where: { bookingId: booking.id }, relations: { units: true } });
+    const itemRepo = manager.getRepository(WagonAllocationContainerItem);
+    const first = created[0];
+    for (const line of lines) {
+      const units = line.units?.length ? line.units : [null];
+      for (const unit of units) {
+        await itemRepo.save(
+          itemRepo.create({
+            wagonBookingAllocationId: first.id,
+            bookingContainerId: line.id,
+            containerNumber: unit?.containerNumber ?? line.containerNumber ?? null,
+            containerTypeId: line.containerTypeId ?? null,
+          }),
+        );
+      }
+    }
+  }
+
   private async setAllocationStatuses(
     manager: EntityManager,
     scheduleId: string,
diff --git a/apps/edr-freight-api/src/modules/train-scheduling/booking-notifier.service.ts b/apps/edr-freight-api/src/modules/train-scheduling/booking-notifier.service.ts
index b806de5ca..84d029e4f 100644
--- a/apps/edr-freight-api/src/modules/train-scheduling/booking-notifier.service.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/booking-notifier.service.ts
@@ -275,6 +275,19 @@ export class BookingNotifierService {
     this.inApp(b, 'Booking rescheduled', msg);
   }
 
+  /**
+   * Staff placed a paid booking onto a train departing on a DIFFERENT day than
+   * the customer's original choice. In-app only — staff drove the change and
+   * the allocation itself already notifies through the secured path.
+   */
+  allocatedOtherDay(b: Booking, newDeparture: Date): void {
+    const when = newDeparture.toLocaleDateString('en-GB', { timeZone: BATCH_TIMEZONE });
+    const msg =
+      `Booking ${b.reference ?? b.id} has been allocated to a train on a different date. ` +
+      `New departure date: ${when}.`;
+    this.inApp(b, 'Booking allocated to another date', msg);
+  }
+
   /**
    * Booking was removed from its train during a staff reschedule (not a government
    * pre-empt). It returns to eligible — the customer must rebook or reschedule.
diff --git a/apps/edr-freight-api/src/modules/train-scheduling/dto/create-container-train-schedule.dto.ts b/apps/edr-freight-api/src/modules/train-scheduling/dto/create-container-train-schedule.dto.ts
index 9dfea0781..e8716eb99 100644
--- a/apps/edr-freight-api/src/modules/train-scheduling/dto/create-container-train-schedule.dto.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/dto/create-container-train-schedule.dto.ts
@@ -9,9 +9,107 @@ import {
   IsNumber,
   IsOptional,
   IsUUID,
+  Max,
   Min,
+  ValidateNested,
 } from 'class-validator';
 
+/**
+ * Per-schedule booking-window rule chosen AT CREATION, instead of inheriting the
+ * live global rules. Mirrors {@link UpdateScheduleWindowRuleDto}, plus the
+ * booking-close offset (which the post-creation override deliberately never
+ * touches). Every field is optional — an omitted field falls back to the global
+ * value, so staff can override just the one knob they care about.
+ */
+export class CreateScheduleWindowRuleDto {
+  @ApiPropertyOptional({ example: 8, description: 'Local EAT hour the booking desk opens each day' })
+  @IsOptional()
+  @Type(() => Number)
+  @IsInt()
+  @Min(0)
+  @Max(23)
+  windowOpenHour?: number;
+
+  @ApiPropertyOptional({
+    example: 17,
+    description:
+      'Local EAT hour the booking desk shuts each day. Equal to windowOpenHour = 24-hour desk',
+  })
+  @IsOptional()
+  @Type(() => Number)
+  @IsInt()
+  @Min(0)
+  @Max(23)
+  windowCloseHour?: number;
+
+  @ApiPropertyOptional({ example: 3, description: 'How long each booking cycle stays open, in hours' })
+  @IsOptional()
+  @Type(() => Number)
+  @IsNumber()
+  @Min(0.0166)
+  @Max(12)
+  windowDurationHours?: number;
+
+  @ApiPropertyOptional({ example: 30, description: 'Max staff document-review minutes after the window closes' })
+  @IsOptional()
+  @Type(() => Number)
+  @IsInt()
+  @Min(0)
+  docReviewMinutes?: number;
+
+  @ApiPropertyOptional({ example: 60, description: 'Customer payment window minutes' })
+  @IsOptional()
+  @Type(() => Number)
+  @IsInt()
+  @Min(1)
+  paymentWindowMinutes?: number;
+
+  @ApiPropertyOptional({
+    example: 3,
+    description: 'Days before departure the IMPORT/DOMESTIC booking window starts',
+  })
+  @IsOptional()
+  @Type(() => Number)
+  @IsInt()
+  @Min(0)
+  importWindowLeadDays?: number;
+
+  @ApiPropertyOptional({
+    example: 24,
+    description: 'Hours before departure the single FCFS EXPORT window opens',
+  })
+  @IsOptional()
+  @Type(() => Number)
+  @IsInt()
+  @Min(1)
+  exportBookingLeadHours?: number;
+
+  @ApiPropertyOptional({
+    example: 180,
+    nullable: true,
+    description:
+      'Minutes before departure the booking window closes; 0/null = close at departure. ' +
+      'Only the offset matching the schedule direction is used (import offset for ' +
+      'IMPORT/DOMESTIC, export offset for EXPORT).',
+  })
+  @IsOptional()
+  @Type(() => Number)
+  @IsInt()
+  @Min(0)
+  importCloseOffsetMinutes?: number | null;
+
+  @ApiPropertyOptional({
+    example: 1440,
+    nullable: true,
+    description: 'Minutes before departure an EXPORT booking window closes; 0/null = at departure',
+  })
+  @IsOptional()
+  @Type(() => Number)
+  @IsInt()
+  @Min(0)
+  exportCloseOffsetMinutes?: number | null;
+}
+
 export class CreateContainerTrainScheduleDto {
   @ApiProperty({ format: 'uuid' })
   @IsUUID()
@@ -73,4 +171,19 @@ export class CreateContainerTrainScheduleDto {
   @IsOptional()
   @IsBoolean()
   reverseWagonOrder?: boolean;
+
+  @ApiPropertyOptional({
+    type: CreateScheduleWindowRuleDto,
+    description:
+      'Configure the booking window for THIS schedule instead of inheriting the live ' +
+      'global rules. Omit to use the global rules (the default). The values sent are ' +
+      'frozen onto the schedule as its rule snapshot, exactly as a post-creation ' +
+      'override would. Rejected for an IMPORT/DOMESTIC train that joins an existing ' +
+      'route+day group — those siblings share one window timeline, so edit the group ' +
+      "window instead of giving one member its own.",
+  })
+  @IsOptional()
+  @ValidateNested()
+  @Type(() => CreateScheduleWindowRuleDto)
+  windowRule?: CreateScheduleWindowRuleDto;
 }
diff --git a/apps/edr-freight-api/src/modules/train-scheduling/fleet-plan.util.ts b/apps/edr-freight-api/src/modules/train-scheduling/fleet-plan.util.ts
index bea01af0a..2769c212b 100644
--- a/apps/edr-freight-api/src/modules/train-scheduling/fleet-plan.util.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/fleet-plan.util.ts
@@ -1,4 +1,4 @@
-import { bookingCargoTons, bulkItemWagonsForAllowedTypes } from './train-capacity.util';
+import { bookingCargoTons, bulkWagonsForAllowedTypes } from './train-capacity.util';
 import type { Booking } from '../bookings/entities/booking.entity';
 import type { WagonType } from '../wagon-types/entities/wagon-type.entity';
 import {
@@ -56,8 +56,10 @@ export function wagonsRequiredForBooking(booking: Booking, bulkWagonCapacity?: n
     // holds the item count there, not tons. No wagon type is fixed yet, so use
     // the best count across the cargo's allowed types (per-type items-fit
     // respected); falls back to `capacity` when the relation isn't loaded.
-    const byItems = bulkItemWagonsForAllowedTypes(booking, booking.cargoType, capacity);
-    if (byItems > 0) return byItems;
+    // PER_TON cargo may cap tons per wagon below the rating (sugar 50T on a 70T
+    // wagon), so tonnage divides by that cap, not by raw capacity.
+    const byWagons = bulkWagonsForAllowedTypes(booking, booking.cargoType, capacity);
+    if (byWagons > 0) return byWagons;
     const weight = Number(booking.cargoTotalWeightVgm ?? 0);
     return Math.max(1, Math.ceil(weight / capacity));
   }
diff --git a/apps/edr-freight-api/src/modules/train-scheduling/train-capacity.util.spec.ts b/apps/edr-freight-api/src/modules/train-scheduling/train-capacity.util.spec.ts
index ead3a4e8b..ed476a6e1 100644
--- a/apps/edr-freight-api/src/modules/train-scheduling/train-capacity.util.spec.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/train-capacity.util.spec.ts
@@ -4,6 +4,10 @@ import {
   bookingTrainLengthMeters,
   bulkItemWagonsForAllowedTypes,
   bulkItemWagonsRequired,
+  bulkTonsPerWagon,
+  bulkTonWagonsForAllowedTypes,
+  bulkTonWagonsRequired,
+  bulkWagonsForAllowedTypes,
   consistUsage,
   consistViolations,
   deriveTrainCapacityFromLocomotive,
@@ -135,6 +139,61 @@ describe('train-capacity.util', () => {
     });
   });
 
+  describe('bulkTonsPerWagon / bulkTonWagonsRequired (PER_TON loading cap)', () => {
+    // Sugar is loaded 50T per wagon even on a 70T wagon.
+    const sugar = { wagonTypes: [{ id: 'nw5', capacityTons: 70 }], tonsPerWagonMap: { nw5: 50 } };
+    const bulk = (tons: number) => ({ freightType: 'BULK', cargoTotalWeightVgm: tons });
+
+    it('uses the configured cap instead of the rated capacity', () => {
+      expect(bulkTonsPerWagon(sugar, 'nw5', 70)).toBe(50);
+    });
+
+    it('falls back to rated capacity when the cargo type caps nothing', () => {
+      expect(bulkTonsPerWagon(null, 'nw5', 70)).toBe(70);
+      expect(bulkTonsPerWagon({ wagonTypes: [] }, 'nw5', 70)).toBe(70);
+      expect(bulkTonsPerWagon({ tonsPerWagonMap: { other: 50 } }, 'nw5', 70)).toBe(70);
+    });
+
+    it('clamps a stale cap that now exceeds the rating (wagon type edited down)', () => {
+      // Saved when NW5 was rated 70T; the type was later re-rated to 45T.
+      expect(bulkTonsPerWagon(sugar, 'nw5', 45)).toBe(45);
+    });
+
+    it('sizes 200T of capped sugar at 4 wagons, not the 3 raw capacity implies', () => {
+      expect(bulkTonWagonsRequired(bulk(200), sugar, 'nw5', 70)).toBe(4);
+      // Same booking, no cap → the old 3-wagon answer.
+      expect(bulkTonWagonsRequired(bulk(200), null, 'nw5', 70)).toBe(3);
+    });
+
+    it('picks the fewest-wagon allowed type, each on its own cap', () => {
+      const cargoType = {
+        wagonTypes: [
+          { id: 'nw5', capacityTons: 70 },
+          { id: 'nw7', capacityTons: 80 },
+        ],
+        tonsPerWagonMap: { nw5: 50 },
+      };
+      // NW5 capped 50 → 4 wagons; NW7 uncapped 80 → 3 wagons. Best = 3.
+      expect(bulkTonWagonsForAllowedTypes(bulk(200), cargoType, 70)).toBe(3);
+    });
+
+    it('routes PER_ITEM and PER_TON through one call', () => {
+      expect(bulkWagonsForAllowedTypes(bulk(200), sugar, 70)).toBe(4);
+      // PER_ITEM still wins where an item count is present.
+      const cars = {
+        wagonTypes: [{ id: 'nw5', capacityTons: 70 }],
+        itemsPerWagonMap: { nw5: 4 },
+      };
+      expect(
+        bulkWagonsForAllowedTypes(
+          { freightType: 'BULK', cargoTotalWeightVgm: 50, bulkTotalWeightTons: 1000 },
+          cars,
+          70,
+        ),
+      ).toBe(17);
+    });
+  });
+
   describe('bookingCargoTons (break-bulk weight preference)', () => {
     it('prefers bulkTotalWeightTons over the item-count VGM column', () => {
       expect(
diff --git a/apps/edr-freight-api/src/modules/train-scheduling/train-capacity.util.ts b/apps/edr-freight-api/src/modules/train-scheduling/train-capacity.util.ts
index 867da564b..63feb6e8c 100644
--- a/apps/edr-freight-api/src/modules/train-scheduling/train-capacity.util.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/train-capacity.util.ts
@@ -152,8 +152,98 @@ export function bulkItemWagonsRequired(
 type ItemFitCargoType = {
   wagonTypes?: Array<{ id: string; capacityTons?: number | string | null }> | null;
   itemsPerWagonMap?: Record<string, number> | null;
+  tonsPerWagonMap?: Record<string, number> | null;
 } | null;
 
+/**
+ * Tons of THIS cargo one wagon of this type may carry: the cargo type's
+ * configured loading limit when set, else the wagon's full rated capacity.
+ * Sugar capped at 50T rides 50T on a 70T wagon, so 200T needs 4 wagons and each
+ * is loaded to 50 — both the count and the fill follow from this one number.
+ *
+ * The configured cap is CLAMPED to the rated capacity rather than trusted: the
+ * cargo-types service rejects a cap above capacity at save time, but a wagon
+ * type edited DOWN afterwards would leave a stale cap that overloads the wagon.
+ * Clamping here means no call site can ever load past the physical rating.
+ */
+export function bulkTonsPerWagon(
+  cargoType: ItemFitCargoType | undefined,
+  wagonTypeId: string | null | undefined,
+  capacityTons: number | string | null | undefined,
+): number {
+  const capacity = num(capacityTons);
+  const cap = wagonTypeId ? num(cargoType?.tonsPerWagonMap?.[wagonTypeId]) : 0;
+  if (!(cap > 0)) return capacity;
+  return capacity > 0 ? Math.min(cap, capacity) : cap;
+}
+
+/**
+ * Wagons a PER_TON bulk booking needs on one wagon type, respecting the cargo
+ * type's per-wagon loading limit: 200T of sugar capped at 50T → 4 wagons even
+ * though the wagon is rated 70T. Returns 0 when there is no tonnage or no
+ * usable per-wagon figure, so callers can fall back as before.
+ */
+export function bulkTonWagonsRequired(
+  booking: Parameters<typeof bookingCargoTons>[0],
+  cargoType: ItemFitCargoType | undefined,
+  wagonTypeId: string | null | undefined,
+  capacityTons: number | string | null | undefined,
+): number {
+  const perWagon = bulkTonsPerWagon(cargoType, wagonTypeId, capacityTons);
+  const tons = bookingCargoTons(booking);
+  if (!(perWagon > 0) || !(tons > 0)) return 0;
+  return Math.max(1, Math.ceil(tons / perWagon));
+}
+
+/**
+ * Best (fewest-wagon) PER_TON count across the cargo type's allowed wagon
+ * types, each sized on its OWN loading limit — the tonnage twin of
+ * {@link bulkItemWagonsForAllowedTypes}, for the call sites that have no single
+ * wagon type fixed yet. Falls back to `fallbackCapacityTons` when the cargo
+ * type has no usable allowed types.
+ */
+export function bulkTonWagonsForAllowedTypes(
+  booking: Parameters<typeof bookingCargoTons>[0],
+  cargoType: ItemFitCargoType | undefined,
+  fallbackCapacityTons: number,
+): number {
+  const allowed = (cargoType?.wagonTypes ?? []).filter((wt) => num(wt.capacityTons) > 0);
+  if (!allowed.length) {
+    return bulkTonWagonsRequired(booking, cargoType, null, fallbackCapacityTons);
+  }
+  let best = 0;
+  for (const wagonType of allowed) {
+    const wagons = bulkTonWagonsRequired(
+      booking,
+      cargoType,
+      wagonType.id,
+      wagonType.capacityTons,
+    );
+    if (wagons > 0 && (best === 0 || wagons < best)) best = wagons;
+  }
+  return best;
+}
+
+/**
+ * Wagons a BULK booking needs, whichever way its cargo is measured: PER_ITEM
+ * sizes by indivisible items, everything else by tonnage under the cargo type's
+ * per-wagon loading limit. One call so no site has to remember both paths.
+ */
+export function bulkWagonsForAllowedTypes(
+  booking: Parameters<typeof bookingCargoTons>[0] & {
+    freightType?: string | null;
+    cargoTotalWeightVgm?: number | string | null;
+    bulkTotalWeightTons?: number | string | null;
+  },
+  cargoType: ItemFitCargoType | undefined,
+  fallbackCapacityTons: number,
+): number {
+  return (
+    bulkItemWagonsForAllowedTypes(booking, cargoType, fallbackCapacityTons) ||
+    bulkTonWagonsForAllowedTypes(booking, cargoType, fallbackCapacityTons)
+  );
+}
+
 /** Configured whole-items fit of one wagon type for a cargo type; null if unset. */
 export function bulkItemsFitFor(
   cargoType: ItemFitCargoType | undefined,
diff --git a/apps/edr-freight-api/src/modules/train-scheduling/train-scheduling.controller.ts b/apps/edr-freight-api/src/modules/train-scheduling/train-scheduling.controller.ts
index 7b0f37b66..742bd2837 100644
--- a/apps/edr-freight-api/src/modules/train-scheduling/train-scheduling.controller.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/train-scheduling.controller.ts
@@ -1,6 +1,7 @@
 import { ApiBearerAuth, ApiOperation, ApiTags } from "@nestjs/swagger";
 import type { Response } from "express";
 import type { AuthUserPayload } from "../../common/resolve-auth-user-id";
+import { UserTradeAccessService } from "../user-trade-access/user-trade-access.service";
 import { resolveAuthUserId } from "../../common/resolve-auth-user-id";
 
 import {
@@ -66,6 +67,7 @@ export class TrainSchedulingController {
     private readonly intercityService: IntercityService,
     private readonly bookingJourneyService: BookingJourneyService,
     private readonly billingService: BillingService,
+    private readonly userTradeAccessService: UserTradeAccessService,
   ) { }
 
   @Get("my-booking-windows")
@@ -130,8 +132,14 @@ export class TrainSchedulingController {
     summary:
       "Batch monitoring board: paginated import schedules (all statuses) with bookings grouped by state",
   })
-  getBatchBoard(@Query() query: BatchBoardQueryDto) {
-    return this.bookingBatchService.getBatchBoard(query);
+  async getBatchBoard(
+    @Query() query: BatchBoardQueryDto,
+    @CurrentUser() user: AuthUserPayload,
+  ) {
+    // Batch board is IMPORT-only — a user without IMPORT access sees nothing.
+    const allowed =
+      await this.userTradeAccessService.resolveAllowedDirections(user);
+    return this.bookingBatchService.getBatchBoard(query, allowed ?? undefined);
   }
 
   @Get("batch-board/:scheduleId")
@@ -703,6 +711,20 @@ export class TrainSchedulingController {
     return res.send(buffer);
   }
 
+  @Get("schedules/:id/intercity/marshalling/document")
+  @TrainSchedulingView()
+  @ApiOperation({ summary: "Download current on-board intercity marshalling (Marshalling 2) PDF" })
+  async intercityMarshallingDocument(
+    @Param("id", ParseUUIDPipe) id: string,
+    @Res() res: Response,
+  ) {
+    const { filename, buffer } = await this.trainSchedulingService.intercityMarshallingDocument(id);
+    res.setHeader("Content-Type", "application/pdf");
+    res.setHeader("Content-Disposition", `inline; filename="${filename}"`);
+    res.setHeader("Content-Length", buffer.length);
+    return res.send(buffer);
+  }
+
   // ---- batch / booking-window staff actions ----
 
   @Post("schedules/:id/run-batch")
@@ -834,6 +856,32 @@ export class TrainSchedulingController {
     return { ok: true };
   }
 
+  @Get("bookings/:bookingId/allocation-candidates")
+  @TrainSchedulingView()
+  @ApiOperation({
+    summary:
+      "Trains a paid-unallocated booking fits, split same-day vs other days",
+  })
+  getAllocationCandidates(
+    @Param("bookingId", ParseUUIDPipe) bookingId: string,
+  ) {
+    return this.bookingBatchService.allocationCandidates(bookingId);
+  }
+
+  @Post("bookings/:bookingId/allocate")
+  @TrainSchedulingUpdate()
+  @ApiOperation({
+    summary:
+      "Staff: place a paid booking onto a fitting train (notifies customer on date change)",
+  })
+  async allocatePaidBooking(
+    @Param("bookingId", ParseUUIDPipe) bookingId: string,
+    @Body("trainScheduleId", ParseUUIDPipe) trainScheduleId: string,
+  ) {
+    await this.bookingBatchService.allocatePaid(bookingId, trainScheduleId);
+    return { ok: true };
+  }
+
   @Get("schedules/:id/checkpoints")
   @TrainSchedulingView()
   @ApiOperation({
@@ -868,15 +916,31 @@ export class TrainSchedulingController {
   @Get("container/schedules")
   @TrainSchedulingView()
   @ApiOperation({ summary: "List container train schedules (paginated)" })
-  getContainerTrainSchedules(@Query() query: ListTrainSchedulesQueryDto) {
-    return this.trainSchedulingService.getContainerTrainSchedules(query);
+  async getContainerTrainSchedules(
+    @Query() query: ListTrainSchedulesQueryDto,
+    @CurrentUser() user: AuthUserPayload,
+  ) {
+    const allowed =
+      await this.userTradeAccessService.resolveAllowedDirections(user);
+    return this.trainSchedulingService.getContainerTrainSchedules(
+      query,
+      allowed ?? undefined,
+    );
   }
 
   @Get("bulk/schedules")
   @TrainSchedulingView()
   @ApiOperation({ summary: "List bulk train schedules (paginated)" })
-  getBulkTrainSchedules(@Query() query: ListTrainSchedulesQueryDto) {
-    return this.trainSchedulingService.getContainerTrainSchedules(query);
+  async getBulkTrainSchedules(
+    @Query() query: ListTrainSchedulesQueryDto,
+    @CurrentUser() user: AuthUserPayload,
+  ) {
+    const allowed =
+      await this.userTradeAccessService.resolveAllowedDirections(user);
+    return this.trainSchedulingService.getContainerTrainSchedules(
+      query,
+      allowed ?? undefined,
+    );
   }
 
   @Get("container/schedules/:id")
diff --git a/apps/edr-freight-api/src/modules/train-scheduling/train-scheduling.module.ts b/apps/edr-freight-api/src/modules/train-scheduling/train-scheduling.module.ts
index 35503d432..56f2cff00 100644
--- a/apps/edr-freight-api/src/modules/train-scheduling/train-scheduling.module.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/train-scheduling.module.ts
@@ -3,6 +3,7 @@ import { TypeOrmModule } from '@nestjs/typeorm';
 import { Session } from '@tria-plc/iamapi-common/entities/iam/user/session.entity';
 
 import { BillingModule } from '../billing/billing.module';
+import { UserTradeAccessModule } from '../user-trade-access/user-trade-access.module';
 import { BookingsModule } from '../bookings/bookings.module';
 import { Container } from '../container-management/entities/container.entity';
 import { LocomotivesModule } from '../locomotives/locomotives.module';
@@ -63,6 +64,7 @@ import { ContractsModule } from '../contracts/contracts.module';
     ]),
     forwardRef(() => BookingsModule),
     BillingModule,
+    UserTradeAccessModule,
     NotificationsModule,
     NotificationInboxModule,
     LocomotivesModule,
diff --git a/apps/edr-freight-api/src/modules/train-scheduling/train-scheduling.service.spec.ts b/apps/edr-freight-api/src/modules/train-scheduling/train-scheduling.service.spec.ts
index 406f51988..455dc3d9c 100644
--- a/apps/edr-freight-api/src/modules/train-scheduling/train-scheduling.service.spec.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/train-scheduling.service.spec.ts
@@ -805,6 +805,51 @@ describe('TrainSchedulingService', () => {
     ).rejects.toBeInstanceOf(BadRequestException);
   });
 
+  describe('restampPendingWindows (hand-configured windows are exempt)', () => {
+    const future = new Date(Date.now() + 30 * 24 * 3600_000);
+    const update = jest.fn();
+
+    beforeEach(() => {
+      update.mockClear();
+      // Global rules read + the TrainSchedule repo the restamp writes through.
+      dataSource.getRepository.mockImplementation((entity: unknown) => {
+        const name = (entity as { name?: string })?.name;
+        if (name === 'TrainSchedulingGlobalRules') {
+          return { find: jest.fn().mockResolvedValue([]) };
+        }
+        return { update };
+      });
+    });
+
+    it('re-stamps a schedule that follows the global rules', async () => {
+      trainSchedulesRepository.findAll.mockResolvedValue([
+        {
+          id: 'sched-global',
+          direction: 'IMPORT',
+          scheduledDepartureDate: future,
+          windowRuleCustom: false,
+        },
+      ]);
+      await expect(service.restampPendingWindows()).resolves.toBe(1);
+      expect(update).toHaveBeenCalledWith('sched-global', expect.anything());
+    });
+
+    it('leaves a hand-configured schedule alone', async () => {
+      trainSchedulesRepository.findAll.mockResolvedValue([
+        {
+          id: 'sched-custom',
+          direction: 'IMPORT',
+          scheduledDepartureDate: future,
+          windowRuleCustom: true,
+        },
+      ]);
+      // Staff picked these times deliberately — a global-rules edit must not
+      // overwrite them, or the per-schedule configuration would be pointless.
+      await expect(service.restampPendingWindows()).resolves.toBe(0);
+      expect(update).not.toHaveBeenCalled();
+    });
+  });
+
   describe('getUnassignedBookings', () => {
     const scheduleId = 'sched-unassigned-1';
     const trainSetId = 'train-set-unassigned';
@@ -1121,6 +1166,132 @@ describe('TrainSchedulingService', () => {
       expect(html).not.toContain('empty)');
       expect(html).not.toContain('EMPTY');
     });
+
+    // ---- intercity marshalling (Marshalling 2): the current on-board view ----
+
+    const onBoardView = (schedule: unknown) =>
+      (service as never as {
+        intercityOnBoardView: (s: unknown) => { wagons: unknown[]; unassignedBookings: unknown[] };
+      }).intercityOnBoardView(schedule);
+
+    const buildWithOpts = (schedule: unknown, opts: unknown) =>
+      (service as never as {
+        buildExportLoadListHtml: (s: unknown, o?: unknown) => string;
+      }).buildExportLoadListHtml(schedule, opts);
+
+    const allocWith = (over: Record<string, unknown>) => ({ ...loadedAllocation, ...over });
+
+    it('drops DEPARTED wagon slots and DEPARTED allocations from the on-board view', () => {
+      const schedule = {
+        trainSet: {
+          wagons: [
+            { ...makeWagon(1, 'W-001', [allocWith({ status: 'LOADED' })]), status: 'RESERVED' },
+            { ...makeWagon(2, 'W-002', [allocWith({ status: 'LOADED' })]), status: 'DEPARTED' },
+            {
+              ...makeWagon(3, 'W-003', [
+                allocWith({ status: 'LOADED', bookingId: 'booking-3' }),
+                allocWith({ status: 'DEPARTED', bookingId: 'booking-4' }),
+              ]),
+              status: 'RESERVED',
+            },
+          ],
+        },
+        scheduleBookings: [],
+      };
+
+      const { wagons } = onBoardView(schedule);
+      const numbers = (wagons as Array<{ physicalWagon: { wagonNumber: string } }>).map(
+        (w) => w.physicalWagon.wagonNumber,
+      );
+      expect(numbers).toEqual(['W-001', 'W-003']);
+      const w3 = (wagons as Array<{ physicalWagon: { wagonNumber: string }; allocations: Array<{ bookingId: string }> }>).find(
+        (w) => w.physicalWagon.wagonNumber === 'W-003',
+      );
+      expect(w3?.allocations.map((a) => a.bookingId)).toEqual(['booking-3']);
+    });
+
+    it('keeps an attached wagon whose cargo all departed, as an EMPTY row', () => {
+      const schedule = {
+        id: 'schedule-1',
+        trainNumber: '8302',
+        direction: 'EXPORT',
+        trainSet: {
+          wagons: [
+            { ...makeWagon(1, 'W-001', [allocWith({ status: 'LOADED' })]), status: 'RESERVED' },
+            { ...makeWagon(2, 'W-002', [allocWith({ status: 'DEPARTED' })]), status: 'RESERVED' },
+          ],
+        },
+        scheduleBookings: [],
+      };
+
+      const { wagons, unassignedBookings } = onBoardView(schedule);
+      const html = buildWithOpts(schedule, { wagons, unassignedBookings });
+      expect(html).toContain('W-002');
+      expect(html.match(/EMPTY — no cargo allocated/g)).toHaveLength(1);
+      expect(html).toContain('2 (1 empty)');
+    });
+
+    it('hides a leg slot (boardYardId set) until it has confirmed LOADED cargo', () => {
+      const legWagonEmpty = { ...makeWagon(2, 'W-LEG', [allocWith({ status: 'RESERVED' })]), status: 'RESERVED', boardYardId: 'yard-mid' };
+      const legWagonLoaded = { ...makeWagon(3, 'W-LEG2', [allocWith({ status: 'LOADED' })]), status: 'RESERVED', boardYardId: 'yard-mid' };
+      const schedule = {
+        trainSet: { wagons: [legWagonEmpty, legWagonLoaded] },
+        scheduleBookings: [],
+      };
+
+      const { wagons } = onBoardView(schedule);
+      const numbers = (wagons as Array<{ physicalWagon: { wagonNumber: string } }>).map(
+        (w) => w.physicalWagon.wagonNumber,
+      );
+      expect(numbers).toEqual(['W-LEG2']);
+    });
+
+    it('lists an IN_TRANSIT booking with no wagon allocation in the unassigned section', () => {
+      const rider = {
+        id: 'booking-9',
+        reference: 'BK-2026-000009',
+        status: 'IN_TRANSIT',
+        company: { name: 'Rider Co' },
+        cargoType: { cargoTypeName: 'Cement', code: 'CEM' },
+        originYard: { label: 'Adama' },
+        destinationYard: { label: 'Dire Dawa' },
+        bookingContainers: [{ containerNumber: 'RIDE-001' }],
+      };
+      const done = { id: 'booking-8', reference: 'BK-2026-000008', status: 'COMPLETED' };
+      const schedule = {
+        id: 'schedule-1',
+        trainNumber: '8302',
+        direction: 'EXPORT',
+        trainSet: { wagons: [{ ...makeWagon(1, 'W-001', [allocWith({ status: 'LOADED' })]), status: 'RESERVED' }] },
+        scheduleBookings: [{ bookingId: rider.id, booking: rider }, { bookingId: done.id, booking: done }],
+      };
+
+      const { wagons, unassignedBookings } = onBoardView(schedule);
+      expect((unassignedBookings as Array<{ id: string }>).map((b) => b.id)).toEqual(['booking-9']);
+
+      const html = buildWithOpts(schedule, {
+        title: 'Intercity Marshalling Document / Load List (Marshalling 2)',
+        positionLabel: 'After Dire Dawa',
+        wagons,
+        unassignedBookings,
+      });
+      expect(html).toContain('ON BOARD — WAGON NOT RECORDED');
+      expect(html).toContain('BK-2026-000009');
+      expect(html).toContain('RIDE-001');
+      expect(html).not.toContain('BK-2026-000008');
+      expect(html).toContain('Intercity Marshalling Document / Load List (Marshalling 2)');
+      expect(html).toContain('After Dire Dawa');
+    });
+
+    it('rejects the intercity marshalling document for a train that has not been dispatched', async () => {
+      trainSchedulesRepository.findByIdWithFullGraph.mockResolvedValue({
+        id: 'schedule-1',
+        status: 'SCHEDULED',
+      });
+      await expect(
+        service.intercityMarshallingDocument('schedule-1'),
+      ).rejects.toBeInstanceOf(BadRequestException);
+    });
   });
 
   describe('moveWagonLoad — staff rearrange', () => {
diff --git a/apps/edr-freight-api/src/modules/train-scheduling/train-scheduling.service.ts b/apps/edr-freight-api/src/modules/train-scheduling/train-scheduling.service.ts
index 9c60c9821..44c50e185 100644
--- a/apps/edr-freight-api/src/modules/train-scheduling/train-scheduling.service.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/train-scheduling.service.ts
@@ -138,6 +138,7 @@ import {
   bookingCargoTons,
   bulkItemsFitFor,
   bulkItemWagonsRequired,
+  bulkTonsPerWagon,
   deriveTrainCapacityFromLocomotive,
   combinedLocomotiveLimits,
   trainSetLocomotiveLimits,
@@ -180,6 +181,13 @@ import {
 
 const SCHEDULABLE_BOOKING_STATUSES = ['PAID'] as const;
 
+/** Drops the keys a partial override left undefined, so `...` merges keep the base value. */
+function pickDefined<T extends object>(source: T): Partial<T> {
+  return Object.fromEntries(
+    Object.entries(source).filter(([, v]) => v !== undefined),
+  ) as Partial<T>;
+}
+
 /**
  * The booking-window rule fields frozen onto a train schedule at creation (and
  * refreshed by restampPendingWindows for not-yet-open schedules). The board draws
@@ -905,6 +913,9 @@ export class TrainSchedulingService {
         windowClosesAt: cap(times.windowClosesAt, t.departure),
         ...ruleFields,
         rulePaymentWindowMinutes,
+        // Deliberately overridden — exempt from the global re-stamp, which would
+        // otherwise revert this schedule the next time global rules are saved.
+        windowRuleCustom: true,
       });
     }
     this.logger.log(
@@ -1196,6 +1207,9 @@ export class TrainSchedulingService {
     let restamped = 0;
     for (const s of schedules) {
       if (!s.scheduledDepartureDate || s.scheduledDepartureDate <= now) continue;
+      // Hand-configured windows are not "pending the global rule" — staff picked
+      // these times deliberately, so a global-rules edit must leave them alone.
+      if (s.windowRuleCustom) continue;
       const times =
         s.direction === 'EXPORT'
           ? computeExportWindowTimes(s.scheduledDepartureDate, cfg)
@@ -1459,29 +1473,8 @@ export class TrainSchedulingService {
       // it on schedule. DOMESTIC runs the same one-booking-day cycle as IMPORT
       // (opens at 08:00 EAT `importWindowLeadDays` before departure); EXPORT opens
       // 24h before departure (FCFS). No schedule is ever always-open now.
-      const windowCfg = await this.getWindowConfig();
+      const globalCfg = await this.getWindowConfig();
 
-      // Staff cannot schedule inside the lead window — there must be room for a
-      // booking window before departure. IMPORT/DOMESTIC lead is in whole EAT
-      // days (lead 3, today 11th → first allowed departure is the 14th); EXPORT
-      // lead is in hours (24h = 1 day ahead).
-      const earliest = earliestSchedulableDeparture(direction, windowCfg, new Date());
-      if (departure.getTime() < earliest.getTime()) {
-        const detail =
-          direction === 'EXPORT'
-            ? `at least ${windowCfg.exportBookingLeadHours} hour(s) ahead`
-            : `at least ${windowCfg.importWindowLeadDays} day(s) ahead`;
-        throw new BadRequestException(
-          `Departure ${departure.toISOString()} is inside the booking lead window; ` +
-            `${direction === 'EXPORT' ? 'export' : 'import'} trains must be scheduled ${detail} ` +
-            `(earliest ${earliest.toISOString()})`,
-        );
-      }
-      // Freeze the rule this schedule is born with. A later global-rules edit
-      // only re-derives NOT-YET-OPEN schedules (see restampPendingWindows); an
-      // already-open schedule keeps this snapshot, and the batch board draws its
-      // windows from it rather than the live config.
-      const ruleSnapshot = windowRuleSnapshot(windowCfg);
       // Route+day grouping (IMPORT/DOMESTIC only): if a schedule already exists
       // on this origin + destination + EAT departure day, this new train JOINS
       // its group and adopts the group's shared window timeline (open/close +
@@ -1505,6 +1498,77 @@ export class TrainSchedulingService {
               route.destinationYardId,
               departure,
             );
+
+      // Per-schedule window rule chosen at creation. Refused for a train that
+      // JOINS an existing route+day group: the group shares ONE window timeline,
+      // so a joining train adopts the anchor's times verbatim and its own
+      // settings would be silently discarded. Staff edit the group's window
+      // instead (Booking window settings, which fans out to every sibling).
+      if (dto.windowRule && groupAnchor) {
+        throw new BadRequestException(
+          'This train joins an existing booking group (same route and departure day), ' +
+            'which shares one booking window across all its trains. Create it with the ' +
+            'group settings, then use Booking window settings to change the window for ' +
+            'the whole group.',
+        );
+      }
+
+      // The rule this schedule is born under: staff overrides on top of the live
+      // global config, so an omitted field still follows the global value.
+      const windowCfg: BookingWindowConfig = dto.windowRule
+        ? {
+            ...globalCfg,
+            ...pickDefined({
+              windowOpenHour: dto.windowRule.windowOpenHour,
+              windowCloseHour: dto.windowRule.windowCloseHour,
+              windowDurationHours: dto.windowRule.windowDurationHours,
+              docReviewMinutes: dto.windowRule.docReviewMinutes,
+              importWindowLeadDays: dto.windowRule.importWindowLeadDays,
+              exportBookingLeadHours: dto.windowRule.exportBookingLeadHours,
+            }),
+            // One pay-window override drives both directions (only the one
+            // matching this schedule's direction is ever read).
+            ...(dto.windowRule.paymentWindowMinutes !== undefined
+              ? {
+                  paymentWindowMinutes: dto.windowRule.paymentWindowMinutes,
+                  exportPaymentWindowMinutes: dto.windowRule.paymentWindowMinutes,
+                }
+              : {}),
+            // Close offsets are nullable-by-intent: null/0 means "close at
+            // departure", which must override a non-null global, so these are
+            // merged on presence rather than on definedness.
+            ...(dto.windowRule.importCloseOffsetMinutes !== undefined
+              ? { importCloseOffsetMinutes: dto.windowRule.importCloseOffsetMinutes ?? null }
+              : {}),
+            ...(dto.windowRule.exportCloseOffsetMinutes !== undefined
+              ? { exportCloseOffsetMinutes: dto.windowRule.exportCloseOffsetMinutes ?? null }
+              : {}),
+          }
+        : globalCfg;
+
+      // Staff cannot schedule inside the lead window — there must be room for a
+      // booking window before departure. IMPORT/DOMESTIC lead is in whole EAT
+      // days (lead 3, today 11th → first allowed departure is the 14th); EXPORT
+      // lead is in hours (24h = 1 day ahead). Checked against the schedule's OWN
+      // lead, so a custom lead is honoured rather than rejected by the global one.
+      const earliest = earliestSchedulableDeparture(direction, windowCfg, new Date());
+      if (departure.getTime() < earliest.getTime()) {
+        const detail =
+          direction === 'EXPORT'
+            ? `at least ${windowCfg.exportBookingLeadHours} hour(s) ahead`
+            : `at least ${windowCfg.importWindowLeadDays} day(s) ahead`;
+        throw new BadRequestException(
+          `Departure ${departure.toISOString()} is inside the booking lead window; ` +
+            `${direction === 'EXPORT' ? 'export' : 'import'} trains must be scheduled ${detail} ` +
+            `(earliest ${earliest.toISOString()})`,
+        );
+      }
+
+      // Freeze the rule this schedule is born with. A later global-rules edit
+      // only re-derives NOT-YET-OPEN schedules (see restampPendingWindows); an
+      // already-open schedule keeps this snapshot, and the batch board draws its
+      // windows from it rather than the live config.
+      const ruleSnapshot = windowRuleSnapshot(windowCfg);
       const computedTimes =
         direction === 'EXPORT'
           ? { ...ruleSnapshot, ...computeExportWindowTimes(departure, windowCfg) }
@@ -1513,12 +1577,30 @@ export class TrainSchedulingService {
               ...ruleSnapshot,
               ...computeImportWindowTimes(departure, windowCfg, new Date()),
             };
+      if (
+        computedTimes.windowOpensAt.getTime() >= computedTimes.windowClosesAt.getTime()
+      ) {
+        throw new BadRequestException(
+          'These booking-window settings leave no window before departure — with the ' +
+            'desk hours and close offset applied, the window would only open once the ' +
+            'train has left.',
+        );
+      }
       const windowFields = {
         bookingWindowStatus: 'CLOSED',
         windowPhase: 'PRE_WINDOW',
         ...(groupAnchor
           ? this.groupWindowFieldsFrom(groupAnchor, departure)
           : computedTimes),
+        // `windowRuleSnapshot` never stamps the pay window (NULL = follow the
+        // live global value for the direction), so an explicit staff override is
+        // persisted here — the same field the post-creation override writes.
+        ...(dto.windowRule?.paymentWindowMinutes !== undefined
+          ? { rulePaymentWindowMinutes: dto.windowRule.paymentWindowMinutes }
+          : {}),
+        // Hand-configured windows opt OUT of the global re-stamp, or the next
+        // global-rules edit would overwrite exactly what staff chose here.
+        windowRuleCustom: dto.windowRule != null,
       };
       // A built train's own consist is the schedule's capacity: full when all
       // its wagons are allocated. Trains built without wagons yet fall back to
@@ -2928,6 +3010,78 @@ export class TrainSchedulingService {
     };
   }
 
+  /**
+   * The train's composition as it stands right now — the source for the
+   * intercity marshalling ("Marshalling 2") document printed after mid-corridor
+   * station work. A wagon slot is on the train iff it has not DEPARTED and
+   * either rides the whole corridor (no boardYardId) or has confirmed LOADED
+   * cargo. Kept wagons carry only their LOADED allocations (DEPARTED =
+   * unloaded, PLANNED/RESERVED = not on board yet).
+   * ponytail: boardYardId presence is the "boarded yet?" heuristic; upgrade
+   * path is comparing the board yard against the latest checkpoint sequence.
+   */
+  private intercityOnBoardView(schedule: TrainSchedule): {
+    wagons: TrainSetWagon[];
+    unassignedBookings: Booking[];
+  } {
+    const wagons = (schedule.trainSet?.wagons ?? [])
+      .filter((wagon) => {
+        if (wagon.status === 'DEPARTED') return false;
+        const hasLoaded = (wagon.allocations ?? []).some((a) => a.status === 'LOADED');
+        return wagon.boardYardId == null || hasLoaded;
+      })
+      .map((wagon) => ({
+        ...wagon,
+        allocations: (wagon.allocations ?? []).filter((a) => a.status === 'LOADED'),
+      })) as TrainSetWagon[];
+
+    const onBoardBookingIds = new Set(
+      wagons.flatMap((wagon) => (wagon.allocations ?? []).map((a) => a.bookingId)),
+    );
+    // IN_TRANSIT bookings with no kept allocation: intercity riders accepted
+    // after dispatch (never wagon-pinned) and loads whose allocation was never
+    // confirmed LOADED. They are physically on the train, so they get a row.
+    const unassignedBookings = (schedule.scheduleBookings ?? [])
+      .map((link) => link.booking)
+      .filter((booking): booking is Booking => Boolean(booking))
+      .filter((booking) => booking.status === 'IN_TRANSIT' && !onBoardBookingIds.has(booking.id));
+
+    return { wagons, unassignedBookings };
+  }
+
+  async intercityMarshallingDocument(scheduleId: string): Promise<{ filename: string; buffer: Buffer }> {
+    const schedule = await this.trainSchedulesRepository.findByIdWithFullGraph(scheduleId);
+    if (!schedule) {
+      throw new NotFoundException(`Train schedule ${scheduleId} not found`);
+    }
+    if (schedule.status !== 'DISPATCHED' && schedule.status !== 'ARRIVED') {
+      throw new BadRequestException(
+        'Intercity marshalling document applies only to dispatched or arrived trains',
+      );
+    }
+
+    const checkpoints = await this.trainCheckpointEventsRepository.findBySchedule(scheduleId);
+    const last = checkpoints[checkpoints.length - 1];
+    const positionLabel = last
+      ? `After ${last.yard?.label ?? last.yard?.code ?? 'checkpoint'}`
+      : `At ${schedule.originStation?.label ?? schedule.originStation?.code ?? 'origin'} — no checkpoint recorded`;
+
+    const { wagons, unassignedBookings } = this.intercityOnBoardView(schedule);
+    const html = this.buildExportLoadListHtml(schedule, {
+      title: 'Intercity Marshalling Document / Load List (Marshalling 2)',
+      positionLabel,
+      wagons,
+      unassignedBookings,
+    });
+    // Styled table-aware fallback (marshalling grid) — see importLoadListDocument.
+    const buffer = await this.pdfDocuments.renderTabularDocument(html, 'Intercity marshalling / load list');
+    const reference = schedule.trainNumber ?? schedule.id;
+    return {
+      filename: `intercity-marshalling-${this.safeDocumentName(reference)}.pdf`,
+      buffer,
+    };
+  }
+
   /**
    * A container item's size in feet, for the marshalling document's 40ft/20ft
    * tally. Two independent sources, since only one is populated depending on
@@ -2954,7 +3108,15 @@ export class TrainSchedulingService {
     return null;
   }
 
-  private buildExportLoadListHtml(schedule: TrainSchedule): string {
+  private buildExportLoadListHtml(
+    schedule: TrainSchedule,
+    opts?: {
+      title?: string;
+      positionLabel?: string;
+      wagons?: TrainSetWagon[];
+      unassignedBookings?: Booking[];
+    },
+  ): string {
     const esc = (value: unknown) =>
       String(value ?? '-')
         .replace(/&/g, '&amp;')
@@ -2967,7 +3129,7 @@ export class TrainSchedulingService {
     const bookingById = new Map((schedule.scheduleBookings ?? []).map((link) => [link.bookingId, link.booking]));
     // The document is checked against the physical train, so it has to run in
     // consist order — the relation comes back unordered.
-    const wagons = [...(schedule.trainSet?.wagons ?? [])].sort(
+    const wagons = [...(opts?.wagons ?? schedule.trainSet?.wagons ?? [])].sort(
       (a, b) => Number(a.sequenceNo ?? 0) - Number(b.sequenceNo ?? 0),
     );
     const rows = wagons
@@ -3011,6 +3173,29 @@ export class TrainSchedulingService {
         });
       })
       .join('');
+    // Intercity riders accepted after dispatch have no wagon slot recorded —
+    // they are still physically on the train, so they get rows of their own.
+    const unassigned = opts?.unassignedBookings ?? [];
+    const unassignedRows = unassigned.length
+      ? `<tr class="empty"><td colspan="11">ON BOARD — WAGON NOT RECORDED</td></tr>` +
+        unassigned
+          .map((booking) => {
+            const containerNumbers = (booking.bookingContainers ?? [])
+              .map((container) => container.containerNumber)
+              .filter(Boolean)
+              .join(', ');
+            const leg = `${booking.originYard?.label ?? booking.originYard?.code ?? '-'} → ${booking.destinationYard?.label ?? booking.destinationYard?.code ?? '-'}`;
+            return `<tr>
+            <td colspan="6">${esc(booking.reference)} — ${esc(leg)}</td>
+            <td>${esc(booking.cargoType?.cargoTypeName ?? booking.cargoType?.code)}</td>
+            <td>${esc(booking.company?.name)}</td>
+            <td>${esc(containerNumbers)}</td>
+            <td>-</td>
+            <td>-</td>
+          </tr>`;
+          })
+          .join('')
+      : '';
     const emptyWagons = wagons.filter((wagon) => (wagon.allocations ?? []).length === 0).length;
     const totalWeight = wagons.reduce(
       (sum, wagon) =>
@@ -3034,7 +3219,7 @@ export class TrainSchedulingService {
 <html>
 <head>
   <meta charset="utf-8" />
-  <title>Export Marshalling Document</title>
+  <title>${esc(opts?.title ?? 'Export Marshalling Document')}</title>
   <style>
     @page { size: A4 landscape; margin: 10mm; }
     * { box-sizing: border-box; }
@@ -3063,7 +3248,7 @@ export class TrainSchedulingService {
   <div class="top">
     <div>
       <div class="brand">Ethio-Djibouti Railway S.C.</div>
-      <h1>Export Marshalling Document / Load List</h1>
+      <h1>${esc(opts?.title ?? 'Export Marshalling Document / Load List')}</h1>
     </div>
     <div class="meta">
       Train / Schedule
@@ -3088,6 +3273,7 @@ export class TrainSchedulingService {
     <div class="tile"><span>Bookings</span><strong>${esc(schedule.scheduleBookings?.length ?? 0)}</strong></div>
     <div class="tile"><span>Status</span><strong>${esc(schedule.status)}</strong></div>
     <div class="tile"><span>Direction</span><strong>${esc(schedule.direction)}</strong></div>
+    ${opts?.positionLabel ? `<div class="tile"><span>Current position</span><strong>${esc(opts.positionLabel)}</strong></div>` : ''}
   </div>
 
   <table>
@@ -3108,6 +3294,7 @@ export class TrainSchedulingService {
     </thead>
     <tbody>
       ${rows || '<tr><td colspan="10">No wagons on this train set.</td></tr>'}
+      ${unassignedRows}
     </tbody>
   </table>
 
@@ -3899,13 +4086,25 @@ export class TrainSchedulingService {
     return Object.assign(detail, { warehouseAutomation });
   }
 
-  async getContainerTrainSchedules(query: ListTrainSchedulesQueryDto = {}) {
+  async getContainerTrainSchedules(
+    query: ListTrainSchedulesQueryDto = {},
+    allowedDirections?: string[],
+  ) {
     const { page, pageSize, skip, take } = normalizePagination(query);
 
+    // Per-user trade-direction scope: schedules carry a `direction` column.
+    if (allowedDirections && allowedDirections.length === 0) {
+      return {
+        items: [],
+        meta: buildPaginationMeta(0, page, pageSize),
+      };
+    }
+
     // Exact-match filters (enum/id semantics). Freight type is derived from
     // the bookings aboard — no column to match — so it rides on `id` as an
     // EXISTS fragment instead.
     const base: FindOptionsWhere<TrainSchedule> = {};
+    if (allowedDirections) base.direction = In(allowedDirections) as never;
     if (query.status) base.status = query.status;
     if (query.originStationId) base.originStationId = query.originStationId;
     if (query.destinationStationId) base.destinationStationId = query.destinationStationId;
@@ -7335,8 +7534,10 @@ export class TrainSchedulingService {
         ? Math.ceil(booking.wagonsRequired)
         : 0;
     const byLength = containerWagonsForLines(booking.bookingContainers ?? []);
-    const byWeight =
-      cargo > 0 && dims.capacityTons > 0 ? Math.ceil(cargo / dims.capacityTons) : 0;
+    // PER_TON cargo may cap tons per wagon below the rating (sugar 50T on a 70T
+    // wagon) — more wagons for the same cargo, so more tare to pull.
+    const tonsPerWagon = bulkTonsPerWagon(booking.cargoType, wagonTypeId, dims.capacityTons);
+    const byWeight = cargo > 0 && tonsPerWagon > 0 ? Math.ceil(cargo / tonsPerWagon) : 0;
     // Break-bulk (PER_ITEM): indivisible items occupy more wagons than raw
     // tonnage suggests — their tare must be pulled too (batch dimsFor parity).
     const byItems = bulkItemWagonsRequired(
diff --git a/apps/edr-freight-api/src/modules/train-scheduling/wagon-plan-flex.util.ts b/apps/edr-freight-api/src/modules/train-scheduling/wagon-plan-flex.util.ts
index 0810b3369..ef1e741be 100644
--- a/apps/edr-freight-api/src/modules/train-scheduling/wagon-plan-flex.util.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/wagon-plan-flex.util.ts
@@ -5,7 +5,7 @@ import { WagonType } from '../wagon-types/entities/wagon-type.entity';
 import {
   bookingCargoTons,
   bulkItemsFitFor,
-  bulkItemWagonsForAllowedTypes,
+  bulkWagonsForAllowedTypes,
 } from './train-capacity.util';
 import {
   sortBookingsForScheduling,
@@ -122,10 +122,11 @@ const shortageFor = (
       ? Math.max(
           1,
           // Break-bulk (PER_ITEM) sizes by indivisible items (items-fit map
-          // respected); PER_TON falls through to tonnage over the largest
-          // candidate. bookingCargoTons, not raw VGM — for PER_ITEM that
-          // column is the item count, not tons.
-          bulkItemWagonsForAllowedTypes(
+          // respected); PER_TON divides by its per-wagon tonnage cap where one
+          // is configured, else the largest candidate's rating.
+          // bookingCargoTons, not raw VGM — for PER_ITEM that column is the
+          // item count, not tons.
+          bulkWagonsForAllowedTypes(
             booking,
             booking.cargoType,
             Math.max(1, ...candidates.map((wt) => Number(wt.capacityTons))),
diff --git a/apps/edr-freight-api/src/modules/train-scheduling/wagon-plan.util.ts b/apps/edr-freight-api/src/modules/train-scheduling/wagon-plan.util.ts
index ef3089925..9720e46c4 100644
--- a/apps/edr-freight-api/src/modules/train-scheduling/wagon-plan.util.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/wagon-plan.util.ts
@@ -7,6 +7,8 @@ import {
   bookingCargoTons,
   bulkItemsFitFor,
   bulkItemWagonsRequired,
+  bulkTonsPerWagon,
+  bulkTonWagonsRequired,
   consistViolations,
 } from './train-capacity.util';
 
@@ -186,15 +188,29 @@ export function buildBulkWagonPlan(
     bulkItemWagonsRequired(b, capacity, bulkItemsFitFor(b.cargoType, wagonType.id)),
   );
   const itemSlots = itemSlotsByBooking.reduce((sum, n) => sum + n, 0);
+
+  // PER_TON cargo with a per-wagon tonnage cap (sugar 50T on a 70T wagon) can't
+  // pool with uncapped tonnage either: its wagons stop at the cap, so 200T needs
+  // 4 wagons and pooling it at 70T would plan 3. Capped bookings are sized on
+  // their own cap; only genuinely uncapped tonnage pools at rated capacity.
+  const cappedTonSlotsByBooking = bookings.map((b, i) =>
+    itemSlotsByBooking[i] > 0 || bulkTonsPerWagon(b.cargoType, wagonType.id, capacity) >= capacity
+      ? 0
+      : bulkTonWagonsRequired(b, b.cargoType, wagonType.id, capacity),
+  );
+  const cappedTonSlots = cappedTonSlotsByBooking.reduce((sum, n) => sum + n, 0);
+
   const totalWeight = roundTons(
     bookings.reduce(
       (sum, b, i) =>
-        itemSlotsByBooking[i] > 0 ? sum : sum + Number(b.cargoTotalWeightVgm ?? 0),
+        itemSlotsByBooking[i] > 0 || cappedTonSlotsByBooking[i] > 0
+          ? sum
+          : sum + Number(b.cargoTotalWeightVgm ?? 0),
       0,
     ),
   );
   const tonSlots = totalWeight > 0 ? Math.ceil(totalWeight / capacity) : 0;
-  const slots = Math.max(1, tonSlots + itemSlots);
+  const slots = Math.max(1, tonSlots + itemSlots + cappedTonSlots);
 
   const basePlan: WagonPlanSlot[] = Array.from({ length: slots }, (_, index) => ({
     sequenceNo: index + 1,
@@ -315,6 +331,7 @@ function allocateBookingsToSlots(
     // bookingCargoTons, not the raw VGM column: for break-bulk (PER_ITEM)
     // bookings that column is an item COUNT, not tons.
     remainingWeightTons: roundTons(bookingCargoTons(booking)),
+    cargoType: booking.cargoType,
   }));
 
   let bookingIndex = 0;
@@ -326,8 +343,15 @@ function allocateBookingsToSlots(
 
     while (wagonRemaining > 0 && bookingIndex < remaining.length) {
       const booking = remaining[bookingIndex];
+      // A PER_TON loading cap (sugar 50T on a 70T wagon) binds the FILL as well
+      // as the wagon count — the plan reserved a wagon per capped chunk, so
+      // pouring rated capacity into it would leave the last wagon empty.
+      const takeCap = Math.min(
+        wagonRemaining,
+        bulkTonsPerWagon(booking.cargoType, slot.wagonTypeId, slot.capacityTons),
+      );
       const allocatedWeightTons = roundTons(
-        Math.min(wagonRemaining, booking.remainingWeightTons),
+        Math.min(takeCap, booking.remainingWeightTons),
       );
 
       if (allocatedWeightTons <= 0) {
@@ -350,6 +374,12 @@ function allocateBookingsToSlots(
 
       if (booking.remainingWeightTons <= 0) {
         bookingIndex += 1;
+      } else if (allocatedWeightTons >= takeCap) {
+        // The cap stopped this wagon short of its rating and the booking has
+        // more to load. The leftover room is NOT free: `buildBulkWagonPlan`
+        // already reserved a wagon for the rest, so backfilling another booking
+        // here would double-book the consist. Close the wagon.
+        break;
       }
     }
 
diff --git a/apps/edr-freight-api/src/modules/user-trade-access/dto/upsert-user-trade-access.dto.ts b/apps/edr-freight-api/src/modules/user-trade-access/dto/upsert-user-trade-access.dto.ts
new file mode 100644
index 000000000..1c2db098e
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/user-trade-access/dto/upsert-user-trade-access.dto.ts
@@ -0,0 +1,16 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { ArrayUnique, IsIn } from 'class-validator';
+import { Freight } from '@edr/types';
+
+export class UpsertUserTradeAccessDto {
+  @ApiProperty({
+    description:
+      'Trade directions the user may see. All three (or no config row) = unrestricted; empty array = sees nothing.',
+    isArray: true,
+    enum: ['IMPORT', 'EXPORT', 'DOMESTIC'],
+    example: ['IMPORT', 'DOMESTIC'],
+  })
+  @ArrayUnique()
+  @IsIn(['IMPORT', 'EXPORT', 'DOMESTIC'], { each: true })
+  directions!: Freight.ScheduleTradeDirection[];
+}
diff --git a/apps/edr-freight-api/src/modules/user-trade-access/entities/user-trade-access.entity.ts b/apps/edr-freight-api/src/modules/user-trade-access/entities/user-trade-access.entity.ts
new file mode 100644
index 000000000..6ef5ca1fb
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/user-trade-access/entities/user-trade-access.entity.ts
@@ -0,0 +1,27 @@
+import { BaseEntity } from '@edr/api-common';
+import { Freight } from '@edr/types';
+import { Column, Entity, Index } from 'typeorm';
+
+/**
+ * Which trade directions (IMPORT / EXPORT / DOMESTIC=Intercity) a backoffice
+ * user may see. No row, or all three directions, means unrestricted.
+ */
+@Entity({ schema: 'freight', name: 'user_trade_access' })
+export class UserTradeAccess extends BaseEntity {
+  /** IAM user id (iam.users) — no FK, iam schema is externally owned. */
+  @Index()
+  @Column({ name: 'user_id', type: 'uuid', unique: true })
+  userId!: string;
+
+  @Column({ name: 'directions', type: 'text', default: '' })
+  directionsRaw!: string;
+
+  @Column({ name: 'updated_by_id', type: 'uuid', nullable: true })
+  updatedById!: string | null;
+
+  get directions(): Freight.ScheduleTradeDirection[] {
+    return this.directionsRaw
+      ? (this.directionsRaw.split(',') as Freight.ScheduleTradeDirection[])
+      : [];
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/user-trade-access/trade-scope.util.spec.ts b/apps/edr-freight-api/src/modules/user-trade-access/trade-scope.util.spec.ts
new file mode 100644
index 000000000..8823098ab
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/user-trade-access/trade-scope.util.spec.ts
@@ -0,0 +1,64 @@
+import { applyDirectionScope, scopedDirections } from './trade-scope.util';
+
+/**
+ * The scope decides what a restricted user may see, so the cases that matter
+ * are the ones where a wrong answer widens access: an unrestricted fallback
+ * where a restriction was configured, or an out-of-scope explicit filter
+ * being honoured instead of denied.
+ */
+describe('scopedDirections', () => {
+  it('leaves an unrestricted user unfiltered', () => {
+    expect(scopedDirections(null)).toBeNull();
+  });
+
+  it('honours an explicit filter for an unrestricted user', () => {
+    expect(scopedDirections(null, 'EXPORT')).toEqual(['EXPORT']);
+  });
+
+  it('falls back to the full scope when no filter is requested', () => {
+    expect(scopedDirections(['EXPORT'])).toEqual(['EXPORT']);
+  });
+
+  it('narrows to the intersection when the filter is in scope', () => {
+    expect(scopedDirections(['IMPORT', 'EXPORT'], 'EXPORT')).toEqual(['EXPORT']);
+  });
+
+  it('denies an out-of-scope filter instead of widening access', () => {
+    expect(scopedDirections(['EXPORT'], 'IMPORT')).toEqual([]);
+  });
+});
+
+describe('applyDirectionScope', () => {
+  const makeQb = () => {
+    const calls: { sql: string; params?: object }[] = [];
+    const qb = {
+      calls,
+      andWhere(sql: string, params?: object) {
+        calls.push({ sql, params });
+        return qb;
+      },
+    };
+    return qb;
+  };
+
+  it('does not touch the query when unrestricted', () => {
+    const qb = makeQb();
+    applyDirectionScope(qb as never, 'booking.trade_direction', null);
+    expect(qb.calls).toHaveLength(0);
+  });
+
+  it('matches nothing on an empty scope rather than everything', () => {
+    const qb = makeQb();
+    applyDirectionScope(qb as never, 'booking.trade_direction', []);
+    expect(qb.calls[0].sql).toBe('1 = 0');
+  });
+
+  it('filters to the allowed directions', () => {
+    const qb = makeQb();
+    applyDirectionScope(qb as never, 'booking.trade_direction', ['EXPORT']);
+    expect(qb.calls[0].sql).toContain('booking.trade_direction IN');
+    expect(qb.calls[0].params).toEqual({
+      scopeDirs_booking_trade_direction: ['EXPORT'],
+    });
+  });
+});
diff --git a/apps/edr-freight-api/src/modules/user-trade-access/trade-scope.util.ts b/apps/edr-freight-api/src/modules/user-trade-access/trade-scope.util.ts
new file mode 100644
index 000000000..37ffa93c9
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/user-trade-access/trade-scope.util.ts
@@ -0,0 +1,100 @@
+import { Freight } from '@edr/types';
+import { Brackets, SelectQueryBuilder, WhereExpressionBuilder } from 'typeorm';
+
+/**
+ * Resolve the effective direction list for a query.
+ *
+ * @param allowed  the user's scope — null = unrestricted
+ * @param requested an explicit ?tradeDirection=… filter, if any
+ * @returns directions to filter by, `null` = no filter, `[]` = show nothing
+ */
+export function scopedDirections(
+  allowed: Freight.ScheduleTradeDirection[] | null,
+  requested?: string | null,
+): string[] | null {
+  if (!allowed) return requested ? [requested] : null;
+  if (!requested) return [...allowed];
+  return allowed.includes(requested as Freight.ScheduleTradeDirection)
+    ? [requested]
+    : [];
+}
+
+/**
+ * Apply a direction scope to a query builder column.
+ * `dirs = null` → untouched; `dirs = []` → matches nothing.
+ */
+export function applyDirectionScope<T extends WhereExpressionBuilder>(
+  qb: T,
+  column: string,
+  dirs: string[] | null,
+): T {
+  if (dirs === null) return qb;
+  if (dirs.length === 0) {
+    qb.andWhere('1 = 0');
+    return qb;
+  }
+  // Unique param name so multiple scopes can coexist on one query.
+  const param = `scopeDirs_${column.replace(/\W/g, '_')}`;
+  qb.andWhere(`${column} IN (:...${param})`, { [param]: dirs });
+  return qb;
+}
+
+/**
+ * SQL-fragment form of {@link applyDirectionScope} for fluent query chains:
+ * `.andWhere(f.sql, f.params)`. `dirs = null/undefined` → TRUE (no-op).
+ */
+export function directionScopeSql(
+  column: string,
+  dirs: string[] | null | undefined,
+): { sql: string; params: Record<string, unknown> } {
+  if (!dirs) return { sql: 'TRUE', params: {} };
+  if (dirs.length === 0) return { sql: 'FALSE', params: {} };
+  const param = `scopeDirs_${column.replace(/\W/g, '_')}`;
+  return { sql: `${column} IN (:...${param})`, params: { [param]: dirs } };
+}
+
+/**
+ * SQL-fragment form of {@link applyBookingRefDirectionScope}: hides rows whose
+ * varchar ref column points at a booking outside the scope; rows that do not
+ * point at a booking stay visible (they carry no direction to scope by).
+ */
+export function bookingRefScopeSql(
+  refColumn: string,
+  dirs: string[] | null | undefined,
+): { sql: string; params: Record<string, unknown> } {
+  if (!dirs) return { sql: 'TRUE', params: {} };
+  const param = `scopeRefDirs_${refColumn.replace(/\W/g, '_')}`;
+  const disallowed = dirs.length
+    ? `b.trade_direction NOT IN (:...${param})`
+    : 'TRUE';
+  return {
+    sql: `NOT EXISTS (SELECT 1 FROM freight.bookings b WHERE b.id::text = ${refColumn} AND ${disallowed})`,
+    params: dirs.length ? { [param]: dirs } : {},
+  };
+}
+
+/**
+ * Scope rows whose direction lives on a related booking referenced by a
+ * varchar id column (invoices.source_id, payments.ref_id). Rows that do not
+ * point at a booking stay visible — they carry no direction to scope by.
+ */
+export function applyBookingRefDirectionScope<T>(
+  qb: SelectQueryBuilder<T & object>,
+  refColumn: string,
+  dirs: string[] | null,
+): SelectQueryBuilder<T & object> {
+  if (dirs === null) return qb;
+  const param = `scopeRefDirs_${refColumn.replace(/\W/g, '_')}`;
+  const disallowed = dirs.length
+    ? `b.trade_direction NOT IN (:...${param})`
+    : 'TRUE';
+  qb.andWhere(
+    new Brackets((w) => {
+      w.where(
+        `NOT EXISTS (SELECT 1 FROM freight.bookings b WHERE b.id::text = ${refColumn} AND ${disallowed})`,
+      );
+    }),
+  );
+  if (dirs.length) qb.setParameter(param, dirs);
+  return qb;
+}
diff --git a/apps/edr-freight-api/src/modules/user-trade-access/user-trade-access.controller.ts b/apps/edr-freight-api/src/modules/user-trade-access/user-trade-access.controller.ts
new file mode 100644
index 000000000..3c6255fd9
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/user-trade-access/user-trade-access.controller.ts
@@ -0,0 +1,67 @@
+import {
+  Body,
+  Controller,
+  ForbiddenException,
+  Get,
+  Param,
+  ParseUUIDPipe,
+  Put,
+} from '@nestjs/common';
+import { ApiBearerAuth, ApiOperation, ApiTags } from '@nestjs/swagger';
+import { CurrentUser } from '@edr/api-common';
+import type { TCurrentUser } from '@tria-plc/api-common/modules/auth/types/current-user.type';
+
+import { StaffReference } from '../../common/booking-guards';
+import { isFreightApprovalAdmin } from '../../common/freight-permission.util';
+import { UpsertUserTradeAccessDto } from './dto/upsert-user-trade-access.dto';
+import { UserTradeAccessService } from './user-trade-access.service';
+
+@ApiTags('user-trade-access')
+@Controller('user-trade-access')
+@StaffReference()
+@ApiBearerAuth()
+export class UserTradeAccessController {
+  constructor(private readonly service: UserTradeAccessService) {}
+
+  @Get()
+  @ApiOperation({ summary: 'List every configured user trade-direction scope' })
+  list(@CurrentUser() user: TCurrentUser) {
+    this.assertAdmin(user);
+    return this.service.listConfigs();
+  }
+
+  @Get('me')
+  @ApiOperation({ summary: "Current user's effective trade-direction scope" })
+  async me(@CurrentUser() user: TCurrentUser) {
+    const allowed = await this.service.resolveAllowedDirections(user);
+    return {
+      restricted: allowed !== null,
+      directions: allowed ?? ['IMPORT', 'EXPORT', 'DOMESTIC'],
+    };
+  }
+
+  @Put(':userId')
+  @ApiOperation({
+    summary: 'Set the trade directions a backoffice user may see',
+  })
+  upsert(
+    @Param('userId', ParseUUIDPipe) userId: string,
+    @Body() dto: UpsertUserTradeAccessDto,
+    @CurrentUser() user: TCurrentUser,
+  ) {
+    this.assertAdmin(user);
+    return this.service.upsert(
+      userId,
+      dto.directions,
+      (user as { id?: string } | null)?.id ?? null,
+    );
+  }
+
+  private assertAdmin(user: TCurrentUser) {
+    if (!isFreightApprovalAdmin(user)) {
+      throw new ForbiddenException(
+        'Only super or organization admins can manage trade-direction access',
+      );
+    }
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/user-trade-access/user-trade-access.module.ts b/apps/edr-freight-api/src/modules/user-trade-access/user-trade-access.module.ts
new file mode 100644
index 000000000..8b3515930
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/user-trade-access/user-trade-access.module.ts
@@ -0,0 +1,15 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+
+import { UserTradeAccess } from './entities/user-trade-access.entity';
+import { UserTradeAccessController } from './user-trade-access.controller';
+import { UserTradeAccessRepository } from './user-trade-access.repository';
+import { UserTradeAccessService } from './user-trade-access.service';
+
+@Module({
+  imports: [TypeOrmModule.forFeature([UserTradeAccess])],
+  controllers: [UserTradeAccessController],
+  providers: [UserTradeAccessService, UserTradeAccessRepository],
+  exports: [UserTradeAccessService],
+})
+export class UserTradeAccessModule {}
diff --git a/apps/edr-freight-api/src/modules/user-trade-access/user-trade-access.repository.ts b/apps/edr-freight-api/src/modules/user-trade-access/user-trade-access.repository.ts
new file mode 100644
index 000000000..1df85b5ee
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/user-trade-access/user-trade-access.repository.ts
@@ -0,0 +1,23 @@
+import { BaseRepository } from '@edr/api-common';
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+
+import { UserTradeAccess } from './entities/user-trade-access.entity';
+
+@Injectable()
+export class UserTradeAccessRepository extends BaseRepository<UserTradeAccess> {
+  constructor(
+    @InjectRepository(UserTradeAccess) repository: Repository<UserTradeAccess>,
+  ) {
+    super(repository);
+  }
+
+  findByUserId(userId: string): Promise<UserTradeAccess | null> {
+    return this.repository.findOne({ where: { userId } });
+  }
+
+  findAllConfigs(): Promise<UserTradeAccess[]> {
+    return this.repository.find({ order: { updatedAt: 'DESC' } });
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/user-trade-access/user-trade-access.service.ts b/apps/edr-freight-api/src/modules/user-trade-access/user-trade-access.service.ts
new file mode 100644
index 000000000..bcabdea8b
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/user-trade-access/user-trade-access.service.ts
@@ -0,0 +1,76 @@
+import { Injectable } from '@nestjs/common';
+import { Freight } from '@edr/types';
+import { isFreightApprovalAdmin } from '../../common/freight-permission.util';
+import { UserTradeAccess } from './entities/user-trade-access.entity';
+import { UserTradeAccessRepository } from './user-trade-access.repository';
+
+const ALL: Freight.ScheduleTradeDirection[] = ['IMPORT', 'EXPORT', 'DOMESTIC'];
+
+/** Loose current-user shape: JWT payloads and TCurrentUser both fit. */
+export type ScopeUser =
+  | ({ id?: string; sub?: string; roles?: { key?: string }[] } & object)
+  | null
+  | undefined;
+
+export type UserTradeAccessView = {
+  userId: string;
+  directions: Freight.ScheduleTradeDirection[];
+  updatedAt: Date;
+};
+
+@Injectable()
+export class UserTradeAccessService {
+  constructor(private readonly repository: UserTradeAccessRepository) {}
+
+  async listConfigs(): Promise<UserTradeAccessView[]> {
+    const rows = await this.repository.findAllConfigs();
+    return rows.map((r) => this.toView(r));
+  }
+
+  async upsert(
+    userId: string,
+    directions: Freight.ScheduleTradeDirection[],
+    actorId?: string | null,
+  ): Promise<UserTradeAccessView> {
+    // Normalize to canonical order so "all three" compares reliably.
+    const normalized = ALL.filter((d) => directions.includes(d));
+    const existing = await this.repository.findByUserId(userId);
+    const saved = existing
+      ? await this.repository.update(existing.id, {
+          directionsRaw: normalized.join(','),
+          updatedById: actorId ?? null,
+        })
+      : await this.repository.create({
+          userId,
+          directionsRaw: normalized.join(','),
+          updatedById: actorId ?? null,
+        });
+    return this.toView(saved as UserTradeAccess);
+  }
+
+  /**
+   * Effective scope for the current user.
+   * `null` = unrestricted (no config, all three directions, admin, or no user
+   * on the request — routes without auth cannot be scoped).
+   */
+  async resolveAllowedDirections(
+    user: ScopeUser,
+  ): Promise<Freight.ScheduleTradeDirection[] | null> {
+    const userId = user?.id ?? user?.sub;
+    if (!userId) return null;
+    if (isFreightApprovalAdmin(user)) return null;
+    const row = await this.repository.findByUserId(userId);
+    if (!row) return null;
+    const dirs = row.directions;
+    if (dirs.length >= ALL.length) return null;
+    return dirs;
+  }
+
+  private toView(row: UserTradeAccess): UserTradeAccessView {
+    return {
+      userId: row.userId,
+      directions: row.directions,
+      updatedAt: row.updatedAt,
+    };
+  }
+}
diff --git a/apps/edr-freight-api/src/scripts/backfill-missing-unload-inventory.ts b/apps/edr-freight-api/src/scripts/backfill-missing-unload-inventory.ts
index 9d51107fe..608fba613 100644
--- a/apps/edr-freight-api/src/scripts/backfill-missing-unload-inventory.ts
+++ b/apps/edr-freight-api/src/scripts/backfill-missing-unload-inventory.ts
@@ -27,12 +27,20 @@ async function main() {
     const dataSource = app.get(DataSource);
     const inventory = app.get(WarehouseInventoryService);
 
+    // Skip bookings destined for a pure facility yard (has a facility but no
+    // warehouse, e.g. Dire Dawa) — those are fully represented by their
+    // facility_handling_events UNLOAD record, not a warehouse_inventory row.
+    // Same gate as BookingJourneyService.autoArriveAtFinalYard.
     const bookings: { id: string; tradeDirection: string }[] = await dataSource.query(
       `SELECT b.id, b.trade_direction AS "tradeDirection"
          FROM freight.bookings b
+         JOIN freight.yards dy ON dy.id = b.destination_yard_id
+         LEFT JOIN freight.yard_facilities yf
+           ON yf.yard_id = dy.id AND yf.deleted_at IS NULL AND yf.is_active = true
         WHERE b.deleted_at IS NULL
           AND b.trade_direction IN ('IMPORT', 'DOMESTIC')
           AND b.status IN ('ARRIVED', 'COMPLETED')
+          AND NOT (dy.has_facility = true AND COALESCE(yf.has_warehouse, false) = false)
           AND NOT EXISTS (
             SELECT 1 FROM freight.warehouse_inventory wi
              WHERE wi.booking_id = b.id AND wi.deleted_at IS NULL
diff --git a/apps/edr-freight-api/src/seed/yard-facilities.seeder.ts b/apps/edr-freight-api/src/seed/yard-facilities.seeder.ts
index 1822a877f..fafbd3a9a 100644
--- a/apps/edr-freight-api/src/seed/yard-facilities.seeder.ts
+++ b/apps/edr-freight-api/src/seed/yard-facilities.seeder.ts
@@ -59,14 +59,23 @@ export class YardFacilitiesSeeder {
         [yard.id],
       );
 
+      // Every facility works both sides of the trip today, so the per-side
+      // flags mirror the freight-type flags. Narrow an individual yard here
+      // when a real one turns out to load a type but not receive it.
       await this.dataSource.query(
         `INSERT INTO freight.yard_facilities
-           (yard_id, has_warehouse, handles_container, handles_bulk, equipment_notes)
-         VALUES ($1, $2, $3, true, $4)
+           (yard_id, has_warehouse, handles_container, handles_bulk, equipment_notes,
+            has_container_facility_origin, has_container_facility_destination,
+            has_bulk_facility_origin, has_bulk_facility_destination)
+         VALUES ($1, $2, $3, true, $4, $3, $3, true, true)
          ON CONFLICT (yard_id) WHERE deleted_at IS NULL
          DO UPDATE SET has_warehouse     = EXCLUDED.has_warehouse,
                        handles_container = EXCLUDED.handles_container,
                        handles_bulk      = EXCLUDED.handles_bulk,
+                       has_container_facility_origin      = EXCLUDED.has_container_facility_origin,
+                       has_container_facility_destination = EXCLUDED.has_container_facility_destination,
+                       has_bulk_facility_origin           = EXCLUDED.has_bulk_facility_origin,
+                       has_bulk_facility_destination      = EXCLUDED.has_bulk_facility_destination,
                        updated_at        = NOW()`,
         [yard.id, hasWarehouse, handlesContainer, `${facility} load/unload facility`],
       );
diff --git a/apps/edr-freight-web/backoffice/package.json b/apps/edr-freight-web/backoffice/package.json
index 568b3a47a..675eced1a 100644
--- a/apps/edr-freight-web/backoffice/package.json
+++ b/apps/edr-freight-web/backoffice/package.json
@@ -55,6 +55,7 @@
     "@tanstack/react-table": "^8.21.3",
     "@tinymce/tinymce-react": "^6.3.0",
     "@tria-plc/iamui": "file:../../../local-packages/tria-plc-iamui-0.1.1.tgz",
+    "@types/three": "^0.185.3",
     "@vis.gl/react-google-maps": "^1.8.3",
     "axios": "^1.7.7",
     "class-variance-authority": "^0.7.1",
@@ -103,6 +104,7 @@
     "sonner": "^2.0.7",
     "stream-browserify": "^3.0.0",
     "tailwind-merge": "^3.6.0",
+    "three": "^0.185.1",
     "tinymce": "^8.6.0",
     "xlsx": "^0.18.5",
     "zod": "^3.25.76",
diff --git a/apps/edr-freight-web/backoffice/src/App.tsx b/apps/edr-freight-web/backoffice/src/App.tsx
index d523d2e8a..4dc1fb9e9 100644
--- a/apps/edr-freight-web/backoffice/src/App.tsx
+++ b/apps/edr-freight-web/backoffice/src/App.tsx
@@ -2,6 +2,7 @@ import {
   ArrowLeftRight,
   Boxes,
   Building2,
+  BarChart3,
   Container,
   FileSignature,
   FileText,
@@ -71,6 +72,8 @@ import InvoiceDetailPage from "./pages/invoices/InvoiceDetailPage";
 import InvoicesPage from "./pages/invoices/InvoicesPage";
 import MyProfilePage from "./pages/dashboard/MyProfilePage";
 import OverviewPage from "./pages/dashboard/OverviewPage";
+import ReportsHubPage from "./pages/reports/ReportsHubPage";
+import ReportPage from "./pages/reports/ReportPage";
 import AiBookingMockTestPage from "./pages/ai/AiBookingMockTestPage";
 import PaymentsPage from "./pages/payments/PaymentsPage";
 //import EmployeesPage from "./pages/dashboard/user-management/EmployeesPage";
@@ -111,6 +114,7 @@ import BatchScheduleDetailPage from "./pages/trainScheduling/BatchScheduleDetail
 import TrainScheduleV2DetailPage from "./pages/trainScheduling/TrainScheduleV2DetailPage";
 import TrainScheduleTrackPage from "./pages/trainScheduling/TrainScheduleTrackPage";
 import TrainSchedulingGlobalRulesPage from "./pages/trainScheduling/TrainSchedulingGlobalRulesPage";
+import TradeAccessPage from "./pages/configuration/TradeAccessPage";
 import ContractValidityPeriodsPage from "./pages/configuration/ContractValidityPeriodsPage";
 import FirstMilePage from "./pages/operations/FirstMilePage";
 import LastMilePage from "./pages/operations/LastMilePage";
@@ -153,6 +157,12 @@ const buildSidebarSections = (demoItems: SidebarItem[]): SidebarSection[] => [
         icon: <LayoutDashboard />,
         permission: FREIGHT_PERMS.overview.view,
       },
+      {
+        label: "Reports",
+        href: "/dashboard/reports",
+        icon: <BarChart3 />,
+        permission: FREIGHT_PERMS.bookings.view,
+      },
       {
         label: "Customers",
         href: "/dashboard/customers",
@@ -425,12 +435,6 @@ const buildSidebarSections = (demoItems: SidebarItem[]): SidebarSection[] => [
             icon: <Container />,
             permission: FREIGHT_PERMS.warehouseInventory.view,
           },
-          {
-            label: "Dispatch Queue",
-            href: "/dashboard/dispatch-queue",
-            icon: <Send />,
-            permission: FREIGHT_PERMS.warehouseInventory.view,
-          },
           {
             label: "Terminal Inventory",
             href: "/dashboard/warehouse-inventory?direction=IMPORT",
@@ -585,6 +589,11 @@ const buildSidebarSections = (demoItems: SidebarItem[]): SidebarSection[] => [
             href: "/dashboard/configuration/train-scheduling-rules",
             permission: FREIGHT_PERMS.trainScheduling.rulesManage,
           },
+          {
+            label: "Trade access",
+            href: "/dashboard/configuration/trade-access",
+            permission: FREIGHT_PERMS.admin,
+          },
         ],
       },
       {
@@ -817,6 +826,8 @@ const App = () => {
       />
       <Route path="/dashboard" element={<DashboardShell />}>
         <Route path="overview" element={<OverviewPage />} />
+        <Route path="reports" element={<ReportsHubPage />} />
+        <Route path="reports/:reportKey" element={<ReportPage />} />
         {/* Dev/testing page for the mock AI booking assistant. */}
         <Route
           path="ai-booking-mock-test"
@@ -1549,6 +1560,14 @@ const App = () => {
             </RequirePermission>
           }
         />
+        <Route
+          path="configuration/trade-access"
+          element={
+            <RequirePermission permission={FREIGHT_PERMS.admin}>
+              <TradeAccessPage />
+            </RequirePermission>
+          }
+        />
         {/* <Route
           path="configuration/contract-validity-periods"
           element={
diff --git a/apps/edr-freight-web/backoffice/src/components/bookings/detail/BookingTrucksPanel.tsx b/apps/edr-freight-web/backoffice/src/components/bookings/detail/BookingTrucksPanel.tsx
index 1a77632ec..4427367cb 100644
--- a/apps/edr-freight-web/backoffice/src/components/bookings/detail/BookingTrucksPanel.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/bookings/detail/BookingTrucksPanel.tsx
@@ -1,13 +1,11 @@
 import { useMemo, useState } from "react";
 import { useQueries, useQuery } from "@tanstack/react-query";
-import { Badge, Button, Center, Group, Loader, SimpleGrid, Stack, Table, Text } from "@mantine/core";
+import { Button, Center, Group, Loader, SimpleGrid, Stack, Table, Text } from "@mantine/core";
 import { Coins, Truck } from "lucide-react";
 
 import { api } from "@/services/api";
-import { warehouseService } from "@/services/warehouse.service";
-import { lastMileService } from "@/services/last-mile.service";
 import { FeePreviewModal } from "@/components/warehouses/FeePreviewModal";
-import { TruckDetentionModal } from "@/components/operations/TruckDetentionModal";
+import { groupByBooking, TruckRows } from "@/pages/warehouses/ImportTrucksPage";
 
 import { SectionCard } from "./SectionCard";
 import { MetricTile } from "./MetricTile";
@@ -15,43 +13,14 @@ import { MetricTile } from "./MetricTile";
 const money = (amount: number, currency: string) =>
   `${Number(amount).toLocaleString()} ${currency === "ETB" ? "Birr (ETB)" : currency}`;
 
-const fmt = (iso: string | null | undefined) => (iso ? new Date(iso).toLocaleString() : "—");
-
-function inspectionLabel(status: string | null | undefined): { text: string; color: string } {
-  if (!status) return { text: "Pending", color: "gray" };
-  if (status === "PASSED") return { text: "Passed", color: "edr-green" };
-  if (status === "FAILED") return { text: "Failed", color: "red" };
-  return { text: status, color: "gray" };
-}
-
-interface TruckRow {
-  key: string;
-  plate: string;
-  driver: string | null;
-  truckType: string | null;
-  containers: string[];
-  warehouseArrived: string | null;
-  warehouseDeparted: string | null;
-  destinationArrived: string | null;
-  returned: string | null;
-  detentionOpen: boolean;
-  detentionDays: number | null;
-  detentionAmount: number | null;
-  hasDetentionRule: boolean;
-  inspection: { text: string; color: string };
-}
-
 /**
- * Every truck tied to a booking's last mile — EDR-dispatched or customer
- * self-haul (a booking only ever uses one), each with its own warehouse-gate
- * and destination-detention clocks, plus the booking's cargo-side cost totals
- * (storage/demurrage/double handling — billed per row internally, always
- * shown here as one booking-level total). Detention stays EDR-only; customer
- * self-haul rows show "—" since EDR only bills detention on its own fleet.
+ * Cargo costs (booking-level totals) plus the same truck-import block the
+ * Unloaded Queue's "Import trucks" view uses — Truck Arrival/Leaving, Exit
+ * paper, Handover, Inspect, Detention times, Warehouse gate times — reused
+ * as-is so this tab never drifts from that queue's behavior.
  */
 export function BookingTrucksPanel({ bookingId }: { bookingId: string }) {
   const [feeModalOpen, setFeeModalOpen] = useState(false);
-  const [detentionModalOpen, setDetentionModalOpen] = useState(false);
 
   const inventoryQuery = useQuery(
     api.warehouses.listInventory.queryOptions({ input: { filter: { bookingId } } }),
@@ -59,47 +28,27 @@ export function BookingTrucksPanel({ bookingId }: { bookingId: string }) {
   const inventoryItems = inventoryQuery.data ?? [];
   const latestInventory = inventoryItems[0] ?? null;
 
-  const edrTrucksQuery = useQuery({
-    queryKey: ["booking-edr-trucks", bookingId],
-    queryFn: () => warehouseService.getLastMileTrucks(bookingId),
-  });
-  const edrTrucks = edrTrucksQuery.data ?? [];
-
-  const customerTrucksQuery = useQuery({
-    queryKey: ["booking-customer-trucks", bookingId],
-    queryFn: () => warehouseService.getCustomerTrucks(bookingId),
-    enabled: edrTrucksQuery.isSuccess && edrTrucks.length === 0,
-  });
-  const customerTrucks = customerTrucksQuery.data ?? [];
-
-  const mode: "EDR" | "CUSTOMER" | "NONE" =
-    edrTrucks.length > 0 ? "EDR" : customerTrucks.length > 0 ? "CUSTOMER" : "NONE";
-
-  const containerItemsQuery = useQuery({
-    queryKey: ["booking-container-items-for-trucks", bookingId],
-    queryFn: () => warehouseService.getContainerItems(bookingId),
-  });
-  const inspectionByContainer = new Map(
-    (containerItemsQuery.data ?? []).map((c) => [c.containerNumber, c.inspectionStatus]),
+  // Same query key as the Unloaded Queue page — shares its cache instead of
+  // refetching the whole queue when it's already loaded elsewhere.
+  const unloadedQuery = useQuery(api.warehouses.importUnloadedQueue.queryOptions({}));
+  const bookingRows = useMemo(
+    () => (unloadedQuery.data ?? []).filter((row) => row.bookingId === bookingId),
+    [unloadedQuery.data, bookingId],
   );
-
-  const lastMileId = edrTrucks[0]?.lastMileId ?? null;
-
-  const detentionPreviewQuery = useQuery({
-    queryKey: ["truck-detention-preview-for-trucks-tab", lastMileId],
-    queryFn: () => lastMileService.truckDetentionPreview(lastMileId as string).then((r) => r.data),
-    enabled: Boolean(lastMileId),
-  });
-  const detentionPreview = detentionPreviewQuery.data;
-  const detentionByVehicle = new Map(
-    (detentionPreview?.groups ?? []).map((g) => [g.vehicleId ?? "", g]),
-  );
-
-  const lastMileRecordQuery = useQuery({
-    queryKey: ["last-mile-record-for-trucks-tab", lastMileId],
-    queryFn: () => lastMileService.getById(lastMileId as string).then((r) => r.data),
-    enabled: Boolean(lastMileId),
-  });
+  const group = useMemo(() => {
+    const [existing] = groupByBooking(bookingRows);
+    return (
+      existing ?? {
+        bookingId,
+        bookingReference: bookingId,
+        customerName: null,
+        trainSchedule: null,
+        status: "NONE",
+        arrivalTime: null,
+        rows: [],
+      }
+    );
+  }, [bookingRows, bookingId]);
 
   // Booking-level cost strip: same per-row fee preview the accrual dashboard
   // and FeePreviewModal already use, summed across every inventory row on
@@ -114,61 +63,7 @@ export function BookingTrucksPanel({ bookingId }: { bookingId: string }) {
   const sumByType = (type: string) =>
     allFees.filter((f) => f.ruleType === type).reduce((sum, f) => sum + Number(f.amount || 0), 0);
 
-  const rows: TruckRow[] = useMemo(() => {
-    if (mode === "EDR") {
-      return edrTrucks.map((t) => {
-        const g = detentionByVehicle.get(t.vehicleId);
-        return {
-          key: t.vehicleId,
-          plate: [t.truckPlateNumber, t.trailerPlateNumber].filter(Boolean).join(" + ") || "—",
-          driver: t.driverName,
-          truckType: t.truckType,
-          containers: t.containerNumber ? [t.containerNumber] : [],
-          warehouseArrived: t.arrivedAt,
-          warehouseDeparted: t.departedAt,
-          destinationArrived: g?.startDate ?? null,
-          returned: g?.endIsOpen ? null : g?.endDate ?? null,
-          detentionOpen: Boolean(g?.endIsOpen),
-          detentionDays: g?.chargeableDays ?? null,
-          detentionAmount: g?.amount ?? null,
-          hasDetentionRule: Boolean(g?.ruleId),
-          inspection: inspectionLabel(t.containerNumber ? inspectionByContainer.get(t.containerNumber) : undefined),
-        };
-      });
-    }
-    if (mode === "CUSTOMER") {
-      return customerTrucks.map((t) => {
-        const containers = (t.containers ?? []).map((c) => c.containerNumber);
-        const statuses = new Set(containers.map((cn) => inspectionByContainer.get(cn) ?? null));
-        const inspection =
-          containers.length === 0
-            ? inspectionLabel(undefined)
-            : statuses.size > 1
-              ? { text: "Mixed", color: "yellow" }
-              : inspectionLabel([...statuses][0]);
-        return {
-          key: t.id,
-          plate: t.plateNumber,
-          driver: t.driverName,
-          truckType: t.truckType,
-          containers,
-          warehouseArrived: t.arrivedAt ?? null,
-          warehouseDeparted: t.departedAt ?? null,
-          destinationArrived: null,
-          returned: null,
-          detentionOpen: false,
-          detentionDays: null,
-          detentionAmount: null,
-          hasDetentionRule: false,
-          inspection,
-        };
-      });
-    }
-    return [];
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [mode, edrTrucks, customerTrucks, inspectionByContainer, detentionByVehicle]);
-
-  if (inventoryQuery.isLoading || edrTrucksQuery.isLoading) {
+  if (inventoryQuery.isLoading || unloadedQuery.isLoading) {
     return (
       <Center py={60}>
         <Group gap={10}>
@@ -201,87 +96,14 @@ export function BookingTrucksPanel({ bookingId }: { bookingId: string }) {
         </SimpleGrid>
       </SectionCard>
 
-      <SectionCard
-        icon={Truck}
-        title="Trucks"
-        subtitle={
-          mode === "EDR" ? "EDR Last Mile" : mode === "CUSTOMER" ? "Customer Self-Haul" : undefined
-        }
-        accent="grape"
-        extra={
-          mode === "EDR" && (
-            <Button size="xs" variant="light" onClick={() => setDetentionModalOpen(true)}>
-              Detention times
-            </Button>
-          )
-        }
-      >
-        {rows.length === 0 ? (
-          <Text size="sm" c="dimmed" ta="center" py="md">
-            No trucks assigned to this booking's last mile yet.
-          </Text>
-        ) : (
-          <Table.ScrollContainer minWidth={1000}>
-            <Table verticalSpacing="xs" fz="xs">
-              <Table.Thead>
-                <Table.Tr>
-                  <Table.Th>Plate</Table.Th>
-                  <Table.Th>Driver</Table.Th>
-                  <Table.Th>Type</Table.Th>
-                  <Table.Th>Container(s)</Table.Th>
-                  <Table.Th>Wh. arrived</Table.Th>
-                  <Table.Th>Wh. departed</Table.Th>
-                  <Table.Th>Dest. arrived</Table.Th>
-                  <Table.Th>Returned</Table.Th>
-                  <Table.Th>Detention</Table.Th>
-                  <Table.Th>Inspection</Table.Th>
-                </Table.Tr>
-              </Table.Thead>
-              <Table.Tbody>
-                {rows.map((r) => (
-                  <Table.Tr key={r.key}>
-                    <Table.Td>{r.plate}</Table.Td>
-                    <Table.Td>{r.driver ?? "—"}</Table.Td>
-                    <Table.Td>{r.truckType ?? "—"}</Table.Td>
-                    <Table.Td>{r.containers.length ? r.containers.join(", ") : "—"}</Table.Td>
-                    <Table.Td>{fmt(r.warehouseArrived)}</Table.Td>
-                    <Table.Td>{fmt(r.warehouseDeparted)}</Table.Td>
-                    <Table.Td>{fmt(r.destinationArrived)}</Table.Td>
-                    <Table.Td>
-                      {r.detentionOpen ? (
-                        <Badge size="xs" color="orange" variant="light">
-                          still out
-                        </Badge>
-                      ) : (
-                        fmt(r.returned)
-                      )}
-                    </Table.Td>
-                    <Table.Td>
-                      {mode !== "EDR" || r.detentionDays == null ? (
-                        "—"
-                      ) : (
-                        <>
-                          {r.detentionDays}d · {money(r.detentionAmount ?? 0, detentionPreview?.currency ?? "USD")}
-                          {!r.hasDetentionRule && (
-                            <Text span size="xs" c="red">
-                              {" "}
-                              · no rule
-                            </Text>
-                          )}
-                        </>
-                      )}
-                    </Table.Td>
-                    <Table.Td>
-                      <Badge size="xs" variant="light" color={r.inspection.color}>
-                        {r.inspection.text}
-                      </Badge>
-                    </Table.Td>
-                  </Table.Tr>
-                ))}
-              </Table.Tbody>
-            </Table>
-          </Table.ScrollContainer>
-        )}
+      <SectionCard icon={Truck} title="Trucks" accent="grape">
+        <Table.ScrollContainer minWidth={1100}>
+          <Table verticalSpacing="xs" fz="xs">
+            <Table.Tbody>
+              <TruckRows group={group} />
+            </Table.Tbody>
+          </Table>
+        </Table.ScrollContainer>
       </SectionCard>
 
       <FeePreviewModal
@@ -289,13 +111,6 @@ export function BookingTrucksPanel({ bookingId }: { bookingId: string }) {
         onClose={() => setFeeModalOpen(false)}
         inventoryId={latestInventory?.id ?? null}
       />
-      {mode === "EDR" && (
-        <TruckDetentionModal
-          opened={detentionModalOpen}
-          onClose={() => setDetentionModalOpen(false)}
-          record={lastMileRecordQuery.data ?? null}
-        />
-      )}
     </Stack>
   );
 }
diff --git a/apps/edr-freight-web/backoffice/src/components/contracts/GlCreateBookingForm.tsx b/apps/edr-freight-web/backoffice/src/components/contracts/GlCreateBookingForm.tsx
index 27e1597c5..4a1cb402f 100644
--- a/apps/edr-freight-web/backoffice/src/components/contracts/GlCreateBookingForm.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/contracts/GlCreateBookingForm.tsx
@@ -172,11 +172,11 @@ function emptyUnit(): UnitDraft {
 function emptyLine(size: string): ContainerLineDraft {
   return {
     containerSize: size,
-    quantity: "1",
+    quantity: "0",
     hazardousQuantity: "0",
     reeferQuantity: "0",
     returnQuantity: "0",
-    units: [emptyUnit()],
+    units: [],
   };
 }
 
diff --git a/apps/edr-freight-web/backoffice/src/components/overview/OverviewQuickLinks.tsx b/apps/edr-freight-web/backoffice/src/components/overview/OverviewQuickLinks.tsx
deleted file mode 100644
index 4bc98e671..000000000
--- a/apps/edr-freight-web/backoffice/src/components/overview/OverviewQuickLinks.tsx
+++ /dev/null
@@ -1,90 +0,0 @@
-import { useNavigate } from "react-router-dom";
-import { ArrowRight, FileText, Train, Users } from "lucide-react";
-import { Card, Group, SimpleGrid, Stack, Text, ThemeIcon } from "@mantine/core";
-
-import { useAuth } from "@/auth/useAuth";
-import { FREIGHT_PERMS, hasPermission } from "@/lib/permissions";
-
-const links = [
-  {
-    title: "Booking requests",
-    description: "Review and action incoming freight bookings",
-    href: "/dashboard/booking-requests",
-    icon: FileText,
-    permission: [FREIGHT_PERMS.bookings.view],
-  },
-  {
-    title: "Train scheduling v2",
-    description: "Full allocation workflow — assign, pin wagons, finalize",
-    href: "/dashboard/operations/train-scheduling-v2",
-    icon: Train,
-    permission: [FREIGHT_PERMS.trainScheduling.view],
-  },
-  {
-    title: "Trains",
-    description: "Manage train master data and fleet status",
-    href: "/dashboard/trains",
-    icon: Train,
-    permission: [FREIGHT_PERMS.fleet.view, FREIGHT_PERMS.trains.view],
-  },
-  {
-    title: "User management",
-    description: "Employees, roles, and permissions",
-    href: "/user-management",
-    icon: Users,
-    permission: [
-      FREIGHT_PERMS.admin,
-      FREIGHT_PERMS.staff.roles.view,
-      FREIGHT_PERMS.staff.employeeRegistration.view,
-      FREIGHT_PERMS.staff.roleAssignment.view,
-    ],
-  },
-];
-
-export function OverviewQuickLinks() {
-  const navigate = useNavigate();
-  const { user } = useAuth();
-
-  const visible = links.filter((link) =>
-    link.permission.some((key) => hasPermission(user, key)),
-  );
-  if (!visible.length) return null;
-
-  return (
-    <Stack gap="md" h="100%">
-      <Text fw={600}>Quick links</Text>
-      <SimpleGrid cols={{ base: 1, sm: 2 }} spacing="sm">
-        {visible.map((link) => {
-          const Icon = link.icon;
-          return (
-            <Card
-              key={link.href}
-              p="md"
-              radius="lg"
-              withBorder
-              style={{ cursor: "pointer" }}
-              onClick={() => navigate(link.href)}
-            >
-              <Group justify="space-between" align="flex-start" wrap="nowrap">
-                <Group align="flex-start" gap="sm" wrap="nowrap">
-                  <ThemeIcon variant="light" color="edr-green" size="lg" radius="md">
-                    <Icon size={18} />
-                  </ThemeIcon>
-                  <Stack gap={2}>
-                    <Text fw={600} size="sm">
-                      {link.title}
-                    </Text>
-                    <Text size="xs" c="dimmed">
-                      {link.description}
-                    </Text>
-                  </Stack>
-                </Group>
-                <ArrowRight size={16} color="var(--mantine-color-gray-5)" />
-              </Group>
-            </Card>
-          );
-        })}
-      </SimpleGrid>
-    </Stack>
-  );
-}
diff --git a/apps/edr-freight-web/backoffice/src/components/overview/OverviewStackedBarChart.tsx b/apps/edr-freight-web/backoffice/src/components/overview/OverviewStackedBarChart.tsx
new file mode 100644
index 000000000..be913f5f0
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/components/overview/OverviewStackedBarChart.tsx
@@ -0,0 +1,82 @@
+import {
+  Bar,
+  BarChart,
+  CartesianGrid,
+  Legend,
+  ResponsiveContainer,
+  Tooltip,
+  XAxis,
+  YAxis,
+} from "recharts";
+import { Paper, Stack, Text } from "@mantine/core";
+
+export interface StackedBarSeries {
+  /** Key into each data row holding this series' value. */
+  key: string;
+  label: string;
+  color: string;
+}
+
+interface OverviewStackedBarChartProps<T extends object> {
+  title: string;
+  data: T[];
+  /** Fixed order + fixed color per series — colors follow the entity, not the rank. */
+  series: StackedBarSeries[];
+  xKey?: string;
+  emptyMessage?: string;
+  formatXLabel?: (value: string) => string;
+}
+
+export function OverviewStackedBarChart<T extends object>({
+  title,
+  data,
+  series,
+  xKey = "date",
+  emptyMessage = "No data available",
+  formatXLabel,
+}: OverviewStackedBarChartProps<T>) {
+  const hasData = data.some((row) =>
+    series.some((s) => Number((row as Record<string, unknown>)[s.key]) > 0),
+  );
+
+  return (
+    <Paper p="md" radius="lg" withBorder h="100%" style={{ minHeight: 260 }}>
+      <Stack gap="sm" h="100%">
+        <Text fw={600}>{title}</Text>
+        {!hasData ? (
+          <Text size="sm" c="dimmed" ta="center" py="xl">
+            {emptyMessage}
+          </Text>
+        ) : (
+          <ResponsiveContainer width="100%" height={230}>
+            <BarChart data={data} margin={{ top: 8, right: 8, left: 0, bottom: 0 }}>
+              <CartesianGrid strokeDasharray="3 3" stroke="#e5e7eb" vertical={false} />
+              <XAxis
+                dataKey={xKey}
+                tickFormatter={formatXLabel}
+                tick={{ fontSize: 11 }}
+                stroke="#94a3b8"
+              />
+              <YAxis allowDecimals={false} tick={{ fontSize: 12 }} stroke="#94a3b8" />
+              <Tooltip labelFormatter={formatXLabel && ((v) => formatXLabel(String(v)))} />
+              <Legend iconType="circle" iconSize={9} />
+              {series.map((s, index) => (
+                <Bar
+                  key={s.key}
+                  dataKey={s.key}
+                  name={s.label}
+                  stackId="stack"
+                  fill={s.color}
+                  stroke="#ffffff"
+                  strokeWidth={1}
+                  barSize={18}
+                  radius={index === series.length - 1 ? [4, 4, 0, 0] : undefined}
+                />
+              ))}
+            </BarChart>
+          </ResponsiveContainer>
+        )}
+      </Stack>
+    </Paper>
+  );
+}
diff --git a/apps/edr-freight-web/backoffice/src/components/overview/OverviewTabContent.tsx b/apps/edr-freight-web/backoffice/src/components/overview/OverviewTabContent.tsx
index 13a357cce..cf71198a6 100644
--- a/apps/edr-freight-web/backoffice/src/components/overview/OverviewTabContent.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/overview/OverviewTabContent.tsx
@@ -14,6 +14,7 @@ import { OverviewBillingTabPanel } from "./tabs/OverviewBillingTabPanel";
 import { OverviewBookingsTabPanel } from "./tabs/OverviewBookingsTabPanel";
 import { OverviewContractsTabPanel } from "./tabs/OverviewContractsTabPanel";
 import { OverviewCustomersTabPanel } from "./tabs/OverviewCustomersTabPanel";
+import { OverviewFleetTabPanel } from "./tabs/OverviewFleetTabPanel";
 import { OverviewOperationsTabPanel } from "./tabs/OverviewOperationsTabPanel";
 import { OverviewStaffTabPanel } from "./tabs/OverviewStaffTabPanel";
 
@@ -36,7 +37,12 @@ export function OverviewTabContent({ tab, range }: OverviewTabContentProps) {
   const bookings = useOverviewBookingsTab(range, tab === "bookings");
   const contracts = useOverviewContractsTab(range, tab === "contracts");
   const billing = useOverviewBillingTab(range, tab === "billing");
-  const operations = useOverviewOperationsTab(tab === "operations");
+  // Fleet reuses the operations dataset — same query key, so switching between
+  // the two tabs costs one fetch.
+  const operations = useOverviewOperationsTab(
+    range,
+    tab === "operations" || tab === "fleet",
+  );
   const customers = useOverviewCustomersTab(range, tab === "customers");
   const staff = useOverviewStaffTab(range, tab === "staff");
 
@@ -47,7 +53,7 @@ export function OverviewTabContent({ tab, range }: OverviewTabContentProps) {
         ? contracts
         : tab === "billing"
           ? billing
-          : tab === "operations"
+          : tab === "operations" || tab === "fleet"
             ? operations
             : tab === "customers"
               ? customers
@@ -99,6 +105,9 @@ export function OverviewTabContent({ tab, range }: OverviewTabContentProps) {
       {tab === "operations" && operations.data && (
         <OverviewOperationsTabPanel data={operations.data} />
       )}
+      {tab === "fleet" && operations.data && (
+        <OverviewFleetTabPanel data={operations.data} />
+      )}
       {tab === "customers" && customers.data && (
         <OverviewCustomersTabPanel data={customers.data} />
       )}
diff --git a/apps/edr-freight-web/backoffice/src/components/overview/tabs/OverviewBookingsTabPanel.tsx b/apps/edr-freight-web/backoffice/src/components/overview/tabs/OverviewBookingsTabPanel.tsx
index c294a5199..cacba63e1 100644
--- a/apps/edr-freight-web/backoffice/src/components/overview/tabs/OverviewBookingsTabPanel.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/overview/tabs/OverviewBookingsTabPanel.tsx
@@ -24,6 +24,13 @@ export function OverviewBookingsTabPanel({ data }: OverviewBookingsTabPanelProps
     <Stack gap="lg">
       <OverviewKpiStrip
         items={[
+          {
+            label: "Total bookings",
+            value: data.kpis.total,
+            icon: FileText,
+            accent: "gold",
+            hint: "All time",
+          },
           {
             label: "Active bookings",
             value: data.kpis.totalActive,
@@ -71,7 +78,7 @@ export function OverviewBookingsTabPanel({ data }: OverviewBookingsTabPanelProps
       </Grid>
 
       <Grid gap="md">
-        <Grid.Col span={{ base: 12, md: 6 }}>
+        <Grid.Col span={{ base: 12, md: 4 }}>
           <OverviewDonutChart
             title="By status"
             data={data.bookingsByStatus.map((item) => ({
@@ -81,10 +88,20 @@ export function OverviewBookingsTabPanel({ data }: OverviewBookingsTabPanelProps
             emptyMessage="No bookings yet"
           />
         </Grid.Col>
-        <Grid.Col span={{ base: 12, md: 6 }}>
-          <OverviewDonutChart
+        <Grid.Col span={{ base: 12, md: 4 }}>
+          <OverviewHorizontalBarChart
             title="By freight type"
             data={data.bookingsByFreightType.map((item) => ({
+              label: item.label,
+              value: item.count,
+            }))}
+            valueLabel="Bookings"
+          />
+        </Grid.Col>
+        <Grid.Col span={{ base: 12, md: 4 }}>
+          <OverviewDonutChart
+            title="By payment currency"
+            data={data.bookingsByCurrency.map((item) => ({
               name: item.label,
               value: item.count,
             }))}
@@ -92,14 +109,6 @@ export function OverviewBookingsTabPanel({ data }: OverviewBookingsTabPanelProps
         </Grid.Col>
       </Grid>
 
-      <OverviewHorizontalBarChart
-        title="By payment currency"
-        data={data.bookingsByCurrency.map((item) => ({
-          label: item.label,
-          value: item.count,
-        }))}
-      />
-
       <OverviewRecentBookingsTable bookings={data.recentBookings} />
     </Stack>
   );
diff --git a/apps/edr-freight-web/backoffice/src/components/overview/tabs/OverviewContractsTabPanel.tsx b/apps/edr-freight-web/backoffice/src/components/overview/tabs/OverviewContractsTabPanel.tsx
index 9786b11e2..e185f40d2 100644
--- a/apps/edr-freight-web/backoffice/src/components/overview/tabs/OverviewContractsTabPanel.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/overview/tabs/OverviewContractsTabPanel.tsx
@@ -41,6 +41,13 @@ export function OverviewContractsTabPanel({
     <Stack gap="lg">
       <OverviewKpiStrip
         items={[
+          {
+            label: "Total contracts",
+            value: data.kpis.total,
+            icon: FileSignature,
+            accent: "gold",
+            hint: "All time",
+          },
           {
             label: "Active contracts",
             value: data.kpis.totalActive,
@@ -94,7 +101,7 @@ export function OverviewContractsTabPanel({
       </Grid>
 
       <Grid gap="md">
-        <Grid.Col span={{ base: 12, md: 6 }}>
+        <Grid.Col span={{ base: 12, md: 4 }}>
           <OverviewDonutChart
             title="By status"
             data={data.contractsByStatus.map((item) => ({
@@ -104,7 +111,7 @@ export function OverviewContractsTabPanel({
             emptyMessage="No contracts yet"
           />
         </Grid.Col>
-        <Grid.Col span={{ base: 12, md: 6 }}>
+        <Grid.Col span={{ base: 12, md: 4 }}>
           <OverviewDonutChart
             title="By kind"
             data={data.contractsByKind.map((item) => ({
@@ -113,16 +120,17 @@ export function OverviewContractsTabPanel({
             }))}
           />
         </Grid.Col>
+        <Grid.Col span={{ base: 12, md: 4 }}>
+          <OverviewDonutChart
+            title="By freight type"
+            data={data.contractsByFreightType.map((item) => ({
+              name: item.label === "CONTAINER" ? "Container" : "Bulk",
+              value: item.count,
+            }))}
+          />
+        </Grid.Col>
       </Grid>
 
-      <OverviewHorizontalBarChart
-        title="By freight type"
-        data={data.contractsByFreightType.map((item) => ({
-          label: item.label === "CONTAINER" ? "Container" : "Bulk",
-          value: item.count,
-        }))}
-      />
-
       <OverviewRecentContractsTable contracts={data.recentContracts} />
     </Stack>
   );
diff --git a/apps/edr-freight-web/backoffice/src/components/overview/tabs/OverviewFleetTabPanel.tsx b/apps/edr-freight-web/backoffice/src/components/overview/tabs/OverviewFleetTabPanel.tsx
new file mode 100644
index 000000000..5949b93e7
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/components/overview/tabs/OverviewFleetTabPanel.tsx
@@ -0,0 +1,115 @@
+import { Train, Truck, Wrench } from "lucide-react";
+import { Grid, Stack } from "@mantine/core";
+
+import type { IOverviewOperationsTab, IOverviewStatusCount } from "@/types/overview";
+import { OverviewDonutChart } from "../OverviewDonutChart";
+import { OverviewHorizontalBarChart } from "../OverviewHorizontalBarChart";
+import { OverviewKpiStrip } from "../OverviewKpiStrip";
+
+function formatStatusLabel(status: string) {
+  return status
+    .replace(/_/g, " ")
+    .toLowerCase()
+    .replace(/\b\w/g, (char) => char.toUpperCase());
+}
+
+function sumCounts(items: IOverviewStatusCount[]) {
+  return items.reduce((sum, item) => sum + item.count, 0);
+}
+
+function countByStatus(items: IOverviewStatusCount[], status: string) {
+  return items.find((item) => item.status === status)?.count ?? 0;
+}
+
+function toDonutData(items: IOverviewStatusCount[]) {
+  return items.map((item) => ({
+    name: formatStatusLabel(item.status),
+    value: item.count,
+  }));
+}
+
+interface OverviewFleetTabPanelProps {
+  data: IOverviewOperationsTab;
+}
+
+export function OverviewFleetTabPanel({ data }: OverviewFleetTabPanelProps) {
+  return (
+    <Stack gap="lg">
+      <OverviewKpiStrip
+        items={[
+          {
+            label: "Total trains",
+            value: sumCounts(data.trainStatusBreakdown),
+            icon: Train,
+            accent: "gold",
+            hint: "All time",
+          },
+          {
+            label: "Active trains",
+            value: data.kpis.trainsActive,
+            icon: Train,
+            accent: "emerald",
+          },
+          {
+            label: "Total wagons",
+            value: sumCounts(data.wagonStatusBreakdown),
+            icon: Truck,
+            accent: "gold",
+            hint: "All time",
+          },
+          {
+            label: "Wagons available",
+            value: data.kpis.wagonsAvailable,
+            icon: Truck,
+            accent: "emerald",
+          },
+          {
+            label: "In maintenance",
+            value: countByStatus(data.wagonStatusBreakdown, "MAINTENANCE"),
+            icon: Wrench,
+            accent: "amber",
+          },
+        ]}
+      />
+
+      <Grid gap="md">
+        <Grid.Col span={{ base: 12, md: 6 }}>
+          <OverviewHorizontalBarChart
+            title="Wagon fleet by type"
+            data={data.wagonsByType.map((item) => ({
+              label: item.label,
+              value: item.count,
+            }))}
+            valueLabel="Wagons"
+          />
+        </Grid.Col>
+        <Grid.Col span={{ base: 12, md: 6 }}>
+          <OverviewHorizontalBarChart
+            title="Wagons by yard"
+            data={data.wagonsByYard.map((item) => ({
+              label: item.label,
+              value: item.count,
+            }))}
+            valueLabel="Wagons"
+            emptyMessage="No wagons assigned to yards"
+          />
+        </Grid.Col>
+      </Grid>
+
+      <Grid gap="md">
+        <Grid.Col span={{ base: 12, md: 6 }}>
+          <OverviewDonutChart
+            title="Train status"
+            data={toDonutData(data.trainStatusBreakdown)}
+          />
+        </Grid.Col>
+        <Grid.Col span={{ base: 12, md: 6 }}>
+          <OverviewDonutChart
+            title="Wagon status"
+            data={toDonutData(data.wagonStatusBreakdown)}
+          />
+        </Grid.Col>
+      </Grid>
+    </Stack>
+  );
+}
diff --git a/apps/edr-freight-web/backoffice/src/components/overview/tabs/OverviewOperationsTabPanel.tsx b/apps/edr-freight-web/backoffice/src/components/overview/tabs/OverviewOperationsTabPanel.tsx
index 355fb6b57..675a81b32 100644
--- a/apps/edr-freight-web/backoffice/src/components/overview/tabs/OverviewOperationsTabPanel.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/overview/tabs/OverviewOperationsTabPanel.tsx
@@ -1,13 +1,25 @@
-import { Box, Container as ContainerIcon, Train, Truck } from "lucide-react";
+import {
+  Box,
+  CalendarClock,
+  Container as ContainerIcon,
+  Send,
+  Train,
+  Truck,
+} from "lucide-react";
 import { Grid, Stack } from "@mantine/core";
 
 import type { IOverviewOperationsTab } from "@/types/overview";
 import { OverviewDonutChart } from "../OverviewDonutChart";
+import { OverviewHorizontalBarChart } from "../OverviewHorizontalBarChart";
 import { OverviewKpiStrip } from "../OverviewKpiStrip";
+import { OverviewStackedBarChart } from "../OverviewStackedBarChart";
 
-interface OverviewOperationsTabPanelProps {
-  data: IOverviewOperationsTab;
-}
+/** Fixed direction colors (CVD-validated pair + violet): color follows the entity. */
+const DIRECTION_SERIES = [
+  { key: "exportCount", label: "Export", color: "#D98A0B" },
+  { key: "importCount", label: "Import", color: "#0369a1" },
+  { key: "domesticCount", label: "Domestic", color: "#7c3aed" },
+];
 
 function formatStatusLabel(status: string) {
   return status
@@ -16,6 +28,22 @@ function formatStatusLabel(status: string) {
     .replace(/\b\w/g, (char) => char.toUpperCase());
 }
 
+function formatDateLabel(date: string) {
+  const parsed = new Date(`${date}T00:00:00`);
+  return parsed.toLocaleDateString(undefined, { month: "short", day: "numeric" });
+}
+
+function toDonutData(items: { status: string; count: number }[]) {
+  return items.map((item) => ({
+    name: formatStatusLabel(item.status),
+    value: item.count,
+  }));
+}
+
+interface OverviewOperationsTabPanelProps {
+  data: IOverviewOperationsTab;
+}
+
 export function OverviewOperationsTabPanel({ data }: OverviewOperationsTabPanelProps) {
   return (
     <Stack gap="lg">
@@ -27,6 +55,19 @@ export function OverviewOperationsTabPanel({ data }: OverviewOperationsTabPanelP
             icon: Train,
             accent: "emerald",
           },
+          {
+            label: "Upcoming departures",
+            value: data.kpis.schedulesUpcoming,
+            icon: CalendarClock,
+            accent: "sky",
+            hint: "Scheduled, not yet departed",
+          },
+          {
+            label: "Dispatched today",
+            value: data.kpis.dispatchedToday,
+            icon: Send,
+            accent: "amber",
+          },
           {
             label: "Wagons available",
             value: data.kpis.wagonsAvailable,
@@ -46,40 +87,58 @@ export function OverviewOperationsTabPanel({ data }: OverviewOperationsTabPanelP
       />
 
       <Grid gap="md">
-        <Grid.Col span={{ base: 12, md: 6 }}>
+        <Grid.Col span={{ base: 12, lg: 8 }}>
+          <OverviewStackedBarChart
+            title="Train departures by direction"
+            data={data.departureTrend}
+            series={DIRECTION_SERIES}
+            formatXLabel={formatDateLabel}
+            emptyMessage="No scheduled departures in this period"
+          />
+        </Grid.Col>
+        <Grid.Col span={{ base: 12, lg: 4 }}>
           <OverviewDonutChart
-            title="Train status"
-            data={data.trainStatusBreakdown.map((item) => ({
-              name: formatStatusLabel(item.status),
-              value: item.count,
+            title="Schedule status"
+            data={toDonutData(data.scheduleStatusBreakdown)}
+            emptyMessage="No train schedules yet"
+          />
+        </Grid.Col>
+      </Grid>
+
+      <Grid gap="md">
+        <Grid.Col span={{ base: 12, md: 6 }}>
+          <OverviewHorizontalBarChart
+            title="Cargo tonnage by type"
+            data={data.cargoTonnageByType.map((item) => ({
+              label: item.label,
+              value: item.tons,
             }))}
+            valueLabel="Tons"
+            emptyMessage="No cargo recorded"
           />
         </Grid.Col>
         <Grid.Col span={{ base: 12, md: 6 }}>
           <OverviewDonutChart
-            title="Wagon status"
-            data={data.wagonStatusBreakdown.map((item) => ({
-              name: formatStatusLabel(item.status),
+            title="Containers by size"
+            data={data.containersBySize.map((item) => ({
+              name: item.label,
               value: item.count,
             }))}
           />
         </Grid.Col>
+      </Grid>
+
+      <Grid gap="md">
         <Grid.Col span={{ base: 12, md: 6 }}>
           <OverviewDonutChart
             title="Container status"
-            data={data.containerStatusBreakdown.map((item) => ({
-              name: formatStatusLabel(item.status),
-              value: item.count,
-            }))}
+            data={toDonutData(data.containerStatusBreakdown)}
           />
         </Grid.Col>
         <Grid.Col span={{ base: 12, md: 6 }}>
           <OverviewDonutChart
             title="Cargo status"
-            data={data.cargoStatusBreakdown.map((item) => ({
-              name: formatStatusLabel(item.status),
-              value: item.count,
-            }))}
+            data={toDonutData(data.cargoStatusBreakdown)}
           />
         </Grid.Col>
       </Grid>
diff --git a/apps/edr-freight-web/backoffice/src/components/profile/MySignatureCard.tsx b/apps/edr-freight-web/backoffice/src/components/profile/MySignatureCard.tsx
index ca9effd27..0a70b3aec 100644
--- a/apps/edr-freight-web/backoffice/src/components/profile/MySignatureCard.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/profile/MySignatureCard.tsx
@@ -1,5 +1,5 @@
 import { useState } from "react";
-import { FileSignature, Loader2 } from "lucide-react";
+import { FileSignature, Loader2, Stamp } from "lucide-react";
 import { useMutation, useQuery } from "@tanstack/react-query";
 import toast from "react-hot-toast";
 
@@ -27,9 +27,9 @@ import {
 } from "@edr/ui-common";
 
 /**
- * Lets the signed-in user view and update the reusable signature stored on
- * their profile. The same signature is offered for approval when signing a
- * booking contract.
+ * Lets the signed-in user view and update the reusable signature and company
+ * stamp stored on their profile — managed independently of each other. Both
+ * are offered when signing a booking contract.
  */
 export function MySignatureCard() {
   const { user } = useAuth();
@@ -38,42 +38,63 @@ export function MySignatureCard() {
   );
   const saveMutation = useMutation(api.signatures.save.mutationOptions());
 
-  const [open, setOpen] = useState(false);
+  const [signatureOpen, setSignatureOpen] = useState(false);
+  const [stampOpen, setStampOpen] = useState(false);
   const [signerName, setSignerName] = useState("");
   const [signatureData, setSignatureData] = useState<string | null>(null);
   const [stampData, setStampData] = useState<string | null>(null);
 
   const defaultName =
     user?.name?.en || user?.username || user?.email || "";
+  const savedName = saved?.signerDisplayName ?? defaultName;
 
-  const openDialog = () => {
-    setSignerName(saved?.signerDisplayName ?? defaultName);
+  const openSignatureDialog = () => {
+    setSignerName(savedName);
     setSignatureData(null);
-    setStampData(saved?.stampImageUrl ?? null);
-    setOpen(true);
+    setSignatureOpen(true);
   };
 
-  const save = () => {
+  const saveSignature = () => {
     if (!signatureData || !signerName.trim()) return;
     saveMutation.mutate(
       {
         signerDisplayName: signerName.trim(),
         signatureImageBase64: signatureData,
-        // Only send the stamp when it changed — omitted keeps the saved one.
-        ...(stampData && stampData !== saved?.stampImageUrl
-          ? { stampImageBase64: stampData }
-          : {}),
+        // Stamp untouched — it is managed by its own dialog.
       },
       {
         onSuccess: () => {
           toast.success("Signature saved");
-          setOpen(false);
+          setSignatureOpen(false);
         },
         onError: () => toast.error("Failed to save signature"),
       },
     );
   };
 
+  const openStampDialog = () => {
+    setStampData(saved?.stampImageUrl ?? null);
+    setStampOpen(true);
+  };
+
+  const saveStamp = () => {
+    if (!stampData) return;
+    saveMutation.mutate(
+      {
+        signerDisplayName: savedName || defaultName,
+        // Signature untouched — stamp-only update.
+        stampImageBase64: stampData,
+      },
+      {
+        onSuccess: () => {
+          toast.success("Stamp saved");
+          setStampOpen(false);
+        },
+        onError: () => toast.error("Failed to save stamp"),
+      },
+    );
+  };
+
   return (
     <Card>
       <CardHeader>
@@ -85,47 +106,64 @@ export function MySignatureCard() {
           This signature can be reused to sign booking contracts.
         </CardDescription>
       </CardHeader>
-      <CardContent className="space-y-4">
+      <CardContent className="space-y-6">
         {isLoading ? (
           <div className="flex h-36 items-center justify-center">
             <Loader2 className="size-6 animate-spin text-primary" />
           </div>
-        ) : saved?.signatureImageUrl ? (
-          <div className="space-y-2">
-            <div className="overflow-hidden rounded-lg border-2 border-dashed border-border bg-white">
-              <img
-                src={saved.signatureImageUrl}
-                alt="My saved signature"
-                className="mx-auto h-36 w-full object-contain"
-              />
-            </div>
-            <p className="text-xs text-muted-foreground">
-              Saved as {saved.signerDisplayName}
-            </p>
-          </div>
         ) : (
-          <p className="text-sm text-muted-foreground">
-            You have not saved a signature yet.
-          </p>
-        )}
-        {saved?.stampImageUrl && (
-          <div className="space-y-2">
-            <div className="overflow-hidden rounded-lg border-2 border-dashed border-border bg-white">
-              <img
-                src={saved.stampImageUrl}
-                alt="My saved company stamp"
-                className="mx-auto h-24 w-full object-contain"
-              />
+          <>
+            <div className="space-y-2">
+              {saved?.signatureImageUrl ? (
+                <>
+                  <div className="overflow-hidden rounded-lg border-2 border-dashed border-border bg-white">
+                    <img
+                      src={saved.signatureImageUrl}
+                      alt="My saved signature"
+                      className="mx-auto h-36 w-full object-contain"
+                    />
+                  </div>
+                  <p className="text-xs text-muted-foreground">
+                    Saved as {saved.signerDisplayName}
+                  </p>
+                </>
+              ) : (
+                <p className="text-sm text-muted-foreground">
+                  You have not saved a signature yet.
+                </p>
+              )}
+              <Button variant="outline" size="sm" onClick={openSignatureDialog}>
+                {saved?.signatureImageUrl ? "Update signature" : "Add signature"}
+              </Button>
             </div>
-            <p className="text-xs text-muted-foreground">Company stamp</p>
-          </div>
+
+            <div className="space-y-2">
+              {saved?.stampImageUrl ? (
+                <>
+                  <div className="overflow-hidden rounded-lg border-2 border-dashed border-border bg-white">
+                    <img
+                      src={saved.stampImageUrl}
+                      alt="My saved company stamp"
+                      className="mx-auto h-24 w-full object-contain"
+                    />
+                  </div>
+                  <p className="text-xs text-muted-foreground">Company stamp</p>
+                </>
+              ) : (
+                <p className="text-sm text-muted-foreground">
+                  You have not uploaded a company stamp yet.
+                </p>
+              )}
+              <Button variant="outline" size="sm" onClick={openStampDialog}>
+                <Stamp className="size-4" />
+                {saved?.stampImageUrl ? "Update stamp" : "Upload stamp"}
+              </Button>
+            </div>
+          </>
         )}
-        <Button variant="outline" size="sm" onClick={openDialog}>
-          {saved?.signatureImageUrl ? "Update signature" : "Add signature"}
-        </Button>
       </CardContent>
 
-      <Dialog open={open} onOpenChange={setOpen}>
+      <Dialog open={signatureOpen} onOpenChange={setSignatureOpen}>
         <DialogContent className="sm:max-w-md">
           <DialogHeader>
             <DialogTitle>Save your signature</DialogTitle>
@@ -145,21 +183,16 @@ export function MySignatureCard() {
               />
             </div>
             <ContractSignaturePad onChange={setSignatureData} />
-            <StampUpload
-              value={stampData}
-              onChange={setStampData}
-              description="Stored on your profile and prefilled when you sign contracts."
-            />
           </div>
           <DialogFooter>
-            <Button variant="outline" onClick={() => setOpen(false)}>
+            <Button variant="outline" onClick={() => setSignatureOpen(false)}>
               Cancel
             </Button>
             <Button
               disabled={
                 saveMutation.isPending || !signatureData || !signerName.trim()
               }
-              onClick={save}
+              onClick={saveSignature}
             >
               {saveMutation.isPending ? (
                 <Loader2 className="size-4 animate-spin" />
@@ -170,6 +203,39 @@ export function MySignatureCard() {
           </DialogFooter>
         </DialogContent>
       </Dialog>
+
+      <Dialog open={stampOpen} onOpenChange={setStampOpen}>
+        <DialogContent className="sm:max-w-md">
+          <DialogHeader>
+            <DialogTitle>Company stamp</DialogTitle>
+            <DialogDescription>
+              Upload your official company stamp or seal as an image. It is
+              stored on your profile and applied next to your signature on
+              contracts.
+            </DialogDescription>
+          </DialogHeader>
+          <StampUpload
+            value={stampData}
+            onChange={setStampData}
+            description="Stored on your profile and prefilled when you sign contracts."
+          />
+          <DialogFooter>
+            <Button variant="outline" onClick={() => setStampOpen(false)}>
+              Cancel
+            </Button>
+            <Button
+              disabled={saveMutation.isPending || !stampData}
+              onClick={saveStamp}
+            >
+              {saveMutation.isPending ? (
+                <Loader2 className="size-4 animate-spin" />
+              ) : (
+                "Save stamp"
+              )}
+            </Button>
+          </DialogFooter>
+        </DialogContent>
+      </Dialog>
     </Card>
   );
 }
diff --git a/apps/edr-freight-web/backoffice/src/components/trainScheduling/CreateScheduleWindowFields.tsx b/apps/edr-freight-web/backoffice/src/components/trainScheduling/CreateScheduleWindowFields.tsx
new file mode 100644
index 000000000..b0de39baa
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/components/trainScheduling/CreateScheduleWindowFields.tsx
@@ -0,0 +1,366 @@
+import { useEffect, useMemo, useState } from "react";
+import {
+  Alert,
+  Badge,
+  Box,
+  Divider,
+  Group,
+  Loader,
+  NumberInput,
+  Select,
+  Stack,
+  Switch,
+  Text,
+} from "@mantine/core";
+import { useQuery } from "@tanstack/react-query";
+import { Info, Moon, Sun } from "lucide-react";
+
+import DurationField from "@/components/trainScheduling/DurationField";
+import { trainSchedulingService } from "@/services/trainScheduling.service";
+import type { CreateScheduleWindowRulePayload } from "@/types/trainScheduling";
+
+/** Fallbacks matching the API's global-rules defaults (used if the fetch fails). */
+const DEFAULTS = {
+  windowOpenHour: 8,
+  windowCloseHour: 17,
+  windowDurationHours: 3,
+  docReviewMinutes: 30,
+  paymentWindowMinutes: 60,
+  importWindowLeadDays: 3,
+  exportBookingLeadHours: 24,
+};
+
+/** 12-hour label for an EAT hour 0–23, e.g. 8 → "8:00 AM", 17 → "5:00 PM". */
+function hourLabel(hour: number): string {
+  const period = hour < 12 ? "AM" : "PM";
+  const h12 = hour % 12 === 0 ? 12 : hour % 12;
+  return `${h12}:00 ${period}`;
+}
+
+const HOUR_OPTIONS = Array.from({ length: 24 }, (_, h) => ({
+  value: String(h),
+  label: `${hourLabel(h)}  ·  ${String(h).padStart(2, "0")}:00`,
+}));
+
+export interface WindowFormState {
+  windowOpenHour: number;
+  windowCloseHour: number;
+  windowDurationHours: number | "";
+  docReviewMinutes: number | "";
+  paymentWindowMinutes: number | "";
+  importWindowLeadDays: number | "";
+  exportBookingLeadHours: number | "";
+  /** Blank = close exactly at departure. */
+  closeOffsetMinutes: number | "";
+}
+
+/**
+ * Builds the create payload from form state, or returns an error message when a
+ * required field was left blank. The close offset is direction-scoped: only the
+ * offset matching this schedule's direction is sent, since the other is never read.
+ */
+export function buildWindowRulePayload(
+  form: WindowFormState,
+  isExport: boolean,
+): { payload: CreateScheduleWindowRulePayload } | { error: string } {
+  const duration = Number(form.windowDurationHours);
+  const doc = Number(form.docReviewMinutes);
+  const pay = Number(form.paymentWindowMinutes);
+  const lead = Number(form.importWindowLeadDays);
+  const exportLead = Number(form.exportBookingLeadHours);
+
+  const leadInvalid = isExport
+    ? form.exportBookingLeadHours === "" || !Number.isFinite(exportLead) || exportLead < 1
+    : form.importWindowLeadDays === "" || !Number.isFinite(lead);
+  if (
+    form.windowDurationHours === "" ||
+    form.docReviewMinutes === "" ||
+    form.paymentWindowMinutes === "" ||
+    !Number.isFinite(duration) ||
+    !Number.isFinite(doc) ||
+    !Number.isFinite(pay) ||
+    leadInvalid
+  ) {
+    return { error: "Fill every booking-window field, or turn the toggle off" };
+  }
+
+  // Blank offset = close at departure. Sent as null (not omitted) so it wins
+  // over a non-null global offset.
+  const offset = form.closeOffsetMinutes === "" ? null : Number(form.closeOffsetMinutes);
+
+  return {
+    payload: {
+      windowOpenHour: form.windowOpenHour,
+      windowCloseHour: form.windowCloseHour,
+      windowDurationHours: duration,
+      docReviewMinutes: doc,
+      paymentWindowMinutes: pay,
+      ...(isExport
+        ? { exportBookingLeadHours: exportLead, exportCloseOffsetMinutes: offset }
+        : { importWindowLeadDays: lead, importCloseOffsetMinutes: offset }),
+    },
+  };
+}
+
+export interface CreateScheduleWindowFieldsProps {
+  /** Direction of the selected route — picks lead/offset semantics. */
+  isExport: boolean;
+  form: WindowFormState | null;
+  onChange: (next: WindowFormState) => void;
+}
+
+/**
+ * Booking-window settings for a schedule being created. Prefills from the live
+ * global rules (so the fields show what the schedule WOULD inherit), then lets
+ * staff tune them for this one train. Mirrors BookingWindowSettingsModal, plus
+ * the booking-close offset.
+ */
+export default function CreateScheduleWindowFields({
+  isExport,
+  form,
+  onChange,
+}: CreateScheduleWindowFieldsProps) {
+  const rulesQuery = useQuery({
+    queryKey: ["train-scheduling", "global-rules"],
+    queryFn: () => trainSchedulingService.getGlobalRules(),
+    staleTime: 5 * 60_000,
+  });
+
+  // Seed once from the global rules, so the toggle opens on the values this
+  // schedule would otherwise inherit rather than on hardcoded guesses.
+  const [seeded, setSeeded] = useState(false);
+  useEffect(() => {
+    if (seeded || form != null) return;
+    const r = rulesQuery.data;
+    if (!r && rulesQuery.isLoading) return;
+    const num = (v: unknown, fallback: number) => {
+      const n = v == null || v === "" ? NaN : Number(v);
+      return Number.isFinite(n) ? n : fallback;
+    };
+    const offset = isExport
+      ? (r as { exportCloseOffsetMinutes?: number | null } | undefined)
+          ?.exportCloseOffsetMinutes
+      : (r as { importCloseOffsetMinutes?: number | null } | undefined)
+          ?.importCloseOffsetMinutes;
+    onChange({
+      windowOpenHour: num(r?.windowOpenHour, DEFAULTS.windowOpenHour),
+      windowCloseHour: num(r?.windowCloseHour, DEFAULTS.windowCloseHour),
+      windowDurationHours: num(r?.windowDurationHours, DEFAULTS.windowDurationHours),
+      docReviewMinutes: num(r?.docReviewMinutes, DEFAULTS.docReviewMinutes),
+      paymentWindowMinutes: num(
+        isExport
+          ? (r as { exportPaymentWindowMinutes?: number } | undefined)
+              ?.exportPaymentWindowMinutes
+          : r?.paymentWindowMinutes,
+        DEFAULTS.paymentWindowMinutes,
+      ),
+      importWindowLeadDays: num(r?.importWindowLeadDays, DEFAULTS.importWindowLeadDays),
+      exportBookingLeadHours: num(
+        r?.exportBookingLeadHours,
+        DEFAULTS.exportBookingLeadHours,
+      ),
+      closeOffsetMinutes: offset == null || offset === 0 ? "" : Number(offset),
+    });
+    setSeeded(true);
+  }, [seeded, form, rulesQuery.data, rulesQuery.isLoading, isExport, onChange]);
+
+  const set = (patch: Partial<WindowFormState>) => {
+    if (form) onChange({ ...form, ...patch });
+  };
+
+  const is24h = form != null && form.windowOpenHour === form.windowCloseHour;
+  // Close < open is a valid OVERNIGHT desk (e.g. 08:00 → 07:00 next morning).
+  const isOvernight = form != null && form.windowCloseHour < form.windowOpenHour;
+
+  const reopenSummary = useMemo(() => {
+    if (!form) return "";
+    const total = (Number(form.docReviewMinutes) || 0) + (Number(form.paymentWindowMinutes) || 0);
+    const h = Math.floor(total / 60);
+    const m = total % 60;
+    const parts = [h ? `${h}h` : "", m ? `${m}m` : ""].filter(Boolean);
+    return parts.length ? parts.join(" ") : "0m";
+  }, [form]);
+
+  if (!form) {
+    return (
+      <Group justify="center" py="md">
+        <Loader size="sm" />
+      </Group>
+    );
+  }
+
+  return (
+    <Stack gap="lg">
+      {isExport ? (
+        <Alert variant="light" color="blue" icon={<Info size={16} />}>
+          Export schedules use a single first-come-first-served window: it opens the
+          export lead time before departure — shifted to the next desk opening if that
+          lands outside desk hours — and stays open until it closes. Cycle timing below
+          doesn&apos;t apply.
+        </Alert>
+      ) : (
+        <Alert variant="light" color="orange" icon={<Info size={16} />}>
+          These settings apply to this train only, and can be set only for the FIRST
+          train on a route and departure day. Later trains that day join its booking
+          group and share the same window.
+        </Alert>
+      )}
+
+      {/* ── Daily desk hours ─────────────────────────────────────────── */}
+      <Box>
+        <Group justify="space-between" align="center" mb={6}>
+          <Text size="sm" fw={600}>
+            Daily desk hours (EAT)
+          </Text>
+          {is24h ? (
+            <Badge variant="light" color="grape" leftSection={<Moon size={12} />}>
+              24-hour desk
+            </Badge>
+          ) : (
+            <Badge variant="light" color="edr-green" leftSection={<Sun size={12} />}>
+              {hourLabel(form.windowOpenHour)} – {hourLabel(form.windowCloseHour)}
+            </Badge>
+          )}
+        </Group>
+        <Group grow align="flex-start">
+          <Select
+            label="Opens"
+            data={HOUR_OPTIONS}
+            value={String(form.windowOpenHour)}
+            onChange={(v) => v != null && set({ windowOpenHour: Number(v) })}
+            allowDeselect={false}
+            comboboxProps={{ withinPortal: true }}
+          />
+          <Select
+            label="Closes"
+            data={HOUR_OPTIONS}
+            value={String(form.windowCloseHour)}
+            onChange={(v) => v != null && set({ windowCloseHour: Number(v) })}
+            allowDeselect={false}
+            comboboxProps={{ withinPortal: true }}
+          />
+        </Group>
+        {isOvernight && !is24h ? (
+          <Text size="xs" c="dimmed" mt={4}>
+            Overnight desk — opens {form.windowOpenHour}:00 and runs past midnight,
+            closing {form.windowCloseHour}:00 the next morning.
+          </Text>
+        ) : null}
+        <Switch
+          mt="sm"
+          size="sm"
+          color="grape"
+          label="Run 24 hours a day (never pause overnight)"
+          checked={is24h}
+          onChange={(e) =>
+            set({
+              // On → close == open (24h desk). Off → restore a normal ~9h day.
+              windowCloseHour: e.currentTarget.checked
+                ? form.windowOpenHour
+                : Math.min(23, form.windowOpenHour + 9),
+            })
+          }
+        />
+      </Box>
+
+      <Divider />
+
+      {/* ── Cycle timing ─────────────────────────────────────────────── */}
+      <Box>
+        <Text size="sm" fw={600} mb={6}>
+          Cycle timing
+        </Text>
+        <Stack gap="sm">
+          <DurationField
+            label="Window duration"
+            description="How long each booking cycle stays open before it closes for review"
+            value={form.windowDurationHours}
+            nativeUnit="hours"
+            onChange={(v) => set({ windowDurationHours: v })}
+            min={0.0166}
+            disabled={isExport}
+          />
+          <Group grow align="flex-start">
+            <DurationField
+              label="Document review"
+              description="Staff time to accept documents after the window closes"
+              value={form.docReviewMinutes}
+              nativeUnit="minutes"
+              onChange={(v) => set({ docReviewMinutes: v })}
+              min={0}
+              disabled={isExport}
+            />
+            <DurationField
+              label="Payment window"
+              description="Time a selected customer has to pay"
+              value={form.paymentWindowMinutes}
+              nativeUnit="minutes"
+              onChange={(v) => set({ paymentWindowMinutes: v })}
+              min={1}
+            />
+          </Group>
+          {!isExport ? (
+            <Text size="xs" c="dimmed">
+              Reopen gap after each cycle = document review + payment ={" "}
+              <b>{reopenSummary}</b>.
+            </Text>
+          ) : null}
+        </Stack>
+      </Box>
+
+      <Divider />
+
+      {/* ── Lead time ────────────────────────────────────────────────── */}
+      {isExport ? (
+        <NumberInput
+          label="Export booking lead (hours)"
+          description="How many hours before departure the export booking window opens"
+          value={form.exportBookingLeadHours}
+          onChange={(v) => set({ exportBookingLeadHours: v === "" ? "" : Number(v) })}
+          min={1}
+          clampBehavior="none"
+          allowNegative={false}
+          allowDecimal={false}
+        />
+      ) : (
+        <NumberInput
+          label="Window lead (days)"
+          description="How many days before departure the booking window starts"
+          value={form.importWindowLeadDays}
+          onChange={(v) => set({ importWindowLeadDays: v === "" ? "" : Number(v) })}
+          min={0}
+          clampBehavior="none"
+          allowNegative={false}
+          allowDecimal={false}
+        />
+      )}
+
+      <Divider />
+
+      {/* ── Booking close offset ─────────────────────────────────────── */}
+      <Box>
+        <Text size="sm" fw={600} mb={2}>
+          Booking close offset
+        </Text>
+        <Text size="xs" c="dimmed" mb={8}>
+          How long before departure this schedule stops accepting bookings. e.g. a
+          3-hour import offset closes a 17:00 departure&apos;s window at 14:00; a 1-day
+          export offset closes a Jul-10 16:00 departure at Jul-9 16:00. Leave blank to
+          close exactly at departure.
+        </Text>
+        <DurationField
+          label={isExport ? "Export close offset" : "Import close offset"}
+          description={
+            isExport
+              ? "This export booking window closes this long before departure (blank = at departure)"
+              : "This import booking window closes this long before departure (blank = at departure)"
+          }
+          value={form.closeOffsetMinutes}
+          nativeUnit="minutes"
+          onChange={(v) => set({ closeOffsetMinutes: v })}
+          min={0}
+        />
+      </Box>
+    </Stack>
+  );
+}
diff --git a/apps/edr-freight-web/backoffice/src/components/trainScheduling/Train3DVisualization.tsx b/apps/edr-freight-web/backoffice/src/components/trainScheduling/Train3DVisualization.tsx
new file mode 100644
index 000000000..38295a393
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/components/trainScheduling/Train3DVisualization.tsx
@@ -0,0 +1,1083 @@
+import { Badge, Box, Button, CloseButton, Divider, Group, Paper, ScrollArea, Stack, Text } from "@mantine/core";
+import { ChevronLeft, ChevronRight, Gauge, Maximize2, Minimize2, Train, TrainFront, X } from "lucide-react";
+import { useEffect, useRef, useState } from "react";
+import * as THREE from "three";
+import { OrbitControls } from "three/examples/jsm/controls/OrbitControls.js";
+
+import type { TrainScheduleDetail } from "@/types/trainScheduling";
+
+type Wagon = NonNullable<TrainScheduleDetail["trainSet"]>["wagons"][number];
+
+interface Train3DVisualizationProps {
+  schedule: TrainScheduleDetail;
+  onClose: () => void;
+}
+
+// shipping-line style colors — no purple
+const CONTAINER_PALETTE = [0xb63a2b, 0x1f6fb2, 0x1e8449, 0xd9a213, 0xd35f1e, 0x11707f, 0x7a3b1e, 0x35506e];
+
+// wagon body color keyed by wagon type — same type = same color across the train
+const WAGON_TYPE_PALETTE = [0x2e6f8e, 0xb0722d, 0x5c7f3b, 0x8e3b3b, 0x3b6e63, 0x8a6d2f, 0x505a7d, 0x6d5540];
+const wagonTypeColor = (w: Wagon, fallback: number) =>
+  w.wagonType?.code ? WAGON_TYPE_PALETTE[Math.abs(hash32(w.wagonType.code)) % WAGON_TYPE_PALETTE.length] : fallback;
+
+const hash32 = (key: string) => {
+  let h = 0;
+  for (let i = 0; i < key.length; i++) h = (h * 31 + key.charCodeAt(i)) | 0;
+  return h;
+};
+
+const hashColor = (key: string) => CONTAINER_PALETTE[Math.abs(hash32(key)) % CONTAINER_PALETTE.length];
+
+type WagonKind = "container" | "bulk" | "tank" | "flat";
+
+const wagonKind = (w: Wagon): WagonKind => {
+  const code = `${w.wagonType?.code ?? ""} ${w.wagonType?.name ?? ""}`.toUpperCase();
+  if (/TANK|LIQUID|FUEL/.test(code)) return "tank";
+  if (/HOPPER|BULK|OPEN|GONDOLA/.test(code) || w.allocations.some((a) => a.bulkLoad)) return "bulk";
+  if (/FLAT|CONT/.test(code) || w.allocations.some((a) => a.containerItems?.length)) return "container";
+  return "flat";
+};
+
+const WAGON_BODY_COLOR: Record<WagonKind, number> = {
+  container: 0x5f7d9c,
+  bulk: 0xa8683f,
+  tank: 0xb8bec8,
+  flat: 0x9aa4ae,
+};
+
+const M = 1; // 1 unit = 1 meter
+const GAUGE = 1.435 * M;
+const WHEEL_R = 0.46 * M;
+const DECK_H = 1.2 * M;
+
+// deterministic pseudo-random so scenery doesn't jump between rebuilds
+const makeRng = (seed: number) => () => {
+  seed = (seed * 1664525 + 1013904223) % 4294967296;
+  return seed / 4294967296;
+};
+
+function makeLabelSprite(text: string, bg: string): THREE.Sprite {
+  const canvas = document.createElement("canvas");
+  canvas.width = 512;
+  canvas.height = 128;
+  const ctx = canvas.getContext("2d")!;
+  ctx.fillStyle = bg;
+  ctx.beginPath();
+  ctx.roundRect(6, 6, 500, 116, 28);
+  ctx.fill();
+  ctx.strokeStyle = "rgba(255,255,255,0.9)";
+  ctx.lineWidth = 6;
+  ctx.stroke();
+  ctx.fillStyle = "#ffffff";
+  ctx.font = "bold 58px system-ui, sans-serif";
+  ctx.textAlign = "center";
+  ctx.textBaseline = "middle";
+  ctx.fillText(text, 256, 68);
+  const texture = new THREE.CanvasTexture(canvas);
+  const sprite = new THREE.Sprite(new THREE.SpriteMaterial({ map: texture, depthTest: false }));
+  sprite.scale.set(7, 1.75, 1);
+  return sprite;
+}
+
+function buildClouds(scene: THREE.Scene, rng: () => number) {
+  const mat = new THREE.MeshStandardMaterial({ color: 0xffffff, roughness: 1, transparent: true, opacity: 0.92 });
+  for (let i = 0; i < 8; i++) {
+    const cloud = new THREE.Group();
+    const puffs = 3 + Math.floor(rng() * 4);
+    for (let p = 0; p < puffs; p++) {
+      const puff = new THREE.Mesh(new THREE.SphereGeometry(8 + rng() * 10, 12, 10), mat);
+      puff.position.set((p - puffs / 2) * 11, rng() * 4, (rng() - 0.5) * 10);
+      puff.scale.y = 0.55;
+      cloud.add(puff);
+    }
+    // high and pushed to the sides so they never sit between camera and train
+    cloud.position.set((rng() - 0.5) * 1800, 220 + rng() * 80, (rng() > 0.5 ? 1 : -1) * (350 + rng() * 400));
+    scene.add(cloud);
+  }
+}
+
+function buildAcacia(rng: () => number): THREE.Group {
+  // flat-topped acacia
+  const tree = new THREE.Group();
+  const trunkH = 2.6 + rng() * 2;
+  const trunkMat = new THREE.MeshStandardMaterial({ color: 0x7a5230, roughness: 1 });
+  const trunk = new THREE.Mesh(new THREE.CylinderGeometry(0.18, 0.35, trunkH, 7), trunkMat);
+  trunk.position.y = trunkH / 2;
+  trunk.rotation.z = (rng() - 0.5) * 0.25;
+  tree.add(trunk);
+  for (const tilt of [-0.6, 0.6]) {
+    const branch = new THREE.Mesh(new THREE.CylinderGeometry(0.09, 0.14, trunkH * 0.6, 6), trunkMat);
+    branch.position.set(tilt * 0.8, trunkH * 0.85, (rng() - 0.5) * 0.6);
+    branch.rotation.z = tilt;
+    tree.add(branch);
+  }
+  const canopyMat = new THREE.MeshStandardMaterial({
+    color: rng() > 0.5 ? 0x2f7d32 : 0x3c8d40,
+    roughness: 1,
+  });
+  const canopy = new THREE.Mesh(new THREE.SphereGeometry(2.6 + rng() * 1.6, 10, 8), canopyMat);
+  canopy.position.y = trunkH + 0.9;
+  canopy.scale.set(1.2, 0.32, 1.2); // flat umbrella top
+  tree.add(canopy);
+  return tree;
+}
+
+function buildShrub(rng: () => number): THREE.Mesh {
+  const dry = [0x3c7d33, 0x4f9e3f, 0x2e6b28, 0x5da84a];
+  const shrub = new THREE.Mesh(
+    new THREE.SphereGeometry(0.5 + rng() * 0.8, 7, 6),
+    new THREE.MeshStandardMaterial({ color: dry[Math.floor(rng() * dry.length)], roughness: 1 }),
+  );
+  shrub.scale.y = 0.55;
+  shrub.position.y = 0.25;
+  return shrub;
+}
+
+function buildRock(rng: () => number): THREE.Mesh {
+  const rock = new THREE.Mesh(
+    new THREE.DodecahedronGeometry(0.5 + rng() * 1.6, 0),
+    new THREE.MeshStandardMaterial({ color: rng() > 0.5 ? 0xa08d76 : 0x8d7f6d, roughness: 1 }),
+  );
+  rock.scale.set(1 + rng(), 0.55 + rng() * 0.4, 1 + rng());
+  rock.position.y = 0.3;
+  rock.rotation.y = rng() * Math.PI;
+  return rock;
+}
+
+function buildCamel(rng: () => number): THREE.Group {
+  const g = new THREE.Group();
+  const mat = new THREE.MeshStandardMaterial({ color: rng() > 0.5 ? 0xc49a5f : 0xb28850, roughness: 1 });
+  const body = new THREE.Mesh(new THREE.BoxGeometry(2.1, 0.95, 0.85), mat);
+  body.position.y = 1.55;
+  g.add(body);
+  const hump = new THREE.Mesh(new THREE.SphereGeometry(0.55, 10, 8), mat);
+  hump.position.set(-0.15, 2.25, 0);
+  hump.scale.set(1.15, 0.9, 0.85);
+  g.add(hump);
+  const neck = new THREE.Mesh(new THREE.BoxGeometry(0.3, 1.3, 0.3), mat);
+  neck.position.set(1.05, 2.35, 0);
+  neck.rotation.z = -0.25;
+  g.add(neck);
+  const head = new THREE.Mesh(new THREE.BoxGeometry(0.65, 0.32, 0.3), mat);
+  head.position.set(1.45, 2.95, 0);
+  g.add(head);
+  const legGeo = new THREE.BoxGeometry(0.17, 1.15, 0.17);
+  for (const [x, z] of [[-0.8, -0.28], [-0.8, 0.28], [0.8, -0.28], [0.8, 0.28]]) {
+    const leg = new THREE.Mesh(legGeo, mat);
+    leg.position.set(x, 0.58, z);
+    g.add(leg);
+  }
+  g.rotation.y = rng() * Math.PI * 2;
+  return g;
+}
+
+function buildGoat(rng: () => number): THREE.Group {
+  const g = new THREE.Group();
+  const colors = [0xe8e4da, 0x4a3b2d, 0x9c8a72];
+  const mat = new THREE.MeshStandardMaterial({ color: colors[Math.floor(rng() * colors.length)], roughness: 1 });
+  const body = new THREE.Mesh(new THREE.BoxGeometry(0.9, 0.5, 0.4), mat);
+  body.position.y = 0.62;
+  g.add(body);
+  const head = new THREE.Mesh(new THREE.BoxGeometry(0.32, 0.3, 0.26), mat);
+  head.position.set(0.55, 0.85, 0);
+  g.add(head);
+  const legGeo = new THREE.BoxGeometry(0.09, 0.4, 0.09);
+  for (const [x, z] of [[-0.32, -0.13], [-0.32, 0.13], [0.32, -0.13], [0.32, 0.13]]) {
+    const leg = new THREE.Mesh(legGeo, mat);
+    leg.position.set(x, 0.2, z);
+    g.add(leg);
+  }
+  g.rotation.y = rng() * Math.PI * 2;
+  return g;
+}
+
+function buildScenery(scene: THREE.Scene, trackLen: number) {
+  const rng = makeRng(1234567);
+  buildClouds(scene, rng);
+  const spread = Math.max(trackLen, 600);
+  // grass variation: darker meadow patches
+  const patchMat = new THREE.MeshStandardMaterial({ color: 0x4f8f3a, roughness: 1 });
+  const patchGeo = new THREE.CircleGeometry(4, 8);
+  const patches = new THREE.InstancedMesh(patchGeo, patchMat, 160);
+  const m4 = new THREE.Matrix4();
+  const q = new THREE.Quaternion().setFromEuler(new THREE.Euler(-Math.PI / 2, 0, 0));
+  const v = new THREE.Vector3();
+  const s = new THREE.Vector3();
+  for (let i = 0; i < 160; i++) {
+    const z = (rng() > 0.5 ? 1 : -1) * (6 + rng() * 220);
+    v.set((rng() - 0.5) * spread * 1.4, 0.02, z);
+    s.setScalar(0.6 + rng() * 2.4);
+    m4.compose(v, q, s);
+    patches.setMatrixAt(i, m4);
+  }
+  scene.add(patches);
+  // low green hills on the horizon sides
+  const duneMat = new THREE.MeshStandardMaterial({ color: 0x4a8a38, roughness: 1 });
+  for (let i = 0; i < 12; i++) {
+    const dune = new THREE.Mesh(new THREE.SphereGeometry(30 + rng() * 50, 12, 8), duneMat);
+    dune.scale.set(1.6 + rng(), 0.12 + rng() * 0.08, 1 + rng());
+    dune.position.set((rng() - 0.5) * spread * 1.6, 0, (rng() > 0.5 ? 1 : -1) * (180 + rng() * 200));
+    scene.add(dune);
+  }
+  // sparse acacias, dry shrubs, rocks
+  for (let i = 0; i < 34; i++) {
+    const tree = buildAcacia(rng);
+    tree.position.set((rng() - 0.5) * spread * 1.2, 0, (rng() > 0.5 ? 1 : -1) * (18 + rng() * 170));
+    tree.scale.setScalar(0.9 + rng() * 1.1);
+    scene.add(tree);
+  }
+  for (let i = 0; i < 120; i++) {
+    const shrub = buildShrub(rng);
+    shrub.position.set((rng() - 0.5) * spread * 1.3, 0.15, (rng() > 0.5 ? 1 : -1) * (8 + rng() * 200));
+    scene.add(shrub);
+  }
+  for (let i = 0; i < 40; i++) {
+    const rock = buildRock(rng);
+    rock.position.x = (rng() - 0.5) * spread * 1.3;
+    rock.position.z = (rng() > 0.5 ? 1 : -1) * (10 + rng() * 190);
+    scene.add(rock);
+  }
+  // camel caravans + goat herds
+  for (let h = 0; h < 5; h++) {
+    const cx = (rng() - 0.5) * spread;
+    const cz = (rng() > 0.5 ? 1 : -1) * (30 + rng() * 130);
+    const count = 2 + Math.floor(rng() * 3);
+    for (let a = 0; a < count; a++) {
+      const camel = buildCamel(rng);
+      camel.position.set(cx + a * 4 + (rng() - 0.5) * 2, 0, cz + (rng() - 0.5) * 6);
+      scene.add(camel);
+    }
+  }
+  for (let h = 0; h < 4; h++) {
+    const cx = (rng() - 0.5) * spread;
+    const cz = (rng() > 0.5 ? 1 : -1) * (20 + rng() * 120);
+    const count = 3 + Math.floor(rng() * 4);
+    for (let a = 0; a < count; a++) {
+      const goat = buildGoat(rng);
+      goat.position.set(cx + (rng() - 0.5) * 10, 0, cz + (rng() - 0.5) * 8);
+      scene.add(goat);
+    }
+  }
+}
+
+function buildTrack(scene: THREE.Scene, length: number) {
+  const railMat = new THREE.MeshStandardMaterial({ color: 0x9aa0a8, metalness: 0.9, roughness: 0.35 });
+  const railGeo = new THREE.BoxGeometry(length, 0.18 * M, 0.08 * M);
+  for (const z of [-GAUGE / 2, GAUGE / 2]) {
+    const rail = new THREE.Mesh(railGeo, railMat);
+    rail.position.set(0, 0.28 * M, z);
+    scene.add(rail);
+  }
+  const sleeperGeo = new THREE.BoxGeometry(0.24 * M, 0.14 * M, 2.4 * M);
+  const sleeperMat = new THREE.MeshStandardMaterial({ color: 0x3b2f26, roughness: 1 });
+  const count = Math.floor(length / 0.65);
+  const sleepers = new THREE.InstancedMesh(sleeperGeo, sleeperMat, count);
+  const m4 = new THREE.Matrix4();
+  for (let i = 0; i < count; i++) {
+    m4.setPosition(-length / 2 + i * 0.65, 0.12 * M, 0);
+    sleepers.setMatrixAt(i, m4);
+  }
+  scene.add(sleepers);
+  // ballast bed
+  const ballast = new THREE.Mesh(
+    new THREE.BoxGeometry(length, 0.1 * M, 4.2 * M),
+    new THREE.MeshStandardMaterial({ color: 0x565a5f, roughness: 1 }),
+  );
+  ballast.position.y = 0.03;
+  scene.add(ballast);
+  // ground
+  const ground = new THREE.Mesh(
+    new THREE.PlaneGeometry(4000, 1600),
+    new THREE.MeshStandardMaterial({ color: 0x5da043, roughness: 1 }),
+  );
+  ground.rotation.x = -Math.PI / 2;
+  ground.position.y = -0.02;
+  scene.add(ground);
+}
+
+function addWheels(group: THREE.Group, length: number, wheels: THREE.Mesh[]) {
+  const geo = new THREE.CylinderGeometry(WHEEL_R, WHEEL_R, 0.25, 20);
+  const mat = new THREE.MeshStandardMaterial({ color: 0x1c1f24, metalness: 0.7, roughness: 0.4 });
+  const bogieOffsets = [-length / 2 + 1.8, length / 2 - 1.8];
+  for (const x of bogieOffsets) {
+    for (const dx of [-0.9, 0.9]) {
+      for (const z of [-GAUGE / 2, GAUGE / 2]) {
+        const wheel = new THREE.Mesh(geo, mat);
+        wheel.rotation.x = Math.PI / 2;
+        wheel.position.set(x + dx, WHEEL_R + 0.05, z);
+        group.add(wheel);
+        wheels.push(wheel);
+      }
+    }
+    const bogie = new THREE.Mesh(
+      new THREE.BoxGeometry(2.6, 0.4, GAUGE + 0.4),
+      new THREE.MeshStandardMaterial({ color: 0x22262c, roughness: 0.8 }),
+    );
+    bogie.position.set(x, WHEEL_R + 0.35, 0);
+    group.add(bogie);
+  }
+}
+
+function buildLocomotive(
+  loco: { id?: string; code: string } | undefined,
+  wheels: THREE.Mesh[],
+  pickables: THREE.Object3D[],
+): THREE.Group {
+  const g = new THREE.Group();
+  const len = 20 * M;
+  const bodyMat = new THREE.MeshStandardMaterial({ color: 0x1e6f42, metalness: 0.4, roughness: 0.5 });
+  const body = new THREE.Mesh(new THREE.BoxGeometry(len, 3.2, 3), bodyMat);
+  body.position.y = DECK_H + 1.6;
+  g.add(body);
+  const cab = new THREE.Mesh(new THREE.BoxGeometry(4.4, 1.1, 3.05), new THREE.MeshStandardMaterial({ color: 0xf2a516, metalness: 0.3, roughness: 0.5 }));
+  cab.position.set(len / 2 - 2.6, DECK_H + 3.75, 0);
+  g.add(cab);
+  const nose = new THREE.Mesh(new THREE.BoxGeometry(1.6, 2.2, 2.6), bodyMat);
+  nose.position.set(len / 2 + 0.6, DECK_H + 1.1, 0);
+  g.add(nose);
+  // headlight
+  const light = new THREE.Mesh(
+    new THREE.SphereGeometry(0.22, 12, 12),
+    new THREE.MeshStandardMaterial({ color: 0xfff6c9, emissive: 0xfff2a8, emissiveIntensity: 2 }),
+  );
+  light.position.set(len / 2 + 1.4, DECK_H + 1.6, 0);
+  g.add(light);
+  const spot = new THREE.SpotLight(0xfff2c0, 60, 90, 0.4, 0.6);
+  spot.position.copy(light.position);
+  spot.target.position.set(len / 2 + 40, 0.5, 0);
+  g.add(spot, spot.target);
+  addWheels(g, len, wheels);
+  g.userData.length = len;
+  const locoId = loco?.id ?? loco?.code ?? "loco";
+  g.userData.locoId = locoId;
+  g.traverse((o) => {
+    o.userData.locoId = locoId;
+  });
+  pickables.push(g);
+  return g;
+}
+
+function buildWagon(wagon: Wagon, wheels: THREE.Mesh[], pickables: THREE.Object3D[]): THREE.Group {
+  const g = new THREE.Group();
+  const len = Math.max(8, wagon.lengthMeters || 14) * M;
+  const kind = wagonKind(wagon);
+  const bodyMat = new THREE.MeshStandardMaterial({
+    color: wagonTypeColor(wagon, WAGON_BODY_COLOR[kind]),
+    metalness: 0.35,
+    roughness: 0.6,
+  });
+
+  // frame/deck common to all
+  const deck = new THREE.Mesh(new THREE.BoxGeometry(len, 0.35, 3), bodyMat);
+  deck.position.y = DECK_H;
+  g.add(deck);
+
+  if (kind === "container") {
+    const items = wagon.allocations.flatMap((a) =>
+      (a.containerItems ?? []).map((c) => ({ ...c, bookingRef: a.bookingReference ?? a.bookingId })),
+    );
+    const n = Math.max(items.length, 0);
+    const slotLen = n > 1 ? len / n - 0.3 : Math.min(12.2, len - 1.5);
+    items.forEach((c, i) => {
+      const cx = n > 1 ? -len / 2 + (i + 0.5) * (len / n) : 0;
+      const box = new THREE.Mesh(
+        new THREE.BoxGeometry(slotLen, 2.6, 2.44),
+        new THREE.MeshStandardMaterial({ color: hashColor(c.bookingRef), metalness: 0.2, roughness: 0.55 }),
+      );
+      box.position.set(cx, DECK_H + 0.35 / 2 + 1.3, 0);
+      // corrugation hint: thin ribs
+      const rib = new THREE.Mesh(
+        new THREE.BoxGeometry(slotLen * 0.98, 2.4, 2.5),
+        new THREE.MeshStandardMaterial({ color: 0x000000, transparent: true, opacity: 0.12 }),
+      );
+      rib.position.copy(box.position);
+      g.add(box, rib);
+    });
+  } else if (kind === "bulk") {
+    // open hopper walls
+    const wallMat = new THREE.MeshStandardMaterial({
+      color: wagonTypeColor(wagon, 0x8a5a34),
+      metalness: 0.25,
+      roughness: 0.7,
+    });
+    const wallH = 2.2;
+    const side = new THREE.BoxGeometry(len, wallH, 0.12);
+    for (const z of [-1.45, 1.45]) {
+      const wall = new THREE.Mesh(side, wallMat);
+      wall.position.set(0, DECK_H + wallH / 2 + 0.17, z);
+      g.add(wall);
+    }
+    const end = new THREE.BoxGeometry(0.12, wallH, 3);
+    for (const x of [-len / 2 + 0.06, len / 2 - 0.06]) {
+      const wall = new THREE.Mesh(end, wallMat);
+      wall.position.set(x, DECK_H + wallH / 2 + 0.17, 0);
+      g.add(wall);
+    }
+    const loaded = wagon.allocations.some((a) => a.bulkLoad) || wagon.assignedWeightTons > 0;
+    if (loaded) {
+      // cargo mound: squashed bumpy cylinder rows
+      const cargoMat = new THREE.MeshStandardMaterial({ color: 0x5c4a33, roughness: 1 });
+      const mounds = Math.max(2, Math.floor(len / 4));
+      for (let i = 0; i < mounds; i++) {
+        const mound = new THREE.Mesh(new THREE.SphereGeometry(1.5, 12, 8), cargoMat);
+        mound.scale.set((len / mounds) * 0.42, 0.55, 0.9);
+        mound.position.set(-len / 2 + (i + 0.5) * (len / mounds), DECK_H + wallH * 0.85, 0);
+        g.add(mound);
+      }
+    }
+  } else if (kind === "tank") {
+    const tank = new THREE.Mesh(
+      new THREE.CylinderGeometry(1.4, 1.4, len - 1.6, 24),
+      new THREE.MeshStandardMaterial({ color: 0xb9bec7, metalness: 0.6, roughness: 0.3 }),
+    );
+    tank.rotation.z = Math.PI / 2;
+    tank.position.y = DECK_H + 1.6;
+    g.add(tank);
+    const dome = new THREE.Mesh(new THREE.CylinderGeometry(0.45, 0.45, 0.5, 16), bodyMat);
+    dome.position.y = DECK_H + 3.1;
+    g.add(dome);
+  } else {
+    // empty flat: low side rails
+    const rail = new THREE.Mesh(new THREE.BoxGeometry(len, 0.35, 0.1), bodyMat);
+    for (const z of [-1.45, 1.45]) {
+      const r = rail.clone();
+      r.position.set(0, DECK_H + 0.35, z);
+      g.add(r);
+    }
+  }
+
+  // floating loaded/empty badge above the wagon
+  const loaded = wagon.allocations.length > 0 || wagon.assignedWeightTons > 0;
+  const labelText = loaded
+    ? `#${wagon.position ?? wagon.sequenceNo} · ${Math.round(wagon.assignedWeightTons)} t`
+    : `#${wagon.position ?? wagon.sequenceNo} · EMPTY`;
+  const label = makeLabelSprite(labelText, loaded ? "rgba(22, 130, 60, 0.95)" : "rgba(120, 128, 138, 0.9)");
+  label.position.set(0, DECK_H + 5.4, 0);
+  g.add(label);
+
+  addWheels(g, len, wheels);
+  g.userData.length = len;
+  g.userData.wagonId = wagon.id;
+  g.traverse((o) => {
+    o.userData.wagonId = wagon.id;
+  });
+  pickables.push(g);
+  return g;
+}
+
+function InfoRow({ label, value }: { label: string; value: string | number | null | undefined }) {
+  if (value === null || value === undefined || value === "") return null;
+  return (
+    <Group justify="space-between" gap="xs" wrap="nowrap">
+      <Text size="xs" c="gray.5">{label}</Text>
+      <Text size="xs" c="gray.1" fw={600} ta="right">{value}</Text>
+    </Group>
+  );
+}
+
+function LocoDetailPanel({
+  locoId,
+  schedule,
+  onClose,
+  onDrive,
+}: {
+  locoId: string;
+  schedule: TrainScheduleDetail;
+  onClose: () => void;
+  onDrive: () => void;
+}) {
+  const locos = schedule.trainSet?.locomotives?.length
+    ? schedule.trainSet.locomotives
+    : schedule.trainSet?.locomotive
+      ? [schedule.trainSet.locomotive]
+      : [];
+  const loco = locos.find((l) => l.id === locoId || l.code === locoId);
+  const ts = schedule.trainSet;
+  return (
+    <Paper
+      radius="lg"
+      p="md"
+      style={{
+        position: "absolute",
+        top: 60,
+        right: 16,
+        width: 340,
+        maxHeight: "calc(100% - 76px)",
+        background: "rgba(13, 17, 23, 0.92)",
+        border: "1px solid rgba(255,255,255,0.15)",
+        color: "#e6edf3",
+        zIndex: 10,
+      }}
+    >
+      <Group justify="space-between" mb="xs">
+        <Text fw={700}>Locomotive {loco?.code ?? ""}</Text>
+        <CloseButton variant="transparent" c="gray.4" onClick={onClose} />
+      </Group>
+      <Button fullWidth color="orange" size="xs" mb="sm" leftSection={<Gauge size={14} />} onClick={onDrive}>
+        Drive this locomotive
+      </Button>
+      <ScrollArea.Autosize mah="70vh">
+        <Stack gap="xs">
+          {loco ? (
+            <>
+              {loco.name ? <Text size="sm" c="gray.3">{loco.name}</Text> : null}
+              <Group gap="xs">
+                <Badge color="yellow" variant="light">{loco.status}</Badge>
+              </Group>
+              <InfoRow label="Max pull weight" value={`${loco.maxPullWeightTons} t`} />
+              {loco.maxTrainLengthMeters ? (
+                <InfoRow label="Max train length" value={`${loco.maxTrainLengthMeters} m`} />
+              ) : null}
+            </>
+          ) : (
+            <Text size="sm" c="gray.5">No locomotive assigned yet.</Text>
+          )}
+          <Divider color="rgba(255,255,255,0.1)" label="Train" labelPosition="left" />
+          <InfoRow label="Voyage / reference" value={schedule.reference} />
+          <InfoRow label="Train number" value={schedule.trainNumber} />
+          <InfoRow
+            label="Train"
+            value={schedule.train ? `${schedule.train.code}${schedule.train.trainName ? ` · ${schedule.train.trainName}` : ""}` : null}
+          />
+          <InfoRow label="Status" value={String(schedule.status)} />
+          <InfoRow label="Direction" value={schedule.direction} />
+          <InfoRow label="Route" value={schedule.route?.name} />
+          <InfoRow
+            label="From → To"
+            value={
+              schedule.originStation || schedule.destinationStation
+                ? `${schedule.originStation?.label ?? schedule.originStation?.code ?? "?"} → ${schedule.destinationStation?.label ?? schedule.destinationStation?.code ?? "?"}`
+                : null
+            }
+          />
+          <InfoRow
+            label="Departure"
+            value={schedule.scheduledDepartureDate ? new Date(schedule.scheduledDepartureDate).toLocaleString() : null}
+          />
+          <InfoRow
+            label="Arrival"
+            value={schedule.scheduledArrivalDate ? new Date(schedule.scheduledArrivalDate).toLocaleString() : null}
+          />
+          {ts ? (
+            <>
+              <Divider color="rgba(255,255,255,0.1)" label="Consist" labelPosition="left" />
+              <InfoRow label="Wagons" value={ts.wagonCount} />
+              <InfoRow label="Total weight" value={`${ts.totalWeightTons} t`} />
+              <InfoRow label="Total length" value={`${ts.totalLengthMeters} m`} />
+              {ts.heaviestLeg ? (
+                <InfoRow
+                  label="Heaviest leg"
+                  value={`${ts.heaviestLeg.grossWeightTons} t · ${ts.heaviestLeg.lengthMeters} m`}
+                />
+              ) : null}
+            </>
+          ) : null}
+        </Stack>
+      </ScrollArea.Autosize>
+    </Paper>
+  );
+}
+
+function WagonDetailPanel({ wagon, schedule, onClose }: { wagon: Wagon; schedule: TrainScheduleDetail; onClose: () => void }) {
+  const bookings = schedule.bookings ?? [];
+  return (
+    <Paper
+      radius="lg"
+      p="md"
+      style={{
+        position: "absolute",
+        top: 60,
+        right: 16,
+        width: 340,
+        maxHeight: "calc(100% - 76px)",
+        background: "rgba(13, 17, 23, 0.92)",
+        border: "1px solid rgba(255,255,255,0.15)",
+        color: "#e6edf3",
+        zIndex: 10,
+      }}
+    >
+      <Group justify="space-between" mb="xs">
+        <Text fw={700}>
+          Wagon {wagon.position ?? wagon.sequenceNo}
+          {wagon.physicalWagonNumber ? ` · ${wagon.physicalWagonNumber}` : ""}
+        </Text>
+        <CloseButton variant="transparent" c="gray.4" onClick={onClose} />
+      </Group>
+      <ScrollArea.Autosize mah="70vh">
+        <Stack gap="xs">
+          <Group gap="xs">
+            <Badge color="yellow" variant="light">{wagon.wagonType?.code ?? "UNKNOWN"}</Badge>
+            <Text size="xs" c="gray.4">{wagon.wagonType?.name}</Text>
+          </Group>
+          <Text size="xs" c="gray.4">
+            Capacity {wagon.capacityTons} t · Loaded {wagon.assignedWeightTons} t
+            {wagon.tareWeightTons ? ` · Tare ${wagon.tareWeightTons} t` : ""} · {wagon.lengthMeters} m
+          </Text>
+          {wagon.allocations.length === 0 ? (
+            <Text size="sm" c="gray.5">Empty wagon — no allocations.</Text>
+          ) : (
+            wagon.allocations.map((alloc) => {
+              const booking = bookings.find((b) => b.id === alloc.bookingId);
+              return (
+                <Paper key={alloc.id} p="sm" radius="md" style={{ background: "rgba(255,255,255,0.06)" }}>
+                  <Stack gap={6}>
+                    <Group justify="space-between">
+                      <Text size="sm" fw={600} ff="monospace">{alloc.bookingReference ?? "—"}</Text>
+                      <Badge size="xs" variant="light" color="teal">{alloc.allocatedWeightTons} t</Badge>
+                    </Group>
+                    {booking ? (
+                      <>
+                        <Text size="xs" c="gray.3">Customer: {booking.customer ?? "—"}</Text>
+                        <Text size="xs" c="gray.4">
+                          {booking.origin ?? "?"} → {booking.destination ?? "?"} · {booking.status ?? "—"}
+                          {booking.loadingStatus ? ` · ${booking.loadingStatus}` : ""}
+                        </Text>
+                        {booking.contractReference ? (
+                          <Text size="xs" c="gray.5" ff="monospace">Contract {booking.contractReference}</Text>
+                        ) : null}
+                      </>
+                    ) : null}
+                    {(alloc.containerItems ?? []).length > 0 ? (
+                      <>
+                        <Divider color="rgba(255,255,255,0.1)" label="Containers" labelPosition="left" />
+                        {(alloc.containerItems ?? []).map((c) => (
+                          <Group key={c.id} justify="space-between">
+                            <Text size="xs" ff="monospace" c="gray.2">{c.containerNumber ?? "—"}</Text>
+                            <Text size="xs" c="gray.5">{c.grossWeightTons ?? "?"} t</Text>
+                          </Group>
+                        ))}
+                      </>
+                    ) : null}
+                    {alloc.bulkLoad ? (
+                      <Text size="xs" c="gray.3">
+                        Bulk: {alloc.bulkLoad.cargoDescription ?? "cargo"} · {alloc.bulkLoad.weightTons} t
+                      </Text>
+                    ) : null}
+                  </Stack>
+                </Paper>
+              );
+            })
+          )}
+        </Stack>
+      </ScrollArea.Autosize>
+    </Paper>
+  );
+}
+
+export function Train3DVisualization({ schedule, onClose }: Train3DVisualizationProps) {
+  const containerRef = useRef<HTMLDivElement>(null);
+  const canvasHostRef = useRef<HTMLDivElement>(null);
+  const [selectedWagonId, setSelectedWagonId] = useState<string | null>(null);
+  const [selectedLocoId, setSelectedLocoId] = useState<string | null>(null);
+  const [driveMode, setDriveMode] = useState(false);
+  const [isFullscreen, setIsFullscreen] = useState(false);
+  const cameraApiRef = useRef<{
+    overview: () => void;
+    front: () => void;
+    rear: () => void;
+    focusWagon: (wagonId: string) => void;
+  } | null>(null);
+
+  const wagons = schedule.trainSet?.wagons ?? [];
+  const dispatched = String(schedule.status).toUpperCase() === "DISPATCHED";
+  // drive mode always simulates motion, even before dispatch
+  const moving = dispatched || driveMode;
+  const selectedWagon = wagons.find((w) => w.id === selectedWagonId) ?? null;
+  const orderedWagons = [...wagons].sort(
+    (a, b) => (a.position ?? a.sequenceNo) - (b.position ?? b.sequenceNo),
+  );
+  const selectedIndex = orderedWagons.findIndex((w) => w.id === selectedWagonId);
+
+  const stepWagon = (dir: 1 | -1) => {
+    if (orderedWagons.length === 0) return;
+    const next =
+      selectedIndex < 0
+        ? dir === 1
+          ? 0
+          : orderedWagons.length - 1
+        : (selectedIndex + dir + orderedWagons.length) % orderedWagons.length;
+    const wagon = orderedWagons[next];
+    setSelectedLocoId(null);
+    setSelectedWagonId(wagon.id);
+    cameraApiRef.current?.focusWagon(wagon.id);
+  };
+
+  const firstLocoId =
+    schedule.trainSet?.locomotives?.[0]?.id ??
+    schedule.trainSet?.locomotive?.id ??
+    "LOCO";
+
+  useEffect(() => {
+    const host = canvasHostRef.current;
+    if (!host) return;
+
+    const scene = new THREE.Scene();
+    scene.background = new THREE.Color(0xa7d8f0);
+    scene.fog = new THREE.Fog(0xd9e8f0, 900, 3200); // far desert haze — never clouds the train
+
+    const camera = new THREE.PerspectiveCamera(55, host.clientWidth / host.clientHeight, 0.1, 5000);
+    const renderer = new THREE.WebGLRenderer({ antialias: true });
+    renderer.toneMapping = THREE.ACESFilmicToneMapping;
+    renderer.toneMappingExposure = 1.15;
+    renderer.setPixelRatio(Math.min(window.devicePixelRatio, 2));
+    renderer.setSize(host.clientWidth, host.clientHeight);
+    host.appendChild(renderer.domElement);
+
+    // lights: bright sunny day
+    scene.add(new THREE.HemisphereLight(0xcfe8ff, 0x6f9c4e, 1.0));
+    const sun = new THREE.DirectionalLight(0xfff4d6, 2.4);
+    sun.position.set(-120, 180, 90);
+    scene.add(sun);
+    const fill = new THREE.DirectionalLight(0xdbeaff, 0.6);
+    fill.position.set(100, 60, -80);
+    scene.add(fill);
+    // visible sun disc
+    const sunDisc = new THREE.Mesh(
+      new THREE.SphereGeometry(18, 16, 16),
+      new THREE.MeshBasicMaterial({ color: 0xfff2b0 }),
+    );
+    sunDisc.position.set(-500, 380, 300);
+    scene.add(sunDisc);
+
+    // train assembly
+    const wheels: THREE.Mesh[] = [];
+    const pickables: THREE.Object3D[] = [];
+    const train = new THREE.Group();
+    const gap = 1.0 * M;
+    let cursor = 0;
+    const locos = schedule.trainSet?.locomotives?.length
+      ? schedule.trainSet.locomotives
+      : schedule.trainSet?.locomotive
+        ? [schedule.trainSet.locomotive]
+        : [{ code: "LOCO" }];
+    const locoGroups: Array<{ id: string; group: THREE.Group }> = [];
+    for (const loco of locos) {
+      const lg = buildLocomotive(loco, wheels, pickables);
+      lg.position.x = cursor - lg.userData.length / 2;
+      cursor -= lg.userData.length + gap;
+      train.add(lg);
+      locoGroups.push({ id: lg.userData.locoId as string, group: lg });
+    }
+    const ordered = [...wagons].sort((a, b) => (a.position ?? a.sequenceNo) - (b.position ?? b.sequenceNo));
+    const wagonGroups: Array<{ id: string; group: THREE.Group }> = [];
+    for (const wagon of ordered) {
+      const wg = buildWagon(wagon, wheels, pickables);
+      wg.position.x = cursor - wg.userData.length / 2;
+      cursor -= wg.userData.length + gap;
+      train.add(wg);
+      wagonGroups.push({ id: wagon.id, group: wg });
+    }
+    const trainLen = -cursor;
+    train.position.x = trainLen / 2; // center train on origin
+    scene.add(train);
+
+    const trackLen = Math.max(trainLen * 2.5, 400);
+    const finalTrackLen = moving ? Math.max(trackLen, 1600) : trackLen;
+    buildTrack(scene, finalTrackLen);
+    buildScenery(scene, finalTrackLen);
+
+    camera.position.set(trainLen * 0.12, 14, 42);
+    const controls = new OrbitControls(camera, renderer.domElement);
+    controls.target.set(0, 2, 0);
+    controls.maxPolarAngle = Math.PI / 2 - 0.03;
+    controls.maxDistance = Math.max(600, trainLen * 1.6);
+    controls.enableDamping = true;
+    controls.zoomToCursor = true; // wheel zooms toward the point under the pointer
+    controls.enabled = !driveMode; // cab ride owns the camera
+
+    // camera fly-to: goal recomputed each frame so it tracks a moving train
+    let cameraGoal: (() => { pos: THREE.Vector3; target: THREE.Vector3 }) | null = null;
+    const worldPos = new THREE.Vector3();
+    const flyToObject = (obj: THREE.Object3D, dist: number, height: number) => {
+      cameraGoal = () => {
+        obj.getWorldPosition(worldPos);
+        return {
+          pos: new THREE.Vector3(worldPos.x + dist * 0.35, height, worldPos.z + dist),
+          target: new THREE.Vector3(worldPos.x, 2.2, worldPos.z),
+        };
+      };
+    };
+    const frontGroup = train.children[0];
+    const rearGroup = wagonGroups[wagonGroups.length - 1]?.group ?? frontGroup;
+    cameraApiRef.current = {
+      overview: () => {
+        // side view fitted with the HORIZONTAL fov — much closer than the naive
+        // vertical-fov fit, and low to the ground so the train fills the frame
+        const vFov = (camera.fov * Math.PI) / 180;
+        const hFov = 2 * Math.atan(Math.tan(vFov / 2) * camera.aspect);
+        const dist = Math.max(40, (trainLen / 2 / Math.tan(hFov / 2)) * 1.08);
+        cameraGoal = () => {
+          train.getWorldPosition(worldPos);
+          const cx = worldPos.x - trainLen / 2; // train extends in -x from its origin
+          return {
+            pos: new THREE.Vector3(cx, Math.max(10, dist * 0.1), dist),
+            target: new THREE.Vector3(cx, 2.5, 0),
+          };
+        };
+      },
+      front: () => flyToObject(frontGroup, 26, 8),
+      rear: () => flyToObject(rearGroup, 20, 7),
+      focusWagon: (wagonId: string) => {
+        const entry = wagonGroups.find((w) => w.id === wagonId);
+        if (entry) flyToObject(entry.group, 16, 6);
+      },
+    };
+    // user grabs the mouse → stop auto-flying, hand control back
+    controls.addEventListener("start", () => {
+      cameraGoal = null;
+    });
+    if (driveMode) {
+      // cab ride: camera on the driver's seat of the lead loco, looking down the line
+      const locoLen = frontGroup.userData.length as number;
+      cameraGoal = () => {
+        frontGroup.getWorldPosition(worldPos);
+        return {
+          pos: new THREE.Vector3(worldPos.x + locoLen / 2 - 3.2, DECK_H + 3.9, 1.05),
+          target: new THREE.Vector3(worldPos.x + locoLen / 2 + 140, 2.2, 0),
+        };
+      };
+    } else if (moving) {
+      // dispatched → open following the rolling train so motion is obvious
+      cameraApiRef.current.overview();
+    }
+
+    // picking
+    const raycaster = new THREE.Raycaster();
+    const pointer = new THREE.Vector2();
+    let highlighted: THREE.Object3D | null = null;
+    const setEmissive = (root: THREE.Object3D, on: boolean) => {
+      root.traverse((o) => {
+        const mesh = o as THREE.Mesh;
+        const mat = mesh.material as THREE.MeshStandardMaterial | undefined;
+        if (mat?.emissive) {
+          mat.emissive.setHex(on ? 0x335588 : 0x000000);
+          mat.emissiveIntensity = on ? 0.9 : 1;
+        }
+      });
+    };
+    const onClick = (e: MouseEvent) => {
+      const rect = renderer.domElement.getBoundingClientRect();
+      pointer.x = ((e.clientX - rect.left) / rect.width) * 2 - 1;
+      pointer.y = -((e.clientY - rect.top) / rect.height) * 2 + 1;
+      raycaster.setFromCamera(pointer, camera);
+      const hits = raycaster.intersectObjects(pickables, true);
+      const wagonId = hits[0]?.object.userData.wagonId as string | undefined;
+      const locoId = hits[0]?.object.userData.locoId as string | undefined;
+      if (highlighted) setEmissive(highlighted, false);
+      highlighted = wagonId
+        ? (pickables.find((p) => p.userData.wagonId === wagonId) ?? null)
+        : locoId
+          ? (locoGroups.find((l) => l.id === locoId)?.group ?? null)
+          : null;
+      if (highlighted) setEmissive(highlighted, true);
+      setSelectedWagonId(wagonId ?? null);
+      setSelectedLocoId(locoId && !wagonId ? locoId : null);
+      if (wagonId) cameraApiRef.current?.focusWagon(wagonId);
+      else if (locoId) {
+        const lg = locoGroups.find((l) => l.id === locoId);
+        if (lg) flyToObject(lg.group, 30, 9);
+      }
+    };
+    renderer.domElement.addEventListener("click", onClick);
+
+    const onResize = () => {
+      camera.aspect = host.clientWidth / host.clientHeight;
+      camera.updateProjectionMatrix();
+      renderer.setSize(host.clientWidth, host.clientHeight);
+    };
+    const resizeObserver = new ResizeObserver(onResize);
+    resizeObserver.observe(host);
+
+    let raf = 0;
+    let last = performance.now();
+    let elapsed = 0;
+    const speed = 14; // m/s visual speed when dispatched
+    const animate = () => {
+      raf = requestAnimationFrame(animate);
+      const now = performance.now();
+      const dt = Math.min((now - last) / 1000, 0.1);
+      last = now;
+      if (moving) {
+        elapsed += dt;
+        train.position.x += speed * dt;
+        for (const w of wheels) w.rotation.y += (speed * dt) / WHEEL_R;
+        // subtle rail-joint sway so motion reads even up close
+        train.position.y = Math.sin(elapsed * 9) * 0.03;
+        train.rotation.z = Math.sin(elapsed * 4.5) * 0.0025;
+        // loop over the long track stretch; jump happens far off-screen
+        const half = finalTrackLen / 2 - trainLen - 40;
+        if (train.position.x > half + trainLen) train.position.x = -half;
+      }
+      if (cameraGoal) {
+        const goal = cameraGoal();
+        const k = Math.min(1, dt * (driveMode ? 7 : 3.2));
+        camera.position.lerp(goal.pos, k);
+        controls.target.lerp(goal.target, k);
+        // static scene: release goal once settled so orbiting feels free again
+        if (!moving && camera.position.distanceTo(goal.pos) < 0.15) cameraGoal = null;
+      }
+      controls.update();
+      renderer.render(scene, camera);
+    };
+    animate();
+
+    return () => {
+      cameraApiRef.current = null;
+      cancelAnimationFrame(raf);
+      resizeObserver.disconnect();
+      renderer.domElement.removeEventListener("click", onClick);
+      controls.dispose();
+      renderer.dispose();
+      host.removeChild(renderer.domElement);
+      scene.traverse((o) => {
+        const mesh = o as THREE.Mesh;
+        mesh.geometry?.dispose?.();
+        const mats = Array.isArray(mesh.material) ? mesh.material : [mesh.material];
+        mats.forEach((m) => m?.dispose?.());
+      });
+    };
+    // rebuild scene only when schedule identity/status changes
+  }, [schedule.id, schedule.status, moving, driveMode, wagons.length]); // eslint-disable-line react-hooks/exhaustive-deps
+
+  useEffect(() => {
+    const onFsChange = () => setIsFullscreen(Boolean(document.fullscreenElement));
+    const onKey = (e: KeyboardEvent) => {
+      if (e.key !== "Escape" || document.fullscreenElement) return;
+      if (driveMode) setDriveMode(false);
+      else onClose();
+    };
+    document.addEventListener("fullscreenchange", onFsChange);
+    window.addEventListener("keydown", onKey);
+    return () => {
+      document.removeEventListener("fullscreenchange", onFsChange);
+      window.removeEventListener("keydown", onKey);
+    };
+  }, [onClose, driveMode]);
+
+  const toggleFullscreen = () => {
+    if (document.fullscreenElement) void document.exitFullscreen();
+    else void containerRef.current?.requestFullscreen();
+  };
+
+  return (
+    <Box
+      ref={containerRef}
+      style={{
+        position: "fixed",
+        inset: 0,
+        zIndex: 400,
+        background: "#02040a",
+      }}
+    >
+      <Box ref={canvasHostRef} style={{ position: "absolute", inset: 0 }} />
+      <Group
+        gap="xs"
+        style={{ position: "absolute", top: 16, left: 16, zIndex: 10 }}
+      >
+        <Badge size="lg" variant="filled" color={driveMode ? "orange" : dispatched ? "green" : "gray"}>
+          {driveMode
+            ? "DRIVER VIEW — SIMULATION"
+            : dispatched
+              ? "DISPATCHED — TRAIN IN MOTION"
+              : `${schedule.status} — TRAIN STOPPED`}
+        </Badge>
+        <Badge size="lg" variant="light" color="yellow">
+          {schedule.route?.name ?? schedule.reference ?? "Train"} · {wagons.length} wagons
+        </Badge>
+      </Group>
+      <Group
+        gap="xs"
+        style={{
+          position: "absolute",
+          bottom: 16,
+          left: "50%",
+          transform: "translateX(-50%)",
+          zIndex: 10,
+          background: "rgba(15, 23, 42, 0.75)",
+          borderRadius: 12,
+          padding: "8px 12px",
+        }}
+      >
+        <Button
+          size="compact-sm"
+          variant="default"
+          leftSection={<Train size={14} />}
+          onClick={() => cameraApiRef.current?.overview()}
+        >
+          Whole train
+        </Button>
+        <Button
+          size="compact-sm"
+          variant="default"
+          leftSection={<TrainFront size={14} />}
+          onClick={() => {
+            setSelectedWagonId(null);
+            setSelectedLocoId(firstLocoId);
+            cameraApiRef.current?.front();
+          }}
+        >
+          Locomotive
+        </Button>
+        <Button size="compact-sm" variant="default" onClick={() => cameraApiRef.current?.rear()}>
+          Last wagon
+        </Button>
+        <Button
+          size="compact-sm"
+          variant={driveMode ? "filled" : "default"}
+          color={driveMode ? "orange" : undefined}
+          leftSection={<Gauge size={14} />}
+          onClick={() => setDriveMode((d) => !d)}
+        >
+          {driveMode ? "Exit drive" : "Drive"}
+        </Button>
+        <Divider orientation="vertical" color="rgba(255,255,255,0.2)" />
+        <Button size="compact-sm" variant="default" onClick={() => stepWagon(-1)} px={8}>
+          <ChevronLeft size={16} />
+        </Button>
+        <Text size="sm" c="white" fw={600} style={{ minWidth: 90, textAlign: "center" }}>
+          {selectedIndex >= 0
+            ? `Wagon ${orderedWagons[selectedIndex].position ?? orderedWagons[selectedIndex].sequenceNo} / ${orderedWagons.length}`
+            : `${orderedWagons.length} wagons`}
+        </Text>
+        <Button size="compact-sm" variant="default" onClick={() => stepWagon(1)} px={8}>
+          <ChevronRight size={16} />
+        </Button>
+      </Group>
+      <Group gap="xs" style={{ position: "absolute", bottom: 16, left: 16, zIndex: 10 }}>
+        <Text
+          size="xs"
+          c="white"
+          px="sm"
+          py={4}
+          style={{ background: "rgba(15, 23, 42, 0.6)", borderRadius: 8 }}
+        >
+          Drag to orbit · scroll to zoom · click a wagon for details
+        </Text>
+      </Group>
+      <Group gap="xs" style={{ position: "absolute", top: 16, right: 16, zIndex: 11 }}>
+        <Button
+          size="compact-sm"
+          variant="default"
+          leftSection={isFullscreen ? <Minimize2 size={14} /> : <Maximize2 size={14} />}
+          onClick={toggleFullscreen}
+        >
+          {isFullscreen ? "Exit fullscreen" : "Fullscreen"}
+        </Button>
+        <Button size="compact-sm" color="red" variant="light" leftSection={<X size={14} />} onClick={onClose}>
+          Close
+        </Button>
+      </Group>
+      {selectedWagon ? (
+        <WagonDetailPanel wagon={selectedWagon} schedule={schedule} onClose={() => setSelectedWagonId(null)} />
+      ) : selectedLocoId ? (
+        <LocoDetailPanel
+          locoId={selectedLocoId}
+          schedule={schedule}
+          onClose={() => setSelectedLocoId(null)}
+          onDrive={() => setDriveMode(true)}
+        />
+      ) : null}
+    </Box>
+  );
+}
diff --git a/apps/edr-freight-web/backoffice/src/components/warehouses/GrnDocumentButton.tsx b/apps/edr-freight-web/backoffice/src/components/warehouses/GrnDocumentButton.tsx
new file mode 100644
index 000000000..41da007fd
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/components/warehouses/GrnDocumentButton.tsx
@@ -0,0 +1,54 @@
+import { useState, type MouseEvent } from 'react';
+import { Button } from '@mantine/core';
+import { FileText } from 'lucide-react';
+
+import { useToast } from '@/hooks/use-toast';
+import { warehouseService } from '@/services/warehouse.service';
+import { extractDownloadErrorMessage } from './options';
+import { openPdfBlob } from './pdf';
+
+/** Opens (or downloads) an inventory item's GRN document — same button everywhere it appears. */
+export function GrnDocumentButton({
+  inventoryId,
+  grnNumber,
+}: {
+  inventoryId: string;
+  grnNumber?: string | null;
+}) {
+  const { toast } = useToast();
+  const [loading, setLoading] = useState(false);
+
+  const openDocument = async (event: MouseEvent<HTMLButtonElement>) => {
+    event.stopPropagation();
+    if (!grnNumber) {
+      toast({ variant: 'destructive', title: 'GRN document unavailable', description: 'This item has no GRN number yet.' });
+      return;
+    }
+    setLoading(true);
+    const pdfWindow = window.open('', '_blank');
+    try {
+      const response = await warehouseService.downloadGrnDocument(inventoryId);
+      const opened = openPdfBlob(response.data, `grn-${grnNumber}.pdf`, pdfWindow);
+      toast({ title: opened ? 'GRN document opened' : 'GRN document downloaded' });
+    } catch (error) {
+      pdfWindow?.close();
+      toast({ variant: 'destructive', title: 'GRN document failed', description: await extractDownloadErrorMessage(error) });
+    } finally {
+      setLoading(false);
+    }
+  };
+
+  return (
+    <Button
+      size="compact-xs"
+      variant="subtle"
+      color="teal"
+      leftSection={<FileText size={12} />}
+      disabled={!grnNumber}
+      loading={loading}
+      onClick={openDocument}
+    >
+      {grnNumber ?? 'No GRN'}
+    </Button>
+  );
+}
diff --git a/apps/edr-freight-web/backoffice/src/components/warehouses/ReceiveInventoryModal.tsx b/apps/edr-freight-web/backoffice/src/components/warehouses/ReceiveInventoryModal.tsx
index cfbdd7b82..8ea4ade67 100644
--- a/apps/edr-freight-web/backoffice/src/components/warehouses/ReceiveInventoryModal.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/warehouses/ReceiveInventoryModal.tsx
@@ -1,4 +1,4 @@
-import { Fragment, useEffect, useMemo, useState, type MouseEvent } from 'react';
+import { Fragment, useEffect, useMemo, useState } from 'react';
 import {
   ActionIcon,
   Alert,
@@ -71,6 +71,7 @@ import { BookingSelect } from './BookingSelect';
 import { DeliverInventoryModal } from './DeliverInventoryModal';
 import { ContainerItemsModal } from './ContainerItemsModal';
 import { FeePreviewModal } from './FeePreviewModal';
+import { GrnDocumentButton } from './GrnDocumentButton';
 import { InspectionReportModal } from './InspectionReportModal';
 import { InventoryDetailModal } from './InventoryDetailModal';
 import { InventoryHistoryModal } from './InventoryHistoryModal';
@@ -98,44 +99,6 @@ interface ReceiveInventoryModalProps {
   onReceived?: () => void;
 }
 
-function GrnDocumentButton({ inventoryId, grnNumber }: { inventoryId: string; grnNumber?: string | null }) {
-  const { toast } = useToast();
-  const [loading, setLoading] = useState(false);
-
-  const openDocument = async (event: MouseEvent<HTMLButtonElement>) => {
-    event.stopPropagation();
-    if (!grnNumber) {
-      toast({ variant: 'destructive', title: 'GRN document unavailable', description: 'This item has no GRN number yet.' });
-      return;
-    }
-    setLoading(true);
-    const pdfWindow = window.open('', '_blank');
-    try {
-      const response = await warehouseService.downloadGrnDocument(inventoryId);
-      const opened = openPdfBlob(response.data, `grn-${grnNumber}.pdf`, pdfWindow);
-      toast({ title: opened ? 'GRN document opened' : 'GRN document downloaded' });
-    } catch (error) {
-      pdfWindow?.close();
-      toast({ variant: 'destructive', title: 'GRN document failed', description: await extractDownloadErrorMessage(error) });
-    } finally {
-      setLoading(false);
-    }
-  };
-
-  return (
-    <Button
-      size="compact-xs"
-      variant="subtle"
-      color="teal"
-      leftSection={<FileText size={12} />}
-      disabled={!grnNumber}
-      loading={loading}
-      onClick={openDocument}
-    >
-      {grnNumber ?? 'No GRN'}
-    </Button>
-  );
-}
 
 interface Location {
   warehouseId: string;
@@ -1513,7 +1476,7 @@ function ExportReceivedTab({ enabled, onChanged }: { enabled: boolean; onChanged
                     </Table.Td>
                     <Table.Td ta="right">
                       <Button size="compact-xs" variant="light" color="orange" onClick={() => setInspectId(r.id)}>
-                        Inspect / Report
+                        Inspection / Report
                       </Button>
                     </Table.Td>
                   </Table.Tr>
@@ -2228,7 +2191,7 @@ const getPendingUnloadBookings = (train: ImportTrain) =>
 const isFullyUnloaded = (train: ImportTrain) =>
   Boolean(train.fullyUnloaded) || (train.totalBookings > 0 && getPendingUnloadBookings(train) === 0);
 
-function ImportArriveQueueTab({
+export function ImportArriveQueueTab({
   enabled,
   onChanged,
 }: {
@@ -2769,7 +2732,7 @@ function ImportUnloadedQueueTab({ enabled }: { enabled: boolean }) {
                               {r.handoverDocumentReference ? 'View handover' : 'Handover'}
                             </Menu.Item>
                           )}
-                          <Menu.Item onClick={() => setInspectId(r.id)}>Inspect / report</Menu.Item>
+                          <Menu.Item onClick={() => setInspectId(r.id)}>Inspection / Report</Menu.Item>
                           {/* Double handling is decided once the goods are off
                               the wagon (every row here is unloaded) — Yes is
                               what makes the fee rule bill this booking. */}
diff --git a/apps/edr-freight-web/backoffice/src/components/warehouses/WarehouseInventoryTable.tsx b/apps/edr-freight-web/backoffice/src/components/warehouses/WarehouseInventoryTable.tsx
index 5eacf7fc1..d224db40b 100644
--- a/apps/edr-freight-web/backoffice/src/components/warehouses/WarehouseInventoryTable.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/warehouses/WarehouseInventoryTable.tsx
@@ -1,9 +1,7 @@
-import { Fragment, useState, type MouseEvent } from 'react';
+import { Fragment, useState } from 'react';
 import { ActionIcon, Badge, Button, Checkbox, Group, Table, Text, Tooltip } from '@mantine/core';
 import { ArrowRightLeft, ChevronDown, ChevronRight, ClipboardList, Coins, Download, Eye, FileText, History, MapPin } from 'lucide-react';
 
-import { useToast } from '@/hooks/use-toast';
-import { warehouseService } from '@/services/warehouse.service';
 import {
   getNextInventoryAction,
   type InventoryAction,
@@ -11,8 +9,8 @@ import {
 } from '@/types/warehouse';
 import { InventoryStatusBadge } from './badges';
 import { TruckBreakdownRow } from './TruckBreakdownRow';
-import { extractDownloadErrorMessage, formatDate, formatNumber, humanizeEnum } from './options';
-import { openPdfBlob } from './pdf';
+import { GrnDocumentButton } from './GrnDocumentButton';
+import { formatDate, formatNumber, humanizeEnum } from './options';
 
 interface WarehouseInventoryTableProps {
   items: WarehouseInventoryItem[];
@@ -64,45 +62,6 @@ const noteLineValue = (notes: string | null | undefined, label: string) => {
 const handoverDocumentReference = (item: WarehouseInventoryItem) =>
   item.handoverDocumentReference ?? noteLineValue(item.notes, 'Handover Reference');
 
-function GrnDocumentButton({ item }: { item: WarehouseInventoryItem }) {
-  const { toast } = useToast();
-  const [loading, setLoading] = useState(false);
-
-  const openDocument = async (event: MouseEvent<HTMLButtonElement>) => {
-    event.stopPropagation();
-    if (!item.grnNumber) {
-      toast({ variant: 'destructive', title: 'GRN document unavailable', description: 'This item has no GRN number yet.' });
-      return;
-    }
-    setLoading(true);
-    const pdfWindow = window.open('', '_blank');
-    try {
-      const response = await warehouseService.downloadGrnDocument(item.id);
-      const opened = openPdfBlob(response.data, `grn-${item.grnNumber}.pdf`, pdfWindow);
-      toast({ title: opened ? 'GRN document opened' : 'GRN document downloaded' });
-    } catch (error) {
-      pdfWindow?.close();
-      toast({ variant: 'destructive', title: 'GRN document failed', description: await extractDownloadErrorMessage(error) });
-    } finally {
-      setLoading(false);
-    }
-  };
-
-  return (
-    <Button
-      size="compact-xs"
-      variant="subtle"
-      color="teal"
-      leftSection={<FileText size={12} />}
-      disabled={!item.grnNumber}
-      loading={loading}
-      onClick={openDocument}
-    >
-      {item.grnNumber ?? 'No GRN'}
-    </Button>
-  );
-}
-
 export function WarehouseInventoryTable({
   items,
   busyId,
@@ -239,7 +198,7 @@ export function WarehouseInventoryTable({
                   )}
                 </Table.Td>
                 <Table.Td>
-                  <GrnDocumentButton item={item} />
+                  <GrnDocumentButton inventoryId={item.id} grnNumber={item.grnNumber} />
                 </Table.Td>
                 <Table.Td>{item.warehouse?.facility?.name ?? '-'}</Table.Td>
                 <Table.Td>{item.warehouse?.code ?? '-'}</Table.Td>
@@ -341,7 +300,7 @@ export function WarehouseInventoryTable({
                       </Tooltip>
                     )}
                     {onDownloadBundle && item.grnNumber && (
-                      <Tooltip label="Download document bundle (GRN + gate clearance + handover)" withArrow>
+                      <Tooltip label="Download document bundle (GRN + exit paper + handover)" withArrow>
                         <ActionIcon variant="subtle" color="grape" onClick={() => onDownloadBundle(item)}>
                           <Download size={16} />
                         </ActionIcon>
diff --git a/apps/edr-freight-web/backoffice/src/constants/QUERY_KEYS.ts b/apps/edr-freight-web/backoffice/src/constants/QUERY_KEYS.ts
index 6e95a27fc..f6df662d5 100644
--- a/apps/edr-freight-web/backoffice/src/constants/QUERY_KEYS.ts
+++ b/apps/edr-freight-web/backoffice/src/constants/QUERY_KEYS.ts
@@ -184,7 +184,8 @@ export const QUERY_KEYS = {
       ["overview", "contracts", range ?? "30d"] as const,
     billingTab: (range?: string) =>
       ["overview", "billing", range ?? "30d"] as const,
-    operationsTab: () => ["overview", "operations"] as const,
+    operationsTab: (range?: string) =>
+      ["overview", "operations", range ?? "30d"] as const,
     customersTab: (range?: string) =>
       ["overview", "customers", range ?? "30d"] as const,
     staffTab: (range?: string) =>
diff --git a/apps/edr-freight-web/backoffice/src/constants/URLS.ts b/apps/edr-freight-web/backoffice/src/constants/URLS.ts
index f7f1f9cbc..0e3facead 100644
--- a/apps/edr-freight-web/backoffice/src/constants/URLS.ts
+++ b/apps/edr-freight-web/backoffice/src/constants/URLS.ts
@@ -109,6 +109,10 @@ export const URL_CONSTANTS = {
     BY_USER_ID: (id: string) => `/api/customers/user/${id}`,
   },
 
+  REPORTS: {
+    RUN: (key: string) => `/reports/${key}`,
+  },
+
   OVERVIEW: {
     BASE: "/overview",
     BOOKINGS: "/overview/bookings",
@@ -343,6 +347,10 @@ export const URL_CONSTANTS = {
       `/train-scheduling/bookings/${bookingId}/expire`,
     MOVE_BOOKING_SCHEDULE: (bookingId: string) =>
       `/train-scheduling/bookings/${bookingId}/move-schedule`,
+    ALLOCATION_CANDIDATES: (bookingId: string) =>
+      `/train-scheduling/bookings/${bookingId}/allocation-candidates`,
+    ALLOCATE_BOOKING: (bookingId: string) =>
+      `/train-scheduling/bookings/${bookingId}/allocate`,
     GLOBAL_RULES: "/train-scheduling/global-rules",
     BOOKING_WINDOWS: "/train-scheduling/booking-windows",
     PREVIEW: "/train-scheduling/preview",
@@ -416,6 +424,8 @@ export const URL_CONSTANTS = {
       `/train-scheduling/schedules/${id}/import-djibouti/load-list/document`,
     EXPORT_LOAD_LIST_DOCUMENT: (id: string) =>
       `/train-scheduling/schedules/${id}/export/load-list/document`,
+    INTERCITY_MARSHALLING_DOCUMENT: (id: string) =>
+      `/train-scheduling/schedules/${id}/intercity/marshalling/document`,
     CHECKPOINTS: (id: string) =>
       `/train-scheduling/schedules/${id}/checkpoints`,
     ARRIVE: (id: string) => `/train-scheduling/schedules/${id}/arrive`,
diff --git a/apps/edr-freight-web/backoffice/src/hooks/useMyTradeAccess.ts b/apps/edr-freight-web/backoffice/src/hooks/useMyTradeAccess.ts
new file mode 100644
index 000000000..6f60f685f
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/hooks/useMyTradeAccess.ts
@@ -0,0 +1,32 @@
+import { useQuery } from "@tanstack/react-query";
+
+import {
+  ALL_TRADE_DIRECTIONS,
+  userTradeAccessService,
+  type TradeDirection,
+} from "@/services/userTradeAccess.service";
+
+/**
+ * Current user's trade-direction scope. While loading (or on error) it
+ * reports full access — the API enforces the real scope regardless; this
+ * hook only trims filter dropdowns to the directions the user can see.
+ */
+export function useMyTradeAccess() {
+  const { data } = useQuery({
+    queryKey: ["user-trade-access", "me"],
+    queryFn: userTradeAccessService.me,
+    staleTime: 5 * 60 * 1000,
+  });
+
+  const directions: TradeDirection[] = data?.directions ?? [
+    ...ALL_TRADE_DIRECTIONS,
+  ];
+
+  return {
+    restricted: data?.restricted ?? false,
+    directions,
+    /** Trim `{ value }`-shaped dropdown options to the allowed directions. */
+    filterOptions: <T extends { value: string }>(options: T[]): T[] =>
+      options.filter((o) => directions.includes(o.value as TradeDirection)),
+  };
+}
diff --git a/apps/edr-freight-web/backoffice/src/hooks/useOverview.ts b/apps/edr-freight-web/backoffice/src/hooks/useOverview.ts
index 023d3d9f1..f46fe865f 100644
--- a/apps/edr-freight-web/backoffice/src/hooks/useOverview.ts
+++ b/apps/edr-freight-web/backoffice/src/hooks/useOverview.ts
@@ -35,10 +35,10 @@ export function useOverviewBillingTab(range: OverviewRange, enabled: boolean) {
   });
 }
 
-export function useOverviewOperationsTab(enabled: boolean) {
+export function useOverviewOperationsTab(range: OverviewRange, enabled: boolean) {
   return useQuery({
-    queryKey: QUERY_KEYS.OVERVIEW.operationsTab(),
-    queryFn: () => overviewService.getOperationsTab(),
+    queryKey: QUERY_KEYS.OVERVIEW.operationsTab(range),
+    queryFn: () => overviewService.getOperationsTab(range),
     enabled,
   });
 }
diff --git a/apps/edr-freight-web/backoffice/src/pages/bookings/BookingRequestsPage.tsx b/apps/edr-freight-web/backoffice/src/pages/bookings/BookingRequestsPage.tsx
index 4aee1e32a..91eb52033 100644
--- a/apps/edr-freight-web/backoffice/src/pages/bookings/BookingRequestsPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/bookings/BookingRequestsPage.tsx
@@ -1,9 +1,12 @@
+import { useMyTradeAccess } from "@/hooks/useMyTradeAccess";
 import {
   ActionIcon,
   Box,
   Button,
   Card,
+  Checkbox,
   Group,
+  Modal,
   MultiSelect,
   Select,
   Stack,
@@ -49,7 +52,10 @@ import {
 import { ContractReferenceLink } from "@/components/bookings/ContractReferenceLink";
 import { api } from "@/services/api";
 import type { BookingListFilter } from "@/services/bookings.service";
+import { trainSchedulingService } from "@/services/trainScheduling.service";
+import type { AllocationCandidate } from "@/types/trainScheduling";
 import type { BookingListRow } from "@/types/booking";
+import { useToast } from "@/hooks/use-toast";
 import {
   Badge,
   DataTable,
@@ -139,6 +145,7 @@ export default function BookingRequestsPage() {
   const [statusFilter, setStatusFilter] = useState<string[]>(() =>
     paramStatuses.split(",").filter(Boolean),
   );
+  const { filterOptions } = useMyTradeAccess();
   const [directionFilter, setDirectionFilter] = useState<string | null>(
     paramDirection,
   );
@@ -153,6 +160,15 @@ export default function BookingRequestsPage() {
   const [scheduledTo, setScheduledTo] = useState<Date | null>(null);
   const [allocateOpen, setAllocateOpen] = useState(false);
   const [allocateIds, setAllocateIds] = useState<string[]>([]);
+  // Paid bookings with no train attached (staff removed them or a sweep
+  // detached them) — the queue the per-row Allocate action works through.
+  const [paidUnallocated, setPaidUnallocated] = useState(false);
+  const [allocatingId, setAllocatingId] = useState<string | null>(null);
+  const [otherDayModal, setOtherDayModal] = useState<{
+    booking: BookingListRow;
+    candidates: AllocationCandidate[];
+  } | null>(null);
+  const { toast } = useToast();
   const suppressRowClickRef = useRef(false);
   const suppressRowClick = useCallback(() => {
     suppressRowClickRef.current = true;
@@ -185,6 +201,10 @@ export default function BookingRequestsPage() {
       ...(directionFilter ? { tradeDirection: directionFilter } : {}),
       ...(freightTypeFilter ? { freightType: freightTypeFilter } : {}),
       ...(paymentStatusFilter ? { paymentStatus: paymentStatusFilter } : {}),
+      // Wins over the payment-status select — the queue is by definition PAID.
+      ...(paidUnallocated
+        ? { paymentStatus: "PAID", assignedToSchedule: "false" as const }
+        : {}),
       ...(ownershipFilter
         ? { isGovernment: ownershipFilter as "true" | "false" }
         : {}),
@@ -206,6 +226,7 @@ export default function BookingRequestsPage() {
     directionFilter,
     freightTypeFilter,
     paymentStatusFilter,
+    paidUnallocated,
     ownershipFilter,
     originYardFilter,
     destinationYardFilter,
@@ -249,6 +270,7 @@ export default function BookingRequestsPage() {
     (directionFilter ? 1 : 0) +
     (freightTypeFilter ? 1 : 0) +
     (paymentStatusFilter ? 1 : 0) +
+    (paidUnallocated ? 1 : 0) +
     (ownershipFilter ? 1 : 0) +
     (originYardFilter ? 1 : 0) +
     (destinationYardFilter ? 1 : 0) +
@@ -261,6 +283,7 @@ export default function BookingRequestsPage() {
     setDirectionFilter(null);
     setFreightTypeFilter(null);
     setPaymentStatusFilter(null);
+    setPaidUnallocated(false);
     setOwnershipFilter(null);
     setOriginYardFilter(null);
     setDestinationYardFilter(null);
@@ -299,6 +322,67 @@ export default function BookingRequestsPage() {
     [navigate],
   );
 
+  // One click: same-day fit → allocate straight away. No same-day fit but a
+  // train on another date fits → let staff pick it (customer is notified of
+  // the date change by the API). Nothing fits → say so.
+  const handleAllocatePaid = useCallback(
+    async (row: BookingListRow) => {
+      setAllocatingId(row.id);
+      try {
+        const candidates =
+          await trainSchedulingService.getAllocationCandidates(row.id);
+        if (candidates.sameDay.length > 0) {
+          const target = candidates.sameDay[0];
+          await trainSchedulingService.allocatePaidBooking(row.id, target.id);
+          toast({
+            title: `Allocated ${row.reference}`,
+            description: `Placed on ${target.reference ?? "train"} departing ${formatDate(target.scheduledDepartureDate)}.`,
+          });
+          void refetch();
+        } else if (candidates.otherDays.length > 0) {
+          setOtherDayModal({ booking: row, candidates: candidates.otherDays });
+        } else {
+          toast({
+            title: "No fitting train",
+            description:
+              "No open schedule covers this booking's route with enough capacity.",
+            variant: "destructive",
+          });
+        }
+      } catch {
+        toast({ title: "Allocation failed", variant: "destructive" });
+      } finally {
+        setAllocatingId(null);
+      }
+    },
+    [refetch, toast],
+  );
+
+  const handleAllocateOtherDay = useCallback(
+    async (candidate: AllocationCandidate) => {
+      if (!otherDayModal) return;
+      const { booking } = otherDayModal;
+      setAllocatingId(booking.id);
+      try {
+        await trainSchedulingService.allocatePaidBooking(
+          booking.id,
+          candidate.id,
+        );
+        toast({
+          title: `Allocated ${booking.reference}`,
+          description: `Placed on ${candidate.reference ?? "train"} departing ${formatDate(candidate.scheduledDepartureDate)}. Customer notified of the date change.`,
+        });
+        setOtherDayModal(null);
+        void refetch();
+      } catch {
+        toast({ title: "Allocation failed", variant: "destructive" });
+      } finally {
+        setAllocatingId(null);
+      }
+    },
+    [otherDayModal, refetch, toast],
+  );
+
   const columns: ColumnDef<BookingListRow>[] = [
     {
       id: "booking",
@@ -433,13 +517,33 @@ export default function BookingRequestsPage() {
     {
       id: "actions",
       size: 140,
-      cell: ({ row }) => (
-        <BookingActionsMenu
-          row={row.original}
-          variant="table"
-          onSuppressRowClick={suppressRowClick}
-        />
-      ),
+      cell: ({ row }) => {
+        const b = row.original;
+        const needsAllocation = b.paymentStatus === "PAID" && !b.trainScheduleId;
+        return (
+          <Group gap="xs" wrap="nowrap">
+            {needsAllocation ? (
+              <Button
+                size="compact-xs"
+                color="edr-green"
+                loading={allocatingId === b.id}
+                onClick={(e) => {
+                  e.stopPropagation();
+                  suppressRowClick();
+                  void handleAllocatePaid(b);
+                }}
+              >
+                Allocate
+              </Button>
+            ) : null}
+            <BookingActionsMenu
+              row={b}
+              variant="table"
+              onSuppressRowClick={suppressRowClick}
+            />
+          </Group>
+        );
+      },
     },
   ];
 
@@ -602,7 +706,7 @@ export default function BookingRequestsPage() {
                     />
                     <Select
                       placeholder="All directions"
-                      data={TRADE_DIRECTION_OPTIONS}
+                      data={filterOptions(TRADE_DIRECTION_OPTIONS)}
                       value={directionFilter}
                       onChange={(v) => {
                         setDirectionFilter(v);
@@ -638,6 +742,16 @@ export default function BookingRequestsPage() {
                       radius="lg"
                       style={{ minWidth: 180 }}
                     />
+                    <Checkbox
+                      label="Paid, not allocated"
+                      checked={paidUnallocated}
+                      onChange={(e) => {
+                        setPaidUnallocated(e.currentTarget.checked);
+                        resetPage();
+                      }}
+                      radius="sm"
+                      style={{ alignSelf: "center" }}
+                    />
                     <Select
                       placeholder="Gov / Private"
                       data={OWNERSHIP_OPTIONS}
@@ -749,6 +863,42 @@ export default function BookingRequestsPage() {
           </Card>
         </Stack>
 
+        <Modal
+          opened={otherDayModal !== null}
+          onClose={() => setOtherDayModal(null)}
+          title="Allocate to another date"
+          centered
+        >
+          <Stack gap="sm">
+            <Text size="sm" c="dimmed">
+              No train on {otherDayModal ? formatDate(otherDayModal.booking.scheduledDate) : "the booking's day"}{" "}
+              fits booking {otherDayModal?.booking.reference}. These trains on
+              other dates do — the customer will be notified of the date change.
+            </Text>
+            {otherDayModal?.candidates.map((c) => (
+              <Group key={c.id} justify="space-between" wrap="nowrap">
+                <div>
+                  <Text size="sm" fw={500}>
+                    {c.reference ?? "Train"}
+                  </Text>
+                  <Text size="xs" c="dimmed">
+                    Departs {formatDate(c.scheduledDepartureDate)}
+                    {c.direction ? ` · ${c.direction}` : ""}
+                  </Text>
+                </div>
+                <Button
+                  size="compact-sm"
+                  color="edr-green"
+                  loading={allocatingId === otherDayModal.booking.id}
+                  onClick={() => void handleAllocateOtherDay(c)}
+                >
+                  Allocate
+                </Button>
+              </Group>
+            ))}
+          </Stack>
+        </Modal>
+
         {allocateBooking ? (
           <AllocateBookingWizard
             booking={allocateBooking}
diff --git a/apps/edr-freight-web/backoffice/src/pages/configuration/TradeAccessPage.tsx b/apps/edr-freight-web/backoffice/src/pages/configuration/TradeAccessPage.tsx
new file mode 100644
index 000000000..842f11064
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/pages/configuration/TradeAccessPage.tsx
@@ -0,0 +1,193 @@
+import { useMemo, useState } from "react";
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import toast from "react-hot-toast";
+
+import {
+  ALL_TRADE_DIRECTIONS,
+  TRADE_DIRECTION_LABELS,
+  userTradeAccessService,
+  type TradeDirection,
+} from "@/services/userTradeAccess.service";
+import {
+  Table,
+  TableBody,
+  TableCell,
+  TableHead,
+  TableHeader,
+  TableRow,
+} from "@/components/ui/table";
+
+const QUERY_KEY = ["user-trade-access", "list"] as const;
+
+type EmployeeRow = {
+  userId: string;
+  name: string;
+  email: string;
+};
+
+/**
+ * Per-user trade-direction access (Import / Export / Intercity checkboxes).
+ * All three checked (or never configured) = unrestricted; unchecking limits
+ * the user's contracts, bookings, schedules, batch board, payments, invoices
+ * and overview to the checked directions. Admins always bypass the scope.
+ */
+export default function TradeAccessPage() {
+  const queryClient = useQueryClient();
+  const [search, setSearch] = useState("");
+
+  const { data: usersResponse, isLoading: usersLoading } = useQuery({
+    queryKey: ["staff-users", "employees"],
+    queryFn: userTradeAccessService.employees,
+  });
+
+  const { data: configs, isLoading: configsLoading } = useQuery({
+    queryKey: QUERY_KEY,
+    queryFn: userTradeAccessService.list,
+  });
+
+  const saveMutation = useMutation({
+    mutationFn: ({
+      userId,
+      directions,
+    }: {
+      userId: string;
+      directions: TradeDirection[];
+    }) => userTradeAccessService.set(userId, directions),
+    onSuccess: () => {
+      void queryClient.invalidateQueries({ queryKey: QUERY_KEY });
+      void queryClient.invalidateQueries({
+        queryKey: ["user-trade-access", "me"],
+      });
+      toast.success("Trade access updated");
+    },
+  });
+
+  const configByUser = useMemo(() => {
+    const map = new Map<string, TradeDirection[]>();
+    for (const row of configs ?? []) map.set(row.userId, row.directions);
+    return map;
+  }, [configs]);
+
+  const rows: EmployeeRow[] = useMemo(() => {
+    const items = usersResponse?.items ?? [];
+    const mapped = items
+      .map((u) => ({
+        userId: u.id ?? "",
+        name: u.name?.en ?? u.username ?? "—",
+        email: u.email ?? "",
+      }))
+      .filter((r: EmployeeRow) => r.userId);
+    const term = search.trim().toLowerCase();
+    if (!term) return mapped;
+    return mapped.filter(
+      (r: EmployeeRow) =>
+        r.name.toLowerCase().includes(term) ||
+        r.email.toLowerCase().includes(term),
+    );
+  }, [usersResponse, search]);
+
+  // No row yet = unrestricted, so render as all three checked.
+  const directionsFor = (userId: string): TradeDirection[] =>
+    configByUser.get(userId) ?? [...ALL_TRADE_DIRECTIONS];
+
+  const toggle = (userId: string, direction: TradeDirection) => {
+    const current = directionsFor(userId);
+    const next = current.includes(direction)
+      ? current.filter((d) => d !== direction)
+      : [...current, direction];
+    saveMutation.mutate({ userId, directions: next });
+  };
+
+  const loading = usersLoading || configsLoading;
+
+  return (
+    <div className="space-y-4 p-4">
+      <div>
+        <h1 className="text-xl font-bold">Trade direction access</h1>
+        <p className="text-sm text-muted-foreground">
+          Choose which trade directions each backoffice user can see. This
+          filters their contracts, bookings, schedules, batch board, payments,
+          invoices and overview. All three checked means full access; super and
+          organization admins are never restricted.
+        </p>
+      </div>
+
+      <input
+        type="search"
+        value={search}
+        onChange={(e) => setSearch(e.target.value)}
+        placeholder="Search by name or email…"
+        className="w-full max-w-sm rounded-md border px-3 py-2 text-sm"
+      />
+
+      {loading ? (
+        <p className="text-sm text-muted-foreground">Loading users…</p>
+      ) : (
+        <Table>
+          <TableHeader>
+            <TableRow>
+              <TableHead>User</TableHead>
+              <TableHead>Email</TableHead>
+              {ALL_TRADE_DIRECTIONS.map((d) => (
+                <TableHead key={d} className="text-center">
+                  {TRADE_DIRECTION_LABELS[d]}
+                </TableHead>
+              ))}
+              <TableHead>Access</TableHead>
+            </TableRow>
+          </TableHeader>
+          <TableBody>
+            {rows.map((row) => {
+              const dirs = directionsFor(row.userId);
+              const unrestricted = dirs.length === ALL_TRADE_DIRECTIONS.length;
+              return (
+                <TableRow key={row.userId}>
+                  <TableCell className="font-medium">{row.name}</TableCell>
+                  <TableCell>{row.email}</TableCell>
+                  {ALL_TRADE_DIRECTIONS.map((d) => (
+                    <TableCell key={d} className="text-center">
+                      <input
+                        type="checkbox"
+                        className="h-4 w-4 accent-primary"
+                        checked={dirs.includes(d)}
+                        disabled={saveMutation.isPending}
+                        onChange={() => toggle(row.userId, d)}
+                        aria-label={`${row.name} — ${TRADE_DIRECTION_LABELS[d]}`}
+                      />
+                    </TableCell>
+                  ))}
+                  <TableCell>
+                    {unrestricted ? (
+                      <span className="text-xs text-muted-foreground">
+                        Full access
+                      </span>
+                    ) : dirs.length === 0 ? (
+                      <span className="text-xs font-medium text-red-600">
+                        No data
+                      </span>
+                    ) : (
+                      <span className="text-xs font-medium text-amber-600">
+                        {dirs.map((d) => TRADE_DIRECTION_LABELS[d]).join(" + ")}{" "}
+                        only
+                      </span>
+                    )}
+                  </TableCell>
+                </TableRow>
+              );
+            })}
+            {rows.length === 0 && (
+              <TableRow>
+                <TableCell
+                  colSpan={3 + ALL_TRADE_DIRECTIONS.length}
+                  className="text-center text-sm text-muted-foreground"
+                >
+                  No users found.
+                </TableCell>
+              </TableRow>
+            )}
+          </TableBody>
+        </Table>
+      )}
+    </div>
+  );
+}
diff --git a/apps/edr-freight-web/backoffice/src/pages/contracts/ClearanceDocumentsPage.tsx b/apps/edr-freight-web/backoffice/src/pages/contracts/ClearanceDocumentsPage.tsx
index b8a871b4b..8a7949410 100644
--- a/apps/edr-freight-web/backoffice/src/pages/contracts/ClearanceDocumentsPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/contracts/ClearanceDocumentsPage.tsx
@@ -1,3 +1,4 @@
+import { useMyTradeAccess } from "@/hooks/useMyTradeAccess";
 import {
   ActionIcon,
   Box,
@@ -92,6 +93,7 @@ export default function ClearanceDocumentsPage() {
   const [bookingStatuses, setBookingStatuses] = useState(
     BOOKING_STATUS_OPTIONS[0].value,
   );
+  const { filterOptions } = useMyTradeAccess();
   const [directionFilter, setDirectionFilter] = useState<string | null>(null);
   const [freightTypeFilter, setFreightTypeFilter] = useState<string | null>(null);
   const [ownershipFilter, setOwnershipFilter] = useState<string | null>(null);
@@ -309,7 +311,7 @@ export default function ClearanceDocumentsPage() {
               <Group gap="sm" mt="sm" wrap="wrap">
                 <Select
                   placeholder="Direction"
-                  data={TRADE_DIRECTION_OPTIONS}
+                  data={filterOptions(TRADE_DIRECTION_OPTIONS)}
                   value={directionFilter}
                   onChange={(v) => {
                     setDirectionFilter(v);
diff --git a/apps/edr-freight-web/backoffice/src/pages/contracts/ContractRequestsPage.tsx b/apps/edr-freight-web/backoffice/src/pages/contracts/ContractRequestsPage.tsx
index 6bbee237b..3ff989bb5 100644
--- a/apps/edr-freight-web/backoffice/src/pages/contracts/ContractRequestsPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/contracts/ContractRequestsPage.tsx
@@ -1,4 +1,5 @@
 import { directionLabel } from "@/lib/utils";
+import { useMyTradeAccess } from "@/hooks/useMyTradeAccess";
 import {
   ActionIcon,
   Box,
@@ -156,6 +157,7 @@ export default function ContractRequestsPage() {
   const [activeTab, setActiveTab] = useState<ContractStatusTabKey>("all");
   // Filter controls (empty/null = "all").
   const [statusFilter, setStatusFilter] = useState<string[]>([]);
+  const { filterOptions } = useMyTradeAccess();
   const [directionFilter, setDirectionFilter] = useState<string | null>(null);
   const [freightTypeFilter, setFreightTypeFilter] = useState<string | null>(
     null,
@@ -561,7 +563,7 @@ export default function ContractRequestsPage() {
                   />
                   <Select
                     placeholder="All directions"
-                    data={TRADE_DIRECTION_OPTIONS}
+                    data={filterOptions(TRADE_DIRECTION_OPTIONS)}
                     value={directionFilter}
                     onChange={(v) => {
                       setDirectionFilter(v);
diff --git a/apps/edr-freight-web/backoffice/src/pages/dashboard/OverviewPage.tsx b/apps/edr-freight-web/backoffice/src/pages/dashboard/OverviewPage.tsx
index c7606641e..12bce6aae 100644
--- a/apps/edr-freight-web/backoffice/src/pages/dashboard/OverviewPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/dashboard/OverviewPage.tsx
@@ -5,6 +5,7 @@ import {
   FileSignature,
   FileText,
   Train,
+  TrainFront,
   UserCheck,
   Users,
 } from "lucide-react";
@@ -13,7 +14,6 @@ import {
   Badge,
   Button,
   Container,
-  Paper,
   Skeleton,
   Stack,
   Tabs,
@@ -22,7 +22,6 @@ import { useQueryClient } from "@tanstack/react-query";
 
 import { useAuth } from "@/auth/useAuth";
 import { OverviewPageHeader } from "@/components/overview/OverviewPageHeader";
-import { OverviewQuickLinks } from "@/components/overview/OverviewQuickLinks";
 import { OverviewTabContent } from "@/components/overview/OverviewTabContent";
 import "@/components/overview/overview.css";
 import { QUERY_KEYS } from "@/constants/QUERY_KEYS";
@@ -82,6 +81,18 @@ const TAB_ITEMS: Array<{
       FREIGHT_PERMS.lastMile.view,
     ],
   },
+  {
+    value: "fleet",
+    label: "Fleet",
+    icon: TrainFront,
+    kpiKey: "operations",
+    metricKey: "wagonsAvailable",
+    permission: [
+      FREIGHT_PERMS.fleet.view,
+      FREIGHT_PERMS.wagons.view,
+      FREIGHT_PERMS.trainScheduling.view,
+    ],
+  },
   {
     value: "customers",
     label: "Customers",
@@ -174,6 +185,12 @@ const OverviewPage = () => {
           </Alert>
         )}
 
+        {visibleTabs.length === 0 && !isLoading && !isError && (
+          <Alert color="gray" variant="light" title="No dashboard sections available">
+            Your role has no access to any overview section.
+          </Alert>
+        )}
+
         {visibleTabs.length > 0 && (
           <Tabs
             value={currentTab}
@@ -220,10 +237,6 @@ const OverviewPage = () => {
             ))}
           </Tabs>
         )}
-
-        <Paper p="lg" radius="lg" withBorder>
-          <OverviewQuickLinks />
-        </Paper>
       </Stack>
     </Container>
   );
diff --git a/apps/edr-freight-web/backoffice/src/pages/reports/ReportPage.tsx b/apps/edr-freight-web/backoffice/src/pages/reports/ReportPage.tsx
new file mode 100644
index 000000000..71a270a78
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/pages/reports/ReportPage.tsx
@@ -0,0 +1,445 @@
+import {
+  Button,
+  Card,
+  Group,
+  MultiSelect,
+  Select,
+  Text,
+} from "@mantine/core";
+import { DateInput } from "@mantine/dates";
+import { keepPreviousData, useQuery } from "@tanstack/react-query";
+import {
+  DataTable,
+  DataTableFooter,
+  usePagination,
+  type ColumnDef,
+} from "@edr/ui-common";
+import { Download, FileSpreadsheet, Printer, RotateCcw } from "lucide-react";
+import { useMemo } from "react";
+import { useParams, useSearchParams, Link } from "react-router-dom";
+import {
+  Area,
+  AreaChart,
+  Bar,
+  BarChart,
+  CartesianGrid,
+  Legend,
+  Line,
+  LineChart,
+  ResponsiveContainer,
+  Tooltip,
+  XAxis,
+  YAxis,
+} from "recharts";
+import * as XLSX from "xlsx";
+import { ALL_TRADE_DIRECTIONS, TRADE_DIRECTION_LABELS } from "@edr/types";
+
+import { KpiStrip, PageContainer, PageHeader } from "@/components/page";
+import { overviewChartColors } from "@/components/overview/overview.styles";
+import { api } from "@/services/api";
+import type { ReportQueryInput, ReportRow } from "@/types/reports";
+import {
+  REPORT_CONFIG_BY_KEY,
+  type ReportColumn,
+  type ReportConfig,
+} from "./reportConfigs";
+
+const compact = new Intl.NumberFormat("en", { notation: "compact" });
+
+const UNIT_SUFFIX = { ETB: " ETB", t: " t", "%": "%", min: " min" } as const;
+
+function formatCell(value: unknown, col: ReportColumn): string {
+  if (value === null || value === undefined || value === "") return "—";
+  if (col.unit || col.numeric) {
+    const n = Number(value);
+    if (!Number.isNaN(n)) {
+      return `${n.toLocaleString()}${col.unit ? UNIT_SUFFIX[col.unit] : ""}`;
+    }
+  }
+  return String(value);
+}
+
+const toDate = (s: string | null): Date | null => (s ? new Date(s) : null);
+// Mantine DateInput onChange emits a date string (or null).
+const toParam = (d: Date | string | null): string | null => {
+  if (!d) return null;
+  return typeof d === "string" ? d.slice(0, 10) : d.toISOString().slice(0, 10);
+};
+
+function downloadBlob(content: BlobPart, type: string, filename: string) {
+  const url = URL.createObjectURL(new Blob([content], { type }));
+  const a = document.createElement("a");
+  a.href = url;
+  a.download = filename;
+  a.click();
+  URL.revokeObjectURL(url);
+}
+
+function exportCsv(config: ReportConfig, rows: ReportRow[]) {
+  const esc = (v: unknown) => `"${String(v ?? "").replace(/"/g, '""')}"`;
+  const lines = [
+    config.columns.map((c) => esc(c.label)).join(","),
+    ...rows.map((r) => config.columns.map((c) => esc(r[c.key])).join(",")),
+  ];
+  downloadBlob(lines.join("\n"), "text/csv;charset=utf-8", `${config.key}.csv`);
+}
+
+function exportXlsx(config: ReportConfig, rows: ReportRow[]) {
+  const sheetRows = rows.map((r) =>
+    Object.fromEntries(config.columns.map((c) => [c.label, r[c.key] ?? ""])),
+  );
+  const wb = XLSX.utils.book_new();
+  XLSX.utils.book_append_sheet(
+    wb,
+    XLSX.utils.json_to_sheet(sheetRows),
+    config.title.slice(0, 31),
+  );
+  XLSX.writeFile(wb, `${config.key}.xlsx`);
+}
+
+function ReportChartView({
+  config,
+  rows,
+}: {
+  config: ReportConfig;
+  rows: ReportRow[];
+}) {
+  const chart = config.chart;
+  const data = useMemo(() => {
+    if (!chart) return [];
+    const sliced = chart.topN ? rows.slice(0, chart.topN) : rows;
+    // xKey "a+b" concatenates columns (e.g. origin+destination → "A → B").
+    const keys = chart.xKey.split("+");
+    return sliced.map((r) => ({
+      ...r,
+      __x:
+        keys.length > 1
+          ? keys.map((k) => String(r[k] ?? "")).join(" → ")
+          : String(r[chart.xKey] ?? ""),
+    }));
+  }, [chart, rows]);
+
+  if (!chart) return null;
+  if (data.length === 0) {
+    return (
+      <Card withBorder shadow="sm">
+        <Text c="dimmed" ta="center" py="xl">
+          No data for the selected filters
+        </Text>
+      </Card>
+    );
+  }
+
+  const ChartComponent =
+    chart.type === "bar" ? BarChart : chart.type === "line" ? LineChart : AreaChart;
+
+  return (
+    <Card withBorder shadow="sm">
+      <ResponsiveContainer width="100%" height={280}>
+        <ChartComponent data={data} margin={{ top: 8, right: 8, left: 8, bottom: 0 }}>
+          <CartesianGrid strokeDasharray="3 3" stroke="#e5e7eb" />
+          <XAxis dataKey="__x" tick={{ fontSize: 12 }} interval="preserveStartEnd" />
+          <YAxis
+            tick={{ fontSize: 12 }}
+            tickFormatter={(v: number) => compact.format(v)}
+            width={56}
+          />
+          <Tooltip formatter={(value) => Number(value ?? 0).toLocaleString()} />
+          {chart.series.length > 1 ? <Legend /> : null}
+          {chart.series.map((s, i) => {
+            const color =
+              overviewChartColors.pipeline[i % overviewChartColors.pipeline.length];
+            if (chart.type === "bar") {
+              return (
+                <Bar key={s.key} dataKey={s.key} name={s.label} fill={color} radius={[4, 4, 0, 0]} />
+              );
+            }
+            if (chart.type === "line") {
+              return (
+                <Line
+                  key={s.key}
+                  type="monotone"
+                  dataKey={s.key}
+                  name={s.label}
+                  stroke={color}
+                  strokeWidth={2}
+                  dot={false}
+                />
+              );
+            }
+            return (
+              <Area
+                key={s.key}
+                type="monotone"
+                dataKey={s.key}
+                name={s.label}
+                stroke={color}
+                fill={color}
+                fillOpacity={0.15}
+                strokeWidth={2}
+              />
+            );
+          })}
+        </ChartComponent>
+      </ResponsiveContainer>
+    </Card>
+  );
+}
+
+export default function ReportPage() {
+  const { reportKey = "" } = useParams<{ reportKey: string }>();
+  const config = REPORT_CONFIG_BY_KEY.get(reportKey);
+  const [params, setParams] = useSearchParams();
+  const { pagination, setPagination } = usePagination({ pageSize: 20 });
+
+  const setParam = (name: string, value: string | null) => {
+    setParams(
+      (prev) => {
+        if (value) prev.set(name, value);
+        else prev.delete(name);
+        return prev;
+      },
+      { replace: true },
+    );
+    setPagination((p) => ({ ...p, pageIndex: 0 }));
+  };
+
+  const input: ReportQueryInput = {
+    key: reportKey,
+    dateFrom: params.get("dateFrom") ?? undefined,
+    dateTo: params.get("dateTo") ?? undefined,
+    granularity:
+      (params.get("granularity") as ReportQueryInput["granularity"]) ?? undefined,
+    yardIds: params.get("yardIds") ?? undefined,
+    statuses: params.get("statuses") ?? undefined,
+    direction: params.get("direction") ?? undefined,
+    freightType: params.get("freightType") ?? undefined,
+  };
+
+  const reportQuery = useQuery(
+    api.reports.run.queryOptions({
+      input,
+      placeholderData: keepPreviousData,
+      staleTime: 30_000,
+      enabled: Boolean(config),
+    }),
+  );
+
+  const yardsQuery = useQuery(
+    api.routes.yards.queryOptions({
+      staleTime: 5 * 60_000,
+      enabled: Boolean(config?.filters.includes("yards")),
+    }),
+  );
+
+  if (!config) {
+    return (
+      <PageContainer>
+        <PageHeader title="Unknown report" backTo="/dashboard/reports" />
+        <Text>
+          This report does not exist. <Link to="/dashboard/reports">Back to reports</Link>
+        </Text>
+      </PageContainer>
+    );
+  }
+
+  const rows = reportQuery.data?.rows ?? [];
+  const kpis = reportQuery.data?.kpis ?? [];
+  const pageCount = Math.max(1, Math.ceil(rows.length / pagination.pageSize));
+
+  const columns: ColumnDef<ReportRow, unknown>[] = config.columns.map((col) => ({
+    accessorKey: col.key,
+    header: col.label,
+    cell: (info) => formatCell(info.getValue(), col),
+  }));
+
+  const tableStatus = reportQuery.isLoading
+    ? "loading"
+    : reportQuery.isError
+      ? "error"
+      : "success";
+
+  return (
+    <PageContainer>
+      <PageHeader
+        title={config.title}
+        subtitle={config.description}
+        backTo="/dashboard/reports"
+        action={
+          <Group gap="xs">
+            <Button
+              variant="default"
+              size="xs"
+              leftSection={<Download size={14} />}
+              onClick={() => exportCsv(config, rows)}
+              disabled={rows.length === 0}
+            >
+              CSV
+            </Button>
+            <Button
+              variant="default"
+              size="xs"
+              leftSection={<FileSpreadsheet size={14} />}
+              onClick={() => exportXlsx(config, rows)}
+              disabled={rows.length === 0}
+            >
+              Excel
+            </Button>
+            <Button
+              variant="default"
+              size="xs"
+              leftSection={<Printer size={14} />}
+              onClick={() => window.print()}
+            >
+              Print
+            </Button>
+          </Group>
+        }
+      />
+
+      <Card withBorder shadow="sm">
+        <Group gap="sm" align="flex-end" wrap="wrap">
+          <DateInput
+            label="From"
+            size="xs"
+            clearable
+            value={toDate(params.get("dateFrom"))}
+            maxDate={toDate(params.get("dateTo")) ?? undefined}
+            onChange={(d) => setParam("dateFrom", toParam(d))}
+            placeholder="All time"
+          />
+          <DateInput
+            label="To"
+            size="xs"
+            clearable
+            value={toDate(params.get("dateTo"))}
+            minDate={toDate(params.get("dateFrom")) ?? undefined}
+            onChange={(d) => setParam("dateTo", toParam(d))}
+            placeholder="All time"
+          />
+          {config.filters.includes("granularity") ? (
+            <Select
+              label="Group by"
+              size="xs"
+              data={[
+                { value: "day", label: "Day" },
+                { value: "week", label: "Week" },
+                { value: "month", label: "Month" },
+              ]}
+              value={params.get("granularity") ?? "day"}
+              onChange={(v) => setParam("granularity", v)}
+              allowDeselect={false}
+            />
+          ) : null}
+          {config.filters.includes("yards") ? (
+            <MultiSelect
+              label="Yards"
+              size="xs"
+              searchable
+              clearable
+              w={220}
+              data={(yardsQuery.data ?? []).map((y) => ({
+                value: y.id,
+                label: y.label,
+              }))}
+              value={params.get("yardIds")?.split(",").filter(Boolean) ?? []}
+              onChange={(v) => setParam("yardIds", v.length ? v.join(",") : null)}
+              placeholder="All yards"
+            />
+          ) : null}
+          {config.filters.includes("direction") ? (
+            <Select
+              label="Direction"
+              size="xs"
+              clearable
+              data={ALL_TRADE_DIRECTIONS.map((d) => ({
+                value: d,
+                label: TRADE_DIRECTION_LABELS[d],
+              }))}
+              value={params.get("direction")}
+              onChange={(v) => setParam("direction", v)}
+              placeholder="All"
+            />
+          ) : null}
+          {config.filters.includes("freightType") ? (
+            <Select
+              label="Freight type"
+              size="xs"
+              clearable
+              data={["CONTAINER", "BULK"]}
+              value={params.get("freightType")}
+              onChange={(v) => setParam("freightType", v)}
+              placeholder="All"
+            />
+          ) : null}
+          {config.filters.includes("statuses") && config.statusOptions ? (
+            <MultiSelect
+              label="Status"
+              size="xs"
+              searchable
+              clearable
+              w={220}
+              data={config.statusOptions}
+              value={params.get("statuses")?.split(",").filter(Boolean) ?? []}
+              onChange={(v) => setParam("statuses", v.length ? v.join(",") : null)}
+              placeholder="Default (active)"
+            />
+          ) : null}
+          <Button
+            variant="subtle"
+            size="xs"
+            leftSection={<RotateCcw size={14} />}
+            onClick={() => setParams({}, { replace: true })}
+          >
+            Reset
+          </Button>
+        </Group>
+      </Card>
+
+      <KpiStrip
+        loading={reportQuery.isLoading}
+        items={kpis.map((k) => ({
+          label: k.label,
+          value: k.value.toLocaleString(),
+          hint: k.unit,
+        }))}
+      />
+
+      <ReportChartView config={config} rows={rows} />
+
+      <DataTable
+        columns={columns}
+        data={rows}
+        status={tableStatus}
+        emptyMessage="No data for the selected filters"
+        error={
+          reportQuery.isError
+            ? {
+                message: "Failed to load report",
+                onRetry: () => void reportQuery.refetch(),
+              }
+            : undefined
+        }
+        pagination={{
+          pageIndex: pagination.pageIndex,
+          pageSize: pagination.pageSize,
+          pageCount,
+          totalCount: rows.length,
+        }}
+        tableOptions={{
+          manualPagination: false,
+          state: { pagination },
+          onPaginationChange: setPagination,
+          autoResetPageIndex: false,
+        }}
+        footer={({ table, pagination: p }) => (
+          <DataTableFooter
+            table={table}
+            pagination={p}
+            options={{ labels: { items: "rows" } }}
+          />
+        )}
+      />
+    </PageContainer>
+  );
+}
diff --git a/apps/edr-freight-web/backoffice/src/pages/reports/ReportsHubPage.tsx b/apps/edr-freight-web/backoffice/src/pages/reports/ReportsHubPage.tsx
new file mode 100644
index 000000000..f8f6f161d
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/pages/reports/ReportsHubPage.tsx
@@ -0,0 +1,159 @@
+import {
+  ActionIcon,
+  Badge,
+  Card,
+  Group,
+  SimpleGrid,
+  Stack,
+  Text,
+  TextInput,
+  Title,
+} from "@mantine/core";
+import { Search, Star } from "lucide-react";
+import { useMemo, useState } from "react";
+import { useNavigate } from "react-router-dom";
+
+import { PageContainer, PageHeader } from "@/components/page";
+import {
+  REPORT_CONFIGS,
+  REPORT_DOMAINS,
+  type ReportConfig,
+} from "./reportConfigs";
+
+const FAVORITES_KEY = "reports.favorites";
+
+const loadFavorites = (): string[] => {
+  try {
+    return JSON.parse(localStorage.getItem(FAVORITES_KEY) ?? "[]");
+  } catch {
+    return [];
+  }
+};
+
+function ReportCard({
+  config,
+  favorite,
+  onToggleFavorite,
+}: {
+  config: ReportConfig;
+  favorite: boolean;
+  onToggleFavorite: () => void;
+}) {
+  const navigate = useNavigate();
+  return (
+    <Card
+      withBorder
+      shadow="sm"
+      className="cursor-pointer transition-colors hover:bg-gray-50"
+      onClick={() => navigate(`/dashboard/reports/${config.key}`)}
+    >
+      <Group justify="space-between" align="flex-start" wrap="nowrap">
+        <div style={{ minWidth: 0 }}>
+          <Text fw={600} truncate>
+            {config.title}
+          </Text>
+          <Text size="sm" c="dimmed" lineClamp={2}>
+            {config.description}
+          </Text>
+        </div>
+        <ActionIcon
+          variant="subtle"
+          color={favorite ? "yellow" : "gray"}
+          aria-label={favorite ? "Remove from favorites" : "Add to favorites"}
+          onClick={(e) => {
+            e.stopPropagation();
+            onToggleFavorite();
+          }}
+        >
+          <Star size={16} fill={favorite ? "currentColor" : "none"} />
+        </ActionIcon>
+      </Group>
+      <Badge mt="sm" size="sm" variant="light">
+        {config.domain}
+      </Badge>
+    </Card>
+  );
+}
+
+export default function ReportsHubPage() {
+  const [search, setSearch] = useState("");
+  const [favorites, setFavorites] = useState<string[]>(loadFavorites);
+
+  const toggleFavorite = (key: string) => {
+    setFavorites((prev) => {
+      const next = prev.includes(key)
+        ? prev.filter((k) => k !== key)
+        : [...prev, key];
+      localStorage.setItem(FAVORITES_KEY, JSON.stringify(next));
+      return next;
+    });
+  };
+
+  const visible = useMemo(() => {
+    const q = search.trim().toLowerCase();
+    if (!q) return REPORT_CONFIGS;
+    return REPORT_CONFIGS.filter(
+      (c) =>
+        c.title.toLowerCase().includes(q) ||
+        c.description.toLowerCase().includes(q),
+    );
+  }, [search]);
+
+  const pinned = visible.filter((c) => favorites.includes(c.key));
+
+  const renderGrid = (configs: ReportConfig[]) => (
+    <SimpleGrid cols={{ base: 1, sm: 2, lg: 3 }} spacing="md">
+      {configs.map((c) => (
+        <ReportCard
+          key={c.key}
+          config={c}
+          favorite={favorites.includes(c.key)}
+          onToggleFavorite={() => toggleFavorite(c.key)}
+        />
+      ))}
+    </SimpleGrid>
+  );
+
+  return (
+    <PageContainer>
+      <PageHeader
+        title="Reports"
+        subtitle="Operational, commercial and financial reporting"
+        action={
+          <TextInput
+            size="xs"
+            w={240}
+            leftSection={<Search size={14} />}
+            placeholder="Search reports…"
+            value={search}
+            onChange={(e) => setSearch(e.currentTarget.value)}
+          />
+        }
+      />
+
+      {pinned.length ? (
+        <Stack gap="sm">
+          <Title order={4}>Favorites</Title>
+          {renderGrid(pinned)}
+        </Stack>
+      ) : null}
+
+      {REPORT_DOMAINS.map((domain) => {
+        const configs = visible.filter((c) => c.domain === domain);
+        if (!configs.length) return null;
+        return (
+          <Stack key={domain} gap="sm">
+            <Title order={4}>{domain}</Title>
+            {renderGrid(configs)}
+          </Stack>
+        );
+      })}
+
+      {visible.length === 0 ? (
+        <Text c="dimmed" ta="center" py="xl">
+          No reports match “{search}”
+        </Text>
+      ) : null}
+    </PageContainer>
+  );
+}
diff --git a/apps/edr-freight-web/backoffice/src/pages/reports/reportConfigs.ts b/apps/edr-freight-web/backoffice/src/pages/reports/reportConfigs.ts
new file mode 100644
index 000000000..9aec4fec0
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/pages/reports/reportConfigs.ts
@@ -0,0 +1,444 @@
+import { BookingStatus } from "@edr/types";
+
+export type ReportDomain = "Commercial" | "Operations" | "Finance" | "Data";
+
+export type ReportColumnUnit = "ETB" | "t" | "%" | "min";
+
+export interface ReportColumn {
+  key: string;
+  label: string;
+  /** Numeric unit — formats the cell (thousands separators, suffix). */
+  unit?: ReportColumnUnit;
+  numeric?: boolean;
+}
+
+export interface ReportChart {
+  type: "area" | "line" | "bar";
+  xKey: string;
+  series: { key: string; label: string }[];
+  /** Chart only the first N rows (rows arrive sorted by the backend). */
+  topN?: number;
+}
+
+export type ReportFilterKey =
+  | "granularity"
+  | "yards"
+  | "direction"
+  | "freightType"
+  | "statuses";
+
+export interface ReportConfig {
+  key: string;
+  title: string;
+  description: string;
+  domain: ReportDomain;
+  filters: ReportFilterKey[];
+  /** Options for the `statuses` filter, when enabled. */
+  statusOptions?: string[];
+  chart?: ReportChart;
+  columns: ReportColumn[];
+}
+
+// Full enum from @edr/types; Set dedupes the deprecated AwaitingPayment alias.
+const BOOKING_STATUSES = [...new Set(Object.values(BookingStatus))];
+
+// Full list mirroring CONTRACT_STATUSES in contract.entity.ts (no shared enum
+// in @edr/types yet).
+const CONTRACT_STATUSES = [
+  "DRAFT",
+  "SUBMITTED",
+  "PRICE_CHANGED_PENDING_CONFIRM",
+  "CHANGES_REQUESTED",
+  "PENDING_APPROVAL",
+  "APPROVED",
+  "APPROVED_PENDING_SIGNATURE",
+  "CONTRACT_READY",
+  "SIGNED_CUSTOMER",
+  "FULLY_EXECUTED",
+  "CONTRACT_ACTIVE",
+  "AWAITING_CLEARANCE_DOCUMENTS",
+  "CLEARANCE_UNDER_REVIEW",
+  "CLEARANCE_READY_FOR_BOOKING",
+  "ACTIVE_SHIPMENT_IN_PROGRESS",
+  "SUSPENDED",
+  "CONTRACT_CLOSED",
+  "EXPIRED",
+  "REJECTED",
+  "CANCELLED",
+  "RENEWAL_DRAFT",
+  "RENEWAL_SUBMITTED",
+  "RENEWAL_PENDING_APPROVAL",
+  "AMENDMENTS_PROPOSED",
+  "ARCHIVED",
+];
+
+const INVOICE_STATUSES = [
+  "ISSUED",
+  "PENDING",
+  "PARTIALLY_PAID",
+  "PAID",
+  "OVERDUE",
+  "REFUNDED",
+];
+
+export const REPORT_CONFIGS: ReportConfig[] = [
+  {
+    key: "bookings-trend",
+    title: "Bookings Trend",
+    description: "Booking volume, tonnage and revenue over time",
+    domain: "Commercial",
+    filters: ["granularity", "yards", "direction", "freightType", "statuses"],
+    statusOptions: BOOKING_STATUSES,
+    chart: {
+      type: "area",
+      xKey: "period",
+      series: [{ key: "revenue", label: "Revenue (ETB)" }],
+    },
+    columns: [
+      { key: "period", label: "Period" },
+      { key: "bookings", label: "Bookings", numeric: true },
+      { key: "tons", label: "Tonnage", unit: "t" },
+      { key: "revenue", label: "Revenue", unit: "ETB" },
+    ],
+  },
+  {
+    key: "revenue-by-customer",
+    title: "Revenue by Customer",
+    description: "Ranked customers by booking revenue",
+    domain: "Commercial",
+    filters: ["yards", "direction", "freightType", "statuses"],
+    statusOptions: BOOKING_STATUSES,
+    chart: {
+      type: "bar",
+      xKey: "customer",
+      series: [{ key: "revenue", label: "Revenue (ETB)" }],
+      topN: 10,
+    },
+    columns: [
+      { key: "customer", label: "Customer" },
+      { key: "bookings", label: "Bookings", numeric: true },
+      { key: "tons", label: "Tonnage", unit: "t" },
+      { key: "revenue", label: "Revenue", unit: "ETB" },
+    ],
+  },
+  {
+    key: "revenue-by-lane",
+    title: "Revenue by Lane",
+    description: "Origin → destination lanes by tonnage and revenue",
+    domain: "Commercial",
+    filters: ["direction", "freightType", "statuses"],
+    statusOptions: BOOKING_STATUSES,
+    chart: {
+      type: "bar",
+      xKey: "origin+destination",
+      series: [{ key: "revenue", label: "Revenue (ETB)" }],
+      topN: 10,
+    },
+    columns: [
+      { key: "origin", label: "Origin" },
+      { key: "destination", label: "Destination" },
+      { key: "bookings", label: "Bookings", numeric: true },
+      { key: "tons", label: "Tonnage", unit: "t" },
+      { key: "revenue", label: "Revenue", unit: "ETB" },
+    ],
+  },
+  {
+    key: "contract-utilization",
+    title: "Contract Utilization",
+    description: "Committed scope caps vs booked tonnage per contract",
+    domain: "Commercial",
+    filters: ["direction", "statuses"],
+    statusOptions: CONTRACT_STATUSES,
+    columns: [
+      { key: "reference", label: "Contract" },
+      { key: "customer", label: "Customer" },
+      { key: "status", label: "Status" },
+      { key: "kind", label: "Kind" },
+      { key: "valid_from", label: "Valid from" },
+      { key: "valid_until", label: "Valid until" },
+      { key: "committed", label: "Committed", unit: "t" },
+      { key: "booked_tons", label: "Booked", unit: "t" },
+      { key: "bookings", label: "Bookings", numeric: true },
+      { key: "utilization_pct", label: "Utilization", unit: "%" },
+    ],
+  },
+  {
+    key: "train-on-time",
+    title: "Train On-Time Performance",
+    description: "Departure punctuality and delays by lane (60-min grace)",
+    domain: "Operations",
+    filters: ["yards", "direction"],
+    chart: {
+      type: "bar",
+      xKey: "origin+destination",
+      series: [{ key: "on_time_pct", label: "On-time %" }],
+      topN: 15,
+    },
+    columns: [
+      { key: "origin", label: "Origin" },
+      { key: "destination", label: "Destination" },
+      { key: "trips", label: "Trips", numeric: true },
+      { key: "departed", label: "Departed", numeric: true },
+      { key: "avg_dep_delay_min", label: "Avg dep. delay", unit: "min" },
+      { key: "avg_arr_delay_min", label: "Avg arr. delay", unit: "min" },
+      { key: "on_time_pct", label: "On-time", unit: "%" },
+    ],
+  },
+  {
+    key: "schedule-fill-rate",
+    title: "Schedule Fill Rate",
+    description: "Booked tonnage vs wagon capacity per train schedule",
+    domain: "Operations",
+    filters: ["yards", "direction"],
+    chart: {
+      type: "line",
+      xKey: "departure",
+      series: [{ key: "fill_pct", label: "Fill %" }],
+    },
+    columns: [
+      { key: "train_number", label: "Train" },
+      { key: "departure", label: "Departure" },
+      { key: "origin", label: "Origin" },
+      { key: "destination", label: "Destination" },
+      { key: "direction", label: "Direction" },
+      { key: "status", label: "Status" },
+      { key: "wagon_count", label: "Wagons", numeric: true },
+      { key: "capacity_tons", label: "Capacity", unit: "t" },
+      { key: "booked_tons", label: "Booked", unit: "t" },
+      { key: "fill_pct", label: "Fill", unit: "%" },
+    ],
+  },
+  {
+    key: "trips-per-route",
+    title: "Trips per Route",
+    description: "Completed trips and tonnage hauled per lane",
+    domain: "Operations",
+    filters: ["yards", "direction"],
+    chart: {
+      type: "bar",
+      xKey: "origin+destination",
+      series: [{ key: "trips", label: "Trips" }],
+      topN: 15,
+    },
+    columns: [
+      { key: "origin", label: "Origin" },
+      { key: "destination", label: "Destination" },
+      { key: "direction", label: "Direction" },
+      { key: "trips", label: "Trips", numeric: true },
+      { key: "tons_hauled", label: "Tonnage hauled", unit: "t" },
+      { key: "avg_tons_per_trip", label: "Avg per trip", unit: "t" },
+    ],
+  },
+  {
+    key: "invoiced-vs-collected",
+    title: "Invoiced vs Collected",
+    description: "Billing issued vs payments received over time",
+    domain: "Finance",
+    filters: ["granularity", "direction"],
+    chart: {
+      type: "line",
+      xKey: "period",
+      series: [
+        { key: "invoiced", label: "Invoiced (ETB)" },
+        { key: "collected", label: "Collected (ETB)" },
+      ],
+    },
+    columns: [
+      { key: "period", label: "Period" },
+      { key: "invoices", label: "Invoices", numeric: true },
+      { key: "invoiced", label: "Invoiced", unit: "ETB" },
+      { key: "collected", label: "Collected", unit: "ETB" },
+      { key: "outstanding", label: "Outstanding", unit: "ETB" },
+    ],
+  },
+  {
+    key: "aging-receivables",
+    title: "Aging Receivables",
+    description: "Outstanding invoice balances by age bucket per customer",
+    domain: "Finance",
+    filters: ["direction", "statuses"],
+    statusOptions: INVOICE_STATUSES,
+    chart: {
+      type: "bar",
+      xKey: "customer",
+      series: [{ key: "outstanding", label: "Outstanding (ETB)" }],
+      topN: 10,
+    },
+    columns: [
+      { key: "customer", label: "Customer" },
+      { key: "invoices", label: "Invoices", numeric: true },
+      { key: "outstanding", label: "Outstanding", unit: "ETB" },
+      { key: "current", label: "Current", unit: "ETB" },
+      { key: "overdue_0_30", label: "0–30d", unit: "ETB" },
+      { key: "overdue_31_60", label: "31–60d", unit: "ETB" },
+      { key: "overdue_61_90", label: "61–90d", unit: "ETB" },
+      { key: "overdue_90_plus", label: "90d+", unit: "ETB" },
+    ],
+  },
+  {
+    key: "revenue-by-payment-method",
+    title: "Revenue by Payment Method",
+    description: "Successful payments broken down by method",
+    domain: "Finance",
+    filters: ["direction"],
+    chart: {
+      type: "bar",
+      xKey: "method",
+      series: [{ key: "amount", label: "Amount (ETB)" }],
+    },
+    columns: [
+      { key: "method", label: "Method" },
+      { key: "payments", label: "Payments", numeric: true },
+      { key: "amount", label: "Amount", unit: "ETB" },
+    ],
+  },
+  // --- Record-level list exports (Data domain) — filtered or full dumps ---
+  {
+    key: "bookings-list",
+    title: "Bookings Export",
+    description: "Booking records with customer, lane, cargo, amounts",
+    domain: "Data",
+    filters: ["yards", "direction", "freightType", "statuses"],
+    statusOptions: BOOKING_STATUSES,
+    columns: [
+      { key: "reference", label: "Reference" },
+      { key: "created", label: "Created" },
+      { key: "customer", label: "Customer" },
+      { key: "status", label: "Status" },
+      { key: "freight_type", label: "Freight" },
+      { key: "direction", label: "Direction" },
+      { key: "origin", label: "Origin" },
+      { key: "destination", label: "Destination" },
+      { key: "cargo", label: "Cargo" },
+      { key: "tons", label: "Tonnage", unit: "t" },
+      { key: "amount", label: "Amount", unit: "ETB" },
+      { key: "payment_status", label: "Payment" },
+      { key: "scheduling_status", label: "Scheduling" },
+    ],
+  },
+  {
+    key: "contracts-list",
+    title: "Contracts Export",
+    description: "Contract records with validity, status, customer",
+    domain: "Data",
+    filters: ["direction", "statuses"],
+    statusOptions: CONTRACT_STATUSES,
+    columns: [
+      { key: "reference", label: "Reference" },
+      { key: "customer", label: "Customer" },
+      { key: "kind", label: "Kind" },
+      { key: "status", label: "Status" },
+      { key: "direction", label: "Direction" },
+      { key: "freight_type", label: "Freight" },
+      { key: "valid_from", label: "Valid from" },
+      { key: "valid_until", label: "Valid until" },
+      { key: "created", label: "Created" },
+    ],
+  },
+  {
+    key: "schedules-list",
+    title: "Train Schedules Export",
+    description: "Schedule records with planned vs actual times",
+    domain: "Data",
+    filters: ["yards", "direction", "statuses"],
+    statusOptions: ["DRAFT", "SCHEDULED", "DISPATCHED", "ARRIVED", "CANCELLED"],
+    columns: [
+      { key: "train_number", label: "Train" },
+      { key: "reference", label: "Reference" },
+      { key: "direction", label: "Direction" },
+      { key: "status", label: "Status" },
+      { key: "origin", label: "Origin" },
+      { key: "destination", label: "Destination" },
+      { key: "scheduled_departure", label: "Sched. departure" },
+      { key: "actual_departure", label: "Actual departure" },
+      { key: "scheduled_arrival", label: "Sched. arrival" },
+      { key: "actual_arrival", label: "Actual arrival" },
+      { key: "max_wagons", label: "Max wagons", numeric: true },
+      { key: "wagon_count", label: "Wagons", numeric: true },
+    ],
+  },
+  {
+    key: "fleet-wagons",
+    title: "Wagons Export",
+    description: "Wagon fleet with type, capacity, status, location",
+    domain: "Data",
+    filters: ["yards", "statuses"],
+    statusOptions: ["AVAILABLE", "ASSIGNED", "MAINTENANCE"],
+    columns: [
+      { key: "wagon_number", label: "Wagon" },
+      { key: "type", label: "Type" },
+      { key: "capacity_tons", label: "Capacity", unit: "t" },
+      { key: "status", label: "Status" },
+      { key: "current_yard", label: "Current yard" },
+    ],
+  },
+  {
+    key: "fleet-locomotives",
+    title: "Locomotives Export",
+    description: "Locomotive fleet with type, pull capacity, status",
+    domain: "Data",
+    filters: ["yards", "statuses"],
+    statusOptions: ["AVAILABLE", "OUT_OF_SERVICE"],
+    columns: [
+      { key: "code", label: "Code" },
+      { key: "name", label: "Name" },
+      { key: "locomotive_type", label: "Type" },
+      { key: "max_pull_tons", label: "Max pull", unit: "t" },
+      { key: "status", label: "Status" },
+      { key: "current_yard", label: "Current yard" },
+    ],
+  },
+  {
+    key: "customers-list",
+    title: "Customers Export",
+    description: "Company records with type, status, TIN",
+    domain: "Data",
+    filters: ["statuses"],
+    statusOptions: ["pending", "active"],
+    columns: [
+      { key: "name", label: "Name" },
+      { key: "type", label: "Type" },
+      { key: "kind", label: "Kind" },
+      { key: "status", label: "Status" },
+      { key: "tin", label: "TIN" },
+      { key: "approved", label: "Approved" },
+      { key: "created", label: "Created" },
+    ],
+  },
+  {
+    key: "payments-list",
+    title: "Payments Export",
+    description: "Payment transactions with method, status, references",
+    domain: "Data",
+    filters: ["direction", "statuses"],
+    statusOptions: [
+      "action-required",
+      "processing",
+      "success",
+      "failed",
+      "canceled",
+      "refunded",
+    ],
+    columns: [
+      { key: "created", label: "Created" },
+      { key: "method", label: "Method" },
+      { key: "status", label: "Status" },
+      { key: "currency", label: "Currency" },
+      { key: "amount", label: "Amount", unit: "ETB" },
+      { key: "transaction_id", label: "Transaction" },
+      { key: "merchant_order_id", label: "Merchant order" },
+      { key: "paid", label: "Paid" },
+    ],
+  },
+];
+
+export const REPORT_CONFIG_BY_KEY = new Map(
+  REPORT_CONFIGS.map((c) => [c.key, c]),
+);
+
+export const REPORT_DOMAINS: ReportDomain[] = [
+  "Commercial",
+  "Operations",
+  "Finance",
+  "Data",
+];
diff --git a/apps/edr-freight-web/backoffice/src/pages/ruleEngine/CargoTypesPage.tsx b/apps/edr-freight-web/backoffice/src/pages/ruleEngine/CargoTypesPage.tsx
index e37db97cc..57c239885 100644
--- a/apps/edr-freight-web/backoffice/src/pages/ruleEngine/CargoTypesPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/ruleEngine/CargoTypesPage.tsx
@@ -60,12 +60,16 @@ interface CargoNode extends RuleEngineRecord {
   wagonTypes?: { id: string; code?: string; name?: string }[];
   /** PER_ITEM only: whole items that physically fit one wagon, keyed by wagon-type id. */
   itemsPerWagonMap?: Record<string, number> | null;
+  /** PER_TON only: max tons of this cargo per wagon, keyed by wagon-type id. */
+  tonsPerWagonMap?: Record<string, number> | null;
   isActive?: boolean;
   displayOrder?: number;
 }
 
 /** Form-value prefix for the per-wagon-type items-fit inputs (PER_ITEM cargo). */
 const ITEMS_FIT_PREFIX = "itemsFit__";
+/** Form-value prefix for the per-wagon-type tonnage-cap inputs (PER_TON cargo). */
+const TONS_CAP_PREFIX = "tonsCap__";
 
 const str = (v: unknown): string => (v == null ? "" : String(v));
 const orderOf = (n: CargoNode): number => Number(n.displayOrder ?? 0);
@@ -159,8 +163,26 @@ const CargoTypesPage = () => {
       getInitialValue: (record) =>
         (record as CargoNode).itemsPerWagonMap?.[opt.value],
     }));
+    // PER_TON cargo: an OPTIONAL "max tons per wagon" per selected wagon type —
+    // how much of this commodity actually rides one wagon, which can be less
+    // than its rating (sugar 50T on a 70T wagon, so 200T takes 4 wagons not 3).
+    // Left blank the wagon's full rated capacity applies, so existing cargo is
+    // unaffected; the API rejects a value above the rating.
+    const tonsCapFields: FormFieldDef[] = (wagonTypeOptions ?? []).map((opt) => ({
+      name: `${TONS_CAP_PREFIX}${opt.value}`,
+      label: `Max tons per ${opt.label} wagon`,
+      type: "number",
+      optional: true,
+      placeholder: "Blank = full wagon capacity",
+      showIf: (values) =>
+        values.unitOfMeasure === "PER_TON" &&
+        Array.isArray(values.wagonTypeIds) &&
+        (values.wagonTypeIds as string[]).includes(opt.value),
+      getInitialValue: (record) =>
+        (record as CargoNode).tonsPerWagonMap?.[opt.value],
+    }));
     const wagonTypesAt = base.findIndex((field) => field.name === "wagonTypeIds");
-    base.splice(wagonTypesAt + 1, 0, ...fitFields);
+    base.splice(wagonTypesAt + 1, 0, ...fitFields, ...tonsCapFields);
     return base;
   }, [wagonTypeOptions]);
 
@@ -230,14 +252,22 @@ const CargoTypesPage = () => {
     // none are visible (not PER_ITEM) so an update clears stale fits.
     const payload: Record<string, unknown> = {};
     const itemsPerWagonMap: Record<string, number> = {};
+    const tonsPerWagonMap: Record<string, number> = {};
     for (const [key, value] of Object.entries(values)) {
       if (key.startsWith(ITEMS_FIT_PREFIX)) {
         itemsPerWagonMap[key.slice(ITEMS_FIT_PREFIX.length)] = Number(value);
+      } else if (key.startsWith(TONS_CAP_PREFIX)) {
+        // Blank means "no cap" (use the full rated capacity), so an empty input
+        // must stay OUT of the map — sending 0 would be a zero-ton wagon.
+        if (value !== "" && value !== null && value !== undefined) {
+          tonsPerWagonMap[key.slice(TONS_CAP_PREFIX.length)] = Number(value);
+        }
       } else {
         payload[key] = value;
       }
     }
     payload.itemsPerWagonMap = Object.keys(itemsPerWagonMap).length ? itemsPerWagonMap : null;
+    payload.tonsPerWagonMap = Object.keys(tonsPerWagonMap).length ? tonsPerWagonMap : null;
     // Add always attaches to the page we're on; edit keeps the node's parent.
     if (formMode?.kind === "create" && current) {
       payload.parentGroupId = current.id;
diff --git a/apps/edr-freight-web/backoffice/src/pages/ruleEngine/config/resources.ts b/apps/edr-freight-web/backoffice/src/pages/ruleEngine/config/resources.ts
index 6e816e772..1702a8af1 100644
--- a/apps/edr-freight-web/backoffice/src/pages/ruleEngine/config/resources.ts
+++ b/apps/edr-freight-web/backoffice/src/pages/ruleEngine/config/resources.ts
@@ -691,6 +691,30 @@ export const RULE_ENGINE_RESOURCES: RuleEngineResourceConfig[] = [
         accessorKey: "hasFacility",
         format: "boolean",
       },
+      {
+        id: "hasContainerFacilityOrigin",
+        header: "Container origin",
+        accessorKey: "hasContainerFacilityOrigin",
+        format: "boolean",
+      },
+      {
+        id: "hasContainerFacilityDestination",
+        header: "Container dest.",
+        accessorKey: "hasContainerFacilityDestination",
+        format: "boolean",
+      },
+      {
+        id: "hasBulkFacilityOrigin",
+        header: "Bulk origin",
+        accessorKey: "hasBulkFacilityOrigin",
+        format: "boolean",
+      },
+      {
+        id: "hasBulkFacilityDestination",
+        header: "Bulk dest.",
+        accessorKey: "hasBulkFacilityDestination",
+        format: "boolean",
+      },
       { id: "displayOrder", header: "Order", accessorKey: "displayOrder", format: "number" },
       activeColumn,
     ],
@@ -710,6 +734,34 @@ export const RULE_ENGINE_RESOURCES: RuleEngineResourceConfig[] = [
         description:
           "This yard can load and unload cargo. Intercity bookings can only be loaded at their origin and unloaded at their destination when it is a facility.",
       },
+      {
+        name: "hasContainerFacilityOrigin",
+        label: "Container facility — origin",
+        type: "boolean",
+        description: "Can load containers onto a train. Offered as a contract origin for container freight.",
+        showIf: (values) => Boolean(values.hasFacility),
+      },
+      {
+        name: "hasContainerFacilityDestination",
+        label: "Container facility — destination",
+        type: "boolean",
+        description: "Can receive containers off a train. Offered as a contract destination for container freight.",
+        showIf: (values) => Boolean(values.hasFacility),
+      },
+      {
+        name: "hasBulkFacilityOrigin",
+        label: "Bulk facility — origin",
+        type: "boolean",
+        description: "Can load bulk cargo onto a train. Offered as a contract origin for bulk freight.",
+        showIf: (values) => Boolean(values.hasFacility),
+      },
+      {
+        name: "hasBulkFacilityDestination",
+        label: "Bulk facility — destination",
+        type: "boolean",
+        description: "Can receive bulk cargo off a train. Offered as a contract destination for bulk freight.",
+        showIf: (values) => Boolean(values.hasFacility),
+      },
       { name: "isActive", label: "Active", type: "boolean" },
     ],
   },
diff --git a/apps/edr-freight-web/backoffice/src/pages/trainScheduling/TrainScheduleTrackPage.tsx b/apps/edr-freight-web/backoffice/src/pages/trainScheduling/TrainScheduleTrackPage.tsx
index 28481ce7a..781c241b6 100644
--- a/apps/edr-freight-web/backoffice/src/pages/trainScheduling/TrainScheduleTrackPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/trainScheduling/TrainScheduleTrackPage.tsx
@@ -5,6 +5,7 @@ import {
   ArrowLeft,
   CalendarClock,
   CheckCircle2,
+  FileText,
   Flag,
   MapPin,
   Navigation,
@@ -40,6 +41,8 @@ import { freightBrand } from "@/theme/freight-brand";
 import { useMutation, useQuery } from "@tanstack/react-query";
 import { api } from "@/services/api";
 import { useToast } from "@/hooks/use-toast";
+import { openPdfBlob } from "@/components/warehouses/pdf";
+import { trainSchedulingService } from "@/services/trainScheduling.service";
 
 const parseError = (error: unknown, fallback: string) => {
   if (isAxiosError(error)) {
@@ -160,6 +163,31 @@ export default function TrainScheduleTrackPage() {
       enabled: Boolean(scheduleId) && trackQuery.data?.status === "DISPATCHED",
     }),
   );
+  // Marshalling 2: the current on-board list, reprinted after station work.
+  const intercityMarshalling = useMutation({
+    mutationFn: () =>
+      trainSchedulingService.downloadIntercityMarshallingDocument(scheduleId ?? ""),
+  });
+  const openIntercityMarshalling = async () => {
+    const pdfWindow = window.open("", "_blank");
+    try {
+      const blob = await intercityMarshalling.mutateAsync();
+      const opened = openPdfBlob(blob, `intercity-marshalling-${scheduleId}.pdf`, pdfWindow);
+      toast({
+        title: "Intercity marshalling ready",
+        description: opened
+          ? "The PDF opened in a browser tab for printing or saving."
+          : "The browser blocked the preview tab, so the PDF was downloaded.",
+      });
+    } catch (error) {
+      pdfWindow?.close();
+      toast({
+        title: "Could not open intercity marshalling document",
+        description: parseError(error, "Please try again"),
+        variant: "destructive",
+      });
+    }
+  };
   const [yardModal, setYardModal] = useState<{
     station: TrackStation;
     isFinal: boolean;
@@ -249,17 +277,32 @@ export default function TrainScheduleTrackPage() {
 
   return (
     <PageContainer>
-      <Button
-        component={Link}
-        to={`/dashboard/operations/train-scheduling-v2/${scheduleId}`}
-        variant="subtle"
-        color="gray"
-        size="compact-sm"
-        leftSection={<ArrowLeft size={16} />}
-        w="fit-content"
-      >
-        Back to schedule
-      </Button>
+      <Group justify="space-between" w="100%">
+        <Button
+          component={Link}
+          to={`/dashboard/operations/train-scheduling-v2/${scheduleId}`}
+          variant="subtle"
+          color="gray"
+          size="compact-sm"
+          leftSection={<ArrowLeft size={16} />}
+          w="fit-content"
+        >
+          Back to schedule
+        </Button>
+        {inTransit || arrived ? (
+          <Button
+            variant="light"
+            color="edr-green"
+            radius="lg"
+            size="compact-sm"
+            leftSection={<FileText size={16} />}
+            loading={intercityMarshalling.isPending}
+            onClick={() => void openIntercityMarshalling()}
+          >
+            Intercity Marshalling
+          </Button>
+        ) : null}
+      </Group>
 
       {/* ── Hero: gradient wash, route + a bold progress ring woven together ── */}
       <Paper
diff --git a/apps/edr-freight-web/backoffice/src/pages/trainScheduling/TrainScheduleV2DetailPage.tsx b/apps/edr-freight-web/backoffice/src/pages/trainScheduling/TrainScheduleV2DetailPage.tsx
index e0c17a57b..ce6fe5353 100644
--- a/apps/edr-freight-web/backoffice/src/pages/trainScheduling/TrainScheduleV2DetailPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/trainScheduling/TrainScheduleV2DetailPage.tsx
@@ -71,6 +71,7 @@ import {
   PreviewSummary,
   ScheduleWarningsAlert,
 } from "@/components/trainScheduling/ScheduleWarningsAlert";
+import { Train3DVisualization } from "@/components/trainScheduling/Train3DVisualization";
 import { TrainCompositionDiagram } from "@/components/trainScheduling/TrainCompositionDiagram";
 import { TrainConsistView } from "@/components/trainScheduling/compositionEditor";
 import { WagonPlanGrid } from "@/components/trainScheduling/WagonPlanGrid";
@@ -116,6 +117,7 @@ export default function TrainScheduleV2DetailPage() {
   const [gatepassNotes, setGatepassNotes] = useState("");
   const [dispatchConfirmOpen, setDispatchConfirmOpen] = useState(false);
   const [switchTarget, setSwitchTarget] = useState<EligibleContainerBooking | null>(null);
+  const [visualization3DOpen, setVisualization3DOpen] = useState(false);
   const autoPreviewedRef = useRef(false);
 
   const detailQuery = useQuery(
@@ -206,10 +208,12 @@ export default function TrainScheduleV2DetailPage() {
   const switchGov = useMutation(api.trainScheduling.switchGovernmentBooking.mutationOptions());
   const dispatch = useMutation(api.trainScheduling.dispatchSchedule.mutationOptions());
   const downloadMarshalling = useMutation({
-    mutationFn: ({ id, direction }: { id: string; direction?: string | null }) =>
-      direction === "EXPORT"
-        ? trainSchedulingService.downloadExportLoadListDocument(id)
-        : trainSchedulingService.downloadImportDjiboutiLoadListDocument(id),
+    mutationFn: ({ id, direction, variant }: { id: string; direction?: string | null; variant?: "INTERCITY" }) =>
+      variant === "INTERCITY"
+        ? trainSchedulingService.downloadIntercityMarshallingDocument(id)
+        : direction === "EXPORT"
+          ? trainSchedulingService.downloadExportLoadListDocument(id)
+          : trainSchedulingService.downloadImportDjiboutiLoadListDocument(id),
   });
 
   useEffect(() => {
@@ -424,14 +428,21 @@ export default function TrainScheduleV2DetailPage() {
     title?: string;
     successDescription?: string;
     errorTitle?: string;
+    variant?: "INTERCITY";
   }) => {
     const pdfWindow = window.open("", "_blank");
     try {
       const blob = await downloadMarshalling.mutateAsync({
         id: scheduleId,
         direction: schedule.direction,
+        variant: options?.variant,
       });
-      const prefix = schedule.direction === "EXPORT" ? "export-marshalling" : "import-marshalling";
+      const prefix =
+        options?.variant === "INTERCITY"
+          ? "intercity-marshalling"
+          : schedule.direction === "EXPORT"
+            ? "export-marshalling"
+            : "import-marshalling";
       const filename = `${prefix}-${schedule.trainNumber ?? scheduleId}.pdf`;
       const opened = openPdfBlob(blob, filename, pdfWindow);
       toast({
@@ -742,16 +753,7 @@ export default function TrainScheduleV2DetailPage() {
           <WagonPlanGrid wagonPlan={displayWagonPlanOriented} freightType={freightType} />
           {canEditBookings && (previewResult || displayWagonPlan.length) ? (
             <Group>
-              {!hasContainerStep ? (
-                <Button
-                  color="edr-green"
-                  radius="md"
-                  loading={assign.isPending}
-                  onClick={handleAssign}
-                >
-                  {assignedIds.length ? "Save assignments" : "Assign bookings"}
-                </Button>
-              ) : (
+              {hasContainerStep ? (
                 <Button
                   color="edr-green"
                   radius="md"
@@ -760,7 +762,7 @@ export default function TrainScheduleV2DetailPage() {
                 >
                   Continue to containers
                 </Button>
-              )}
+              ) : null}
               <Button variant="default" radius="md" onClick={() => void runPreview()}>
                 Refresh preview
               </Button>
@@ -955,6 +957,18 @@ export default function TrainScheduleV2DetailPage() {
               </Stack>
             </Group>
             <Group gap="sm">
+              {(schedule.trainSet?.wagons?.length ?? 0) > 0 ? (
+                <Button
+                  variant="gradient"
+                  gradient={{ from: "#0f172a", to: "#334155" }}
+                  radius="lg"
+                  size="sm"
+                  leftSection={<Eye size={16} />}
+                  onClick={() => setVisualization3DOpen(true)}
+                >
+                  3D Visualization
+                </Button>
+              ) : null}
               {canPrintMarshalling ? (
                 <Button
                   variant="light"
@@ -968,6 +982,24 @@ export default function TrainScheduleV2DetailPage() {
                   Marshalling PDF
                 </Button>
               ) : null}
+              {["DISPATCHED", "ARRIVED"].includes(schedule.status) ? (
+                <Button
+                  variant="light"
+                  color="edr-green"
+                  radius="lg"
+                  size="sm"
+                  leftSection={<FileText size={16} />}
+                  loading={downloadMarshalling.isPending}
+                  onClick={() =>
+                    void openMarshallingDocument({
+                      title: "Intercity marshalling ready",
+                      variant: "INTERCITY",
+                    })
+                  }
+                >
+                  Intercity Marshalling
+                </Button>
+              ) : null}
               {["DISPATCHED", "ARRIVED"].includes(schedule.status) ? (
                 <Button
                   component={Link}
@@ -1406,6 +1438,9 @@ export default function TrainScheduleV2DetailPage() {
           </Group>
         </Stack>
       </Modal>
+      {visualization3DOpen ? (
+        <Train3DVisualization schedule={schedule} onClose={() => setVisualization3DOpen(false)} />
+      ) : null}
     </PageContainer>
   );
 }
diff --git a/apps/edr-freight-web/backoffice/src/pages/trainScheduling/TrainScheduleV2ListPage.tsx b/apps/edr-freight-web/backoffice/src/pages/trainScheduling/TrainScheduleV2ListPage.tsx
index 946359647..3c2244f68 100644
--- a/apps/edr-freight-web/backoffice/src/pages/trainScheduling/TrainScheduleV2ListPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/trainScheduling/TrainScheduleV2ListPage.tsx
@@ -6,12 +6,14 @@ import {
   Button,
   Card,
   Checkbox,
+  Divider,
   Group,
   Menu,
   Modal,
   Select,
   SimpleGrid,
   Stack,
+  Switch,
   Text,
   TextInput,
   ThemeIcon,
@@ -46,6 +48,10 @@ import {
   directionRowStyle,
 } from "@/components/trainBuilder/trainStatus";
 import BookingWindowSettingsModal from "@/components/trainScheduling/BookingWindowSettingsModal";
+import CreateScheduleWindowFields, {
+  buildWindowRulePayload,
+  type WindowFormState,
+} from "@/components/trainScheduling/CreateScheduleWindowFields";
 import EditScheduleDateModal from "@/components/trainScheduling/EditScheduleDateModal";
 import { showScheduleWarnings } from "@/components/trainScheduling/locomotiveOptions";
 import {
@@ -59,6 +65,7 @@ import { useToast } from "@/hooks/use-toast";
 import { useAuth } from "@/auth/useAuth";
 import { canCreateSchedule, canUpdateSchedule } from "@/lib/permissions";
 import type {
+  CreateScheduleWindowRulePayload,
   FreightType,
   TrainScheduleListFilters,
   TrainScheduleListItem,
@@ -133,6 +140,10 @@ export default function TrainScheduleV2ListPage() {
   const [scheduleDate, setScheduleDate] = useState("");
   const [trainId, setTrainId] = useState("");
   const [reverseWagonOrder, setReverseWagonOrder] = useState(false);
+  // Booking window for the schedule being created: off = inherit the live global
+  // rules (the default), on = the values in `windowForm` are frozen onto it.
+  const [configureWindow, setConfigureWindow] = useState(false);
+  const [windowForm, setWindowForm] = useState<WindowFormState | null>(null);
   // Recomputed each time the create modal opens so a long-lived tab can't keep
   // offering a stale "now" as the earliest selectable departure.
   const minScheduleDate = useMemo(
@@ -535,6 +546,25 @@ export default function TrainScheduleV2ListPage() {
       });
       return;
     }
+    // Only build the window override when the toggle is on — off means "inherit
+    // the global rules", which the API expresses as an absent windowRule.
+    let windowRule: CreateScheduleWindowRulePayload | undefined;
+    if (configureWindow) {
+      if (!windowForm) {
+        toast({ title: "Booking window settings are still loading", variant: "destructive" });
+        return;
+      }
+      const built = buildWindowRulePayload(
+        windowForm,
+        selectedRoute?.direction === "EXPORT",
+      );
+      if ("error" in built) {
+        toast({ title: built.error, variant: "destructive" });
+        return;
+      }
+      windowRule = built.payload;
+    }
+
     try {
       const created = await create.mutateAsync({
         payload: {
@@ -542,11 +572,14 @@ export default function TrainScheduleV2ListPage() {
           scheduleDate: new Date(scheduleDate).toISOString(),
           trainId,
           reverseWagonOrder,
+          ...(windowRule ? { windowRule } : {}),
         },
       });
       toast({ title: "Train schedule created" });
       showScheduleWarnings(created.warnings);
       setReverseWagonOrder(false);
+      setConfigureWindow(false);
+      setWindowForm(null);
       setCreateOpen(false);
       navigate(`/dashboard/operations/train-scheduling-v2/${created.id}`);
     } catch (err) {
@@ -843,6 +876,22 @@ export default function TrainScheduleV2ListPage() {
             checked={reverseWagonOrder}
             onChange={(e) => setReverseWagonOrder(e.currentTarget.checked)}
           />
+
+          <Divider />
+
+          <Switch
+            label="Configure booking window for this schedule"
+            description="Off, this train follows the global booking rules. On, the settings below are frozen onto it and a later global-rules change won't move them."
+            checked={configureWindow}
+            onChange={(e) => setConfigureWindow(e.currentTarget.checked)}
+          />
+          {configureWindow ? (
+            <CreateScheduleWindowFields
+              isExport={selectedRoute?.direction === "EXPORT"}
+              form={windowForm}
+              onChange={setWindowForm}
+            />
+          ) : null}
           <Group justify="flex-end">
             <Button variant="default" onClick={() => setCreateOpen(false)}>
               Cancel
diff --git a/apps/edr-freight-web/backoffice/src/pages/warehouses/ArrivalQueuePage.tsx b/apps/edr-freight-web/backoffice/src/pages/warehouses/ArrivalQueuePage.tsx
index 8bb1080d9..5304f8b2c 100644
--- a/apps/edr-freight-web/backoffice/src/pages/warehouses/ArrivalQueuePage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/warehouses/ArrivalQueuePage.tsx
@@ -1,338 +1,11 @@
-import { Fragment, useEffect, useMemo, useState } from 'react';
-import {
-  Badge,
-  Button,
-  Card,
-  Group,
-  Loader,
-  Select,
-  Stack,
-  Table,
-  Text,
-} from '@mantine/core';
-import { ChevronDown, ChevronRight, PackageOpen, Truck } from 'lucide-react';
+import { Card } from '@mantine/core';
 
 import { PageContainer, PageHeader } from '@/components/page';
-import {
-  VisualEmptyState,
-  WarehouseOpsKpiStrip,
-  formatDate,
-  formatNumber,
-  warehousesAtStation,
-  yardsForBooking,
-} from '@/components/warehouses';
-import {
-  useAutoUnloadArrivedBookings,
-  useAllWarehouseYards,
-  useAllWarehouseZones,
-  useImportArriveQueue,
-  useImportTrainItems,
-  useWarehouses,
-} from '@/hooks/useWarehouses';
-import { useToast } from '@/hooks/use-toast';
-import type { AutoUnloadArrivedResult, ImportTrain, ImportTrainItem, Warehouse, WarehouseYard, WarehouseZone } from '@/types/warehouse';
-
-type UnloadAssignment = { bookingId: string; warehouseId: string; yardId: string; zoneId: string };
-type AssignmentDraft = Partial<Omit<UnloadAssignment, 'bookingId'>>;
-
-const getErrorMessage = (error: unknown) => {
-  if (error && typeof error === 'object' && 'response' in error) {
-    const response = (error as { response?: { data?: { message?: unknown } } }).response;
-    const message = response?.data?.message;
-    if (Array.isArray(message)) return message.join(', ');
-    if (typeof message === 'string') return message;
-  }
-  return error instanceof Error ? error.message : undefined;
-};
-
-const getPendingUnloadBookings = (train: ImportTrain) =>
-  train.pendingUnloadBookings ?? train.totalBookings;
-
-const isFullyUnloaded = (train: ImportTrain) =>
-  Boolean(train.fullyUnloaded) || (train.totalBookings > 0 && getPendingUnloadBookings(train) === 0);
-
-const isContainerFreight = (freightType: string | null | undefined) =>
-  (freightType ?? '').toUpperCase() === 'CONTAINER';
-
-function isUnloadPending(item: ImportTrainItem) {
-  return !item.currentStatus || item.currentStatus === 'RECEIVED';
-}
-
-function ImportTrainDetailRows({
-  train,
-  warehouses,
-  yards,
-  zones,
-  assignments,
-  onAssignmentChange,
-  onReadyChange,
-}: {
-  train: ImportTrain;
-  warehouses: Warehouse[];
-  yards: WarehouseYard[];
-  zones: WarehouseZone[];
-  assignments: Record<string, AssignmentDraft>;
-  onAssignmentChange: (bookingId: string, draft: AssignmentDraft) => void;
-  onReadyChange: (ready: boolean) => void;
-}) {
-  const { data: items = [], isLoading } = useImportTrainItems(train.scheduleId);
-  // A train only ever unloads at the warehouse actually sitting at its
-  // destination station — Indode's train never offers Sebeta's warehouse.
-  const scopedWarehouses = useMemo(
-    () => warehousesAtStation(warehouses, train.destinationStationId),
-    [warehouses, train.destinationStationId],
-  );
-  const warehouseOptions = useMemo(
-    () => scopedWarehouses.map((warehouse) => ({ value: warehouse.id, label: `${warehouse.name} (${warehouse.code})` })),
-    [scopedWarehouses],
-  );
-  // With exactly one warehouse at the station there is nothing to choose —
-  // pre-fill it so staff only has to pick yard/zone, not re-discover Indode.
-  useEffect(() => {
-    if (scopedWarehouses.length !== 1) return;
-    const onlyWarehouseId = scopedWarehouses[0].id;
-    items.filter(isUnloadPending).forEach((item) => {
-      if (!assignments[item.bookingId]?.warehouseId) {
-        onAssignmentChange(item.bookingId, { ...assignments[item.bookingId], warehouseId: onlyWarehouseId });
-      }
-    });
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [scopedWarehouses, items]);
-
-  // Once a booking's warehouse is known, its yard (and then zone) follow from
-  // what the cargo actually is — a Wheat booking only ever has one candidate
-  // yard (Dry Bulk) once Indode's real yard layout is configured, so staff
-  // never see a picker for something that isn't actually a choice.
-  useEffect(() => {
-    items.filter(isUnloadPending).forEach((item) => {
-      const draft = assignments[item.bookingId];
-      if (!draft?.warehouseId) return;
-
-      if (!draft.yardId) {
-        const candidateYards = yardsForBooking(yards, {
-          warehouseId: draft.warehouseId,
-          freightType: item.freightType,
-          tradeDirection: 'IMPORT',
-          cargoTypeCode: item.cargoTypeCode,
-        });
-        if (candidateYards.length === 1) {
-          onAssignmentChange(item.bookingId, { ...draft, yardId: candidateYards[0].id });
-        }
-        return;
-      }
-
-      if (!draft.zoneId) {
-        const candidateZones = zones.filter((zone) => zone.yardId === draft.yardId);
-        if (candidateZones.length === 1) {
-          onAssignmentChange(item.bookingId, { ...draft, zoneId: candidateZones[0].id });
-        }
-      }
-    });
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [assignments, items, yards, zones]);
-
-  useEffect(() => {
-    const pending = items.filter(isUnloadPending);
-    onReadyChange(
-      pending.length > 0 &&
-        pending.every((item) => {
-          const draft = assignments[item.bookingId];
-          return Boolean(draft?.warehouseId && draft.yardId && draft.zoneId);
-        }),
-    );
-  }, [assignments, items]);
-
-  if (isLoading) {
-    return (
-      <Group justify="center" py="md">
-        <Loader size="sm" />
-      </Group>
-    );
-  }
-
-  if (items.length === 0) {
-    return (
-      <Text c="dimmed" ta="center" py="md" size="sm">
-        No assigned bookings found for this train.
-      </Text>
-    );
-  }
-
-  return (
-    <Table highlightOnHover verticalSpacing="xs">
-      <Table.Thead>
-        <Table.Tr>
-          <Table.Th>Booking</Table.Th>
-          <Table.Th>Customer</Table.Th>
-          <Table.Th>Container</Table.Th>
-          <Table.Th>Cargo</Table.Th>
-          <Table.Th>Weight</Table.Th>
-          <Table.Th>Arrival</Table.Th>
-          <Table.Th>Status</Table.Th>
-          <Table.Th>Warehouse</Table.Th>
-          <Table.Th>Yard</Table.Th>
-          <Table.Th>Zone</Table.Th>
-          <Table.Th>Inspection</Table.Th>
-          <Table.Th>Pickup</Table.Th>
-        </Table.Tr>
-      </Table.Thead>
-      <Table.Tbody>
-        {items.map((item: ImportTrainItem) => {
-          const draft = assignments[item.bookingId] ?? {};
-          const yardOptions = yardsForBooking(yards, {
-            warehouseId: draft.warehouseId,
-            freightType: item.freightType,
-            tradeDirection: 'IMPORT',
-            cargoTypeCode: item.cargoTypeCode,
-          }).map((yard) => ({ value: yard.id, label: `${yard.name} (${yard.code})` }));
-          // The yard is already scoped to what this cargo can go into — a
-          // zone's own type always matches its parent yard's purpose (see the
-          // Indode seed migration), so no separate zone-type filter is needed.
-          const zoneOptions = zones
-            .filter((zone) => zone.yardId === draft.yardId)
-            .map((zone) => ({ value: zone.id, label: `${zone.name} (${zone.code})` }));
-          const pending = isUnloadPending(item);
-
-          return (
-          <Table.Tr key={item.bookingId}>
-            <Table.Td>
-              <Text size="sm" fw={600}>
-                {item.bookingReference ?? item.bookingId.slice(0, 8)}
-              </Text>
-            </Table.Td>
-            <Table.Td>{item.customerName ?? '—'}</Table.Td>
-            <Table.Td>{item.containerNumber ?? '—'}</Table.Td>
-            <Table.Td>{item.cargoType ?? '—'}</Table.Td>
-            <Table.Td>{formatNumber(item.weight)}</Table.Td>
-            <Table.Td>{formatDate(item.arrivalTime)}</Table.Td>
-            <Table.Td>
-              <Badge variant="light" color={item.currentStatus === 'UNLOADED' ? 'green' : 'orange'} size="sm">
-                {item.currentStatus ?? 'PENDING'}
-              </Badge>
-            </Table.Td>
-            <Table.Td>
-              <Select
-                placeholder="Warehouse"
-                data={warehouseOptions}
-                value={draft.warehouseId ?? null}
-                onChange={(value) => onAssignmentChange(item.bookingId, { warehouseId: value ?? undefined })}
-                searchable
-                disabled={!pending}
-                w={210}
-              />
-            </Table.Td>
-            <Table.Td>
-              <Select
-                placeholder={isContainerFreight(item.freightType) ? 'Container yard' : 'Bulk yard'}
-                data={yardOptions}
-                value={draft.yardId ?? null}
-                onChange={(value) =>
-                  onAssignmentChange(item.bookingId, { ...draft, yardId: value ?? undefined, zoneId: undefined })
-                }
-                searchable
-                disabled={!pending || !draft.warehouseId}
-                w={190}
-              />
-            </Table.Td>
-            <Table.Td>
-              <Select
-                placeholder={isContainerFreight(item.freightType) ? 'Container zone' : 'Bulk zone'}
-                data={zoneOptions}
-                value={draft.zoneId ?? null}
-                onChange={(value) => onAssignmentChange(item.bookingId, { ...draft, zoneId: value ?? undefined })}
-                searchable
-                disabled={!pending || !draft.yardId}
-                w={190}
-              />
-            </Table.Td>
-            <Table.Td>
-              <Badge variant="light" color={item.inspectionStatus === 'PASSED' ? 'green' : 'gray'} size="sm">
-                {item.inspectionStatus ?? 'Not inspected'}
-              </Badge>
-            </Table.Td>
-            <Table.Td>{item.pickupOption.replace(/_/g, ' ')}</Table.Td>
-          </Table.Tr>
-          );
-        })}
-      </Table.Tbody>
-    </Table>
-  );
-}
+import { WarehouseOpsKpiStrip } from '@/components/warehouses';
+import { ImportArriveQueueTab } from '@/components/warehouses/ReceiveInventoryModal';
 
 /** Arrived import trains awaiting unload into warehouse inventory. */
 export default function ArrivalQueuePage() {
-  const { toast } = useToast();
-  const { data: trains = [], isLoading } = useImportArriveQueue();
-  const { data: warehouses = [], isLoading: warehousesLoading } = useWarehouses({ status: 'ACTIVE' });
-  const { data: yards = [] } = useAllWarehouseYards();
-  const { data: zones = [] } = useAllWarehouseZones();
-  const autoUnload = useAutoUnloadArrivedBookings();
-  const [openScheduleId, setOpenScheduleId] = useState<string | null>(null);
-  const [busyScheduleId, setBusyScheduleId] = useState<string | null>(null);
-  const [assignmentsBySchedule, setAssignmentsBySchedule] = useState<Record<string, Record<string, AssignmentDraft>>>({});
-  const [readyBySchedule, setReadyBySchedule] = useState<Record<string, boolean>>({});
-
-  const unloadTrain = async (train: ImportTrain) => {
-    const assignments = Object.entries(assignmentsBySchedule[train.scheduleId] ?? {})
-      .filter((entry): entry is [string, Required<AssignmentDraft>] =>
-        Boolean(entry[1].warehouseId && entry[1].yardId && entry[1].zoneId),
-      )
-      .map(([bookingId, draft]) => ({
-        bookingId,
-        warehouseId: draft.warehouseId,
-        yardId: draft.yardId,
-        zoneId: draft.zoneId,
-      }));
-
-    if (!readyBySchedule[train.scheduleId] || assignments.length === 0) {
-      toast({
-        variant: 'destructive',
-        title: 'Assign locations',
-        description: 'Select warehouse, yard and zone for each pending booking before unloading.',
-      });
-      return;
-    }
-
-    if (isFullyUnloaded(train)) {
-      toast({
-        title: 'Already unloaded',
-        description: `${train.trainNumber ?? 'This train'} has no remaining bookings to auto unload.`,
-      });
-      return;
-    }
-
-    setBusyScheduleId(train.scheduleId);
-    try {
-      const res = (await autoUnload.mutateAsync({ scheduleId: train.scheduleId, assignments })) as {
-        data: AutoUnloadArrivedResult;
-      };
-      const result = res.data;
-      const alreadyUnloaded = result.unloadedCount === 0 && result.skippedCount > 0 && result.failedCount === 0;
-      const firstReason = result.results.find((item) => item.reason)?.reason;
-      const details = [
-        result.skippedCount ? `${result.skippedCount} skipped` : '',
-        result.failedCount ? `${result.failedCount} failed` : '',
-      ]
-        .filter(Boolean)
-        .join(', ');
-
-      toast({
-        title: alreadyUnloaded ? 'Already unloaded' : `${result.unloadedCount} booking(s) unloaded`,
-        description: alreadyUnloaded
-          ? firstReason ?? `${train.trainNumber ?? 'Train'} is already in warehouse inventory.`
-          : details || `${train.trainNumber ?? 'Train'} moved into warehouse inventory.`,
-      });
-    } catch (error) {
-      toast({
-        variant: 'destructive',
-        title: 'Auto unload failed',
-        description: getErrorMessage(error),
-      });
-    } finally {
-      setBusyScheduleId(null);
-    }
-  };
-
   return (
     <PageContainer>
       <PageHeader
@@ -344,136 +17,7 @@ export default function ArrivalQueuePage() {
       <WarehouseOpsKpiStrip />
 
       <Card withBorder radius="md" padding="lg">
-          <Group justify="space-between" mb="md">
-            <Stack gap={2}>
-              <Text fw={600}>{trains.length} arrived import train(s)</Text>
-              <Text size="sm" c="dimmed">
-                Open a train, assign each booking to a warehouse yard and zone, then unload it.
-              </Text>
-            </Stack>
-          </Group>
-
-          {isLoading ? (
-            <Group justify="center" py="xl">
-              <Loader />
-            </Group>
-          ) : trains.length === 0 ? (
-            <VisualEmptyState
-              variant="container"
-              title="No arrived import trains"
-              description="Import trains appear here once their train schedule status is ARRIVED."
-            />
-          ) : (
-            <Table.ScrollContainer minWidth={1150}>
-              <Table verticalSpacing="sm" highlightOnHover striped>
-                <Table.Thead>
-                  <Table.Tr>
-                    <Table.Th>Train</Table.Th>
-                    <Table.Th>Route</Table.Th>
-                    <Table.Th>Origin</Table.Th>
-                    <Table.Th>Destination</Table.Th>
-                    <Table.Th>Arrival</Table.Th>
-                    <Table.Th ta="center">Bookings</Table.Th>
-                    <Table.Th ta="center">Containers</Table.Th>
-                    <Table.Th ta="center">Cargoes</Table.Th>
-                    <Table.Th>Status</Table.Th>
-                    <Table.Th ta="right">Actions</Table.Th>
-                  </Table.Tr>
-                </Table.Thead>
-                <Table.Tbody>
-                  {trains.map((train: ImportTrain) => {
-                    const isOpen = openScheduleId === train.scheduleId;
-                    const fullyUnloaded = isFullyUnloaded(train);
-                    const unloadedBookings = train.unloadedBookings ?? train.totalBookings - getPendingUnloadBookings(train);
-                    return (
-                      <Fragment key={train.scheduleId}>
-                        <Table.Tr>
-                          <Table.Td>
-                            <Stack gap={0}>
-                              <Text size="sm" fw={700}>
-                                {train.trainNumber ?? '—'}
-                              </Text>
-                              <Text size="xs" c="dimmed">
-                                {train.scheduleId.slice(0, 8)}
-                              </Text>
-                            </Stack>
-                          </Table.Td>
-                          <Table.Td>{train.route ?? '—'}</Table.Td>
-                          <Table.Td>{train.origin ?? '—'}</Table.Td>
-                          <Table.Td>{train.destination ?? '—'}</Table.Td>
-                          <Table.Td>
-                            <Text size="xs">{formatDate(train.arrivalTime)}</Text>
-                          </Table.Td>
-                          <Table.Td ta="center">{train.totalBookings}</Table.Td>
-                          <Table.Td ta="center">{train.totalContainers}</Table.Td>
-                          <Table.Td ta="center">{train.totalCargoes}</Table.Td>
-                          <Table.Td>
-                            <Stack gap={2}>
-                              <Badge variant="light" color="teal" size="sm">
-                                {train.status}
-                              </Badge>
-                              <Text size="xs" c="dimmed">
-                                {Math.max(unloadedBookings, 0)}/{train.totalBookings} unloaded
-                              </Text>
-                            </Stack>
-                          </Table.Td>
-                          <Table.Td>
-                            <Group gap="xs" justify="flex-end" wrap="nowrap">
-                              <Button
-                                size="compact-xs"
-                                variant="light"
-                                leftSection={isOpen ? <ChevronDown size={14} /> : <ChevronRight size={14} />}
-                                onClick={() => setOpenScheduleId(isOpen ? null : train.scheduleId)}
-                              >
-                                Open
-                              </Button>
-                              <Button
-                                size="compact-xs"
-                                color={fullyUnloaded ? 'gray' : 'orange'}
-                                leftSection={busyScheduleId === train.scheduleId ? <PackageOpen size={14} /> : <Truck size={14} />}
-                                loading={busyScheduleId === train.scheduleId}
-                                disabled={fullyUnloaded || train.totalBookings === 0 || !readyBySchedule[train.scheduleId] || warehousesLoading}
-                                onClick={() => unloadTrain(train)}
-                              >
-                                {fullyUnloaded ? 'Already Unloaded' : 'Auto Unload'}
-                              </Button>
-                            </Group>
-                          </Table.Td>
-                        </Table.Tr>
-                        {isOpen && (
-                          <Table.Tr>
-                            <Table.Td colSpan={10} bg="var(--mantine-color-gray-0)">
-                              <ImportTrainDetailRows
-                                train={train}
-                                warehouses={warehouses}
-                                yards={yards}
-                                zones={zones}
-                                assignments={assignmentsBySchedule[train.scheduleId] ?? {}}
-                                onAssignmentChange={(bookingId, draft) =>
-                                  setAssignmentsBySchedule((current) => ({
-                                    ...current,
-                                    [train.scheduleId]: {
-                                      ...(current[train.scheduleId] ?? {}),
-                                      [bookingId]: draft.warehouseId
-                                        ? draft
-                                        : {},
-                                    },
-                                  }))
-                                }
-                                onReadyChange={(ready) =>
-                                  setReadyBySchedule((current) => ({ ...current, [train.scheduleId]: ready }))
-                                }
-                              />
-                            </Table.Td>
-                          </Table.Tr>
-                        )}
-                      </Fragment>
-                    );
-                  })}
-                </Table.Tbody>
-              </Table>
-            </Table.ScrollContainer>
-          )}
+        <ImportArriveQueueTab enabled />
       </Card>
     </PageContainer>
   );
diff --git a/apps/edr-freight-web/backoffice/src/pages/warehouses/ContainerReturnsPage.tsx b/apps/edr-freight-web/backoffice/src/pages/warehouses/ContainerReturnsPage.tsx
index 36745db3b..feb4c4815 100644
--- a/apps/edr-freight-web/backoffice/src/pages/warehouses/ContainerReturnsPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/warehouses/ContainerReturnsPage.tsx
@@ -17,7 +17,7 @@ import {
   Select,
   Checkbox,
 } from "@mantine/core";
-import { ChevronDown, ChevronRight } from "lucide-react";
+import { ChevronDown, ChevronRight, History } from "lucide-react";
 
 import { PageContainer, PageHeader } from "@/components/page";
 import RuleEngineListFooter from "@/components/ruleEngine/RuleEngineListFooter";
@@ -27,9 +27,30 @@ import { useWarehouseYards, useWarehouseZones } from "@/hooks/useWarehouses";
 import { api } from "@/services/api";
 import { warehouseService } from "@/services/warehouse.service";
 import { importOperationsService } from "@/services/importOperations.service";
+import type { EmptyContainerReturnStatus } from "@/types/importOperations";
 
 type ReturnType = "all" | "edr" | "customer";
 
+const RETURN_STATUS_ORDER: EmptyContainerReturnStatus[] = [
+  "RETURNED",
+  "ASSIGNED_STORAGE",
+  "DOCUMENTATION_CLEARED",
+  "WAGON_ALLOCATED",
+  "TRANSPORTED_TO_DJIBOUTI",
+  "HANDOVER_ISSUED",
+  "COMPLETED",
+];
+
+const RETURN_STATUS_LABEL: Record<EmptyContainerReturnStatus, string> = {
+  RETURNED: "Returned",
+  ASSIGNED_STORAGE: "Assigned Storage",
+  DOCUMENTATION_CLEARED: "Documentation Cleared",
+  WAGON_ALLOCATED: "Wagon Allocated",
+  TRANSPORTED_TO_DJIBOUTI: "Transported to Djibouti",
+  HANDOVER_ISSUED: "Handover Issued",
+  COMPLETED: "Completed",
+};
+
 interface ContainerReturnRow {
   key: string;
   containerNumber: string;
@@ -61,6 +82,7 @@ export default function ContainerReturnsPage() {
   const [returnModalOpen, setReturnModalOpen] = useState(false);
   const [standaloneModalOpen, setStandaloneModalOpen] = useState(false);
   const [activeKey, setActiveKey] = useState<string | null>(null);
+  const [historyRow, setHistoryRow] = useState<any | null>(null);
 
   const { data: unloadedQueue = [], isLoading: queueLoading } = useQuery({
     queryKey: ["import-unloaded-queue"],
@@ -164,6 +186,11 @@ export default function ContainerReturnsPage() {
     enabled: bookingIds.length > 0 && !queueLoading,
   });
 
+  const filteredReturnedContainers = useMemo(() => {
+    if (filterType === "all") return returnedContainers;
+    return returnedContainers.filter((ret: any) => ret.returnedBy === filterType.toUpperCase());
+  }, [returnedContainers, filterType]);
+
   const allGroups = useMemo(() => containerReturnsQuery.data ?? [], [containerReturnsQuery.data]);
   const filteredGroups = useMemo(() => {
     if (filterType === "all") return allGroups;
@@ -202,6 +229,7 @@ export default function ContainerReturnsPage() {
             facility: container.warehouse,
             condition: container.condition,
             handoverNote: container.handoverNote,
+            returnedBy: truck.returnType,
           });
           results.push(result);
         }
@@ -223,6 +251,26 @@ export default function ContainerReturnsPage() {
     },
   });
 
+  const advanceStatusMutation = useMutation({
+    mutationFn: (id: string) => {
+      const current = returnedContainers.find((r: any) => r.id === id);
+      const nextIndex = RETURN_STATUS_ORDER.indexOf(current?.status ?? "RETURNED") + 1;
+      const status = RETURN_STATUS_ORDER[nextIndex] ?? "COMPLETED";
+      return importOperationsService.updateEmptyReturnStatus(id, { status });
+    },
+    onSuccess: () => {
+      toast({ title: "Return status updated" });
+      qc.invalidateQueries({ queryKey: ["empty-container-returns"] });
+    },
+    onError: (error: any) => {
+      toast({
+        variant: "destructive",
+        title: "Failed to update return status",
+        description: error?.response?.data?.message || error?.message,
+      });
+    },
+  });
+
   const activeGroup = activeKey ? (filteredGroups.find((g) => `${g.returnType.toLowerCase()}-${g.bookingId}` === activeKey) ?? null) : null;
 
   if (queueLoading || containerReturnsQuery.isLoading) {
@@ -257,7 +305,7 @@ export default function ContainerReturnsPage() {
         </Button>
       </Group>
 
-      {returnedContainers.length > 0 && (
+      {filteredReturnedContainers.length > 0 && (
         <>
           <Text fw={600} mb="xs">Returned Containers</Text>
           <Table.ScrollContainer minWidth={1000} mb="lg">
@@ -266,27 +314,60 @@ export default function ContainerReturnsPage() {
                 <Table.Tr>
                   <Table.Th>Container Number</Table.Th>
                   <Table.Th>Booking Ref</Table.Th>
+                  <Table.Th>Returned By</Table.Th>
                   <Table.Th>Returned Date</Table.Th>
                   <Table.Th>Facility</Table.Th>
                   <Table.Th>Yard</Table.Th>
                   <Table.Th>Condition</Table.Th>
                   <Table.Th>Status</Table.Th>
+                  <Table.Th ta="right">Action</Table.Th>
                 </Table.Tr>
               </Table.Thead>
               <Table.Tbody>
-                {returnedContainers.map((ret: any) => (
-                  <Table.Tr key={ret.id}>
-                    <Table.Td>{ret.containerNumber}</Table.Td>
-                    <Table.Td>{ret.bookingId ? "Associated" : "—"}</Table.Td>
-                    <Table.Td>{ret.returnDate ? new Date(ret.returnDate).toLocaleDateString() : "—"}</Table.Td>
-                    <Table.Td>{ret.facility || "—"}</Table.Td>
-                    <Table.Td>{ret.yard || "—"}</Table.Td>
-                    <Table.Td>{ret.condition || "—"}</Table.Td>
-                    <Table.Td>
-                      <Badge size="sm">{ret.status}</Badge>
-                    </Table.Td>
-                  </Table.Tr>
-                ))}
+                {filteredReturnedContainers.map((ret: any) => {
+                  const nextStatus = RETURN_STATUS_ORDER[RETURN_STATUS_ORDER.indexOf(ret.status) + 1];
+                  return (
+                    <Table.Tr key={ret.id}>
+                      <Table.Td>{ret.containerNumber}</Table.Td>
+                      <Table.Td>{ret.bookingId ? "Associated" : "—"}</Table.Td>
+                      <Table.Td>
+                        {ret.returnedBy ? (
+                          <Badge size="sm" color={ret.returnedBy === "EDR" ? "edr-green" : "blue"}>
+                            {ret.returnedBy === "EDR" ? "EDR Last Mile" : "Customer Self-Haul"}
+                          </Badge>
+                        ) : (
+                          "—"
+                        )}
+                      </Table.Td>
+                      <Table.Td>{ret.returnDate ? new Date(ret.returnDate).toLocaleDateString() : "—"}</Table.Td>
+                      <Table.Td>{ret.facility || "—"}</Table.Td>
+                      <Table.Td>{ret.yard || "—"}</Table.Td>
+                      <Table.Td>{ret.condition || "—"}</Table.Td>
+                      <Table.Td>
+                        <Badge size="sm">{RETURN_STATUS_LABEL[ret.status as EmptyContainerReturnStatus] ?? ret.status}</Badge>
+                      </Table.Td>
+                      <Table.Td ta="right">
+                        <Group gap="xs" justify="flex-end" wrap="nowrap">
+                          <ActionIcon variant="subtle" color="gray" onClick={() => setHistoryRow(ret)} title="View status history">
+                            <History size={14} />
+                          </ActionIcon>
+                          {nextStatus ? (
+                            <Button
+                              size="xs"
+                              variant="light"
+                              loading={advanceStatusMutation.isPending && advanceStatusMutation.variables === ret.id}
+                              onClick={() => advanceStatusMutation.mutate(ret.id)}
+                            >
+                              Advance to {RETURN_STATUS_LABEL[nextStatus]}
+                            </Button>
+                          ) : (
+                            <Text size="xs" c="dimmed">Done</Text>
+                          )}
+                        </Group>
+                      </Table.Td>
+                    </Table.Tr>
+                  );
+                })}
               </Table.Tbody>
             </Table>
           </Table.ScrollContainer>
@@ -404,6 +485,23 @@ export default function ContainerReturnsPage() {
         onSubmit={(payload) => createReturnsMutation.mutate(payload)}
         loading={createReturnsMutation.isPending}
       />
+
+      <Modal opened={!!historyRow} onClose={() => setHistoryRow(null)} title="Status History" size="sm">
+        {historyRow && (
+          <Stack gap="sm">
+            <Text fw={600}>{historyRow.containerNumber}</Text>
+            {(historyRow.statusHistory ?? []).map((entry: any, idx: number) => (
+              <Group key={idx} justify="space-between">
+                <Badge size="sm">{RETURN_STATUS_LABEL[entry.status as EmptyContainerReturnStatus] ?? entry.status}</Badge>
+                <Text size="sm" c="dimmed">{new Date(entry.changedAt).toLocaleString()}</Text>
+              </Group>
+            ))}
+            {!(historyRow.statusHistory ?? []).length && (
+              <Text size="sm" c="dimmed">No history recorded.</Text>
+            )}
+          </Stack>
+        )}
+      </Modal>
     </PageContainer>
   );
 }
diff --git a/apps/edr-freight-web/backoffice/src/pages/warehouses/ImportTrucksPage.tsx b/apps/edr-freight-web/backoffice/src/pages/warehouses/ImportTrucksPage.tsx
index 8072b67d5..d2cc909f2 100644
--- a/apps/edr-freight-web/backoffice/src/pages/warehouses/ImportTrucksPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/warehouses/ImportTrucksPage.tsx
@@ -82,7 +82,7 @@ const money = (amount: number, currency: string) =>
 const formatTime = (iso: string | null | undefined) =>
   iso ? new Date(iso).toLocaleString() : "—";
 
-interface BookingGroup {
+export interface BookingGroup {
   bookingId: string;
   bookingReference: string;
   customerName: string | null;
@@ -93,7 +93,7 @@ interface BookingGroup {
 }
 
 /** One collapsed line per booking; its inventory rows travel with it for the fee lookup. */
-function groupByBooking(items: ImportUnloadedItem[]): BookingGroup[] {
+export function groupByBooking(items: ImportUnloadedItem[]): BookingGroup[] {
   const groups = new Map<string, BookingGroup>();
   for (const item of items) {
     if (!item.bookingId) continue;
@@ -140,7 +140,7 @@ interface TruckRow {
  * Haulage mode is decided by which list comes back non-empty — a booking is
  * either EDR last mile or customer self-haul, never both.
  */
-function TruckRows({ group }: { group: BookingGroup }) {
+export function TruckRows({ group }: { group: BookingGroup }) {
   const { toast } = useToast();
   const queryClient = useQueryClient();
   const [busy, setBusy] = useState(false);
@@ -423,14 +423,7 @@ function TruckRows({ group }: { group: BookingGroup }) {
                     disabled={!primaryId}
                     onClick={() => openRelease(t)}
                   >
-                    Truck Arrival
-                  </Menu.Item>
-                  <Menu.Item
-                    leftSection={<Truck size={14} />}
-                    disabled={!primaryId}
-                    onClick={() => openRelease(t)}
-                  >
-                    Truck Leaving
+                    {t.arrivedAt ? 'Truck Arrival / Leaving' : 'Truck Arrival'}
                   </Menu.Item>
                   <Menu.Divider />
                   <Menu.Item
@@ -452,7 +445,7 @@ function TruckRows({ group }: { group: BookingGroup }) {
                     disabled={!primaryId}
                     onClick={() => setInspectId(primaryId)}
                   >
-                    Inspect / report
+                    Inspection / Report
                   </Menu.Item>
                   {isEdr && (
                     <>
diff --git a/apps/edr-freight-web/backoffice/src/services/api.ts b/apps/edr-freight-web/backoffice/src/services/api.ts
index 9933fbccf..b21ec07a0 100644
--- a/apps/edr-freight-web/backoffice/src/services/api.ts
+++ b/apps/edr-freight-web/backoffice/src/services/api.ts
@@ -163,6 +163,8 @@ import {
   type SaveLocomotivePayload,
 } from "./locomotives.service";
 import { overviewService } from "./overview.service";
+import { reportsService } from "./reports.service";
+import type { ReportQueryInput, ReportResult } from "@/types/reports";
 import {
   paymentsService,
   type PaginatedPayments,
@@ -2880,4 +2882,13 @@ export const api = {
       ({ range }) => overviewService.getDashboard(range),
     ),
   },
+
+  reports: {
+    run: endpoint<ReportQueryInput, ReportResult>(
+      "reports",
+      "run",
+      (input) => reportsService.run(input),
+      (input) => ["reports", input.key, input],
+    ),
+  },
 };
diff --git a/apps/edr-freight-web/backoffice/src/services/overview.service.ts b/apps/edr-freight-web/backoffice/src/services/overview.service.ts
index 44258ec9b..71e7fb671 100644
--- a/apps/edr-freight-web/backoffice/src/services/overview.service.ts
+++ b/apps/edr-freight-web/backoffice/src/services/overview.service.ts
@@ -43,8 +43,12 @@ export const overviewService = {
     return unwrap(response);
   },
 
-  getOperationsTab: async (): Promise<IOverviewOperationsTab> => {
-    const response = await client.get<IOverviewOperationsTab>(O.OPERATIONS);
+  getOperationsTab: async (
+    range?: OverviewRange,
+  ): Promise<IOverviewOperationsTab> => {
+    const response = await client.get<IOverviewOperationsTab>(O.OPERATIONS, {
+      params: range ? { range } : undefined,
+    });
     return unwrap(response);
   },
 
diff --git a/apps/edr-freight-web/backoffice/src/services/reports.service.ts b/apps/edr-freight-web/backoffice/src/services/reports.service.ts
new file mode 100644
index 000000000..6f6995614
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/services/reports.service.ts
@@ -0,0 +1,14 @@
+import { api as client } from "../auth/http";
+import { unwrap } from "@/utils/endpoint";
+import { URL_CONSTANTS } from "@/constants/URLS";
+import type { ReportQueryInput, ReportResult } from "@/types/reports";
+
+export const reportsService = {
+  run: async ({ key, ...params }: ReportQueryInput): Promise<ReportResult> => {
+    const response = await client.get<ReportResult>(
+      URL_CONSTANTS.REPORTS.RUN(key),
+      { params },
+    );
+    return unwrap(response.data);
+  },
+};
diff --git a/apps/edr-freight-web/backoffice/src/services/signatures.service.ts b/apps/edr-freight-web/backoffice/src/services/signatures.service.ts
index 577e3b4de..6a71c1836 100644
--- a/apps/edr-freight-web/backoffice/src/services/signatures.service.ts
+++ b/apps/edr-freight-web/backoffice/src/services/signatures.service.ts
@@ -11,7 +11,8 @@ export interface SavedSignature {
 
 export interface SaveSignaturePayload {
   signerDisplayName: string;
-  signatureImageBase64: string;
+  /** Omit to keep the existing saved signature (stamp-only update). */
+  signatureImageBase64?: string;
   /** Omit to keep the existing saved stamp. */
   stampImageBase64?: string;
 }
diff --git a/apps/edr-freight-web/backoffice/src/services/trainScheduling.service.ts b/apps/edr-freight-web/backoffice/src/services/trainScheduling.service.ts
index 063b3e8d6..35dc23684 100644
--- a/apps/edr-freight-web/backoffice/src/services/trainScheduling.service.ts
+++ b/apps/edr-freight-web/backoffice/src/services/trainScheduling.service.ts
@@ -3,6 +3,7 @@ import { api as client } from "../auth/http";
 import { unwrap } from "@/utils/endpoint";
 import { URL_CONSTANTS } from "@/constants/URLS";
 import type {
+  AllocationCandidates,
   BatchBoardFilters,
   BatchBoardListResponse,
   BatchBoardScheduleDetail,
@@ -319,6 +320,25 @@ export const trainSchedulingService = {
     );
   },
 
+  getAllocationCandidates: async (
+    bookingId: string,
+  ): Promise<AllocationCandidates> => {
+    const response = await client.get<AllocationCandidates>(
+      URL_CONSTANTS.TRAIN_SCHEDULING.ALLOCATION_CANDIDATES(bookingId),
+    );
+    return unwrap(response.data);
+  },
+
+  allocatePaidBooking: async (
+    bookingId: string,
+    trainScheduleId: string,
+  ): Promise<void> => {
+    await client.post(
+      URL_CONSTANTS.TRAIN_SCHEDULING.ALLOCATE_BOOKING(bookingId),
+      { trainScheduleId },
+    );
+  },
+
   getScheduleById: async (
     id: string,
     freightType?: FreightType,
@@ -624,6 +644,16 @@ export const trainSchedulingService = {
     return response.data;
   },
 
+  downloadIntercityMarshallingDocument: async (
+    scheduleId: string,
+  ): Promise<Blob> => {
+    const response = await client.get(
+      URL_CONSTANTS.TRAIN_SCHEDULING.INTERCITY_MARSHALLING_DOCUMENT(scheduleId),
+      { responseType: "blob" },
+    );
+    return response.data;
+  },
+
   getTrack: async (scheduleId: string): Promise<TrainTrackResponse> => {
     const response = await client.get<TrainTrackResponse>(
       URL_CONSTANTS.TRAIN_SCHEDULING.CHECKPOINTS(scheduleId),
diff --git a/apps/edr-freight-web/backoffice/src/services/userTradeAccess.service.ts b/apps/edr-freight-web/backoffice/src/services/userTradeAccess.service.ts
new file mode 100644
index 000000000..3570e004d
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/services/userTradeAccess.service.ts
@@ -0,0 +1,63 @@
+import { api as client } from "../auth/http";
+
+export type TradeDirection = "IMPORT" | "EXPORT" | "DOMESTIC";
+
+export const ALL_TRADE_DIRECTIONS: TradeDirection[] = [
+  "IMPORT",
+  "EXPORT",
+  "DOMESTIC",
+];
+
+export const TRADE_DIRECTION_LABELS: Record<TradeDirection, string> = {
+  IMPORT: "Import",
+  EXPORT: "Export",
+  DOMESTIC: "Intercity",
+};
+
+export interface UserTradeAccessRow {
+  userId: string;
+  directions: TradeDirection[];
+  updatedAt: string;
+}
+
+export interface MyTradeAccess {
+  restricted: boolean;
+  directions: TradeDirection[];
+}
+
+export interface StaffUser {
+  id: string;
+  /** Localized jsonb on iam.users — not a plain string. */
+  name: { en?: string; am?: string } | null;
+  username: string;
+  email: string | null;
+}
+
+export const userTradeAccessService = {
+  /**
+   * Employees to assign scopes to. Served by the freight API rather than IAM's
+   * `/users/filter`, which 400s on its own pagination params (its @Query() DTO
+   * omits skip/take/orderBy while the global whitelist pipe rejects them).
+   */
+  employees: async (): Promise<{ items: StaffUser[] }> =>
+    (
+      await client.get("/staff/users", {
+        params: { userType: "employee", pageSize: 100 },
+      })
+    ).data,
+
+  /** All configured per-user scopes (admin only). */
+  list: async (): Promise<UserTradeAccessRow[]> =>
+    (await client.get("/user-trade-access")).data,
+
+  /** Current user's effective scope. */
+  me: async (): Promise<MyTradeAccess> =>
+    (await client.get("/user-trade-access/me")).data,
+
+  /** Set the directions a user may see (admin only). */
+  set: async (
+    userId: string,
+    directions: TradeDirection[],
+  ): Promise<UserTradeAccessRow> =>
+    (await client.put(`/user-trade-access/${userId}`, { directions })).data,
+};
diff --git a/apps/edr-freight-web/backoffice/src/super-admin/hooks/useExternalUsers.ts b/apps/edr-freight-web/backoffice/src/super-admin/hooks/useExternalUsers.ts
index 8f120b037..3631bb006 100644
--- a/apps/edr-freight-web/backoffice/src/super-admin/hooks/useExternalUsers.ts
+++ b/apps/edr-freight-web/backoffice/src/super-admin/hooks/useExternalUsers.ts
@@ -19,6 +19,7 @@ export enum userTypeEnum {
   external = "external_organization",
   individual = "individual",
   externalUsers = "external_organization,individual",
+  employee = "employee",
 }
 
 export interface ExternalQueryParams {
diff --git a/apps/edr-freight-web/backoffice/src/types/importOperations.ts b/apps/edr-freight-web/backoffice/src/types/importOperations.ts
index 64214eddc..ff5c1901f 100644
--- a/apps/edr-freight-web/backoffice/src/types/importOperations.ts
+++ b/apps/edr-freight-web/backoffice/src/types/importOperations.ts
@@ -102,6 +102,12 @@ export interface EmptyContainerReturn {
   status: EmptyContainerReturnStatus;
   wagonAllocationReference: string | null;
   performedBy: string | null;
+  returnedBy: 'EDR' | 'CUSTOMER' | null;
+  statusHistory: Array<{
+    status: EmptyContainerReturnStatus;
+    changedAt: string;
+    performedBy: string | null;
+  }>;
 }
 
 export interface CreateEmptyContainerReturnPayload {
@@ -115,6 +121,7 @@ export interface CreateEmptyContainerReturnPayload {
   condition?: string;
   handoverNote?: string;
   performedBy?: string;
+  returnedBy?: 'EDR' | 'CUSTOMER';
 }
 
 export interface UpdateEmptyContainerReturnStatusPayload extends ImportOperationActionPayload {
diff --git a/apps/edr-freight-web/backoffice/src/types/overview.ts b/apps/edr-freight-web/backoffice/src/types/overview.ts
index 126b5f79e..f0553fc22 100644
--- a/apps/edr-freight-web/backoffice/src/types/overview.ts
+++ b/apps/edr-freight-web/backoffice/src/types/overview.ts
@@ -8,6 +8,8 @@ export type {
   IOverviewBillingKpis,
   IOverviewStaffKpis,
   IOverviewTrendPoint,
+  IOverviewDirectionTrendPoint,
+  IOverviewTonnagePoint,
   IOverviewStatusCount,
   IOverviewPipelineCount,
   IOverviewPaymentTrendPoint,
diff --git a/apps/edr-freight-web/backoffice/src/types/reports.ts b/apps/edr-freight-web/backoffice/src/types/reports.ts
new file mode 100644
index 000000000..72326788c
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/types/reports.ts
@@ -0,0 +1,27 @@
+export interface ReportKpi {
+  label: string;
+  value: number;
+  unit?: string;
+}
+
+export type ReportRow = Record<string, unknown>;
+
+export interface ReportResult {
+  kpis: ReportKpi[];
+  rows: ReportRow[];
+}
+
+/** Query params for GET /reports/:key. List filters are comma-separated. */
+export interface ReportQueryInput {
+  key: string;
+  dateFrom?: string;
+  dateTo?: string;
+  granularity?: "day" | "week" | "month";
+  companyIds?: string;
+  routeIds?: string;
+  yardIds?: string;
+  cargoTypeIds?: string;
+  statuses?: string;
+  direction?: string;
+  freightType?: string;
+}
diff --git a/apps/edr-freight-web/backoffice/src/types/trainScheduling.ts b/apps/edr-freight-web/backoffice/src/types/trainScheduling.ts
index 36fc4a112..94e393e1b 100644
--- a/apps/edr-freight-web/backoffice/src/types/trainScheduling.ts
+++ b/apps/edr-freight-web/backoffice/src/types/trainScheduling.ts
@@ -103,6 +103,21 @@ export interface BookingWagonShortage {
   wagonsShort: number;
 }
 
+/** A train a paid-unallocated booking can board (route + capacity verified). */
+export interface AllocationCandidate {
+  id: string;
+  reference: string | null;
+  direction: string | null;
+  scheduledDepartureDate: string;
+}
+
+export interface AllocationCandidates {
+  /** Trains departing on the booking's own scheduled day. */
+  sameDay: AllocationCandidate[];
+  /** Fitting trains on other days — allocating to one notifies the customer. */
+  otherDays: AllocationCandidate[];
+}
+
 export interface DeferredBookingRow {
   id: string;
   reference: string;
@@ -891,6 +906,23 @@ export interface CreateTrainSchedulePayload {
   maxWagonsPerTrain?: number;
   /** Reverse the wagon order on this train: physically-last wagon becomes position 1. */
   reverseWagonOrder?: boolean;
+  /**
+   * Configure the booking window for THIS schedule instead of inheriting the
+   * live global rules. Omit to follow the global rules (the default).
+   */
+  windowRule?: CreateScheduleWindowRulePayload;
+}
+
+/**
+ * Booking-window rule chosen at creation. Mirrors the per-schedule override plus
+ * the booking-close offset; omitted fields fall back to the global rule.
+ */
+export interface CreateScheduleWindowRulePayload
+  extends UpdateScheduleWindowRulePayload {
+  /** Minutes before departure an IMPORT/DOMESTIC window closes; null = at departure. */
+  importCloseOffsetMinutes?: number | null;
+  /** Minutes before departure an EXPORT window closes; null = at departure. */
+  exportCloseOffsetMinutes?: number | null;
 }
 
 export interface AssignBookingsPayload {
diff --git a/apps/edr-freight-web/portal/src/components/profile/MySignatureCard.tsx b/apps/edr-freight-web/portal/src/components/profile/MySignatureCard.tsx
index 678829cb3..dd911d284 100644
--- a/apps/edr-freight-web/portal/src/components/profile/MySignatureCard.tsx
+++ b/apps/edr-freight-web/portal/src/components/profile/MySignatureCard.tsx
@@ -1,5 +1,5 @@
 import { useState } from "react";
-import { FileSignature, Loader2 } from "lucide-react";
+import { FileSignature, Loader2, Stamp } from "lucide-react";
 
 import { ContractSignaturePad } from "@/components/bookings/ContractSignaturePad";
 import { StampUpload } from "@/components/contracts/StampUpload";
@@ -26,41 +26,56 @@ import {
 } from "@edr/ui-common";
 
 /**
- * Lets the signed-in customer view and update the reusable signature stored on
- * their profile. The same signature is offered for approval when signing a
- * booking contract.
+ * Lets the signed-in customer view and update the reusable signature and
+ * company stamp stored on their profile — managed independently of each
+ * other. Both are offered when signing a booking contract.
  */
 export function MySignatureCard() {
   const { user } = useAuth();
   const { data: saved, isPending } = useMySignature();
   const saveMutation = useSaveSignature();
 
-  const [open, setOpen] = useState(false);
+  const [signatureOpen, setSignatureOpen] = useState(false);
+  const [stampOpen, setStampOpen] = useState(false);
   const [signerName, setSignerName] = useState("");
   const [signatureData, setSignatureData] = useState<string | null>(null);
   const [stampData, setStampData] = useState<string | null>(null);
 
   const defaultName = user?.name?.en || user?.username || user?.email || "";
+  const savedName = saved?.signerDisplayName ?? defaultName;
 
-  const openDialog = () => {
-    setSignerName(saved?.signerDisplayName ?? defaultName);
+  const openSignatureDialog = () => {
+    setSignerName(savedName);
     setSignatureData(null);
-    setStampData(saved?.stampImageUrl ?? null);
-    setOpen(true);
+    setSignatureOpen(true);
   };
 
-  const save = () => {
+  const saveSignature = () => {
     if (!signatureData || !signerName.trim()) return;
     saveMutation.mutate(
       {
         signerDisplayName: signerName.trim(),
         signatureImageBase64: signatureData,
-        // Only send the stamp when it changed — omitted keeps the saved one.
-        ...(stampData && stampData !== saved?.stampImageUrl
-          ? { stampImageBase64: stampData }
-          : {}),
+        // Stamp untouched — it is managed by its own dialog.
       },
-      { onSuccess: () => setOpen(false) },
+      { onSuccess: () => setSignatureOpen(false) },
+    );
+  };
+
+  const openStampDialog = () => {
+    setStampData(saved?.stampImageUrl ?? null);
+    setStampOpen(true);
+  };
+
+  const saveStamp = () => {
+    if (!stampData) return;
+    saveMutation.mutate(
+      {
+        signerDisplayName: savedName || defaultName,
+        // Signature untouched — stamp-only update.
+        stampImageBase64: stampData,
+      },
+      { onSuccess: () => setStampOpen(false) },
     );
   };
 
@@ -75,47 +90,64 @@ export function MySignatureCard() {
           Reused to approve and sign booking contracts.
         </CardDescription>
       </CardHeader>
-      <CardContent className="flex flex-col gap-4">
+      <CardContent className="flex flex-col gap-6">
         {isPending ? (
           <div className="flex h-36 items-center justify-center">
             <Loader2 className="size-6 animate-spin text-primary" />
           </div>
-        ) : saved?.signatureImageUrl ? (
-          <div className="flex flex-col gap-2">
-            <div className="overflow-hidden rounded-lg border-2 border-dashed border-border bg-white">
-              <img
-                src={saved.signatureImageUrl}
-                alt="My saved signature"
-                className="mx-auto h-36 w-full object-contain"
-              />
-            </div>
-            <p className="text-xs text-muted-foreground">
-              Saved as {saved.signerDisplayName}
-            </p>
-          </div>
         ) : (
-          <p className="text-sm text-muted-foreground">
-            You have not saved a signature yet.
-          </p>
-        )}
-        {saved?.stampImageUrl && (
-          <div className="flex flex-col gap-2">
-            <div className="overflow-hidden rounded-lg border-2 border-dashed border-border bg-white">
-              <img
-                src={saved.stampImageUrl}
-                alt="My saved company stamp"
-                className="mx-auto h-24 w-full object-contain"
-              />
+          <>
+            <div className="flex flex-col gap-2">
+              {saved?.signatureImageUrl ? (
+                <>
+                  <div className="overflow-hidden rounded-lg border-2 border-dashed border-border bg-white">
+                    <img
+                      src={saved.signatureImageUrl}
+                      alt="My saved signature"
+                      className="mx-auto h-36 w-full object-contain"
+                    />
+                  </div>
+                  <p className="text-xs text-muted-foreground">
+                    Saved as {saved.signerDisplayName}
+                  </p>
+                </>
+              ) : (
+                <p className="text-sm text-muted-foreground">
+                  You have not saved a signature yet.
+                </p>
+              )}
+              <Button variant="outline" size="sm" onClick={openSignatureDialog}>
+                {saved?.signatureImageUrl ? "Update signature" : "Add signature"}
+              </Button>
             </div>
-            <p className="text-xs text-muted-foreground">Company stamp</p>
-          </div>
+
+            <div className="flex flex-col gap-2">
+              {saved?.stampImageUrl ? (
+                <>
+                  <div className="overflow-hidden rounded-lg border-2 border-dashed border-border bg-white">
+                    <img
+                      src={saved.stampImageUrl}
+                      alt="My saved company stamp"
+                      className="mx-auto h-24 w-full object-contain"
+                    />
+                  </div>
+                  <p className="text-xs text-muted-foreground">Company stamp</p>
+                </>
+              ) : (
+                <p className="text-sm text-muted-foreground">
+                  You have not uploaded a company stamp yet.
+                </p>
+              )}
+              <Button variant="outline" size="sm" onClick={openStampDialog}>
+                <Stamp className="size-4" />
+                {saved?.stampImageUrl ? "Update stamp" : "Upload stamp"}
+              </Button>
+            </div>
+          </>
         )}
-        <Button variant="outline" size="sm" onClick={openDialog}>
-          {saved?.signatureImageUrl ? "Update signature" : "Add signature"}
-        </Button>
       </CardContent>
 
-      <Dialog open={open} onOpenChange={setOpen}>
+      <Dialog open={signatureOpen} onOpenChange={setSignatureOpen}>
         <DialogContent className="sm:max-w-md">
           <DialogHeader>
             <DialogTitle>Save your signature</DialogTitle>
@@ -135,21 +167,16 @@ export function MySignatureCard() {
               />
             </div>
             <ContractSignaturePad onChange={setSignatureData} />
-            <StampUpload
-              value={stampData}
-              onChange={setStampData}
-              description="Stored on your profile and prefilled when you sign contracts."
-            />
           </div>
           <DialogFooter>
-            <Button variant="outline" onClick={() => setOpen(false)}>
+            <Button variant="outline" onClick={() => setSignatureOpen(false)}>
               Cancel
             </Button>
             <Button
               disabled={
                 saveMutation.isPending || !signatureData || !signerName.trim()
               }
-              onClick={save}
+              onClick={saveSignature}
             >
               {saveMutation.isPending ? (
                 <Loader2 className="size-4 animate-spin" />
@@ -160,6 +187,39 @@ export function MySignatureCard() {
           </DialogFooter>
         </DialogContent>
       </Dialog>
+
+      <Dialog open={stampOpen} onOpenChange={setStampOpen}>
+        <DialogContent className="sm:max-w-md">
+          <DialogHeader>
+            <DialogTitle>Company stamp</DialogTitle>
+            <DialogDescription>
+              Upload your official company stamp or seal as an image. It is
+              stored on your profile and applied next to your signature on
+              contracts.
+            </DialogDescription>
+          </DialogHeader>
+          <StampUpload
+            value={stampData}
+            onChange={setStampData}
+            description="Stored on your profile and prefilled when you sign contracts."
+          />
+          <DialogFooter>
+            <Button variant="outline" onClick={() => setStampOpen(false)}>
+              Cancel
+            </Button>
+            <Button
+              disabled={saveMutation.isPending || !stampData}
+              onClick={saveStamp}
+            >
+              {saveMutation.isPending ? (
+                <Loader2 className="size-4 animate-spin" />
+              ) : (
+                "Save stamp"
+              )}
+            </Button>
+          </DialogFooter>
+        </DialogContent>
+      </Dialog>
     </Card>
   );
 }
diff --git a/apps/edr-freight-web/portal/src/pages/accounts/SignupPage.tsx b/apps/edr-freight-web/portal/src/pages/accounts/SignupPage.tsx
index d56272e0c..03a9e515a 100644
--- a/apps/edr-freight-web/portal/src/pages/accounts/SignupPage.tsx
+++ b/apps/edr-freight-web/portal/src/pages/accounts/SignupPage.tsx
@@ -21,7 +21,9 @@ import AuthShell from "@/components/auth/AuthShell";
 import OtpChannelStep, { OTP_LENGTH } from "@/components/auth/OtpChannelStep";
 import PasswordChecklist from "@/components/auth/PasswordChecklist";
 import { ControlledPhoneField, isValidPhone } from "@/components/PhoneField";
+import { StampUpload } from "@/components/contracts/StampUpload";
 import { api } from "@/services/api";
+import { signaturesService } from "@/services/signatures.service";
 import {
   confirmPasswordField,
   passwordField,
@@ -59,6 +61,10 @@ export default function SignupPage() {
   const navigate = useNavigate();
   const { signup } = useAuth();
   const [error, setError] = useState<string | null>(null);
+  // Company stamp image, captured at signup and stored on the new profile so
+  // it is ready when the customer signs their first contract. Optional —
+  // individuals without a stamp can add one later from Settings.
+  const [stampData, setStampData] = useState<string | null>(null);
 
   // Two-stage signup: fill the form, then a mandatory OTP challenge before the
   // account is actually created. The code goes to BOTH the email and phone just
@@ -179,6 +185,18 @@ export default function SignupPage() {
       };
       const result = await signup(payload);
       if (result.success) {
+        // Signup logs the user in, so the stamp can land on their profile
+        // right away. Non-fatal — it can also be added later from Settings.
+        if (stampData) {
+          try {
+            await signaturesService.saveMySignature({
+              signerDisplayName: payload.name.en,
+              stampImageBase64: stampData,
+            });
+          } catch {
+            // Ignore — account exists; the stamp can be re-uploaded later.
+          }
+        }
         navigate("/portal");
       } else {
         setOtpError(result.error.message);
@@ -269,6 +287,13 @@ export default function SignupPage() {
                 {...register("confirmPassword")}
               />
 
+              <StampUpload
+                value={stampData}
+                onChange={setStampData}
+                label="Company stamp (optional)"
+                description="Stored on your profile and applied next to your signature when you sign contracts."
+              />
+
               {error ? (
                 <Alert
                   color="red"
diff --git a/apps/edr-freight-web/portal/src/pages/bookings/booking-display.tsx b/apps/edr-freight-web/portal/src/pages/bookings/booking-display.tsx
index ec5abad1b..7dc1109eb 100644
--- a/apps/edr-freight-web/portal/src/pages/bookings/booking-display.tsx
+++ b/apps/edr-freight-web/portal/src/pages/bookings/booking-display.tsx
@@ -145,12 +145,38 @@ export function paymentStatusLabel(status?: string | null): string {
 }
 
 /**
- * Payment status pill. Once the booking's own lifecycle status has moved past
- * payment (PAID or later — stage ≥ 3 in STATUS_CONFIG), payment is a settled
- * fact: show "Paid" even if a stale/lagging `paymentStatus` value says
- * otherwise, rather than surface a contradictory "Paid booking, pending
- * payment" row.
+ * Booking statuses that are only reachable at or after the payment gate.
+ * Settlement writes `status` and `paymentStatus` in one transaction
+ * (booking-invoice.service.ts `advanceBookingOnPayment`), so these are a
+ * backstop for a stale/lagging `paymentStatus` — not the primary signal.
  */
+const PAID_OR_LATER_STATUSES = new Set([
+  "PAID",
+  "TRUCK_ASSIGNED",
+  "IN_TRANSIT",
+  "ARRIVED",
+  "COMPLETED",
+]);
+
+/**
+ * Payment status pill. `paymentStatus` is authoritative; the status set above
+ * only covers a lagging read, so a booking past the payment gate never shows a
+ * contradictory "Paid booking, pending payment" row.
+ *
+ * Note the set is explicit rather than derived from `STATUS_CONFIG.stage` —
+ * stage is a portal timeline grouping, and stage 3 lumps pre-payment clearance
+ * statuses (AWAITING_DOCUMENTS, CLEARANCE_READY, SIGNED_CUSTOMER, OPERATION_*)
+ * in with genuinely post-payment ones, which made every freshly initiated
+ * contract booking render as "Paid".
+ */
+export function effectivePaymentStatus(
+  status?: string | null,
+  bookingStatus?: string | null,
+): string | null | undefined {
+  const settled = bookingStatus ? PAID_OR_LATER_STATUSES.has(bookingStatus) : false;
+  return settled ? "PAID" : status;
+}
+
 export function PaymentBadge({
   status,
   bookingStatus,
@@ -158,8 +184,7 @@ export function PaymentBadge({
   status?: string | null;
   bookingStatus?: string | null;
 }) {
-  const settled = bookingStatus ? (STATUS_CONFIG[bookingStatus]?.stage ?? 0) >= 3 : false;
-  const effective = settled ? "PAID" : status;
+  const effective = effectivePaymentStatus(status, bookingStatus);
   if (!effective) return <Text fz={13} c="dimmed">—</Text>;
   return (
     <Badge
diff --git a/apps/edr-freight-web/portal/src/pages/bookings/payment-badge.test.ts b/apps/edr-freight-web/portal/src/pages/bookings/payment-badge.test.ts
new file mode 100644
index 000000000..658ad31a6
--- /dev/null
+++ b/apps/edr-freight-web/portal/src/pages/bookings/payment-badge.test.ts
@@ -0,0 +1,35 @@
+import { describe, expect, it } from "vitest";
+
+import { effectivePaymentStatus } from "./booking-display";
+
+describe("effectivePaymentStatus", () => {
+  it("keeps PENDING for pre-payment statuses", () => {
+    // Regression: these all sit at STATUS_CONFIG stage 3, so the old
+    // `stage >= 3` heuristic rendered every freshly initiated contract
+    // booking as "Paid".
+    for (const s of [
+      "AWAITING_DOCUMENTS",
+      "DOCUMENTS_UNDER_REVIEW",
+      "CLEARANCE_READY",
+      "SIGNED_CUSTOMER",
+      "FULLY_EXECUTED",
+      "SELECTED_FOR_BATCH",
+      "OPERATION_REQUEST_PENDING",
+      "PNR_GENERATED",
+    ]) {
+      expect(effectivePaymentStatus("PENDING", s)).toBe("PENDING");
+    }
+  });
+
+  it("shows PAID once the booking is at or past the payment gate", () => {
+    for (const s of ["PAID", "TRUCK_ASSIGNED", "IN_TRANSIT", "ARRIVED", "COMPLETED"]) {
+      expect(effectivePaymentStatus("PENDING", s)).toBe("PAID");
+    }
+  });
+
+  it("passes the real payment status through when the booking status is absent", () => {
+    expect(effectivePaymentStatus("PAID", null)).toBe("PAID");
+    expect(effectivePaymentStatus("FAILED", undefined)).toBe("FAILED");
+    expect(effectivePaymentStatus(null, null)).toBeNull();
+  });
+});
diff --git a/apps/edr-freight-web/portal/src/pages/contracts/NewShipmentPage.tsx b/apps/edr-freight-web/portal/src/pages/contracts/NewShipmentPage.tsx
index 50f2828f6..6b2ce4470 100644
--- a/apps/edr-freight-web/portal/src/pages/contracts/NewShipmentPage.tsx
+++ b/apps/edr-freight-web/portal/src/pages/contracts/NewShipmentPage.tsx
@@ -266,8 +266,7 @@ function NewShipmentBookingForm({
       withReturn: contract.equipmentReturn === "WITH_RETURN",
       // The contract quotes USD; the customer bills this shipment in the
       // currency they pick here. Intercity is always ETB.
-      paymentCurrency:
-        contract.tradeDirection === "DOMESTIC" ? "ETB" : "USD",
+      paymentCurrency: contract.tradeDirection === "DOMESTIC" ? "ETB" : "USD",
     },
     resolver: zodResolver(
       createShipmentFormSchema({
@@ -306,7 +305,10 @@ function NewShipmentBookingForm({
             bookingId: completeBookingId,
             dto,
           })
-        : api.contracts.createBookingUnderContract.call({ id: contractId, dto }),
+        : api.contracts.createBookingUnderContract.call({
+            id: contractId,
+            dto,
+          }),
     onSuccess: (booking) => {
       queryClient.invalidateQueries({ queryKey: api.bookings.list.queryKey() });
       queryClient.invalidateQueries({
@@ -366,7 +368,8 @@ function NewShipmentBookingForm({
               .map((l) => ({
                 containerSize: l.containerSize,
                 quantity: Number(l.quantity),
-                hazardousQuantity: Number(l.hazardousQuantity || 0) || undefined,
+                hazardousQuantity:
+                  Number(l.hazardousQuantity || 0) || undefined,
                 reeferQuantity: Number(l.reeferQuantity || 0) || undefined,
                 ...(withReturnService
                   ? { returnQuantity: Number(l.returnQuantity || 0) }
@@ -379,7 +382,9 @@ function NewShipmentBookingForm({
                   // line counts and bills each surcharge on the ticked containers.
                   isHazardous: Boolean(u.isHazardous),
                   isReefer: Boolean(u.isReefer),
-                  ...(withReturnService ? { isReturn: Boolean(u.isReturn) } : {}),
+                  ...(withReturnService
+                    ? { isReturn: Boolean(u.isReturn) }
+                    : {}),
                 })),
               })),
           }
@@ -417,6 +422,12 @@ function NewShipmentBookingForm({
     validateMutation.mutate(buildDto(values));
   });
 
+  // The per-field messages render inline, but on a long single-page form the
+  // failing field is often scrolled out of view — mirror the backoffice's
+  // summary alert next to the submit button so the click never looks inert.
+  const showValidationSummary =
+    form.formState.isSubmitted && !form.formState.isValid;
+
   const handleConfirm = () => {
     if (!pendingValues) return;
     // Guard: never let a booking with unresolved 20ft pairing errors submit.
@@ -457,8 +468,15 @@ function NewShipmentBookingForm({
         mb="lg"
       >
         <Box>
-          <Title order={1} fw={800} fz={26} style={{ letterSpacing: "-0.01em" }}>
-            {completeBookingId ? "Complete Your Booking" : "New Shipment Booking"}
+          <Title
+            order={1}
+            fw={800}
+            fz={26}
+            style={{ letterSpacing: "-0.01em" }}
+          >
+            {completeBookingId
+              ? "Complete Your Booking"
+              : "New Shipment Booking"}
           </Title>
           <Text size="sm" c="edr-muted" mt={4}>
             {completeBookingId
@@ -534,28 +552,41 @@ function NewShipmentBookingForm({
             marginTop: "auto",
           }}
         >
-          <Group justify="flex-end" className="mx-auto max-w-4xl">
-            <Tooltip
-              label={`Book an even number of 20ft containers — ${ft20Total} is odd and would leave one unpaired.`}
-              withArrow
-              disabled={!hasOdd20ft}
-            >
-              {/* Mantine tooltips get no pointer events from a disabled button,
+          <Box className="mx-auto max-w-4xl">
+            {showValidationSummary ? (
+              <Alert
+                color="red"
+                variant="light"
+                radius="md"
+                icon={<AlertCircle size={16} />}
+                mb="sm"
+              >
+                Fix the highlighted fields before reviewing the price.
+              </Alert>
+            ) : null}
+            <Group justify="flex-end">
+              <Tooltip
+                label={`Book an even number of 20ft containers — ${ft20Total} is odd and would leave one unpaired.`}
+                withArrow
+                disabled={!hasOdd20ft}
+              >
+                {/* Mantine tooltips get no pointer events from a disabled button,
                   so the wrapper carries the hover target. */}
-              <Box>
-                <Button
-                  type="button"
-                  color="edr-green"
-                  radius="md"
-                  leftSection={<Receipt size={16} />}
-                  onClick={handleReview}
-                  disabled={hasOdd20ft}
-                >
-                  Review price &amp; book
-                </Button>
-              </Box>
-            </Tooltip>
-          </Group>
+                <Box>
+                  <Button
+                    type="button"
+                    color="edr-green"
+                    radius="md"
+                    leftSection={<Receipt size={16} />}
+                    onClick={handleReview}
+                    disabled={hasOdd20ft}
+                  >
+                    Review price &amp; book
+                  </Button>
+                </Box>
+              </Tooltip>
+            </Group>
+          </Box>
         </Box>
       </form>
 
@@ -621,8 +652,7 @@ function PriceConfirmModal({
         quantity: li.quantity,
         amount: li.amount,
       })),
-      total:
-        validation?.totalAmount ?? items.reduce((s, l) => s + l.amount, 0),
+      total: validation?.totalAmount ?? items.reduce((s, l) => s + l.amount, 0),
     };
   }, [validation, baseTotal]);
 
@@ -715,8 +745,8 @@ function PriceConfirmModal({
                   </Text>
                 ))}
                 <Text fz="xs" c="red.7" mt={2}>
-                  Adjust the 20ft container weights or quantities so pairs differ
-                  by no more than 10 tons.
+                  Adjust the 20ft container weights or quantities so pairs
+                  differ by no more than 10 tons.
                 </Text>
               </Stack>
             </Alert>
@@ -810,7 +840,12 @@ function PriceConfirmModal({
             </Alert>
           )}
 
-          <Paper withBorder radius={16} p="lg" style={{ borderColor: "#E6ECF2" }}>
+          <Paper
+            withBorder
+            radius={16}
+            p="lg"
+            style={{ borderColor: "#E6ECF2" }}
+          >
             <Stack gap={10}>
               {total.lines.map((line, i) => (
                 <Group key={i} justify="space-between" wrap="nowrap" gap="sm">
@@ -1007,7 +1042,9 @@ function ScheduleStep({
   const isIntercity = contract.tradeDirection === "DOMESTIC";
   const { data: availableDays, isLoading } = useQuery({
     ...api.bookings.getAvailableDaysForCargo.queryOptions({
-      input: cargoQuery ?? ({ freightType: "BULK" } as Freight.AvailableDaysForCargoQuery),
+      input:
+        cargoQuery ??
+        ({ freightType: "BULK" } as Freight.AvailableDaysForCargoQuery),
     }),
     enabled: cargoQuery !== null && !isIntercity,
   });
@@ -1064,7 +1101,12 @@ function ScheduleStep({
           title="Schedule"
           description="Intercity shipments have no fixed day."
         />
-        <Alert color="blue" variant="light" radius="md" icon={<AlertCircle size={16} />}>
+        <Alert
+          color="blue"
+          variant="light"
+          radius="md"
+          icon={<AlertCircle size={16} />}
+        >
           Your shipment rides the next import/export train passing through your
           corridor. Operations assign it to a train with free capacity — you
           will be notified when it is accepted and payment is due.
@@ -1110,7 +1152,12 @@ function ScheduleStep({
         )}
       />
       {cargoQuery === null ? (
-        <Alert color="yellow" variant="light" radius="md" icon={<AlertCircle size={16} />}>
+        <Alert
+          color="yellow"
+          variant="light"
+          radius="md"
+          icon={<AlertCircle size={16} />}
+        >
           Enter your cargo details first — available shipment days depend on the
           wagons your cargo needs.
         </Alert>
@@ -1245,11 +1292,11 @@ function CargoStep({
       "containers",
       sizes.map((size) => ({
         containerSize: size,
-        quantity: "1",
+        quantity: "0",
         hazardousQuantity: "0",
         reeferQuantity: "0",
         returnQuantity: "0",
-        units: [emptyUnit()],
+        units: [],
       })),
       { shouldValidate: false },
     );
@@ -1289,11 +1336,11 @@ function CargoStep({
         return (
           current.find((l) => l.containerSize === size) ?? {
             containerSize: size,
-            quantity: "1",
+            quantity: "0",
             hazardousQuantity: "0",
             reeferQuantity: "0",
             returnQuantity: "0",
-            units: [emptyUnit()],
+            units: [],
           }
         );
       }
@@ -1315,7 +1362,10 @@ function CargoStep({
         })),
       };
     });
-    form.setValue("containers", next, { shouldValidate: true, shouldDirty: true });
+    form.setValue("containers", next, {
+      shouldValidate: true,
+      shouldDirty: true,
+    });
     setImportErrors([]);
     setImportSummary(`Imported ${rows.length} container(s) from ${file.name}.`);
   };
@@ -1330,7 +1380,12 @@ function CargoStep({
         />
         <Stack gap={18}>
           {sizes.length > 0 && (
-            <Paper withBorder radius="md" p="md" style={{ borderColor: "#E6ECF2" }}>
+            <Paper
+              withBorder
+              radius="md"
+              p="md"
+              style={{ borderColor: "#E6ECF2" }}
+            >
               <Group justify="space-between" wrap="wrap" gap="sm">
                 <Box>
                   <Text fz={13} fw={600} c="#10202F">
@@ -1458,10 +1513,11 @@ function CargoStep({
                 title={`Odd number of 20ft containers (${ft20})`}
               >
                 <Text fz={13}>
-                  20ft containers travel two per wagon, so they must be booked in
-                  even numbers. Please add one more 20ft container or remove one
-                  (e.g. book {ft20 + 1} or {ft20 - 1} instead of {ft20}) — the
-                  booking cannot be submitted with an unpaired 20ft container.
+                  20ft containers travel two per wagon, so they must be booked
+                  in even numbers. Please add one more 20ft container or remove
+                  one (e.g. book {ft20 + 1} or {ft20 - 1} instead of {ft20}) —
+                  the booking cannot be submitted with an unpaired 20ft
+                  container.
                 </Text>
               </Alert>
             );
@@ -1660,16 +1716,6 @@ function NotesSection({ form }: { form: ShipmentForm }) {
   );
 }
 
-/** A blank container row — handling switches start off. */
-const emptyUnit = () => ({
-  containerNumber: "",
-  sealNumber: "",
-  vgmTons: "",
-  isHazardous: false,
-  isReefer: false,
-  isReturn: false,
-});
-
 function ContainerLineEditor({
   form,
   index,
@@ -1726,7 +1772,11 @@ function ContainerLineEditor({
    * price estimate and the submitted payload stay in step with the switches.
    */
   const syncHandlingCounts = (
-    units: Array<{ isHazardous?: boolean; isReefer?: boolean; isReturn?: boolean }>,
+    units: Array<{
+      isHazardous?: boolean;
+      isReefer?: boolean;
+      isReturn?: boolean;
+    }>,
   ) => {
     const set = (
       key: "hazardousQuantity" | "reeferQuantity" | "returnQuantity",
@@ -1856,94 +1906,100 @@ function ContainerLineEditor({
             ))}
           </Group>
         )}
-        {Array.from({ length: Math.max(quantity, units.length) }).map((_, u) => (
-          <Group key={u} gap={10} wrap="nowrap" align="flex-start">
-            <Controller
-              name={`containers.${index}.units.${u}.containerNumber`}
-              control={form.control}
-              render={({ field, fieldState }) => (
-                <TextInput
-                  {...field}
-                  onChange={(e) =>
-                    field.onChange(e.currentTarget.value.toUpperCase())
-                  }
-                  placeholder="e.g. MSCU1234567"
-                  error={fieldState.error?.message}
-                  radius={10}
-                  styles={fieldStyles}
-                  style={{ flex: 1 }}
-                />
-              )}
-            />
-            <Controller
-              name={`containers.${index}.units.${u}.sealNumber`}
-              control={form.control}
-              render={({ field }) => (
-                <TextInput
-                  {...field}
-                  placeholder="Optional"
-                  radius={10}
-                  styles={fieldStyles}
-                  style={{ flex: 1 }}
-                />
-              )}
-            />
-            <Controller
-              name={`containers.${index}.units.${u}.vgmTons`}
-              control={form.control}
-              render={({ field, fieldState }) => (
-                <TextInput
-                  {...field}
-                  type="number"
-                  onKeyDown={blockNegative}
-                  placeholder="e.g. 24.5"
-                  min={0}
-                  step={0.01}
-                  error={fieldState.error?.message}
-                  radius={10}
-                  styles={fieldStyles}
-                  style={{ flex: 1 }}
-                />
-              )}
-            />
-            {handlingColumns.map((col) => (
+        {Array.from({ length: Math.max(quantity, units.length) }).map(
+          (_, u) => (
+            <Group key={u} gap={10} wrap="nowrap" align="flex-start">
               <Controller
-                key={col.key}
-                name={`containers.${index}.units.${u}.${col.key}`}
+                name={`containers.${index}.units.${u}.containerNumber`}
                 control={form.control}
-                render={({ field }) => (
-                  <Box
-                    style={{
-                      width: 96,
-                      flexShrink: 0,
-                      height: 42,
-                      display: "flex",
-                      alignItems: "center",
-                      justifyContent: "center",
-                    }}
-                  >
-                    <Switch
-                      checked={Boolean(field.value)}
-                      aria-label={`${col.label} — container ${u + 1}`}
-                      onChange={(e) =>
-                        toggleUnitHandling(u, col.key, e.currentTarget.checked)
-                      }
-                      size="sm"
-                    />
-                  </Box>
+                render={({ field, fieldState }) => (
+                  <TextInput
+                    {...field}
+                    onChange={(e) =>
+                      field.onChange(e.currentTarget.value.toUpperCase())
+                    }
+                    placeholder="e.g. MSCU1234567"
+                    error={fieldState.error?.message}
+                    radius={10}
+                    styles={fieldStyles}
+                    style={{ flex: 1 }}
+                  />
                 )}
               />
-            ))}
-            <ActionIcon
-              variant="subtle"
-              color="red"
-              aria-label={`Remove container ${u + 1}`}
-              onClick={() => removeUnit(u)}
-            >
-              <X size={16} />
-            </ActionIcon>
-          </Group>
-        ))}
+              <Controller
+                name={`containers.${index}.units.${u}.sealNumber`}
+                control={form.control}
+                render={({ field }) => (
+                  <TextInput
+                    {...field}
+                    placeholder="Optional"
+                    radius={10}
+                    styles={fieldStyles}
+                    style={{ flex: 1 }}
+                  />
+                )}
+              />
+              <Controller
+                name={`containers.${index}.units.${u}.vgmTons`}
+                control={form.control}
+                render={({ field, fieldState }) => (
+                  <TextInput
+                    {...field}
+                    type="number"
+                    onKeyDown={blockNegative}
+                    placeholder="e.g. 24.5"
+                    min={0}
+                    step={0.01}
+                    error={fieldState.error?.message}
+                    radius={10}
+                    styles={fieldStyles}
+                    style={{ flex: 1 }}
+                  />
+                )}
+              />
+              {handlingColumns.map((col) => (
+                <Controller
+                  key={col.key}
+                  name={`containers.${index}.units.${u}.${col.key}`}
+                  control={form.control}
+                  render={({ field }) => (
+                    <Box
+                      style={{
+                        width: 96,
+                        flexShrink: 0,
+                        height: 42,
+                        display: "flex",
+                        alignItems: "center",
+                        justifyContent: "center",
+                      }}
+                    >
+                      <Switch
+                        checked={Boolean(field.value)}
+                        aria-label={`${col.label} — container ${u + 1}`}
+                        onChange={(e) =>
+                          toggleUnitHandling(
+                            u,
+                            col.key,
+                            e.currentTarget.checked,
+                          )
+                        }
+                        size="sm"
+                      />
+                    </Box>
+                  )}
+                />
+              ))}
+              <ActionIcon
+                variant="subtle"
+                color="red"
+                aria-label={`Remove container ${u + 1}`}
+                onClick={() => removeUnit(u)}
+              >
+                <X size={16} />
+              </ActionIcon>
+            </Group>
+          ),
+        )}
       </Stack>
     </Box>
   );
diff --git a/apps/edr-freight-web/portal/src/pages/contracts/new-contract-form/step4-route.tsx b/apps/edr-freight-web/portal/src/pages/contracts/new-contract-form/step4-route.tsx
index 756dd7fd9..55109143e 100644
--- a/apps/edr-freight-web/portal/src/pages/contracts/new-contract-form/step4-route.tsx
+++ b/apps/edr-freight-web/portal/src/pages/contracts/new-contract-form/step4-route.tsx
@@ -25,6 +25,28 @@ export function Step4Route({
   const originYard = form.watch("originYard");
   const destinationYard = form.watch("destinationYard");
   const operationType = form.watch("operationType");
+  const cargoType = form.watch("cargoType");
+
+  // A yard is only offerable for the side it can actually work: loading cargo
+  // onto a train and receiving it off one need different equipment, and a yard
+  // with no facility at all reports false on every flag.
+  const yardHandlesSide = useCallback(
+    (
+      yard: Freight.BookingReferenceYard | undefined,
+      side: "origin" | "destination",
+    ) => {
+      if (!yard) return false;
+      if (side === "origin") {
+        return cargoType === "bulk"
+          ? yard.hasBulkFacilityOrigin
+          : yard.hasContainerFacilityOrigin;
+      }
+      return cargoType === "bulk"
+        ? yard.hasBulkFacilityDestination
+        : yard.hasContainerFacilityDestination;
+    },
+    [cargoType],
+  );
 
   const { originCountry, destinationCountry } = useMemo(() => {
     switch (operationType) {
@@ -47,23 +69,28 @@ export function Step4Route({
   }, [referenceData]);
 
   const yardsForSide = useCallback(
-    (country: string | null, excludeYardId: string) =>
+    (
+      country: string | null,
+      excludeYardId: string,
+      side: "origin" | "destination",
+    ) =>
       yardOptions
         .filter((o) => o.value !== excludeYardId)
         .filter((o) => {
-          if (!country) return true;
           const yard = referenceData?.yard.find((y) => y.id === o.value);
+          if (!yardHandlesSide(yard, side)) return false;
+          if (!country) return true;
           return yard?.country === country;
         }),
-    [yardOptions, referenceData],
+    [yardOptions, referenceData, yardHandlesSide],
   );
 
   const originData = useMemo(
-    () => yardsForSide(originCountry, destinationYard),
+    () => yardsForSide(originCountry, destinationYard, "origin"),
     [yardsForSide, originCountry, destinationYard],
   );
   const destData = useMemo(
-    () => yardsForSide(destinationCountry, originYard),
+    () => yardsForSide(destinationCountry, originYard, "destination"),
     [yardsForSide, destinationCountry, originYard],
   );
 
@@ -88,6 +115,18 @@ export function Step4Route({
     }
   }, [destinationCountry, dest, form]);
 
+  // Switching cargo type can strand an already-picked yard that has no facility
+  // for the new type on that side. Same pristine-hydration guard as above.
+  useEffect(() => {
+    if (!form.formState.isDirty) return;
+    if (origin && !yardHandlesSide(origin, "origin")) {
+      form.setValue("originYard", "");
+    }
+    if (dest && !yardHandlesSide(dest, "destination")) {
+      form.setValue("destinationYard", "");
+    }
+  }, [origin, dest, yardHandlesSide, form]);
+
   const directionStyle: Record<string, string> = {
     EXPORT: "bg-sky-50 text-sky-800 border-sky-200",
     IMPORT: "bg-amber-50 text-amber-800 border-amber-200",
diff --git a/apps/edr-freight-web/portal/src/services/signatures.service.ts b/apps/edr-freight-web/portal/src/services/signatures.service.ts
index 052e26b07..75a216b34 100644
--- a/apps/edr-freight-web/portal/src/services/signatures.service.ts
+++ b/apps/edr-freight-web/portal/src/services/signatures.service.ts
@@ -10,7 +10,8 @@ export interface SavedSignature {
 
 export interface SaveSignaturePayload {
   signerDisplayName: string;
-  signatureImageBase64: string;
+  /** Omit to keep the existing saved signature (stamp-only update). */
+  signatureImageBase64?: string;
   /** Omit to keep the existing saved stamp. */
   stampImageBase64?: string;
 }
diff --git a/apps/edr-passenger-api/package.json b/apps/edr-passenger-api/package.json
index f58cd7bcf..b3571871c 100644
--- a/apps/edr-passenger-api/package.json
+++ b/apps/edr-passenger-api/package.json
@@ -45,8 +45,8 @@
     "@nestjs/websockets": "^11.1.27",
     "@prisma/client": "^6.19.3",
     "@sendgrid/mail": "^8.1.0",
-    "@tria-plc/api-common": "file:../../local-packages/tria-plc-api-common-1.4.3.tgz",
-    "@tria-plc/iamapi-common": "file:../../local-packages/tria-plc-iamapi-common-0.7.9.tgz",
+    "@tria-plc/api-common": "file:../../local-packages/tria-plc-api-common-1.6.0.tgz",
+    "@tria-plc/iamapi-common": "file:../../local-packages/tria-plc-iamapi-common-1.0.0.tgz",
     "@types/bcrypt": "^6.0.0",
     "amqp-connection-manager": "^5.0.0",
     "amqplib": "^2.0.1",
diff --git a/apps/edr-passenger-api/prisma/migrations/20260802000001_add_seat_block_reason_category_and_blocker_name/migration.sql b/apps/edr-passenger-api/prisma/migrations/20260802000001_add_seat_block_reason_category_and_blocker_name/migration.sql
new file mode 100644
index 000000000..3cfc394e2
--- /dev/null
+++ b/apps/edr-passenger-api/prisma/migrations/20260802000001_add_seat_block_reason_category_and_blocker_name/migration.sql
@@ -0,0 +1,23 @@
+-- Blocked Seat Revenue Loss report (GET /reports/blocked-seats-revenue-loss) needs to answer
+-- "who blocked this seat and why". Purely additive: every column is nullable and every index is
+-- new, so rows written before this migration keep working and simply report as
+-- System / Unknown (blockedByName) and Uncategorized (reasonCategory).
+
+-- CreateEnum
+DO $$
+BEGIN
+  CREATE TYPE "passenger"."SeatBlockReasonCategory" AS ENUM ('MAINTENANCE', 'VIP_RESERVED', 'SAFETY', 'OPERATIONAL', 'OTHER');
+EXCEPTION
+  WHEN duplicate_object THEN NULL;
+END
+$$;
+
+-- AlterTable
+ALTER TABLE "passenger"."SeatBlock"
+  ADD COLUMN IF NOT EXISTS "reasonCategory" "passenger"."SeatBlockReasonCategory",
+  ADD COLUMN IF NOT EXISTS "blockedByName" TEXT;
+
+-- CreateIndex: the report filters SeatBlock by blockedAt window, and joins
+-- schedule-scoped blocks to a (schedule, seat) pair.
+CREATE INDEX IF NOT EXISTS "SeatBlock_blockedAt_idx" ON "passenger"."SeatBlock"("blockedAt");
+CREATE INDEX IF NOT EXISTS "SeatBlock_scheduleId_seatId_idx" ON "passenger"."SeatBlock"("scheduleId", "seatId");
diff --git a/apps/edr-passenger-api/prisma/schema.prisma b/apps/edr-passenger-api/prisma/schema.prisma
index 00090ff1a..7bca3116d 100644
--- a/apps/edr-passenger-api/prisma/schema.prisma
+++ b/apps/edr-passenger-api/prisma/schema.prisma
@@ -1349,19 +1349,38 @@ model NotificationTemplate {
   @@schema("passenger")
 }
 
+/// Why a seat was pulled out of sale. Coarse bucket for reporting; the free-text
+/// `reason` stays as the operator's detail. Nullable — rows written before this
+/// column existed have no category and report as "Uncategorized".
+enum SeatBlockReasonCategory {
+  MAINTENANCE
+  VIP_RESERVED
+  SAFETY
+  OPERATIONAL
+  OTHER
+
+  @@schema("passenger")
+}
+
 model SeatBlock {
-  id         String    @id @default(uuid())
-  seatId     String
-  scheduleId String?
-  reason     String
-  blockedBy  String
-  approvedBy String?
-  blockedAt  DateTime  @default(now())
-  unblockAt  DateTime?
-  seat       Seat      @relation(fields: [seatId], references: [id])
+  id             String                   @id @default(uuid())
+  seatId         String
+  scheduleId     String?
+  reason         String
+  reasonCategory SeatBlockReasonCategory?
+  blockedBy      String
+  /// Display name of the blocking staff member, denormalized at write time so the
+  /// revenue-loss report needs no cross-service IAM lookup. Null on legacy rows.
+  blockedByName  String?
+  approvedBy     String?
+  blockedAt      DateTime                 @default(now())
+  unblockAt      DateTime?
+  seat           Seat                     @relation(fields: [seatId], references: [id])
 
   @@index([seatId])
   @@index([scheduleId])
+  @@index([blockedAt])
+  @@index([scheduleId, seatId])
   @@schema("passenger")
 }
 
diff --git a/apps/edr-passenger-api/src/common/acting-user.ts b/apps/edr-passenger-api/src/common/acting-user.ts
new file mode 100644
index 000000000..630e307a8
--- /dev/null
+++ b/apps/edr-passenger-api/src/common/acting-user.ts
@@ -0,0 +1,63 @@
+/**
+ * Reading the authenticated staff member off the request.
+ *
+ * `JwtGuard` (from `@tria-plc/api-common`) puts the decoded IAM user on `request.user`.
+ * Sibling controllers reach for `req.user?.id ?? req.user?.sub`, because the shape differs
+ * slightly between token versions. This module centralises that so callers get a small,
+ * typed value object instead of an `any` bag.
+ */
+
+/** Bilingual name as IAM stores it. */
+interface ActingUserName {
+  en?: string;
+  am?: string;
+}
+
+/** The slice of `request.user` this app actually reads. */
+export interface ActingUserClaims {
+  id?: string;
+  /** Older tokens carry the subject as `sub` rather than `id`. */
+  sub?: string;
+  name?: ActingUserName | string | null;
+  username?: string;
+  email?: string;
+}
+
+/** The minimal Express request shape needed to reach the authenticated user. */
+export interface RequestWithActingUser {
+  user?: ActingUserClaims;
+}
+
+/** Who performed an action, resolved once at write time so readers need no IAM lookup. */
+export interface ActingUser {
+  /** IAM user id. */
+  id: string;
+  /** Human-readable name, denormalized alongside the id. */
+  name: string;
+}
+
+/**
+ * Resolves the acting staff member from a guarded request.
+ *
+ * Returns `null` when no user is attached — callers decide what that means. Endpoints behind
+ * `@PassengerStaff(...)` always have one, since the guard rejects anonymous requests; system
+ * paths (ticketing, cleanup jobs) legitimately have none and record themselves explicitly.
+ */
+export function resolveActingUser(req: RequestWithActingUser): ActingUser | null {
+  const claims = req.user;
+  const id = claims?.id ?? claims?.sub;
+  if (!id) return null;
+
+  return { id, name: resolveActingUserName(claims) };
+}
+
+function resolveActingUserName(claims: ActingUserClaims | undefined): string {
+  if (!claims) return 'Unknown';
+  const { name } = claims;
+  if (typeof name === 'string' && name.trim()) return name.trim();
+  if (name && typeof name === 'object') {
+    const localized = name.en?.trim() || name.am?.trim();
+    if (localized) return localized;
+  }
+  return claims.username?.trim() || claims.email?.trim() || 'Unknown';
+}
diff --git a/apps/edr-passenger-api/src/modules/dashboard/dashboard.module.ts b/apps/edr-passenger-api/src/modules/dashboard/dashboard.module.ts
index 09b3717b4..5a541452c 100644
--- a/apps/edr-passenger-api/src/modules/dashboard/dashboard.module.ts
+++ b/apps/edr-passenger-api/src/modules/dashboard/dashboard.module.ts
@@ -1,6 +1,13 @@
 import { Module } from '@nestjs/common';
 import { DashboardController } from './dashboard.controller';
 import { DashboardService } from './dashboard.service';
+import { ReportsModule } from '../reports/reports.module';
 
-@Module({ controllers: [DashboardController], providers: [DashboardService] })
+@Module({
+  // ReportsModule owns the blocked-seat revenue loss rule; the dashboard's roll-up
+  // reads it from there instead of keeping a second copy of the definition.
+  imports: [ReportsModule],
+  controllers: [DashboardController],
+  providers: [DashboardService],
+})
 export class DashboardModule {}
diff --git a/apps/edr-passenger-api/src/modules/dashboard/dashboard.service.ts b/apps/edr-passenger-api/src/modules/dashboard/dashboard.service.ts
index f7e015e11..6a5d83b89 100644
--- a/apps/edr-passenger-api/src/modules/dashboard/dashboard.service.ts
+++ b/apps/edr-passenger-api/src/modules/dashboard/dashboard.service.ts
@@ -1,17 +1,31 @@
-import { Injectable } from '@nestjs/common';
+import { Injectable, Logger } from '@nestjs/common';
 import { InjectDataSource } from '@nestjs/typeorm';
 import { DataSource } from 'typeorm';
+import { BlockedSeatRevenueLossStat } from '@edr/types';
 import { PrismaService } from '../../common/prisma.service';
+import { ReportsService } from '../reports/reports.service';
+
+/** Shown when nothing is blocked, or when the loss roll-up could not be computed. */
+const EMPTY_BLOCKED_SEAT_LOSS: BlockedSeatRevenueLossStat = {
+  periodDays: null,
+  lossByCurrency: [],
+  schedulesAffected: 0,
+  blockedSeatCount: 0,
+  topReasonCategory: null,
+};
 
 @Injectable()
 export class DashboardService {
+  private readonly logger = new Logger(DashboardService.name);
+
   constructor(
     private prisma: PrismaService,
     @InjectDataSource() private dataSource: DataSource,
+    private reports: ReportsService,
   ) {}
 
   async getBackofficeStats() {
-    const [totalBookings, totalPackageBookings, totalTickets, totalPassengers, blockedSeatsCount, revenueRows, packageRevenueRows] =
+    const [totalBookings, totalPackageBookings, totalTickets, totalPassengers, blockedSeatsCount, revenueRows, packageRevenueRows, blockedSeatRevenueLoss] =
       await Promise.all([
         this.prisma.booking.count({ where: { status: { in: ['CONFIRMED', 'BOARDED'] } } }),
         this.prisma.booking.count({ where: { status: { in: ['CONFIRMED', 'BOARDED'] }, packageId: { not: null } } }),
@@ -38,6 +52,9 @@ export class DashboardService {
             AND id IN (SELECT "bookingId" FROM passenger."PaymentIntent" WHERE status = 'SUCCEEDED')
           GROUP BY COALESCE("displayCurrency"::text, "currency"::text)
         `,
+        // Joined into this same call on purpose: the dashboard's request count stays
+        // exactly where it was, and the card renders from the payload it already fetches.
+        this.getBlockedSeatRevenueLossStat(),
       ]);
 
     const totalPackageTickets = await this.prisma.ticket.count({
@@ -58,11 +75,43 @@ export class DashboardService {
       totalNormalTickets: totalTickets - totalPackageTickets,
       totalPassengers,
       blockedSeatsCount,
+      blockedSeatRevenueLoss,
       revenueByCurrency: toMap(revenueRows),
       packageRevenueByCurrency: toMap(packageRevenueRows),
     };
   }
 
+  /**
+   * Compact roll-up of the Blocked Seat Revenue Loss report over its full history.
+   *
+   * Reuses the report service rather than re-deriving the rule — there is exactly one
+   * definition of what a blocked seat costs. A failure here degrades to zeroes instead of
+   * taking the whole dashboard down with it.
+   */
+  private async getBlockedSeatRevenueLossStat(): Promise<BlockedSeatRevenueLossStat> {
+    try {
+      // pageSize 1: only the summary is read, and paging does not change what it covers.
+      const report = await this.reports.getBlockedSeatsRevenueLoss({ page: 1, pageSize: 1 });
+      const { summary } = report;
+
+      return {
+        periodDays: null,
+        lossByCurrency: summary.lossByCurrency,
+        schedulesAffected: summary.schedulesAffected,
+        blockedSeatCount: summary.blockedSeatCount,
+        // topReasonCategories is already sorted by estimated loss, descending.
+        topReasonCategory: summary.topReasonCategories[0]?.reasonCategory ?? null,
+      };
+    } catch (err) {
+      this.logger.warn(
+        `Blocked-seat revenue loss roll-up unavailable — ${
+          err instanceof Error ? err.message : String(err)
+        }`,
+      );
+      return EMPTY_BLOCKED_SEAT_LOSS;
+    }
+  }
+
   async getHomeDashboard(passengerId: string) {
     const now = new Date();
     const [passenger, upcomingBooking, wallet, promos, weatherAlerts, stationSignals, savedRoutes] = await Promise.all([
diff --git a/apps/edr-passenger-api/src/modules/reports/blocked-seats-loss.calculator.spec.ts b/apps/edr-passenger-api/src/modules/reports/blocked-seats-loss.calculator.spec.ts
new file mode 100644
index 000000000..84aa5a72b
--- /dev/null
+++ b/apps/edr-passenger-api/src/modules/reports/blocked-seats-loss.calculator.spec.ts
@@ -0,0 +1,641 @@
+import {
+  assembleReport,
+  AssembleOptions,
+  countSellableSeats,
+  LossBlock,
+  LossCalculatorInput,
+  LossCoach,
+  LossFare,
+  LossSchedule,
+  LossSeat,
+  resolveSeatClass,
+  selectCountedBlocks,
+  soldKey,
+} from './blocked-seats-loss.calculator';
+
+// ── Fixtures ─────────────────────────────────────────────────────────────────
+
+const DEPARTURE = new Date('2026-07-15T08:00:00.000Z');
+const NOW = new Date('2026-07-20T00:00:00.000Z');
+
+const ECONOMY_LOCAL = {
+  id: 'sc-econ-local',
+  name: 'Economy',
+  bedPosition: null,
+  nationalityType: 'LOCAL',
+};
+const ECONOMY_INTL = {
+  id: 'sc-econ-intl',
+  name: 'Economy (International)',
+  bedPosition: null,
+  nationalityType: 'INTERNATIONAL',
+};
+
+function coach(overrides: Partial<LossCoach> = {}): LossCoach {
+  return {
+    id: 'coach-1',
+    number: 'C1',
+    coachTypeType: 'passenger',
+    coachTypeName: 'Economy Coach',
+    seatClasses: [ECONOMY_LOCAL, ECONOMY_INTL],
+    ...overrides,
+  };
+}
+
+function seat(overrides: Partial<LossSeat> = {}): LossSeat {
+  return {
+    id: 'seat-1',
+    coachId: 'coach-1',
+    seatNumber: '1',
+    bedPosition: null,
+    premiumFeeMinor: 0,
+    ...overrides,
+  };
+}
+
+function schedule(overrides: Partial<LossSchedule> = {}): LossSchedule {
+  return {
+    id: 'sched-1',
+    trainNumber: 'ET-101',
+    routeName: 'Addis Ababa — Dire Dawa',
+    originStation: 'Addis Ababa',
+    destinationStation: 'Dire Dawa',
+    departureAt: DEPARTURE,
+    status: 'SCHEDULED',
+    ...overrides,
+  };
+}
+
+function block(overrides: Partial<LossBlock> = {}): LossBlock {
+  return {
+    id: 'block-1',
+    seatId: 'seat-1',
+    scheduleId: null,
+    reason: 'Torn upholstery',
+    reasonCategory: 'MAINTENANCE',
+    blockedBy: 'user-1',
+    blockedByName: 'Abebe Bekele',
+    approvedBy: null,
+    blockedAt: new Date('2026-07-10T00:00:00.000Z'),
+    unblockAt: null,
+    ...overrides,
+  };
+}
+
+function fare(overrides: Partial<LossFare> = {}): LossFare {
+  return {
+    seatClassId: ECONOMY_LOCAL.id,
+    seatClassName: 'Economy',
+    farePerPassengerMinor: 50_000, // ETB 500.00
+    exchangeRate: 1,
+    currency: 'ETB',
+    ...overrides,
+  };
+}
+
+/** Builds a calculator input from loose parts, wiring up the id→entity maps. */
+function makeInput(parts: {
+  schedules?: LossSchedule[];
+  seats?: LossSeat[];
+  coaches?: LossCoach[];
+  /** scheduleId → coachIds assigned to it. */
+  assignments?: Record<string, string[]>;
+  sold?: [string, string][];
+  blocks?: LossBlock[];
+}): LossCalculatorInput {
+  const seats = parts.seats ?? [seat()];
+  const coaches = parts.coaches ?? [coach()];
+  const schedules = parts.schedules ?? [schedule()];
+  const assignments = parts.assignments ?? { 'sched-1': ['coach-1'] };
+
+  return {
+    schedules,
+    seatsById: new Map(seats.map((s) => [s.id, s])),
+    coachesById: new Map(coaches.map((c) => [c.id, c])),
+    coachIdsBySchedule: new Map(
+      Object.entries(assignments).map(([sid, cids]) => [sid, new Set(cids)]),
+    ),
+    soldSeatKeys: new Set((parts.sold ?? []).map(([sid, seatId]) => soldKey(sid, seatId))),
+    blocks: parts.blocks ?? [block()],
+  };
+}
+
+function makeOptions(overrides: Partial<AssembleOptions> = {}): AssembleOptions {
+  return {
+    faresBySchedule: new Map([['sched-1', new Map([[ECONOMY_LOCAL.id, fare()]])]]),
+    schedulesWithoutFare: new Set<string>(),
+    nationalityType: 'LOCAL',
+    nationalityAssumption: 'Ethiopian',
+    now: NOW,
+    dateFrom: new Date('2026-07-01T00:00:00.000Z'),
+    dateTo: new Date('2026-07-31T23:59:59.999Z'),
+    page: 1,
+    pageSize: 25,
+    sortBy: 'lossMinor',
+    ...overrides,
+  };
+}
+
+// ── Tests ────────────────────────────────────────────────────────────────────
+
+describe('blocked-seats-loss calculator', () => {
+  describe('schedule attribution', () => {
+    it('counts a schedule-scoped block against exactly that schedule', () => {
+      const other = schedule({ id: 'sched-2' });
+      const counted = selectCountedBlocks(
+        makeInput({
+          schedules: [schedule(), other],
+          assignments: { 'sched-1': ['coach-1'], 'sched-2': ['coach-1'] },
+          blocks: [block({ scheduleId: 'sched-1' })],
+        }),
+      );
+
+      expect(counted.get('sched-1')).toHaveLength(1);
+      expect(counted.get('sched-1')?.[0].blockType).toBe('SCHEDULE');
+      // Same coach runs on sched-2, but the block named sched-1 only.
+      expect(counted.has('sched-2')).toBe(false);
+    });
+
+    it('counts a global block against every schedule its window covers', () => {
+      const counted = selectCountedBlocks(
+        makeInput({
+          schedules: [schedule(), schedule({ id: 'sched-2' })],
+          assignments: { 'sched-1': ['coach-1'], 'sched-2': ['coach-1'] },
+          blocks: [block({ scheduleId: null })],
+        }),
+      );
+
+      expect(counted.get('sched-1')?.[0].blockType).toBe('GLOBAL');
+      expect(counted.get('sched-2')?.[0].blockType).toBe('GLOBAL');
+    });
+
+    it('ignores a global block that started after departure', () => {
+      const counted = selectCountedBlocks(
+        makeInput({
+          blocks: [block({ blockedAt: new Date('2026-07-16T00:00:00.000Z') })],
+        }),
+      );
+      expect(counted.size).toBe(0);
+    });
+
+    it('ignores a global block that was lifted before departure', () => {
+      const counted = selectCountedBlocks(
+        makeInput({
+          blocks: [
+            block({
+              blockedAt: new Date('2026-07-01T00:00:00.000Z'),
+              unblockAt: new Date('2026-07-10T00:00:00.000Z'),
+            }),
+          ],
+        }),
+      );
+      expect(counted.size).toBe(0);
+    });
+
+    it('counts a global block still open at departure', () => {
+      const counted = selectCountedBlocks(
+        makeInput({
+          blocks: [
+            block({
+              blockedAt: new Date('2026-07-01T00:00:00.000Z'),
+              unblockAt: new Date('2026-07-20T00:00:00.000Z'),
+            }),
+          ],
+        }),
+      );
+      expect(counted.get('sched-1')).toHaveLength(1);
+    });
+
+    it('counts a seat blocked twice for one schedule only once, at the newer block', () => {
+      const counted = selectCountedBlocks(
+        makeInput({
+          blocks: [
+            block({ id: 'old', blockedAt: new Date('2026-07-01T00:00:00.000Z') }),
+            block({ id: 'new', blockedAt: new Date('2026-07-09T00:00:00.000Z') }),
+          ],
+        }),
+      );
+
+      expect(counted.get('sched-1')).toHaveLength(1);
+      expect(counted.get('sched-1')?.[0].block.id).toBe('new');
+    });
+
+    it('prefers a schedule-scoped block over a global one for the same seat', () => {
+      const counted = selectCountedBlocks(
+        makeInput({
+          blocks: [
+            block({ id: 'global', scheduleId: null }),
+            block({ id: 'scoped', scheduleId: 'sched-1' }),
+          ],
+        }),
+      );
+
+      expect(counted.get('sched-1')).toHaveLength(1);
+      expect(counted.get('sched-1')?.[0].block.id).toBe('scoped');
+    });
+
+    it('skips CANCELLED schedules entirely', () => {
+      const counted = selectCountedBlocks(
+        makeInput({ schedules: [schedule({ status: 'CANCELLED' })] }),
+      );
+      expect(counted.size).toBe(0);
+    });
+  });
+
+  describe('coach-assignment gating', () => {
+    it('ignores a global block when the seat\'s coach was not on that train', () => {
+      const counted = selectCountedBlocks(
+        makeInput({ assignments: { 'sched-1': ['coach-other'] } }),
+      );
+      expect(counted.size).toBe(0);
+    });
+
+    it('counts a global block when the coach was assigned', () => {
+      const counted = selectCountedBlocks(
+        makeInput({ assignments: { 'sched-1': ['coach-1'] } }),
+      );
+      expect(counted.get('sched-1')).toHaveLength(1);
+    });
+
+    it('gates each schedule independently on its own assignments', () => {
+      const counted = selectCountedBlocks(
+        makeInput({
+          schedules: [schedule(), schedule({ id: 'sched-2' })],
+          assignments: { 'sched-1': ['coach-1'], 'sched-2': ['coach-other'] },
+        }),
+      );
+
+      expect(counted.has('sched-1')).toBe(true);
+      expect(counted.has('sched-2')).toBe(false);
+    });
+  });
+
+  describe('dining and placeholder exclusion', () => {
+    it('excludes seats in a dining coach', () => {
+      const counted = selectCountedBlocks(
+        makeInput({ coaches: [coach({ coachTypeType: 'dining' })] }),
+      );
+      expect(counted.size).toBe(0);
+    });
+
+    it('excludes placeholder seats whose number starts with "-"', () => {
+      const counted = selectCountedBlocks(
+        makeInput({ seats: [seat({ seatNumber: '-1' })] }),
+      );
+      expect(counted.size).toBe(0);
+    });
+
+    // Regression: real EDR data puts a display name in CoachType.type — 'Dining Coach '
+    // with a trailing space — rather than the documented 'dining' slug. An exact match
+    // let dining seats into the report and inflated the blocked-seat count.
+    it.each([
+      ['dining'],
+      ['Dining Coach '],
+      ['DINING'],
+      ['  dining  '],
+    ])('excludes a dining coach whose type is %p', (coachTypeType) => {
+      const counted = selectCountedBlocks(
+        makeInput({ coaches: [coach({ coachTypeType, coachTypeName: 'Dining Coach ' })] }),
+      );
+      expect(counted.size).toBe(0);
+    });
+
+    it('excludes a dining coach identified only by its coachType name', () => {
+      const counted = selectCountedBlocks(
+        makeInput({
+          coaches: [coach({ coachTypeType: 'Regular Seat', coachTypeName: 'Dining Coach ' })],
+        }),
+      );
+      expect(counted.size).toBe(0);
+    });
+
+    it('does not mistake a normal coach for a dining one', () => {
+      const counted = selectCountedBlocks(
+        makeInput({
+          coaches: [coach({ coachTypeType: 'Regular Seat', coachTypeName: 'Hard Seat Coach' })],
+        }),
+      );
+      expect(counted.get('sched-1')).toHaveLength(1);
+    });
+
+    it('keeps a real seat in a sleeper coach', () => {
+      const counted = selectCountedBlocks(
+        makeInput({ coaches: [coach({ coachTypeType: 'sleeper' })] }),
+      );
+      expect(counted.get('sched-1')).toHaveLength(1);
+    });
+
+    it('leaves dining and placeholder seats out of the sellable-seat denominator', () => {
+      const input = makeInput({
+        seats: [
+          seat({ id: 'real-1', coachId: 'coach-1', seatNumber: '1' }),
+          seat({ id: 'real-2', coachId: 'coach-1', seatNumber: '2' }),
+          seat({ id: 'spacer', coachId: 'coach-1', seatNumber: '-1' }),
+          seat({ id: 'diner', coachId: 'coach-dining', seatNumber: '1' }),
+        ],
+        coaches: [coach(), coach({ id: 'coach-dining', coachTypeType: 'dining' })],
+        assignments: { 'sched-1': ['coach-1', 'coach-dining'] },
+      });
+
+      expect(countSellableSeats('sched-1', input)).toBe(2);
+    });
+  });
+
+  describe('blocked-after-sale exclusion', () => {
+    it('excludes a blocked seat that was nonetheless sold on that schedule', () => {
+      const counted = selectCountedBlocks(
+        makeInput({ sold: [['sched-1', 'seat-1']] }),
+      );
+      expect(counted.size).toBe(0);
+    });
+
+    it('still counts the block on a schedule where the seat was not sold', () => {
+      const counted = selectCountedBlocks(
+        makeInput({
+          schedules: [schedule(), schedule({ id: 'sched-2' })],
+          assignments: { 'sched-1': ['coach-1'], 'sched-2': ['coach-1'] },
+          sold: [['sched-1', 'seat-1']],
+        }),
+      );
+
+      expect(counted.has('sched-1')).toBe(false);
+      expect(counted.has('sched-2')).toBe(true);
+    });
+
+    it("excludes ticketing's own bookkeeping blocks", () => {
+      const counted = selectCountedBlocks(
+        makeInput({ blocks: [block({ reason: 'Booked in tickets t-1, t-2' })] }),
+      );
+      expect(counted.size).toBe(0);
+    });
+  });
+
+  describe('seat-class resolution and per-seat loss', () => {
+    it('picks the seat class variant matching the nationality assumption', () => {
+      expect(resolveSeatClass(seat(), coach(), 'LOCAL')?.id).toBe(ECONOMY_LOCAL.id);
+      expect(resolveSeatClass(seat(), coach(), 'INTERNATIONAL')?.id).toBe(ECONOMY_INTL.id);
+    });
+
+    it('narrows by bed position before nationality in a sleeper coach', () => {
+      const upper = { id: 'sc-upper', name: 'Upper Berth', bedPosition: 'upper', nationalityType: 'LOCAL' };
+      const lower = { id: 'sc-lower', name: 'Lower Berth', bedPosition: 'lower', nationalityType: 'LOCAL' };
+      const sleeper = coach({ seatClasses: [upper, lower] });
+
+      expect(resolveSeatClass(seat({ bedPosition: 'LOWER' }), sleeper, 'LOCAL')?.id).toBe('sc-lower');
+    });
+
+    it("adds the seat's own premium fee to the class fare", () => {
+      const report = assembleReport(
+        makeInput({ seats: [seat({ premiumFeeMinor: 2_500 })] }),
+        selectCountedBlocks(makeInput({ seats: [seat({ premiumFeeMinor: 2_500 })] })),
+        makeOptions(),
+      );
+
+      // 50_000 class fare + 2_500 seat premium
+      expect(report.schedules[0].blocks[0].estimatedLossMinor).toBe(52_500);
+    });
+
+    it('counts the seat but claims no money when no fare could be quoted', () => {
+      const input = makeInput({});
+      const report = assembleReport(input, selectCountedBlocks(input), makeOptions({
+        faresBySchedule: new Map(),
+        schedulesWithoutFare: new Set(['sched-1']),
+      }));
+
+      expect(report.summary.blockedSeatCount).toBe(1);
+      expect(report.schedules[0].estimatedLossMinor).toBe(0);
+      expect(report.meta.schedulesWithoutFare).toBe(1);
+    });
+  });
+
+  describe('load-factor adjustment', () => {
+    it('scales estimated loss by sold ÷ sellable', () => {
+      const seats = [
+        seat({ id: 'seat-1', seatNumber: '1' }),
+        seat({ id: 'seat-2', seatNumber: '2' }),
+        seat({ id: 'seat-3', seatNumber: '3' }),
+        seat({ id: 'seat-4', seatNumber: '4' }),
+      ];
+      // 4 sellable seats, 2 sold ⇒ load factor 0.5.
+      const parts = { seats, sold: [['sched-1', 'seat-2'], ['sched-1', 'seat-3']] as [string, string][] };
+      const input = makeInput(parts);
+      const report = assembleReport(input, selectCountedBlocks(input), makeOptions());
+
+      const row = report.schedules[0];
+      expect(row.sellableSeats).toBe(4);
+      expect(row.soldSeats).toBe(2);
+      expect(row.loadFactorPercent).toBe(50);
+      expect(row.estimatedLossMinor).toBe(50_000);
+      expect(row.adjustedLossMinor).toBe(25_000);
+    });
+
+    it('adjusts to zero on a train that sold nothing', () => {
+      const input = makeInput({});
+      const report = assembleReport(input, selectCountedBlocks(input), makeOptions());
+
+      expect(report.schedules[0].loadFactorPercent).toBe(0);
+      expect(report.schedules[0].estimatedLossMinor).toBe(50_000);
+      expect(report.schedules[0].adjustedLossMinor).toBe(0);
+    });
+  });
+
+  describe('multi-currency grouping', () => {
+    it('groups totals per currency and never sums across them', () => {
+      const schedules = [schedule(), schedule({ id: 'sched-2' })];
+      const seats = [
+        seat({ id: 'seat-1', coachId: 'coach-1', seatNumber: '1' }),
+        seat({ id: 'seat-2', coachId: 'coach-2', seatNumber: '1' }),
+      ];
+      const coaches = [coach(), coach({ id: 'coach-2', number: 'C2' })];
+      const blocks = [
+        block({ id: 'b1', seatId: 'seat-1', scheduleId: 'sched-1' }),
+        block({ id: 'b2', seatId: 'seat-2', scheduleId: 'sched-2' }),
+      ];
+      const input = makeInput({
+        schedules,
+        seats,
+        coaches,
+        blocks,
+        assignments: { 'sched-1': ['coach-1'], 'sched-2': ['coach-2'] },
+      });
+
+      const report = assembleReport(
+        input,
+        selectCountedBlocks(input),
+        makeOptions({
+          faresBySchedule: new Map([
+            ['sched-1', new Map([[ECONOMY_LOCAL.id, fare({ currency: 'ETB' })]])],
+            [
+              'sched-2',
+              new Map([
+                [ECONOMY_LOCAL.id, fare({ currency: 'DJF', exchangeRate: 2, farePerPassengerMinor: 50_000 })],
+              ]),
+            ],
+          ]),
+        }),
+      );
+
+      expect(report.summary.lossByCurrency).toEqual(
+        expect.arrayContaining([
+          { currency: 'ETB', estimatedLossMinor: 50_000, adjustedLossMinor: 0 },
+          { currency: 'DJF', estimatedLossMinor: 100_000, adjustedLossMinor: 0 },
+        ]),
+      );
+      expect(report.summary.lossByCurrency).toHaveLength(2);
+    });
+
+    it('keeps reason-category and blocker breakdowns split by currency', () => {
+      const input = makeInput({
+        schedules: [schedule(), schedule({ id: 'sched-2' })],
+        seats: [
+          seat({ id: 'seat-1', coachId: 'coach-1', seatNumber: '1' }),
+          seat({ id: 'seat-2', coachId: 'coach-2', seatNumber: '1' }),
+        ],
+        coaches: [coach(), coach({ id: 'coach-2', number: 'C2' })],
+        blocks: [
+          block({ id: 'b1', seatId: 'seat-1', scheduleId: 'sched-1' }),
+          block({ id: 'b2', seatId: 'seat-2', scheduleId: 'sched-2' }),
+        ],
+        assignments: { 'sched-1': ['coach-1'], 'sched-2': ['coach-2'] },
+      });
+
+      const report = assembleReport(
+        input,
+        selectCountedBlocks(input),
+        makeOptions({
+          faresBySchedule: new Map([
+            ['sched-1', new Map([[ECONOMY_LOCAL.id, fare({ currency: 'ETB' })]])],
+            ['sched-2', new Map([[ECONOMY_LOCAL.id, fare({ currency: 'USD' })]])],
+          ]),
+        }),
+      );
+
+      // Same category, same blocker — but two currencies, so two rows each.
+      expect(report.summary.topReasonCategories).toHaveLength(2);
+      expect(report.summary.topReasonCategories.map((r) => r.currency).sort()).toEqual(['ETB', 'USD']);
+      expect(report.summary.topBlockers).toHaveLength(2);
+    });
+  });
+
+  describe('legacy rows', () => {
+    it('reports an uncategorized legacy block under UNCATEGORIZED with an Unknown blocker', () => {
+      const input = makeInput({
+        blocks: [block({ reasonCategory: null, blockedByName: null, blockedBy: 'legacy-id' })],
+      });
+      const report = assembleReport(input, selectCountedBlocks(input), makeOptions());
+
+      expect(report.schedules[0].blocks[0].reasonCategory).toBeNull();
+      expect(report.summary.topReasonCategories[0].reasonCategory).toBe('UNCATEGORIZED');
+      expect(report.summary.topBlockers[0].blockedByName).toBe('Unknown');
+    });
+
+    it('names a SYSTEM blocker "System"', () => {
+      const input = makeInput({
+        blocks: [block({ blockedBy: 'SYSTEM', blockedByName: null })],
+      });
+      const report = assembleReport(input, selectCountedBlocks(input), makeOptions());
+
+      expect(report.summary.topBlockers[0].blockedByName).toBe('System');
+    });
+  });
+
+  describe('zero-blocks schedule', () => {
+    it('returns an empty report when nothing is blocked', () => {
+      const input = makeInput({ blocks: [] });
+      const report = assembleReport(input, selectCountedBlocks(input), makeOptions());
+
+      expect(report.schedules).toHaveLength(0);
+      expect(report.summary.schedulesAffected).toBe(0);
+      expect(report.summary.blockedSeatCount).toBe(0);
+      expect(report.summary.lossByCurrency).toEqual([]);
+      expect(report.meta.total).toBe(0);
+      // The methodology and exclusions still travel with the (empty) answer.
+      expect(report.meta.exclusions.length).toBeGreaterThan(0);
+      expect(report.meta.methodology).toContain('counterfactual');
+    });
+
+    it('omits unaffected schedules from a report that has other affected ones', () => {
+      const input = makeInput({
+        schedules: [schedule(), schedule({ id: 'sched-empty' })],
+        assignments: { 'sched-1': ['coach-1'], 'sched-empty': ['coach-1'] },
+        blocks: [block({ scheduleId: 'sched-1' })],
+      });
+      const report = assembleReport(input, selectCountedBlocks(input), makeOptions());
+
+      expect(report.schedules.map((s) => s.scheduleId)).toEqual(['sched-1']);
+      expect(report.meta.total).toBe(1);
+    });
+  });
+
+  describe('meta and drill-down detail', () => {
+    it('states the nationality assumption it priced at', () => {
+      const input = makeInput({});
+      const report = assembleReport(
+        input,
+        selectCountedBlocks(input),
+        makeOptions({ nationalityAssumption: 'German', nationalityType: 'INTERNATIONAL' }),
+      );
+
+      expect(report.meta.nationalityAssumption).toBe('German');
+      expect(report.meta.methodology).toContain('German');
+      expect(report.meta.methodology).toContain('INTERNATIONAL');
+    });
+
+    it('reports days blocked against now while a block is still open', () => {
+      const input = makeInput({
+        blocks: [block({ blockedAt: new Date('2026-07-10T00:00:00.000Z'), unblockAt: null })],
+      });
+      const report = assembleReport(input, selectCountedBlocks(input), makeOptions());
+
+      const detail = report.schedules[0].blocks[0];
+      expect(detail.stillBlocked).toBe(true);
+      expect(detail.daysBlocked).toBe(10); // 10 Jul → 20 Jul (NOW)
+    });
+
+    it('reports days blocked against unblockAt once a block has ended', () => {
+      const input = makeInput({
+        blocks: [
+          block({
+            blockedAt: new Date('2026-07-10T00:00:00.000Z'),
+            unblockAt: new Date('2026-07-16T00:00:00.000Z'),
+          }),
+        ],
+      });
+      const report = assembleReport(input, selectCountedBlocks(input), makeOptions());
+
+      const detail = report.schedules[0].blocks[0];
+      expect(detail.stillBlocked).toBe(false);
+      expect(detail.daysBlocked).toBe(6);
+    });
+
+    it('paginates schedules and reports the unpaginated total', () => {
+      const schedules = [1, 2, 3].map((n) => schedule({ id: `sched-${n}` }));
+      const seats = [1, 2, 3].map((n) => seat({ id: `seat-${n}`, seatNumber: String(n) }));
+      const blocks = [1, 2, 3].map((n) =>
+        block({ id: `b-${n}`, seatId: `seat-${n}`, scheduleId: `sched-${n}` }),
+      );
+      const input = makeInput({
+        schedules,
+        seats,
+        blocks,
+        assignments: { 'sched-1': ['coach-1'], 'sched-2': ['coach-1'], 'sched-3': ['coach-1'] },
+      });
+
+      const report = assembleReport(
+        input,
+        selectCountedBlocks(input),
+        makeOptions({
+          page: 2,
+          pageSize: 2,
+          faresBySchedule: new Map(
+            schedules.map((s) => [s.id, new Map([[ECONOMY_LOCAL.id, fare()]])]),
+          ),
+        }),
+      );
+
+      expect(report.meta.total).toBe(3);
+      expect(report.schedules).toHaveLength(1);
+      expect(report.summary.blockedSeatCount).toBe(3); // summary covers all, not the page
+    });
+  });
+});
diff --git a/apps/edr-passenger-api/src/modules/reports/blocked-seats-loss.calculator.ts b/apps/edr-passenger-api/src/modules/reports/blocked-seats-loss.calculator.ts
new file mode 100644
index 000000000..6ce581067
--- /dev/null
+++ b/apps/edr-passenger-api/src/modules/reports/blocked-seats-loss.calculator.ts
@@ -0,0 +1,563 @@
+/**
+ * Blocked Seat Revenue Loss — the counting rule and the money.
+ *
+ * Deliberately free of Prisma and Nest: `ReportsService` does the fetching, this module
+ * decides which blocks count against which schedule and what each one cost. That split is
+ * what makes the rule testable — every exclusion below has a unit test in
+ * `blocked-seats-loss.calculator.spec.ts`.
+ *
+ * All amounts are integer minor units, always carried with their currency.
+ */
+
+import {
+  BlockedSeatBlockType,
+  BlockedSeatLossByBlocker,
+  BlockedSeatLossByCurrency,
+  BlockedSeatLossByReasonCategory,
+  BlockedSeatLossDetail,
+  BlockedSeatLossSchedule,
+  BlockedSeatRevenueLossReport,
+  SeatBlockReasonCategory,
+  UNCATEGORIZED_REASON_CATEGORY,
+} from '@edr/types';
+
+// ── Inputs ───────────────────────────────────────────────────────────────────
+
+export interface LossSeatClass {
+  id: string;
+  name: string;
+  bedPosition: string | null;
+  nationalityType: string | null;
+}
+
+export interface LossCoach {
+  id: string;
+  number: string;
+  /** CoachType.type — 'passenger' | 'sleeper' | 'dining' | 'baggage'. */
+  coachTypeType: string;
+  coachTypeName: string;
+  seatClasses: LossSeatClass[];
+}
+
+export interface LossSeat {
+  id: string;
+  coachId: string;
+  seatNumber: string;
+  bedPosition: string | null;
+  premiumFeeMinor: number;
+}
+
+export interface LossSchedule {
+  id: string;
+  trainNumber: string;
+  routeName: string | null;
+  originStation: string;
+  destinationStation: string;
+  departureAt: Date;
+  status: string;
+}
+
+export interface LossBlock {
+  id: string;
+  seatId: string;
+  /** Null for a global block — one that applies wherever the seat's coach runs. */
+  scheduleId: string | null;
+  reason: string;
+  reasonCategory: SeatBlockReasonCategory | null;
+  blockedBy: string;
+  blockedByName: string | null;
+  approvedBy: string | null;
+  blockedAt: Date;
+  unblockAt: Date | null;
+}
+
+/** One fare quote from the fare engine, per seat class, per schedule. */
+export interface LossFare {
+  seatClassId: string;
+  seatClassName: string;
+  /** Base + class premium + insurance, in ETB minor units. */
+  farePerPassengerMinor: number;
+  /** ETB → billing currency. 1 when billing in ETB. */
+  exchangeRate: number;
+  currency: string;
+}
+
+export interface LossCalculatorInput {
+  schedules: LossSchedule[];
+  /** Every seat on every coach involved, keyed by seat id. */
+  seatsById: Map<string, LossSeat>;
+  /** Every coach involved, keyed by coach id. */
+  coachesById: Map<string, LossCoach>;
+  /** Coach ids assigned to each schedule, keyed by schedule id. */
+  coachIdsBySchedule: Map<string, Set<string>>;
+  /** `${scheduleId}|${seatId}` for every seat with a CONFIRMED/BOARDED booking. */
+  soldSeatKeys: Set<string>;
+  /** Candidate blocks — schedule-scoped for these schedules, plus overlapping global ones. */
+  blocks: LossBlock[];
+}
+
+/** A block that survived every gate, bound to the schedule it cost revenue on. */
+export interface CountedBlock {
+  block: LossBlock;
+  seat: LossSeat;
+  coach: LossCoach;
+  blockType: BlockedSeatBlockType;
+}
+
+// ── Exclusions, stated once so the API can echo them verbatim ────────────────
+
+export const BLOCKED_SEAT_LOSS_EXCLUSIONS: readonly string[] = [
+  'Dining-coach seats — never sold as passenger seats, so blocking one costs no fare revenue.',
+  'Placeholder seats (seat number starting with "-") — layout spacers, not real seats.',
+  'CANCELLED schedules — the train did not run, so no fare was lost to the block.',
+  'Seats that were nonetheless sold on that schedule (a CONFIRMED or BOARDED booking exists) — blocked after sale, so no revenue was lost.',
+  'System blocks created by ticket issuance ("Booked in tickets …") — bookkeeping for seats that were sold, not withheld inventory.',
+  'A seat blocked more than once for the same schedule is counted once, at its most recent block.',
+];
+
+/** Prefix ticket issuance writes into `SeatBlock.reason` for already-sold seats. */
+export const TICKETING_BLOCK_REASON_PREFIX = 'Booked in tickets';
+
+const MS_PER_DAY = 24 * 60 * 60 * 1000;
+
+// ── Step 1: which blocks count against which schedule ────────────────────────
+
+/**
+ * Applies the counting rule.
+ *
+ * A blocked seat counts against a schedule when either:
+ *   - a `SeatBlock` row targets that `scheduleId` directly, or
+ *   - a global block (no `scheduleId`) was in effect at departure — `blockedAt <=
+ *     departureAt` and (`unblockAt IS NULL` or `unblockAt >= departureAt`) — **and** the
+ *     seat's coach was actually assigned to that schedule.
+ *
+ * …minus every exclusion in {@link BLOCKED_SEAT_LOSS_EXCLUSIONS}.
+ *
+ * Returns counted blocks keyed by schedule id. Schedules with no counted block are absent.
+ */
+export function selectCountedBlocks(
+  input: LossCalculatorInput,
+): Map<string, CountedBlock[]> {
+  const { schedules, seatsById, coachesById, coachIdsBySchedule, soldSeatKeys, blocks } = input;
+
+  // Per schedule, at most one counted block per seat. A schedule-scoped block beats a
+  // global one (it is the more specific statement); between two of the same kind, the
+  // most recently created wins.
+  const bySchedule = new Map<string, Map<string, CountedBlock>>();
+
+  for (const schedule of schedules) {
+    if (schedule.status === 'CANCELLED') continue;
+    const assignedCoachIds = coachIdsBySchedule.get(schedule.id) ?? new Set<string>();
+
+    for (const block of blocks) {
+      if (block.reason.startsWith(TICKETING_BLOCK_REASON_PREFIX)) continue;
+
+      const seat = seatsById.get(block.seatId);
+      if (!seat) continue;
+      if (isPlaceholderSeat(seat)) continue;
+
+      const coach = coachesById.get(seat.coachId);
+      if (!coach || isDiningCoach(coach)) continue;
+
+      let blockType: BlockedSeatBlockType;
+      if (block.scheduleId !== null) {
+        if (block.scheduleId !== schedule.id) continue;
+        blockType = 'SCHEDULE';
+      } else {
+        if (!assignedCoachIds.has(seat.coachId)) continue;
+        if (!isGlobalBlockInEffectAt(block, schedule.departureAt)) continue;
+        blockType = 'GLOBAL';
+      }
+
+      // Blocked but sold anyway ⇒ the fare was collected, nothing was lost.
+      if (soldSeatKeys.has(soldKey(schedule.id, seat.id))) continue;
+
+      const candidate: CountedBlock = { block, seat, coach, blockType };
+      const seatMap = bySchedule.get(schedule.id) ?? new Map<string, CountedBlock>();
+      const existing = seatMap.get(seat.id);
+      if (!existing || supersedes(candidate, existing)) seatMap.set(seat.id, candidate);
+      bySchedule.set(schedule.id, seatMap);
+    }
+  }
+
+  const result = new Map<string, CountedBlock[]>();
+  for (const [scheduleId, seatMap] of bySchedule) {
+    if (seatMap.size === 0) continue;
+    result.set(scheduleId, [...seatMap.values()]);
+  }
+  return result;
+}
+
+function supersedes(candidate: CountedBlock, existing: CountedBlock): boolean {
+  if (candidate.blockType !== existing.blockType) return candidate.blockType === 'SCHEDULE';
+  return candidate.block.blockedAt.getTime() > existing.block.blockedAt.getTime();
+}
+
+function isGlobalBlockInEffectAt(block: LossBlock, departureAt: Date): boolean {
+  if (block.blockedAt.getTime() > departureAt.getTime()) return false;
+  if (block.unblockAt === null) return true;
+  return block.unblockAt.getTime() >= departureAt.getTime();
+}
+
+export function isPlaceholderSeat(seat: Pick<LossSeat, 'seatNumber'>): boolean {
+  return !seat.seatNumber || seat.seatNumber.startsWith('-');
+}
+
+/**
+ * `CoachType.type` is documented as a slug ('passenger' | 'sleeper' | 'dining' | 'baggage'),
+ * but real EDR data stores display names there instead — e.g. `'Dining Coach '`, trailing
+ * space included. An exact `=== 'dining'` match therefore lets dining seats through and
+ * inflates the blocked-seat count. Match on a substring of type *or* name so both the
+ * documented convention and the data as it actually exists are covered.
+ */
+export function isDiningCoach(
+  coach: Pick<LossCoach, 'coachTypeType' | 'coachTypeName'>,
+): boolean {
+  const haystack = `${coach.coachTypeType ?? ''} ${coach.coachTypeName ?? ''}`.toLowerCase();
+  return haystack.includes('dining');
+}
+
+export function soldKey(scheduleId: string, seatId: string): string {
+  return `${scheduleId}|${seatId}`;
+}
+
+// ── Step 2: seats that could have been sold ──────────────────────────────────
+
+/**
+ * Sellable seats on a schedule: every seat on every assigned coach, minus dining coaches
+ * and placeholder rows. This is the denominator of the load factor, and it deliberately
+ * ignores the `coachId` filter so the percentage stays comparable across filtered views.
+ */
+export function countSellableSeats(
+  scheduleId: string,
+  input: Pick<LossCalculatorInput, 'coachIdsBySchedule' | 'coachesById' | 'seatsById'>,
+): number {
+  const coachIds = input.coachIdsBySchedule.get(scheduleId);
+  if (!coachIds || coachIds.size === 0) return 0;
+
+  let total = 0;
+  for (const seat of input.seatsById.values()) {
+    if (!coachIds.has(seat.coachId)) continue;
+    if (isPlaceholderSeat(seat)) continue;
+    const coach = input.coachesById.get(seat.coachId);
+    if (!coach || isDiningCoach(coach)) continue;
+    total++;
+  }
+  return total;
+}
+
+// ── Step 3: the money ────────────────────────────────────────────────────────
+
+/**
+ * Picks the seat class a seat is priced under.
+ *
+ * Bed position selects the tier in a sleeper coach; `nationalityType` then picks the
+ * LOCAL or INTERNATIONAL variant of that tier, matching how the fare engine resolves it.
+ */
+export function resolveSeatClass(
+  seat: LossSeat,
+  coach: LossCoach,
+  nationalityType: string,
+): LossSeatClass | null {
+  const classes = coach.seatClasses;
+  if (classes.length === 0) return null;
+
+  const bed = seat.bedPosition?.toLowerCase();
+  const byBed = bed
+    ? classes.filter((sc) => sc.bedPosition?.toLowerCase() === bed)
+    : classes.filter((sc) => !sc.bedPosition);
+  const pool = byBed.length > 0 ? byBed : classes;
+
+  return pool.find((sc) => sc.nationalityType === nationalityType) ?? pool[0] ?? null;
+}
+
+/**
+ * What one blocked seat would have sold for:
+ *
+ *     base fare + class premium + insurance   (the fare engine's per-passenger fare)
+ *   + the seat's own premium                  (window/berth surcharge)
+ *
+ * converted into the billing currency implied by the nationality assumption.
+ *
+ * Returns `null` when no fare could be quoted for the seat's class — the seat still
+ * counts as blocked, it just carries no monetary claim.
+ */
+export function estimateSeatLoss(
+  seat: LossSeat,
+  fare: LossFare | null,
+): { estimatedLossMinor: number; currency: string } | null {
+  if (!fare) return null;
+  const etbMinor = fare.farePerPassengerMinor + (seat.premiumFeeMinor ?? 0);
+  return {
+    estimatedLossMinor: Math.round(etbMinor * fare.exchangeRate),
+    currency: fare.currency,
+  };
+}
+
+// ── Step 4: assemble ─────────────────────────────────────────────────────────
+
+export interface AssembleOptions {
+  /** Seat-class fares per schedule, keyed by schedule id then seat class id. */
+  faresBySchedule: Map<string, Map<string, LossFare>>;
+  /** Schedule ids whose fare calculation failed outright. */
+  schedulesWithoutFare: Set<string>;
+  /** 'LOCAL' or 'INTERNATIONAL' — how seat classes were resolved. */
+  nationalityType: string;
+  /** The nationality string the fares were priced at, for `meta`. */
+  nationalityAssumption: string;
+  /** Reference time for "days blocked" on still-blocked seats. Injected for determinism. */
+  now: Date;
+  dateFrom: Date;
+  dateTo: Date;
+  page: number;
+  pageSize: number;
+  sortBy: string;
+}
+
+/**
+ * Turns counted blocks + fares into the wire response.
+ *
+ * Schedules with no counted block are omitted: they carry no loss and no drill-down, and
+ * `meta.total` counts the schedules actually paginated so the two never disagree.
+ */
+export function assembleReport(
+  input: LossCalculatorInput,
+  countedBySchedule: Map<string, CountedBlock[]>,
+  options: AssembleOptions,
+): BlockedSeatRevenueLossReport {
+  const soldCountBySchedule = countSoldSeatsPerSchedule(input.soldSeatKeys);
+
+  const scheduleRows: BlockedSeatLossSchedule[] = [];
+
+  for (const schedule of input.schedules) {
+    const counted = countedBySchedule.get(schedule.id);
+    if (!counted || counted.length === 0) continue;
+
+    const fares = options.faresBySchedule.get(schedule.id) ?? new Map<string, LossFare>();
+    const sellableSeats = countSellableSeats(schedule.id, input);
+    const soldSeats = soldCountBySchedule.get(schedule.id) ?? 0;
+    const loadFactor = sellableSeats > 0 ? Math.min(1, soldSeats / sellableSeats) : 0;
+
+    const blocks: BlockedSeatLossDetail[] = counted
+      .map((c) => toDetail(c, fares, options))
+      .sort(byCoachThenSeat);
+
+    // One schedule prices in exactly one currency (the nationality assumption fixes it),
+    // so a plain sum here never crosses currencies.
+    const estimatedLossMinor = blocks.reduce((sum, b) => sum + b.estimatedLossMinor, 0);
+    const currency = blocks.find((b) => b.currency)?.currency ?? 'ETB';
+    const blockedByNames = [...new Set(blocks.map(blockerDisplayName))];
+
+    scheduleRows.push({
+      scheduleId: schedule.id,
+      trainNumber: schedule.trainNumber,
+      routeName: schedule.routeName,
+      originStation: schedule.originStation,
+      destinationStation: schedule.destinationStation,
+      departureAt: schedule.departureAt.toISOString(),
+      status: schedule.status,
+      sellableSeats,
+      soldSeats,
+      loadFactorPercent: +(loadFactor * 100).toFixed(1),
+      blockedSeatCount: blocks.length,
+      blockedByNames,
+      estimatedLossMinor,
+      adjustedLossMinor: Math.round(estimatedLossMinor * loadFactor),
+      currency,
+      blocks,
+    });
+  }
+
+  sortSchedules(scheduleRows, options.sortBy);
+
+  const summary = {
+    schedulesAffected: scheduleRows.length,
+    blockedSeatCount: scheduleRows.reduce((sum, s) => sum + s.blockedSeatCount, 0),
+    lossByCurrency: groupLossByCurrency(scheduleRows),
+    topReasonCategories: groupByReasonCategory(scheduleRows),
+    topBlockers: groupByBlocker(scheduleRows),
+  };
+
+  const page = Math.max(1, options.page);
+  const pageSize = Math.max(1, options.pageSize);
+  const paged = scheduleRows.slice((page - 1) * pageSize, page * pageSize);
+
+  return {
+    summary,
+    schedules: paged,
+    meta: {
+      total: scheduleRows.length,
+      page,
+      pageSize,
+      dateFrom: options.dateFrom.toISOString(),
+      dateTo: options.dateTo.toISOString(),
+      nationalityAssumption: options.nationalityAssumption,
+      methodology: buildMethodology(options),
+      exclusions: [...BLOCKED_SEAT_LOSS_EXCLUSIONS],
+      schedulesWithoutFare: options.schedulesWithoutFare.size,
+    },
+  };
+}
+
+function toDetail(
+  counted: CountedBlock,
+  fares: Map<string, LossFare>,
+  options: AssembleOptions,
+): BlockedSeatLossDetail {
+  const { block, seat, coach, blockType } = counted;
+  const seatClass = resolveSeatClass(seat, coach, options.nationalityType);
+  const fare = lookupFare(seatClass, coach, fares);
+  const loss = estimateSeatLoss(seat, fare);
+  const endedAt = block.unblockAt ?? options.now;
+
+  return {
+    blockId: block.id,
+    seatId: seat.id,
+    coachNumber: coach.number,
+    seatNumber: seat.seatNumber,
+    seatClassName: seatClass?.name ?? coach.coachTypeName ?? null,
+    reason: block.reason,
+    reasonCategory: block.reasonCategory,
+    blockType,
+    blockedBy: block.blockedBy,
+    blockedByName: block.blockedByName,
+    approvedBy: block.approvedBy,
+    blockedAt: block.blockedAt.toISOString(),
+    unblockAt: block.unblockAt ? block.unblockAt.toISOString() : null,
+    stillBlocked: block.unblockAt === null,
+    daysBlocked: Math.max(
+      0,
+      Math.floor((endedAt.getTime() - block.blockedAt.getTime()) / MS_PER_DAY),
+    ),
+    estimatedLossMinor: loss?.estimatedLossMinor ?? 0,
+    currency: loss?.currency ?? 'ETB',
+  };
+}
+
+/**
+ * The fare engine keys its quotes by the *nationality-resolved* seat class, which may not
+ * be the class the seat nominally belongs to. Try the exact class, then any sibling class
+ * on the same coach type that was quoted.
+ */
+function lookupFare(
+  seatClass: LossSeatClass | null,
+  coach: LossCoach,
+  fares: Map<string, LossFare>,
+): LossFare | null {
+  if (fares.size === 0) return null;
+  if (seatClass) {
+    const exact = fares.get(seatClass.id);
+    if (exact) return exact;
+    const sibling = coach.seatClasses.find(
+      (sc) => sc.bedPosition === seatClass.bedPosition && fares.has(sc.id),
+    );
+    if (sibling) return fares.get(sibling.id) ?? null;
+  }
+  const anyOnCoach = coach.seatClasses.find((sc) => fares.has(sc.id));
+  return anyOnCoach ? (fares.get(anyOnCoach.id) ?? null) : null;
+}
+
+function countSoldSeatsPerSchedule(soldSeatKeys: Set<string>): Map<string, number> {
+  const counts = new Map<string, number>();
+  for (const key of soldSeatKeys) {
+    const scheduleId = key.slice(0, key.indexOf('|'));
+    counts.set(scheduleId, (counts.get(scheduleId) ?? 0) + 1);
+  }
+  return counts;
+}
+
+function byCoachThenSeat(a: BlockedSeatLossDetail, b: BlockedSeatLossDetail): number {
+  const coach = (a.coachNumber ?? '').localeCompare(b.coachNumber ?? '', undefined, {
+    numeric: true,
+  });
+  if (coach !== 0) return coach;
+  return (a.seatNumber ?? '').localeCompare(b.seatNumber ?? '', undefined, { numeric: true });
+}
+
+function sortSchedules(rows: BlockedSeatLossSchedule[], sortBy: string): void {
+  switch (sortBy) {
+    case 'lossMinorAsc':
+      rows.sort((a, b) => a.estimatedLossMinor - b.estimatedLossMinor);
+      break;
+    case 'blockedSeatCount':
+      rows.sort((a, b) => b.blockedSeatCount - a.blockedSeatCount);
+      break;
+    case 'departureAt':
+      rows.sort((a, b) => a.departureAt.localeCompare(b.departureAt));
+      break;
+    default:
+      rows.sort((a, b) => b.estimatedLossMinor - a.estimatedLossMinor);
+  }
+}
+
+function groupLossByCurrency(rows: BlockedSeatLossSchedule[]): BlockedSeatLossByCurrency[] {
+  const byCurrency = new Map<string, BlockedSeatLossByCurrency>();
+  for (const row of rows) {
+    const entry = byCurrency.get(row.currency) ?? {
+      currency: row.currency,
+      estimatedLossMinor: 0,
+      adjustedLossMinor: 0,
+    };
+    entry.estimatedLossMinor += row.estimatedLossMinor;
+    entry.adjustedLossMinor += row.adjustedLossMinor;
+    byCurrency.set(row.currency, entry);
+  }
+  return [...byCurrency.values()].sort((a, b) => b.estimatedLossMinor - a.estimatedLossMinor);
+}
+
+function groupByReasonCategory(
+  rows: BlockedSeatLossSchedule[],
+): BlockedSeatLossByReasonCategory[] {
+  const groups = new Map<string, BlockedSeatLossByReasonCategory>();
+  for (const row of rows) {
+    for (const block of row.blocks) {
+      const category = block.reasonCategory ?? UNCATEGORIZED_REASON_CATEGORY;
+      const key = `${category}|${block.currency}`;
+      const entry = groups.get(key) ?? {
+        reasonCategory: category,
+        count: 0,
+        estimatedLossMinor: 0,
+        currency: block.currency,
+      };
+      entry.count++;
+      entry.estimatedLossMinor += block.estimatedLossMinor;
+      groups.set(key, entry);
+    }
+  }
+  return [...groups.values()].sort((a, b) => b.estimatedLossMinor - a.estimatedLossMinor);
+}
+
+/** Legacy rows carry no name; 'SYSTEM' blocks are not a person. */
+function blockerDisplayName(block: Pick<BlockedSeatLossDetail, 'blockedBy' | 'blockedByName'>): string {
+  return block.blockedByName ?? (block.blockedBy === 'SYSTEM' ? 'System' : 'Unknown');
+}
+
+function groupByBlocker(rows: BlockedSeatLossSchedule[]): BlockedSeatLossByBlocker[] {
+  const groups = new Map<string, BlockedSeatLossByBlocker>();
+  for (const row of rows) {
+    for (const block of row.blocks) {
+      const key = `${block.blockedBy}|${block.currency}`;
+      const entry = groups.get(key) ?? {
+        blockedBy: block.blockedBy,
+        blockedByName: blockerDisplayName(block),
+        count: 0,
+        estimatedLossMinor: 0,
+        currency: block.currency,
+      };
+      entry.count++;
+      entry.estimatedLossMinor += block.estimatedLossMinor;
+      groups.set(key, entry);
+    }
+  }
+  return [...groups.values()].sort((a, b) => b.estimatedLossMinor - a.estimatedLossMinor);
+}
+
+function buildMethodology(options: AssembleOptions): string {
+  return [
+    'Estimated loss is a counterfactual: it is the fare each blocked seat would have sold for, not money that left the business.',
+    'Per blocked seat: estimatedLoss = base fare (distance × seat-class per-km tariff × insurance factor) + seat-class premium + insurance fee + the seat\'s own premium fee, priced for the schedule\'s full origin→destination journey.',
+    `Fares are priced at nationality "${options.nationalityAssumption}" (${options.nationalityType} tariff), which also fixes the billing currency. Totals are grouped per currency and never summed across them.`,
+    'estimatedLossAtFullOccupancy assumes every blocked seat would have sold. adjustedLoss = estimatedLoss × load factor (sold ÷ sellable seats on that schedule), because a blocked seat on a half-empty train did not really cost a full fare. The true figure sits between the two.',
+    'A blocked seat counts against a schedule when a SeatBlock names that schedule directly, or when a global block was in effect at departure and the seat\'s coach was assigned to that schedule.',
+  ].join(' ');
+}
diff --git a/apps/edr-passenger-api/src/modules/reports/reports.controller.ts b/apps/edr-passenger-api/src/modules/reports/reports.controller.ts
index 52b84da66..1eea923fd 100644
--- a/apps/edr-passenger-api/src/modules/reports/reports.controller.ts
+++ b/apps/edr-passenger-api/src/modules/reports/reports.controller.ts
@@ -1,7 +1,14 @@
-import { Body, Controller, Get, Param, Post, Query } from "@nestjs/common";
-import { ApiTags, ApiOperation, ApiBearerAuth } from "@nestjs/swagger";
+import { Body, Controller, Get, Param, Post, Query, Res } from "@nestjs/common";
+import type { Response } from "express";
+import {
+  ApiTags,
+  ApiOperation,
+  ApiBearerAuth,
+  ApiOkResponse,
+  ApiProduces,
+} from "@nestjs/swagger";
 import { ReportsService } from "./reports.service";
-import { GenerateReportDto } from "./reports.dto";
+import { BlockedSeatsRevenueLossQueryDto, GenerateReportDto } from "./reports.dto";
 import { PassengerStaff } from "../../common/passenger-guards";
 import { PASSENGER_PERMS } from "../../seed/passenger-permissions.registry";
 
@@ -76,6 +83,54 @@ export class ReportsController {
     return this.service.getPaymentDiscrepancyBySchedule(scheduleId, { search, seatClass, sort });
   }
 
+  // ── Blocked Seat Revenue Loss ──────────────────────────────────────────────
+
+  @Get("blocked-seats-revenue-loss")
+  @ApiOperation({
+    summary: "Potential revenue lost to blocked seats, per schedule",
+    description:
+      "For every train schedule in the window, the fare revenue that could never be earned because seats were " +
+      "blocked out of sale — with per-seat drill-down showing who blocked each seat and why.\n\n" +
+      "**A blocked seat counts against a schedule when** a `SeatBlock` row names that `scheduleId` directly, " +
+      "**or** a global block (no `scheduleId`) was in effect at departure — `blockedAt <= departureAt` and " +
+      "(`unblockAt IS NULL` or `unblockAt >= departureAt`) — and the seat's coach was assigned to that schedule " +
+      "via `CoachAssignment`.\n\n" +
+      "**Excluded** (echoed in `meta.exclusions`): dining-coach seats, placeholder seats, CANCELLED schedules, " +
+      "seats that were sold anyway, and ticketing's own bookkeeping blocks.\n\n" +
+      "**This is a counterfactual.** `estimatedLossMinor` assumes every blocked seat would have sold; " +
+      "`adjustedLossMinor` scales it by the schedule's load factor. The real figure sits between the two — " +
+      "`meta.methodology` states the formula and the nationality assumption in full.\n\n" +
+      "All amounts are integer minor units, grouped per currency and never summed across currencies.",
+  })
+  @ApiOkResponse({ description: "Blocked-seat revenue loss report" })
+  getBlockedSeatsRevenueLoss(@Query() query: BlockedSeatsRevenueLossQueryDto) {
+    return this.service.getBlockedSeatsRevenueLoss(query);
+  }
+
+  @Get("blocked-seats-revenue-loss/export")
+  @ApiOperation({
+    summary: "Blocked-seat revenue loss as CSV",
+    description:
+      "Same filters as the JSON report, flattened to one row per blocked seat. Not paginated — the whole " +
+      "filtered result is returned.",
+  })
+  @ApiProduces("text/csv")
+  @ApiOkResponse({ description: "CSV export", schema: { type: "string" } })
+  // `@Res()` without passthrough so the global ResponseTransformInterceptor does not wrap
+  // the CSV in a `{ success, data }` envelope — same approach as the attachment stream.
+  async exportBlockedSeatsRevenueLoss(
+    @Query() query: BlockedSeatsRevenueLossQueryDto,
+    @Res() res: Response,
+  ): Promise<void> {
+    const csv = await this.service.exportBlockedSeatsRevenueLossCsv(query);
+    res.setHeader("Content-Type", "text/csv; charset=utf-8");
+    res.setHeader(
+      "Content-Disposition",
+      `attachment; filename="blocked-seats-revenue-loss-${new Date().toISOString().split("T")[0]}.csv"`,
+    );
+    res.send(csv);
+  }
+
   @Get(":reportId")
   @ApiOperation({ summary: "Get report by ID" })
   getReport(@Param("reportId") reportId: string) {
diff --git a/apps/edr-passenger-api/src/modules/reports/reports.dto.ts b/apps/edr-passenger-api/src/modules/reports/reports.dto.ts
index 5fdb856ec..8b8049807 100644
--- a/apps/edr-passenger-api/src/modules/reports/reports.dto.ts
+++ b/apps/edr-passenger-api/src/modules/reports/reports.dto.ts
@@ -1,5 +1,7 @@
-import { IsString, IsDateString, IsOptional, IsEnum } from 'class-validator';
+import { IsString, IsDateString, IsOptional, IsEnum, IsInt, Min, Max } from 'class-validator';
+import { Type } from 'class-transformer';
 import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+import { SeatBlockReasonCategory } from '../seats/seats.dto';
 
 export enum ReportType {
   REVENUE = 'REVENUE',
@@ -27,3 +29,77 @@ export class ExportReportDto {
   @ApiProperty() @IsString() reportId: string;
   @ApiProperty({ enum: ExportFormat }) @IsEnum(ExportFormat) format: ExportFormat;
 }
+
+// ── Blocked Seat Revenue Loss ────────────────────────────────────────────────
+
+export enum BlockedSeatsLossSortBy {
+  /** Largest estimated loss first (default). */
+  LOSS_DESC = 'lossMinor',
+  /** Smallest estimated loss first. */
+  LOSS_ASC = 'lossMinorAsc',
+  /** Most blocked seats first. */
+  BLOCKED_SEATS = 'blockedSeatCount',
+  /** Soonest departure first. */
+  DEPARTURE = 'departureAt',
+}
+
+export class BlockedSeatsRevenueLossQueryDto {
+  @ApiPropertyOptional({
+    example: '2026-07-01',
+    description: 'Start of the window, inclusive, matched on TrainSchedule.departureAt. Defaults to the earliest scheduled departure on record.',
+  })
+  @IsOptional() @IsDateString() dateFrom?: string;
+
+  @ApiPropertyOptional({
+    example: '2026-07-31',
+    description: 'End of the window, inclusive, matched on TrainSchedule.departureAt. Defaults to the latest scheduled departure on record.',
+  })
+  @IsOptional() @IsDateString() dateTo?: string;
+
+  @ApiPropertyOptional({ description: 'Restrict to a single TrainSchedule.' })
+  @IsOptional() @IsString() scheduleId?: string;
+
+  @ApiPropertyOptional({ description: 'Restrict to schedules running this route.' })
+  @IsOptional() @IsString() routeId?: string;
+
+  @ApiPropertyOptional({ description: 'Restrict to schedules operated by this train.' })
+  @IsOptional() @IsString() trainId?: string;
+
+  @ApiPropertyOptional({
+    description:
+      'Restrict to blocks on seats in this coach. Load factor still reflects the whole train, so the percentage stays comparable.',
+  })
+  @IsOptional() @IsString() coachId?: string;
+
+  @ApiPropertyOptional({
+    enum: SeatBlockReasonCategory,
+    description: 'Restrict to blocks in this reporting bucket. Legacy uncategorized blocks are excluded when set.',
+  })
+  @IsOptional() @IsEnum(SeatBlockReasonCategory) reasonCategory?: SeatBlockReasonCategory;
+
+  @ApiPropertyOptional({
+    description: "Blocker filter — matches the IAM user id exactly, or the recorded name case-insensitively.",
+  })
+  @IsOptional() @IsString() blockedBy?: string;
+
+  @ApiPropertyOptional({
+    example: 'Ethiopian',
+    default: 'Ethiopian',
+    description:
+      'Nationality the counterfactual fares are priced at. Drives both the seat-class tariff variant (LOCAL vs INTERNATIONAL) and the billing currency. Defaults to Ethiopian — the local tariff in ETB.',
+  })
+  @IsOptional() @IsString() nationality?: string;
+
+  @ApiPropertyOptional({ default: 1, minimum: 1, description: 'Page of schedules, 1-based.' })
+  @IsOptional() @Type(() => Number) @IsInt() @Min(1) page?: number;
+
+  @ApiPropertyOptional({ default: 25, minimum: 1, maximum: 200, description: 'Schedules per page.' })
+  @IsOptional() @Type(() => Number) @IsInt() @Min(1) @Max(200) pageSize?: number;
+
+  @ApiPropertyOptional({
+    enum: BlockedSeatsLossSortBy,
+    default: BlockedSeatsLossSortBy.LOSS_DESC,
+    description: 'Schedule ordering. Defaults to largest estimated loss first.',
+  })
+  @IsOptional() @IsEnum(BlockedSeatsLossSortBy) sortBy?: BlockedSeatsLossSortBy;
+}
diff --git a/apps/edr-passenger-api/src/modules/reports/reports.module.ts b/apps/edr-passenger-api/src/modules/reports/reports.module.ts
index 801120cbf..5e4de0c18 100644
--- a/apps/edr-passenger-api/src/modules/reports/reports.module.ts
+++ b/apps/edr-passenger-api/src/modules/reports/reports.module.ts
@@ -2,9 +2,12 @@ import { Module } from '@nestjs/common';
 import { HttpModule } from '@nestjs/axios';
 import { ReportsController } from './reports.controller';
 import { ReportsService } from './reports.service';
+import { FareEngineModule } from '../fare-engine/fare-engine.module';
 
 @Module({
-  imports: [HttpModule],
+  // FareEngineModule supplies the counterfactual fares the blocked-seat revenue
+  // loss report prices blocked seats against — never re-implemented here.
+  imports: [HttpModule, FareEngineModule],
   controllers: [ReportsController],
   providers: [ReportsService],
   exports: [ReportsService]
diff --git a/apps/edr-passenger-api/src/modules/reports/reports.service.ts b/apps/edr-passenger-api/src/modules/reports/reports.service.ts
index 49be0859c..8811a3855 100644
--- a/apps/edr-passenger-api/src/modules/reports/reports.service.ts
+++ b/apps/edr-passenger-api/src/modules/reports/reports.service.ts
@@ -1,8 +1,84 @@
 import { Injectable, Logger } from "@nestjs/common";
 import { InjectDataSource } from "@nestjs/typeorm";
 import { DataSource } from "typeorm";
+import {
+  BlockedSeatRevenueLossReport,
+  UNCATEGORIZED_REASON_CATEGORY,
+} from "@edr/types";
 import { PrismaService } from "../../common/prisma.service";
-import { GenerateReportDto, ReportType } from "./reports.dto";
+import { FareEngineService } from "../fare-engine/fare-engine.service";
+import {
+  BlockedSeatsLossSortBy,
+  BlockedSeatsRevenueLossQueryDto,
+  GenerateReportDto,
+  ReportType,
+} from "./reports.dto";
+import {
+  assembleReport,
+  LossCalculatorInput,
+  LossCoach,
+  LossFare,
+  LossSeat,
+  selectCountedBlocks,
+  soldKey,
+} from "./blocked-seats-loss.calculator";
+
+/** Fares are quoted at the local tariff unless the caller asks otherwise. */
+const DEFAULT_LOSS_NATIONALITY = "Ethiopian";
+const DEFAULT_LOSS_PAGE_SIZE = 25;
+/** How many schedules are priced in parallel. Keeps the DB from being flooded. */
+const FARE_QUOTE_CONCURRENCY = 4;
+/** CSV export is not paginated, but still needs an upper bound. */
+const CSV_EXPORT_MAX_SCHEDULES = 5000;
+
+const EMPTY_LOSS_INPUT: LossCalculatorInput = {
+  schedules: [],
+  seatsById: new Map(),
+  coachesById: new Map(),
+  coachIdsBySchedule: new Map(),
+  soldSeatKeys: new Set(),
+  blocks: [],
+};
+
+/** Mirrors the fare engine's own LOCAL/INTERNATIONAL split. */
+function resolveNationalityType(nationality: string): string {
+  const upper = nationality.toUpperCase();
+  return upper === "ETHIOPIAN" || upper === "DJIBOUTIAN" ? "LOCAL" : "INTERNATIONAL";
+}
+
+/**
+ * The fare engine returns two shapes: a full distance-based calculation, and a thinner
+ * FareRule fallback for schedules with no route. Both are reduced to the fields the loss
+ * calculator needs, or dropped if neither shape is present.
+ */
+function normalizeFareQuote(quote: unknown): LossFare | null {
+  if (typeof quote !== "object" || quote === null) return null;
+  const q = quote as Record<string, unknown>;
+
+  const seatClassId = q.seatClassId;
+  if (typeof seatClassId !== "string") return null;
+
+  const fareMinor =
+    typeof q.farePerPassengerMinor === "number"
+      ? q.farePerPassengerMinor
+      : typeof q.totalMinor === "number"
+        ? q.totalMinor
+        : null;
+  if (fareMinor === null) return null;
+
+  return {
+    seatClassId,
+    seatClassName: typeof q.seatClassName === "string" ? q.seatClassName : "Unknown",
+    farePerPassengerMinor: fareMinor,
+    exchangeRate: typeof q.exchangeRate === "number" ? q.exchangeRate : 1,
+    currency: typeof q.billingCurrency === "string" ? q.billingCurrency : "ETB",
+  };
+}
+
+/** RFC 4180 cell: always quoted, embedded quotes doubled. */
+function toCsvCell(value: string | number): string {
+  return `"${String(value).replace(/"/g, '""')}"`;
+}
 
 @Injectable()
 export class ReportsService {
@@ -10,6 +86,7 @@ export class ReportsService {
   constructor(
     private prisma: PrismaService,
     @InjectDataSource() private dataSource: DataSource,
+    private fareEngine: FareEngineService,
   ) {}
 
   async generateReport(dto: GenerateReportDto) {
@@ -1135,6 +1212,349 @@ export class ReportsService {
     };
   }
 
+  // ── Blocked Seat Revenue Loss ──────────────────────────────────────────────
+
+  /**
+   * Resolves the reporting window. Both bounds are inclusive and snap to whole local days,
+   * matching `generateReport`. When the caller supplies neither bound, defaults to the full
+   * history of scheduled departures on record — the earliest `TrainSchedule.departureAt` to
+   * the latest — not a rolling window, so nothing ages out of the report on its own.
+   */
+  private async resolveWindow(
+    query: Pick<BlockedSeatsRevenueLossQueryDto, "dateFrom" | "dateTo">,
+    now: Date,
+  ): Promise<{ dateFrom: Date; dateTo: Date }> {
+    let dateFrom: Date;
+    let dateTo: Date;
+
+    if (query.dateFrom && query.dateTo) {
+      dateFrom = new Date(query.dateFrom);
+      dateTo = new Date(query.dateTo);
+    } else {
+      const bounds = await this.prisma.trainSchedule.aggregate({
+        _min: { departureAt: true },
+        _max: { departureAt: true },
+      });
+      dateFrom = query.dateFrom ? new Date(query.dateFrom) : (bounds._min.departureAt ?? new Date(now));
+      dateTo = query.dateTo ? new Date(query.dateTo) : (bounds._max.departureAt ?? new Date(now));
+    }
+
+    dateTo.setHours(23, 59, 59, 999);
+    dateFrom.setHours(0, 0, 0, 0);
+
+    return { dateFrom, dateTo };
+  }
+
+  /**
+   * Potential revenue lost to seats that were blocked and therefore never sellable.
+   *
+   * The counting rule and the money live in `blocked-seats-loss.calculator.ts`; this method
+   * is the fetch plan. Query count is bounded and independent of the number of schedules:
+   * schedules → coach assignments → seats → booking seats → seat blocks, plus one fare
+   * calculation per *affected* schedule (schedules with no blocked seat need no fare).
+   */
+  async getBlockedSeatsRevenueLoss(
+    query: BlockedSeatsRevenueLossQueryDto,
+  ): Promise<BlockedSeatRevenueLossReport> {
+    const now = new Date();
+    const { dateFrom, dateTo } = await this.resolveWindow(query, now);
+    const nationalityAssumption = query.nationality?.trim() || DEFAULT_LOSS_NATIONALITY;
+    const nationalityType = resolveNationalityType(nationalityAssumption);
+
+    // 1 — schedules in the window. CANCELLED trains never ran, so nothing was lost on them.
+    const schedules = await this.prisma.trainSchedule.findMany({
+      where: {
+        departureAt: { gte: dateFrom, lte: dateTo },
+        status: { not: 'CANCELLED' },
+        ...(query.scheduleId ? { id: query.scheduleId } : {}),
+        ...(query.routeId ? { routeId: query.routeId } : {}),
+        ...(query.trainId ? { trainId: query.trainId } : {}),
+      },
+      select: {
+        id: true,
+        departureAt: true,
+        status: true,
+        train: { select: { number: true } },
+        route: { select: { name: true } },
+        originStation: { select: { name: true } },
+        destinationStation: { select: { name: true } },
+      },
+      orderBy: { departureAt: 'desc' },
+    });
+
+    const emptyOptions = {
+      faresBySchedule: new Map<string, Map<string, LossFare>>(),
+      schedulesWithoutFare: new Set<string>(),
+      nationalityType,
+      nationalityAssumption,
+      now,
+      dateFrom,
+      dateTo,
+      page: query.page ?? 1,
+      pageSize: query.pageSize ?? DEFAULT_LOSS_PAGE_SIZE,
+      sortBy: query.sortBy ?? BlockedSeatsLossSortBy.LOSS_DESC,
+    };
+
+    if (schedules.length === 0) {
+      return assembleReport(EMPTY_LOSS_INPUT, new Map(), emptyOptions);
+    }
+
+    const scheduleIds = schedules.map((s) => s.id);
+    const departures = schedules.map((s) => s.departureAt.getTime());
+    const earliestDeparture = new Date(Math.min(...departures));
+    const latestDeparture = new Date(Math.max(...departures));
+
+    // 2 — coach assignments. Unfiltered by `coachId` on purpose: the load factor must
+    // describe the whole train even when the block list is narrowed to one coach.
+    const assignments = await this.prisma.coachAssignment.findMany({
+      where: { scheduleId: { in: scheduleIds } },
+      select: {
+        scheduleId: true,
+        coachId: true,
+        coach: {
+          select: {
+            id: true,
+            number: true,
+            coachType: {
+              select: {
+                name: true,
+                type: true,
+                seatClasses: {
+                  select: { id: true, name: true, bedPosition: true, nationalityType: true },
+                },
+              },
+            },
+          },
+        },
+      },
+    });
+
+    const coachesById = new Map<string, LossCoach>();
+    const coachIdsBySchedule = new Map<string, Set<string>>();
+    for (const assignment of assignments) {
+      const coachIds = coachIdsBySchedule.get(assignment.scheduleId) ?? new Set<string>();
+      coachIds.add(assignment.coachId);
+      coachIdsBySchedule.set(assignment.scheduleId, coachIds);
+
+      if (!coachesById.has(assignment.coachId)) {
+        coachesById.set(assignment.coachId, {
+          id: assignment.coach.id,
+          number: assignment.coach.number,
+          coachTypeType: assignment.coach.coachType?.type ?? 'passenger',
+          coachTypeName: assignment.coach.coachType?.name ?? 'Unknown',
+          seatClasses: assignment.coach.coachType?.seatClasses ?? [],
+        });
+      }
+    }
+
+    // 3 — seats on those coaches. Bounded by fleet size, not by schedule count.
+    const coachIds = [...coachesById.keys()];
+    const seatRows = coachIds.length
+      ? await this.prisma.seat.findMany({
+          where: { coachId: { in: coachIds } },
+          select: {
+            id: true,
+            coachId: true,
+            seatNumber: true,
+            bedPosition: true,
+            premiumFeeMinor: true,
+          },
+        })
+      : [];
+    const seatsById = new Map<string, LossSeat>(seatRows.map((s) => [s.id, s]));
+
+    // 4 — seats actually sold on these schedules. Same tri-branch shape the other
+    // schedule reports use: outbound leg, return leg, and legacy rows with a null
+    // scheduleId that inherit the booking's schedule.
+    const bookingSeats = await this.prisma.bookingSeat.findMany({
+      where: {
+        booking: { status: { in: ['CONFIRMED', 'BOARDED'] } },
+        OR: [
+          { scheduleId: { in: scheduleIds } },
+          { leg: 2, booking: { returnScheduleId: { in: scheduleIds } } },
+          { scheduleId: null, leg: 1, booking: { scheduleId: { in: scheduleIds } } },
+        ],
+      },
+      select: {
+        seatId: true,
+        scheduleId: true,
+        leg: true,
+        booking: { select: { scheduleId: true, returnScheduleId: true } },
+      },
+    });
+
+    const scheduleIdSet = new Set(scheduleIds);
+    const soldSeatKeys = new Set<string>();
+    for (const bs of bookingSeats) {
+      const effectiveScheduleId =
+        bs.scheduleId ?? (bs.leg === 2 ? bs.booking.returnScheduleId : bs.booking.scheduleId);
+      if (!effectiveScheduleId || !scheduleIdSet.has(effectiveScheduleId)) continue;
+      soldSeatKeys.add(soldKey(effectiveScheduleId, bs.seatId));
+    }
+
+    // 5 — candidate blocks: schedule-scoped ones for these schedules, plus global ones
+    // whose active window overlaps the departure range at all. Per-schedule precision
+    // is applied in the calculator against each schedule's own departureAt.
+    const blockRows = await this.prisma.seatBlock.findMany({
+      where: {
+        AND: [
+          {
+            OR: [
+              { scheduleId: { in: scheduleIds } },
+              {
+                scheduleId: null,
+                blockedAt: { lte: latestDeparture },
+                OR: [{ unblockAt: null }, { unblockAt: { gte: earliestDeparture } }],
+              },
+            ],
+          },
+          ...(query.reasonCategory ? [{ reasonCategory: query.reasonCategory }] : []),
+          ...(query.coachId ? [{ seat: { coachId: query.coachId } }] : []),
+          ...(query.blockedBy
+            ? [
+                {
+                  OR: [
+                    { blockedBy: query.blockedBy },
+                    {
+                      blockedByName: {
+                        contains: query.blockedBy,
+                        mode: 'insensitive' as const,
+                      },
+                    },
+                  ],
+                },
+              ]
+            : []),
+        ],
+      },
+      select: {
+        id: true,
+        seatId: true,
+        scheduleId: true,
+        reason: true,
+        reasonCategory: true,
+        blockedBy: true,
+        blockedByName: true,
+        approvedBy: true,
+        blockedAt: true,
+        unblockAt: true,
+      },
+      orderBy: { blockedAt: 'desc' },
+    });
+
+    const input: LossCalculatorInput = {
+      schedules: schedules.map((s) => ({
+        id: s.id,
+        trainNumber: s.train?.number ?? '—',
+        routeName: s.route?.name ?? null,
+        originStation: s.originStation?.name ?? '—',
+        destinationStation: s.destinationStation?.name ?? '—',
+        departureAt: s.departureAt,
+        status: s.status,
+      })),
+      seatsById,
+      coachesById,
+      coachIdsBySchedule,
+      soldSeatKeys,
+      blocks: blockRows,
+    };
+
+    const countedBySchedule = selectCountedBlocks(input);
+
+    // 6 — one fare calculation per affected schedule, never per seat.
+    const { faresBySchedule, schedulesWithoutFare } = await this.quoteFaresForSchedules(
+      [...countedBySchedule.keys()],
+      nationalityAssumption,
+    );
+
+    return assembleReport(input, countedBySchedule, {
+      ...emptyOptions,
+      faresBySchedule,
+      schedulesWithoutFare,
+    });
+  }
+
+  /**
+   * Quotes every active seat class on each affected schedule, in small concurrent batches
+   * so a wide date range does not open hundreds of simultaneous fare calculations.
+   */
+  private async quoteFaresForSchedules(
+    scheduleIds: string[],
+    nationality: string,
+  ): Promise<{
+    faresBySchedule: Map<string, Map<string, LossFare>>;
+    schedulesWithoutFare: Set<string>;
+  }> {
+    const faresBySchedule = new Map<string, Map<string, LossFare>>();
+    const schedulesWithoutFare = new Set<string>();
+
+    for (let i = 0; i < scheduleIds.length; i += FARE_QUOTE_CONCURRENCY) {
+      const batch = scheduleIds.slice(i, i + FARE_QUOTE_CONCURRENCY);
+      await Promise.all(
+        batch.map(async (scheduleId) => {
+          try {
+            const quotes = await this.fareEngine.calculateAllForSchedule(scheduleId, nationality);
+            const bySeatClass = new Map<string, LossFare>();
+            for (const quote of quotes) {
+              const fare = normalizeFareQuote(quote);
+              if (fare) bySeatClass.set(fare.seatClassId, fare);
+            }
+            if (bySeatClass.size === 0) {
+              schedulesWithoutFare.add(scheduleId);
+              return;
+            }
+            faresBySchedule.set(scheduleId, bySeatClass);
+          } catch (err) {
+            // A schedule with no route and no fare rules cannot be priced. Its blocked
+            // seats still show up in the report; they just carry no monetary claim.
+            this.logger.warn(
+              `Blocked-seat loss: no fare for schedule ${scheduleId} — ${
+                err instanceof Error ? err.message : String(err)
+              }`,
+            );
+            schedulesWithoutFare.add(scheduleId);
+          }
+        }),
+      );
+    }
+
+    return { faresBySchedule, schedulesWithoutFare };
+  }
+
+  /** CSV of the same report, one row per blocked seat, honouring the same filters. */
+  async exportBlockedSeatsRevenueLossCsv(
+    query: BlockedSeatsRevenueLossQueryDto,
+  ): Promise<string> {
+    // Export is the whole filtered result, not the caller's page.
+    const report = await this.getBlockedSeatsRevenueLoss({
+      ...query,
+      page: 1,
+      pageSize: CSV_EXPORT_MAX_SCHEDULES,
+    });
+
+    const headers = [
+      'Train', 'Route', 'Origin', 'Destination', 'Departure', 'Schedule Status',
+      'Sellable Seats', 'Sold Seats', 'Load Factor %', 'Coach', 'Seat', 'Seat Class',
+      'Block Type', 'Reason Category', 'Reason', 'Blocked By', 'Blocked By Name',
+      'Approved By', 'Blocked At', 'Unblock At', 'Still Blocked', 'Days Blocked',
+      'Estimated Loss (minor)', 'Currency',
+    ];
+
+    const rows = report.schedules.flatMap((s) =>
+      s.blocks.map((b) => [
+        s.trainNumber, s.routeName ?? '', s.originStation, s.destinationStation,
+        s.departureAt, s.status, s.sellableSeats, s.soldSeats, s.loadFactorPercent,
+        b.coachNumber ?? '', b.seatNumber ?? '', b.seatClassName ?? '',
+        b.blockType, b.reasonCategory ?? UNCATEGORIZED_REASON_CATEGORY, b.reason,
+        b.blockedBy, b.blockedByName ?? '', b.approvedBy ?? '',
+        b.blockedAt, b.unblockAt ?? '', b.stillBlocked ? 'YES' : 'NO', b.daysBlocked,
+        b.estimatedLossMinor, b.currency,
+      ]),
+    );
+
+    return [headers, ...rows].map((row) => row.map(toCsvCell).join(',')).join('\n');
+  }
+
   async getReport(reportId: string) {
     return this.prisma.operationalReport.findUnique({
       where: { id: reportId },
diff --git a/apps/edr-passenger-api/src/modules/search/search.service.ts b/apps/edr-passenger-api/src/modules/search/search.service.ts
index 8820619d8..262ddd3a6 100644
--- a/apps/edr-passenger-api/src/modules/search/search.service.ts
+++ b/apps/edr-passenger-api/src/modules/search/search.service.ts
@@ -442,13 +442,47 @@ export class SearchService {
       where: { active: true, stops: { some: { stationId: originStationId } } },
       select: { stops: { select: { stationId: true, sequence: true } } },
     });
-    return candidateRoutes.some((r) => {
+    const onRouteDefinition = candidateRoutes.some((r) => {
       const o = r.stops.find((s) => s.stationId === originStationId);
       const d = r.stops.find((s) => s.stationId === destinationStationId);
       return !!o && !!d && o.sequence < d.sequence;
     });
+    if (onRouteDefinition) return true;
+
+    // Fallback: a schedule whose own stop times connect the pair in order.
+    //
+    // A return leg is modelled by reusing the outbound Route while laying its TripStopTimes
+    // in the opposite order (see test/fixtures/seed-ui.ts). The RouteStop check above cannot
+    // see that — it only knows A→B→C — so it reports "no route" for C→A even though
+    // searchSchedules finds and sells that trip, because searchSchedules resolves
+    // connectivity from TripStopTime.sequence, exactly like the availability loop below.
+    // Without this fallback the endpoint contradicts the search it is meant to preview, and
+    // the portal would disable the date picker for a pair that is genuinely bookable.
+    const schedules = await this.prisma.trainSchedule.findMany({
+      where: {
+        AND: [
+          { stopTimes: { some: { stationId: originStationId } } },
+          { stopTimes: { some: { stationId: destinationStationId } } },
+        ],
+      },
+      select: {
+        stopTimes: {
+          where: { stationId: { in: [originStationId, destinationStationId] } },
+          select: { stationId: true, sequence: true },
+        },
+      },
+      take: this.ROUTE_EXISTS_SCHEDULE_SCAN_LIMIT,
+    });
+    return schedules.some((s) => {
+      const o = s.stopTimes.find((st) => st.stationId === originStationId);
+      const d = s.stopTimes.find((st) => st.stationId === destinationStationId);
+      return !!o && !!d && o.sequence < d.sequence;
+    });
   }
 
+  /** Bounds the stop-time fallback scan — connectivity is a yes/no, not a survey. */
+  private readonly ROUTE_EXISTS_SCHEDULE_SCAN_LIMIT = 200;
+
   /** Status/package/coach bookability only — ignores date, cutoff, and seat-level availability. */
   private isBookableSchedule(s: { status: string; isPackageOnly: boolean; coachAssignments: { id: string }[] }): boolean {
     return (
diff --git a/apps/edr-passenger-api/src/modules/seats/seats.controller.ts b/apps/edr-passenger-api/src/modules/seats/seats.controller.ts
index c66dca06d..d19b6f024 100644
--- a/apps/edr-passenger-api/src/modules/seats/seats.controller.ts
+++ b/apps/edr-passenger-api/src/modules/seats/seats.controller.ts
@@ -7,6 +7,7 @@ import {
   Post,
   Patch,
   Query,
+  Req,
   SetMetadata,
   UseGuards,
 } from "@nestjs/common";
@@ -20,7 +21,8 @@ import {
   ApiBody,
 } from "@nestjs/swagger";
 import { SeatsService } from "./seats.service";
-import { HoldSeatsDto, ReleaseHoldDto } from "./seats.dto";
+import { BlockSeatDto, HoldSeatsDto, ReleaseHoldDto, SetMaintenanceDto } from "./seats.dto";
+import { resolveActingUser, RequestWithActingUser } from "../../common/acting-user";
 import { GetDuplicateSeatsQuery, ResolveDuplicatesDto } from "./duplicate-seats.dto";
 import { JwtGuard } from "../../common/jwt.guard";
 import { PassengerStaff } from "../../common/passenger-guards";
@@ -220,11 +222,22 @@ This makes it clear which segment of the route each seat is held for, enabling s
   @Post(":seatId/block")
   @PassengerStaff([PASSENGER_PERMS.seats.manage, PASSENGER_PERMS.admin])
   @ApiBearerAuth("IAM-auth")
-  @ApiOperation({ summary: "Block a seat (e.g., maintenance, damage)" })
+  @ApiOperation({
+    summary: "Block a seat (e.g., maintenance, damage)",
+    description:
+      "The authenticated staff member is recorded as the blocker — their IAM id in `blockedBy` and their " +
+      "display name in `blockedByName` — so the Blocked Seat Revenue Loss report can attribute the block " +
+      "without a cross-service lookup.",
+  })
   @ApiParam({ name: "seatId", description: "Seat UUID" })
+  @ApiBody({ type: BlockSeatDto })
   @ApiResponse({ status: 200, description: "Seat blocked" })
-  blockSeat(@Param("seatId") seatId: string, @Body() body: { reason: string; scheduleId?: string }) {
-    return this.service.blockSeat(seatId, body.reason, body.scheduleId);
+  blockSeat(
+    @Param("seatId") seatId: string,
+    @Body() body: BlockSeatDto,
+    @Req() req: RequestWithActingUser,
+  ) {
+    return this.service.blockSeat(seatId, body, resolveActingUser(req));
   }
 
   @Delete(":seatId/block")
@@ -243,9 +256,14 @@ This makes it clear which segment of the route each seat is held for, enabling s
   @ApiBearerAuth("IAM-auth")
   @ApiOperation({ summary: "Set seat status to Under Maintenance" })
   @ApiParam({ name: "seatId", description: "Seat UUID" })
+  @ApiBody({ type: SetMaintenanceDto })
   @ApiResponse({ status: 200, description: "Seat set to under maintenance" })
-  setMaintenance(@Param("seatId") seatId: string, @Body() body: { reason: string }) {
-    return this.service.setMaintenance(seatId, body.reason);
+  setMaintenance(
+    @Param("seatId") seatId: string,
+    @Body() body: SetMaintenanceDto,
+    @Req() req: RequestWithActingUser,
+  ) {
+    return this.service.setMaintenance(seatId, body.reason, resolveActingUser(req));
   }
 
   @Delete(":seatId/maintenance")
diff --git a/apps/edr-passenger-api/src/modules/seats/seats.dto.ts b/apps/edr-passenger-api/src/modules/seats/seats.dto.ts
index 87d47588e..1d177e719 100644
--- a/apps/edr-passenger-api/src/modules/seats/seats.dto.ts
+++ b/apps/edr-passenger-api/src/modules/seats/seats.dto.ts
@@ -53,3 +53,43 @@ export class ReleaseHoldDto {
   @ApiProperty({ example: 'hold-uuid', description: 'SeatHold UUID to release' })
   @IsString() holdId: string;
 }
+
+/** Coarse bucket for *why* a seat was pulled out of sale — mirrors the Prisma
+ * `SeatBlockReasonCategory` enum. The free-text `reason` stays the detail. */
+export enum SeatBlockReasonCategory {
+  MAINTENANCE = 'MAINTENANCE',
+  VIP_RESERVED = 'VIP_RESERVED',
+  SAFETY = 'SAFETY',
+  OPERATIONAL = 'OPERATIONAL',
+  OTHER = 'OTHER',
+}
+
+export class BlockSeatDto {
+  @ApiProperty({
+    example: 'Torn upholstery — awaiting replacement',
+    description: 'Free-text detail explaining the block. Shown verbatim in the revenue-loss report.',
+  })
+  @IsString() reason: string;
+
+  @ApiPropertyOptional({
+    example: 'schedule-uuid',
+    description:
+      'When set, the block applies only to this schedule. Omit for a global block that pulls the seat out of sale on every schedule its coach runs on.',
+  })
+  @IsOptional() @IsString() scheduleId?: string;
+
+  @ApiPropertyOptional({
+    enum: SeatBlockReasonCategory,
+    default: SeatBlockReasonCategory.OTHER,
+    description:
+      'Reporting bucket for this block. Defaults to OTHER. Drives the reason-category breakdown in the Blocked Seat Revenue Loss report.',
+  })
+  @IsOptional()
+  @IsEnum(SeatBlockReasonCategory)
+  reasonCategory?: SeatBlockReasonCategory;
+}
+
+export class SetMaintenanceDto {
+  @ApiProperty({ example: 'Seat recline mechanism jammed' })
+  @IsString() reason: string;
+}
diff --git a/apps/edr-passenger-api/src/modules/seats/seats.service.ts b/apps/edr-passenger-api/src/modules/seats/seats.service.ts
index 77e13740a..383f7d96c 100644
--- a/apps/edr-passenger-api/src/modules/seats/seats.service.ts
+++ b/apps/edr-passenger-api/src/modules/seats/seats.service.ts
@@ -1,6 +1,7 @@
 import { Injectable, ConflictException, NotFoundException, BadRequestException, Logger } from '@nestjs/common';
 import { PrismaService } from '../../common/prisma.service';
-import { HoldSeatsDto, JourneyDirection } from './seats.dto';
+import { BlockSeatDto, HoldSeatsDto, JourneyDirection, SeatBlockReasonCategory } from './seats.dto';
+import { ActingUser } from '../../common/acting-user';
 import { Cron, CronExpression } from '@nestjs/schedule';
 import { SegmentsService } from '../segments/segments.service';
 import { SystemConfigService, CONFIG_KEYS } from '../system-config/system-config.service';
@@ -696,7 +697,10 @@ export class SeatsService {
       coachNumber: b.seat.coach.number,
       scheduleId: b.scheduleId,
       reason: b.reason,
+      // Blocks written before the reason-category column existed report as uncategorized.
+      reasonCategory: b.reasonCategory,
       blockedBy: b.blockedBy,
+      blockedByName: b.blockedByName,
       blockedAt: b.blockedAt,
       unblockAt: b.unblockAt,
     }));
@@ -898,20 +902,42 @@ export class SeatsService {
     return { imported, errors: errors.slice(0, 10) };
   }
 
-  async blockSeat(seatId: string, reason: string, scheduleId?: string) {
+  /**
+   * Pulls a seat out of sale.
+   *
+   * `actor` is the authenticated staff member from the request. Their IAM id lands in
+   * `blockedBy` and their display name is denormalized into `blockedByName`, so the
+   * Blocked Seat Revenue Loss report can attribute the block without a cross-service
+   * lookup. System-initiated blocks (no authenticated user) fall back to `SYSTEM`.
+   */
+  async blockSeat(seatId: string, dto: BlockSeatDto, actor: ActingUser | null) {
     const seat = await this.prisma.seat.findUnique({ where: { id: seatId } });
     if (!seat) throw new NotFoundException('Seat not found');
 
+    const { reason, scheduleId } = dto;
+    const reasonCategory = dto.reasonCategory ?? SeatBlockReasonCategory.OTHER;
+    const blockedBy = actor?.id ?? 'SYSTEM';
+    const blockedByName = actor?.name ?? 'System';
+
     // Schedule-scoped block: only affects this schedule, not all schedules
     // Global block (no scheduleId): sets Seat.status = BLOCKED for all schedules
     if (scheduleId) {
-      await this.prisma.seatBlock.create({ data: { seatId, scheduleId, reason, blockedBy: 'system' } });
+      await this.prisma.seatBlock.create({
+        data: { seatId, scheduleId, reason, reasonCategory, blockedBy, blockedByName },
+      });
     } else {
       await this.prisma.seat.update({ where: { id: seatId }, data: { status: 'BLOCKED' } });
-      await this.prisma.seatBlock.create({ data: { seatId, reason, blockedBy: 'system' } });
+      await this.prisma.seatBlock.create({
+        data: { seatId, reason, reasonCategory, blockedBy, blockedByName },
+      });
     }
-    await this.auditService.log({ action: 'UPDATE', entityType: 'Seat', entityId: seatId, newData: { status: 'BLOCKED', reason, scheduleId } });
-    return { blocked: true, seatId, reason, scheduleId };
+    await this.auditService.log({
+      action: 'UPDATE',
+      entityType: 'Seat',
+      entityId: seatId,
+      newData: { status: 'BLOCKED', reason, reasonCategory, scheduleId, blockedBy },
+    });
+    return { blocked: true, seatId, reason, reasonCategory, scheduleId, blockedBy, blockedByName };
   }
 
   async unblockSeat(seatId: string, scheduleId?: string) {
@@ -928,12 +954,20 @@ export class SeatsService {
     return { unblocked: true, seatId, scheduleId };
   }
 
-  async setMaintenance(seatId: string, reason: string) {
+  async setMaintenance(seatId: string, reason: string, actor: ActingUser | null) {
     const seat = await this.prisma.seat.findUnique({ where: { id: seatId } });
     if (!seat) throw new NotFoundException('Seat not found');
     if (seat.status === 'BOOKED') throw new BadRequestException('Cannot set a booked seat to maintenance');
     await this.prisma.seat.update({ where: { id: seatId }, data: { status: 'UNDER_MAINTENANCE' as any } });
-    await this.prisma.seatBlock.create({ data: { seatId, reason: `MAINTENANCE: ${reason}`, blockedBy: 'system' } });
+    await this.prisma.seatBlock.create({
+      data: {
+        seatId,
+        reason: `MAINTENANCE: ${reason}`,
+        reasonCategory: SeatBlockReasonCategory.MAINTENANCE,
+        blockedBy: actor?.id ?? 'SYSTEM',
+        blockedByName: actor?.name ?? 'System',
+      },
+    });
     return { maintenance: true, seatId, reason };
   }
 
diff --git a/apps/edr-passenger-api/test/available-dates.e2e-spec.ts b/apps/edr-passenger-api/test/available-dates.e2e-spec.ts
new file mode 100644
index 000000000..bd6ed4363
--- /dev/null
+++ b/apps/edr-passenger-api/test/available-dates.e2e-spec.ts
@@ -0,0 +1,308 @@
+/**
+ * `/search/available-dates` — the data behind the search form's date picker.
+ *
+ * The portal disables the date control entirely when `routeExists` is false, and grays out
+ * individual days that report `available: false`. Both behaviours are only as correct as this
+ * endpoint, so this suite pins:
+ *
+ *   1. routeExists=false (with an empty `dates` array) for a station pair no active route
+ *      connects in that direction — the case that disables the whole control.
+ *   2. routeExists=true plus a per-date availability list when a route does connect them.
+ *   3. Direction matters: seed-core's route runs A→B→C, so C→A is NOT a route even though
+ *      both stations sit on it. This is the exact regression the UI relies on — a reverse
+ *      pair must not be treated as bookable.
+ *   4. A date only counts as available when a bookable schedule actually departs that day.
+ *   5. The range is clamped server-side and never reports dates in the past.
+ *
+ * Uses the slim harness (real Nest DI) for schedule creation so the real interpolation runs,
+ * then instantiates SearchService directly with a real Prisma — SearchModule is not in the
+ * slim harness's DOMAIN_MODULES (it pulls in NotificationsModule → RabbitMQ), mirroring the
+ * Tier-2 pattern in stop-based-booking-segment.e2e-spec.ts.
+ */
+import { SchedulesService } from "../src/modules/schedules/schedules.service";
+import { SearchService } from "../src/modules/search/search.service";
+import { SegmentsService } from "../src/modules/segments/segments.service";
+import { CurrencyService } from "../src/modules/currency/currency.service";
+import { FareEngineService } from "../src/modules/fare-engine/fare-engine.service";
+import { createServiceHarness, ServiceHarness } from "./setup/slim-app";
+import { IDS, resetAndSeedCore } from "./fixtures/seed-core";
+
+const ADDIS_OFFSET_MS = 3 * 60 * 60 * 1000;
+const ONE_DAY_MS = 24 * 60 * 60 * 1000;
+
+/** Calendar date in Africa/Addis_Ababa (fixed UTC+3) — matches the service's own conversion. */
+function addisDateStr(d: Date): string {
+  return new Date(d.getTime() + ADDIS_OFFSET_MS).toISOString().slice(0, 10);
+}
+
+function daysFromNow(days: number): Date {
+  return new Date(Date.now() + days * ONE_DAY_MS);
+}
+
+describe("GET /search/available-dates", () => {
+  let harness: ServiceHarness;
+  let searchService: SearchService;
+  let schedulesService: SchedulesService;
+
+  beforeAll(async () => {
+    harness = await createServiceHarness();
+    schedulesService = await harness.moduleRef.resolve(SchedulesService);
+    const currencyService = harness.moduleRef.get(CurrencyService);
+    const fareEngine = harness.moduleRef.get(FareEngineService);
+    const segmentsService = new SegmentsService(harness.prisma as any);
+    searchService = new SearchService(
+      harness.prisma as any,
+      currencyService,
+      fareEngine,
+      segmentsService,
+    );
+  });
+
+  afterAll(async () => {
+    await harness.close();
+  });
+
+  beforeEach(async () => {
+    await resetAndSeedCore(harness.prisma);
+  });
+
+  /** Creates a bookable schedule departing `days` from now on the seeded A→B→C route. */
+  async function createBookableSchedule(days: number, trainNumber: string) {
+    const departureAt = daysFromNow(days);
+    departureAt.setUTCHours(6, 0, 0, 0);
+    const arrivalAt = new Date(departureAt.getTime() + 6 * 60 * 60 * 1000);
+
+    const train = await harness.prisma.train.create({
+      data: { number: trainNumber, name: `Test ${trainNumber}` },
+    });
+    const coach = await harness.prisma.coach.create({
+      data: {
+        coachTypeId: IDS.coachType,
+        number: `${trainNumber}-C1`,
+        capacity: 2,
+        sequence: 1,
+        status: "ACTIVE",
+      },
+    });
+    await Promise.all(
+      ["1A", "1B"].map((seatNumber, i) =>
+        harness.prisma.seat.create({
+          data: { coachId: coach.id, seatNumber, row: 1, col: String.fromCharCode(65 + i) },
+        }),
+      ),
+    );
+    const schedule = await schedulesService.createSchedule({
+      trainId: train.id,
+      routeId: IDS.route,
+      originStationId: IDS.stationA,
+      destinationStationId: IDS.stationC,
+      departureAt: departureAt.toISOString(),
+      arrivalAt: arrivalAt.toISOString(),
+      coachIds: [coach.id],
+    } as any);
+
+    return { schedule, departureDate: addisDateStr(departureAt) };
+  }
+
+  function range(days = 30) {
+    return { from: addisDateStr(new Date()), to: addisDateStr(daysFromNow(days)) };
+  }
+
+  it("reports routeExists=false and no dates when no route connects the pair", async () => {
+    // seed-core's only route runs A→B→C and no schedule exists yet, so nothing connects C→A.
+    // Every date is unbookable, and the portal disables the date control outright rather than
+    // graying out each day individually.
+    const result = await searchService.getAvailableDates({
+      originStationId: IDS.stationC,
+      destinationStationId: IDS.stationA,
+      ...range(),
+    } as any);
+
+    expect(result.routeExists).toBe(false);
+    expect(result.dates).toEqual([]);
+  });
+
+  /**
+   * Regression: `routeExists` must agree with what the search can actually sell.
+   *
+   * A return leg reuses the outbound Route but lays its TripStopTimes in the opposite order.
+   * routeExistsForPair originally consulted only RouteStop ordering, so it answered "no route"
+   * for C→A while searchTrips happily returned a bookable trip for that same pair. The portal
+   * disables its date picker on this flag, so the stale answer would have blocked a real,
+   * sellable journey.
+   */
+  it("reports routeExists=true for a reverse pair a real schedule connects", async () => {
+    const departureAt = daysFromNow(3);
+    departureAt.setUTCHours(6, 0, 0, 0);
+    const train = await harness.prisma.train.create({
+      data: { number: "AD-REV", name: "Reverse leg" },
+    });
+    const coach = await harness.prisma.coach.create({
+      data: { coachTypeId: IDS.coachType, number: "AD-REV-C1", capacity: 1, sequence: 1, status: "ACTIVE" },
+    });
+    await harness.prisma.seat.create({
+      data: { coachId: coach.id, seatNumber: "1A", row: 1, col: "A" },
+    });
+    // Return leg: same Route, but stop times run C → A.
+    const schedule = await harness.prisma.trainSchedule.create({
+      data: {
+        trainId: train.id,
+        routeId: IDS.route,
+        originStationId: IDS.stationC,
+        destinationStationId: IDS.stationA,
+        departureAt,
+        arrivalAt: new Date(departureAt.getTime() + 6 * 60 * 60 * 1000),
+        durationMinutes: 360,
+        status: "SCHEDULED",
+      },
+    });
+    await harness.prisma.tripStopTime.createMany({
+      data: [
+        { scheduleId: schedule.id, stationId: IDS.stationC, sequence: 1, plannedDepartureAt: departureAt, status: "OPEN" },
+        { scheduleId: schedule.id, stationId: IDS.stationA, sequence: 2, plannedArrivalAt: new Date(departureAt.getTime() + 6 * 3600_000), status: "OPEN" },
+      ],
+    });
+    await harness.prisma.coachAssignment.create({
+      data: { scheduleId: schedule.id, coachId: coach.id, positionNumber: 1, isOperational: true },
+    });
+
+    const result = await searchService.getAvailableDates({
+      originStationId: IDS.stationC,
+      destinationStationId: IDS.stationA,
+      ...range(),
+    } as any);
+
+    expect(result.routeExists).toBe(true);
+    expect(result.dates.filter((d) => d.available).map((d) => d.date)).toContain(
+      addisDateStr(departureAt),
+    );
+  });
+
+  it("reports routeExists=false for a station pair with no route at all", async () => {
+    const orphan = await harness.prisma.station.create({
+      data: { code: "ZZZ", name: "Orphan", city: "Nowhere" },
+    });
+
+    const result = await searchService.getAvailableDates({
+      originStationId: IDS.stationA,
+      destinationStationId: orphan.id,
+      ...range(),
+    } as any);
+
+    expect(result.routeExists).toBe(false);
+    expect(result.dates).toEqual([]);
+  });
+
+  it("reports routeExists=true with a per-date list for a connected pair", async () => {
+    const result = await searchService.getAvailableDates({
+      originStationId: IDS.stationA,
+      destinationStationId: IDS.stationC,
+      ...range(),
+    } as any);
+
+    expect(result.routeExists).toBe(true);
+    expect(result.dates.length).toBeGreaterThan(0);
+    for (const d of result.dates) {
+      expect(d).toEqual({ date: expect.any(String), available: expect.any(Boolean) });
+    }
+  });
+
+  it("marks only the days a bookable schedule departs as available", async () => {
+    const { departureDate } = await createBookableSchedule(3, "AD-1");
+
+    const result = await searchService.getAvailableDates({
+      originStationId: IDS.stationA,
+      destinationStationId: IDS.stationC,
+      ...range(),
+    } as any);
+
+    expect(result.routeExists).toBe(true);
+    const available = result.dates.filter((d) => d.available).map((d) => d.date);
+    expect(available).toContain(departureDate);
+    // Every other day in the window has no schedule, so it must be reported unavailable —
+    // this is what grays out individual days on the picker.
+    expect(available).toEqual([departureDate]);
+  });
+
+  it("treats a mid-route segment as its own pair (A→B available, C→B never)", async () => {
+    const { departureDate } = await createBookableSchedule(4, "AD-2");
+
+    const forward = await searchService.getAvailableDates({
+      originStationId: IDS.stationA,
+      destinationStationId: IDS.stationB,
+      ...range(),
+    } as any);
+    expect(forward.routeExists).toBe(true);
+    expect(forward.dates.filter((d) => d.available).map((d) => d.date)).toContain(departureDate);
+
+    // C sits after B on the route, so C→B is backwards — no route, whatever schedules exist.
+    const backward = await searchService.getAvailableDates({
+      originStationId: IDS.stationC,
+      destinationStationId: IDS.stationB,
+      ...range(),
+    } as any);
+    expect(backward.routeExists).toBe(false);
+    expect(backward.dates).toEqual([]);
+  });
+
+  it("never reports dates before today, even when asked for a past range", async () => {
+    const result = await searchService.getAvailableDates({
+      originStationId: IDS.stationA,
+      destinationStationId: IDS.stationC,
+      from: addisDateStr(daysFromNow(-30)),
+      to: addisDateStr(daysFromNow(5)),
+    } as any);
+
+    const today = addisDateStr(new Date());
+    expect(result.routeExists).toBe(true);
+    for (const d of result.dates) expect(d.date >= today).toBe(true);
+  });
+
+  it("clamps an over-long range to the 90-day server maximum", async () => {
+    const result = await searchService.getAvailableDates({
+      originStationId: IDS.stationA,
+      destinationStationId: IDS.stationC,
+      from: addisDateStr(new Date()),
+      to: addisDateStr(daysFromNow(400)),
+    } as any);
+
+    expect(result.routeExists).toBe(true);
+    // Inclusive of both ends, 90 days spans at most 91 calendar dates.
+    expect(result.dates.length).toBeLessThanOrEqual(91);
+    expect(result.to <= addisDateStr(daysFromNow(91))).toBe(true);
+  });
+
+  it("does not mark a package-only schedule's day as available", async () => {
+    const { schedule, departureDate } = await createBookableSchedule(5, "AD-3");
+    await harness.prisma.trainSchedule.update({
+      where: { id: schedule.id },
+      data: { isPackageOnly: true },
+    });
+
+    const result = await searchService.getAvailableDates({
+      originStationId: IDS.stationA,
+      destinationStationId: IDS.stationC,
+      ...range(),
+    } as any);
+
+    const available = result.dates.filter((d) => d.available).map((d) => d.date);
+    expect(available).not.toContain(departureDate);
+  });
+
+  it("does not mark a cancelled schedule's day as available", async () => {
+    const { schedule, departureDate } = await createBookableSchedule(6, "AD-4");
+    await harness.prisma.trainSchedule.update({
+      where: { id: schedule.id },
+      data: { status: "CANCELLED" },
+    });
+
+    const result = await searchService.getAvailableDates({
+      originStationId: IDS.stationA,
+      destinationStationId: IDS.stationC,
+      ...range(),
+    } as any);
+
+    const available = result.dates.filter((d) => d.available).map((d) => d.date);
+    expect(available).not.toContain(departureDate);
+  });
+});
diff --git a/apps/edr-passenger-web/backoffice/src/app/dashboard/page.tsx b/apps/edr-passenger-web/backoffice/src/app/dashboard/page.tsx
index 7eede0089..649796cc5 100644
--- a/apps/edr-passenger-web/backoffice/src/app/dashboard/page.tsx
+++ b/apps/edr-passenger-web/backoffice/src/app/dashboard/page.tsx
@@ -10,7 +10,9 @@ import {
   Banknote,
   ArrowRight,
   ScanLine,
+  Ban,
 } from "lucide-react";
+import { SEAT_BLOCK_REASON_CATEGORY_LABELS } from "@edr/types";
 import { dashboardApi } from "@/lib/api/dashboard";
 import { apiClient } from "@/lib/api-client";
 import { formatCurrency } from "@/lib/utils";
@@ -161,6 +163,10 @@ function DashboardPageContent() {
       return rate !== null ? sum + Math.round(totalMinor * rate) : sum;
     }, 0);
 
+  const blockedLoss = stats?.blockedSeatRevenueLoss;
+  // Never summed across currencies — each is shown on its own line, largest first.
+  const blockedLossRows = blockedLoss?.lossByCurrency ?? [];
+
   const normalRows = stats?.revenueByCurrency ?? [];
   const packageRows = stats?.packageRevenueByCurrency ?? [];
   const normalGrand = calcGrand(normalRows);
@@ -320,6 +326,73 @@ function DashboardPageContent() {
             </>
           )}
         </div>
+
+        {/* Blocked-seat revenue loss — rides the same backoffice-stats payload, so the
+            dashboard makes no extra request for it. */}
+        <div className="card flex flex-col gap-3 border-rose-200 bg-rose-50/60 dark:border-rose-900/50 dark:bg-rose-950/20">
+          <div className="flex items-center gap-2">
+            <div className="rounded-lg bg-rose-100 dark:bg-rose-900/40 p-1.5">
+              <Ban className="h-4 w-4 text-rose-600 dark:text-rose-400" />
+            </div>
+            <span className="text-xs font-semibold uppercase tracking-wider text-rose-700 dark:text-rose-400">
+              Blocked Seats / Revenue Not Collected
+            </span>
+            <span className="ml-auto text-[11px] text-muted-foreground">
+              {blockedLoss?.periodDays ? `Last ${blockedLoss.periodDays}d` : "All time"}
+            </span>
+          </div>
+          {statsLoading ? (
+            <p className="text-muted-foreground text-sm">Loading…</p>
+          ) : (
+            <>
+              {blockedLossRows.length === 0 ? (
+                <p className="text-3xl font-bold text-foreground tabular-nums">
+                  {formatCurrency(0, "ETB")}
+                </p>
+              ) : (
+                blockedLossRows.map((row, i) => (
+                  <p
+                    key={row.currency}
+                    className={
+                      i === 0
+                        ? "text-3xl font-bold text-rose-600 dark:text-rose-400 tabular-nums"
+                        : "text-lg font-semibold text-rose-600/80 dark:text-rose-400/80 tabular-nums"
+                    }
+                  >
+                    {formatCurrency(row.estimatedLossMinor, row.currency)}
+                  </p>
+                ))
+              )}
+              <p className="text-xs text-muted-foreground -mt-1">
+                Estimated potential revenue never earned
+              </p>
+              <div className="flex flex-col gap-2 border-t border-border pt-3">
+                <div className="flex items-center justify-between">
+                  <span className="text-xs text-muted-foreground">Seats blocked</span>
+                  <span className="text-sm font-semibold text-foreground tabular-nums">
+                    {(blockedLoss?.blockedSeatCount ?? 0).toLocaleString()} across{" "}
+                    {(blockedLoss?.schedulesAffected ?? 0).toLocaleString()} schedules
+                  </span>
+                </div>
+                <div className="flex items-center justify-between">
+                  <span className="text-xs text-muted-foreground">Top reason</span>
+                  <span className="text-sm font-semibold text-foreground">
+                    {blockedLoss?.topReasonCategory
+                      ? (SEAT_BLOCK_REASON_CATEGORY_LABELS[blockedLoss.topReasonCategory] ??
+                        blockedLoss.topReasonCategory)
+                      : "—"}
+                  </span>
+                </div>
+              </div>
+              <Link
+                href="/reports/blocked-seats"
+                className="flex items-center justify-center gap-1.5 rounded-md bg-rose-600 hover:bg-rose-700 dark:bg-rose-600 dark:hover:bg-rose-500 px-3 py-2 text-sm font-semibold text-white shadow-sm transition-colors mt-auto"
+              >
+                View full report <ArrowRight className="h-3.5 w-3.5" />
+              </Link>
+            </>
+          )}
+        </div>
       </div>
 
       {/* Revenue breakdown */}
diff --git a/apps/edr-passenger-web/backoffice/src/app/reports/blocked-seats/layout.tsx b/apps/edr-passenger-web/backoffice/src/app/reports/blocked-seats/layout.tsx
new file mode 100644
index 000000000..790272de1
--- /dev/null
+++ b/apps/edr-passenger-web/backoffice/src/app/reports/blocked-seats/layout.tsx
@@ -0,0 +1,3 @@
+export default function Layout({ children }: { children: React.ReactNode }) {
+  return <>{children}</>;
+}
diff --git a/apps/edr-passenger-web/backoffice/src/app/reports/blocked-seats/page.tsx b/apps/edr-passenger-web/backoffice/src/app/reports/blocked-seats/page.tsx
new file mode 100644
index 000000000..f2b1055e9
--- /dev/null
+++ b/apps/edr-passenger-web/backoffice/src/app/reports/blocked-seats/page.tsx
@@ -0,0 +1,919 @@
+"use client";
+
+import { useMemo, useState } from "react";
+import { useQuery } from "@tanstack/react-query";
+import {
+  Ban,
+  ChevronDown,
+  ChevronRight,
+  Download,
+  Info,
+  Layers,
+  TrendingDown,
+  Train,
+} from "lucide-react";
+import {
+  Bar,
+  BarChart,
+  CartesianGrid,
+  Cell,
+  ResponsiveContainer,
+  Tooltip as RechartsTooltip,
+  XAxis,
+  YAxis,
+} from "recharts";
+import type {
+  BlockedSeatLossDetail,
+  BlockedSeatLossSchedule,
+  BlockedSeatRevenueLossReport,
+} from "@edr/types";
+import {
+  SEAT_BLOCK_REASON_CATEGORIES,
+  SEAT_BLOCK_REASON_CATEGORY_LABELS,
+  UNCATEGORIZED_REASON_CATEGORY,
+} from "@edr/types";
+import { apiClient } from "@/lib/api-client";
+import {
+  blockedSeatsLossApi,
+  type BlockedSeatsLossFilters,
+  type ScheduleOption,
+} from "@/lib/api/blocked-seats-loss";
+import Badge from "@/components/ui/Badge";
+import ActionButton from "@/components/ui/ActionButton";
+import Pagination from "@/components/ui/Pagination";
+import { usePagination } from "@/lib/use-pagination";
+import { formatCurrency, formatDateTime } from "@/lib/utils";
+import { categoricalColor, getChartPalette } from "@/lib/chart-palette";
+import { useTheme } from "@/lib/theme-store";
+
+interface RouteOption {
+  id: string;
+  name: string;
+  code: string;
+}
+
+interface TrainOption {
+  id: string;
+  number: string;
+  name: string;
+}
+
+/** Fixed domain order for reason categories, so a filter never repaints the survivors. */
+const REASON_CATEGORY_ORDER: readonly string[] = [
+  ...SEAT_BLOCK_REASON_CATEGORIES,
+  UNCATEGORIZED_REASON_CATEGORY,
+];
+
+function reasonLabel(category: string | null): string {
+  const key = category ?? UNCATEGORIZED_REASON_CATEGORY;
+  return SEAT_BLOCK_REASON_CATEGORY_LABELS[key] ?? key;
+}
+
+const TABLE_PAGE_SIZE = 25;
+
+export default function BlockedSeatRevenueLossPage() {
+  const isDark = useTheme((s) => s.isDark);
+  const palette = getChartPalette(isDark);
+
+  // ── Filters ───────────────────────────────────────────────────────────────
+  // Blank dateFrom/dateTo are dropped before the request (see toQueryString), so the report
+  // defaults to its full history — the earliest schedule on record to the latest — rather
+  // than a rolling window.
+  const [dateFrom, setDateFrom] = useState("");
+  const [dateTo, setDateTo] = useState("");
+  const [scheduleId, setScheduleId] = useState("");
+  const [routeId, setRouteId] = useState("");
+  const [trainId, setTrainId] = useState("");
+  const [reasonCategory, setReasonCategory] = useState("");
+  const [blockedBy, setBlockedBy] = useState("");
+  const [blockedByInput, setBlockedByInput] = useState("");
+  const [sortBy, setSortBy] = useState("lossMinor");
+  const [page, setPage] = useState(1);
+  const [expanded, setExpanded] = useState<Set<string>>(new Set());
+  const [showMethodology, setShowMethodology] = useState(false);
+  const [exporting, setExporting] = useState(false);
+
+  const filters: BlockedSeatsLossFilters = useMemo(
+    () => ({
+      dateFrom,
+      dateTo,
+      scheduleId,
+      routeId,
+      trainId,
+      reasonCategory,
+      blockedBy,
+      sortBy,
+    }),
+    [dateFrom, dateTo, scheduleId, routeId, trainId, reasonCategory, blockedBy, sortBy],
+  );
+
+  const { data: schedules = [], isLoading: loadingSchedules } = useQuery<ScheduleOption[]>({
+    queryKey: ["report-schedules-all"],
+    queryFn: blockedSeatsLossApi.getSchedules,
+  });
+
+  const { data: routes = [] } = useQuery<RouteOption[]>({
+    queryKey: ["routes"],
+    queryFn: () => apiClient.get<RouteOption[]>("/routes"),
+  });
+
+  const { data: trains = [] } = useQuery<TrainOption[]>({
+    queryKey: ["fleet-trains"],
+    queryFn: async () => {
+      const res = await apiClient.get<TrainOption[] | { items: TrainOption[] }>(
+        "/fleet/trains",
+      );
+      return Array.isArray(res) ? res : (res?.items ?? []);
+    },
+  });
+
+  const { data, isLoading, isError, isFetching } = useQuery<BlockedSeatRevenueLossReport>({
+    queryKey: ["blocked-seats-revenue-loss", filters, page],
+    // Hold the previous render while refetching rather than flashing a skeleton.
+    placeholderData: (previous) => previous,
+    queryFn: () =>
+      blockedSeatsLossApi.getReport({ ...filters, page, pageSize: TABLE_PAGE_SIZE }),
+  });
+
+  const summary = data?.summary;
+  const scheduleRows = data?.schedules ?? [];
+  const totalPages = Math.max(1, Math.ceil((data?.meta.total ?? 0) / TABLE_PAGE_SIZE));
+
+  const resetFilters = () => {
+    setDateFrom("");
+    setDateTo("");
+    setScheduleId("");
+    setRouteId("");
+    setTrainId("");
+    setReasonCategory("");
+    setBlockedBy("");
+    setBlockedByInput("");
+    setSortBy("lossMinor");
+    setPage(1);
+  };
+
+  const onFilterChange = (apply: () => void) => {
+    apply();
+    setPage(1);
+    setExpanded(new Set());
+  };
+
+  const toggleExpanded = (id: string) => {
+    setExpanded((prev) => {
+      const next = new Set(prev);
+      if (next.has(id)) next.delete(id);
+      else next.add(id);
+      return next;
+    });
+  };
+
+  const doExport = async () => {
+    setExporting(true);
+    try {
+      const csv = await blockedSeatsLossApi.exportCsv(filters);
+      const blob = new Blob([csv], { type: "text/csv;charset=utf-8" });
+      const url = URL.createObjectURL(blob);
+      const a = document.createElement("a");
+      a.href = url;
+      a.download = `blocked-seats-revenue-loss-${new Date().toISOString().split("T")[0]}.csv`;
+      a.click();
+      URL.revokeObjectURL(url);
+    } finally {
+      setExporting(false);
+    }
+  };
+
+  // ── Chart data ────────────────────────────────────────────────────────────
+  // Money is only comparable within one currency, so both charts are scoped to the
+  // dominant currency on this page and say so.
+  const chartCurrency = summary?.lossByCurrency[0]?.currency ?? "ETB";
+  const otherCurrencies = (summary?.lossByCurrency ?? [])
+    .slice(1)
+    .map((c) => c.currency);
+
+  const topSchedules = useMemo(
+    () =>
+      scheduleRows
+        .filter((s) => s.currency === chartCurrency)
+        .slice()
+        .sort((a, b) => b.estimatedLossMinor - a.estimatedLossMinor)
+        .slice(0, 10)
+        .map((s) => ({
+          label: `${s.trainNumber} · ${new Date(s.departureAt).toLocaleDateString("en-GB", {
+            day: "2-digit",
+            month: "short",
+          })}`,
+          estimatedLossMinor: s.estimatedLossMinor,
+          adjustedLossMinor: s.adjustedLossMinor,
+          blockedSeatCount: s.blockedSeatCount,
+          scheduleId: s.scheduleId,
+        })),
+    [scheduleRows, chartCurrency],
+  );
+
+  const reasonBreakdown = useMemo(() => {
+    const rows = (summary?.topReasonCategories ?? []).filter(
+      (r) => r.currency === chartCurrency,
+    );
+    const total = rows.reduce((sum, r) => sum + r.estimatedLossMinor, 0);
+    return rows.map((r) => ({
+      ...r,
+      // Colour by fixed domain position, not by rank in this filtered view.
+      color: categoricalColor(palette, REASON_CATEGORY_ORDER.indexOf(r.reasonCategory)),
+      sharePercent: total > 0 ? (r.estimatedLossMinor / total) * 100 : 0,
+    }));
+  }, [summary, chartCurrency, palette]);
+
+  const hasData = (summary?.blockedSeatCount ?? 0) > 0;
+
+  return (
+    <div className="space-y-6 p-6">
+      <div className="flex items-start justify-between gap-4 flex-wrap">
+        <div>
+          <h1 className="text-3xl font-bold text-foreground">Blocked Seat Revenue Loss</h1>
+          <p className="text-muted-foreground mt-1">
+            Potential fare revenue that could never be earned because seats were blocked
+            out of sale — with per-seat detail on who blocked each one and why.
+          </p>
+        </div>
+        <ActionButton
+          icon={Download}
+          variant="secondary"
+          onClick={doExport}
+          loading={exporting}
+          disabled={!hasData}
+        >
+          Download CSV
+        </ActionButton>
+      </div>
+
+      {/* ── Filter bar: one row above everything it scopes ───────────────── */}
+      <div className="card">
+        <div className="grid grid-cols-1 gap-4 sm:grid-cols-2 lg:grid-cols-4">
+          <div>
+            <label className="label" htmlFor="bsl-from">
+              Departing from
+            </label>
+            <input
+              id="bsl-from"
+              type="date"
+              className="input"
+              value={dateFrom}
+              onChange={(e) => onFilterChange(() => setDateFrom(e.target.value))}
+            />
+          </div>
+          <div>
+            <label className="label" htmlFor="bsl-to">
+              Departing to
+            </label>
+            <input
+              id="bsl-to"
+              type="date"
+              className="input"
+              value={dateTo}
+              onChange={(e) => onFilterChange(() => setDateTo(e.target.value))}
+            />
+          </div>
+          <div className="lg:col-span-2">
+            <label className="label" htmlFor="bsl-schedule">
+              Schedule
+            </label>
+            <select
+              id="bsl-schedule"
+              className="input"
+              value={scheduleId}
+              disabled={loadingSchedules}
+              onChange={(e) => onFilterChange(() => setScheduleId(e.target.value))}
+            >
+              <option value="">
+                {loadingSchedules ? "Loading schedules…" : "All schedules"}
+              </option>
+              {schedules.map((s) => (
+                <option key={s.id} value={s.id}>
+                  {s.label}
+                </option>
+              ))}
+            </select>
+          </div>
+          <div>
+            <label className="label" htmlFor="bsl-route">
+              Route
+            </label>
+            <select
+              id="bsl-route"
+              className="input"
+              value={routeId}
+              onChange={(e) => onFilterChange(() => setRouteId(e.target.value))}
+            >
+              <option value="">All routes</option>
+              {routes.map((r) => (
+                <option key={r.id} value={r.id}>
+                  {r.name}
+                </option>
+              ))}
+            </select>
+          </div>
+          <div>
+            <label className="label" htmlFor="bsl-train">
+              Train
+            </label>
+            <select
+              id="bsl-train"
+              className="input"
+              value={trainId}
+              onChange={(e) => onFilterChange(() => setTrainId(e.target.value))}
+            >
+              <option value="">All trains</option>
+              {trains.map((t) => (
+                <option key={t.id} value={t.id}>
+                  {t.number} — {t.name}
+                </option>
+              ))}
+            </select>
+          </div>
+          <div>
+            <label className="label" htmlFor="bsl-reason">
+              Reason category
+            </label>
+            <select
+              id="bsl-reason"
+              className="input"
+              value={reasonCategory}
+              onChange={(e) => onFilterChange(() => setReasonCategory(e.target.value))}
+            >
+              <option value="">All reasons</option>
+              {SEAT_BLOCK_REASON_CATEGORIES.map((c) => (
+                <option key={c} value={c}>
+                  {reasonLabel(c)}
+                </option>
+              ))}
+            </select>
+          </div>
+          <div>
+            <label className="label" htmlFor="bsl-blocker">
+              Blocked by
+            </label>
+            <form
+              onSubmit={(e) => {
+                e.preventDefault();
+                onFilterChange(() => setBlockedBy(blockedByInput.trim()));
+              }}
+            >
+              <input
+                id="bsl-blocker"
+                type="search"
+                className="input"
+                placeholder="Name or user id — press Enter"
+                value={blockedByInput}
+                onChange={(e) => setBlockedByInput(e.target.value)}
+                onBlur={() => onFilterChange(() => setBlockedBy(blockedByInput.trim()))}
+              />
+            </form>
+          </div>
+        </div>
+        <div className="mt-4 flex items-center justify-between gap-4 flex-wrap">
+          <div className="flex items-center gap-3">
+            <label className="text-xs text-muted-foreground" htmlFor="bsl-sort">
+              Sort by
+            </label>
+            <select
+              id="bsl-sort"
+              className="input w-56"
+              value={sortBy}
+              onChange={(e) => onFilterChange(() => setSortBy(e.target.value))}
+            >
+              <option value="lossMinor">Largest estimated loss</option>
+              <option value="lossMinorAsc">Smallest estimated loss</option>
+              <option value="blockedSeatCount">Most blocked seats</option>
+              <option value="departureAt">Earliest departure</option>
+            </select>
+          </div>
+          <button
+            type="button"
+            onClick={resetFilters}
+            className="text-xs text-primary hover:underline"
+          >
+            Reset filters
+          </button>
+        </div>
+        {isError && (
+          <p className="text-xs text-red-500 mt-3">
+            Failed to load the report. Check the filters and try again.
+          </p>
+        )}
+      </div>
+
+      {isLoading && !data ? (
+        <div className="card py-16 text-center text-muted-foreground">Loading report…</div>
+      ) : !hasData ? (
+        <div className="card py-16 text-center text-muted-foreground">
+          <Ban className="h-10 w-10 mx-auto mb-3 opacity-30" />
+          <p>No blocked seats cost revenue in this window.</p>
+          <p className="text-xs mt-1">
+            Widen the date range, or clear the route/train/reason filters.
+          </p>
+        </div>
+      ) : (
+        <div className={isFetching ? "opacity-60 transition-opacity space-y-6" : "space-y-6"}>
+          {/* ── Summary tiles ─────────────────────────────────────────────── */}
+          <div className="grid grid-cols-1 gap-4 sm:grid-cols-2 lg:grid-cols-4">
+            <div className="card">
+              <div className="flex items-start justify-between">
+                <div className="min-w-0">
+                  <p className="text-muted-foreground text-sm font-medium">
+                    Estimated loss
+                  </p>
+                  {summary?.lossByCurrency.map((c, i) => (
+                    <p
+                      key={c.currency}
+                      className={
+                        i === 0
+                          ? "text-2xl font-bold mt-2 text-foreground"
+                          : "text-base font-semibold text-foreground"
+                      }
+                    >
+                      {formatCurrency(c.estimatedLossMinor, c.currency)}
+                    </p>
+                  ))}
+                  <p className="text-xs text-muted-foreground mt-1">At full occupancy</p>
+                </div>
+                <TrendingDown className="h-8 w-8 text-slate-500 opacity-30 shrink-0" />
+              </div>
+            </div>
+
+            <div className="card">
+              <div className="flex items-start justify-between">
+                <div className="min-w-0">
+                  <p className="text-muted-foreground text-sm font-medium">Adjusted loss</p>
+                  {summary?.lossByCurrency.map((c, i) => (
+                    <p
+                      key={c.currency}
+                      className={
+                        i === 0
+                          ? "text-2xl font-bold mt-2 text-foreground"
+                          : "text-base font-semibold text-foreground"
+                      }
+                    >
+                      {formatCurrency(c.adjustedLossMinor, c.currency)}
+                    </p>
+                  ))}
+                  <p className="text-xs text-muted-foreground mt-1">
+                    Scaled by each train&apos;s load factor
+                  </p>
+                </div>
+                <Layers className="h-8 w-8 text-slate-500 opacity-30 shrink-0" />
+              </div>
+            </div>
+
+            <div className="card">
+              <div className="flex items-start justify-between">
+                <div>
+                  <p className="text-muted-foreground text-sm font-medium">Blocked seats</p>
+                  <p className="text-2xl font-bold mt-2 text-foreground tabular-nums">
+                    {summary?.blockedSeatCount.toLocaleString()}
+                  </p>
+                  <p className="text-xs text-muted-foreground mt-1">
+                    Across {summary?.schedulesAffected.toLocaleString()} schedules
+                  </p>
+                </div>
+                <Ban className="h-8 w-8 text-slate-500 opacity-30 shrink-0" />
+              </div>
+            </div>
+
+            <div className="card">
+              <div className="flex items-start justify-between">
+                <div>
+                  <p className="text-muted-foreground text-sm font-medium">
+                    Seat-days blocked
+                  </p>
+                  <p className="text-2xl font-bold mt-2 text-foreground tabular-nums">
+                    {scheduleRows
+                      .reduce(
+                        (sum, s) => sum + s.blocks.reduce((n, b) => n + b.daysBlocked, 0),
+                        0,
+                      )
+                      .toLocaleString()}
+                  </p>
+                  <p className="text-xs text-muted-foreground mt-1">On this page</p>
+                </div>
+                <Train className="h-8 w-8 text-slate-500 opacity-30 shrink-0" />
+              </div>
+            </div>
+          </div>
+
+          {/* ── Charts ────────────────────────────────────────────────────── */}
+          <div className="grid grid-cols-1 gap-6 xl:grid-cols-2">
+            <div className="card">
+              <h3 className="text-base font-semibold text-foreground">
+                Top schedules by estimated loss
+              </h3>
+              <p className="text-xs text-muted-foreground mt-1 mb-4">
+                Estimated loss in {chartCurrency}, largest first
+                {otherCurrencies.length > 0 && (
+                  <> · {otherCurrencies.join(", ")} shown in the table below</>
+                )}
+              </p>
+              {topSchedules.length === 0 ? (
+                <div className="h-[320px] flex items-center justify-center text-muted-foreground text-sm">
+                  No schedules in {chartCurrency} on this page
+                </div>
+              ) : (
+                <ResponsiveContainer width="100%" height={40 * topSchedules.length + 48}>
+                  <BarChart
+                    data={topSchedules}
+                    layout="vertical"
+                    margin={{ top: 4, right: 72, bottom: 8, left: 8 }}
+                    barCategoryGap="28%"
+                  >
+                    <CartesianGrid
+                      horizontal={false}
+                      stroke={palette.grid}
+                      strokeWidth={1}
+                    />
+                    <XAxis
+                      type="number"
+                      tick={{ fontSize: 11, fill: palette.textMuted }}
+                      tickFormatter={(v: number) => (v / 100).toLocaleString()}
+                      axisLine={{ stroke: palette.axis }}
+                      tickLine={false}
+                    />
+                    <YAxis
+                      type="category"
+                      dataKey="label"
+                      width={128}
+                      tick={{ fontSize: 11, fill: palette.textMuted }}
+                      axisLine={false}
+                      tickLine={false}
+                    />
+                    <RechartsTooltip
+                      cursor={{ fill: palette.grid, fillOpacity: 0.35 }}
+                      contentStyle={{
+                        background: palette.tooltipBg,
+                        border: `1px solid ${palette.tooltipBorder}`,
+                        borderRadius: 8,
+                        fontSize: 12,
+                      }}
+                      formatter={(value: number, name: string) => [
+                        formatCurrency(value, chartCurrency),
+                        name === "estimatedLossMinor" ? "Estimated" : "Adjusted",
+                      ]}
+                    />
+                    {/* One series, one hue — bar length already encodes magnitude. */}
+                    <Bar
+                      dataKey="estimatedLossMinor"
+                      fill={palette.sequential}
+                      radius={[0, 4, 4, 0]}
+                      maxBarSize={24}
+                      isAnimationActive={false}
+                      label={{
+                        position: "right",
+                        fontSize: 11,
+                        fill: palette.textMuted,
+                        formatter: (v: number) => formatCurrency(v, chartCurrency),
+                      }}
+                    />
+                  </BarChart>
+                </ResponsiveContainer>
+              )}
+            </div>
+
+            <div className="card">
+              <h3 className="text-base font-semibold text-foreground">
+                Where the loss comes from
+              </h3>
+              <p className="text-xs text-muted-foreground mt-1 mb-4">
+                Share of estimated loss by reason category, in {chartCurrency}
+              </p>
+
+              {/* Part-to-whole: one horizontal stacked bar, 2px surface gaps between
+                  segments (no borders), with a legend carrying identity in text. */}
+              <div
+                className="flex w-full h-7 rounded-md overflow-hidden"
+                role="img"
+                aria-label={`Estimated loss by reason category: ${reasonBreakdown
+                  .map((r) => `${reasonLabel(r.reasonCategory)} ${r.sharePercent.toFixed(0)}%`)
+                  .join(", ")}`}
+              >
+                {reasonBreakdown.map((r, i) => (
+                  <div
+                    key={r.reasonCategory}
+                    className="h-full"
+                    style={{
+                      width: `${r.sharePercent}%`,
+                      background: r.color,
+                      marginRight: i < reasonBreakdown.length - 1 ? 2 : 0,
+                    }}
+                    title={`${reasonLabel(r.reasonCategory)} — ${formatCurrency(
+                      r.estimatedLossMinor,
+                      r.currency,
+                    )}`}
+                  />
+                ))}
+              </div>
+
+              {/* Legend doubles as the table view — the numbers are never tooltip-gated. */}
+              <table className="w-full text-sm mt-4">
+                <thead>
+                  <tr className="text-xs uppercase tracking-wider text-muted-foreground">
+                    <th className="text-left font-medium py-2">Reason</th>
+                    <th className="text-right font-medium py-2">Seats</th>
+                    <th className="text-right font-medium py-2">Share</th>
+                    <th className="text-right font-medium py-2">Estimated loss</th>
+                  </tr>
+                </thead>
+                <tbody className="divide-y divide-border">
+                  {reasonBreakdown.map((r) => (
+                    <tr key={r.reasonCategory}>
+                      <td className="py-2">
+                        <span className="flex items-center gap-2">
+                          <span
+                            className="h-2.5 w-2.5 rounded-sm shrink-0"
+                            style={{ background: r.color }}
+                            aria-hidden="true"
+                          />
+                          <span className="text-foreground">
+                            {reasonLabel(r.reasonCategory)}
+                          </span>
+                        </span>
+                      </td>
+                      <td className="py-2 text-right tabular-nums text-muted-foreground">
+                        {r.count.toLocaleString()}
+                      </td>
+                      <td className="py-2 text-right tabular-nums text-muted-foreground">
+                        {r.sharePercent.toFixed(1)}%
+                      </td>
+                      <td className="py-2 text-right tabular-nums text-foreground font-medium">
+                        {formatCurrency(r.estimatedLossMinor, r.currency)}
+                      </td>
+                    </tr>
+                  ))}
+                </tbody>
+              </table>
+            </div>
+          </div>
+
+          {/* ── Schedule table with per-seat drill-down ───────────────────── */}
+          <div className="card p-0">
+            <div className="px-4 pt-4 pb-3 flex items-center justify-between gap-4 flex-wrap">
+              <h3 className="text-sm font-semibold uppercase tracking-wider text-muted-foreground">
+                Affected schedules
+              </h3>
+              <span className="text-xs text-muted-foreground">
+                Expand a row to see every blocked seat
+              </span>
+            </div>
+            <div className="overflow-x-auto">
+              <table className="w-full text-sm">
+                <thead className="bg-gray-50 dark:bg-gray-800">
+                  <tr>
+                    {[
+                      "Schedule",
+                      "Route",
+                      "Departure",
+                      "Blocked",
+                      "Blocked by",
+                      "Load factor",
+                      "Estimated loss",
+                      "Adjusted loss",
+                    ].map((h) => (
+                      <th
+                        key={h}
+                        className="px-4 py-3 text-left text-xs font-medium uppercase tracking-wider text-gray-500 dark:text-gray-400 whitespace-nowrap"
+                      >
+                        {h}
+                      </th>
+                    ))}
+                  </tr>
+                </thead>
+                <tbody className="bg-white dark:bg-gray-900 divide-y divide-gray-200 dark:divide-gray-700">
+                  {scheduleRows.map((row) => (
+                    <ScheduleRow
+                      key={row.scheduleId}
+                      row={row}
+                      expanded={expanded.has(row.scheduleId)}
+                      onToggle={() => toggleExpanded(row.scheduleId)}
+                    />
+                  ))}
+                  {scheduleRows.length === 0 && (
+                    <tr>
+                      <td
+                        colSpan={8}
+                        className="py-8 text-center text-sm text-muted-foreground"
+                      >
+                        No schedules on this page
+                      </td>
+                    </tr>
+                  )}
+                </tbody>
+              </table>
+            </div>
+            <Pagination
+              currentPage={page}
+              totalPages={totalPages}
+              onPageChange={(p) => {
+                setPage(p);
+                setExpanded(new Set());
+              }}
+            />
+          </div>
+        </div>
+      )}
+
+      {/* ── Methodology, verbatim from the API ──────────────────────────── */}
+      {data && (
+        <div className="card">
+          <button
+            type="button"
+            onClick={() => setShowMethodology((v) => !v)}
+            className="flex w-full items-center gap-2 text-left"
+            aria-expanded={showMethodology}
+          >
+            {showMethodology ? (
+              <ChevronDown className="h-4 w-4 text-muted-foreground" />
+            ) : (
+              <ChevronRight className="h-4 w-4 text-muted-foreground" />
+            )}
+            <Info className="h-4 w-4 text-muted-foreground" />
+            <span className="text-sm font-semibold text-foreground">
+              How this is calculated
+            </span>
+          </button>
+          {showMethodology && (
+            <div className="mt-4 space-y-4 text-sm text-muted-foreground">
+              <p className="leading-relaxed">{data.meta.methodology}</p>
+              <div>
+                <p className="font-medium text-foreground mb-2">What is excluded</p>
+                <ul className="list-disc pl-5 space-y-1">
+                  {data.meta.exclusions.map((e) => (
+                    <li key={e}>{e}</li>
+                  ))}
+                </ul>
+              </div>
+              <dl className="grid grid-cols-1 gap-x-6 gap-y-2 sm:grid-cols-2">
+                <div className="flex justify-between gap-4">
+                  <dt>Fares priced at nationality</dt>
+                  <dd className="text-foreground">{data.meta.nationalityAssumption}</dd>
+                </div>
+                <div className="flex justify-between gap-4">
+                  <dt>Departure window</dt>
+                  <dd className="text-foreground">
+                    {formatDateTime(data.meta.dateFrom)} — {formatDateTime(data.meta.dateTo)}
+                  </dd>
+                </div>
+                <div className="flex justify-between gap-4">
+                  <dt>Schedules affected</dt>
+                  <dd className="text-foreground tabular-nums">{data.meta.total}</dd>
+                </div>
+                <div className="flex justify-between gap-4">
+                  <dt>Schedules with no fare on file</dt>
+                  <dd className="text-foreground tabular-nums">
+                    {data.meta.schedulesWithoutFare}
+                  </dd>
+                </div>
+              </dl>
+              {data.meta.schedulesWithoutFare > 0 && (
+                <p className="text-xs">
+                  {data.meta.schedulesWithoutFare} schedule
+                  {data.meta.schedulesWithoutFare === 1 ? "" : "s"} could not be priced (no
+                  route and no fare rules). Their blocked seats are counted, but carry no
+                  monetary claim.
+                </p>
+              )}
+            </div>
+          )}
+        </div>
+      )}
+    </div>
+  );
+}
+
+// ── Schedule row + drill-down ───────────────────────────────────────────────
+
+function ScheduleRow({
+  row,
+  expanded,
+  onToggle,
+}: {
+  row: BlockedSeatLossSchedule;
+  expanded: boolean;
+  onToggle: () => void;
+}) {
+  return (
+    <>
+      <tr
+        className="hover:bg-gray-50 dark:hover:bg-gray-800 transition-colors cursor-pointer"
+        onClick={onToggle}
+      >
+        <td className="px-4 py-3 whitespace-nowrap">
+          <span className="flex items-center gap-2">
+            {expanded ? (
+              <ChevronDown className="h-4 w-4 text-muted-foreground shrink-0" />
+            ) : (
+              <ChevronRight className="h-4 w-4 text-muted-foreground shrink-0" />
+            )}
+            <span className="font-semibold text-foreground">{row.trainNumber}</span>
+            <Badge variant="status" status={row.status}>
+              {row.status}
+            </Badge>
+          </span>
+        </td>
+        <td className="px-4 py-3 text-xs text-muted-foreground whitespace-nowrap">
+          {row.originStation} → {row.destinationStation}
+        </td>
+        <td className="px-4 py-3 text-xs text-muted-foreground whitespace-nowrap">
+          {formatDateTime(row.departureAt)}
+        </td>
+        <td className="px-4 py-3 tabular-nums whitespace-nowrap">{row.blockedSeatCount}</td>
+        <td className="px-4 py-3 text-xs text-muted-foreground max-w-[12rem] truncate" title={row.blockedByNames.join(", ")}>
+          {row.blockedByNames.length > 1
+            ? `${row.blockedByNames[0]} +${row.blockedByNames.length - 1}`
+            : (row.blockedByNames[0] ?? "—")}
+        </td>
+        <td className="px-4 py-3 whitespace-nowrap text-xs text-muted-foreground tabular-nums">
+          {row.loadFactorPercent}%{" "}
+          <span className="opacity-70">
+            ({row.soldSeats}/{row.sellableSeats})
+          </span>
+        </td>
+        <td className="px-4 py-3 tabular-nums font-medium whitespace-nowrap">
+          {formatCurrency(row.estimatedLossMinor, row.currency)}
+        </td>
+        <td className="px-4 py-3 tabular-nums whitespace-nowrap text-muted-foreground">
+          {formatCurrency(row.adjustedLossMinor, row.currency)}
+        </td>
+      </tr>
+      {expanded && (
+        <tr>
+          <td colSpan={8} className="bg-gray-50/60 dark:bg-gray-800/40 px-4 py-4">
+            <BlockDetailTable blocks={row.blocks} />
+          </td>
+        </tr>
+      )}
+    </>
+  );
+}
+
+function BlockDetailTable({ blocks }: { blocks: BlockedSeatLossDetail[] }) {
+  const { paged, page, totalPages, setPage } = usePagination(blocks, 50);
+
+  return (
+    <div className="overflow-x-auto">
+      <table className="w-full text-xs">
+        <thead>
+          <tr className="text-[11px] uppercase tracking-wider text-muted-foreground">
+            {[
+              "Coach · Seat",
+              "Class",
+              "Scope",
+              "Reason",
+              "Blocked by",
+              "Approved by",
+              "Blocked at",
+              "Estimated loss",
+            ].map((h) => (
+              <th key={h} className="px-3 py-2 text-left font-medium whitespace-nowrap">
+                {h}
+              </th>
+            ))}
+          </tr>
+        </thead>
+        <tbody className="divide-y divide-border">
+          {paged.map((b) => (
+            <tr key={b.blockId}>
+              <td className="px-3 py-2 whitespace-nowrap font-medium text-foreground">
+                {b.coachNumber ?? "—"} · #{b.seatNumber ?? "—"}
+              </td>
+              <td className="px-3 py-2 whitespace-nowrap text-muted-foreground">
+                {b.seatClassName ?? "—"}
+              </td>
+              <td className="px-3 py-2 whitespace-nowrap">
+                <Badge>{b.blockType === "SCHEDULE" ? "Schedule" : "Global"}</Badge>
+              </td>
+              <td className="px-3 py-2 max-w-sm">
+                <span className="flex flex-col gap-1">
+                  <Badge className="w-fit">{reasonLabel(b.reasonCategory)}</Badge>
+                  <span className="text-muted-foreground break-words">{b.reason}</span>
+                </span>
+              </td>
+              <td className="px-3 py-2 whitespace-nowrap text-foreground">
+                {b.blockedByName ?? (b.blockedBy === "SYSTEM" ? "System" : "Unknown")}
+              </td>
+              <td className="px-3 py-2 whitespace-nowrap text-muted-foreground">
+                {b.approvedBy ?? "—"}
+              </td>
+              <td className="px-3 py-2 whitespace-nowrap text-muted-foreground">
+                {formatDateTime(b.blockedAt)}
+              </td>
+              <td className="px-3 py-2 whitespace-nowrap tabular-nums font-medium text-foreground">
+                {formatCurrency(b.estimatedLossMinor, b.currency)}
+              </td>
+            </tr>
+          ))}
+        </tbody>
+      </table>
+      {totalPages > 1 && (
+        <Pagination currentPage={page} totalPages={totalPages} onPageChange={setPage} />
+      )}
+    </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 f1289d24a..c2d3ef2db 100644
--- a/apps/edr-passenger-web/backoffice/src/app/seats/page.tsx
+++ b/apps/edr-passenger-web/backoffice/src/app/seats/page.tsx
@@ -9,6 +9,11 @@ import { PERMS } from '@/lib/permissions';
 import Modal from '@/components/ui/Modal';
 import ActionButton from '@/components/ui/ActionButton'
 import { Armchair, Lock, Unlock, Bed, X, RotateCcw, ChevronDown, Train, Wrench, Ticket as TicketIcon } from 'lucide-react';
+import {
+  SEAT_BLOCK_REASON_CATEGORIES,
+  SEAT_BLOCK_REASON_CATEGORY_LABELS,
+  SeatBlockReasonCategory,
+} from '@edr/types';
 
 export default function SeatsPage() {
   const [activeTab, setActiveTab] = useState<'route' | 'schedule'>('route');
@@ -19,9 +24,17 @@ export default function SeatsPage() {
   const [showRemoveModal, setShowRemoveModal] = useState(false);
   const [selectedSeat, setSelectedSeat] = useState<any>(null);
   const [blockReason, setBlockReason] = useState('');
+  // Reporting bucket for the block — drives the reason breakdown in the Blocked Seat
+  // Revenue Loss report. Free-text `reason` stays the operator's detail.
+  const [blockCategory, setBlockCategory] = useState<SeatBlockReasonCategory>(
+    SeatBlockReasonCategory.Other,
+  );
   const [showBlockCoachModal, setShowBlockCoachModal] = useState(false);
   const [selectedCoach, setSelectedCoach] = useState<any>(null);
   const [blockCoachReason, setBlockCoachReason] = useState('');
+  const [blockCoachCategory, setBlockCoachCategory] = useState<SeatBlockReasonCategory>(
+    SeatBlockReasonCategory.Other,
+  );
   const [showUnblockCoachModal, setShowUnblockCoachModal] = useState(false);
   const [coachToUnblock, setCoachToUnblock] = useState<any>(null);
   const [showMaintenanceModal, setShowMaintenanceModal] = useState(false);
@@ -110,13 +123,14 @@ export default function SeatsPage() {
   };
 
   const blockMutation = useMutation({
-    mutationFn: ({ seatId, reason }: any) =>
-      seatsApi.block(seatId, { reason, ...(activeTab === 'schedule' && selectedSchedule ? { scheduleId: selectedSchedule } : {}) }),
+    mutationFn: ({ seatId, reason, reasonCategory }: any) =>
+      seatsApi.block(seatId, { reason, reasonCategory, ...(activeTab === 'schedule' && selectedSchedule ? { scheduleId: selectedSchedule } : {}) }),
     onSuccess: () => {
       invalidateSeatData();
       setShowBlockModal(false);
       setSelectedSeat(null);
       setBlockReason('');
+      setBlockCategory(SeatBlockReasonCategory.Other);
     },
   });
 
@@ -186,17 +200,18 @@ export default function SeatsPage() {
   const coaches = activeTab === 'schedule' ? (seatMapData?.coaches || []) : (Array.isArray(routeCoachesData) ? routeCoachesData : []);
 
   const blockCoachMutation = useMutation({
-    mutationFn: async ({ coachId, reason }: any) => {
+    mutationFn: async ({ coachId, reason, reasonCategory }: any) => {
       const coachSeats = coaches.find((c: any) => c.id === coachId)?.seats || [];
       const seatIds = coachSeats.map((s: any) => s.id).filter((id: any) => id);
       const scheduleId = activeTab === 'schedule' ? selectedSchedule : undefined;
-      return Promise.all(seatIds.map((seatId: string) => seatsApi.block(seatId, { reason, ...(scheduleId ? { scheduleId } : {}) })));
+      return Promise.all(seatIds.map((seatId: string) => seatsApi.block(seatId, { reason, reasonCategory, ...(scheduleId ? { scheduleId } : {}) })));
     },
     onSuccess: () => {
       invalidateSeatData();
       setShowBlockCoachModal(false);
       setSelectedCoach(null);
       setBlockCoachReason('');
+      setBlockCoachCategory(SeatBlockReasonCategory.Other);
     },
   });
 
@@ -356,7 +371,7 @@ export default function SeatsPage() {
       alert('Please provide a reason for blocking');
       return;
     }
-    await blockCoachMutation.mutateAsync({ coachId: selectedCoach.id, reason: blockCoachReason });
+    await blockCoachMutation.mutateAsync({ coachId: selectedCoach.id, reason: blockCoachReason, reasonCategory: blockCoachCategory });
   };
 
   const submitBlock = async () => {
@@ -364,7 +379,7 @@ export default function SeatsPage() {
       alert('Please provide a reason for the reservation');
       return;
     }
-    await blockMutation.mutateAsync({ seatId: selectedSeat.id, reason: blockReason });
+    await blockMutation.mutateAsync({ seatId: selectedSeat.id, reason: blockReason, reasonCategory: blockCategory });
   };
 
   const submitRemoveSeat = async () => {
@@ -874,6 +889,23 @@ export default function SeatsPage() {
           <p className="text-sm text-muted-foreground">
             Reserve seat <strong>{selectedSeat?.seatNumber}</strong> in Coach <strong>{selectedSeat?.coach?.coachNumber}</strong>
           </p>
+          <div>
+            <label className="label">Reason Category</label>
+            <select
+              className="input"
+              value={blockCategory}
+              onChange={(e) => setBlockCategory(e.target.value as SeatBlockReasonCategory)}
+            >
+              {SEAT_BLOCK_REASON_CATEGORIES.map((c) => (
+                <option key={c} value={c}>
+                  {SEAT_BLOCK_REASON_CATEGORY_LABELS[c]}
+                </option>
+              ))}
+            </select>
+            <p className="text-xs text-muted-foreground mt-1">
+              Groups this block in the Blocked Seat Revenue Loss report.
+            </p>
+          </div>
           <div>
             <label className="label">Reason for Reservation *</label>
             <textarea
@@ -1150,6 +1182,20 @@ export default function SeatsPage() {
               This will block all {selectedCoach?.seats?.length || 0} seats in this coach.
             </p>
           </div>
+          <div>
+            <label className="label">Reason Category</label>
+            <select
+              className="input"
+              value={blockCoachCategory}
+              onChange={(e) => setBlockCoachCategory(e.target.value as SeatBlockReasonCategory)}
+            >
+              {SEAT_BLOCK_REASON_CATEGORIES.map((c) => (
+                <option key={c} value={c}>
+                  {SEAT_BLOCK_REASON_CATEGORY_LABELS[c]}
+                </option>
+              ))}
+            </select>
+          </div>
           <div>
             <label className="label">Reason for Blocking *</label>
             <textarea
diff --git a/apps/edr-passenger-web/backoffice/src/components/layout/Sidebar.tsx b/apps/edr-passenger-web/backoffice/src/components/layout/Sidebar.tsx
index 3c93538b9..616488917 100644
--- a/apps/edr-passenger-web/backoffice/src/components/layout/Sidebar.tsx
+++ b/apps/edr-passenger-web/backoffice/src/components/layout/Sidebar.tsx
@@ -33,6 +33,7 @@ import {
   Moon,
   Sun,
   Armchair,
+  Ban,
   Grid3x3,
   Banknote,
   Activity,
@@ -123,6 +124,7 @@ const navigationSections: { title: string; items: NavItem[] }[] = [
     items: [
       { name: 'Overall',              href: '/reports/overall',                icon: BarChart3,      permission: PERMS.reports.view },
       { name: 'Seats',               href: '/reports/seats',                  icon: Armchair,       permission: PERMS.reports.view },
+      { name: 'Blocked Seats',       href: '/reports/blocked-seats',          icon: Ban,            permission: PERMS.reports.view },
       { name: 'Passengers',          href: '/reports/passengers',             icon: Users,          permission: PERMS.reports.view },
       { name: 'Boarding',            href: '/reports/boarding',               icon: LogIn,          permission: PERMS.reports.view },
       { name: 'Payments',            href: '/reports/payments',               icon: CreditCard,     permission: PERMS.reports.view },
diff --git a/apps/edr-passenger-web/backoffice/src/lib/api/blocked-seats-loss.ts b/apps/edr-passenger-web/backoffice/src/lib/api/blocked-seats-loss.ts
new file mode 100644
index 000000000..b5fbd2ad3
--- /dev/null
+++ b/apps/edr-passenger-web/backoffice/src/lib/api/blocked-seats-loss.ts
@@ -0,0 +1,54 @@
+import { apiClient } from '@/lib/api-client';
+import type { BlockedSeatRevenueLossReport } from '@edr/types';
+
+/** One entry of `GET /reports/schedules`. */
+export interface ScheduleOption {
+  id: string;
+  label: string;
+  departureAt: string;
+  isPackage: boolean;
+}
+
+/** Every filter the report accepts. Empty strings are dropped before the request. */
+export interface BlockedSeatsLossFilters {
+  dateFrom?: string;
+  dateTo?: string;
+  scheduleId?: string;
+  routeId?: string;
+  trainId?: string;
+  coachId?: string;
+  reasonCategory?: string;
+  blockedBy?: string;
+  nationality?: string;
+  page?: number;
+  pageSize?: number;
+  sortBy?: string;
+}
+
+/** Serializes filters, omitting blanks so the API applies its own defaults. */
+export function toQueryString(filters: BlockedSeatsLossFilters): string {
+  const params = new URLSearchParams();
+  for (const [key, value] of Object.entries(filters)) {
+    if (value === undefined || value === null || value === '') continue;
+    params.set(key, String(value));
+  }
+  return params.toString();
+}
+
+export const blockedSeatsLossApi = {
+  getReport: (filters: BlockedSeatsLossFilters) =>
+    apiClient.get<BlockedSeatRevenueLossReport>(
+      `/reports/blocked-seats-revenue-loss?${toQueryString(filters)}`,
+    ),
+
+  getSchedules: () => apiClient.get<ScheduleOption[]>('/reports/schedules?all=true'),
+
+  /**
+   * CSV export. `getRaw` because the endpoint streams a bare CSV body with no
+   * `{ success, data }` envelope for `get` to unwrap.
+   */
+  exportCsv: (filters: BlockedSeatsLossFilters) =>
+    apiClient.getRaw<string>(
+      `/reports/blocked-seats-revenue-loss/export?${toQueryString(filters)}`,
+    ),
+};
diff --git a/apps/edr-passenger-web/backoffice/src/lib/api/dashboard.ts b/apps/edr-passenger-web/backoffice/src/lib/api/dashboard.ts
index bff0eaf08..0a9737041 100644
--- a/apps/edr-passenger-web/backoffice/src/lib/api/dashboard.ts
+++ b/apps/edr-passenger-web/backoffice/src/lib/api/dashboard.ts
@@ -1,4 +1,5 @@
 import { apiClient } from '@/lib/api-client';
+import type { BlockedSeatRevenueLossStat } from '@edr/types';
 import { DashboardStats, RevenueData } from '@/types';
 
 export const dashboardApi = {
@@ -12,6 +13,7 @@ export const dashboardApi = {
       totalPackageTickets: number;
       totalPassengers: number;
       blockedSeatsCount: number;
+      blockedSeatRevenueLoss: BlockedSeatRevenueLossStat;
       revenueByCurrency: { currency: string; totalMinor: number }[];
       packageRevenueByCurrency: { currency: string; totalMinor: number }[];
     }>('/dashboard/backoffice-stats');
diff --git a/apps/edr-passenger-web/backoffice/src/lib/chart-palette.ts b/apps/edr-passenger-web/backoffice/src/lib/chart-palette.ts
new file mode 100644
index 000000000..24c597a14
--- /dev/null
+++ b/apps/edr-passenger-web/backoffice/src/lib/chart-palette.ts
@@ -0,0 +1,66 @@
+/**
+ * Chart palette.
+ *
+ * Categorical slots are assigned in fixed order and never cycled — a series keeps its
+ * hue when a filter removes its neighbours. Both modes are separately stepped for their
+ * own surface, not an automatic flip of the light values.
+ *
+ * Validated against this app's card surfaces (light `#ffffff`, dark `#0f1729`) with the
+ * dataviz six-check validator, six slots, adjacent pairlist:
+ *   light — CVD ΔE 9.1, normal-vision ΔE 19.6, contrast WARN on aqua/yellow/magenta
+ *   dark  — CVD ΔE 8.4, normal-vision ΔE 19.3, contrast all ≥ 3:1
+ * The light-mode contrast WARN obliges *relief*: every chart using these slots ships a
+ * legend with visible text labels and a table view of the same numbers.
+ */
+
+export interface ChartPalette {
+  /** Categorical slots, in fixed assignment order. */
+  categorical: readonly string[];
+  /** Single hue for magnitude — one colour for every bar in a one-series chart. */
+  sequential: string;
+  /** Recessive chrome. */
+  grid: string;
+  axis: string;
+  /** Text tokens — labels never wear the data colour. */
+  textMuted: string;
+  /** Surface, for the 2px gaps and rings that separate marks. */
+  surface: string;
+  tooltipBg: string;
+  tooltipBorder: string;
+}
+
+const LIGHT: ChartPalette = {
+  categorical: ['#2a78d6', '#eb6834', '#1baf7a', '#eda100', '#e87ba4', '#008300'],
+  sequential: '#2a78d6',
+  grid: '#e1e0d9',
+  axis: '#c3c2b7',
+  textMuted: '#898781',
+  surface: '#ffffff',
+  tooltipBg: '#ffffff',
+  tooltipBorder: 'rgba(11,11,11,0.10)',
+};
+
+const DARK: ChartPalette = {
+  categorical: ['#3987e5', '#d95926', '#199e70', '#c98500', '#d55181', '#008300'],
+  sequential: '#3987e5',
+  grid: '#2c2c2a',
+  axis: '#383835',
+  textMuted: '#898781',
+  surface: '#0f1729',
+  tooltipBg: '#0f1729',
+  tooltipBorder: 'rgba(255,255,255,0.10)',
+};
+
+export function getChartPalette(isDark: boolean): ChartPalette {
+  return isDark ? DARK : LIGHT;
+}
+
+/**
+ * Colour for a categorical member, keyed by its position in a **stable** ordering of the
+ * whole domain — never by its rank in the current filtered view, so filtering does not
+ * repaint the survivors. Past the last slot everything folds into one neutral bucket
+ * rather than inventing a hue no CVD check would pass.
+ */
+export function categoricalColor(palette: ChartPalette, index: number): string {
+  return palette.categorical[index] ?? palette.textMuted;
+}
diff --git a/apps/edr-passenger-web/portal/src/app/booking/search/page.tsx b/apps/edr-passenger-web/portal/src/app/booking/search/page.tsx
index 9fbbde0e7..69d3859cf 100644
--- a/apps/edr-passenger-web/portal/src/app/booking/search/page.tsx
+++ b/apps/edr-passenger-web/portal/src/app/booking/search/page.tsx
@@ -727,11 +727,21 @@ export default function SearchPage() {
 
   const disabledDates = useMemo(() => {
     const set = new Set<string>();
+    // routeExists === false is handled by disabling the date control outright
+    // (noRouteForPair below), not by enumerating dates — the server returns an
+    // empty `dates` array in that case anyway.
     if (!availableDates?.routeExists) return set;
     for (const d of availableDates.dates) if (!d.available) set.add(d.date);
     return set;
   }, [availableDates]);
 
+  // No route connects the chosen From/To, so no date could ever produce a trip. The date
+  // picker is disabled outright rather than left selectable: graying out individual days
+  // would imply the date is the problem when the station pair is, and letting someone pick
+  // a date only to fail at submit wastes the interaction.
+  const noRouteForPair =
+    !!originId && !!destId && availableDates?.routeExists === false;
+
   // /search/available-dates only ever reports on a bounded window (server-clamped to 90 days —
   // see AVAILABLE_DATES_RANGE_DAYS). disabledDates alone can't gray out anything past that
   // window (it was simply never fetched, not confirmed available), so once a route is picked
@@ -758,6 +768,15 @@ export default function SearchPage() {
     }
   }, [departureDate, disabledDates, setValue, setError]);
 
+  // Losing the route invalidates any date already chosen — clear both legs so a stale value
+  // cannot be submitted from behind a now-disabled control.
+  useEffect(() => {
+    if (noRouteForPair && departureDate) {
+      setValue("departureDate", "");
+      clearErrors("departureDate");
+    }
+  }, [noRouteForPair, departureDate, setValue, clearErrors]);
+
   // Same idea as the departure-date availability above, but for the return leg — which travels
   // destination -> origin, the reverse pair. Only fetched for round trips once both stations are
   // picked; deliberately unaware of which specific outbound schedule will end up chosen (that's
@@ -789,6 +808,14 @@ export default function SearchPage() {
     return set;
   }, [returnAvailableDates]);
 
+  // The return leg travels destination → origin, so it has its own route-existence answer:
+  // a one-way route (A→C with no C→A) leaves the outbound date pickable but the return not.
+  const noReturnRouteForPair =
+    tripType === "ROUND_TRIP" &&
+    !!originId &&
+    !!destId &&
+    returnAvailableDates?.routeExists === false;
+
   const returnMaxDate = originId && destId && tripType === "ROUND_TRIP" ? maxSearchDate : undefined;
 
   // If the currently selected return date becomes unavailable (From/To changed, or the
@@ -805,6 +832,13 @@ export default function SearchPage() {
     }
   }, [returnDate, returnDisabledDates, setValue, setError]);
 
+  useEffect(() => {
+    if (noReturnRouteForPair && returnDate) {
+      setValue("returnDate", "");
+      clearErrors("returnDate");
+    }
+  }, [noReturnRouteForPair, returnDate, setValue, clearErrors]);
+
   const saveRecent = useCallback((id: string) => {
     setRecentStationIds((prev) => {
       const next = [id, ...prev.filter((x) => x !== id)].slice(0, 5);
@@ -1242,10 +1276,19 @@ export default function SearchPage() {
                                 minDate={new Date()}
                                 maxDate={departureMaxDate}
                                 disabledDates={disabledDates}
+                                disabled={noRouteForPair}
                                 placeholder="Departure date"
                                 error={!!errors.departureDate}
                               />
                             </div>
+                            {noRouteForPair && (
+                              <p
+                                data-testid="no-route-notice"
+                                className="text-xs text-amber-600 dark:text-amber-400"
+                              >
+                                No route connects these stations — pick a different destination.
+                              </p>
+                            )}
                             {errors.departureDate && (
                               <p className="text-xs text-red-500">
                                 {errors.departureDate.message}
@@ -1278,11 +1321,20 @@ export default function SearchPage() {
                                   }
                                   maxDate={returnMaxDate}
                                   disabledDates={returnDisabledDates}
+                                disabled={noReturnRouteForPair}
                                   placeholder="Return date"
                                   error={!!errors.returnDate}
                                 />
                               </div>
-                              {errors.returnDate && (
+                              {noReturnRouteForPair && (
+                              <p
+                                data-testid="no-return-route-notice"
+                                className="text-xs text-amber-600 dark:text-amber-400"
+                              >
+                                No return route from this destination.
+                              </p>
+                            )}
+                            {errors.returnDate && (
                                 <p className="text-xs text-red-500">
                                   {errors.returnDate.message}
                                 </p>
@@ -1436,11 +1488,20 @@ export default function SearchPage() {
                               minDate={new Date()}
                               maxDate={departureMaxDate}
                               disabledDates={disabledDates}
+                                disabled={noRouteForPair}
                               placeholder="Departure"
                               error={!!errors.departureDate}
                             />
                           </div>
-                          {errors.departureDate && (
+                          {noRouteForPair && (
+                              <p
+                                data-testid="no-route-notice"
+                                className="text-xs text-amber-600 dark:text-amber-400"
+                              >
+                                No route connects these stations — pick a different destination.
+                              </p>
+                            )}
+                            {errors.departureDate && (
                             <p className="text-xs text-red-500">
                               {errors.departureDate.message}
                             </p>
@@ -1592,9 +1653,18 @@ export default function SearchPage() {
                             minDate={new Date()}
                             maxDate={departureMaxDate}
                             disabledDates={disabledDates}
+                                disabled={noRouteForPair}
                             placeholder="Departure date"
                           />
-                          {errors.departureDate && (
+                          {noRouteForPair && (
+                              <p
+                                data-testid="no-route-notice"
+                                className="text-xs text-amber-600 dark:text-amber-400"
+                              >
+                                No route connects these stations — pick a different destination.
+                              </p>
+                            )}
+                            {errors.departureDate && (
                             <p className="text-xs text-red-500">
                               {errors.departureDate.message}
                             </p>
@@ -1625,9 +1695,18 @@ export default function SearchPage() {
                             }
                             maxDate={returnMaxDate}
                             disabledDates={returnDisabledDates}
+                                disabled={noReturnRouteForPair}
                             placeholder="Return date"
                           />
-                          {errors.returnDate && (
+                          {noReturnRouteForPair && (
+                              <p
+                                data-testid="no-return-route-notice"
+                                className="text-xs text-amber-600 dark:text-amber-400"
+                              >
+                                No return route from this destination.
+                              </p>
+                            )}
+                            {errors.returnDate && (
                             <p className="text-xs text-red-500">
                               {errors.returnDate.message}
                             </p>
diff --git a/apps/edr-passenger-web/portal/src/components/ModernDatePicker.tsx b/apps/edr-passenger-web/portal/src/components/ModernDatePicker.tsx
index 0d81bba3b..97cacd8a5 100644
--- a/apps/edr-passenger-web/portal/src/components/ModernDatePicker.tsx
+++ b/apps/edr-passenger-web/portal/src/components/ModernDatePicker.tsx
@@ -21,6 +21,12 @@ interface ModernDatePickerProps {
   // Dates with no bookable schedule for the selected route (YYYY-MM-DD keys) — disabled
   // alongside the minDate/maxDate range, not just clamping it.
   disabledDates?: Set<string>;
+  /**
+   * Disables the whole control — the calendar cannot be opened at all. Used when no route
+   * exists between the selected stations, where every date is unselectable and graying out
+   * individual days would be misleading (the problem is the route, not the date).
+   */
+  disabled?: boolean;
   placeholder?: string;
   error?: boolean;
 }
@@ -38,6 +44,7 @@ export default function ModernDatePicker({
   minDate,
   maxDate,
   disabledDates,
+  disabled = false,
   placeholder = 'Select date',
   error = false,
 }: ModernDatePickerProps) {
@@ -52,6 +59,13 @@ export default function ModernDatePicker({
   const [ethViewYear, setEthViewYear] = useState(initialEthDate.year);
   const containerRef = useRef<HTMLDivElement>(null);
 
+  // If the control becomes disabled while the calendar is open (e.g. the user changes
+  // the destination to one with no route), close it rather than leaving a live calendar
+  // floating over a disabled field.
+  useEffect(() => {
+    if (disabled) setIsOpen(false);
+  }, [disabled]);
+
   useEffect(() => {
     const check = () => setIsMobileView(window.innerWidth < 768);
     check();
@@ -297,8 +311,10 @@ export default function ModernDatePicker({
       {/* Trigger button */}
       <button
         type="button"
-        onClick={() => setIsOpen(true)}
-        className={`w-full min-w-0 px-2.5 sm:px-3.5 py-3.5 border-2 rounded-xl focus:outline-none focus:ring-2 focus:ring-primary/30 focus:border-primary text-left flex items-center justify-between gap-1.5 bg-white dark:bg-gray-800 transition-all group ${
+        onClick={() => !disabled && setIsOpen(true)}
+        disabled={disabled}
+        aria-disabled={disabled}
+        className={`w-full min-w-0 px-2.5 sm:px-3.5 py-3.5 border-2 rounded-xl focus:outline-none focus:ring-2 focus:ring-primary/30 focus:border-primary text-left flex items-center justify-between gap-1.5 bg-white dark:bg-gray-800 transition-all group disabled:opacity-60 disabled:cursor-not-allowed disabled:hover:border-gray-200 dark:disabled:hover:border-gray-700 ${
           error
             ? 'border-red-400 hover:border-red-400'
             : 'border-gray-200 dark:border-gray-700 hover:border-gray-300 dark:hover:border-gray-600'
diff --git a/apps/edr-passenger-web/portal/src/components/SearchWidget.tsx b/apps/edr-passenger-web/portal/src/components/SearchWidget.tsx
index 33fea2bee..fd55e8be1 100644
--- a/apps/edr-passenger-web/portal/src/components/SearchWidget.tsx
+++ b/apps/edr-passenger-web/portal/src/components/SearchWidget.tsx
@@ -195,11 +195,20 @@ export function SearchWidget({ fullWidth = false, onSearch }: SearchWidgetProps)
   const disabledDates = useMemo(() => {
     const set = new Set<string>();
     if (!availableDates) return set;
-    if (!availableDates.routeExists) return set; // no route → don't blanket-disable every date, the submit-time error already covers this
+    // routeExists === false is handled by disabling the whole control (noRouteForPair below)
+    // rather than by enumerating every date as unavailable — the server returns an empty
+    // `dates` array in that case anyway.
+    if (!availableDates.routeExists) return set;
     for (const d of availableDates.dates) if (!d.available) set.add(d.date);
     return set;
   }, [availableDates]);
 
+  // No route connects the chosen stations, so no date could ever yield a trip. The date
+  // field is disabled outright: letting someone pick a date and only telling them after
+  // they submit wastes the interaction, and graying out individual days would imply the
+  // date is the problem when the station pair is.
+  const noRouteForPair = !!originId && !!destinationId && availableDates?.routeExists === false;
+
   // /search/available-dates only ever reports on a bounded window (server-clamped to 90 days —
   // see AVAILABLE_DATES_RANGE_DAYS). disabledDates alone can't gray out anything past that
   // window (it was simply never fetched, not confirmed available), so once a route is picked
@@ -225,6 +234,15 @@ export function SearchWidget({ fullWidth = false, onSearch }: SearchWidgetProps)
     }
   }, [departureDate, disabledDates, setValue, setError]);
 
+  // Losing the route invalidates any date already chosen — clear it so a stale value can't
+  // be submitted from behind the now-disabled control.
+  useEffect(() => {
+    if (noRouteForPair && departureDate) {
+      setValue('departureDate', '');
+      clearErrors('departureDate');
+    }
+  }, [noRouteForPair, departureDate, setValue, clearErrors]);
+
   const onSubmit = (data: SearchForm) => {
     setSearchCriteria({ ...data });
     const params = new URLSearchParams({
@@ -283,18 +301,29 @@ export function SearchWidget({ fullWidth = false, onSearch }: SearchWidgetProps)
             {/* Date */}
             <div className="space-y-2">
               <label className="block text-sm font-medium text-gray-700 dark:text-gray-300">Date</label>
-              <ModernDatePicker
-                value={departureDate ? new Date(departureDate + 'T00:00:00') : undefined}
-                onChange={(date) => {
-                  setValue('departureDate', toDateStr(date));
-                  clearErrors('departureDate');
-                }}
-                minDate={new Date()}
-                maxDate={departureMaxDate}
-                disabledDates={disabledDates}
-                placeholder="Select date"
-              />
-              {errors.departureDate && (
+              <div data-testid="departure-date-field">
+                <ModernDatePicker
+                  value={departureDate ? new Date(departureDate + 'T00:00:00') : undefined}
+                  onChange={(date) => {
+                    setValue('departureDate', toDateStr(date));
+                    clearErrors('departureDate');
+                  }}
+                  minDate={new Date()}
+                  maxDate={departureMaxDate}
+                  disabledDates={disabledDates}
+                  disabled={noRouteForPair}
+                  placeholder={noRouteForPair ? 'No route available' : 'Select date'}
+                />
+              </div>
+              {noRouteForPair && (
+                <p
+                  data-testid="no-route-notice"
+                  className="text-amber-600 dark:text-amber-400 text-sm"
+                >
+                  No route connects these stations — pick a different destination.
+                </p>
+              )}
+              {!noRouteForPair && errors.departureDate && (
                 <p className="text-red-600 dark:text-red-400 text-sm">{errors.departureDate.message}</p>
               )}
             </div>
diff --git a/docker-compose.e2e.yaml b/docker-compose.e2e.yaml
index 20578fe56..4df2cc1e4 100644
--- a/docker-compose.e2e.yaml
+++ b/docker-compose.e2e.yaml
@@ -324,6 +324,8 @@ services:
       CYPRESS_BASE_URL: http://localhost:${E2E_BACKOFFICE_PORT:-5383}
       CYPRESS_API_URL: http://localhost:${E2E_API_PORT:-3101}
       CYPRESS_PORTAL_URL: http://localhost:${E2E_PORTAL_PORT:-5373}
+      # Must match freight-api-e2e's SERVICE_AUTH_TOKEN above.
+      CYPRESS_SERVICE_AUTH_TOKEN: e2e-service-token
     volumes:
       - .:/repo
 
diff --git a/e2e-ui-report/index.html b/e2e-ui-report/index.html
index 2a7cc27fd..3a1ba110f 100644
--- a/e2e-ui-report/index.html
+++ b/e2e-ui-report/index.html
@@ -87,4 +87,4 @@ Error generating stack: `+l.message+`
     <div id='root'></div>
   </body>
 </html>
-<template id="playwrightReportBase64">data:application/zip;base64,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</template>
\ No newline at end of file
+<template id="playwrightReportBase64">data:application/zip;base64,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</template>
\ No newline at end of file
diff --git a/e2e-ui/specs/guest/search-date-availability.spec.ts b/e2e-ui/specs/guest/search-date-availability.spec.ts
new file mode 100644
index 000000000..1b09296c3
--- /dev/null
+++ b/e2e-ui/specs/guest/search-date-availability.spec.ts
@@ -0,0 +1,136 @@
+import { test, expect, type Page } from "@playwright/test";
+import { API_URL, STATIONS, staffToken } from "../../fixtures/data";
+
+/**
+ * Search form — date selectability is driven by whether a route actually exists.
+ *
+ * Two behaviours, both backed by GET /search/available-dates:
+ *
+ *   1. No route between the selected From/To → the Date control is DISABLED outright and an
+ *      explanation is shown. Letting someone pick a date and only failing at submit wastes the
+ *      interaction, and graying out individual days would imply the date is the problem when
+ *      the station pair is.
+ *   2. A route exists → the control is enabled, and only the days with no bookable schedule
+ *      are individually disabled inside the calendar.
+ *
+ * The form prefills From/To from the URL query (see booking/search/page.tsx), so these specs set
+ * the pair deterministically instead of driving the station modal across three layout variants.
+ *
+ * Runs in the `guest` project — the search form needs no authentication.
+ */
+
+/** A station on no route at all — created per-run so the shared seed stays untouched. */
+async function createOrphanStation(request: Page["request"]): Promise<string> {
+  const res = await request.post(`${API_URL}/stations`, {
+    headers: { Authorization: `Bearer ${staffToken()}` },
+    data: {
+      code: `ORP${Date.now().toString().slice(-4)}`,
+      name: `Orphan ${Date.now()}`,
+      city: "Nowhere",
+    },
+  });
+  expect(res.ok(), `station create failed: ${res.status()} ${await res.text()}`).toBeTruthy();
+  const body = await res.json();
+  return body?.data?.id ?? body?.id;
+}
+
+function searchUrl(origin: string, destination: string): string {
+  return `/booking/search?origin=${origin}&destination=${destination}`;
+}
+
+/** The departure-date trigger. Several layout variants exist; only one is visible at a time. */
+function dateTrigger(page: Page) {
+  return page
+    .locator("button")
+    .filter({ hasText: /^(Departure date|Departure|Select date|Date)$/i })
+    .first();
+}
+
+test.describe("search date availability", () => {
+  test("no route between the stations disables the date picker", async ({ page, request }) => {
+    const orphanId = await createOrphanStation(request);
+
+    await page.goto(searchUrl(STATIONS.A, orphanId), { waitUntil: "domcontentloaded" });
+
+    // The notice only renders once /search/available-dates has answered routeExists:false.
+    await expect(page.getByTestId("no-route-notice").first()).toBeVisible({ timeout: 20_000 });
+    await expect(dateTrigger(page)).toBeDisabled();
+  });
+
+  test("a disabled date picker cannot be opened", async ({ page, request }) => {
+    const orphanId = await createOrphanStation(request);
+
+    await page.goto(searchUrl(STATIONS.A, orphanId), { waitUntil: "domcontentloaded" });
+    await expect(page.getByTestId("no-route-notice").first()).toBeVisible({ timeout: 20_000 });
+
+    // force:true bypasses Playwright's own actionability guard, so this asserts the app
+    // really refuses to open — not merely that the button looks unclickable.
+    await dateTrigger(page).click({ force: true }).catch(() => {});
+    await page.waitForTimeout(500);
+    await expect(page.getByRole("button", { name: /^\d{1,2}$/ })).toHaveCount(0);
+  });
+
+  test("a route that exists leaves the date picker enabled and openable", async ({ page }) => {
+    await page.goto(searchUrl(STATIONS.A, STATIONS.C), { waitUntil: "domcontentloaded" });
+
+    // Give the availability query the same chance to resolve as the no-route case gets.
+    await page.waitForTimeout(3_000);
+    await expect(page.getByTestId("no-route-notice")).toHaveCount(0);
+
+    const trigger = dateTrigger(page);
+    await expect(trigger).toBeEnabled();
+    await trigger.click();
+    // Calendar day cells confirm it actually opened.
+    await expect(page.getByRole("button", { name: /^\d{1,2}$/ }).first()).toBeVisible({
+      timeout: 10_000,
+    });
+  });
+
+  test("dates with no bookable schedule are individually disabled", async ({ page }) => {
+    await page.goto(searchUrl(STATIONS.A, STATIONS.C), { waitUntil: "domcontentloaded" });
+    await page.waitForTimeout(3_000);
+
+    await dateTrigger(page).click();
+    const dayCells = page.getByRole("button", { name: /^\d{1,2}$/ });
+    await expect(dayCells.first()).toBeVisible({ timeout: 10_000 });
+
+    // The seed creates exactly one bookable departure in the window, so the calendar must
+    // contain both enabled and disabled days — never all-enabled (which would mean the
+    // availability data was ignored) and never all-disabled (which would mean it was
+    // misapplied to a route that does have a trip).
+    const total = await dayCells.count();
+    let disabled = 0;
+    for (let i = 0; i < total; i++) {
+      if (await dayCells.nth(i).isDisabled()) disabled++;
+    }
+    expect(total).toBeGreaterThan(0);
+    expect(disabled).toBeGreaterThan(0);
+    expect(disabled).toBeLessThan(total);
+  });
+
+  test("switching to a routeless destination clears an already-chosen date", async ({
+    page,
+    request,
+  }) => {
+    const orphanId = await createOrphanStation(request);
+
+    // Start on a valid pair with a date already in the URL, so a value is definitely set.
+    const withDate = new Date();
+    withDate.setDate(withDate.getDate() + 2);
+    const dateStr = withDate.toISOString().slice(0, 10);
+    await page.goto(`${searchUrl(STATIONS.A, STATIONS.C)}&date=${dateStr}`, {
+      waitUntil: "domcontentloaded",
+    });
+    await page.waitForTimeout(2_500);
+
+    // Now navigate to the routeless pair — the stale date must not survive behind the
+    // disabled control, or a doomed search could still be submitted.
+    await page.goto(searchUrl(STATIONS.A, orphanId), { waitUntil: "domcontentloaded" });
+    await expect(page.getByTestId("no-route-notice").first()).toBeVisible({ timeout: 20_000 });
+
+    const trigger = dateTrigger(page);
+    await expect(trigger).toBeDisabled();
+    // Placeholder text (not a formatted date) proves the value was cleared.
+    await expect(trigger).not.toContainText(/\d{4}/);
+  });
+});
diff --git a/e2e/freight/cypress.config.ts b/e2e/freight/cypress.config.ts
index 5abf08477..27451c049 100644
--- a/e2e/freight/cypress.config.ts
+++ b/e2e/freight/cypress.config.ts
@@ -42,6 +42,8 @@ export default defineConfig({
       defaultPassword: process.env.CYPRESS_DEFAULT_PASSWORD ?? "password@tria",
       // Demo portal users: hardcoded in DemoUsersSeeder.
       demoPassword: "12345678",
+      // Shared secret for /api/internal/* — SERVICE_AUTH_TOKEN in docker-compose.e2e.yaml.
+      serviceAuthToken: process.env.CYPRESS_SERVICE_AUTH_TOKEN ?? "e2e-service-token",
     },
     setupNodeEvents(on) {
       const dbUrl =
diff --git a/e2e/freight/cypress/e2e/flows/export_one_time.cy.ts b/e2e/freight/cypress/e2e/flows/export_one_time.cy.ts
index eaba7c298..7435594e2 100644
--- a/e2e/freight/cypress/e2e/flows/export_one_time.cy.ts
+++ b/e2e/freight/cypress/e2e/flows/export_one_time.cy.ts
@@ -450,6 +450,11 @@ describe("export one-time journeys: container + bulk on one train", { retries: 0
       cy.task("db:query", {
         sql: `UPDATE freight.train_schedules
               SET window_opens_at = LEAST(window_opens_at, now()),
+                  -- The e2e rules run a 1.002-minute window duration, so the
+                  -- CREATE-time close for a departing-today schedule is already
+                  -- in the past — hold the close out or the next 10s tick slams
+                  -- the window shut mid-flow.
+                  window_closes_at = GREATEST(window_closes_at, now() + interval '45 minutes'),
                   window_phase = 'OPEN',
                   booking_window_status = 'OPEN'
               WHERE id = $1 AND booking_window_status <> 'FULL'`,
diff --git a/e2e/freight/cypress/e2e/flows/g1-utils.ts b/e2e/freight/cypress/e2e/flows/g1-utils.ts
index c2631431d..4edc5804d 100644
--- a/e2e/freight/cypress/e2e/flows/g1-utils.ts
+++ b/e2e/freight/cypress/e2e/flows/g1-utils.ts
@@ -37,6 +37,7 @@ import {
   db,
   dbSchedule,
   forceWindowOpen,
+  holdPayWindows,
   opsStaff,
   ORIGIN,
   pollDb,
@@ -190,8 +191,35 @@ export function closeWindowAndRunBatch(departure: Date) {
 
   cy.loginBackoffice(opsStaff);
   withSchedule(departure, (s) => cy.visit(`/dashboard/operations/batch-board/${s.id}`));
-  cy.contains("Doc review", { timeout: 120000 }).should("exist");
-  cy.contains("button", "Doc review complete — run batch", { timeout: 120000 }).click();
+  // The e2e rules run a 1-MINUTE doc review, and the login + visit above can
+  // outlive it — the tick then runs the batch itself and the button never
+  // renders. Click the button while the phase is still DOC_REVIEW; once the
+  // engine has advanced on its own there is nothing left to click, and the
+  // poll below asserts the batch ran either way.
+  withSchedule(departure, (s) => {
+    const tryRunBatch = (attempt: number): void => {
+      db<{ p: string }>(
+        `SELECT window_phase AS p FROM freight.train_schedules WHERE id = $1`,
+        [s.id],
+      ).then(({ rows }) => {
+        if (rows[0].p !== "DOC_REVIEW") return; // tick already ran the batch
+        cy.get("body").then(($body) => {
+          const button = $body.find(
+            'button:contains("Doc review complete — run batch")',
+          );
+          if (button.length > 0) {
+            cy.wrap(button.first()).click({ force: true });
+            return;
+          }
+          expect(attempt, "batch board rendered its doc-review action").to.be.lessThan(
+            20,
+          );
+          cy.wait(3000, { log: false }).then(() => tryRunBatch(attempt + 1));
+        });
+      });
+    };
+    tryRunBatch(0);
+  });
 
   withSchedule(departure, (s) =>
     pollDb<ScheduleRow>(
@@ -199,10 +227,16 @@ export function closeWindowAndRunBatch(departure: Date) {
       `SELECT window_phase FROM freight.train_schedules WHERE id = $1`,
       [s.id],
       // DONE when the batch reserved nobody — itself a scenario outcome.
-      (row) => !!row && ["PAYMENT", "DONE"].includes(row.window_phase as string),
+      // PRE_WINDOW/OPEN when an under-filled day concluded and re-opened for
+      // its next cycle (window duration is 1 minute in e2e).
+      (row) =>
+        !!row &&
+        ["PAYMENT", "DONE", "PRE_WINDOW", "OPEN"].includes(row.window_phase as string),
       20,
     ),
   );
+  // The batch stamped 1-minute pay windows; hold them while the spec pays.
+  holdPayWindows();
 }
 
 /**
@@ -224,6 +258,15 @@ export function expectBoard(
   cy.loginBackoffice(opsStaff);
   withSchedule(departure, (s) => cy.visit(`/dashboard/operations/batch-board/${s.id}`));
   cy.contains(/Priority Tracking/, { timeout: 120000 }).click();
+  // While a window is OPEN the tab defaults to the Forecast view (an
+  // under-filled day re-opens for its next cycle — g1_s3's core scenario) and
+  // the live lanes are hidden behind the "Live state" toggle. On settled
+  // boards the toggle is not rendered at all, so only click it when present.
+  cy.contains(/Priority ranking|Live state/, { timeout: 120000 })
+    .invoke("text")
+    .then((text) => {
+      if (text.includes("Live state")) cy.contains("Live state").click();
+    });
   cy.contains("Priority ranking", { timeout: 120000 }).should("be.visible");
 
   if (opts.inBatch !== undefined) {
diff --git a/e2e/freight/cypress/e2e/flows/g1_s3_underfill_day_stays_open.cy.ts b/e2e/freight/cypress/e2e/flows/g1_s3_underfill_day_stays_open.cy.ts
index 0f925eb14..75ae1a6b3 100644
--- a/e2e/freight/cypress/e2e/flows/g1_s3_underfill_day_stays_open.cy.ts
+++ b/e2e/freight/cypress/e2e/flows/g1_s3_underfill_day_stays_open.cy.ts
@@ -91,7 +91,17 @@ describe("G1·S3: an under-filled train keeps its day open", { retries: 0 }, ()
     configureAndOpenSchedule({ departure: DEPARTURE });
   });
 
-  it("A and B book through the API; C books 24×20FT through the portal", () => {
+  // The API bookings and the portal booking are SEPARATE tests on purpose.
+  // cy.loginPortal's cross-origin visit makes Cypress reload the runner,
+  // re-evaluate the bundle (re-running `before()` and regenerating the
+  // module-scope stamp) and restart the CURRENT test from the top. With A and
+  // B in the same test as the portal visit they were booked twice — once per
+  // pass, under two stamps, even on a freshly wiped DB — and the orphaned
+  // first pair expired at payment end, corrupting the board counts and the
+  // free-wagon arithmetic. In their own test the completed API step is never
+  // re-entered; the restart only repeats the login. Same structure as g1_s2,
+  // which is why that spec never double-booked.
+  it("A and B book through the API", () => {
     let isoSeed = 8600;
     (["A", "B"] as const).forEach((suffix) => {
       const shape = SHAPES[suffix];
@@ -105,8 +115,12 @@ describe("G1·S3: an under-filled train keeps its day open", { retries: 0 }, ()
       });
       isoSeed += shape.twenty + shape.forty;
     });
+  });
 
+  it("C books 24×20FT through the portal shipment form", () => {
     cy.loginPortal(customer);
+    // dbContractId picks the NEWEST *-C contract, so the duplicate seeded by
+    // the reload's before() pass is inert.
     dbContractId("C").then((contractId) => {
       bookContainersVisually({
         contractId,
diff --git a/e2e/freight/cypress/e2e/flows/import-utils.ts b/e2e/freight/cypress/e2e/flows/import-utils.ts
index 5337d9f9c..94b871412 100644
--- a/e2e/freight/cypress/e2e/flows/import-utils.ts
+++ b/e2e/freight/cypress/e2e/flows/import-utils.ts
@@ -640,8 +640,47 @@ export function expectClearanceOnBookingInvoice(suffix: string) {
   );
 }
 
+/**
+ * Push every still-unpaid fixture reservation's pay deadline out 10 minutes.
+ *
+ * The e2e rules run a 1-MINUTE payment window (seed-import-corridor.sql), and
+ * a spec's pay loop — login, settle, poll, per booking — always outlives it:
+ * without this the 10s tick expires the holds the spec is queued up to pay.
+ * Called right after the batch reserves (completeDocReview,
+ * closeWindowAndRunBatch), after an export FCFS accept, and again before each
+ * payment. Blanket over CTR-IMP-% on purpose: specs run one at a time, and the
+ * first payment must rescue its yet-unpaid siblings, whichever schedule they
+ * reserved onto.
+ *
+ * Two invariants preserved:
+ *  - export parity ("the pay window never outlives the window close"): while a
+ *    booking's window is still open, the extension clamps to window_closes_at;
+ *  - expiry scenarios: specs that TEST expiry pull deadlines back into the
+ *    past afterwards (forceReservationExpiry / forceOfferLapse), and
+ *    endPaymentPhase now expires its schedule's unpaid holds itself — so the
+ *    extension never masks an expiry.
+ */
+export function holdPayWindows() {
+  db(
+    `UPDATE freight.bookings b
+     SET payment_deadline = LEAST(
+           now() + interval '10 minutes',
+           COALESCE(
+             (SELECT ts.window_closes_at FROM freight.train_schedules ts
+              WHERE ts.id = b.train_schedule_id
+                AND ts.window_closes_at > now()),
+             now() + interval '10 minutes'))
+     FROM freight.contracts ct
+     WHERE ct.id = b.contract_id AND ct.reference LIKE 'CTR-IMP-%'
+       AND b.deleted_at IS NULL
+       AND b.status IN ('SELECTED_FOR_BATCH', 'AWAITING_PAYMENT')
+       AND b.payment_deadline IS NOT NULL`,
+  );
+}
+
 /** Staff force-pay; polls PAID + SCHEDULED. */
 export function markPaid(suffix: string) {
+  holdPayWindows();
   withBooking(suffix, (b) => {
     apiPost(opsStaff, `/api/train-scheduling/bookings/${b.id}/mark-paid`)
       .its("status")
@@ -668,6 +707,7 @@ export function markPaid(suffix: string) {
  * path that applies a pending split offer (staff mark-paid skips it).
  */
 export function settleViaGateway(suffix: string) {
+  holdPayWindows();
   withBooking(suffix, (b) => {
     db<{ intent_id: string; currency: string; total: string }>(
       `WITH inv AS (
@@ -698,6 +738,9 @@ export function settleViaGateway(suffix: string) {
       cy.request({
         method: "POST",
         url: `${apiUrl()}/api/internal/payments/mark-paid`,
+        headers: {
+          "x-service-token": Cypress.env("serviceAuthToken") as string,
+        },
         body: {
           version: 1,
           eventId: crypto.randomUUID(),
@@ -917,6 +960,25 @@ export function resetCorridorDay(departure: Date, destCode = DEST, originCode =
        AND b.scheduled_date = $1::date`,
     [eatDayStr(departure)],
   );
+  // Finally, soft-delete every remaining unpinned fixture booking on the day.
+  // Reset runs before the current run books anything, so all of them are
+  // prior-run debris — and merely leaving them unpinned is not enough:
+  //  - EXPIRED ones render in the board's "Expired" lane (it lists by DAY),
+  //    so `expired: 0` could never pass against a warm DB;
+  //  - PAID ones sit in the day pool, and when an under-filled day re-opens
+  //    for its next cycle the engine's batch fill re-links them to the LIVE
+  //    schedule mid-run — observed as 15 ghosts re-pinned within one second,
+  //    inflating "In the batch (N)" past what the spec created.
+  db(
+    `UPDATE freight.bookings b
+     SET deleted_at = now()
+     FROM freight.contracts ct
+     WHERE ct.id = b.contract_id AND ct.reference LIKE 'CTR-IMP-%'
+       AND b.deleted_at IS NULL
+       AND b.train_schedule_id IS NULL
+       AND b.scheduled_date = $1::date`,
+    [eatDayStr(departure)],
+  );
 }
 
 /** Create the reversed 6-stop corridor (ET → DJ = EXPORT) if missing. */
@@ -959,6 +1021,10 @@ export function acceptExport(suffix: string) {
       .should("be.oneOf", [200, 201]);
   });
   pollBookingStatus(suffix, ["SELECTED_FOR_BATCH", "AWAITING_PAYMENT"], 10);
+  // The accept stamped a 1-minute pay window (export_payment_window_minutes);
+  // a spec accepting several bookings would lose the first before the last is
+  // even accepted. Still clamped to the window close — see holdPayWindows.
+  holdPayWindows();
 }
 
 export interface ScheduleRow {
@@ -1228,18 +1294,54 @@ export function closeBookingWindow(scheduleId: string) {
  * (Lands on DONE instead when the batch reserved nobody.)
  */
 export function completeDocReview(scheduleId: string) {
-  apiPost(opsStaff, `/api/train-scheduling/schedules/${scheduleId}/doc-review-complete`)
-    .its("status")
-    .should("be.oneOf", [200, 201]);
+  apiPost(
+    opsStaff,
+    `/api/train-scheduling/schedules/${scheduleId}/doc-review-complete`,
+    undefined,
+    false,
+  ).then((res) => {
+    if (res.status >= 400) {
+      // The e2e rules run a 1-MINUTE doc review: the tick may have run the
+      // batch on its own while the spec was still logging in or asserting.
+      // That is the engine doing the right thing on schedule — but a 4xx with
+      // the phase still stuck in DOC_REVIEW is a real failure.
+      db<{ p: string }>(
+        `SELECT window_phase AS p FROM freight.train_schedules WHERE id = $1`,
+        [scheduleId],
+      ).then(({ rows }) => {
+        expect(
+          rows[0]?.p,
+          `doc-review-complete ${res.status} — engine advanced on its own`,
+        ).to.be.oneOf(["PAYMENT", "DONE", "PRE_WINDOW", "OPEN"]);
+      });
+    }
+  });
   pollSchedulePhase(
     scheduleId,
-    ["PAYMENT", "DONE", "PRE_WINDOW"],
+    // OPEN: with a 1-minute window duration an under-filled day can already
+    // have re-opened for its next cycle by the first poll read.
+    ["PAYMENT", "DONE", "PRE_WINDOW", "OPEN"],
     `schedule ${scheduleId} payment phase`,
   );
+  holdPayWindows();
 }
 
 /** End the payment phase now — the tick settles (allocate paid / expire unpaid). */
 export function endPaymentPhase(scheduleId: string) {
+  // holdPayWindows pushed the unpaid holds' own deadlines out so a pay loop
+  // could outlive the 1-minute window; ending the phase means those holds must
+  // now expire, so pull them back first — the settle only expires reservations
+  // whose OWN deadline has passed, and holds the cycle open for the rest.
+  db(
+    `UPDATE freight.bookings b
+     SET payment_deadline = now() - interval '1 second'
+     FROM freight.contracts ct
+     WHERE ct.id = b.contract_id AND ct.reference LIKE 'CTR-IMP-%'
+       AND b.deleted_at IS NULL
+       AND b.train_schedule_id = $1
+       AND b.status IN ('SELECTED_FOR_BATCH', 'AWAITING_PAYMENT')`,
+    [scheduleId],
+  );
   db(
     `UPDATE freight.train_schedules
      SET payment_phase_ends_at = now() - interval '1 second'
diff --git a/e2e/freight/cypress/e2e/flows/segment_weight.cy.ts b/e2e/freight/cypress/e2e/flows/segment_weight.cy.ts
index 16ef643dc..28068f548 100644
--- a/e2e/freight/cypress/e2e/flows/segment_weight.cy.ts
+++ b/e2e/freight/cypress/e2e/flows/segment_weight.cy.ts
@@ -428,6 +428,11 @@ describe(
           cy.task("db:query", {
             sql: `UPDATE freight.train_schedules
                   SET window_opens_at = LEAST(window_opens_at, now()),
+                      -- The e2e rules run a 1.002-minute window duration, so the
+                      -- CREATE-time close for a departing-today schedule is already
+                      -- in the past — hold the close out or the next 10s tick slams
+                      -- the window shut mid-flow.
+                      window_closes_at = GREATEST(window_closes_at, now() + interval '45 minutes'),
                       window_phase = 'OPEN',
                       booking_window_status = 'OPEN'
                   WHERE id = $1 AND booking_window_status <> 'FULL'`,
diff --git a/e2e/freight/cypress/fixtures/seed-import-corridor.sql b/e2e/freight/cypress/fixtures/seed-import-corridor.sql
index 05d45561f..8d7aedb06 100644
--- a/e2e/freight/cypress/fixtures/seed-import-corridor.sql
+++ b/e2e/freight/cypress/fixtures/seed-import-corridor.sql
@@ -450,14 +450,20 @@ WHERE NOT EXISTS (
 );
 
 -- ---------------------------------------------------------------------------
--- e2e window durations: 1 minute instead of the 30/60 production defaults.
+-- e2e window durations — the dev-environment settings, verbatim:
+--   window duration 0.0167 h (1.002 min), doc review 1 min, payment 1 min
+--   (import AND export).
 --
--- Most specs never wait these out — closeWindowAndRunBatch clicks "Doc review
--- complete" and endPaymentPhase pulls the deadline into the past — so this is
--- a safety net for the paths that DO let a phase elapse on its own, not the
--- main speed lever. That one is the 10s @Cron tick in booking-window.service.
+-- Specs still arrange the timestamps they need (forceWindowOpen holds a
+-- window open for 45 min; endPaymentPhase ends the pay phase early), but
+-- every ENGINE-stamped deadline now comes from these 1-minute rules: the
+-- batch's pay windows, the doc-review auto-advance, and re-opened cycles all
+-- elapse in about a minute on their own via the 10s @Cron tick in
+-- booking-window.service. holdPayWindows (import-utils.ts) is what keeps a
+-- spec's queued-up payments from expiring under the 1-minute pay window.
 -- ---------------------------------------------------------------------------
 UPDATE freight.train_scheduling_global_rules
-   SET doc_review_minutes = 1,
+   SET window_duration_hours = 0.0167,
+       doc_review_minutes = 1,
        payment_window_minutes = 1,
        export_payment_window_minutes = 1;
diff --git a/e2e/freight/scripts/e2e.mjs b/e2e/freight/scripts/e2e.mjs
index ee59f0098..fe8d639b2 100644
--- a/e2e/freight/scripts/e2e.mjs
+++ b/e2e/freight/scripts/e2e.mjs
@@ -16,7 +16,7 @@
  */
 
 import { execFileSync, spawnSync } from "node:child_process";
-import { generateKeyPairSync } from "node:crypto";
+import { createHash, generateKeyPairSync } from "node:crypto";
 import { existsSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { createServer } from "node:net";
 import { dirname, join, resolve } from "node:path";
@@ -25,7 +25,17 @@ import { fileURLToPath } from "node:url";
 const e2eDir = resolve(dirname(fileURLToPath(import.meta.url)), "..");
 const repoRoot = resolve(e2eDir, "..", "..");
 const stateFile = join(e2eDir, ".e2e-ports.json");
-const composeBase = ["compose", "-f", join(repoRoot, "docker-compose.e2e.yaml")];
+// Per-checkout compose project: parallel checkouts on one docker daemon
+// otherwise share the yaml's fixed `name:` and recreate/kill each other's
+// containers mid-run.
+const projectName = `edr-freight-e2e-${createHash("sha1").update(repoRoot).digest("hex").slice(0, 6)}`;
+const composeBase = [
+  "compose",
+  "-p",
+  projectName,
+  "-f",
+  join(repoRoot, "docker-compose.e2e.yaml"),
+];
 
 const DEFAULT_PORTS = {
   E2E_API_PORT: 3101,
diff --git a/packages/types/src/freight/index.ts b/packages/types/src/freight/index.ts
index ffa19a8cc..37997ea18 100644
--- a/packages/types/src/freight/index.ts
+++ b/packages/types/src/freight/index.ts
@@ -303,6 +303,22 @@ export const TRADE_DIRECTION_LABELS: Record<ScheduleTradeDirection, string> = {
   DOMESTIC: "Intercity",
 };
 
+/** All trade directions a backoffice user can be scoped to. */
+export const ALL_TRADE_DIRECTIONS: ScheduleTradeDirection[] = [
+  "IMPORT",
+  "EXPORT",
+  "DOMESTIC",
+];
+
+/**
+ * Per-user backoffice data scope: which trade directions the user may see.
+ * A missing config (or all three directions) means unrestricted.
+ */
+export interface UserTradeAccessDto {
+  userId: string;
+  directions: ScheduleTradeDirection[];
+}
+
 export enum TrainCheckpointKind {
   Departed = "DEPARTED",
   Passed = "PASSED",
@@ -951,6 +967,16 @@ export interface BookingReferenceYard {
   name: string;
   code: string;
   country: string;
+  /**
+   * Which freight types this yard can take, per side of the trip. False for a
+   * yard with no facility record at all. Forms use these to offer a yard as an
+   * origin or destination only where the selected cargo can actually be
+   * handled.
+   */
+  hasContainerFacilityOrigin: boolean;
+  hasBulkFacilityOrigin: boolean;
+  hasContainerFacilityDestination: boolean;
+  hasBulkFacilityDestination: boolean;
 }
 
 export interface BookingReferenceContainerType {
diff --git a/packages/types/src/freight/notifications.ts b/packages/types/src/freight/notifications.ts
index ecd30c715..e3ca5b219 100644
--- a/packages/types/src/freight/notifications.ts
+++ b/packages/types/src/freight/notifications.ts
@@ -92,6 +92,13 @@ export interface NotificationRecipients {
   organizationId?: string;
   /** Backoffice: every current employee across all organizations. */
   allBackoffice?: boolean;
+  /**
+   * Backoffice: current employees (any org) who hold ANY of these permission
+   * keys — e.g. notify only marketing, not every employee. Super/org admins
+   * are not implicitly included; add `allBackoffice`/explicit userIds too if
+   * admins should also see it.
+   */
+  permissionKeys?: string[];
 }
 
 /** Input any subsystem passes to `NotificationInboxService.notify(...)`. */
diff --git a/packages/types/src/freight/overview.ts b/packages/types/src/freight/overview.ts
index d2ba267cc..e3d98bc00 100644
--- a/packages/types/src/freight/overview.ts
+++ b/packages/types/src/freight/overview.ts
@@ -1,6 +1,8 @@
 export type OverviewRange = '7d' | '30d' | '90d';
 
 export interface IOverviewBookingKpis {
+  /** All bookings ever recorded (excluding deleted / GENERAL umbrella rows). */
+  total: number;
   totalActive: number;
   needsAction: number;
   urgent: number;
@@ -13,6 +15,8 @@ export interface IOverviewOperationsKpis {
   wagonsAvailable: number;
   containersInTransit: number;
   cargoesLoaded: number;
+  schedulesUpcoming: number;
+  dispatchedToday: number;
 }
 
 export interface IOverviewCustomerKpis {
@@ -33,6 +37,8 @@ export interface IOverviewStaffKpis {
 }
 
 export interface IOverviewContractKpis {
+  /** All contracts ever recorded (excluding deleted). */
+  total: number;
   totalActive: number;
   needsAction: number;
   inApproval: number;
@@ -151,8 +157,27 @@ export interface IOverviewBillingTab {
   generatedAt: string;
 }
 
+/** Scheduled train departures per day, split by trade direction. */
+export interface IOverviewDirectionTrendPoint {
+  date: string;
+  importCount: number;
+  exportCount: number;
+  domesticCount: number;
+}
+
+export interface IOverviewTonnagePoint {
+  label: string;
+  tons: number;
+}
+
 export interface IOverviewOperationsTab {
   kpis: IOverviewOperationsKpis;
+  departureTrend: IOverviewDirectionTrendPoint[];
+  scheduleStatusBreakdown: IOverviewStatusCount[];
+  wagonsByType: IOverviewLabelCount[];
+  wagonsByYard: IOverviewLabelCount[];
+  containersBySize: IOverviewLabelCount[];
+  cargoTonnageByType: IOverviewTonnagePoint[];
   trainStatusBreakdown: IOverviewStatusCount[];
   wagonStatusBreakdown: IOverviewStatusCount[];
   containerStatusBreakdown: IOverviewStatusCount[];
@@ -181,5 +206,6 @@ export type OverviewTabKey =
   | 'contracts'
   | 'billing'
   | 'operations'
+  | 'fleet'
   | 'customers'
   | 'staff';
diff --git a/packages/types/src/index.ts b/packages/types/src/index.ts
index b4fd73d81..d77e81fff 100644
--- a/packages/types/src/index.ts
+++ b/packages/types/src/index.ts
@@ -2,5 +2,9 @@ export * from "./common/index";
 export * from "./freight/index";
 export * as Freight from "./freight/index";
 export * as Passenger from "./passenger/index";
+// Flat re-export: the Blocked Seat Revenue Loss shapes are shared verbatim between the
+// passenger API and the backoffice, and reading them through the `Passenger.` namespace
+// on every line buys nothing.
+export * from "./passenger/blocked-seat-revenue-loss";
 export type { PaymentEvent, PaymentEventType, PaymentFailedEvent, PaymentSucceededEvent, PaymentIntentSnapshot, InitiatePaymentRequest } from "./common/payments";
 export { PaymentReferenceType, PaymentService } from "./common/payments";
diff --git a/packages/types/src/passenger/blocked-seat-revenue-loss.ts b/packages/types/src/passenger/blocked-seat-revenue-loss.ts
new file mode 100644
index 000000000..f39791929
--- /dev/null
+++ b/packages/types/src/passenger/blocked-seat-revenue-loss.ts
@@ -0,0 +1,172 @@
+/**
+ * Blocked Seat Revenue Loss report — shared shapes for
+ * `GET /reports/blocked-seats-revenue-loss`.
+ *
+ * Every monetary field is an **integer count of minor units** (ETB cents, DJF centimes …)
+ * and is always paired with its `currency`. Never sum across currencies.
+ */
+
+/**
+ * Why a seat was pulled out of sale. Mirrors the Prisma `SeatBlockReasonCategory` enum.
+ *
+ * Declared as a const object + union type rather than a TS `enum` so that Prisma's own
+ * generated string-literal union assigns to it directly, with no cast at the boundary.
+ */
+export const SeatBlockReasonCategory = {
+  Maintenance: "MAINTENANCE",
+  VipReserved: "VIP_RESERVED",
+  Safety: "SAFETY",
+  Operational: "OPERATIONAL",
+  Other: "OTHER",
+} as const;
+
+export type SeatBlockReasonCategory =
+  (typeof SeatBlockReasonCategory)[keyof typeof SeatBlockReasonCategory];
+
+/** Every category value, in the order they should appear in a picker. */
+export const SEAT_BLOCK_REASON_CATEGORIES: readonly SeatBlockReasonCategory[] =
+  Object.values(SeatBlockReasonCategory);
+
+/** Human labels for {@link SeatBlockReasonCategory}, plus the legacy null bucket. */
+export const SEAT_BLOCK_REASON_CATEGORY_LABELS: Record<string, string> = {
+  MAINTENANCE: "Maintenance",
+  VIP_RESERVED: "VIP Reserved",
+  SAFETY: "Safety",
+  OPERATIONAL: "Operational",
+  OTHER: "Other",
+  UNCATEGORIZED: "Uncategorized",
+};
+
+/** Bucket label used for blocks written before `reasonCategory` existed. */
+export const UNCATEGORIZED_REASON_CATEGORY = "UNCATEGORIZED";
+
+/**
+ * How the block reached this schedule.
+ * - `SCHEDULE` — a `SeatBlock` row naming this `scheduleId` directly.
+ * - `GLOBAL` — a `SeatBlock` row with no `scheduleId`, in effect at departure, whose
+ *   seat's coach was assigned to this schedule.
+ */
+export type BlockedSeatBlockType = "SCHEDULE" | "GLOBAL";
+
+/** One blocked seat on one schedule — the drill-down row. */
+export interface BlockedSeatLossDetail {
+  blockId: string;
+  seatId: string;
+  coachNumber: string | null;
+  seatNumber: string | null;
+  seatClassName: string | null;
+  /** Operator's free-text detail, verbatim. */
+  reason: string;
+  /** `null` on rows written before the column existed — render as "Uncategorized". */
+  reasonCategory: SeatBlockReasonCategory | null;
+  blockType: BlockedSeatBlockType;
+  /** IAM user id, or `SYSTEM` for system-initiated blocks. */
+  blockedBy: string;
+  /** `null` on legacy rows — render as "Unknown". */
+  blockedByName: string | null;
+  approvedBy: string | null;
+  blockedAt: string;
+  unblockAt: string | null;
+  /** True when the block has no scheduled end. */
+  stillBlocked: boolean;
+  /** Whole days from `blockedAt` to `unblockAt`, or to now while still blocked. */
+  daysBlocked: number;
+  estimatedLossMinor: number;
+  currency: string;
+}
+
+/** One schedule with at least one blocked seat counted against it. */
+export interface BlockedSeatLossSchedule {
+  scheduleId: string;
+  trainNumber: string;
+  routeName: string | null;
+  originStation: string;
+  destinationStation: string;
+  departureAt: string;
+  status: string;
+  /** Non-dining, non-placeholder seats on the coaches assigned to this schedule. */
+  sellableSeats: number;
+  /** Seats with a CONFIRMED/BOARDED booking on this schedule. */
+  soldSeats: number;
+  /** `soldSeats / sellableSeats`, as a percentage rounded to one decimal. */
+  loadFactorPercent: number;
+  blockedSeatCount: number;
+  /** Distinct blockers behind this schedule's blocked seats, in no particular order. */
+  blockedByNames: string[];
+  /** Loss at full occupancy — the sum of the fares these seats would have sold for. */
+  estimatedLossMinor: number;
+  /** `estimatedLossMinor × loadFactor` — what the train's actual demand supports. */
+  adjustedLossMinor: number;
+  currency: string;
+  blocks: BlockedSeatLossDetail[];
+}
+
+/** Loss totals for one currency. */
+export interface BlockedSeatLossByCurrency {
+  currency: string;
+  estimatedLossMinor: number;
+  adjustedLossMinor: number;
+}
+
+/** Loss grouped by reason category, per currency. */
+export interface BlockedSeatLossByReasonCategory {
+  /** A {@link SeatBlockReasonCategory} value, or {@link UNCATEGORIZED_REASON_CATEGORY}. */
+  reasonCategory: string;
+  count: number;
+  estimatedLossMinor: number;
+  currency: string;
+}
+
+/** Loss grouped by the staff member who blocked the seat, per currency. */
+export interface BlockedSeatLossByBlocker {
+  blockedBy: string;
+  blockedByName: string;
+  count: number;
+  estimatedLossMinor: number;
+  currency: string;
+}
+
+export interface BlockedSeatLossSummary {
+  schedulesAffected: number;
+  blockedSeatCount: number;
+  lossByCurrency: BlockedSeatLossByCurrency[];
+  topReasonCategories: BlockedSeatLossByReasonCategory[];
+  topBlockers: BlockedSeatLossByBlocker[];
+}
+
+/**
+ * Provenance for the numbers above. `methodology` and `exclusions` are meant to be
+ * rendered verbatim in the UI — this report is a counterfactual, and the assumptions
+ * behind it have to travel with it.
+ */
+export interface BlockedSeatLossMeta {
+  /** Total schedules matching the filters, before pagination. */
+  total: number;
+  page: number;
+  pageSize: number;
+  dateFrom: string;
+  dateTo: string;
+  /** Nationality the fares were priced at (drives tariff variant and currency). */
+  nationalityAssumption: string;
+  methodology: string;
+  exclusions: string[];
+  /** Schedules whose fare could not be computed — their seats count but carry no loss. */
+  schedulesWithoutFare: number;
+}
+
+export interface BlockedSeatRevenueLossReport {
+  summary: BlockedSeatLossSummary;
+  schedules: BlockedSeatLossSchedule[];
+  meta: BlockedSeatLossMeta;
+}
+
+/** Compact roll-up embedded in `GET /dashboard/backoffice-stats`. */
+export interface BlockedSeatRevenueLossStat {
+  /** `null` means the roll-up covers full history — the earliest schedule to the latest. */
+  periodDays: number | null;
+  lossByCurrency: BlockedSeatLossByCurrency[];
+  schedulesAffected: number;
+  blockedSeatCount: number;
+  /** Largest category by estimated loss, or `null` when nothing is blocked. */
+  topReasonCategory: string | null;
+}
diff --git a/packages/types/src/passenger/index.ts b/packages/types/src/passenger/index.ts
index dff769f00..f5f39c5f7 100644
--- a/packages/types/src/passenger/index.ts
+++ b/packages/types/src/passenger/index.ts
@@ -1,6 +1,7 @@
 import type { BaseEntity } from "../common";
 
 export * from "./support-chat";
+export * from "./blocked-seat-revenue-loss";
 
 export enum TicketStatus {
   Reserved = "RESERVED",
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 8e3fe21a2..734e66efe 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -352,6 +352,9 @@ importers:
       '@tria-plc/iamui':
         specifier: file:../../../local-packages/tria-plc-iamui-0.1.1.tgz
         version: file:local-packages/tria-plc-iamui-0.1.1.tgz(0ce39b7e349029277dcd938d06eeb0f7)
+      '@types/three':
+        specifier: ^0.185.3
+        version: 0.185.3
       '@vis.gl/react-google-maps':
         specifier: ^1.8.3
         version: 1.8.3(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
@@ -496,6 +499,9 @@ importers:
       tailwind-merge:
         specifier: ^3.6.0
         version: 3.6.0
+      three:
+        specifier: ^0.185.1
+        version: 0.185.1
       tinymce:
         specifier: ^8.6.0
         version: 8.6.0
@@ -589,7 +595,7 @@ importers:
         version: 5.101.0(react@19.2.6)
       '@tria-plc/iamui':
         specifier: file:../../../local-packages/tria-plc-iamui-0.1.1.tgz
-        version: file:local-packages/tria-plc-iamui-0.1.1.tgz(0ce39b7e349029277dcd938d06eeb0f7)
+        version: file:local-packages/tria-plc-iamui-0.1.1.tgz(a5d0bdee55164ae56064fb273b530e00)
       '@vis.gl/react-google-maps':
         specifier: ^1.8.3
         version: 1.8.3(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
@@ -815,11 +821,11 @@ importers:
         specifier: ^8.1.0
         version: 8.1.6
       '@tria-plc/api-common':
-        specifier: file:../../local-packages/tria-plc-api-common-1.4.3.tgz
-        version: file:local-packages/tria-plc-api-common-1.4.3.tgz(aaad3d77da283ea37b052677c39644c3)
+        specifier: file:../../local-packages/tria-plc-api-common-1.6.0.tgz
+        version: file:local-packages/tria-plc-api-common-1.6.0.tgz(2b4e99ab22f78c34e7861d649f4ff29b)
       '@tria-plc/iamapi-common':
-        specifier: file:../../local-packages/tria-plc-iamapi-common-0.7.9.tgz
-        version: file:local-packages/tria-plc-iamapi-common-0.7.9.tgz(4d1d275441e80423228c2d8370f9d999)
+        specifier: file:../../local-packages/tria-plc-iamapi-common-1.0.0.tgz
+        version: file:local-packages/tria-plc-iamapi-common-1.0.0.tgz(cc085a020c559b355f168432c579a024)
       '@types/bcrypt':
         specifier: ^6.0.0
         version: 6.0.0
@@ -1850,6 +1856,9 @@ packages:
   '@date-fns/tz@1.5.0':
     resolution: {integrity: sha512-lwYN/vDPeNRULcepoE/LO2Pgx+7/RV+S9ARfbc9lr2DtGkOD7pAiruHvbR1RX3Qyf6ja47EWJDMsNK5vK08DJg==}
 
+  '@dimforge/rapier3d-compat@0.12.0':
+    resolution: {integrity: sha512-uekIGetywIgopfD97oDL5PfeezkFpNhwlzlaEYNOA0N6ghdsOvh/HYjSMek5Q2O1PYvRSDFcqFVJl4r4ZBwOow==}
+
   '@dotenvx/dotenvx@1.71.0':
     resolution: {integrity: sha512-KEUw/mGu+EDRhYWRTNGHIimVCs9NvMFaIXOGrHSXoCteKLE5EsJnmPjOPpYorjXVg/0xG0fbdVw720azw1z4ag==}
     hasBin: true
@@ -4622,23 +4631,6 @@ packages:
   '@tootallnate/quickjs-emscripten@0.23.0':
     resolution: {integrity: sha512-C5Mc6rdnsaJDjO3UpGW/CQTHtCKaYlScZTly4JIu97Jxo/odCiH0ITnDXSJPTOrEKk/ycSZ0AOgTmkDtkOsvIA==}
 
-  '@tria-plc/api-common@file:local-packages/tria-plc-api-common-1.4.3.tgz':
-    resolution: {integrity: sha512-cHlo96Wh3ET8qHjq5mevJwqitFRynU17KzEpE5fz0efCs9NIw7N3K6L+bYwConOCP7jbIROe/2rkG9ToY/AA3w==, tarball: file:local-packages/tria-plc-api-common-1.4.3.tgz}
-    version: 1.4.3
-    peerDependencies:
-      '@nestjs/common': ^11.0.0
-      '@nestjs/core': ^11.0.0
-      '@nestjs/jwt': ^11.0.0
-      '@nestjs/microservices': ^11.0.0
-      '@nestjs/passport': ^11.0.0
-      '@nestjs/swagger': ^11.0.0
-      '@nestjs/throttler': ^6.0.0
-      '@nestjs/typeorm': ^11.0.0
-      '@tria-plc/iamapi-common': ^0.1.0
-      reflect-metadata: ^0.2.0
-      rxjs: ^7.8.0
-      typeorm: ^0.3.0
-
   '@tria-plc/api-common@file:local-packages/tria-plc-api-common-1.6.0.tgz':
     resolution: {integrity: sha512-SZomla65xesBQZ12n8xH+9eX0TRbXNWToQ3SNURLhP1zlHJWUMTVHoRXTd5zWoe4mqah2Lr83L8ueHERsqCTFw==, tarball: file:local-packages/tria-plc-api-common-1.6.0.tgz}
     version: 1.6.0
@@ -4655,28 +4647,6 @@ packages:
       rxjs: ^7.8.0
       typeorm: ^0.3.0
 
-  '@tria-plc/iamapi-common@file:local-packages/tria-plc-iamapi-common-0.7.9.tgz':
-    resolution: {integrity: sha512-Y6SDEJUR4NcwLXrRJFZ+SbknpczybMwp59cR000vjFEu09RClLr5Gzv8TaJbOeDytyhdgjkZriVNPb2Dt6tipA==, tarball: file:local-packages/tria-plc-iamapi-common-0.7.9.tgz}
-    version: 0.7.9
-    engines: {node: '>=20'}
-    peerDependencies:
-      '@nestjs/axios': ^4.0.0
-      '@nestjs/common': ^11.0.0
-      '@nestjs/core': ^11.0.0
-      '@nestjs/jwt': ^11.0.0
-      '@nestjs/microservices': ^11.0.0
-      '@nestjs/passport': ^11.0.0
-      '@nestjs/swagger': ^11.0.0
-      '@nestjs/throttler': ^6.0.0
-      '@nestjs/typeorm': ^11.0.0
-      '@tria-plc/api-common': '*'
-      axios: ^1.9.0
-      class-transformer: ^0.5.1
-      class-validator: ^0.14.1
-      reflect-metadata: ^0.2.0
-      rxjs: ^7.8.0
-      typeorm: ^0.3.0
-
   '@tria-plc/iamapi-common@file:local-packages/tria-plc-iamapi-common-1.0.0.tgz':
     resolution: {integrity: sha512-rfHSXOm/0VUMTj7HrvYysrEAqxItqfPs4Rd35qWJyaAk+snF1wTKFRVz6cRGPoQNj8fhplkVAefnvuKBuHT+xQ==, tarball: file:local-packages/tria-plc-iamapi-common-1.0.0.tgz}
     version: 1.0.0
@@ -4752,6 +4722,9 @@ packages:
     cpu: [arm64]
     os: [win32]
 
+  '@tweenjs/tween.js@23.1.3':
+    resolution: {integrity: sha512-vJmvvwFxYuGnF2axRtPYocag6Clbb5YS7kLL+SO/TeVFzHqDIWrNKYtcsPMibjDx9O+bu+psAy9NKfWklassUA==}
+
   '@tybys/wasm-util@0.10.2':
     resolution: {integrity: sha512-RoBvJ2X0wuKlWFIjrwffGw1IqZHKQqzIchKaadZZfnNpsAYp2mM0h36JtPCjNDAHGgYez/15uMBpfGwchhiMgg==}
 
@@ -4978,6 +4951,9 @@ packages:
   '@types/stack-utils@2.0.3':
     resolution: {integrity: sha512-9aEbYZ3TbYMznPdcdr3SmIrLXwC/AKZXQeCf9Pgao5CKb8CyHuEX5jzWPTkvregvhRJHcpRO6BFoGW9ycaOkYw==}
 
+  '@types/stats.js@0.17.4':
+    resolution: {integrity: sha512-jIBvWWShCvlBqBNIZt0KAshWpvSjhkwkEu4ZUcASoAvhmrgAUI2t1dXrjSL4xXVLB4FznPrIsX3nKXFl/Dt4vA==}
+
   '@types/statuses@2.0.6':
     resolution: {integrity: sha512-xMAgYwceFhRA2zY+XbEA7mxYbA093wdiW8Vu6gZPGWy9cmOyU9XesH1tNcEWsKFd5Vzrqx5T3D38PWx1FIIXkA==}
 
@@ -4987,6 +4963,9 @@ packages:
   '@types/supertest@6.0.3':
     resolution: {integrity: sha512-8WzXq62EXFhJ7QsH3Ocb/iKQ/Ty9ZVWnVzoTKc9tyyFRRF3a74Tk2+TLFgaFFw364Ere+npzHKEJ6ga2LzIL7w==}
 
+  '@types/three@0.185.3':
+    resolution: {integrity: sha512-8TqTn1+fjPWuJ4mR6Igtg56DCf9b5EeAlwhb5xaa6WlBrsg7SvG0NQbyctGRkHCKwg0uftfCspOEsTXelgktMA==}
+
   '@types/tinymce@4.6.9':
     resolution: {integrity: sha512-pDxBUlV4v1jgJ97SlnVOSyf3KUy3OQ3s5Ddpfh1L9M5lXlBmX7TJ2OLSozx1WBxp91acHvYPWDwz2U/kMM1oxQ==}
 
@@ -5011,6 +4990,9 @@ packages:
   '@types/vorpal@1.12.8':
     resolution: {integrity: sha512-Qt+Yxa1q6QCaYMxZFXlyPOF3ktIscTelNr1AFYuKM7/Dhlki4gvc476uFyA/hYvskSA6V8W+55x9FjlbAPcYdQ==}
 
+  '@types/webxr@0.5.24':
+    resolution: {integrity: sha512-h8fgEd/DpoS9CBrjEQXR+dIDraopAEfu4wYVNY2tEPwk60stPWhvZMf4Foo5FakuQ7HFZoa8WceaWFervK2Ovg==}
+
   '@types/ws@8.18.1':
     resolution: {integrity: sha512-ThVF6DCVhA8kUGy+aazFQ4kXQ7E1Ty7A3ypFOe0IcJV8O/M511G99AW24irKrW56Wt44yG9+ij8FaqoBGkuBXg==}
 
@@ -5577,9 +5559,6 @@ packages:
     resolution: {integrity: sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==}
     engines: {node: '>= 8'}
 
-  api-common@1.2.2:
-    resolution: {integrity: sha512-2A3NpFNlOOvPY8Vq+g8Pokj6PdMk8fJpg58JpI/QuSXeB9JrS4YbRgzdexPBnJIUCNDHnjr+7S1vOsRRctHzyw==}
-
   app-root-path@3.1.0:
     resolution: {integrity: sha512-biN3PwB2gUtjaYy/isrU3aNWI5w+fAfvHkSvCKeQGxhmYpwKFUxudR3Yya+KqVRHBmEDYh+/lTozYCFbmzX4nA==}
     engines: {node: '>= 6.0.0'}
@@ -5720,9 +5699,6 @@ packages:
     resolution: {integrity: sha512-hsU18Ae8CDTR6Kgu9DYf0EbCr/a5iGL0rytQDobUcdpYOKokk8LEjVphnXkDkgpi0wYVsqrXuP0bZxJaTqdgoA==}
     engines: {node: '>= 0.4'}
 
-  async@2.6.4:
-    resolution: {integrity: sha512-mzo5dfJYwAn29PeiJ0zvwTo04zj8HDJj0Mn8TD7sno7q12prdbnasKJHhkm2c1LgrhlJ0teaea8860oxi51mGA==}
-
   async@3.2.6:
     resolution: {integrity: sha512-htCUDlxyyCLMgaM3xXg0C0LW2xqfuQ6p05pCEIsXuyQ+a1koYKTuBMzRNwmybfLgvJDMd0r1LTn4+E0Ti6C2AA==}
 
@@ -6281,10 +6257,6 @@ packages:
   colorette@2.0.20:
     resolution: {integrity: sha512-IfEDxwoWIjkeXL1eXcDiow4UbKjhLdq6/EuSVR9GMN7KVH3r9gQ83e73hsz1Nd1T3ijd5xv1wcWRYO+D6kCI2w==}
 
-  colors@1.0.3:
-    resolution: {integrity: sha512-pFGrxThWcWQ2MsAz6RtgeWe4NK2kUE1WfsrvvlctdII745EW9I0yflqhe7++M5LEc7bV2c/9/5zc8sFcpL0Drw==}
-    engines: {node: '>=0.1.90'}
-
   colors@1.4.0:
     resolution: {integrity: sha512-a+UqTh4kgZg/SlGvfbzDHpgRu7AAQOmmqRHJnxhRZICKFUT91brVhNNt58CMWU9PsBbv3PDCZUHbVxuDiH2mtA==}
     engines: {node: '>=0.1.90'}
@@ -6528,10 +6500,6 @@ packages:
   csstype@3.2.3:
     resolution: {integrity: sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ==}
 
-  cycle@1.0.3:
-    resolution: {integrity: sha512-TVF6svNzeQCOpjCqsy0/CSy8VgObG3wXusJ73xW2GbG5rGx7lC8zxDSURicsXI2UsGdi2L0QNRCi745/wUDvsA==}
-    engines: {node: '>=0.4.0'}
-
   cypress@15.18.1:
     resolution: {integrity: sha512-JtkTVtUE2lvLYgZCaug+Uai0H9IqsJirlBO49c87QwG0bJUGvAUVBz1EJve0b0oaYP244Ew9M0BkrHpcqkYxmw==}
     engines: {node: ^20.1.0 || ^22.0.0 || >=24.0.0}
@@ -6974,12 +6942,6 @@ packages:
     resolution: {integrity: sha512-VyjaKxUmeDX/m2lxm/aknsJ1GWDWUO2Ze2Ad8S1Pb9dykAm9TjSKp5CjrNyltYqZ5W/PO6TInAmO2/BfwMyT1g==}
     engines: {node: '>=0.10.0'}
 
-  error-tojson@0.0.1:
-    resolution: {integrity: sha512-zhtlVKgW0CgzltibgAlgi6oljh7L8k7jo61NuATFXodGMI2aiqAusW5FaiAtMcT8OLzdPkfhqh34I2XjxPI+Aw==}
-
-  errors@0.3.0:
-    resolution: {integrity: sha512-/4VTzspBdKkY8DE7VnjGYdHaSZdnQqQyOwYv3o2lwaKLhTvQmVATmoUCvFIFLVrn5kJqDHZl5ZltOu1Bit8rvg==}
-
   es-abstract@1.24.2:
     resolution: {integrity: sha512-2FpH9Q5i2RRwyEP1AylXe6nYLR5OhaJTZwmlcP0dL/+JCbgg7yyEo/sEK6HeGZRf3dFpWwThaRHVApXSkW3xeg==}
     engines: {node: '>= 0.4'}
@@ -7319,10 +7281,6 @@ packages:
     resolution: {integrity: sha512-11Ndz7Nv+mvAC1j0ktTa7fAb0vLyGGX+rMHNBYQviQDGU0Hw7lhctJANqbPhu9nV9/izT/IntTgZ7Im/9LJs9g==}
     engines: {'0': node >=0.6.0}
 
-  eyes@0.1.8:
-    resolution: {integrity: sha512-GipyPsXO1anza0AOZdy69Im7hGFCNB7Y/NGjDlZGJ3GJJLtwNSb2vrzYrTYJRrRloVx7pl+bhUaTB8yiccPvFQ==}
-    engines: {node: '> 0.1.90'}
-
   falsey@0.3.2:
     resolution: {integrity: sha512-lxEuefF5MBIVDmE6XeqCdM4BWk1+vYmGZtkbKZ/VFcg6uBBw6fXNEbWmxCjDdQlFc9hy450nkiWwM3VAW6G1qg==}
     engines: {node: '>=0.10.0'}
@@ -8721,9 +8679,6 @@ packages:
   jws@4.0.1:
     resolution: {integrity: sha512-EKI/M/yqPncGUUh44xz0PxSidXFr/+r0pA70+gIYhjv+et7yxM+s29Y+VGDkovRofQem0fs7Uvf4+YmAdyRduA==}
 
-  jwt-decode@2.2.0:
-    resolution: {integrity: sha512-86GgN2vzfUu7m9Wcj63iUkuDzFNYFVmjeDm2GzWpUk+opB0pEpMsw6ePCMrhYkumz2C1ihqtZzOMAg7FiXcNoQ==}
-
   keyv@4.5.4:
     resolution: {integrity: sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==}
 
@@ -9182,6 +9137,9 @@ packages:
     resolution: {integrity: sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==}
     engines: {node: '>= 8'}
 
+  meshoptimizer@1.1.1:
+    resolution: {integrity: sha512-oRFNWJRDA/WTrVj7NWvqa5HqE1t9MYDj2VaWirQCzCCrAd2GHrqR/sQezCxiWATPNlKTcRaPRHPJwIRoPBAp5g==}
+
   methods@1.1.2:
     resolution: {integrity: sha512-iclAHeNqNm68zFtnZ0e+1L2yUIdvzNoauKU4WBA3VvH/vPFieF7qfRlwUZU+DA9P9bPXIS90ulxoUoCH23sV2w==}
     engines: {node: '>= 0.6'}
@@ -9247,9 +9205,6 @@ packages:
     resolution: {integrity: sha512-OBwBN9AL4dqmETlpS2zasx+vTeWclWzkblfZk7KTA5j3jeOONz/tRCnZomUyvNg83wL5Zv9Ss6HMJXAgL8R2Yg==}
     engines: {node: '>=16 || 14 >=14.17'}
 
-  minimist@0.0.8:
-    resolution: {integrity: sha512-miQKw5Hv4NS1Psg2517mV4e4dYNaO3++hjAvLOAzKqZ61rH8NS1SK+vbfBWZ5PY/Me/bEWhUwqMghEW5Fb9T7Q==}
-
   minimist@1.2.8:
     resolution: {integrity: sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==}
 
@@ -9268,11 +9223,6 @@ packages:
     resolution: {integrity: sha512-WRoDn//mXBiJ1H40rqa3vH0toePwSsGb45iInWlTySa+Uu4k3tYUSxa2v1KqAiLtvlrSzaExqS1gtk96A9zvEA==}
     engines: {node: '>=0.10.0'}
 
-  mkdirp@0.5.1:
-    resolution: {integrity: sha512-SknJC52obPfGQPnjIkXbmA6+5H15E+fR+E4iR2oQ3zzCLbd7/ONua69R/Gw7AgkTLsRG+r5fzksYwWe1AgTyWA==}
-    deprecated: Legacy versions of mkdirp are no longer supported. Please update to mkdirp 1.x. (Note that the API surface has changed to use Promises in 1.x.)
-    hasBin: true
-
   mkdirp@0.5.6:
     resolution: {integrity: sha512-FP+p8RB8OWpF3YZBCrP5gtADmtXApB5AMLn+vdyA+PyxCjrCs00mjyUozssO33cwDeT3wNGdLxJ5M//YqtHAJw==}
     hasBin: true
@@ -9836,10 +9786,6 @@ packages:
   pkg-types@2.3.1:
     resolution: {integrity: sha512-y+ichcgc2LrADuhLNAx8DFjVfgz91pRxfZdI3UDhxHvcVEZsenLO+7XaU5vOp0u/7V/wZ+plyuQxtrDlZJ+yeg==}
 
-  pkginfo@0.4.1:
-    resolution: {integrity: sha512-8xCNE/aT/EXKenuMDZ+xTVwkT8gsoHN2z/Q29l80u0ppGEXVvsKRzNMbtKhg8LS8k1tJLAHHylf6p4VFmP6XUQ==}
-    engines: {node: '>= 0.4.0'}
-
   playwright-core@1.61.1:
     resolution: {integrity: sha512-h7Qlt6m4REp25qvIdvbDtVmD4LqVXfpRxhORv9L0jzETM05p4fuPJ3dKyuSXQxDSbXnmS79HAgi9589lGSpLkg==}
     engines: {node: '>=18'}
@@ -10790,9 +10736,6 @@ packages:
     resolution: {integrity: sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==}
     engines: {node: '>=8'}
 
-  short-id-gen@1.1.2:
-    resolution: {integrity: sha512-rIxGIHcAhbf8jCgB6LYTeFC8jXffu4m0g+SXTljxGLkNhlMAq4jgQYPxvURtIX+tyqAx8YXuuh7j1qDVxJSZIA==}
-
   side-channel-list@1.0.1:
     resolution: {integrity: sha512-mjn/0bi/oUURjc5Xl7IaWi/OJJJumuoJFQJfDDyO46+hBWsfaVM65TBHq2eoZBhzl9EchxOijpkbRC8SVBQU0w==}
     engines: {node: '>= 0.4'}
@@ -10955,9 +10898,6 @@ packages:
   stable-hash@0.0.5:
     resolution: {integrity: sha512-+L3ccpzibovGXFK+Ap/f8LOS0ahMrHTf3xu7mMLSpEGU0EO9ucaysSylKo9eRDFNhWve/y275iPmIZ4z39a9iA==}
 
-  stack-trace@0.0.10:
-    resolution: {integrity: sha512-KGzahc7puUKkzyMt+IqAep+TVNbKP+k2Lmwhub39m1AsTSkaDutx56aDCo+HLDzf/D26BIHTJWNiTG1KAJiQCg==}
-
   stack-utils@2.0.6:
     resolution: {integrity: sha512-XlkWvfIm6RmsWtNJx+uqtKLS8eqFbxUg0ZzLXqY0caEy9l7hruX8IpiDnjsLavoBgqCCR71TqWO8MaXYheJ3RQ==}
     engines: {node: '>=10'}
@@ -11329,6 +11269,9 @@ packages:
   thenify@3.3.1:
     resolution: {integrity: sha512-RVZSIV5IG10Hk3enotrhvz0T9em6cyHBLkH/YAZuKqd8hRkKhSfCGIcP2KUY0EPxndzANBmNllzWPwak+bheSw==}
 
+  three@0.185.1:
+    resolution: {integrity: sha512-5aojFCXKwnjBRZvUnt3WFfEcvUJgkN5LlijRFN95hMy8WVkG4I0QNcJE+OuWvuJ0bOdStrbfXn0pkd6/QyiAlg==}
+
   throttleit@1.0.1:
     resolution: {integrity: sha512-vDZpf9Chs9mAdfY046mcPt8fg5QSZr37hEH4TXYBnDF+izxgrbRGUAAaBvIk/fJm9aOFCGFd1EsNg5AZCbnQCQ==}
 
@@ -12078,15 +12021,6 @@ packages:
     engines: {node: '>=8'}
     hasBin: true
 
-  winston-daily-rotate-file@1.7.2:
-    resolution: {integrity: sha512-bUkpSyWuDZVD2L7Ci/JrH09sIeqpwhQvmDrIAJ9PhUaewIbv9FTDTCvFnE2AFIIfDcTm7+AKiEKK4EP5lRL3fg==}
-    peerDependencies:
-      winston: 2.x
-
-  winston@2.4.7:
-    resolution: {integrity: sha512-vLB4BqzCKDnnZH9PHGoS2ycawueX4HLqENXQitvFHczhgW2vFpSOn31LZtVr1KU8YTw7DS4tM+cqyovxo8taVg==}
-    engines: {node: '>= 0.10.0'}
-
   wmf@1.0.2:
     resolution: {integrity: sha512-/p9K7bEh0Dj6WbXg4JG0xvLQmIadrner1bi45VMJTfnbVHsc7yIajZyoSoK60/dtVBs12Fm6WkUI5/3WAVsNMw==}
     engines: {node: '>=0.8'}
@@ -12364,11 +12298,11 @@ snapshots:
       '@babel/helpers': 7.29.7
       '@babel/parser': 7.29.7
       '@babel/template': 7.29.7
-      '@babel/traverse': 7.29.7(supports-color@5.5.0)
+      '@babel/traverse': 7.29.7
       '@babel/types': 7.29.7
       '@jridgewell/remapping': 2.3.5
       convert-source-map: 2.0.0
-      debug: 4.4.3(supports-color@5.5.0)
+      debug: 4.4.3(supports-color@8.1.1)
       gensync: 1.0.0-beta.2
       json5: 2.2.3
       semver: 6.3.1
@@ -12403,7 +12337,7 @@ snapshots:
       '@babel/helper-optimise-call-expression': 7.29.7
       '@babel/helper-replace-supers': 7.29.7(@babel/core@7.29.7)
       '@babel/helper-skip-transparent-expression-wrappers': 7.29.7
-      '@babel/traverse': 7.29.7(supports-color@5.5.0)
+      '@babel/traverse': 7.29.7
       semver: 6.3.1
     transitivePeerDependencies:
       - supports-color
@@ -12412,7 +12346,14 @@ snapshots:
 
   '@babel/helper-member-expression-to-functions@7.29.7':
     dependencies:
-      '@babel/traverse': 7.29.7(supports-color@5.5.0)
+      '@babel/traverse': 7.29.7
+      '@babel/types': 7.29.7
+    transitivePeerDependencies:
+      - supports-color
+
+  '@babel/helper-module-imports@7.29.7':
+    dependencies:
+      '@babel/traverse': 7.29.7
       '@babel/types': 7.29.7
     transitivePeerDependencies:
       - supports-color
@@ -12427,9 +12368,9 @@ snapshots:
   '@babel/helper-module-transforms@7.29.7(@babel/core@7.29.7)':
     dependencies:
       '@babel/core': 7.29.7
-      '@babel/helper-module-imports': 7.29.7(supports-color@5.5.0)
+      '@babel/helper-module-imports': 7.29.7
       '@babel/helper-validator-identifier': 7.29.7
-      '@babel/traverse': 7.29.7(supports-color@5.5.0)
+      '@babel/traverse': 7.29.7
     transitivePeerDependencies:
       - supports-color
 
@@ -12444,13 +12385,13 @@ snapshots:
       '@babel/core': 7.29.7
       '@babel/helper-member-expression-to-functions': 7.29.7
       '@babel/helper-optimise-call-expression': 7.29.7
-      '@babel/traverse': 7.29.7(supports-color@5.5.0)
+      '@babel/traverse': 7.29.7
     transitivePeerDependencies:
       - supports-color
 
   '@babel/helper-skip-transparent-expression-wrappers@7.29.7':
     dependencies:
-      '@babel/traverse': 7.29.7(supports-color@5.5.0)
+      '@babel/traverse': 7.29.7
       '@babel/types': 7.29.7
     transitivePeerDependencies:
       - supports-color
@@ -12603,6 +12544,18 @@ snapshots:
       '@babel/parser': 7.29.7
       '@babel/types': 7.29.7
 
+  '@babel/traverse@7.29.7':
+    dependencies:
+      '@babel/code-frame': 7.29.7
+      '@babel/generator': 7.29.7
+      '@babel/helper-globals': 7.29.7
+      '@babel/parser': 7.29.7
+      '@babel/template': 7.29.7
+      '@babel/types': 7.29.7
+      debug: 4.4.3(supports-color@8.1.1)
+    transitivePeerDependencies:
+      - supports-color
+
   '@babel/traverse@7.29.7(supports-color@5.5.0)':
     dependencies:
       '@babel/code-frame': 7.29.7
@@ -12790,6 +12743,8 @@ snapshots:
 
   '@date-fns/tz@1.5.0': {}
 
+  '@dimforge/rapier3d-compat@0.12.0': {}
+
   '@dotenvx/dotenvx@1.71.0':
     dependencies:
       commander: 11.1.0
@@ -12826,7 +12781,7 @@ snapshots:
 
   '@emotion/babel-plugin@11.13.5':
     dependencies:
-      '@babel/helper-module-imports': 7.29.7(supports-color@5.5.0)
+      '@babel/helper-module-imports': 7.29.7
       '@babel/runtime': 7.29.7
       '@emotion/hash': 0.9.2
       '@emotion/memoize': 0.9.0
@@ -12992,7 +12947,7 @@ snapshots:
   '@eslint/eslintrc@2.1.4':
     dependencies:
       ajv: 6.15.0
-      debug: 4.4.3(supports-color@5.5.0)
+      debug: 4.4.3(supports-color@8.1.1)
       espree: 9.6.1
       globals: 13.24.0
       ignore: 5.3.2
@@ -13152,7 +13107,7 @@ snapshots:
   '@humanwhocodes/config-array@0.13.0':
     dependencies:
       '@humanwhocodes/object-schema': 2.0.3
-      debug: 4.4.3(supports-color@5.5.0)
+      debug: 4.4.3(supports-color@8.1.1)
       minimatch: 3.1.5
     transitivePeerDependencies:
       - supports-color
@@ -14349,7 +14304,7 @@ snapshots:
 
   '@puppeteer/browsers@2.13.2':
     dependencies:
-      debug: 4.4.3(supports-color@5.5.0)
+      debug: 4.4.3(supports-color@8.1.1)
       extract-zip: 2.0.1
       progress: 2.0.3
       proxy-agent: 6.5.0
@@ -16417,7 +16372,7 @@ snapshots:
 
   '@tokenizer/inflate@0.4.1':
     dependencies:
-      debug: 4.4.3(supports-color@5.5.0)
+      debug: 4.4.3(supports-color@8.1.1)
       token-types: 6.1.2
     transitivePeerDependencies:
       - supports-color
@@ -16426,7 +16381,7 @@ snapshots:
 
   '@tootallnate/quickjs-emscripten@0.23.0': {}
 
-  '@tria-plc/api-common@file:local-packages/tria-plc-api-common-1.4.3.tgz(aaad3d77da283ea37b052677c39644c3)':
+  '@tria-plc/api-common@file:local-packages/tria-plc-api-common-1.6.0.tgz(2b4e99ab22f78c34e7861d649f4ff29b)':
     dependencies:
       '@nestjs/axios': 4.0.1(@nestjs/common@11.1.24(class-transformer@0.5.1)(class-validator@0.14.4)(reflect-metadata@0.2.2)(rxjs@7.8.2))(axios@1.17.0)(rxjs@7.8.2)
       '@nestjs/common': 11.1.24(class-transformer@0.5.1)(class-validator@0.14.4)(reflect-metadata@0.2.2)(rxjs@7.8.2)
@@ -16437,7 +16392,6 @@ snapshots:
       '@nestjs/swagger': 7.4.2(@nestjs/common@11.1.24(class-transformer@0.5.1)(class-validator@0.14.4)(reflect-metadata@0.2.2)(rxjs@7.8.2))(@nestjs/core@11.1.24)(class-transformer@0.5.1)(class-validator@0.14.4)(reflect-metadata@0.2.2)
       '@nestjs/throttler': 6.5.0(@nestjs/common@11.1.24(class-transformer@0.5.1)(class-validator@0.14.4)(reflect-metadata@0.2.2)(rxjs@7.8.2))(@nestjs/core@11.1.24)(reflect-metadata@0.2.2)
       '@nestjs/typeorm': 11.0.1(@nestjs/common@11.1.24(class-transformer@0.5.1)(class-validator@0.14.4)(reflect-metadata@0.2.2)(rxjs@7.8.2))(@nestjs/core@11.1.24)(reflect-metadata@0.2.2)(rxjs@7.8.2)(typeorm@0.3.30(babel-plugin-macros@3.1.0)(pg@8.21.0)(ts-node@10.9.2(@types/node@20.19.42)(typescript@5.9.3)))
-      '@tria-plc/iamapi-common': file:local-packages/tria-plc-iamapi-common-0.7.9.tgz(4d1d275441e80423228c2d8370f9d999)
       argon2: 0.43.1
       axios: 1.17.0
       change-case: 5.4.4
@@ -16513,7 +16467,7 @@ snapshots:
       - debug
       - supports-color
 
-  '@tria-plc/iamapi-common@file:local-packages/tria-plc-iamapi-common-0.7.9.tgz(4d1d275441e80423228c2d8370f9d999)':
+  '@tria-plc/iamapi-common@file:local-packages/tria-plc-iamapi-common-1.0.0.tgz(cc085a020c559b355f168432c579a024)':
     dependencies:
       '@nestjs/axios': 4.0.1(@nestjs/common@11.1.24(class-transformer@0.5.1)(class-validator@0.14.4)(reflect-metadata@0.2.2)(rxjs@7.8.2))(axios@1.17.0)(rxjs@7.8.2)
       '@nestjs/common': 11.1.24(class-transformer@0.5.1)(class-validator@0.14.4)(reflect-metadata@0.2.2)(rxjs@7.8.2)
@@ -16524,8 +16478,7 @@ snapshots:
       '@nestjs/swagger': 7.4.2(@nestjs/common@11.1.24(class-transformer@0.5.1)(class-validator@0.14.4)(reflect-metadata@0.2.2)(rxjs@7.8.2))(@nestjs/core@11.1.24)(class-transformer@0.5.1)(class-validator@0.14.4)(reflect-metadata@0.2.2)
       '@nestjs/throttler': 6.5.0(@nestjs/common@11.1.24(class-transformer@0.5.1)(class-validator@0.14.4)(reflect-metadata@0.2.2)(rxjs@7.8.2))(@nestjs/core@11.1.24)(reflect-metadata@0.2.2)
       '@nestjs/typeorm': 11.0.1(@nestjs/common@11.1.24(class-transformer@0.5.1)(class-validator@0.14.4)(reflect-metadata@0.2.2)(rxjs@7.8.2))(@nestjs/core@11.1.24)(reflect-metadata@0.2.2)(rxjs@7.8.2)(typeorm@0.3.30(babel-plugin-macros@3.1.0)(pg@8.21.0)(ts-node@10.9.2(@types/node@20.19.42)(typescript@5.9.3)))
-      '@tria-plc/api-common': file:local-packages/tria-plc-api-common-1.4.3.tgz(aaad3d77da283ea37b052677c39644c3)
-      api-common: 1.2.2
+      '@tria-plc/api-common': file:local-packages/tria-plc-api-common-1.6.0.tgz(2b4e99ab22f78c34e7861d649f4ff29b)
       argon2: 0.43.1
       axios: 1.17.0
       class-transformer: 0.5.1
@@ -16706,6 +16659,130 @@ snapshots:
       - utf-8-validate
       - vite
 
+  '@tria-plc/iamui@file:local-packages/tria-plc-iamui-0.1.1.tgz(a5d0bdee55164ae56064fb273b530e00)':
+    dependencies:
+      '@emotion/react': 11.14.0(@types/react@18.3.31)(react@19.2.6)
+      '@emotion/styled': 11.14.1(@emotion/react@11.14.0(@types/react@18.3.31)(react@19.2.6))(@types/react@18.3.31)(react@19.2.6)
+      '@hookform/resolvers': 5.4.0(react-hook-form@7.77.0(react@19.2.6))
+      '@lottiefiles/react-lottie-player': 3.6.0(react@19.2.6)
+      '@mantine/charts': 7.17.8(@mantine/core@7.17.8(@mantine/hooks@7.17.8(react@19.2.6))(@types/react@18.3.31)(react-dom@19.2.6(react@19.2.6))(react@19.2.6))(@mantine/hooks@7.17.8(react@19.2.6))(react-dom@19.2.6(react@19.2.6))(react@19.2.6)(recharts@3.8.1(@types/react@18.3.31)(react-dom@19.2.6(react@19.2.6))(react-is@19.2.7)(react@19.2.6)(redux@5.0.1))
+      '@mantine/core': 7.17.8(@mantine/hooks@7.17.8(react@19.2.6))(@types/react@18.3.31)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@mantine/dates': 7.17.8(@mantine/core@7.17.8(@mantine/hooks@7.17.8(react@19.2.6))(@types/react@18.3.31)(react-dom@19.2.6(react@19.2.6))(react@19.2.6))(@mantine/hooks@7.17.8(react@19.2.6))(dayjs@1.11.21)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@mantine/hooks': 7.17.8(react@19.2.6)
+      '@mantine/notifications': 7.17.8(@mantine/core@7.17.8(@mantine/hooks@7.17.8(react@19.2.6))(@types/react@18.3.31)(react-dom@19.2.6(react@19.2.6))(react@19.2.6))(@mantine/hooks@7.17.8(react@19.2.6))(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-accordion': 1.2.13(@types/react-dom@18.3.7(@types/react@18.3.31))(@types/react@18.3.31)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-alert-dialog': 1.1.16(@types/react-dom@18.3.7(@types/react@18.3.31))(@types/react@18.3.31)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-avatar': 1.1.12(@types/react-dom@18.3.7(@types/react@18.3.31))(@types/react@18.3.31)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-checkbox': 1.3.4(@types/react-dom@18.3.7(@types/react@18.3.31))(@types/react@18.3.31)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-collapsible': 1.1.13(@types/react-dom@18.3.7(@types/react@18.3.31))(@types/react@18.3.31)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-context-menu': 2.3.0(@types/react-dom@18.3.7(@types/react@18.3.31))(@types/react@18.3.31)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-dialog': 1.1.16(@types/react-dom@18.3.7(@types/react@18.3.31))(@types/react@18.3.31)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-dropdown-menu': 2.1.17(@types/react-dom@18.3.7(@types/react@18.3.31))(@types/react@18.3.31)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-hover-card': 1.1.16(@types/react-dom@18.3.7(@types/react@18.3.31))(@types/react@18.3.31)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-label': 2.1.9(@types/react-dom@18.3.7(@types/react@18.3.31))(@types/react@18.3.31)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-navigation-menu': 1.2.15(@types/react-dom@18.3.7(@types/react@18.3.31))(@types/react@18.3.31)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-popover': 1.1.16(@types/react-dom@18.3.7(@types/react@18.3.31))(@types/react@18.3.31)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-progress': 1.1.9(@types/react-dom@18.3.7(@types/react@18.3.31))(@types/react@18.3.31)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-radio-group': 1.4.0(@types/react-dom@18.3.7(@types/react@18.3.31))(@types/react@18.3.31)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-scroll-area': 1.2.11(@types/react-dom@18.3.7(@types/react@18.3.31))(@types/react@18.3.31)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-select': 2.3.0(@types/react-dom@18.3.7(@types/react@18.3.31))(@types/react@18.3.31)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-separator': 1.1.9(@types/react-dom@18.3.7(@types/react@18.3.31))(@types/react@18.3.31)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-slot': 1.2.5(@types/react@18.3.31)(react@19.2.6)
+      '@radix-ui/react-switch': 1.3.0(@types/react-dom@18.3.7(@types/react@18.3.31))(@types/react@18.3.31)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-tabs': 1.1.14(@types/react-dom@18.3.7(@types/react@18.3.31))(@types/react@18.3.31)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-toast': 1.2.16(@types/react-dom@18.3.7(@types/react@18.3.31))(@types/react@18.3.31)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-tooltip': 1.2.9(@types/react-dom@18.3.7(@types/react@18.3.31))(@types/react@18.3.31)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@react-pdf-viewer/core': 3.12.0(pdfjs-dist@5.4.296)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@react-pdf-viewer/default-layout': 3.12.0(pdfjs-dist@5.4.296)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@react-pdf/renderer': 4.5.1(react@19.2.6)
+      '@reduxjs/toolkit': 2.12.0(react-redux@9.3.0(@types/react@18.3.31)(react@19.2.6)(redux@5.0.1))(react@19.2.6)
+      '@tabler/icons-react': 3.44.0(react@19.2.6)
+      '@tailwindcss/vite': 4.3.0(vite@5.4.21(@types/node@24.13.1)(lightningcss@1.32.0)(terser@5.48.0))
+      '@tanstack/react-query': 5.101.0(react@19.2.6)
+      '@tanstack/react-query-devtools': 5.101.0(@tanstack/react-query@5.101.0(react@19.2.6))(react@19.2.6)
+      '@tanstack/react-table': 8.21.3(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@tinymce/tinymce-react': 6.3.0(react-dom@19.2.6(react@19.2.6))(react@19.2.6)(tinymce@7.9.3)
+      '@types/dompurify': 3.2.0
+      '@types/node': 24.13.1
+      '@types/tinymce': 4.6.9
+      axios: 1.17.0
+      class-variance-authority: 0.7.1
+      clsx: 2.1.1
+      cmdk: 1.1.1(@types/react-dom@18.3.7(@types/react@18.3.31))(@types/react@18.3.31)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      date-fns: 3.6.0
+      dayjs: 1.11.21
+      dompurify: 3.4.8
+      ethiopian-calendar-date-converter: 2.1.6
+      ethiopian-calendar-new: 1.1.0
+      file-type: 18.7.0
+      framer-motion: 12.40.0(@emotion/is-prop-valid@1.4.0)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      html2canvas: 1.4.1
+      i18next: 25.10.10(typescript@5.9.3)
+      i18next-browser-languagedetector: 8.2.1
+      jquery: 3.7.1
+      js-cookie: 3.0.8
+      jspdf: 3.0.4
+      lodash: 4.18.1
+      lucide-react: 0.513.0(react@19.2.6)
+      mantine-react-table: 2.0.0-beta.9(@mantine/core@7.17.8(@mantine/hooks@7.17.8(react@19.2.6))(@types/react@18.3.31)(react-dom@19.2.6(react@19.2.6))(react@19.2.6))(@mantine/dates@7.17.8(@mantine/core@7.17.8(@mantine/hooks@7.17.8(react@19.2.6))(@types/react@18.3.31)(react-dom@19.2.6(react@19.2.6))(react@19.2.6))(@mantine/hooks@7.17.8(react@19.2.6))(dayjs@1.11.21)(react-dom@19.2.6(react@19.2.6))(react@19.2.6))(@mantine/hooks@7.17.8(react@19.2.6))(@tabler/icons-react@3.44.0(react@19.2.6))(clsx@2.1.1)(dayjs@1.11.21)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      mui-ethiopian-datepicker: 0.3.2(4b3af212eafdf0059f009b005d7e343d)
+      next-themes: 0.4.6(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      path: 0.12.7
+      pdf-lib: 1.17.1
+      qs: 6.15.2
+      react: 19.2.6
+      react-cookie: 8.1.2(@types/react@18.3.31)(react@19.2.6)
+      react-css-nocode-editor: 1.0.13(react-dom@19.2.6(react@19.2.6))(react-is@19.2.7)(react@19.2.6)
+      react-day-picker: 8.10.2(date-fns@3.6.0)(react@19.2.6)
+      react-dom: 19.2.6(react@19.2.6)
+      react-dropzone: 14.4.1(react@19.2.6)
+      react-hook-form: 7.77.0(react@19.2.6)
+      react-i18next: 15.7.4(i18next@25.10.10(typescript@5.9.3))(react-dom@19.2.6(react@19.2.6))(react@19.2.6)(typescript@5.9.3)
+      react-icons: 5.6.0(react@19.2.6)
+      react-image-crop: 11.0.10(react@19.2.6)
+      react-intersection-observer: 9.16.0(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      react-pdf: 10.4.1(@types/react@18.3.31)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      react-pdf-html: 2.1.5(@react-pdf/renderer@4.5.1(react@19.2.6))(react@19.2.6)
+      react-redux: 9.3.0(@types/react@18.3.31)(react@19.2.6)(redux@5.0.1)
+      react-resizable-panels: 3.0.6(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      react-router-dom: 7.17.0(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      react-signature-canvas: 1.1.0-alpha.2(@types/prop-types@15.7.15)(@types/react@18.3.31)(prop-types@15.8.1)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      recharts: 3.8.1(@types/react@18.3.31)(react-dom@19.2.6(react@19.2.6))(react-is@19.2.7)(react@19.2.6)(redux@5.0.1)
+      rollup-plugin-visualizer: 7.0.1(rollup@4.61.1)
+      socket.io-client: 4.8.3
+      sonner: 2.0.7(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      tailwind-merge: 3.6.0
+      tailwind-scrollbar-hide: 4.0.0(tailwindcss@4.3.0)
+      tailwindcss: 4.3.0
+      tailwindcss-animate: 1.0.7(tailwindcss@4.3.0)
+      tinymce: 7.9.3
+      url: 0.11.4
+      vaul: 1.1.2(@types/react-dom@18.3.7(@types/react@18.3.31))(@types/react@18.3.31)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      xlsx: 0.18.5
+      zod: 3.25.76
+    transitivePeerDependencies:
+      - '@babel/core'
+      - '@emotion/is-prop-valid'
+      - '@mui/icons-material'
+      - '@mui/material'
+      - '@mui/x-date-pickers'
+      - '@types/prop-types'
+      - '@types/react'
+      - '@types/react-dom'
+      - bufferutil
+      - debug
+      - pdfjs-dist
+      - prop-types
+      - react-is
+      - react-native
+      - redux
+      - rolldown
+      - rollup
+      - supports-color
+      - typescript
+      - utf-8-validate
+      - vite
+
   '@ts-morph/common@0.27.0':
     dependencies:
       fast-glob: 3.3.3
@@ -16738,6 +16815,8 @@ snapshots:
   '@turbo/windows-arm64@2.9.16':
     optional: true
 
+  '@tweenjs/tween.js@23.1.3': {}
+
   '@tybys/wasm-util@0.10.2':
     dependencies:
       tslib: 2.8.1
@@ -16999,6 +17078,8 @@ snapshots:
 
   '@types/stack-utils@2.0.3': {}
 
+  '@types/stats.js@0.17.4': {}
+
   '@types/statuses@2.0.6': {}
 
   '@types/superagent@8.1.10':
@@ -17013,6 +17094,15 @@ snapshots:
       '@types/methods': 1.1.4
       '@types/superagent': 8.1.10
 
+  '@types/three@0.185.3':
+    dependencies:
+      '@dimforge/rapier3d-compat': 0.12.0
+      '@tweenjs/tween.js': 23.1.3
+      '@types/stats.js': 0.17.4
+      '@types/webxr': 0.5.24
+      fflate: 0.8.3
+      meshoptimizer: 1.1.1
+
   '@types/tinymce@4.6.9':
     dependencies:
       '@types/jquery': 4.0.1
@@ -17032,6 +17122,8 @@ snapshots:
 
   '@types/vorpal@1.12.8': {}
 
+  '@types/webxr@0.5.24': {}
+
   '@types/ws@8.18.1':
     dependencies:
       '@types/node': 20.19.42
@@ -17069,7 +17161,7 @@ snapshots:
       '@typescript-eslint/types': 8.60.1
       '@typescript-eslint/typescript-estree': 8.60.1(typescript@5.9.3)
       '@typescript-eslint/visitor-keys': 8.60.1
-      debug: 4.4.3(supports-color@5.5.0)
+      debug: 4.4.3(supports-color@8.1.1)
       eslint: 8.57.1
       typescript: 5.9.3
     transitivePeerDependencies:
@@ -17079,7 +17171,7 @@ snapshots:
     dependencies:
       '@typescript-eslint/tsconfig-utils': 8.60.1(typescript@5.9.3)
       '@typescript-eslint/types': 8.60.1
-      debug: 4.4.3(supports-color@5.5.0)
+      debug: 4.4.3(supports-color@8.1.1)
       typescript: 5.9.3
     transitivePeerDependencies:
       - supports-color
@@ -17098,7 +17190,7 @@ snapshots:
       '@typescript-eslint/types': 8.60.1
       '@typescript-eslint/typescript-estree': 8.60.1(typescript@5.9.3)
       '@typescript-eslint/utils': 8.60.1(eslint@8.57.1)(typescript@5.9.3)
-      debug: 4.4.3(supports-color@5.5.0)
+      debug: 4.4.3(supports-color@8.1.1)
       eslint: 8.57.1
       ts-api-utils: 2.5.0(typescript@5.9.3)
       typescript: 5.9.3
@@ -17113,7 +17205,7 @@ snapshots:
       '@typescript-eslint/tsconfig-utils': 8.60.1(typescript@5.9.3)
       '@typescript-eslint/types': 8.60.1
       '@typescript-eslint/visitor-keys': 8.60.1
-      debug: 4.4.3(supports-color@5.5.0)
+      debug: 4.4.3(supports-color@8.1.1)
       minimatch: 10.2.5
       semver: 7.8.2
       tinyglobby: 0.2.17
@@ -17402,7 +17494,7 @@ snapshots:
 
   agent-base@6.0.2:
     dependencies:
-      debug: 4.4.3(supports-color@5.5.0)
+      debug: 4.4.3(supports-color@8.1.1)
     transitivePeerDependencies:
       - supports-color
 
@@ -17642,17 +17734,6 @@ snapshots:
       normalize-path: 3.0.0
       picomatch: 2.3.2
 
-  api-common@1.2.2:
-    dependencies:
-      error-tojson: 0.0.1
-      errors: 0.3.0
-      jwt-decode: 2.2.0
-      moment: 2.30.1
-      pkginfo: 0.4.1
-      short-id-gen: 1.1.2
-      winston: 2.4.7
-      winston-daily-rotate-file: 1.7.2(winston@2.4.7)
-
   app-root-path@3.1.0: {}
 
   append-field@1.0.0: {}
@@ -17828,10 +17909,6 @@ snapshots:
 
   async-function@1.0.0: {}
 
-  async@2.6.4:
-    dependencies:
-      lodash: 4.18.1
-
   async@3.2.6: {}
 
   asynckit@0.4.0: {}
@@ -17926,6 +18003,16 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
+  babel-plugin-styled-components@2.3.0(styled-components@5.3.11(react-dom@19.2.6(react@19.2.6))(react-is@19.2.7)(react@19.2.6))(supports-color@5.5.0):
+    dependencies:
+      '@babel/helper-annotate-as-pure': 7.29.7
+      '@babel/helper-module-imports': 7.29.7(supports-color@5.5.0)
+      '@babel/plugin-syntax-jsx': 7.29.7(@babel/core@7.29.7)
+      picomatch: 4.0.4
+      styled-components: 5.3.11(react-dom@19.2.6(react@19.2.6))(react-is@19.2.7)(react@19.2.6)
+    transitivePeerDependencies:
+      - supports-color
+
   babel-polyfill@6.26.0:
     dependencies:
       babel-runtime: 6.26.0
@@ -18079,7 +18166,7 @@ snapshots:
     dependencies:
       bytes: 3.1.2
       content-type: 1.0.5
-      debug: 4.4.3(supports-color@5.5.0)
+      debug: 4.4.3(supports-color@8.1.1)
       http-errors: 2.0.1
       iconv-lite: 0.7.2
       on-finished: 2.4.1
@@ -18459,8 +18546,6 @@ snapshots:
 
   colorette@2.0.20: {}
 
-  colors@1.0.3: {}
-
   colors@1.4.0:
     optional: true
 
@@ -18694,8 +18779,6 @@ snapshots:
 
   csstype@3.2.3: {}
 
-  cycle@1.0.3: {}
-
   cypress@15.18.1:
     dependencies:
       '@cypress/request': 4.0.1
@@ -19080,7 +19163,7 @@ snapshots:
   engine.io-client@6.6.5:
     dependencies:
       '@socket.io/component-emitter': 3.1.2
-      debug: 4.4.3(supports-color@5.5.0)
+      debug: 4.4.3(supports-color@8.1.1)
       engine.io-parser: 5.2.3
       ws: 8.20.1
       xmlhttprequest-ssl: 2.1.2
@@ -19100,7 +19183,7 @@ snapshots:
       base64id: 2.0.0
       cookie: 0.7.2
       cors: 2.8.6
-      debug: 4.4.3(supports-color@5.5.0)
+      debug: 4.4.3(supports-color@8.1.1)
       engine.io-parser: 5.2.3
       ws: 8.21.0
     transitivePeerDependencies:
@@ -19143,10 +19226,6 @@ snapshots:
 
   error-symbol@0.1.0: {}
 
-  error-tojson@0.0.1: {}
-
-  errors@0.3.0: {}
-
   es-abstract@1.24.2:
     dependencies:
       array-buffer-byte-length: 1.0.2
@@ -19333,7 +19412,7 @@ snapshots:
   eslint-import-resolver-typescript@3.10.1(eslint-plugin-import@2.32.0(@typescript-eslint/parser@8.60.1(eslint@8.57.1)(typescript@5.9.3))(eslint@8.57.1))(eslint@8.57.1):
     dependencies:
       '@nolyfill/is-core-module': 1.0.39
-      debug: 4.4.3(supports-color@5.5.0)
+      debug: 4.4.3(supports-color@8.1.1)
       eslint: 8.57.1
       get-tsconfig: 4.14.0
       is-bun-module: 2.0.0
@@ -19461,7 +19540,7 @@ snapshots:
       ajv: 6.15.0
       chalk: 4.1.2
       cross-spawn: 7.0.6
-      debug: 4.4.3(supports-color@5.5.0)
+      debug: 4.4.3(supports-color@8.1.1)
       doctrine: 3.0.0
       escape-string-regexp: 4.0.0
       eslint-scope: 7.2.2
@@ -19691,7 +19770,7 @@ snapshots:
       content-type: 1.0.5
       cookie: 0.7.2
       cookie-signature: 1.2.2
-      debug: 4.4.3(supports-color@5.5.0)
+      debug: 4.4.3(supports-color@8.1.1)
       depd: 2.0.0
       encodeurl: 2.0.0
       escape-html: 1.0.3
@@ -19744,7 +19823,7 @@ snapshots:
 
   extract-zip@2.0.1:
     dependencies:
-      debug: 4.4.3(supports-color@5.5.0)
+      debug: 4.4.3(supports-color@8.1.1)
       get-stream: 5.2.0
       yauzl: 2.10.0
     optionalDependencies:
@@ -19754,8 +19833,6 @@ snapshots:
 
   extsprintf@1.3.0: {}
 
-  eyes@0.1.8: {}
-
   falsey@0.3.2:
     dependencies:
       kind-of: 5.1.0
@@ -19897,7 +19974,7 @@ snapshots:
 
   finalhandler@2.1.1:
     dependencies:
-      debug: 4.4.3(supports-color@5.5.0)
+      debug: 4.4.3(supports-color@8.1.1)
       encodeurl: 2.0.0
       escape-html: 1.0.3
       on-finished: 2.4.1
@@ -20143,7 +20220,7 @@ snapshots:
     dependencies:
       basic-ftp: 5.3.1
       data-uri-to-buffer: 6.0.2
-      debug: 4.4.3(supports-color@5.5.0)
+      debug: 4.4.3(supports-color@8.1.1)
     transitivePeerDependencies:
       - supports-color
 
@@ -20424,7 +20501,7 @@ snapshots:
   http-proxy-agent@7.0.2:
     dependencies:
       agent-base: 7.1.4
-      debug: 4.4.3(supports-color@5.5.0)
+      debug: 4.4.3(supports-color@8.1.1)
     transitivePeerDependencies:
       - supports-color
 
@@ -20437,14 +20514,14 @@ snapshots:
   https-proxy-agent@5.0.1:
     dependencies:
       agent-base: 6.0.2
-      debug: 4.4.3(supports-color@5.5.0)
+      debug: 4.4.3(supports-color@8.1.1)
     transitivePeerDependencies:
       - supports-color
 
   https-proxy-agent@7.0.6:
     dependencies:
       agent-base: 7.1.4
-      debug: 4.4.3(supports-color@5.5.0)
+      debug: 4.4.3(supports-color@8.1.1)
     transitivePeerDependencies:
       - supports-color
 
@@ -20869,7 +20946,7 @@ snapshots:
 
   istanbul-lib-source-maps@4.0.1:
     dependencies:
-      debug: 4.4.3(supports-color@5.5.0)
+      debug: 4.4.3(supports-color@8.1.1)
       istanbul-lib-coverage: 3.2.2
       source-map: 0.6.1
     transitivePeerDependencies:
@@ -21401,8 +21478,6 @@ snapshots:
       jwa: 2.0.1
       safe-buffer: 5.2.1
 
-  jwt-decode@2.2.0: {}
-
   keyv@4.5.4:
     dependencies:
       json-buffer: 3.0.1
@@ -21517,7 +21592,7 @@ snapshots:
     dependencies:
       chalk: 5.6.2
       commander: 13.1.0
-      debug: 4.4.3(supports-color@5.5.0)
+      debug: 4.4.3(supports-color@8.1.1)
       execa: 8.0.1
       lilconfig: 3.1.3
       listr2: 8.3.3
@@ -21803,6 +21878,8 @@ snapshots:
 
   merge2@1.4.1: {}
 
+  meshoptimizer@1.1.1: {}
+
   methods@1.1.2: {}
 
   micromatch@3.1.10:
@@ -21866,8 +21943,6 @@ snapshots:
     dependencies:
       brace-expansion: 2.1.1
 
-  minimist@0.0.8: {}
-
   minimist@1.2.8: {}
 
   minio@7.1.3:
@@ -21896,10 +21971,6 @@ snapshots:
       for-in: 1.0.2
       is-extendable: 1.0.1
 
-  mkdirp@0.5.1:
-    dependencies:
-      minimist: 0.0.8
-
   mkdirp@0.5.6:
     dependencies:
       minimist: 1.2.8
@@ -22318,7 +22389,7 @@ snapshots:
     dependencies:
       '@tootallnate/quickjs-emscripten': 0.23.0
       agent-base: 7.1.4
-      debug: 4.4.3(supports-color@5.5.0)
+      debug: 4.4.3(supports-color@8.1.1)
       get-uri: 6.0.5
       http-proxy-agent: 7.0.2
       https-proxy-agent: 7.0.6
@@ -22508,8 +22579,6 @@ snapshots:
       exsolve: 1.0.8
       pathe: 2.0.3
 
-  pkginfo@0.4.1: {}
-
   playwright-core@1.61.1: {}
 
   playwright@1.61.1:
@@ -22658,7 +22727,7 @@ snapshots:
   proxy-agent@6.5.0:
     dependencies:
       agent-base: 7.1.4
-      debug: 4.4.3(supports-color@5.5.0)
+      debug: 4.4.3(supports-color@8.1.1)
       http-proxy-agent: 7.0.2
       https-proxy-agent: 7.0.6
       lru-cache: 7.18.3
@@ -22687,7 +22756,7 @@ snapshots:
     dependencies:
       '@puppeteer/browsers': 2.13.2
       chromium-bidi: 14.0.0(devtools-protocol@0.0.1608973)
-      debug: 4.4.3(supports-color@5.5.0)
+      debug: 4.4.3(supports-color@8.1.1)
       devtools-protocol: 0.0.1608973
       typed-query-selector: 2.12.2
       webdriver-bidi-protocol: 0.4.1
@@ -22940,6 +23009,15 @@ snapshots:
       - '@babel/core'
       - react-is
 
+  react-css-nocode-editor@1.0.13(react-dom@19.2.6(react@19.2.6))(react-is@19.2.7)(react@19.2.6):
+    dependencies:
+      react: 19.2.6
+      react-dom: 19.2.6(react@19.2.6)
+      styled-components: 5.3.11(react-dom@19.2.6(react@19.2.6))(react-is@19.2.7)(react@19.2.6)
+    transitivePeerDependencies:
+      - '@babel/core'
+      - react-is
+
   react-day-picker@8.10.2(date-fns@3.6.0)(react@19.2.6):
     dependencies:
       date-fns: 3.6.0
@@ -23513,7 +23591,7 @@ snapshots:
 
   router@2.2.0:
     dependencies:
-      debug: 4.4.3(supports-color@5.5.0)
+      debug: 4.4.3(supports-color@8.1.1)
       depd: 2.0.0
       is-promise: 4.0.0
       parseurl: 1.3.3
@@ -23631,7 +23709,7 @@ snapshots:
 
   send@1.2.1:
     dependencies:
-      debug: 4.4.3(supports-color@5.5.0)
+      debug: 4.4.3(supports-color@8.1.1)
       encodeurl: 2.0.0
       escape-html: 1.0.3
       etag: 1.8.1
@@ -23763,8 +23841,6 @@ snapshots:
 
   shebang-regex@3.0.0: {}
 
-  short-id-gen@1.1.2: {}
-
   side-channel-list@1.0.1:
     dependencies:
       es-errors: 1.3.0
@@ -23849,7 +23925,7 @@ snapshots:
 
   socket.io-adapter@2.5.8:
     dependencies:
-      debug: 4.4.3(supports-color@5.5.0)
+      debug: 4.4.3(supports-color@8.1.1)
       ws: 8.21.0
     transitivePeerDependencies:
       - bufferutil
@@ -23859,7 +23935,7 @@ snapshots:
   socket.io-client@4.8.3:
     dependencies:
       '@socket.io/component-emitter': 3.1.2
-      debug: 4.4.3(supports-color@5.5.0)
+      debug: 4.4.3(supports-color@8.1.1)
       engine.io-client: 6.6.5
       socket.io-parser: 4.2.6
     transitivePeerDependencies:
@@ -23870,7 +23946,7 @@ snapshots:
   socket.io-parser@4.2.6:
     dependencies:
       '@socket.io/component-emitter': 3.1.2
-      debug: 4.4.3(supports-color@5.5.0)
+      debug: 4.4.3(supports-color@8.1.1)
     transitivePeerDependencies:
       - supports-color
 
@@ -23879,7 +23955,7 @@ snapshots:
       accepts: 1.3.8
       base64id: 2.0.0
       cors: 2.8.6
-      debug: 4.4.3(supports-color@5.5.0)
+      debug: 4.4.3(supports-color@8.1.1)
       engine.io: 6.6.9
       socket.io-adapter: 2.5.8
       socket.io-parser: 4.2.6
@@ -23891,7 +23967,7 @@ snapshots:
   socks-proxy-agent@8.0.5:
     dependencies:
       agent-base: 7.1.4
-      debug: 4.4.3(supports-color@5.5.0)
+      debug: 4.4.3(supports-color@8.1.1)
       socks: 2.8.9
     transitivePeerDependencies:
       - supports-color
@@ -23966,8 +24042,6 @@ snapshots:
 
   stable-hash@0.0.5: {}
 
-  stack-trace@0.0.10: {}
-
   stack-utils@2.0.6:
     dependencies:
       escape-string-regexp: 2.0.0
@@ -24171,6 +24245,24 @@ snapshots:
     transitivePeerDependencies:
       - '@babel/core'
 
+  styled-components@5.3.11(react-dom@19.2.6(react@19.2.6))(react-is@19.2.7)(react@19.2.6):
+    dependencies:
+      '@babel/helper-module-imports': 7.29.7(supports-color@5.5.0)
+      '@babel/traverse': 7.29.7(supports-color@5.5.0)
+      '@emotion/is-prop-valid': 1.4.0
+      '@emotion/stylis': 0.8.5
+      '@emotion/unitless': 0.7.5
+      babel-plugin-styled-components: 2.3.0(styled-components@5.3.11(react-dom@19.2.6(react@19.2.6))(react-is@19.2.7)(react@19.2.6))(supports-color@5.5.0)
+      css-to-react-native: 3.2.0
+      hoist-non-react-statics: 3.3.2
+      react: 19.2.6
+      react-dom: 19.2.6(react@19.2.6)
+      react-is: 19.2.7
+      shallowequal: 1.1.0
+      supports-color: 5.5.0
+    transitivePeerDependencies:
+      - '@babel/core'
+
   styled-jsx@5.1.1(babel-plugin-macros@3.1.0)(react@18.3.1):
     dependencies:
       client-only: 0.0.1
@@ -24196,7 +24288,7 @@ snapshots:
     dependencies:
       component-emitter: 1.3.1
       cookiejar: 2.1.4
-      debug: 4.4.3(supports-color@5.5.0)
+      debug: 4.4.3(supports-color@8.1.1)
       fast-safe-stringify: 2.1.1
       form-data: 4.0.5
       formidable: 3.5.4
@@ -24379,6 +24471,8 @@ snapshots:
     dependencies:
       any-promise: 1.3.0
 
+  three@0.185.1: {}
+
   throttleit@1.0.1: {}
 
   through2@2.0.5:
@@ -24703,7 +24797,7 @@ snapshots:
       app-root-path: 3.1.0
       buffer: 6.0.3
       dayjs: 1.11.21
-      debug: 4.4.3(supports-color@5.5.0)
+      debug: 4.4.3(supports-color@8.1.1)
       dedent: 1.7.2(babel-plugin-macros@3.1.0)
       dotenv: 16.6.1
       glob: 10.5.0
@@ -24727,7 +24821,7 @@ snapshots:
       app-root-path: 3.1.0
       buffer: 6.0.3
       dayjs: 1.11.21
-      debug: 4.4.3(supports-color@5.5.0)
+      debug: 4.4.3(supports-color@8.1.1)
       dedent: 1.7.2(babel-plugin-macros@3.1.0)
       dotenv: 16.6.1
       glob: 10.5.0
@@ -25030,7 +25124,7 @@ snapshots:
   vite-node@2.1.9(@types/node@22.20.1)(lightningcss@1.32.0)(terser@5.48.0):
     dependencies:
       cac: 6.7.14
-      debug: 4.4.3(supports-color@5.5.0)
+      debug: 4.4.3(supports-color@8.1.1)
       es-module-lexer: 1.7.0
       pathe: 1.1.2
       vite: 5.4.21(@types/node@22.20.1)(lightningcss@1.32.0)(terser@5.48.0)
@@ -25048,7 +25142,7 @@ snapshots:
   vite-node@2.1.9(@types/node@24.13.1)(lightningcss@1.32.0)(terser@5.48.0):
     dependencies:
       cac: 6.7.14
-      debug: 4.4.3(supports-color@5.5.0)
+      debug: 4.4.3(supports-color@8.1.1)
       es-module-lexer: 1.7.0
       pathe: 1.1.2
       vite: 5.4.21(@types/node@24.13.1)(lightningcss@1.32.0)(terser@5.48.0)
@@ -25095,7 +25189,7 @@ snapshots:
       '@vitest/spy': 2.1.9
       '@vitest/utils': 2.1.9
       chai: 5.3.3
-      debug: 4.4.3(supports-color@5.5.0)
+      debug: 4.4.3(supports-color@8.1.1)
       expect-type: 1.3.0
       magic-string: 0.30.21
       pathe: 1.1.2
@@ -25131,7 +25225,7 @@ snapshots:
       '@vitest/spy': 2.1.9
       '@vitest/utils': 2.1.9
       chai: 5.3.3
-      debug: 4.4.3(supports-color@5.5.0)
+      debug: 4.4.3(supports-color@8.1.1)
       expect-type: 1.3.0
       magic-string: 0.30.21
       pathe: 1.1.2
@@ -25321,20 +25415,6 @@ snapshots:
       siginfo: 2.0.0
       stackback: 0.0.2
 
-  winston-daily-rotate-file@1.7.2(winston@2.4.7):
-    dependencies:
-      mkdirp: 0.5.1
-      winston: 2.4.7
-
-  winston@2.4.7:
-    dependencies:
-      async: 2.6.4
-      colors: 1.0.3
-      cycle: 1.0.3
-      eyes: 0.1.8
-      isstream: 0.1.2
-      stack-trace: 0.0.10
-
   wmf@1.0.2: {}
 
   word-wrap@1.2.5: {}
diff --git a/sonar-project.properties b/sonar-project.properties
new file mode 100644
index 000000000..793b6128b
--- /dev/null
+++ b/sonar-project.properties
@@ -0,0 +1,13 @@
+sonar.projectKey=edr-platform
+sonar.projectName=EDR Platform
+
+sonar.sources=apps,packages
+sonar.exclusions=**/node_modules/**,**/dist/**,**/build/**,**/*.spec.ts,**/*.test.ts,**/*.e2e-spec.ts,**/coverage/**,**/.turbo/**,e2e/**,integration/**
+
+sonar.tests=apps,packages
+sonar.test.inclusions=**/*.spec.ts,**/*.test.ts
+
+sonar.javascript.lcov.reportPaths=apps/*/coverage/lcov.info,apps/edr-freight-web/*/coverage/lcov.info,apps/edr-passenger-web/*/coverage/lcov.info,packages/*/coverage/lcov.info
+sonar.typescript.lcov.reportPaths=apps/*/coverage/lcov.info,apps/edr-freight-web/*/coverage/lcov.info,apps/edr-passenger-web/*/coverage/lcov.info,packages/*/coverage/lcov.info
+
+sonar.sourceEncoding=UTF-8