diff --git a/.github/workflows/deploy.yml b/.github/workflows/deploy.yml
index 72ad6de66..62530611c 100644
--- a/.github/workflows/deploy.yml
+++ b/.github/workflows/deploy.yml
@@ -182,24 +182,6 @@ jobs:
           set -euo pipefail
           docker compose --project-name "${COMPOSE_PROJECT_NAME}" up -d "${{ matrix.service }}" --force-recreate
 
-      - name: Verify deployment health
-        if: contains(fromJson('["passenger-api", "payment-api"]'), matrix.service)
-        run: |
-          set -euo pipefail
-          PORT=$(grep '^PORT=' "${SERVICE_ENV_FILE}" | cut -d= -f2)
-          echo "Waiting for service to become healthy on port ${PORT}..."
-          for i in $(seq 1 12); do
-            if wget -qO- "http://localhost:${PORT}/health/ready" 2>/dev/null | grep -q '"status":"ok"'; then
-              echo "Service is healthy."
-              exit 0
-            fi
-            echo "Attempt ${i}/12 — not ready yet, waiting 10s..."
-            sleep 10
-          done
-          echo "Service failed health check after 120s — rolling back"
-          docker compose --project-name "${COMPOSE_PROJECT_NAME}" up -d "${{ matrix.service }}" --force-recreate || true
-          exit 1
-
       - name: Remove npm credentials from workspace
         if: always()
         run: rm -f .npmrc .npmrc_temp
diff --git a/apps/edr-freight-api/.env.example b/apps/edr-freight-api/.env.example
index 1ed8ff9fc..5bce9de95 100644
--- a/apps/edr-freight-api/.env.example
+++ b/apps/edr-freight-api/.env.example
@@ -61,4 +61,25 @@ REDIS_PORT=6379
 RABBITMQ_ENABLED=false
 RABBITMQ_URL=amqp://localhost:5672
 SMS_QUEUE=sms_queue
+
+# ── VeriFayda 2.0 (eSignet OIDC) identity verification ──────────────────────
+# Disabled by default; /fayda/verification/start returns 503 until enabled.
+FAYDA_ENABLED=false
+FAYDA_CLIENT_ID=
+FAYDA_AUTHORIZATION_ENDPOINT=
+FAYDA_TOKEN_ENDPOINT=
+FAYDA_USERINFO_ENDPOINT=
+# Base64-encoded RSA private JWK used for the private_key_jwt client assertion
+FAYDA_PRIVATE_KEY_BASE64=
+# OAuth redirect_uri for MOBILE clients (must be registered with eSignet)
+FAYDA_REDIRECT_URI=http://localhost:3001/api/fayda/verification/complete
+# OAuth redirect_uri for WEB clients. Defaults to FAYDA_REDIRECT_URI when unset.
+FAYDA_WEB_REDIRECT_URI=http://localhost:3000/callback
+CLIENT_ASSERTION_TYPE=urn:ietf:params:oauth:client-assertion-type:jwt-bearer
+FAYDA_SCOPE=openid profile email phone address
+FAYDA_ACR_VALUES=mosip:idp:acr:generated-code
+FAYDA_CLAIMS_LOCALES=en am
+FAYDA_SESSION_TTL_MINUTES=10
+EXPIRATION_TIME=15
+ALGORITHM=RS256
 EMAIL_QUEUE=email_queue
diff --git a/apps/edr-freight-api/package.json b/apps/edr-freight-api/package.json
index a0a119861..39eed76ea 100644
--- a/apps/edr-freight-api/package.json
+++ b/apps/edr-freight-api/package.json
@@ -22,6 +22,7 @@
     "seed:export-djibouti-interchange-demo": "ts-node -r tsconfig-paths/register src/scripts/seed-export-djibouti-interchange-demo.ts",
     "seed:import-djibouti-demo": "ts-node -r tsconfig-paths/register src/scripts/seed-import-djibouti-demo.ts",
     "seed:approved-first-lastmile-demo-bookings": "ts-node -r tsconfig-paths/register src/scripts/seed-approved-first-lastmile-demo-bookings.ts",
+    "seed:paid-import-export-mile-demo": "ts-node -r tsconfig-paths/register src/scripts/seed-paid-import-export-mile-demo.ts",
     "seed:negad-indode-arrived-train": "ts-node -r tsconfig-paths/register src/scripts/seed-negad-indode-arrived-train.ts",
     "seed:gate-pass-train-scenarios": "ts-node -r tsconfig-paths/register src/scripts/seed-gate-pass-train-scenarios.ts",
     "auto-unload:arrived-import-trains": "ts-node -r tsconfig-paths/register src/scripts/auto-unload-arrived-import-trains.ts",
@@ -63,6 +64,7 @@
     "dotenv": "^17.4.2",
     "dotenv-cli": "^11.0.0",
     "handlebars": "^4.7.9",
+    "jose": "^5.10.0",
     "libphonenumber-js": "^1.13.6",
     "minio": "7.1.3",
     "pg": "^8.13.0",
diff --git a/apps/edr-freight-api/src/app.module.ts b/apps/edr-freight-api/src/app.module.ts
index f40e4f40f..c2a3a5abb 100644
--- a/apps/edr-freight-api/src/app.module.ts
+++ b/apps/edr-freight-api/src/app.module.ts
@@ -1,4 +1,8 @@
-import { Module, OnApplicationBootstrap } from "@nestjs/common";
+import {
+  MiddlewareConsumer,
+  Module,
+  OnApplicationBootstrap,
+} from "@nestjs/common";
 import { ConfigModule, ConfigService } from "@nestjs/config";
 import { TypeOrmModule, TypeOrmModuleOptions } from "@nestjs/typeorm";
 import { ScheduleModule } from "@nestjs/schedule";
@@ -12,6 +16,7 @@ import appConfig from "./config/app.config";
 import databaseConfig from "./config/database.config";
 import telebirrConfig from "./config/telebirr.config";
 import rabbitmqConfig from "./config/rabbitmq.config";
+import faydaConfig from "./config/fayda.config";
 
 import { BookingsModule } from "./modules/bookings/bookings.module";
 import { ContractsModule } from "./modules/contracts/contracts.module";
@@ -59,28 +64,32 @@ import { FreightPermissionKeyMigrationSeeder } from "./seed/freight-permission-k
 import { DemoFreightDataSeeder } from "./seed/demo-freight-data.seeder";
 import { GovCompaniesSeeder } from "./seed/gov-companies.seeder";
 import { ApprovedFirstLastMileDemoBookingsSeeder } from "./seed/approved-first-lastmile-demo-bookings.seeder";
+import { PaidImportExportMileDemoSeeder } from "./seed/paid-import-export-mile-demo.seeder";
 //New Trains, Wagons, Container and Cargo management modules
 import { TrainsModule } from "./modules/trains/trains.module";
-import { WagonsModule } from './modules/wagons/wagons.module';
-import { ContainersModule } from './modules/container-management/containers.module';
-import { CargoesModule } from './modules/cargoes/cargoes.module';
-import { RoutesModule } from './modules/routes/routes.module';
-import { WarehousesModule } from './modules/warehouses/warehouses.module';
-import { OverviewModule } from './modules/overview/overview.module';
-import { VehiclesModule } from './modules/vehicles/vehicles.module';
-import { DriversModule } from './modules/drivers/drivers.module';
-import { FuelModule } from './modules/fuel/fuel.module';
-import { MaintenanceModule } from './modules/maintenance/maintenance.module';
-import { FirstMileModule } from './modules/first-mile/first-mile.module';
-import { LastMileModule } from './modules/last-mile/last-mile.module';
-import { InterchangeDocumentsModule } from './modules/interchange-documents/interchange-documents.module';
-import { ImportOperationsModule } from './modules/import-operations/import-operations.module';
+import { VerifaydaModule } from './modules/verifayda/verifayda.module';
+import { FleetHistoryModule } from './modules/fleet-history/fleet-history.module';
+import { WagonsModule } from "./modules/wagons/wagons.module";
+import { ContainersModule } from "./modules/container-management/containers.module";
+import { CargoesModule } from "./modules/cargoes/cargoes.module";
+import { RoutesModule } from "./modules/routes/routes.module";
+import { WarehousesModule } from "./modules/warehouses/warehouses.module";
+import { OverviewModule } from "./modules/overview/overview.module";
+import { VehiclesModule } from "./modules/vehicles/vehicles.module";
+import { DriversModule } from "./modules/drivers/drivers.module";
+import { FuelModule } from "./modules/fuel/fuel.module";
+import { MaintenanceModule } from "./modules/maintenance/maintenance.module";
+import { FirstMileModule } from "./modules/first-mile/first-mile.module";
+import { LastMileModule } from "./modules/last-mile/last-mile.module";
+import { InterchangeDocumentsModule } from "./modules/interchange-documents/interchange-documents.module";
+import { ImportOperationsModule } from "./modules/import-operations/import-operations.module";
+import { LoggerMiddleware } from "./logger.middleware";
 
 @Module({
   imports: [
     ConfigModule.forRoot({
       isGlobal: true,
-      load: [appConfig, databaseConfig, telebirrConfig, rabbitmqConfig],
+      load: [appConfig, databaseConfig, telebirrConfig, rabbitmqConfig, faydaConfig],
     }),
     ScheduleModule.forRoot(),
     EventEmitterModule.forRoot(),
@@ -141,6 +150,8 @@ import { ImportOperationsModule } from './modules/import-operations/import-opera
     LastMileModule,
     InterchangeDocumentsModule,
     ImportOperationsModule,
+    VerifaydaModule,
+    FleetHistoryModule,
   ],
   providers: [
     EdrOrgSeeder,
@@ -160,6 +171,7 @@ import { ImportOperationsModule } from './modules/import-operations/import-opera
     ExportDjiboutiInterchangeDemoSeeder,
     MarshallingDemoTrainsSeeder,
     ApprovedFirstLastMileDemoBookingsSeeder,
+    PaidImportExportMileDemoSeeder,
   ],
 })
 export class AppModule implements OnApplicationBootstrap {
@@ -211,4 +223,8 @@ export class AppModule implements OnApplicationBootstrap {
     // bookings bill to. Idempotent — keyed by fixed IDs.
     await this.govCompaniesSeeder.run();
   }
+
+  configure(consumer: MiddlewareConsumer) {
+    consumer.apply(LoggerMiddleware).forRoutes("*");
+  }
 }
diff --git a/apps/edr-freight-api/src/config/fayda.config.ts b/apps/edr-freight-api/src/config/fayda.config.ts
new file mode 100644
index 000000000..a25289159
--- /dev/null
+++ b/apps/edr-freight-api/src/config/fayda.config.ts
@@ -0,0 +1,126 @@
+import { registerAs } from '@nestjs/config';
+
+export interface FaydaJwk {
+  kty: 'RSA';
+  use?: string;
+  kid?: string;
+  alg?: string;
+  n: string;
+  e: string;
+  d: string;
+  p?: string;
+  q?: string;
+  dp?: string;
+  dq?: string;
+  qi?: string;
+}
+
+export type FaydaPlatform = 'WEB' | 'MOBILE';
+
+export interface FaydaConfig {
+  enabled: boolean;
+  clientId: string;
+  authorizationEndpoint: string;
+  tokenEndpoint: string;
+  userInfoEndpoint: string;
+  /** OAuth redirect_uri sent to eSignet for MOBILE clients. */
+  redirectUri: string;
+  /** OAuth redirect_uri sent to eSignet for WEB clients. Falls back to `redirectUri`. */
+  webRedirectUri: string;
+  privateJwk: FaydaJwk;
+  scope: string;
+  acrValues: string;
+  claimsLocales: string;
+  sessionTtlMinutes: number;
+}
+
+const REQUIRED_VARS = [
+  'FAYDA_CLIENT_ID',
+  'FAYDA_AUTHORIZATION_ENDPOINT',
+  'FAYDA_TOKEN_ENDPOINT',
+  'FAYDA_USERINFO_ENDPOINT',
+  'FAYDA_PRIVATE_KEY_BASE64',
+] as const;
+
+function decodePrivateJwk(base64: string): FaydaJwk {
+  let jwk: unknown;
+  try {
+    const json = Buffer.from(base64, 'base64').toString('utf8');
+    jwk = JSON.parse(json);
+  } catch (err) {
+    throw new Error(
+      `FAYDA_PRIVATE_KEY_BASE64 is not valid Base64-encoded JSON: ${(err as Error).message}`,
+    );
+  }
+  if (!jwk || typeof jwk !== 'object') {
+    throw new Error('FAYDA_PRIVATE_KEY_BASE64 must decode to a JSON object');
+  }
+  const candidate = jwk as Partial<FaydaJwk>;
+  if (candidate.kty !== 'RSA') {
+    throw new Error('FAYDA_PRIVATE_KEY_BASE64 JWK must have kty="RSA"');
+  }
+  if (!candidate.n || !candidate.e || !candidate.d) {
+    throw new Error(
+      'FAYDA_PRIVATE_KEY_BASE64 JWK is missing required RSA private-key fields (n, e, d)',
+    );
+  }
+  return candidate as FaydaJwk;
+}
+
+export default registerAs('fayda', (): FaydaConfig => {
+  const enabled = (process.env.FAYDA_ENABLED ?? 'false').toLowerCase() === 'true';
+  // `profile` covers name/birthdate/gender/picture; `email`, `phone`, `address`
+  // are needed so the matching essential claims aren't rejected as out-of-scope.
+  const scope = process.env.FAYDA_SCOPE ?? 'openid profile email phone address';
+  const acrValues = process.env.FAYDA_ACR_VALUES ?? 'mosip:idp:acr:generated-code';
+  const claimsLocales = process.env.FAYDA_CLAIMS_LOCALES ?? 'en am';
+  const sessionTtl = Number.parseInt(process.env.FAYDA_SESSION_TTL_MINUTES ?? '10', 10);
+  const redirectUri = process.env.FAYDA_REDIRECT_URI ?? '';
+  const webRedirectUri = process.env.FAYDA_WEB_REDIRECT_URI || redirectUri;
+  if (!enabled) {
+    return {
+      enabled: false,
+      clientId: process.env.FAYDA_CLIENT_ID ?? '',
+      authorizationEndpoint: process.env.FAYDA_AUTHORIZATION_ENDPOINT ?? '',
+      tokenEndpoint: process.env.FAYDA_TOKEN_ENDPOINT ?? '',
+      userInfoEndpoint: process.env.FAYDA_USERINFO_ENDPOINT ?? '',
+      redirectUri,
+      webRedirectUri,
+      privateJwk: { kty: 'RSA', n: '', e: '', d: '' },
+      scope,
+      acrValues,
+      claimsLocales,
+      sessionTtlMinutes: Number.isNaN(sessionTtl) || sessionTtl <= 0 ? 10 : sessionTtl,
+    };
+  }
+
+  const missing = REQUIRED_VARS.filter((name) => !process.env[name]);
+  if (missing.length > 0) {
+    throw new Error(
+      `Fayda integration is enabled (FAYDA_ENABLED=true) but the following env vars are missing: ${missing.join(', ')}`,
+    );
+  }
+  if (!redirectUri) {
+    throw new Error(
+      'Fayda integration is enabled but the redirect URI is missing: set FAYDA_REDIRECT_URI',
+    );
+  }
+  if (Number.isNaN(sessionTtl) || sessionTtl <= 0) {
+    throw new Error('FAYDA_SESSION_TTL_MINUTES must be a positive integer');
+  }
+
+  return {
+    enabled: true,
+    clientId: process.env.FAYDA_CLIENT_ID!,
+    authorizationEndpoint: process.env.FAYDA_AUTHORIZATION_ENDPOINT!,
+    tokenEndpoint: process.env.FAYDA_TOKEN_ENDPOINT!,
+    userInfoEndpoint: process.env.FAYDA_USERINFO_ENDPOINT!,
+    redirectUri,
+    webRedirectUri,
+    privateJwk: decodePrivateJwk(process.env.FAYDA_PRIVATE_KEY_BASE64!),
+    scope,
+    acrValues,
+    claimsLocales,
+    sessionTtlMinutes: sessionTtl,
+  };
+});
diff --git a/apps/edr-freight-api/src/logger.middleware.ts b/apps/edr-freight-api/src/logger.middleware.ts
new file mode 100644
index 000000000..dd7532ec8
--- /dev/null
+++ b/apps/edr-freight-api/src/logger.middleware.ts
@@ -0,0 +1,21 @@
+import { Injectable, NestMiddleware, Logger } from "@nestjs/common";
+import { Request, Response, NextFunction } from "express";
+
+@Injectable()
+export class LoggerMiddleware implements NestMiddleware {
+  private readonly logger = new Logger("HTTP");
+
+  use(req: Request, res: Response, next: NextFunction) {
+    const start = Date.now();
+
+    res.on("finish", () => {
+      const duration = Date.now() - start;
+
+      this.logger.log(
+        `${req.method} ${req.originalUrl} ${res.statusCode} ${duration}ms`,
+      );
+    });
+
+    next();
+  }
+}
diff --git a/apps/edr-freight-api/src/main.ts b/apps/edr-freight-api/src/main.ts
index 0107956e4..0fa1056dd 100644
--- a/apps/edr-freight-api/src/main.ts
+++ b/apps/edr-freight-api/src/main.ts
@@ -38,7 +38,8 @@ async function bootstrap() {
     maxAge: 86400, // cache preflight for 24h to cut chatter in dev
   });
 
-  app.setGlobalPrefix("api");
+  // /callback stays un-prefixed: it's the Fayda OAuth redirect_uri ack endpoint.
+  app.setGlobalPrefix("api", { exclude: ["callback"] });
   // enableImplicitConversion is OFF: class-transformer's implicit boolean
   // coercion turns any non-empty multipart/form-data string (including the
   // literal "false") into `true`, silently corrupting flags like isHazardous
diff --git a/apps/edr-freight-api/src/migrations/1870000000000-RepairSynchronizeDrift.ts b/apps/edr-freight-api/src/migrations/1870000000000-RepairSynchronizeDrift.ts
new file mode 100644
index 000000000..32f1e6f0c
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/1870000000000-RepairSynchronizeDrift.ts
@@ -0,0 +1,269 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+/**
+ * Repairs schema drift on databases that were originally built by TypeORM
+ * `synchronize` (at an older entity snapshot) and never had their migration
+ * history recorded. Such databases have `freight.migrations` empty while most
+ * of the schema already exists, so a from-scratch migration run aborts on the
+ * first non-idempotent statement and never reaches the columns/tables added
+ * after synchronize was last used.
+ *
+ * The deployment procedure for those databases is:
+ *   1. Baseline every pre-existing migration into `freight.migrations`.
+ *   2. Run migrations — this file is the only pending one and back-fills the
+ *      objects the drift scan found missing.
+ *
+ * Every statement is idempotent (IF NOT EXISTS / guarded CREATE TYPE), so it is
+ * also safe on a clean database where the earlier migrations already created
+ * these objects — it simply no-ops.
+ */
+export class RepairSynchronizeDrift1870000000000
+  implements MigrationInterface
+{
+  name = 'RepairSynchronizeDrift1870000000000';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    // --- enum types (derived from entities that never had a source migration) ---
+    await queryRunner.query(`DO $$ BEGIN
+      CREATE TYPE freight.consignments_cargo_type_enum AS ENUM (
+        'CONTAINER', 'BULK_LIQUID', 'BULK_DRY', 'GENERAL', 'REFRIGERATED', 'HAZARDOUS'
+      );
+    EXCEPTION WHEN duplicate_object THEN null; END $$;`);
+    await queryRunner.query(`DO $$ BEGIN
+      CREATE TYPE freight.consignments_status_enum AS ENUM (
+        'PENDING', 'LOADED', 'IN_TRANSIT', 'AT_DESTINATION', 'DELIVERED', 'RETURNED'
+      );
+    EXCEPTION WHEN duplicate_object THEN null; END $$;`);
+    await queryRunner.query(`DO $$ BEGIN
+      CREATE TYPE freight.tracking_events_status_enum AS ENUM (
+        'PENDING', 'LOADED', 'IN_TRANSIT', 'AT_DESTINATION', 'DELIVERED', 'RETURNED'
+      );
+    EXCEPTION WHEN duplicate_object THEN null; END $$;`);
+
+    // --- missing tables ---
+    await queryRunner.query(`CREATE TABLE IF NOT EXISTS freight.consignments (
+      id uuid NOT NULL DEFAULT gen_random_uuid(),
+      booking_id uuid NOT NULL,
+      tracking_number varchar(64) NOT NULL,
+      cargo_type freight.consignments_cargo_type_enum NOT NULL,
+      weight_kg numeric(12, 2) NOT NULL,
+      status freight.consignments_status_enum NOT NULL DEFAULT 'PENDING',
+      origin_station varchar(128) NOT NULL,
+      destination_station varchar(128) NOT NULL,
+      created_at timestamptz NOT NULL DEFAULT now(),
+      updated_at timestamptz NOT NULL DEFAULT now(),
+      deleted_at timestamptz,
+      CONSTRAINT pk_consignments PRIMARY KEY (id),
+      CONSTRAINT uq_consignments_tracking_number UNIQUE (tracking_number)
+    );`);
+
+    await queryRunner.query(`CREATE TABLE IF NOT EXISTS freight.tracking_events (
+      id uuid NOT NULL DEFAULT gen_random_uuid(),
+      consignment_id uuid NOT NULL,
+      location varchar(256) NOT NULL,
+      status freight.tracking_events_status_enum NOT NULL,
+      occurred_at timestamptz NOT NULL,
+      description text,
+      created_at timestamptz NOT NULL DEFAULT now(),
+      updated_at timestamptz NOT NULL DEFAULT now(),
+      deleted_at timestamptz,
+      CONSTRAINT pk_tracking_events PRIMARY KEY (id)
+    );`);
+
+    await queryRunner.query(`CREATE TABLE IF NOT EXISTS freight.fuel_purchases (
+      id uuid NOT NULL DEFAULT gen_random_uuid(),
+      vehicle_id uuid NOT NULL,
+      purchase_date timestamptz NOT NULL,
+      liters numeric(10, 2) NOT NULL,
+      cost_per_liter numeric(10, 2) NOT NULL,
+      total_cost numeric(14, 2) NOT NULL,
+      fuel_station varchar(255) NULL,
+      payment_method varchar(50) DEFAULT 'CASH',
+      odometer_reading numeric(10, 2) NULL,
+      driver_id uuid NULL,
+      receipt_number varchar(255) NULL,
+      notes text NULL,
+      created_at timestamptz NOT NULL DEFAULT now(),
+      updated_at timestamptz NOT NULL DEFAULT now(),
+      deleted_at timestamptz NULL,
+      CONSTRAINT pk_fuel_purchases PRIMARY KEY (id),
+      CONSTRAINT fk_fuel_purchases_vehicle FOREIGN KEY (vehicle_id)
+        REFERENCES freight.vehicles (id) ON DELETE CASCADE
+    );`);
+    await queryRunner.query(`CREATE INDEX IF NOT EXISTS idx_fuel_purchases_vehicle ON freight.fuel_purchases (vehicle_id);`);
+    await queryRunner.query(`CREATE INDEX IF NOT EXISTS idx_fuel_purchases_date ON freight.fuel_purchases (purchase_date);`);
+
+    await queryRunner.query(`CREATE TABLE IF NOT EXISTS freight.fuel_consumption (
+      id uuid NOT NULL DEFAULT gen_random_uuid(),
+      vehicle_id uuid NOT NULL,
+      month date NOT NULL,
+      total_liters numeric(10, 2) NOT NULL,
+      total_cost numeric(14, 2) NOT NULL,
+      total_distance_km numeric(10, 2) NOT NULL,
+      fuel_efficiency_km_per_l numeric(10, 2) NULL,
+      number_of_purchases integer DEFAULT 0,
+      average_cost_per_liter numeric(10, 2) NULL,
+      created_at timestamptz NOT NULL DEFAULT now(),
+      updated_at timestamptz NOT NULL DEFAULT now(),
+      deleted_at timestamptz NULL,
+      CONSTRAINT pk_fuel_consumption PRIMARY KEY (id),
+      CONSTRAINT fk_fuel_consumption_vehicle FOREIGN KEY (vehicle_id)
+        REFERENCES freight.vehicles (id) ON DELETE CASCADE,
+      CONSTRAINT uq_fuel_consumption_vehicle_month UNIQUE (vehicle_id, month)
+    );`);
+    await queryRunner.query(`CREATE INDEX IF NOT EXISTS idx_fuel_consumption_vehicle_month ON freight.fuel_consumption (vehicle_id, month);`);
+
+    await queryRunner.query(`CREATE TABLE IF NOT EXISTS freight.maintenance_schedules (
+      id uuid NOT NULL DEFAULT gen_random_uuid(),
+      vehicle_id uuid NOT NULL,
+      maintenance_type varchar NOT NULL,
+      description varchar NOT NULL,
+      scheduled_date timestamptz NOT NULL,
+      completed_date timestamptz,
+      estimated_cost numeric(14,2),
+      actual_cost numeric(14,2),
+      status varchar NOT NULL DEFAULT 'SCHEDULED',
+      odometer_reading numeric,
+      service_provider varchar,
+      notes text,
+      next_due_km numeric,
+      next_due_date timestamptz,
+      created_at timestamptz NOT NULL DEFAULT now(),
+      updated_at timestamptz NOT NULL DEFAULT now(),
+      deleted_at timestamptz,
+      PRIMARY KEY (id)
+    );`);
+    await queryRunner.query(`CREATE INDEX IF NOT EXISTS idx_maintenance_schedules_vehicle_date ON freight.maintenance_schedules (vehicle_id, scheduled_date);`);
+
+    await queryRunner.query(`CREATE TABLE IF NOT EXISTS freight.maintenance_costs (
+      id uuid NOT NULL DEFAULT gen_random_uuid(),
+      vehicle_id uuid NOT NULL,
+      maintenance_schedule_id uuid,
+      incurred_date timestamptz NOT NULL,
+      cost_amount numeric(14,2) NOT NULL,
+      cost_type varchar NOT NULL,
+      description varchar NOT NULL,
+      service_provider varchar,
+      invoice_number varchar,
+      notes text,
+      created_at timestamptz NOT NULL DEFAULT now(),
+      updated_at timestamptz NOT NULL DEFAULT now(),
+      deleted_at timestamptz,
+      PRIMARY KEY (id),
+      CONSTRAINT fk_maintenance_schedule FOREIGN KEY (maintenance_schedule_id)
+        REFERENCES freight.maintenance_schedules (id) ON DELETE SET NULL
+    );`);
+    await queryRunner.query(`CREATE INDEX IF NOT EXISTS idx_maintenance_costs_vehicle_date ON freight.maintenance_costs (vehicle_id, incurred_date);`);
+
+    await queryRunner.query(`CREATE TABLE IF NOT EXISTS freight.otp_verifications (
+      id uuid NOT NULL DEFAULT gen_random_uuid(),
+      phone varchar NOT NULL,
+      otp varchar NOT NULL,
+      verified boolean NOT NULL DEFAULT false,
+      created_at timestamptz NOT NULL DEFAULT now(),
+      updated_at timestamptz NOT NULL DEFAULT now(),
+      deleted_at timestamptz,
+      CONSTRAINT pk_otp_verifications PRIMARY KEY (id),
+      CONSTRAINT uq_otp_verifications_phone UNIQUE (phone)
+    );`);
+
+    await queryRunner.query(`CREATE TABLE IF NOT EXISTS freight.booking_batch_offers (
+      id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+      booking_id uuid NOT NULL REFERENCES freight.bookings(id) ON DELETE CASCADE,
+      train_schedule_id uuid NOT NULL REFERENCES freight.train_schedules(id) ON DELETE CASCADE,
+      offered_wagons integer NOT NULL,
+      total_wagons integer NOT NULL,
+      offered_lines jsonb NULL,
+      offered_weight_tons numeric(12, 3) NOT NULL,
+      offered_amount numeric(14, 2) NOT NULL,
+      offered_pricing_breakdown jsonb NULL,
+      invoice_id uuid NULL,
+      payment_deadline timestamptz NOT NULL,
+      status varchar(10) NOT NULL DEFAULT 'OFFERED',
+      created_at timestamptz NOT NULL DEFAULT now(),
+      updated_at timestamptz NOT NULL DEFAULT now(),
+      deleted_at timestamptz NULL
+    );`);
+    await queryRunner.query(`CREATE INDEX IF NOT EXISTS idx_booking_batch_offers_booking ON freight.booking_batch_offers (booking_id);`);
+    await queryRunner.query(`CREATE INDEX IF NOT EXISTS idx_booking_batch_offers_schedule ON freight.booking_batch_offers (train_schedule_id);`);
+    await queryRunner.query(`CREATE INDEX IF NOT EXISTS idx_booking_batch_offers_status ON freight.booking_batch_offers (status);`);
+
+    // --- missing columns on existing tables ---
+    await queryRunner.query(`ALTER TABLE freight.invoices
+      ADD COLUMN IF NOT EXISTS subtotal_amount numeric(14, 2) NOT NULL DEFAULT 0,
+      ADD COLUMN IF NOT EXISTS tax_amount numeric(14, 2) NOT NULL DEFAULT 0,
+      ADD COLUMN IF NOT EXISTS paid_amount numeric(14, 2) NOT NULL DEFAULT 0,
+      ADD COLUMN IF NOT EXISTS balance_amount numeric(14, 2) NOT NULL DEFAULT 0,
+      ADD COLUMN IF NOT EXISTS paid_at timestamptz;`);
+
+    await queryRunner.query(`ALTER TABLE freight.bookings
+      ADD COLUMN IF NOT EXISTS booking_type varchar(20) NOT NULL DEFAULT 'ONE_TIME',
+      ADD COLUMN IF NOT EXISTS customer_truck_plate_number varchar(32),
+      ADD COLUMN IF NOT EXISTS customer_truck_driver_name varchar(120),
+      ADD COLUMN IF NOT EXISTS customer_truck_type varchar(60),
+      ADD COLUMN IF NOT EXISTS customer_truck_container_number varchar(16),
+      ADD COLUMN IF NOT EXISTS customer_truck_assigned_at timestamptz,
+      ADD COLUMN IF NOT EXISTS customer_truck_arrived_at timestamptz,
+      ADD COLUMN IF NOT EXISTS bulk_hazardous_quantity numeric(12,3) NOT NULL DEFAULT 0,
+      ADD COLUMN IF NOT EXISTS bulk_reefer_quantity numeric(12,3) NOT NULL DEFAULT 0,
+      ADD COLUMN IF NOT EXISTS clearance_current_phase varchar(40),
+      ADD COLUMN IF NOT EXISTS duty_required boolean,
+      ADD COLUMN IF NOT EXISTS vessel_departure_date date,
+      ADD COLUMN IF NOT EXISTS ro_amendment_requested_at timestamptz,
+      ADD COLUMN IF NOT EXISTS ro_hold_reason text,
+      ADD COLUMN IF NOT EXISTS pre_clearance_finalized_at timestamptz;`);
+    await queryRunner.query(`CREATE INDEX IF NOT EXISTS idx_bookings_booking_type ON freight.bookings (booking_type);`);
+
+    await queryRunner.query(`ALTER TABLE freight.cargoes
+      ADD COLUMN IF NOT EXISTS receiver_name varchar,
+      ADD COLUMN IF NOT EXISTS delivered_at timestamp,
+      ADD COLUMN IF NOT EXISTS delivery_remarks text;`);
+
+    await queryRunner.query(`ALTER TABLE freight.contract_clearance_cycles
+      ADD COLUMN IF NOT EXISTS duty_required boolean,
+      ADD COLUMN IF NOT EXISTS vessel_departure_date date,
+      ADD COLUMN IF NOT EXISTS ro_amendment_requested_at timestamptz,
+      ADD COLUMN IF NOT EXISTS ro_hold_reason text,
+      ADD COLUMN IF NOT EXISTS current_phase varchar(40),
+      ADD COLUMN IF NOT EXISTS pre_clearance_finalized_at timestamptz;`);
+
+    await queryRunner.query(`ALTER TABLE freight.first_mile
+      ADD COLUMN IF NOT EXISTS paid boolean NOT NULL DEFAULT false;`);
+    await queryRunner.query(`ALTER TABLE freight.last_mile
+      ADD COLUMN IF NOT EXISTS paid boolean NOT NULL DEFAULT false;`);
+
+    await queryRunner.query(`ALTER TABLE freight.route_milestones
+      ADD COLUMN IF NOT EXISTS distance_km numeric(10,2);`);
+
+    await queryRunner.query(`ALTER TABLE freight.routes
+      ADD COLUMN IF NOT EXISTS status varchar(32) NOT NULL DEFAULT 'AVAILABLE';`);
+    await queryRunner.query(`CREATE INDEX IF NOT EXISTS "IDX_routes_status" ON freight.routes (status);`);
+
+    await queryRunner.query(`ALTER TABLE freight.train_schedules
+      ADD COLUMN IF NOT EXISTS window_phase varchar(20) NULL,
+      ADD COLUMN IF NOT EXISTS window_opens_at timestamptz NULL,
+      ADD COLUMN IF NOT EXISTS window_closes_at timestamptz NULL,
+      ADD COLUMN IF NOT EXISTS doc_review_ends_at timestamptz NULL,
+      ADD COLUMN IF NOT EXISTS doc_review_completed_at timestamptz NULL,
+      ADD COLUMN IF NOT EXISTS payment_phase_ends_at timestamptz NULL,
+      ADD COLUMN IF NOT EXISTS booking_cycle_no integer NOT NULL DEFAULT 0;`);
+    await queryRunner.query(`CREATE INDEX IF NOT EXISTS idx_train_schedules_window_phase
+      ON freight.train_schedules (window_phase) WHERE window_phase IS NOT NULL;`);
+
+    await queryRunner.query(`ALTER TABLE freight.train_scheduling_global_rules
+      ADD COLUMN IF NOT EXISTS import_window_lead_days integer NOT NULL DEFAULT 3,
+      ADD COLUMN IF NOT EXISTS export_booking_lead_hours integer NOT NULL DEFAULT 24,
+      ADD COLUMN IF NOT EXISTS window_open_hour integer NOT NULL DEFAULT 8,
+      ADD COLUMN IF NOT EXISTS window_duration_hours numeric(4, 2) NOT NULL DEFAULT 3,
+      ADD COLUMN IF NOT EXISTS doc_review_minutes integer NOT NULL DEFAULT 30,
+      ADD COLUMN IF NOT EXISTS payment_window_minutes integer NOT NULL DEFAULT 60,
+      ADD COLUMN IF NOT EXISTS reopen_delay_minutes integer NOT NULL DEFAULT 90;`);
+  }
+
+  public async down(): Promise<void> {
+    // No-op: this migration only repairs drift by additively creating objects
+    // that other migrations own. Rolling it back would drop objects those
+    // migrations legitimately created. Revert individual feature migrations
+    // instead if needed.
+  }
+}
diff --git a/apps/edr-freight-api/src/migrations/1890000000002-AddFaydaVerificationSessions.ts b/apps/edr-freight-api/src/migrations/1890000000002-AddFaydaVerificationSessions.ts
new file mode 100644
index 000000000..10b358eea
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/1890000000002-AddFaydaVerificationSessions.ts
@@ -0,0 +1,44 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+/**
+ * Session store for the VeriFayda 2.0 OIDC verification flow (ported from
+ * passenger-api). One row per started verification; `state` is the
+ * single-use CSRF token linking the eSignet redirect back to the session.
+ */
+export class AddFaydaVerificationSessions1890000000002 implements MigrationInterface {
+  name = "AddFaydaVerificationSessions1890000000002";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      CREATE TABLE IF NOT EXISTS freight.fayda_verification_sessions (
+        id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+        state varchar NOT NULL UNIQUE,
+        code_verifier varchar NOT NULL,
+        purpose varchar NOT NULL DEFAULT 'VERIFY',
+        platform varchar NOT NULL DEFAULT 'WEB',
+        save_to_account boolean NOT NULL DEFAULT false,
+        status varchar NOT NULL DEFAULT 'PENDING',
+        error_code varchar,
+        error_description text,
+        iam_user_id uuid,
+        expires_at timestamptz NOT NULL,
+        completed_at timestamptz,
+        created_at timestamptz NOT NULL DEFAULT now(),
+        updated_at timestamptz NOT NULL DEFAULT now(),
+        deleted_at timestamptz
+      )
+    `);
+    await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS "IDX_FAYDA_SESSIONS_EXPIRES_AT"
+      ON freight.fayda_verification_sessions (expires_at)
+    `);
+    await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS "IDX_FAYDA_SESSIONS_IAM_USER_ID"
+      ON freight.fayda_verification_sessions (iam_user_id)
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`DROP TABLE IF EXISTS freight.fayda_verification_sessions`);
+  }
+}
diff --git a/apps/edr-freight-api/src/migrations/1890000000003-AddDriverFaydaVerification.ts b/apps/edr-freight-api/src/migrations/1890000000003-AddDriverFaydaVerification.ts
new file mode 100644
index 000000000..ba8003143
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/1890000000003-AddDriverFaydaVerification.ts
@@ -0,0 +1,26 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+/**
+ * Track Fayda identity verification on drivers: whether the driver's
+ * identity was verified through VeriFayda and the OIDC subject it was
+ * verified against.
+ */
+export class AddDriverFaydaVerification1890000000003 implements MigrationInterface {
+  name = "AddDriverFaydaVerification1890000000003";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      ALTER TABLE freight.drivers
+      ADD COLUMN IF NOT EXISTS fayda_verified boolean DEFAULT false,
+      ADD COLUMN IF NOT EXISTS fayda_sub varchar
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      ALTER TABLE freight.drivers
+      DROP COLUMN IF EXISTS fayda_verified,
+      DROP COLUMN IF EXISTS fayda_sub
+    `);
+  }
+}
diff --git a/apps/edr-freight-api/src/migrations/1890000000004-AddLastMileVehicleAssignments.ts b/apps/edr-freight-api/src/migrations/1890000000004-AddLastMileVehicleAssignments.ts
new file mode 100644
index 000000000..7c1413617
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/1890000000004-AddLastMileVehicleAssignments.ts
@@ -0,0 +1,39 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+/**
+ * Allow more than one vehicle per last-mile delivery. Junction table joins
+ * last_mile ⇄ vehicles; existing single vehicle_id values are backfilled as
+ * the first assignment so nothing is lost.
+ */
+export class AddLastMileVehicleAssignments1890000000004 implements MigrationInterface {
+  name = "AddLastMileVehicleAssignments1890000000004";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      CREATE TABLE IF NOT EXISTS freight.last_mile_vehicle_assignments (
+        id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+        last_mile_id uuid NOT NULL REFERENCES freight.last_mile(id) ON DELETE CASCADE,
+        vehicle_id uuid NOT NULL REFERENCES freight.vehicles(id),
+        created_at timestamptz NOT NULL DEFAULT now(),
+        updated_at timestamptz NOT NULL DEFAULT now(),
+        deleted_at timestamptz,
+        CONSTRAINT "UQ_LAST_MILE_VEHICLE" UNIQUE (last_mile_id, vehicle_id)
+      )
+    `);
+    await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS "IDX_LM_VEHICLE_ASSIGNMENTS_VEHICLE"
+      ON freight.last_mile_vehicle_assignments (vehicle_id)
+    `);
+    // Backfill: existing single-vehicle assignments become the first row
+    await queryRunner.query(`
+      INSERT INTO freight.last_mile_vehicle_assignments (last_mile_id, vehicle_id)
+      SELECT id, vehicle_id FROM freight.last_mile
+      WHERE vehicle_id IS NOT NULL AND deleted_at IS NULL
+      ON CONFLICT (last_mile_id, vehicle_id) DO NOTHING
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`DROP TABLE IF EXISTS freight.last_mile_vehicle_assignments`);
+  }
+}
diff --git a/apps/edr-freight-api/src/migrations/1890000000005-AddDriverGender.ts b/apps/edr-freight-api/src/migrations/1890000000005-AddDriverGender.ts
new file mode 100644
index 000000000..2ec26e034
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/1890000000005-AddDriverGender.ts
@@ -0,0 +1,24 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+/**
+ * Store the driver's gender. Prefilled from the Fayda VERIFY response
+ * (Male/Female) but editable; nullable so existing rows and manual,
+ * non-Fayda driver records stay valid.
+ */
+export class AddDriverGender1890000000005 implements MigrationInterface {
+  name = "AddDriverGender1890000000005";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      ALTER TABLE freight.drivers
+      ADD COLUMN IF NOT EXISTS gender varchar
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      ALTER TABLE freight.drivers
+      DROP COLUMN IF EXISTS gender
+    `);
+  }
+}
diff --git a/apps/edr-freight-api/src/migrations/1890000000006-AddDriverFaydaSubUnique.ts b/apps/edr-freight-api/src/migrations/1890000000006-AddDriverFaydaSubUnique.ts
new file mode 100644
index 000000000..04c9a7000
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/1890000000006-AddDriverFaydaSubUnique.ts
@@ -0,0 +1,23 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+/**
+ * Enforce one driver record per verified Fayda identity. A unique index on
+ * fayda_sub blocks a second driver from being created against the same Fayda
+ * OIDC subject; NULLs stay distinct so legacy/unverified rows are unaffected.
+ */
+export class AddDriverFaydaSubUnique1890000000006 implements MigrationInterface {
+  name = "AddDriverFaydaSubUnique1890000000006";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      CREATE UNIQUE INDEX IF NOT EXISTS "UQ_DRIVERS_FAYDA_SUB"
+      ON freight.drivers (fayda_sub)
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      DROP INDEX IF EXISTS freight."UQ_DRIVERS_FAYDA_SUB"
+    `);
+  }
+}
diff --git a/apps/edr-freight-api/src/migrations/1890000000007-DriverUniquePartialSoftDelete.ts b/apps/edr-freight-api/src/migrations/1890000000007-DriverUniquePartialSoftDelete.ts
new file mode 100644
index 000000000..77d0a3043
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/1890000000007-DriverUniquePartialSoftDelete.ts
@@ -0,0 +1,62 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+/**
+ * Make driver uniqueness soft-delete aware. The original table used plain
+ * column UNIQUE constraints (drivers_email_key, etc.) which count soft-deleted
+ * rows, so deleting a driver then re-adding the same email/phone/license/Fayda
+ * identity failed at the DB with a raw 500 — even though the service's own
+ * (deleted_at-excluding) duplicate check saw nothing. Replace them with partial
+ * unique indexes scoped to live rows (deleted_at IS NULL) so uniqueness matches
+ * what the service enforces and freed values become reusable after deletion.
+ */
+export class DriverUniquePartialSoftDelete1890000000007 implements MigrationInterface {
+  name = "DriverUniquePartialSoftDelete1890000000007";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    // Drop the full-table unique constraints from CreateDriversTable...
+    await queryRunner.query(`
+      ALTER TABLE freight.drivers
+        DROP CONSTRAINT IF EXISTS drivers_email_key,
+        DROP CONSTRAINT IF EXISTS drivers_phone_number_key,
+        DROP CONSTRAINT IF EXISTS drivers_license_number_key
+    `);
+    // ...and the plain fayda_sub unique index from 1890000000006.
+    await queryRunner.query(`DROP INDEX IF EXISTS freight."UQ_DRIVERS_FAYDA_SUB"`);
+
+    // Re-add each as a partial unique index scoped to non-deleted rows.
+    await queryRunner.query(`
+      CREATE UNIQUE INDEX IF NOT EXISTS "UQ_DRIVERS_EMAIL_ACTIVE"
+      ON freight.drivers (email) WHERE deleted_at IS NULL
+    `);
+    await queryRunner.query(`
+      CREATE UNIQUE INDEX IF NOT EXISTS "UQ_DRIVERS_PHONE_ACTIVE"
+      ON freight.drivers (phone_number) WHERE deleted_at IS NULL
+    `);
+    await queryRunner.query(`
+      CREATE UNIQUE INDEX IF NOT EXISTS "UQ_DRIVERS_LICENSE_ACTIVE"
+      ON freight.drivers (license_number) WHERE deleted_at IS NULL
+    `);
+    await queryRunner.query(`
+      CREATE UNIQUE INDEX IF NOT EXISTS "UQ_DRIVERS_FAYDA_SUB_ACTIVE"
+      ON freight.drivers (fayda_sub) WHERE deleted_at IS NULL
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`DROP INDEX IF EXISTS freight."UQ_DRIVERS_EMAIL_ACTIVE"`);
+    await queryRunner.query(`DROP INDEX IF EXISTS freight."UQ_DRIVERS_PHONE_ACTIVE"`);
+    await queryRunner.query(`DROP INDEX IF EXISTS freight."UQ_DRIVERS_LICENSE_ACTIVE"`);
+    await queryRunner.query(`DROP INDEX IF EXISTS freight."UQ_DRIVERS_FAYDA_SUB_ACTIVE"`);
+
+    await queryRunner.query(`
+      CREATE UNIQUE INDEX IF NOT EXISTS "UQ_DRIVERS_FAYDA_SUB"
+      ON freight.drivers (fayda_sub)
+    `);
+    await queryRunner.query(`
+      ALTER TABLE freight.drivers
+        ADD CONSTRAINT drivers_email_key UNIQUE (email),
+        ADD CONSTRAINT drivers_phone_number_key UNIQUE (phone_number),
+        ADD CONSTRAINT drivers_license_number_key UNIQUE (license_number)
+    `);
+  }
+}
diff --git a/apps/edr-freight-api/src/migrations/1890000000008-AddFleetEvents.ts b/apps/edr-freight-api/src/migrations/1890000000008-AddFleetEvents.ts
new file mode 100644
index 000000000..8fbb688d3
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/1890000000008-AddFleetEvents.ts
@@ -0,0 +1,43 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+/**
+ * Append-only audit log for fleet activity (driver↔vehicle assignments, vehicle
+ * status/availability transitions, first/last-mile vehicle assignments + mile
+ * status changes). Queried by vehicle_id or driver_id to build a per-record
+ * timeline. Populated going forward — existing records have no back-history.
+ */
+export class AddFleetEvents1890000000008 implements MigrationInterface {
+  name = "AddFleetEvents1890000000008";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      CREATE TABLE IF NOT EXISTS freight.fleet_events (
+        id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+        event_type varchar NOT NULL,
+        vehicle_id uuid,
+        driver_id uuid,
+        first_mile_id uuid,
+        last_mile_id uuid,
+        from_value varchar,
+        to_value varchar,
+        label varchar,
+        metadata jsonb,
+        created_at timestamptz NOT NULL DEFAULT now(),
+        updated_at timestamptz NOT NULL DEFAULT now(),
+        deleted_at timestamptz
+      )
+    `);
+    await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS "IDX_FLEET_EVENTS_VEHICLE"
+      ON freight.fleet_events (vehicle_id, created_at)
+    `);
+    await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS "IDX_FLEET_EVENTS_DRIVER"
+      ON freight.fleet_events (driver_id, created_at)
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`DROP TABLE IF EXISTS freight.fleet_events`);
+  }
+}
diff --git a/apps/edr-freight-api/src/migrations/1890000000009-AddLastMileAssignmentContainerNumber.ts b/apps/edr-freight-api/src/migrations/1890000000009-AddLastMileAssignmentContainerNumber.ts
new file mode 100644
index 000000000..d8bc1c5c0
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/1890000000009-AddLastMileAssignmentContainerNumber.ts
@@ -0,0 +1,26 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+/**
+ * Container number carried by each vehicle on a last-mile delivery. Auto-filled
+ * from the booking's container number when present, else entered by the operator
+ * at assignment time.
+ */
+export class AddLastMileAssignmentContainerNumber1890000000009
+  implements MigrationInterface
+{
+  name = "AddLastMileAssignmentContainerNumber1890000000009";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      ALTER TABLE freight.last_mile_vehicle_assignments
+      ADD COLUMN IF NOT EXISTS container_number varchar
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      ALTER TABLE freight.last_mile_vehicle_assignments
+      DROP COLUMN IF EXISTS container_number
+    `);
+  }
+}
diff --git a/apps/edr-freight-api/src/migrations/1890000000010-AddLastMileAssignmentDistance.ts b/apps/edr-freight-api/src/migrations/1890000000010-AddLastMileAssignmentDistance.ts
new file mode 100644
index 000000000..fc2d30552
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/1890000000010-AddLastMileAssignmentDistance.ts
@@ -0,0 +1,26 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+/**
+ * Per-vehicle actual distance on a last-mile delivery. A booking served by
+ * several trucks records each truck's km; the record's total (last_mile.exact_km)
+ * is their sum and drives the invoice.
+ */
+export class AddLastMileAssignmentDistance1890000000010
+  implements MigrationInterface
+{
+  name = "AddLastMileAssignmentDistance1890000000010";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      ALTER TABLE freight.last_mile_vehicle_assignments
+      ADD COLUMN IF NOT EXISTS distance_km numeric(10,2)
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      ALTER TABLE freight.last_mile_vehicle_assignments
+      DROP COLUMN IF EXISTS distance_km
+    `);
+  }
+}
diff --git a/apps/edr-freight-api/src/migrations/1900000000000-AddLoadingStatusToTrainScheduleBookings.ts b/apps/edr-freight-api/src/migrations/1900000000000-AddLoadingStatusToTrainScheduleBookings.ts
new file mode 100644
index 000000000..6c7235e3b
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/1900000000000-AddLoadingStatusToTrainScheduleBookings.ts
@@ -0,0 +1,25 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+/**
+ * Track per-booking loading confirmation (LOADED/UNLOADED) on train_schedule_bookings.
+ * Tracking only — does not gate dispatch.
+ */
+export class AddLoadingStatusToTrainScheduleBookings1900000000000
+  implements MigrationInterface
+{
+  name = "AddLoadingStatusToTrainScheduleBookings1900000000000";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      ALTER TABLE freight.train_schedule_bookings
+      ADD COLUMN IF NOT EXISTS loading_status varchar(20) NOT NULL DEFAULT 'UNLOADED'
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      ALTER TABLE freight.train_schedule_bookings
+      DROP COLUMN IF EXISTS loading_status
+    `);
+  }
+}
diff --git a/apps/edr-freight-api/src/migrations/1900000000000-SimplifyRatesAndWeightLimitRules.ts b/apps/edr-freight-api/src/migrations/1900000000000-SimplifyRatesAndWeightLimitRules.ts
new file mode 100644
index 000000000..7a661bc7c
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/1900000000000-SimplifyRatesAndWeightLimitRules.ts
@@ -0,0 +1,126 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+/**
+ * Simplify the rate + weight-limit configuration model:
+ *
+ *  1. Drop the effective_from / effective_to validity window from both
+ *     `rates` and `weight_limit_rules`. Rates are now activated purely by
+ *     the approval workflow (status = LIVE) and weight limits are always
+ *     active for their container + direction. No time-travel scheduling.
+ *
+ *  2. Enforce "one rate per pattern" with partial unique indexes so the same
+ *     configuration (e.g. FIRST_MILE for a given container type) cannot be
+ *     duplicated. NULL scope columns are COALESCE-normalised because Postgres
+ *     treats NULLs as distinct in a plain unique index.
+ *
+ *  This migration is destructive on the date columns — existing effective_*
+ *  values are dropped.
+ */
+export class SimplifyRatesAndWeightLimitRules1900000000000 implements MigrationInterface {
+  name = 'SimplifyRatesAndWeightLimitRules1900000000000';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    // ── 1. De-duplicate existing data so the unique indexes can be created ──
+    // Keep the most recently-created row per pattern, soft-delete the rest.
+    await queryRunner.query(`
+      WITH ranked AS (
+        SELECT id,
+               row_number() OVER (
+                 PARTITION BY rate_type,
+                              COALESCE(container_type_id, '00000000-0000-0000-0000-000000000000'::uuid),
+                              COALESCE(cargo_type_id, '00000000-0000-0000-0000-000000000000'::uuid),
+                              COALESCE(trade_direction, ''),
+                              rate_unit
+                 ORDER BY created_at DESC, id DESC
+               ) AS rn
+        FROM freight.rates
+        WHERE deleted_at IS NULL AND status <> 'SUPERSEDED'
+      )
+      UPDATE freight.rates r
+      SET deleted_at = now()
+      FROM ranked
+      WHERE r.id = ranked.id AND ranked.rn > 1;
+    `);
+
+    await queryRunner.query(`
+      WITH ranked AS (
+        SELECT id,
+               row_number() OVER (
+                 PARTITION BY container_type_id, trade_direction
+                 ORDER BY created_at DESC, id DESC
+               ) AS rn
+        FROM freight.weight_limit_rules
+        WHERE deleted_at IS NULL
+      )
+      UPDATE freight.weight_limit_rules w
+      SET deleted_at = now()
+      FROM ranked
+      WHERE w.id = ranked.id AND ranked.rn > 1;
+    `);
+
+    // ── 2. Drop the effective-date indexes + columns ───────────────────────
+    await queryRunner.query(`DROP INDEX IF EXISTS freight."IDX_rates_effective_from";`);
+    await queryRunner.query(`DROP INDEX IF EXISTS freight."IDX_weight_limit_rules_effective_from";`);
+    // Indexes created by TypeORM's @Index carry generated hashed names — drop
+    // any index that references the effective_from column defensively.
+    await queryRunner.query(`
+      DO $$
+      DECLARE idx record;
+      BEGIN
+        FOR idx IN
+          SELECT indexname FROM pg_indexes
+          WHERE schemaname = 'freight'
+            AND tablename IN ('rates', 'weight_limit_rules')
+            AND indexdef ILIKE '%effective_from%'
+        LOOP
+          EXECUTE format('DROP INDEX IF EXISTS freight.%I', idx.indexname);
+        END LOOP;
+      END $$;
+    `);
+
+    await queryRunner.query(`ALTER TABLE freight.rates DROP COLUMN IF EXISTS effective_from;`);
+    await queryRunner.query(`ALTER TABLE freight.rates DROP COLUMN IF EXISTS effective_to;`);
+    await queryRunner.query(`ALTER TABLE freight.weight_limit_rules DROP COLUMN IF EXISTS effective_from;`);
+    await queryRunner.query(`ALTER TABLE freight.weight_limit_rules DROP COLUMN IF EXISTS effective_to;`);
+
+    // ── 3. One-rate-per-pattern partial unique indexes ─────────────────────
+    // The unit is part of the identity so a surcharge can legitimately carry two
+    // rows that bill different ways (e.g. reefer PER_CONTAINER + reefer PER_TON),
+    // while still blocking a true duplicate (same rateType + scope + unit).
+    await queryRunner.query(`
+      CREATE UNIQUE INDEX IF NOT EXISTS "UQ_rates_pattern"
+      ON freight.rates (
+        rate_type,
+        COALESCE(container_type_id, '00000000-0000-0000-0000-000000000000'::uuid),
+        COALESCE(cargo_type_id, '00000000-0000-0000-0000-000000000000'::uuid),
+        COALESCE(trade_direction, ''),
+        rate_unit
+      )
+      WHERE deleted_at IS NULL AND status <> 'SUPERSEDED';
+    `);
+
+    await queryRunner.query(`
+      CREATE UNIQUE INDEX IF NOT EXISTS "UQ_weight_limit_rules_pattern"
+      ON freight.weight_limit_rules (container_type_id, trade_direction)
+      WHERE deleted_at IS NULL;
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`DROP INDEX IF EXISTS freight."UQ_rates_pattern";`);
+    await queryRunner.query(`DROP INDEX IF EXISTS freight."UQ_weight_limit_rules_pattern";`);
+
+    await queryRunner.query(`ALTER TABLE freight.rates ADD COLUMN IF NOT EXISTS effective_from date;`);
+    await queryRunner.query(`UPDATE freight.rates SET effective_from = COALESCE(effective_from, created_at::date);`);
+    await queryRunner.query(`ALTER TABLE freight.rates ALTER COLUMN effective_from SET NOT NULL;`);
+    await queryRunner.query(`ALTER TABLE freight.rates ADD COLUMN IF NOT EXISTS effective_to date;`);
+
+    await queryRunner.query(`ALTER TABLE freight.weight_limit_rules ADD COLUMN IF NOT EXISTS effective_from date;`);
+    await queryRunner.query(`ALTER TABLE freight.weight_limit_rules ADD COLUMN IF NOT EXISTS effective_to date;`);
+
+    await queryRunner.query(`CREATE INDEX IF NOT EXISTS "IDX_rates_effective_from" ON freight.rates (effective_from);`);
+    await queryRunner.query(
+      `CREATE INDEX IF NOT EXISTS "IDX_weight_limit_rules_effective_from" ON freight.weight_limit_rules (effective_from);`,
+    );
+  }
+}
diff --git a/apps/edr-freight-api/src/migrations/1910000000000-WidenWindowDurationHoursPrecision.ts b/apps/edr-freight-api/src/migrations/1910000000000-WidenWindowDurationHoursPrecision.ts
new file mode 100644
index 000000000..194c0d056
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/1910000000000-WidenWindowDurationHoursPrecision.ts
@@ -0,0 +1,28 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+/**
+ * Widen train_scheduling_global_rules.window_duration_hours from numeric(4,2)
+ * to numeric(6,4). The UI now lets staff enter the booking-window duration in
+ * minutes / hours / days and converts to the column's native hours unit; a
+ * 4-minute window is 0.0667h, which numeric(4,2) rounds to 0.07 (≈3.96 min).
+ * Four decimals store sub-minute durations exactly (0.0667h → 4.00 min).
+ */
+export class WidenWindowDurationHoursPrecision1910000000000
+  implements MigrationInterface
+{
+  name = "WidenWindowDurationHoursPrecision1910000000000";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      ALTER TABLE freight.train_scheduling_global_rules
+        ALTER COLUMN window_duration_hours TYPE numeric(6, 4);
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      ALTER TABLE freight.train_scheduling_global_rules
+        ALTER COLUMN window_duration_hours TYPE numeric(4, 2);
+    `);
+  }
+}
diff --git a/apps/edr-freight-api/src/migrations/1920000000000-AddScheduleWindowRuleSnapshot.ts b/apps/edr-freight-api/src/migrations/1920000000000-AddScheduleWindowRuleSnapshot.ts
new file mode 100644
index 000000000..d48e127c3
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/1920000000000-AddScheduleWindowRuleSnapshot.ts
@@ -0,0 +1,58 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+/**
+ * Snapshot the booking-window rule onto each train schedule.
+ *
+ * A schedule's window (open time + reopen cycles) must be frozen to the rule it
+ * was created with: a later global-rules edit applies only to FUTURE schedules,
+ * while an already-open schedule keeps its base rule. Previously the batch board
+ * recomputed windows from the LIVE global config, so editing the rule redrew the
+ * board for open schedules (a synthetic grid that no longer matched the window
+ * the customer was shown). These columns give the board a per-schedule rule to
+ * derive its display windows from.
+ *
+ * Existing rows are backfilled from the current global-rules singleton — the best
+ * available base, since they never stored one. Their stamped windowOpensAt/
+ * windowClosesAt are still real, so only projected reopen cycles rely on the
+ * backfill.
+ */
+export class AddScheduleWindowRuleSnapshot1920000000000
+  implements MigrationInterface
+{
+  name = "AddScheduleWindowRuleSnapshot1920000000000";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      ALTER TABLE freight.train_schedules
+        ADD COLUMN IF NOT EXISTS rule_window_open_hour integer,
+        ADD COLUMN IF NOT EXISTS rule_window_duration_hours numeric(6, 4),
+        ADD COLUMN IF NOT EXISTS rule_reopen_delay_minutes integer,
+        ADD COLUMN IF NOT EXISTS rule_import_window_lead_days integer,
+        ADD COLUMN IF NOT EXISTS rule_export_booking_lead_hours integer;
+    `);
+
+    // Backfill from the global-rules singleton so pre-existing schedules render.
+    await queryRunner.query(`
+      UPDATE freight.train_schedules ts
+      SET
+        rule_window_open_hour = COALESCE(ts.rule_window_open_hour, r.window_open_hour),
+        rule_window_duration_hours = COALESCE(ts.rule_window_duration_hours, r.window_duration_hours),
+        rule_reopen_delay_minutes = COALESCE(ts.rule_reopen_delay_minutes, r.reopen_delay_minutes),
+        rule_import_window_lead_days = COALESCE(ts.rule_import_window_lead_days, r.import_window_lead_days),
+        rule_export_booking_lead_hours = COALESCE(ts.rule_export_booking_lead_hours, r.export_booking_lead_hours)
+      FROM freight.train_scheduling_global_rules r
+      WHERE ts.rule_window_open_hour IS NULL;
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      ALTER TABLE freight.train_schedules
+        DROP COLUMN IF EXISTS rule_window_open_hour,
+        DROP COLUMN IF EXISTS rule_window_duration_hours,
+        DROP COLUMN IF EXISTS rule_reopen_delay_minutes,
+        DROP COLUMN IF EXISTS rule_import_window_lead_days,
+        DROP COLUMN IF EXISTS rule_export_booking_lead_hours;
+    `);
+  }
+}
diff --git a/apps/edr-freight-api/src/migrations/1930000000000-AddMaxCapacityToWeightLimitRules.ts b/apps/edr-freight-api/src/migrations/1930000000000-AddMaxCapacityToWeightLimitRules.ts
new file mode 100644
index 000000000..b1218a9b3
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/1930000000000-AddMaxCapacityToWeightLimitRules.ts
@@ -0,0 +1,28 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+/**
+ * Add a hard per-unit weight ceiling to weight limit rules.
+ *
+ * maxVgmTons stays the soft "overweight" threshold (surcharge + warning);
+ * max_capacity_tons is the absolute ceiling above which a booking cannot be
+ * created at all. Null means no ceiling (existing behavior).
+ */
+export class AddMaxCapacityToWeightLimitRules1930000000000
+  implements MigrationInterface
+{
+  name = "AddMaxCapacityToWeightLimitRules1930000000000";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      ALTER TABLE freight.weight_limit_rules
+        ADD COLUMN IF NOT EXISTS max_capacity_tons numeric(8, 3);
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      ALTER TABLE freight.weight_limit_rules
+        DROP COLUMN IF EXISTS max_capacity_tons;
+    `);
+  }
+}
diff --git a/apps/edr-freight-api/src/migrations/1940000000000-AddFirstMileVehicleAssignments.ts b/apps/edr-freight-api/src/migrations/1940000000000-AddFirstMileVehicleAssignments.ts
new file mode 100644
index 000000000..42f2c4eba
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/1940000000000-AddFirstMileVehicleAssignments.ts
@@ -0,0 +1,42 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+/**
+ * Allow more than one vehicle per first-mile pickup. Junction table joins
+ * first_mile ⇄ vehicles, with each truck's container number + actual distance;
+ * existing single vehicle_id values are backfilled as the first assignment so
+ * nothing is lost. Mirrors the last-mile vehicle-assignment schema.
+ */
+export class AddFirstMileVehicleAssignments1940000000000 implements MigrationInterface {
+  name = "AddFirstMileVehicleAssignments1940000000000";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      CREATE TABLE IF NOT EXISTS freight.first_mile_vehicle_assignments (
+        id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+        first_mile_id uuid NOT NULL REFERENCES freight.first_mile(id) ON DELETE CASCADE,
+        vehicle_id uuid NOT NULL REFERENCES freight.vehicles(id),
+        container_number varchar,
+        distance_km numeric(10,2),
+        created_at timestamptz NOT NULL DEFAULT now(),
+        updated_at timestamptz NOT NULL DEFAULT now(),
+        deleted_at timestamptz,
+        CONSTRAINT "UQ_FIRST_MILE_VEHICLE" UNIQUE (first_mile_id, vehicle_id)
+      )
+    `);
+    await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS "IDX_FM_VEHICLE_ASSIGNMENTS_VEHICLE"
+      ON freight.first_mile_vehicle_assignments (vehicle_id)
+    `);
+    // Backfill: existing single-vehicle assignments become the first row
+    await queryRunner.query(`
+      INSERT INTO freight.first_mile_vehicle_assignments (first_mile_id, vehicle_id)
+      SELECT id, vehicle_id FROM freight.first_mile
+      WHERE vehicle_id IS NOT NULL AND deleted_at IS NULL
+      ON CONFLICT (first_mile_id, vehicle_id) DO NOTHING
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`DROP TABLE IF EXISTS freight.first_mile_vehicle_assignments`);
+  }
+}
diff --git a/apps/edr-freight-api/src/migrations/1940000000000-AddWagonTypeFkToCargoAndContainerTypes.ts b/apps/edr-freight-api/src/migrations/1940000000000-AddWagonTypeFkToCargoAndContainerTypes.ts
new file mode 100644
index 000000000..c7ab60577
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/1940000000000-AddWagonTypeFkToCargoAndContainerTypes.ts
@@ -0,0 +1,133 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+/**
+ * Replace load-type string matching with a real wagon-type foreign key.
+ *
+ * Before this migration, train scheduling picked a wagon type by matching
+ * strings — a hardcoded cargo-code → wagon-code map for bulk (COFFEE→KW2, …)
+ * and a fixed NW5 default for every container. This adds `wagon_type_id` FKs on
+ * `cargo_types` and `container_types` so scheduling resolves the wagon type
+ * through the relation instead.
+ *
+ * The columns are NULLABLE: cargo grouping rows and container/legacy cargo that
+ * never ship in bulk have no wagon type, and forcing one onto them is
+ * meaningless. Scheduling enforces the requirement at run time (it throws when a
+ * scheduled bulk cargo type or a container type in the batch has no wagon type).
+ *
+ * Backfill reproduces the old hardcoded resolution one final time so existing
+ * bulk cargo + container rows are not left unset. After this, the runtime map is
+ * removed — the FK is the single source of truth.
+ */
+export class AddWagonTypeFkToCargoAndContainerTypes1940000000000
+  implements MigrationInterface
+{
+  name = "AddWagonTypeFkToCargoAndContainerTypes1940000000000";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    // ── Columns + FKs ────────────────────────────────────────────────────────
+    await queryRunner.query(`
+      ALTER TABLE freight.cargo_types
+        ADD COLUMN IF NOT EXISTS wagon_type_id uuid;
+    `);
+    await queryRunner.query(`
+      ALTER TABLE freight.container_types
+        ADD COLUMN IF NOT EXISTS wagon_type_id uuid;
+    `);
+
+    await queryRunner.query(`
+      ALTER TABLE freight.cargo_types
+        ADD CONSTRAINT fk_cargo_types_wagon_type
+        FOREIGN KEY (wagon_type_id)
+        REFERENCES freight.wagon_types(id)
+        ON DELETE RESTRICT;
+    `);
+    await queryRunner.query(`
+      ALTER TABLE freight.container_types
+        ADD CONSTRAINT fk_container_types_wagon_type
+        FOREIGN KEY (wagon_type_id)
+        REFERENCES freight.wagon_types(id)
+        ON DELETE RESTRICT;
+    `);
+
+    await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS idx_cargo_types_wagon_type_id
+        ON freight.cargo_types (wagon_type_id);
+    `);
+    await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS idx_container_types_wagon_type_id
+        ON freight.container_types (wagon_type_id);
+    `);
+
+    // ── Backfill: old cargo-code → wagon-code map (one last time) ─────────────
+    // COFFEE/GRAIN/WHEAT/SORGHUM/CORN → KW2, FERTILIZER/SUGAR → PW2,
+    // COAL → KW3, STEEL/ORE → CW3. Unmapped bulk cargo → CW3 (old default).
+    const cargoCodeToWagon: Record<string, string> = {
+      COFFEE: "KW2",
+      GRAIN: "KW2",
+      WHEAT: "KW2",
+      SORGHUM: "KW2",
+      CORN: "KW2",
+      FERTILIZER: "PW2",
+      SUGAR: "PW2",
+      COAL: "KW3",
+      STEEL: "CW3",
+      ORE: "CW3",
+    };
+
+    for (const [cargoCode, wagonCode] of Object.entries(cargoCodeToWagon)) {
+      await queryRunner.query(
+        `
+        UPDATE freight.cargo_types ct
+        SET wagon_type_id = wt.id
+        FROM freight.wagon_types wt
+        WHERE wt.code = $1
+          AND UPPER(TRIM(ct.code)) = $2
+          AND ct.wagon_type_id IS NULL;
+        `,
+        [wagonCode, cargoCode],
+      );
+    }
+
+    // Remaining bulk cargo (PER_TON) without a mapped code → default bulk wagon CW3.
+    await queryRunner.query(`
+      UPDATE freight.cargo_types ct
+      SET wagon_type_id = wt.id
+      FROM freight.wagon_types wt
+      WHERE wt.code = 'CW3'
+        AND ct.wagon_type_id IS NULL
+        AND ct.unit_of_measure = 'PER_TON';
+    `);
+
+    // All container types → the old container default wagon NW5.
+    await queryRunner.query(`
+      UPDATE freight.container_types ct
+      SET wagon_type_id = wt.id
+      FROM freight.wagon_types wt
+      WHERE wt.code = 'NW5'
+        AND ct.wagon_type_id IS NULL;
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      DROP INDEX IF EXISTS freight.idx_container_types_wagon_type_id;
+    `);
+    await queryRunner.query(`
+      DROP INDEX IF EXISTS freight.idx_cargo_types_wagon_type_id;
+    `);
+    await queryRunner.query(`
+      ALTER TABLE freight.container_types
+        DROP CONSTRAINT IF EXISTS fk_container_types_wagon_type;
+    `);
+    await queryRunner.query(`
+      ALTER TABLE freight.cargo_types
+        DROP CONSTRAINT IF EXISTS fk_cargo_types_wagon_type;
+    `);
+    await queryRunner.query(`
+      ALTER TABLE freight.container_types DROP COLUMN IF EXISTS wagon_type_id;
+    `);
+    await queryRunner.query(`
+      ALTER TABLE freight.cargo_types DROP COLUMN IF EXISTS wagon_type_id;
+    `);
+  }
+}
diff --git a/apps/edr-freight-api/src/migrations/1950000000000-AddCustomerTruckAssignments.ts b/apps/edr-freight-api/src/migrations/1950000000000-AddCustomerTruckAssignments.ts
new file mode 100644
index 000000000..7c95199b1
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/1950000000000-AddCustomerTruckAssignments.ts
@@ -0,0 +1,59 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+/**
+ * Multi-truck customer (self-haul) assignment. Replaces the single
+ * booking.customer_truck_* fields with a per-booking list of trucks, each
+ * carrying 1–2 containers and tracking its own arrival. The legacy
+ * booking.customer_truck_* columns are kept as a synced booking-level flag
+ * (any truck assigned / all trucks arrived) so the warehouse exit-gate and
+ * delivery-approval logic keep working.
+ */
+export class AddCustomerTruckAssignments1950000000000 implements MigrationInterface {
+  name = 'AddCustomerTruckAssignments1950000000000';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      CREATE TABLE IF NOT EXISTS freight.customer_truck_assignments (
+        id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+        booking_id uuid NOT NULL REFERENCES freight.bookings(id) ON DELETE CASCADE,
+        plate_number varchar(32) NOT NULL,
+        driver_name varchar(120) NOT NULL,
+        truck_type varchar(60) NOT NULL,
+        assigned_at timestamptz NOT NULL DEFAULT now(),
+        arrived_at timestamptz,
+        created_at timestamptz NOT NULL DEFAULT now(),
+        updated_at timestamptz NOT NULL DEFAULT now(),
+        deleted_at timestamptz
+      );
+    `);
+    await queryRunner.query(
+      `CREATE INDEX IF NOT EXISTS "IDX_customer_truck_assignments_booking" ON freight.customer_truck_assignments (booking_id);`,
+    );
+
+    await queryRunner.query(`
+      CREATE TABLE IF NOT EXISTS freight.customer_truck_containers (
+        id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+        assignment_id uuid NOT NULL REFERENCES freight.customer_truck_assignments(id) ON DELETE CASCADE,
+        booking_id uuid NOT NULL REFERENCES freight.bookings(id) ON DELETE CASCADE,
+        container_number varchar(64) NOT NULL,
+        created_at timestamptz NOT NULL DEFAULT now(),
+        updated_at timestamptz NOT NULL DEFAULT now(),
+        deleted_at timestamptz
+      );
+    `);
+    await queryRunner.query(
+      `CREATE INDEX IF NOT EXISTS "IDX_customer_truck_containers_assignment" ON freight.customer_truck_containers (assignment_id);`,
+    );
+    // One container number can be loaded onto exactly one truck per booking.
+    await queryRunner.query(`
+      CREATE UNIQUE INDEX IF NOT EXISTS "UQ_customer_truck_containers_booking_number"
+      ON freight.customer_truck_containers (booking_id, container_number)
+      WHERE deleted_at IS NULL;
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`DROP TABLE IF EXISTS freight.customer_truck_containers;`);
+    await queryRunner.query(`DROP TABLE IF EXISTS freight.customer_truck_assignments;`);
+  }
+}
diff --git a/apps/edr-freight-api/src/migrations/1960000000000-AddContainerReceiptToBookingContainerUnits.ts b/apps/edr-freight-api/src/migrations/1960000000000-AddContainerReceiptToBookingContainerUnits.ts
new file mode 100644
index 000000000..59a0441c5
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/1960000000000-AddContainerReceiptToBookingContainerUnits.ts
@@ -0,0 +1,36 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+/**
+ * Per-container receive tracking. A booking's containers arrive individually
+ * (on separate self-haul trucks), so each container unit tracks whether it has
+ * been received into the port and, once staff confirm it, the GRN it belongs to.
+ * A single GRN covers the containers received together — so if the whole booking
+ * arrives at once, all its units share one GRN (per-booking GRN).
+ */
+export class AddContainerReceiptToBookingContainerUnits1960000000000
+  implements MigrationInterface
+{
+  name = 'AddContainerReceiptToBookingContainerUnits1960000000000';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      ALTER TABLE freight.booking_container_units
+        ADD COLUMN IF NOT EXISTS received_to_port boolean NOT NULL DEFAULT false,
+        ADD COLUMN IF NOT EXISTS received_at timestamptz,
+        ADD COLUMN IF NOT EXISTS grn_number varchar(100)
+    `);
+    await queryRunner.query(
+      `CREATE INDEX IF NOT EXISTS "IDX_booking_container_units_grn" ON freight.booking_container_units (grn_number);`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`DROP INDEX IF EXISTS freight."IDX_booking_container_units_grn";`);
+    await queryRunner.query(`
+      ALTER TABLE freight.booking_container_units
+        DROP COLUMN IF EXISTS received_to_port,
+        DROP COLUMN IF EXISTS received_at,
+        DROP COLUMN IF EXISTS grn_number
+    `);
+  }
+}
diff --git a/apps/edr-freight-api/src/migrations/1970000000000-AddCustomerTruckDeparture.ts b/apps/edr-freight-api/src/migrations/1970000000000-AddCustomerTruckDeparture.ts
new file mode 100644
index 000000000..e36420751
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/1970000000000-AddCustomerTruckDeparture.ts
@@ -0,0 +1,26 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+/**
+ * Import self-haul trucks are weighed on leaving. The customer does not
+ * pre-specify what an import truck takes — staff register the containers loaded
+ * and the weighed gross when the truck departs. These columns capture that.
+ */
+export class AddCustomerTruckDeparture1970000000000 implements MigrationInterface {
+  name = 'AddCustomerTruckDeparture1970000000000';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      ALTER TABLE freight.customer_truck_assignments
+        ADD COLUMN IF NOT EXISTS gross_weight_kg numeric(14, 2),
+        ADD COLUMN IF NOT EXISTS departed_at timestamptz
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      ALTER TABLE freight.customer_truck_assignments
+        DROP COLUMN IF EXISTS gross_weight_kg,
+        DROP COLUMN IF EXISTS departed_at
+    `);
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/auth/check-availability.controller.ts b/apps/edr-freight-api/src/modules/auth/check-availability.controller.ts
new file mode 100644
index 000000000..13084d1c8
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/auth/check-availability.controller.ts
@@ -0,0 +1,22 @@
+import { Controller, Get, Query } from "@nestjs/common";
+import { ApiOperation, ApiTags } from "@nestjs/swagger";
+import { Public } from "@edr/api-common";
+
+import { CheckAvailabilityService } from "./check-availability.service";
+
+@ApiTags("auth")
+@Controller("auth")
+@Public()
+export class CheckAvailabilityController {
+  constructor(
+    private readonly checkAvailabilityService: CheckAvailabilityService,
+  ) {}
+
+  @Get("check-availability")
+  @ApiOperation({
+    summary: "Check whether an email and/or phone number is already registered",
+  })
+  check(@Query("email") email?: string, @Query("phone") phone?: string) {
+    return this.checkAvailabilityService.check({ email, phone });
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/auth/check-availability.service.ts b/apps/edr-freight-api/src/modules/auth/check-availability.service.ts
new file mode 100644
index 000000000..c9ce84b72
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/auth/check-availability.service.ts
@@ -0,0 +1,47 @@
+import { BadRequestException, Injectable } from "@nestjs/common";
+import { InjectRepository } from "@nestjs/typeorm";
+import { Repository } from "typeorm";
+
+import { User } from "@tria-plc/iamapi-common/entities/iam/user/user.entity";
+
+export interface CheckAvailabilityQuery {
+  email?: string;
+  phone?: string;
+}
+
+export interface CheckAvailabilityResult {
+  emailTaken: boolean;
+  phoneTaken: boolean;
+}
+
+@Injectable()
+export class CheckAvailabilityService {
+  constructor(
+    @InjectRepository(User)
+    private readonly userRepository: Repository<User>,
+  ) {}
+
+  async check({
+    email,
+    phone,
+  }: CheckAvailabilityQuery): Promise<CheckAvailabilityResult> {
+    if (!email && !phone) {
+      throw new BadRequestException("email or phone is required");
+    }
+
+    const matches = await this.userRepository.find({
+      where: [
+        ...(email ? [{ email }] : []),
+        ...(phone ? [{ phoneNumber: phone }] : []),
+      ],
+      select: { id: true, email: true, phoneNumber: true },
+    });
+
+    return {
+      emailTaken: email ? matches.some((user) => user.email === email) : false,
+      phoneTaken: phone
+        ? matches.some((user) => user.phoneNumber === phone)
+        : false,
+    };
+  }
+}
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 a689ba24e..16fbeffda 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
@@ -1,10 +1,16 @@
 import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
 
+import { User } from '@tria-plc/iamapi-common/entities/iam/user/user.entity';
+
+import { CheckAvailabilityController } from './check-availability.controller';
+import { CheckAvailabilityService } from './check-availability.service';
 import { FreightMeController } from './freight-me.controller';
 import { FreightMeService } from './freight-me.service';
 
 @Module({
-  controllers: [FreightMeController],
-  providers: [FreightMeService],
+  imports: [TypeOrmModule.forFeature([User])],
+  controllers: [FreightMeController, CheckAvailabilityController],
+  providers: [FreightMeService, CheckAvailabilityService],
 })
 export class FreightAuthModule {}
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 536129122..a334b5e28 100644
--- a/apps/edr-freight-api/src/modules/billing/billing.service.ts
+++ b/apps/edr-freight-api/src/modules/billing/billing.service.ts
@@ -307,6 +307,16 @@ export class BillingService {
     });
   }
 
+  /** Invoices for a batch of source records (e.g. many last-mile legs), so a
+   *  list can show which records already have an invoice without N+1 queries. */
+  findBySourceIds(source: string, sourceIds: string[]): Promise<Invoice[]> {
+    if (!sourceIds.length) return Promise.resolve([]);
+    return this.invoices.findAll({
+      where: { source, sourceId: In(sourceIds) },
+      order: { createdAt: "DESC" },
+    });
+  }
+
   /** Invoices for the signed-in customer; empty when they have no company. */
   async findForUser(
     userId: string,
@@ -947,12 +957,27 @@ export class BillingService {
       returnUrl: opts.returnUrl,
       failureUrl: opts.failureUrl,
     });
-
+//
     // Link the intent to the invoice BEFORE any settlement can correlate against it.
     await this.dataSource
       .getRepository(Invoice)
       .update({ id: invoice.id }, { paymentId: result.intentId });
 
+    // DEMO: manually fire the gateway `payment.succeeded` callback here, without
+    // waiting for real gateway settlement. Runs AFTER the paymentId link above so
+    // `handlePaymentEvent → settleByPaymentId` can correlate the invoice. TODO:
+    // remove — real settlement flips this via the `${source}.invoice.paid` handler.
+    if (!result.immediateSuccess) {
+      await this.payment.handlePaymentEvent({
+        eventType: "payment.succeeded",
+        eventId: `demo-${result.intentId}`,
+        referenceId: invoice.sourceId,
+        intentId: result.intentId,
+        providerTxnId: result.providerTxnId,
+        paidAt: (result.paidAt ?? new Date()).toISOString(),
+      });
+    }
+
     if (result.immediateSuccess) {
       await this.settleByPaymentId(
         result.intentId,
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 e8469e627..d63106c2b 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
@@ -431,7 +431,7 @@ export class BookingPricingService {
 
     const lines: PriceLineItemDto[] = [];
     const usedRatesMap = new Map<string, Rate>();
-    const wagonCount = await this.bookingsRepository.calculateWagonCount(booking.id);
+    const wagonCount = await this.resolveWagonCount(booking);
 
     for (const container of evalInput.containers) {
       const rate = this.pickRate(liveRates, rateType, container.containerTypeId, 'USD');
@@ -571,6 +571,23 @@ export class BookingPricingService {
     return { lineItems: lines, usedRates: [...usedRatesMap.values()] };
   }
 
+  /**
+   * Wagon count for PER_WAGON rates. A persisted booking uses the SQL aggregate;
+   * an unsaved preview booking (no id) sums the wagonsRequired already computed
+   * on its in-memory container lines — same math, no DB row needed.
+   */
+  private async resolveWagonCount(booking: Booking): Promise<number> {
+    if (!booking.id) {
+      return Math.ceil(
+        (booking.bookingContainers ?? []).reduce(
+          (sum, bc) => sum + Number(bc.wagonsRequired ?? 0),
+          0,
+        ),
+      );
+    }
+    return this.bookingsRepository.calculateWagonCount(booking.id);
+  }
+
   /** Friendly container-type label for the per-unit card; degrades to "Container". */
   private async containerTypeLabel(containerTypeId: string): Promise<string> {
     try {
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 3e1ea3cd4..06edbf04e 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
@@ -1051,17 +1051,27 @@ export class BookingTransitionService {
       // paid → auto-allocated by the settle/paid pipeline. Consolidated bookings
       // only reserve once both partners are FULLY_EXECUTED (handled inside).
       const fresh = await this.bookingsService.findById(booking.id);
-      await this.bookingBatchService.acceptExportBooking(fresh);
-    } else if (booking.tradeDirection === "IMPORT") {
-      // Import bookings wait for their booking-day window cycle — the batch runs
-      // after staff document review, never at accept time.
-    } else if (booking.scheduledDate) {
-      this.bookingBatchService.enqueueRouteDayProcessing(
-        booking.originYardId,
-        booking.destinationYardId,
-        eatDay(new Date(booking.scheduledDate)),
-      );
+      try {
+        await this.bookingBatchService.acceptExportBooking(fresh);
+      } catch (err) {
+        // The status update above already committed. Without compensation the
+        // client gets an error for a booking that reads as accepted after a
+        // refresh — half-applied state. Put the request back so staff can retry.
+        await this.bookingsRepository.update(booking.id, {
+          status: "OPERATION_REQUEST_PENDING",
+          fullyExecutedAt: null,
+          lockedAt: booking.lockedAt ?? null,
+        } as never);
+        this.logger.warn(
+          `Export accept failed post-commit for ${booking.reference}:${booking.id}; reverted to OPERATION_REQUEST_PENDING: ${(err as Error).message}`,
+        );
+        throw err;
+      }
     }
+    // IMPORT and DOMESTIC bookings wait for their booking-day window cycle — the
+    // batch runs after the window closes + staff document review, never at accept
+    // time. (Legacy pre-migration schedules with no window phase are still served
+    // by the periodic legacy fill.)
     return this.bookingsService.findById(booking.id);
   }
 
@@ -1076,31 +1086,78 @@ export class BookingTransitionService {
         offeredAmount: number;
         paymentDeadline: Date;
       } | null;
+      /** Flat list of physical container numbers on this booking (for the
+       *  customer truck-assignment container picker). */
+      containerNumbers: string[];
     }
   > {
-    const note = await this.bookingsRepository.findLatestReviewNote(
-      booking.id,
-      "CHANGES_REQUESTED",
-    );
-    const summary =
-      booking.contractSummary ??
-      this.contractService.buildContractSummary(booking);
-    const nextPending =
-      booking.status === "PENDING_APPROVAL" ||
-        booking.status === "APPROVED_PENDING_SIGNATURE"
-        ? await this.bookingsRepository.findNextPendingApprovalStep(booking.id)
-        : null;
-    const nextStep = computeNextStep(booking, nextPending);
-    const activeBatchOffer =
-      booking.status === "SELECTED_FOR_BATCH"
-        ? await this.bookingBatchService.getOpenOfferSummary(booking.id)
-        : null;
+    // This enrichment runs AFTER the transition has committed. A failure here
+    // must never 500 the response — the client would report "failed" for a
+    // transition that actually succeeded (visible only after a refresh).
+    // Degrade each fragile field to null instead.
+    let note: Awaited<
+      ReturnType<typeof this.bookingsRepository.findLatestReviewNote>
+    > = null;
+    try {
+      note = await this.bookingsRepository.findLatestReviewNote(
+        booking.id,
+        "CHANGES_REQUESTED",
+      );
+    } catch (err) {
+      this.logger.warn(
+        `enrichBookingResponse: review-note lookup failed for ${booking.id}: ${(err as Error).message}`,
+      );
+    }
+    let summary: string | null = booking.contractSummary ?? null;
+    try {
+      summary =
+        booking.contractSummary ??
+        this.contractService.buildContractSummary(booking);
+    } catch (err) {
+      this.logger.warn(
+        `enrichBookingResponse: contract summary failed for ${booking.id}: ${(err as Error).message}`,
+      );
+    }
+    let nextStep: BookingNextStep | null = null;
+    try {
+      const nextPending =
+        booking.status === "PENDING_APPROVAL" ||
+          booking.status === "APPROVED_PENDING_SIGNATURE"
+          ? await this.bookingsRepository.findNextPendingApprovalStep(booking.id)
+          : null;
+      nextStep = computeNextStep(booking, nextPending);
+    } catch (err) {
+      this.logger.warn(
+        `enrichBookingResponse: next-step lookup failed for ${booking.id}: ${(err as Error).message}`,
+      );
+    }
+    let activeBatchOffer: Awaited<
+      ReturnType<typeof this.bookingBatchService.getOpenOfferSummary>
+    > = null;
+    try {
+      activeBatchOffer =
+        booking.status === "SELECTED_FOR_BATCH"
+          ? await this.bookingBatchService.getOpenOfferSummary(booking.id)
+          : null;
+    } catch (err) {
+      this.logger.warn(
+        `enrichBookingResponse: batch-offer lookup failed for ${booking.id}: ${(err as Error).message}`,
+      );
+    }
+    // Physical container numbers entered at booking time (booking_container
+    // units), flattened for the customer truck-assignment container picker.
+    const containerNumbers = (booking.bookingContainers ?? [])
+      .flatMap((bc) => bc.units ?? [])
+      .map((unit) => unit.containerNumber)
+      .filter((n): n is string => Boolean(n));
+
     return {
       ...booking,
       latestChangeRequestNote: note?.note ?? null,
       contractSummary: summary,
       nextStep,
       activeBatchOffer,
+      containerNumbers,
     };
   }
 }
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 c5574377a..106b7ed5b 100644
--- a/apps/edr-freight-api/src/modules/bookings/bookings.controller.ts
+++ b/apps/edr-freight-api/src/modules/bookings/bookings.controller.ts
@@ -2,6 +2,7 @@ import {
   Body,
   Controller,
   Delete,
+  ForbiddenException,
   Get,
   HttpCode,
   Param,
@@ -61,6 +62,11 @@ import {
 } from './dto/request-changes.dto';
 import { ContractViewDto } from './dto/contract-view.dto';
 import { CustomerTruckAssignmentDto } from './dto/customer-truck-assignment.dto';
+import { AddCustomerTruckDto } from './dto/add-customer-truck.dto';
+import { DepartCustomerTruckDto } from './dto/depart-customer-truck.dto';
+import { CustomerTruckService } from './customer-truck.service';
+import { GenerateGrnDto } from './dto/generate-grn.dto';
+import { ContainerReceiptService } from './container-receipt.service';
 import { SignContractDto } from './dto/sign-contract.dto';
 import { UpdateBookingDto } from './dto/update-booking.dto';
 import {
@@ -83,6 +89,8 @@ export class BookingsController {
     private readonly transitionService: BookingTransitionService,
     private readonly contractService: BookingContractService,
     private readonly bookingClearanceService: BookingClearanceService,
+    private readonly customerTruckService: CustomerTruckService,
+    private readonly containerReceiptService: ContainerReceiptService,
   ) {}
 
   @Post()
@@ -309,6 +317,94 @@ export class BookingsController {
     res.send(buffer);
   }
 
+  @Get(':id/customer-trucks')
+  @ApiOperation({ summary: 'List customer self-haul trucks (multi-truck) for a booking' })
+  async listCustomerTrucks(
+    @Param('id', ParseUUIDPipe) id: string,
+    @CurrentUser() user: TCurrentUser,
+  ) {
+    const booking = await this.bookingsService.findById(id);
+    if (!hasFreightPermission(user, FREIGHT_PERMS.bookings.view)) {
+      await this.bookingsService.assertCustomerCanAccessBooking(user?.id, booking);
+    }
+    return this.customerTruckService.listTrucks(id);
+  }
+
+  @Post(':id/customer-trucks')
+  @ApiOperation({ summary: 'Add a customer self-haul truck carrying 1–2 of the booking containers' })
+  async addCustomerTruck(
+    @Param('id', ParseUUIDPipe) id: string,
+    @Body() dto: AddCustomerTruckDto,
+    @CurrentUser() user: TCurrentUser,
+  ) {
+    const booking = await this.bookingsService.findById(id);
+    if (!hasFreightPermission(user, FREIGHT_PERMS.bookings.view)) {
+      await this.bookingsService.assertCustomerCanAccessBooking(user?.id, booking);
+    }
+    return this.customerTruckService.addTruck(id, dto);
+  }
+
+  @Delete(':id/customer-trucks/:assignmentId')
+  @ApiOperation({ summary: 'Remove a not-yet-arrived customer truck from a booking' })
+  async removeCustomerTruck(
+    @Param('id', ParseUUIDPipe) id: string,
+    @Param('assignmentId', ParseUUIDPipe) assignmentId: string,
+    @CurrentUser() user: TCurrentUser,
+  ) {
+    const booking = await this.bookingsService.findById(id);
+    if (!hasFreightPermission(user, FREIGHT_PERMS.bookings.view)) {
+      await this.bookingsService.assertCustomerCanAccessBooking(user?.id, booking);
+    }
+    return this.customerTruckService.removeTruck(id, assignmentId);
+  }
+
+  @Post(':id/customer-trucks/:assignmentId/depart')
+  @ApiOperation({
+    summary: 'Register an import truck leaving: containers loaded + weighed gross (staff)',
+  })
+  async departCustomerTruck(
+    @Param('id', ParseUUIDPipe) id: string,
+    @Param('assignmentId', ParseUUIDPipe) assignmentId: string,
+    @Body() dto: DepartCustomerTruckDto,
+    @CurrentUser() user: TCurrentUser,
+  ) {
+    // Weighing + registering the load on exit is a warehouse/gate staff action.
+    if (!hasFreightPermission(user, FREIGHT_PERMS.bookings.view)) {
+      throw new ForbiddenException('Only warehouse staff can register a truck departure');
+    }
+    return this.customerTruckService.departTruck(id, assignmentId, dto);
+  }
+
+  @Get(':id/received-pending-grn')
+  @ApiOperation({ summary: 'Containers received into port but not yet on a GRN' })
+  async receivedPendingGrn(
+    @Param('id', ParseUUIDPipe) id: string,
+    @CurrentUser() user: TCurrentUser,
+  ) {
+    // GRN is a warehouse-staff action — no customer access.
+    if (!hasFreightPermission(user, FREIGHT_PERMS.bookings.view)) {
+      throw new ForbiddenException('Only warehouse staff can view or generate GRNs');
+    }
+    return this.containerReceiptService.listReceivedPendingGrn(id);
+  }
+
+  @Post(':id/generate-grn')
+  @ApiOperation({
+    summary:
+      'Generate a GRN over the received containers (all received, or a subset) — one GRN per batch',
+  })
+  async generateGrn(
+    @Param('id', ParseUUIDPipe) id: string,
+    @Body() dto: GenerateGrnDto,
+    @CurrentUser() user: TCurrentUser,
+  ) {
+    // GRN is a warehouse-staff action — no customer access.
+    if (!hasFreightPermission(user, FREIGHT_PERMS.bookings.view)) {
+      throw new ForbiddenException('Only warehouse staff can view or generate GRNs');
+    }
+    return this.containerReceiptService.generateGrn(id, dto.containerNumbers);
+  }
+
   @Get(':id/tracking')
   @ApiOperation({
     summary: "Shipment tracking timeline for a booking",
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 92790c273..2cb10ce8e 100644
--- a/apps/edr-freight-api/src/modules/bookings/bookings.module.ts
+++ b/apps/edr-freight-api/src/modules/bookings/bookings.module.ts
@@ -33,6 +33,11 @@ import { BookingRateSnapshot } from './entities/booking-rate-snapshot.entity';
 import { BookingContractSignature } from './entities/booking-contract-signature.entity';
 import { BookingReviewNote } from './entities/booking-review-note.entity';
 import { Booking } from './entities/booking.entity';
+import { CustomerTruckAssignment } from './entities/customer-truck-assignment.entity';
+import { CustomerTruckContainer } from './entities/customer-truck-container.entity';
+import { CustomerTruckAssignmentsRepository } from './customer-truck-assignments.repository';
+import { CustomerTruckService } from './customer-truck.service';
+import { ContainerReceiptService } from './container-receipt.service';
 import { ContractPdfService } from '../../contracts/contract-pdf.service';
 import { ContractsModule } from '../contracts/contracts.module';
 import { BookingContainerAllocation } from "./entities/booking-container-allocation.entity";
@@ -55,6 +60,8 @@ import { VehiclesModule } from "../vehicles/vehicles.module";
       BookingReviewNote,
       BookingContractSignature,
       BookingContainerAllocation,
+      CustomerTruckAssignment,
+      CustomerTruckContainer,
     ]),
     BillingModule,
     forwardRef(() => FirstMileModule),
@@ -91,12 +98,17 @@ import { VehiclesModule } from "../vehicles/vehicles.module";
     ContractPricingScheduleBuilder,
     ContractRendererService,
     ContractPdfService,
+    CustomerTruckAssignmentsRepository,
+    CustomerTruckService,
+    ContainerReceiptService,
   ],
   exports: [
     BookingsService,
     BookingsRepository,
     BookingPricingService,
     BookingInvoiceService,
+    CustomerTruckService,
+    ContainerReceiptService,
   ],
 })
 export class BookingsModule { }
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 3f696bc6b..6dfe2b8b9 100644
--- a/apps/edr-freight-api/src/modules/bookings/bookings.repository.ts
+++ b/apps/edr-freight-api/src/modules/bookings/bookings.repository.ts
@@ -5,6 +5,7 @@ import { InjectRepository } from '@nestjs/typeorm';
 import { DataSource, EntityManager, FindOptionsWhere, In, Repository, SelectQueryBuilder } from 'typeorm';
 
 import { ContainerType } from '../rule-engine/entities/container-type.entity';
+import { Contract } from '../contracts/entities/contract.entity';
 import { ContractRoute } from '../contracts/entities/contract-route.entity';
 import { BookingApprovalStep } from './entities/booking-approval-step.entity';
 import { BookingCargoModifier } from './entities/booking-cargo-modifier.entity';
@@ -35,6 +36,7 @@ export interface BookingListFilterOptions {
   serviceTypeId?: string;
   cargoTypeId?: string;
   freightType?: string;
+  bookingType?: string;
   tradeDirection?: string;
   paymentCurrency?: string;
   paymentStatus?: string;
@@ -89,6 +91,7 @@ export class BookingsRepository extends BaseRepository<Booking> {
       .createQueryBuilder('booking')
       .leftJoinAndSelect('booking.bookingContainers', 'bc')
       .leftJoinAndSelect('bc.containerType', 'ct')
+      .leftJoinAndSelect('bc.units', 'bcu')
       .leftJoinAndSelect('booking.company', 'company')
       // .leftJoinAndSelect('booking.customer', 'customer')
       .leftJoinAndSelect('booking.train', 'train')
@@ -103,6 +106,7 @@ export class BookingsRepository extends BaseRepository<Booking> {
       .leftJoinAndSelect('booking.reviewNotes', 'reviewNotes')
       .leftJoinAndSelect('booking.consolidationPartner', 'consolidationPartner')
       .where('booking.id = :id', { id })
+      .addOrderBy('bcu.sort_order', 'ASC')
       .leftJoinAndMapMany(
         'booking.files',
         FileRecord,
@@ -584,6 +588,12 @@ export class BookingsRepository extends BaseRepository<Booking> {
       .leftJoinAndSelect('booking.serviceType', 'serviceType')
       .leftJoinAndSelect('booking.approvalSteps', 'approvalSteps')
       .leftJoinAndSelect('booking.consolidationPartner', 'consolidationPartner')
+      // Contract reference for the list column + search (no entity relation on
+      // Booking → contract, so join the entity by id and select just the
+      // reference — a schema-qualified table string is parsed as alias.relation
+      // by TypeORM and crashes).
+      .leftJoin(Contract, 'contract', 'contract.id = booking.contract_id')
+      .addSelect('contract.reference', 'contract_reference')
       .where('booking.deleted_at IS NULL');
 
     this.applyListFilters(qb, options);
@@ -602,10 +612,24 @@ export class BookingsRepository extends BaseRepository<Booking> {
       qb.orderBy(sortField, options.sortOrder ?? 'DESC');
     }
 
-    const [items, total] = await qb
+    const total = await qb.getCount();
+    const { entities: items, raw } = await qb
       .skip((page - 1) * pageSize)
       .take(pageSize)
-      .getManyAndCount();
+      .getRawAndEntities();
+
+    // The joined contract.reference comes back on the raw rows only (entity has no
+    // contract relation) — map it onto each booking by position.
+    const contractRefByBooking = new Map<string, string | null>();
+    for (const row of raw as Array<{ booking_id: string; contract_reference: string | null }>) {
+      if (row.booking_id && !contractRefByBooking.has(row.booking_id)) {
+        contractRefByBooking.set(row.booking_id, row.contract_reference ?? null);
+      }
+    }
+    for (const item of items) {
+      (item as Booking & { contractReference?: string | null }).contractReference =
+        contractRefByBooking.get(item.id) ?? null;
+    }
 
     if (items.length) {
       const links = await this.dataSource.getRepository(TrainScheduleBooking).find({
@@ -737,6 +761,11 @@ export class BookingsRepository extends BaseRepository<Booking> {
         freightType: options.freightType,
       });
     }
+    if (options.bookingType) {
+      qb.andWhere('booking.bookingType = :bookingType', {
+        bookingType: options.bookingType,
+      });
+    }
     if (options.createdFrom) {
       qb.andWhere('booking.created_at >= :createdFrom', {
         createdFrom: options.createdFrom,
@@ -1051,8 +1080,12 @@ export class BookingsRepository extends BaseRepository<Booking> {
         company: true,
         originYard: true,
         destinationYard: true,
-        bookingContainers: { containerType: true },
-        cargoType: true,
+        // units carry the real per-container numbers entered at booking time —
+        // the wagon plan shows those instead of generated placeholders.
+        // containerType.wagonType + cargoType.wagonType drive wagon-type
+        // resolution during scheduling (FK, not the old load-type string map).
+        bookingContainers: { containerType: { wagonType: true }, units: true },
+        cargoType: { wagonType: true },
       },
       order: { priorityScore: 'DESC', createdAt: 'ASC' },
     });
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 ac639a4bd..1f2c1a09e 100644
--- a/apps/edr-freight-api/src/modules/bookings/bookings.service.ts
+++ b/apps/edr-freight-api/src/modules/bookings/bookings.service.ts
@@ -145,7 +145,28 @@ export class BookingsService {
       throw new BadRequestException('Customer truck must be assigned before freight order copies can be generated');
     }
 
-    const html = this.buildCustomerTruckFreightOrderHtml(booking);
+    const trucks: Array<{
+      plateNumber: string;
+      driverName: string;
+      truckType: string;
+      arrivedAt: string | null;
+      containers: string | null;
+    }> = await this.dataSource.query(
+      `SELECT a.plate_number AS "plateNumber",
+              a.driver_name AS "driverName",
+              a.truck_type AS "truckType",
+              a.arrived_at AS "arrivedAt",
+              string_agg(c.container_number, ', ' ORDER BY c.container_number) AS "containers"
+         FROM freight.customer_truck_assignments a
+         LEFT JOIN freight.customer_truck_containers c
+           ON c.assignment_id = a.id AND c.deleted_at IS NULL
+        WHERE a.booking_id = $1 AND a.deleted_at IS NULL
+        GROUP BY a.id, a.plate_number, a.driver_name, a.truck_type, a.arrived_at, a.assigned_at
+        ORDER BY a.assigned_at`,
+      [bookingId],
+    );
+
+    const html = this.buildCustomerTruckFreightOrderHtml(booking, trucks);
     const buffer = await this.contractPdfService.htmlToPdfBuffer(html);
     return {
       filename: `freight-order-${booking.reference.replace(/[^a-zA-Z0-9_-]+/g, '-')}.pdf`,
@@ -190,37 +211,85 @@ export class BookingsService {
     return `BK-${year}-${String(count + 1).padStart(6, '0')}`;
   }
 
-  private buildCustomerTruckFreightOrderHtml(booking: Booking): string {
+  private buildCustomerTruckFreightOrderHtml(
+    booking: Booking,
+    trucks: Array<{
+      plateNumber: string;
+      driverName: string;
+      truckType: string;
+      arrivedAt: string | null;
+      containers: string | null;
+    }>,
+  ): string {
     const assignedAt = booking.customerTruckAssignedAt
       ? new Date(booking.customerTruckAssignedAt).toLocaleString('en-GB')
       : '-';
-    const rows: Array<[string, string | null | undefined]> = [
+    const bookingRows: Array<[string, string | null | undefined]> = [
       ['Booking Reference', booking.reference],
       ['Client Name', booking.company?.name],
       ['Client ID', booking.companyId],
       ['Trade Direction', booking.tradeDirection],
       ['Freight Type', booking.freightType],
-      ['Truck Plate Number', booking.customerTruckPlateNumber],
-      ['Driver Name', booking.customerTruckDriverName],
-      ['Truck Type', booking.customerTruckType],
-      ['Container Number to Load', booking.customerTruckContainerNumber],
       ['Assigned At', assignedAt],
       ['Booking Status', booking.status],
     ];
-    const rowHtml = rows
+    const bookingRowHtml = bookingRows
       .map(([label, value]) => `<tr><th>${this.escapeHtml(label)}</th><td>${this.escapeHtml(value || '-')}</td></tr>`)
       .join('');
+
+    // Fall back to the legacy single-truck booking columns when there are no
+    // multi-truck rows (bookings assigned before the multi-truck feature).
+    const truckList =
+      trucks.length > 0
+        ? trucks
+        : booking.customerTruckPlateNumber
+          ? [
+              {
+                plateNumber: booking.customerTruckPlateNumber,
+                driverName: booking.customerTruckDriverName ?? '',
+                truckType: booking.customerTruckType ?? '',
+                arrivedAt: booking.customerTruckArrivedAt
+                  ? String(booking.customerTruckArrivedAt)
+                  : null,
+                containers: booking.customerTruckContainerNumber ?? null,
+              },
+            ]
+          : [];
+
+    const truckBlocks = truckList
+      .map((t, i) => {
+        const rows: Array<[string, string | null | undefined]> = [
+          ['Truck Plate Number', t.plateNumber],
+          ['Driver Name', t.driverName],
+          ['Truck Type', t.truckType],
+          ['Containers Loaded', t.containers],
+          [
+            'Arrival',
+            t.arrivedAt ? new Date(t.arrivedAt).toLocaleString('en-GB') : 'Awaiting arrival',
+          ],
+        ];
+        const html = rows
+          .map(
+            ([label, value]) =>
+              `<tr><th>${this.escapeHtml(label)}</th><td>${this.escapeHtml(value || '-')}</td></tr>`,
+          )
+          .join('');
+        return `<div class="truck"><h2>Truck ${i + 1}</h2><table>${html}</table></div>`;
+      })
+      .join('');
+
     const copy = (watermark: string) => `
       <section class="copy">
         <div class="watermark">${this.escapeHtml(watermark)}</div>
         <header>
           <div>
             <h1>Freight Order</h1>
-            <p>Customer external truck assignment</p>
+            <p>Customer external truck assignment — ${truckList.length} truck${truckList.length !== 1 ? 's' : ''}</p>
           </div>
           <strong>${this.escapeHtml(booking.reference)}</strong>
         </header>
-        <table>${rowHtml}</table>
+        <table>${bookingRowHtml}</table>
+        ${truckBlocks}
         <div class="signatures">
           <div>Customer / Carrier Signature</div>
           <div>Port Operations Verification</div>
@@ -238,11 +307,13 @@ export class BookingsService {
             .watermark { position: absolute; inset: 0; display: flex; align-items: center; justify-content: center; font-size: 34px; font-weight: 800; color: rgba(16, 32, 47, 0.08); transform: rotate(-18deg); pointer-events: none; }
             header { display: flex; justify-content: space-between; align-items: flex-start; border-bottom: 3px solid #0a9f6a; padding-bottom: 14px; margin-bottom: 18px; }
             h1 { margin: 0; font-size: 28px; letter-spacing: 0; }
+            h2 { margin: 18px 0 8px; font-size: 14px; color: #0a6f4d; }
             p { margin: 4px 0 0; color: #64748b; }
             strong { font-size: 16px; color: #0a9f6a; }
-            table { width: 100%; border-collapse: collapse; position: relative; z-index: 1; }
+            table { width: 100%; border-collapse: collapse; position: relative; z-index: 1; margin-bottom: 6px; }
             th, td { border: 1px solid #cbd5e1; padding: 9px 10px; text-align: left; font-size: 12px; }
             th { width: 34%; background: #f1f5f9; }
+            .truck { page-break-inside: avoid; }
             .signatures { display: grid; grid-template-columns: repeat(3, 1fr); gap: 16px; margin-top: 34px; font-size: 11px; color: #475569; position: relative; z-index: 1; }
             .signatures div { border-top: 1px solid #334155; padding-top: 8px; min-height: 28px; }
           </style>
@@ -1001,6 +1072,7 @@ export class BookingsService {
       serviceTypeId: filter.serviceTypeId,
       cargoTypeId: filter.cargoTypeId,
       freightType: filter.freightType,
+      bookingType: filter.bookingType,
       tradeDirection: filter.tradeDirection,
       paymentCurrency: filter.paymentCurrency,
       paymentStatus: filter.paymentStatus,
diff --git a/apps/edr-freight-api/src/modules/bookings/container-receipt.service.ts b/apps/edr-freight-api/src/modules/bookings/container-receipt.service.ts
new file mode 100644
index 000000000..fde3ab797
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/bookings/container-receipt.service.ts
@@ -0,0 +1,145 @@
+import { BadRequestException, Injectable, NotFoundException } from '@nestjs/common';
+import { DataSource, EntityManager } from 'typeorm';
+
+export interface ReceivedUnitRow {
+  id: string;
+  containerNumber: string;
+  receivedToPort: boolean;
+  receivedAt: string | null;
+  grnNumber: string | null;
+}
+
+/**
+ * Per-container receive + GRN tracking on booking_container_units.
+ *
+ * Containers arrive individually (on separate self-haul trucks), so each unit is
+ * flipped `received_to_port` when its truck arrives (auto). Staff then confirm a
+ * Goods Received Note over the received-but-un-GRN'd containers: one GRN covers a
+ * batch, so if the whole booking arrives together every unit shares a single GRN
+ * (per-booking GRN); if trucks arrive separately each batch gets its own GRN.
+ */
+@Injectable()
+export class ContainerReceiptService {
+  constructor(private readonly dataSource: DataSource) {}
+
+  /**
+   * Auto-mark the containers loaded on an arrived truck as received into the
+   * port. Idempotent — only flips units not already received. Runs inside the
+   * caller's transaction when a manager is supplied.
+   */
+  async markReceivedForAssignment(
+    bookingId: string,
+    assignmentId: string,
+    manager?: EntityManager,
+  ): Promise<void> {
+    const m = manager ?? this.dataSource.manager;
+    await m.query(
+      `UPDATE freight.booking_container_units bcu
+          SET received_to_port = true,
+              received_at = COALESCE(bcu.received_at, NOW()),
+              updated_at = NOW()
+         FROM freight.booking_containers bc,
+              freight.customer_truck_containers ctc
+        WHERE bc.id = bcu.booking_container_id
+          AND bc.booking_id = $1
+          AND ctc.assignment_id = $2
+          AND ctc.deleted_at IS NULL
+          AND ctc.container_number = bcu.container_number
+          AND bcu.deleted_at IS NULL
+          AND bcu.received_to_port = false`,
+      [bookingId, assignmentId],
+    );
+  }
+
+  /** Received-into-port containers that have not yet been assigned a GRN. */
+  async listReceivedPendingGrn(bookingId: string): Promise<ReceivedUnitRow[]> {
+    return this.dataSource.query(
+      `SELECT bcu.id,
+              bcu.container_number AS "containerNumber",
+              bcu.received_to_port AS "receivedToPort",
+              bcu.received_at AS "receivedAt",
+              bcu.grn_number AS "grnNumber"
+         FROM freight.booking_container_units bcu
+         JOIN freight.booking_containers bc
+           ON bc.id = bcu.booking_container_id AND bc.deleted_at IS NULL
+        WHERE bc.booking_id = $1
+          AND bcu.deleted_at IS NULL
+          AND bcu.received_to_port = true
+          AND bcu.grn_number IS NULL
+        ORDER BY bcu.received_at`,
+      [bookingId],
+    );
+  }
+
+  /**
+   * Confirm a GRN over the currently received-but-un-GRN'd containers (optionally
+   * a subset by container number). Assigns one GRN number to the whole batch and
+   * returns it with the covered containers. If the batch covers every container
+   * on the booking it is effectively a per-booking GRN.
+   */
+  async generateGrn(
+    bookingId: string,
+    containerNumbers?: string[],
+  ): Promise<{ grnNumber: string; containerNumbers: string[]; perBooking: boolean }> {
+    const [booking] = await this.dataSource.query(
+      `SELECT reference FROM freight.bookings WHERE id = $1 AND deleted_at IS NULL`,
+      [bookingId],
+    );
+    if (!booking) throw new NotFoundException(`Booking ${bookingId} not found`);
+
+    return this.dataSource.transaction(async (manager) => {
+      const wanted = containerNumbers?.map((n) => n.trim().toUpperCase());
+      const pending: ReceivedUnitRow[] = await manager.query(
+        `SELECT bcu.id, bcu.container_number AS "containerNumber"
+           FROM freight.booking_container_units bcu
+           JOIN freight.booking_containers bc
+             ON bc.id = bcu.booking_container_id AND bc.deleted_at IS NULL
+          WHERE bc.booking_id = $1
+            AND bcu.deleted_at IS NULL
+            AND bcu.received_to_port = true
+            AND bcu.grn_number IS NULL
+            ${wanted ? 'AND bcu.container_number = ANY($2::varchar[])' : ''}`,
+        wanted ? [bookingId, wanted] : [bookingId],
+      );
+      if (!pending.length) {
+        throw new BadRequestException('No received containers are awaiting a GRN');
+      }
+
+      // Batch sequence = number of GRNs already issued for this booking + 1.
+      const [{ batches }]: Array<{ batches: string }> = await manager.query(
+        `SELECT COUNT(DISTINCT bcu.grn_number) AS batches
+           FROM freight.booking_container_units bcu
+           JOIN freight.booking_containers bc
+             ON bc.id = bcu.booking_container_id AND bc.deleted_at IS NULL
+          WHERE bc.booking_id = $1 AND bcu.grn_number IS NOT NULL AND bcu.deleted_at IS NULL`,
+        [bookingId],
+      );
+      const seq = Number(batches) + 1;
+      const grnNumber = `GRN-${String(booking.reference).replace(/^BK-?/i, '')}-${String(seq).padStart(2, '0')}`;
+
+      const ids = pending.map((p) => p.id);
+      await manager.query(
+        `UPDATE freight.booking_container_units
+            SET grn_number = $1, updated_at = NOW()
+          WHERE id = ANY($2::uuid[])`,
+        [grnNumber, ids],
+      );
+
+      // Per-booking when no container on the booking is left un-GRN'd.
+      const [{ remaining }]: Array<{ remaining: string }> = await manager.query(
+        `SELECT COUNT(*) AS remaining
+           FROM freight.booking_container_units bcu
+           JOIN freight.booking_containers bc
+             ON bc.id = bcu.booking_container_id AND bc.deleted_at IS NULL
+          WHERE bc.booking_id = $1 AND bcu.deleted_at IS NULL AND bcu.grn_number IS NULL`,
+        [bookingId],
+      );
+
+      return {
+        grnNumber,
+        containerNumbers: pending.map((p) => p.containerNumber),
+        perBooking: Number(remaining) === 0 && seq === 1,
+      };
+    });
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/bookings/customer-truck-assignments.repository.ts b/apps/edr-freight-api/src/modules/bookings/customer-truck-assignments.repository.ts
new file mode 100644
index 000000000..45a09a6a3
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/bookings/customer-truck-assignments.repository.ts
@@ -0,0 +1,29 @@
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+import { BaseRepository } from '@edr/api-common';
+
+import { CustomerTruckAssignment } from './entities/customer-truck-assignment.entity';
+
+@Injectable()
+export class CustomerTruckAssignmentsRepository extends BaseRepository<CustomerTruckAssignment> {
+  constructor(
+    @InjectRepository(CustomerTruckAssignment)
+    private readonly repo: Repository<CustomerTruckAssignment>,
+  ) {
+    super(repo);
+  }
+
+  /** All trucks assigned to a booking, oldest first, with their containers. */
+  findByBookingId(bookingId: string): Promise<CustomerTruckAssignment[]> {
+    return this.repo.find({
+      where: { bookingId },
+      relations: { containers: true },
+      order: { assignedAt: 'ASC' },
+    });
+  }
+
+  findByIdWithContainers(id: string): Promise<CustomerTruckAssignment | null> {
+    return this.repo.findOne({ where: { id }, relations: { containers: true } });
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/bookings/customer-truck.service.ts b/apps/edr-freight-api/src/modules/bookings/customer-truck.service.ts
new file mode 100644
index 000000000..5d0650219
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/bookings/customer-truck.service.ts
@@ -0,0 +1,321 @@
+import {
+  BadRequestException,
+  ConflictException,
+  Injectable,
+  NotFoundException,
+} from '@nestjs/common';
+import { DataSource, EntityManager, IsNull } from 'typeorm';
+
+import { AddCustomerTruckDto } from './dto/add-customer-truck.dto';
+import { DepartCustomerTruckDto } from './dto/depart-customer-truck.dto';
+import { CustomerTruckAssignment } from './entities/customer-truck-assignment.entity';
+import { CustomerTruckContainer } from './entities/customer-truck-container.entity';
+import { CustomerTruckAssignmentsRepository } from './customer-truck-assignments.repository';
+
+interface BookingGuardRow {
+  tradeDirection: string | null;
+  firstMile: string | null;
+  lastMile: string | null;
+  paymentStatus: string | null;
+  status: string | null;
+}
+
+/**
+ * Multi-truck self-haul assignment. A booking with no EDR first/last-mile leg
+ * can have several customer trucks, each carrying 1–2 of its containers and
+ * tracking its own arrival. The legacy booking.customer_truck_* columns are kept
+ * as a booking-level flag (any truck assigned / all arrived) so the warehouse
+ * exit-gate + delivery-approval logic keep working unchanged.
+ */
+@Injectable()
+export class CustomerTruckService {
+  constructor(
+    private readonly dataSource: DataSource,
+    private readonly assignments: CustomerTruckAssignmentsRepository,
+  ) {}
+
+  listTrucks(bookingId: string): Promise<CustomerTruckAssignment[]> {
+    return this.assignments.findByBookingId(bookingId);
+  }
+
+  async addTruck(bookingId: string, dto: AddCustomerTruckDto): Promise<CustomerTruckAssignment[]> {
+    const booking = await this.loadBookingGuard(bookingId);
+    this.assertSelfHaulPaid(booking);
+
+    const isExport = booking.tradeDirection === 'EXPORT';
+    const requested = (dto.containerNumbers ?? []).map((n) => n.trim().toUpperCase());
+
+    // EXPORT: the truck delivers 1–2 known containers. IMPORT: containers are
+    // not pre-specified — they are registered + weighed when the truck leaves.
+    if (isExport) {
+      if (requested.length < 1 || requested.length > 2) {
+        throw new BadRequestException('An export truck must carry 1 or 2 of the booking containers');
+      }
+    } else if (requested.length > 2) {
+      throw new BadRequestException('A truck carries at most 2 containers');
+    }
+
+    if (requested.length) {
+      const bookingNumbers = await this.bookingContainerNumbers(bookingId);
+      for (const n of requested) {
+        if (!bookingNumbers.includes(n)) {
+          throw new BadRequestException(`Container ${n} is not one of this booking's containers`);
+        }
+      }
+      const alreadyAssigned = await this.assignedContainerNumbers(bookingId);
+      for (const n of requested) {
+        if (alreadyAssigned.includes(n)) {
+          throw new ConflictException(`Container ${n} is already loaded onto another truck`);
+        }
+      }
+    }
+
+    await this.dataSource.transaction(async (manager) => {
+      const assignment = await manager.getRepository(CustomerTruckAssignment).save(
+        manager.getRepository(CustomerTruckAssignment).create({
+          bookingId,
+          plateNumber: dto.truckPlateNumber.trim().toUpperCase(),
+          driverName: dto.driverName.trim(),
+          truckType: dto.truckType.trim(),
+        }),
+      );
+      await manager.getRepository(CustomerTruckContainer).save(
+        requested.map((containerNumber) =>
+          manager.getRepository(CustomerTruckContainer).create({
+            assignmentId: assignment.id,
+            bookingId,
+            containerNumber,
+          }),
+        ),
+      );
+      // Booking-level flag: first truck marks the booking as truck-assigned.
+      await manager.query(
+        `UPDATE freight.bookings
+            SET customer_truck_assigned_at = COALESCE(customer_truck_assigned_at, NOW()),
+                status = CASE WHEN status = 'PAID' THEN 'TRUCK_ASSIGNED' ELSE status END,
+                updated_at = NOW()
+          WHERE id = $1`,
+        [bookingId],
+      );
+    });
+
+    return this.listTrucks(bookingId);
+  }
+
+  async removeTruck(bookingId: string, assignmentId: string): Promise<CustomerTruckAssignment[]> {
+    const assignment = await this.assignments.findByIdWithContainers(assignmentId);
+    if (!assignment || assignment.bookingId !== bookingId) {
+      throw new NotFoundException('Truck assignment not found for this booking');
+    }
+    if (assignment.arrivedAt) {
+      throw new ConflictException('Cannot remove a truck that has already arrived');
+    }
+
+    await this.dataSource.transaction(async (manager) => {
+      await manager.getRepository(CustomerTruckContainer).softDelete({ assignmentId });
+      await manager.getRepository(CustomerTruckAssignment).softDelete(assignmentId);
+      const remaining = await manager
+        .getRepository(CustomerTruckAssignment)
+        .count({ where: { bookingId } });
+      if (remaining === 0) {
+        // No trucks left — clear the booking-level flag and revert the status.
+        await manager.query(
+          `UPDATE freight.bookings
+              SET customer_truck_assigned_at = NULL,
+                  status = CASE WHEN status = 'TRUCK_ASSIGNED' THEN 'PAID' ELSE status END,
+                  updated_at = NOW()
+            WHERE id = $1`,
+          [bookingId],
+        );
+      }
+    });
+
+    return this.listTrucks(bookingId);
+  }
+
+  /**
+   * Register an IMPORT self-haul truck leaving the port: the containers it
+   * actually loaded (replacing any provisional list) and its weighed gross.
+   * Export bookings have no truck departure — trucks only deliver (receive).
+   */
+  async departTruck(
+    bookingId: string,
+    assignmentId: string,
+    dto: DepartCustomerTruckDto,
+  ): Promise<CustomerTruckAssignment[]> {
+    const booking = await this.loadBookingGuard(bookingId);
+    if (booking.tradeDirection !== 'IMPORT') {
+      throw new BadRequestException(
+        'Truck departure/weighing applies to import self-haul only (export trucks only deliver)',
+      );
+    }
+    const assignment = await this.assignments.findByIdWithContainers(assignmentId);
+    if (!assignment || assignment.bookingId !== bookingId) {
+      throw new NotFoundException('Truck assignment not found for this booking');
+    }
+    // Once filled, the departure record is uneditable.
+    if (assignment.departedAt) {
+      throw new ConflictException('This truck has already departed — its exit record is locked');
+    }
+
+    const requested = (dto.containerNumbers ?? []).map((n) => n.trim().toUpperCase());
+    if (requested.length) {
+      const bookingNumbers = await this.bookingContainerNumbers(bookingId);
+      for (const n of requested) {
+        if (!bookingNumbers.includes(n)) {
+          throw new BadRequestException(`Container ${n} is not one of this booking's containers`);
+        }
+      }
+      const elsewhere = await this.assignedContainerNumbersExcept(bookingId, assignmentId);
+      for (const n of requested) {
+        if (elsewhere.includes(n)) {
+          throw new ConflictException(`Container ${n} is already loaded onto another truck`);
+        }
+      }
+    }
+
+    await this.dataSource.transaction(async (manager) => {
+      if (requested.length) {
+        // Replace the truck's containers with what was actually loaded.
+        await manager.getRepository(CustomerTruckContainer).softDelete({ assignmentId });
+        await manager.getRepository(CustomerTruckContainer).save(
+          requested.map((containerNumber) =>
+            manager.getRepository(CustomerTruckContainer).create({
+              assignmentId,
+              bookingId,
+              containerNumber,
+            }),
+          ),
+        );
+      }
+      await manager.getRepository(CustomerTruckAssignment).update(assignmentId, {
+        grossWeightKg: dto.grossWeightKg,
+        departedAt: dto.gateOutTime ? new Date(dto.gateOutTime) : new Date(),
+        arrivedAt: assignment.arrivedAt ?? new Date(),
+      });
+    });
+
+    return this.listTrucks(bookingId);
+  }
+
+  /**
+   * Mark the truck carrying `containerNumber` as arrived. Called by the warehouse
+   * receive flow. When every truck on the booking has arrived, the booking-level
+   * customer_truck_arrived_at flag is stamped (used by the delivery-approval
+   * gate). No-op when the container is not on any customer truck.
+   */
+  async markArrivedByContainer(
+    bookingId: string,
+    containerNumber: string,
+    manager?: EntityManager,
+  ): Promise<void> {
+    const m = manager ?? this.dataSource.manager;
+    const cn = containerNumber.trim().toUpperCase();
+    const container = await m.getRepository(CustomerTruckContainer).findOne({
+      where: { bookingId, containerNumber: cn },
+    });
+    if (!container) return;
+
+    await m
+      .getRepository(CustomerTruckAssignment)
+      .update({ id: container.assignmentId, arrivedAt: IsNull() }, { arrivedAt: new Date() });
+
+    await this.syncBookingArrival(bookingId, m);
+  }
+
+  /** Mark every truck on the booking arrived (fallback when no container is known). */
+  async markAllArrived(bookingId: string, manager?: EntityManager): Promise<void> {
+    const m = manager ?? this.dataSource.manager;
+    await m
+      .getRepository(CustomerTruckAssignment)
+      .update({ bookingId, arrivedAt: IsNull() }, { arrivedAt: new Date() });
+    await this.syncBookingArrival(bookingId, m);
+  }
+
+  /**
+   * Stamp the booking-level arrival flag on the FIRST truck arrival. The import
+   * handover is signed once, before the first truck leaves, even though trucks
+   * pick up per-container — so the flag fires on the first arrival (COALESCE
+   * keeps it), not once all trucks have arrived.
+   */
+  private async syncBookingArrival(bookingId: string, m: EntityManager): Promise<void> {
+    await m.query(
+      `UPDATE freight.bookings
+          SET customer_truck_arrived_at = COALESCE(customer_truck_arrived_at, NOW()),
+              updated_at = NOW()
+        WHERE id = $1 AND customer_truck_assigned_at IS NOT NULL`,
+      [bookingId],
+    );
+  }
+
+  private async loadBookingGuard(bookingId: string): Promise<BookingGuardRow> {
+    const [row]: BookingGuardRow[] = await this.dataSource.query(
+      `SELECT trade_direction AS "tradeDirection",
+              first_mile_pickup_address AS "firstMile",
+              last_mile_delivery_address AS "lastMile",
+              payment_status AS "paymentStatus",
+              status
+         FROM freight.bookings
+        WHERE id = $1 AND deleted_at IS NULL`,
+      [bookingId],
+    );
+    if (!row) throw new NotFoundException(`Booking ${bookingId} not found`);
+    return row;
+  }
+
+  private assertSelfHaulPaid(booking: BookingGuardRow): void {
+    const hasFirstMile = Boolean(booking.firstMile?.trim());
+    const hasLastMile = Boolean(booking.lastMile?.trim());
+    const usesMileService =
+      booking.tradeDirection === 'IMPORT'
+        ? hasLastMile
+        : booking.tradeDirection === 'EXPORT'
+          ? hasFirstMile
+          : hasFirstMile || hasLastMile;
+    if (usesMileService) {
+      throw new BadRequestException(
+        'Customer truck assignment is only allowed when first/last mile delivery is not selected',
+      );
+    }
+    if (booking.paymentStatus !== 'PAID') {
+      throw new BadRequestException(
+        'Booking must be paid before assigning an external customer truck',
+      );
+    }
+  }
+
+  private async bookingContainerNumbers(bookingId: string): Promise<string[]> {
+    const rows: Array<{ containerNumber: string }> = await this.dataSource.query(
+      `SELECT bcu.container_number AS "containerNumber"
+         FROM freight.booking_container_units bcu
+         JOIN freight.booking_containers bc
+           ON bc.id = bcu.booking_container_id AND bc.deleted_at IS NULL
+        WHERE bc.booking_id = $1 AND bcu.deleted_at IS NULL`,
+      [bookingId],
+    );
+    return rows.map((r) => r.containerNumber.trim().toUpperCase());
+  }
+
+  private async assignedContainerNumbers(bookingId: string): Promise<string[]> {
+    const rows: Array<{ containerNumber: string }> = await this.dataSource.query(
+      `SELECT container_number AS "containerNumber"
+         FROM freight.customer_truck_containers
+        WHERE booking_id = $1 AND deleted_at IS NULL`,
+      [bookingId],
+    );
+    return rows.map((r) => r.containerNumber.trim().toUpperCase());
+  }
+
+  private async assignedContainerNumbersExcept(
+    bookingId: string,
+    exceptAssignmentId: string,
+  ): Promise<string[]> {
+    const rows: Array<{ containerNumber: string }> = await this.dataSource.query(
+      `SELECT container_number AS "containerNumber"
+         FROM freight.customer_truck_containers
+        WHERE booking_id = $1 AND assignment_id <> $2 AND deleted_at IS NULL`,
+      [bookingId, exceptAssignmentId],
+    );
+    return rows.map((r) => r.containerNumber.trim().toUpperCase());
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/bookings/dto/add-customer-truck.dto.ts b/apps/edr-freight-api/src/modules/bookings/dto/add-customer-truck.dto.ts
new file mode 100644
index 000000000..4356d66ec
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/bookings/dto/add-customer-truck.dto.ts
@@ -0,0 +1,47 @@
+import {
+  ArrayMaxSize,
+  ArrayUnique,
+  IsArray,
+  IsIn,
+  IsNotEmpty,
+  IsOptional,
+  IsString,
+  Matches,
+  MaxLength,
+} from 'class-validator';
+
+import { CUSTOMER_TRUCK_TYPES } from './customer-truck-assignment.dto';
+
+/**
+ * Add one external customer truck to a booking.
+ *  - EXPORT: the truck delivers 1–2 known containers (required, validated in the
+ *    service against the booking's containers).
+ *  - IMPORT: the customer does not pre-specify — containers are registered and
+ *    weighed when the truck leaves, so `containerNumbers` may be omitted/empty.
+ */
+export class AddCustomerTruckDto {
+  @IsString()
+  @IsNotEmpty()
+  @MaxLength(32)
+  truckPlateNumber!: string;
+
+  @IsString()
+  @IsNotEmpty()
+  @MaxLength(120)
+  driverName!: string;
+
+  @IsString()
+  @IsNotEmpty()
+  @IsIn(CUSTOMER_TRUCK_TYPES)
+  truckType!: string;
+
+  @IsOptional()
+  @IsArray()
+  @ArrayMaxSize(2)
+  @ArrayUnique()
+  @Matches(/^[A-Z]{4}\d{7}$/, {
+    each: true,
+    message: 'each container number must match ISO container format, e.g. ABCD1234567',
+  })
+  containerNumbers?: string[];
+}
diff --git a/apps/edr-freight-api/src/modules/bookings/dto/depart-customer-truck.dto.ts b/apps/edr-freight-api/src/modules/bookings/dto/depart-customer-truck.dto.ts
new file mode 100644
index 000000000..31ab1b5bd
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/bookings/dto/depart-customer-truck.dto.ts
@@ -0,0 +1,37 @@
+import {
+  ArrayMaxSize,
+  ArrayUnique,
+  IsArray,
+  IsDateString,
+  IsNumber,
+  IsOptional,
+  Matches,
+  Min,
+} from 'class-validator';
+
+/**
+ * Register an import self-haul truck leaving the port: the containers it actually
+ * loaded (staff read them off the truck) and the weighed gross. Container numbers
+ * are optional here only because they may already have been recorded; the weighed
+ * gross is required.
+ */
+export class DepartCustomerTruckDto {
+  @IsOptional()
+  @IsArray()
+  @ArrayMaxSize(2)
+  @ArrayUnique()
+  @Matches(/^[A-Z]{4}\d{7}$/, {
+    each: true,
+    message: 'each container number must match ISO container format, e.g. ABCD1234567',
+  })
+  containerNumbers?: string[];
+
+  @IsNumber()
+  @Min(0)
+  grossWeightKg!: number;
+
+  /** Gate-out time. Defaults to now when omitted. */
+  @IsOptional()
+  @IsDateString()
+  gateOutTime?: string;
+}
diff --git a/apps/edr-freight-api/src/modules/bookings/dto/generate-grn.dto.ts b/apps/edr-freight-api/src/modules/bookings/dto/generate-grn.dto.ts
new file mode 100644
index 000000000..2f5ea86af
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/bookings/dto/generate-grn.dto.ts
@@ -0,0 +1,17 @@
+import { ArrayUnique, IsArray, IsOptional, Matches } from 'class-validator';
+
+/**
+ * Confirm a Goods Received Note. Omit `containerNumbers` to GRN every
+ * received-but-un-GRN'd container on the booking (per-booking when that's all of
+ * them); pass a subset to GRN just those.
+ */
+export class GenerateGrnDto {
+  @IsOptional()
+  @IsArray()
+  @ArrayUnique()
+  @Matches(/^[A-Z]{4}\d{7}$/, {
+    each: true,
+    message: 'each container number must match ISO container format, e.g. ABCD1234567',
+  })
+  containerNumbers?: string[];
+}
diff --git a/apps/edr-freight-api/src/modules/bookings/entities/booking-container-unit.entity.ts b/apps/edr-freight-api/src/modules/bookings/entities/booking-container-unit.entity.ts
index e8ef1b138..619013280 100644
--- a/apps/edr-freight-api/src/modules/bookings/entities/booking-container-unit.entity.ts
+++ b/apps/edr-freight-api/src/modules/bookings/entities/booking-container-unit.entity.ts
@@ -34,4 +34,17 @@ export class BookingContainerUnit extends BaseEntity {
 
   @Column({ name: 'sort_order', type: 'smallint', default: 0 })
   sortOrder!: number;
+
+  /** Whether this container has been received into the port (auto-set when its
+   *  self-haul truck arrives). */
+  @Column({ name: 'received_to_port', type: 'boolean', default: false })
+  receivedToPort!: boolean;
+
+  @Column({ name: 'received_at', type: 'timestamptz', nullable: true })
+  receivedAt?: Date | null;
+
+  /** The GRN this container was received under (assigned when staff confirm the
+   *  Goods Received Note for a batch of received containers). */
+  @Column({ name: 'grn_number', type: 'varchar', length: 100, nullable: true })
+  grnNumber?: string | null;
 }
diff --git a/apps/edr-freight-api/src/modules/bookings/entities/booking-container.entity.ts b/apps/edr-freight-api/src/modules/bookings/entities/booking-container.entity.ts
index db9746c09..182ff153d 100644
--- a/apps/edr-freight-api/src/modules/bookings/entities/booking-container.entity.ts
+++ b/apps/edr-freight-api/src/modules/bookings/entities/booking-container.entity.ts
@@ -1,8 +1,9 @@
 import { BaseEntity } from '@edr/api-common';
-import { Column, Entity, Index, JoinColumn, ManyToOne } from 'typeorm';
+import { Column, Entity, Index, JoinColumn, ManyToOne, OneToMany } from 'typeorm';
 import { ContainerType } from '../../rule-engine/entities/container-type.entity';
 import { WeightLimitRule } from '../../rule-engine/entities/weight-limit-rule.entity';
 import { Booking } from './booking.entity';
+import { BookingContainerUnit } from './booking-container-unit.entity';
 
 @Entity({ schema: 'freight', name: 'booking_container' })
 @Index(['bookingId'])
@@ -61,4 +62,8 @@ export class BookingContainer extends BaseEntity {
 
   @Column({ name: 'overweight_excess_tons', type: 'numeric', precision: 10, scale: 3, nullable: true })
   overweightExcessTons?: number | null;
+
+  /** The physical containers under this line — each with its own number + VGM. */
+  @OneToMany(() => BookingContainerUnit, (u) => u.bookingContainer)
+  units?: BookingContainerUnit[];
 }
diff --git a/apps/edr-freight-api/src/modules/bookings/entities/booking.entity.ts b/apps/edr-freight-api/src/modules/bookings/entities/booking.entity.ts
index 4b033bab5..cf0ca76f6 100644
--- a/apps/edr-freight-api/src/modules/bookings/entities/booking.entity.ts
+++ b/apps/edr-freight-api/src/modules/bookings/entities/booking.entity.ts
@@ -157,6 +157,10 @@ export class Booking extends BaseEntity {
   @Column({ name: 'contract_route_id', type: 'uuid', nullable: true })
   contractRouteId?: string | null;
 
+  /** Booking origin: ONE_TIME (single-shipment) or GENERAL_CONTRACT (drawdown). */
+  @Column({ name: 'booking_type', type: 'varchar', length: 20, default: 'ONE_TIME' })
+  bookingType!: string;
+
   /** Denormalized contract kind (ONE_TIME | GENERAL) for the single-active-booking index. */
   @Column({ name: 'contract_kind', type: 'varchar', length: 20, nullable: true })
   contractKind?: string | null;
diff --git a/apps/edr-freight-api/src/modules/bookings/entities/customer-truck-assignment.entity.ts b/apps/edr-freight-api/src/modules/bookings/entities/customer-truck-assignment.entity.ts
new file mode 100644
index 000000000..6eeaba963
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/bookings/entities/customer-truck-assignment.entity.ts
@@ -0,0 +1,47 @@
+import { BaseEntity } from '@edr/api-common';
+import { Column, Entity, Index, JoinColumn, ManyToOne, OneToMany } from 'typeorm';
+
+import { Booking } from './booking.entity';
+import { CustomerTruckContainer } from './customer-truck-container.entity';
+
+/**
+ * One external (self-haul) truck a customer assigns to a booking that has no
+ * EDR first/last-mile leg. Each truck carries 1–2 containers and tracks its own
+ * arrival at the terminal/warehouse.
+ */
+@Entity({ schema: 'freight', name: 'customer_truck_assignments' })
+@Index(['bookingId'])
+export class CustomerTruckAssignment extends BaseEntity {
+  @Column({ name: 'booking_id', type: 'uuid' })
+  bookingId!: string;
+
+  @ManyToOne(() => Booking, { onDelete: 'CASCADE' })
+  @JoinColumn({ name: 'booking_id' })
+  booking?: Booking;
+
+  @Column({ name: 'plate_number', type: 'varchar', length: 32 })
+  plateNumber!: string;
+
+  @Column({ name: 'driver_name', type: 'varchar', length: 120 })
+  driverName!: string;
+
+  @Column({ name: 'truck_type', type: 'varchar', length: 60 })
+  truckType!: string;
+
+  @Column({ name: 'assigned_at', type: 'timestamptz', default: () => 'now()' })
+  assignedAt!: Date;
+
+  @Column({ name: 'arrived_at', type: 'timestamptz', nullable: true })
+  arrivedAt?: Date | null;
+
+  /** Weighed gross of what the truck actually loaded (import), captured on
+   *  leaving. Null until the truck departs. */
+  @Column({ name: 'gross_weight_kg', type: 'numeric', precision: 14, scale: 2, nullable: true })
+  grossWeightKg?: number | null;
+
+  @Column({ name: 'departed_at', type: 'timestamptz', nullable: true })
+  departedAt?: Date | null;
+
+  @OneToMany(() => CustomerTruckContainer, (c) => c.assignment, { cascade: true })
+  containers?: CustomerTruckContainer[];
+}
diff --git a/apps/edr-freight-api/src/modules/bookings/entities/customer-truck-container.entity.ts b/apps/edr-freight-api/src/modules/bookings/entities/customer-truck-container.entity.ts
new file mode 100644
index 000000000..110e31671
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/bookings/entities/customer-truck-container.entity.ts
@@ -0,0 +1,26 @@
+import { BaseEntity } from '@edr/api-common';
+import { Column, Entity, Index, JoinColumn, ManyToOne } from 'typeorm';
+
+import { CustomerTruckAssignment } from './customer-truck-assignment.entity';
+
+/**
+ * A container number loaded onto a customer truck. A container may be loaded
+ * onto exactly one truck per booking (enforced by a partial unique index on
+ * booking_id + container_number).
+ */
+@Entity({ schema: 'freight', name: 'customer_truck_containers' })
+@Index(['assignmentId'])
+export class CustomerTruckContainer extends BaseEntity {
+  @Column({ name: 'assignment_id', type: 'uuid' })
+  assignmentId!: string;
+
+  @ManyToOne(() => CustomerTruckAssignment, (a) => a.containers, { onDelete: 'CASCADE' })
+  @JoinColumn({ name: 'assignment_id' })
+  assignment?: CustomerTruckAssignment;
+
+  @Column({ name: 'booking_id', type: 'uuid' })
+  bookingId!: string;
+
+  @Column({ name: 'container_number', type: 'varchar', length: 64 })
+  containerNumber!: string;
+}
diff --git a/apps/edr-freight-api/src/modules/companies/companies.controller.ts b/apps/edr-freight-api/src/modules/companies/companies.controller.ts
index 4bcc3252a..b1761b35f 100644
--- a/apps/edr-freight-api/src/modules/companies/companies.controller.ts
+++ b/apps/edr-freight-api/src/modules/companies/companies.controller.ts
@@ -334,15 +334,19 @@ export class CompaniesController {
     @Param("companyId", ParseUUIDPipe) companyId: string,
   ) {
     const files = await this.filesService.findByResource(companyId, "companies");
-    return files.map((f) => ({
-      id: f.id,
-      name: f.name,
-      code: f.code,
-      mimeType: f.mimeType,
-      size: f.size,
-      uploadedAt: f.createdAt,
-      url: f.url,
-    }));
+    return Promise.all(
+      files.map(async (f) => ({
+        id: f.id,
+        name: f.name,
+        code: f.code,
+        mimeType: f.mimeType,
+        size: f.size,
+        uploadedAt: f.createdAt,
+        // Raw `f.url` is an un-signed MinIO path the browser can't open — sign
+        // it so the file previews/downloads in the client.
+        url: f.url ? await this.filesService.signUrl(f.url) : f.url,
+      })),
+    );
   }
 
   @Post(":companyId/documents")
diff --git a/apps/edr-freight-api/src/modules/companies/companies.service.ts b/apps/edr-freight-api/src/modules/companies/companies.service.ts
index 02f77b2e0..62be578bb 100644
--- a/apps/edr-freight-api/src/modules/companies/companies.service.ts
+++ b/apps/edr-freight-api/src/modules/companies/companies.service.ts
@@ -1183,9 +1183,11 @@ export class CompaniesService {
     const { businessInfo } = await this.etradeService.resolveCompanyData(tin);
     if (!businessInfo) {
       throw new BadRequestException(
-        "No business license found for this TIN. Please check the number and try again.",
+        "We couldn't find a business license for this TIN with eTrade. Please double-check the number and try again.",
       );
     }
-    return this.etradeService.extractRegistrationData(businessInfo);
+    const registrationData = this.etradeService.extractRegistrationData(businessInfo);
+    const tinTaken = await this.companiesRepo.existsByTin(tin);
+    return { ...registrationData, tinTaken };
   }
 }
diff --git a/apps/edr-freight-api/src/modules/companies/dto/create-company.dto.ts b/apps/edr-freight-api/src/modules/companies/dto/create-company.dto.ts
index e5b686d11..a56ea5ad8 100644
--- a/apps/edr-freight-api/src/modules/companies/dto/create-company.dto.ts
+++ b/apps/edr-freight-api/src/modules/companies/dto/create-company.dto.ts
@@ -1,4 +1,4 @@
-import { IsString, IsNotEmpty, IsOptional, IsEnum, MaxLength, Length, Matches, IsEmail } from 'class-validator';
+import { IsString, IsNotEmpty, IsOptional, IsEnum, MaxLength, Length, IsEmail } from 'class-validator';
 import { CompanyType, CompanyStatus } from '../entities/company.entity';
 import { IsValidPhone } from '../../../common/validators/is-phone-number.validator';
 
@@ -17,10 +17,7 @@ export class CreateCompanyDto {
 
   @IsString()
   @IsNotEmpty()
-  @Length(10, 10)
-  @Matches(/^00\d{8}$/, {
-    message: 'TIN must be 10 digits starting with 00',
-  })
+  @Length(10, 10, { message: 'TIN must be exactly 10 digits' })
   tin!: string;
 
   @IsOptional()
diff --git a/apps/edr-freight-api/src/modules/companies/dto/etrade-response.dto.ts b/apps/edr-freight-api/src/modules/companies/dto/etrade-response.dto.ts
index 200b69fee..ef7eb2a21 100644
--- a/apps/edr-freight-api/src/modules/companies/dto/etrade-response.dto.ts
+++ b/apps/edr-freight-api/src/modules/companies/dto/etrade-response.dto.ts
@@ -17,6 +17,7 @@ export class ETradeResponseDto implements CompanyRegistrationData {
   managerName!: string;
   managerEmail?: string;
   managerPhone!: string;
+  tinTaken?: boolean;
 
   constructor(data: CompanyRegistrationData) {
     this.licenceNumber = data.licenceNumber;
@@ -35,5 +36,6 @@ export class ETradeResponseDto implements CompanyRegistrationData {
     this.managerName = data.managerName;
     this.managerEmail = data.managerEmail;
     this.managerPhone = data.managerPhone;
+    this.tinTaken = data.tinTaken;
   }
 }
diff --git a/apps/edr-freight-api/src/modules/companies/dto/update-profile.dto.ts b/apps/edr-freight-api/src/modules/companies/dto/update-profile.dto.ts
index 316038dc9..9fd8f28ae 100644
--- a/apps/edr-freight-api/src/modules/companies/dto/update-profile.dto.ts
+++ b/apps/edr-freight-api/src/modules/companies/dto/update-profile.dto.ts
@@ -1,4 +1,4 @@
-import { IsString, IsOptional, IsEmail, MaxLength, Length, Matches, IsEnum } from 'class-validator';
+import { IsString, IsOptional, IsEmail, MaxLength, Length, IsEnum } from 'class-validator';
 import { CompanyNationality } from '../entities/company.entity';
 import { IsValidPhone } from '../../../common/validators/is-phone-number.validator';
 
@@ -34,10 +34,7 @@ export class UpdateProfileDto {
 
   @IsOptional()
   @IsString()
-  @Length(10, 10)
-  @Matches(/^00\d{8}$/, {
-    message: 'TIN must be 10 digits starting with 00',
-  })
+  @Length(10, 10, { message: 'TIN must be exactly 10 digits' })
   tin?: string;
 
   @IsOptional()
diff --git a/apps/edr-freight-api/src/modules/contracts/booking-clearance.service.ts b/apps/edr-freight-api/src/modules/contracts/booking-clearance.service.ts
index 3f169c49c..61ac93925 100644
--- a/apps/edr-freight-api/src/modules/contracts/booking-clearance.service.ts
+++ b/apps/edr-freight-api/src/modules/contracts/booking-clearance.service.ts
@@ -205,7 +205,7 @@ export class BookingClearanceService {
     const finalInvoice = await this.glOperationsService.finalInvoiceSummary(bookingId);
     const bookingMilestone = (code: string) =>
       milestones.find((m) => m.milestoneCode === code);
-    const gatepassMilestone = bookingMilestone('GATEPASS_GRANTED');
+    const gatepass = await this.glOperationsService.gatepassForBooking(bookingId);
     const t1ClosedMilestone = bookingMilestone('T1_CLOSED');
     const riskMilestone = bookingMilestone('RISK_ASSIGNED');
     const secondDuty = this.glOperationsService.secondDutyState(milestones, files);
@@ -242,14 +242,8 @@ export class BookingClearanceService {
       workflowFiles,
       t1,
       train,
-      gatepassGranted: gatepassMilestone?.status === 'COMPLETED',
-      gatepassAt:
-        gatepassMilestone?.status === 'COMPLETED'
-          ? (gatepassMilestone.metadata?.gatepassAt ??
-            (gatepassMilestone.triggeredAt
-              ? gatepassMilestone.triggeredAt.toISOString()
-              : null))
-          : null,
+      gatepassGranted: gatepass.granted,
+      gatepassAt: gatepass.grantedAt,
       t1Closed: t1ClosedMilestone?.status === 'COMPLETED',
       t1ClosedAt:
         t1ClosedMilestone?.status === 'COMPLETED' && t1ClosedMilestone.triggeredAt
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 ef36ea5eb..125cf5f3d 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
@@ -1,9 +1,11 @@
 import {
   BadRequestException,
   ForbiddenException,
+  Inject,
   Injectable,
   Logger,
   NotFoundException,
+  forwardRef,
 } from '@nestjs/common';
 import { DataSource } from 'typeorm';
 
@@ -12,9 +14,11 @@ import { BookingContainer } from '../bookings/entities/booking-container.entity'
 import { BookingContainerUnit } from '../bookings/entities/booking-container-unit.entity';
 import { BookingsRepository } from '../bookings/bookings.repository';
 import { BookingPricingService } from '../bookings/booking-pricing.service';
+import { PriceLineItemDto } from '../bookings/dto/generate-price-response.dto';
 import { BookingInvoiceService } from '../bookings/booking-invoice.service';
 import { validate20ftWeightPairing } from '../bookings/container-pairing.util';
 import { TrainSchedulingGlobalRules } from '../train-scheduling/entities/train-scheduling-global-rules.entity';
+import { TrainSchedulingService } from '../train-scheduling/train-scheduling.service';
 import { ContainerTypesService } from '../rule-engine/services/container-types.service';
 import { RuleEngineService } from '../rule-engine/rule-engine.service';
 import { ContainerType } from '../rule-engine/entities/container-type.entity';
@@ -62,6 +66,8 @@ export class ContractBookingService {
     private readonly workflowService: ClearanceWorkflowService,
     private readonly invoiceService: BookingInvoiceService,
     private readonly dataSource: DataSource,
+    @Inject(forwardRef(() => TrainSchedulingService))
+    private readonly trainSchedulingService: TrainSchedulingService,
   ) {}
 
   async createUnderContract(
@@ -113,6 +119,32 @@ export class ContractBookingService {
     const generalCustoms =
       contract.contractKind === 'GENERAL' && Boolean(contract.customsClearingEnabled);
 
+    // Booking-window gate (config-driven): an operations booking may only be
+    // created while the route's booking window is open — import: the day's window
+    // (windowOpenHour EAT, importWindowLeadDays before departure, windowDurationHours);
+    // export: within exportBookingLeadHours of departure. Customs Path B bookings
+    // enter clearance first and are scheduled later, so they are not gated here.
+    if (!generalCustoms) {
+      await this.trainSchedulingService.assertBookingWindowOpen({
+        originYardId: route?.originYardId ?? null,
+        destinationYardId: route?.destinationYardId ?? null,
+        scheduledDate: dto.scheduledDate ?? null,
+        direction: contract.tradeDirection ?? null,
+      });
+    }
+
+    // Hard capacity gate: a container line whose total weight exceeds the
+    // container type's max capacity can never be booked — no surcharge path,
+    // no override. Checked before any row is written.
+    if (freightType === 'CONTAINER') {
+      await this.assertWithinMaxCapacity(contract, dto);
+      // 20ft weight-pairing gate at CREATION: two 20ft on a wagon must differ
+      // ≤ the cap, and drawdown bookings never pass through submit — so this is
+      // their only chance to hard-block an unbalanceable set. Entry order is
+      // irrelevant (the check sorts by weight before pairing).
+      await this.assert20ftPairableAtCreate(dto);
+    }
+
     // Denormalize route/direction/freight onto the booking for the scheduling engine.
     const booking = await this.bookingsRepository.create({
       reference,
@@ -566,11 +598,14 @@ export class ContractBookingService {
   }
 
   /**
-   * Pre-create validation for the shipment form: run the overweight rule + the
-   * 20ft weight-pairing rule against the entered containers WITHOUT persisting a
-   * booking. The portal calls this from the price-confirm modal so the customer
-   * sees the overweight warning (+ surcharge basis) and is blocked on an
-   * un-pairable 20ft set before the booking is created.
+   * Pre-create validation + authoritative price preview for the shipment form:
+   * build an UNSAVED booking shaped exactly like {@link createUnderContract}
+   * would persist it and run the same BookingPricingService compute over it —
+   * base rail freight, first/last-mile trucking, and every rule-engine surcharge
+   * (overweight, hazard, reefer, consolidation, …). The portal and the GL
+   * backoffice form call this from the price-confirm modal, so the breakdown the
+   * user confirms is line-for-line what the booking will be charged. Also runs
+   * the 20ft weight-pairing rule, which hard-blocks creation.
    */
   async validateShipment(
     contractId: string,
@@ -582,16 +617,31 @@ export class ContractBookingService {
       maxAllowedTons: number;
       excessTons: number;
     }>;
+    overweightSurchargeAmount: number;
+    currency: string | null;
     pairingErrors: string[];
+    capacityErrors: string[];
+    lineItems: PriceLineItemDto[];
+    totalAmount: number;
   }> {
     const contract = await this.contractsRepository.findByIdWithRelations(contractId);
     if (!contract) throw new NotFoundException(`Contract ${contractId} not found`);
 
     const lines = dto.containers ?? [];
-    if (!lines.length) return { overweightLines: [], pairingErrors: [] };
+    if (contract.freightType === 'CONTAINER' && !lines.length) {
+      return {
+        overweightLines: [],
+        overweightSurchargeAmount: 0,
+        currency: null,
+        pairingErrors: [],
+        capacityErrors: [],
+        lineItems: [],
+        totalAmount: 0,
+      };
+    }
 
-    // Resolve each line's container type + total VGM (sum of unit weights) so the
-    // rule engine can flag overweight per line (maxVgmTons × quantity vs total).
+    // Resolve each container line's type + total VGM (sum of unit weights) —
+    // mirrors persistContainers so the preview lines match the persisted ones.
     const resolved = await Promise.all(
       lines.map(async (line) => {
         const ct = await this.resolveContainerTypeForSize(
@@ -606,46 +656,44 @@ export class ContractBookingService {
       }),
     );
 
-    const ruleResult = await this.ruleEngineService.evaluate({
-      freightType: 'CONTAINER',
-      cargoTypeId: null,
-      serviceTypeId: contract.serviceTypeId,
-      paymentCurrency: contract.paymentCurrency,
+    // The unsaved twin of the booking createUnderContract would write: same
+    // denormalized contract fields, same container-line math. No id → the
+    // pricing service derives wagon counts from the in-memory lines.
+    const route = await this.resolveRoute(contract, dto.contractRouteId);
+    const previewBooking = Object.assign(new Booking(), {
+      freightType: contract.freightType,
       tradeDirection: contract.tradeDirection,
-      isHazardous: false,
-      isReefer: contract.isReefer ?? false,
-      isGovernment: false,
-      allowConsolidation: false,
+      paymentCurrency: contract.paymentCurrency,
+      serviceTypeId: contract.serviceTypeId,
+      cargoTypeId: this.resolveCargoTypeId(contract, dto),
+      isHazardous: contract.isHazardous,
+      isReefer: contract.isReefer,
+      isGovernment: contract.isGovernment,
       shippingLineId: null,
-      totalWagons: 0,
-      bulkTons: 0,
-      containers: resolved.map((r) => ({
-        containerTypeId: r.ct.id,
-        quantity: r.line.quantity,
-        vgmPerUnitTons: r.line.quantity ? r.totalVgmTons / r.line.quantity : 0,
-        totalVgmTons: r.totalVgmTons,
-        isReefer: r.ct.isReefer,
-      })),
-    } as never);
+      contractRouteId: route?.id ?? null,
+      cargoTotalWeightVgm: this.resolveBulkTons(dto),
+      firstMilePickupAddress: contract.firstMilePickupAddress ?? null,
+      lastMileDeliveryAddress: contract.lastMileDeliveryAddress ?? null,
+      bookingContainers: resolved.map(({ line, ct, totalVgmTons }) =>
+        Object.assign(new BookingContainer(), {
+          containerTypeId: ct.id,
+          containerSize: line.containerSize,
+          quantity: line.quantity,
+          hazardousQuantity: line.hazardousQuantity ?? 0,
+          reeferQuantity: line.reeferQuantity ?? 0,
+          vgmPerUnitTons: line.units.length ? totalVgmTons / line.units.length : 0,
+          totalVgmTons,
+          wagonsRequired: Math.ceil(line.quantity * Number(ct.wagonsPerUnit ?? 1)),
+        }),
+      ),
+    }) as Booking;
 
-    const overweightLines: Array<{
-      containerTypeCode: string;
-      totalVgmTons: number;
-      maxAllowedTons: number;
-      excessTons: number;
-    }> = [];
-    for (let i = 0; i < ruleResult.containerWeightResults.length; i++) {
-      const wr = ruleResult.containerWeightResults[i];
-      if (!wr?.isOverweight) continue;
-      const r = resolved[i];
-      const excessTons = Number(wr.overweightExcessTons ?? 0);
-      overweightLines.push({
-        containerTypeCode: r?.ct.code ?? r?.line.containerSize ?? '',
-        totalVgmTons: r?.totalVgmTons ?? 0,
-        maxAllowedTons: Math.max(0, (r?.totalVgmTons ?? 0) - excessTons),
-        excessTons,
-      });
-    }
+    const computed = await this.bookingPricingService.computePriceForBooking(previewBooking);
+
+    // The overweight surcharge line is already currency-converted; surface its
+    // amount separately so the warning alert can reference the exact charge.
+    const overweightSurchargeAmount =
+      computed.lineItems.find((li) => li.code === 'OVERWEIGHT_PER_TON')?.amount ?? 0;
 
     // 20ft weight-pairing: gather every 20ft unit weight and check the pair rule.
     const twentyFtUnits = resolved
@@ -661,7 +709,90 @@ export class ContractBookingService {
       (v) => v.message,
     );
 
-    return { overweightLines, pairingErrors };
+    // Hard capacity ceiling — a non-empty result means the create call will be
+    // rejected, so the form can block submit up front.
+    const capacityErrors = await this.ruleEngineService.capacityViolations(
+      resolved.map(({ line, ct, totalVgmTons }) => ({
+        containerTypeId: ct.id,
+        quantity: line.quantity,
+        totalVgmTons,
+      })),
+      contract.tradeDirection,
+    );
+
+    return {
+      overweightLines: computed.overweightLines,
+      overweightSurchargeAmount,
+      currency: computed.currency,
+      pairingErrors,
+      capacityErrors,
+      lineItems: computed.lineItems,
+      totalAmount: computed.totalAmount,
+    };
+  }
+
+  /**
+   * Throws when any container line's total weight exceeds the hard capacity
+   * ceiling of its weight limit rule. Mirrors validateShipment's line
+   * resolution so the gate matches what the form preview reported.
+   */
+  private async assertWithinMaxCapacity(
+    contract: Contract,
+    dto: CreateBookingUnderContractDto,
+  ): Promise<void> {
+    const lines = dto.containers ?? [];
+    if (!lines.length) return;
+
+    const containers = await Promise.all(
+      lines.map(async (line) => {
+        const ct = await this.resolveContainerTypeForSize(
+          line.containerSize,
+          contract.isReefer || (line.reeferQuantity ?? 0) > 0,
+        );
+        const totalVgmTons = (line.units ?? []).reduce(
+          (s, u) => s + Number(u.vgmTons ?? 0),
+          0,
+        );
+        return { containerTypeId: ct.id, quantity: line.quantity, totalVgmTons };
+      }),
+    );
+
+    const violations = await this.ruleEngineService.capacityViolations(
+      containers,
+      contract.tradeDirection,
+    );
+    if (violations.length) {
+      throw new BadRequestException(violations.join('; '));
+    }
+  }
+
+  /**
+   * Hard-block booking creation when the 20ft container weights cannot be
+   * balanced onto wagons (pair diff over the global cap). Same rule the
+   * shipment-form preview reports as `pairingErrors`, enforced server-side.
+   */
+  private async assert20ftPairableAtCreate(
+    dto: CreateBookingUnderContractDto,
+  ): Promise<void> {
+    const twentyFtUnits = (dto.containers ?? [])
+      .filter((line) => (line.containerSize ?? '').includes('20'))
+      .flatMap((line, lineIdx) =>
+        (line.units ?? []).map((u, idx) => ({
+          label: u.containerNumber || `20ft-${lineIdx + 1}.${idx + 1}`,
+          grossWeightTons: Number(u.vgmTons ?? 0),
+        })),
+      );
+    if (twentyFtUnits.length < 2) return;
+
+    const maxDiff = await this.max20ftPairDiffTons();
+    const violations = validate20ftWeightPairing(twentyFtUnits, maxDiff);
+    if (violations.length) {
+      throw new BadRequestException(
+        `Cannot create booking — 20ft containers cannot be paired on wagons: ${violations
+          .map((v) => v.message)
+          .join(' ')}`,
+      );
+    }
   }
 
   private async max20ftPairDiffTons(): Promise<number> {
diff --git a/apps/edr-freight-api/src/modules/contracts/contract-clearance.service.ts b/apps/edr-freight-api/src/modules/contracts/contract-clearance.service.ts
index 73a4fe117..2c79ba42f 100644
--- a/apps/edr-freight-api/src/modules/contracts/contract-clearance.service.ts
+++ b/apps/edr-freight-api/src/modules/contracts/contract-clearance.service.ts
@@ -77,6 +77,9 @@ export interface ContractClearanceView {
   /** Export post-booking clearance finalized (transit permit uploaded + GL confirmed). */
   exportClearanceFinalized?: boolean;
   linkedBookingId?: string | null;
+  /** Reference + status of the GL-created shipment booking, once it exists. */
+  linkedBookingReference?: string | null;
+  linkedBookingStatus?: string | null;
   dutyAdvice?: {
     amount: number;
     currency: string;
@@ -275,7 +278,9 @@ export class ContractClearanceService {
     }
     const bookingMilestone = (code: string) =>
       bookingMilestones.find((m) => m.milestoneCode === code);
-    const gatepassMilestone = bookingMilestone('GATEPASS_GRANTED');
+    const gatepass = cycle?.bookingId
+      ? await this.glOperationsService.gatepassForBooking(cycle.bookingId)
+      : { granted: false, grantedAt: null };
     const t1ClosedMilestone = bookingMilestone('T1_CLOSED');
     const riskMilestone = bookingMilestone('RISK_ASSIGNED');
     const secondDuty = this.glOperationsService.secondDutyState(
@@ -284,13 +289,22 @@ export class ContractClearanceService {
     );
 
     let nextAction = this.workflowService.computeNextAction(contract, cycle, milestones);
-    if (cycle?.bookingId && contract.tradeDirection === 'EXPORT') {
+    // Once GL creates the shipment booking, surface its reference + status so the
+    // customer sees the concrete booking instead of a stale "will be created
+    // shortly" message. Reuse the export booking load; fetch for import too.
+    let linkedBookingReference: string | null = null;
+    let linkedBookingStatus: string | null = null;
+    if (cycle?.bookingId) {
       const booking = await this.bookingsService.findById(cycle.bookingId);
       if (booking) {
-        nextAction = this.workflowService.computeNextActionForBooking(
-          booking,
-          bookingMilestones,
-        );
+        linkedBookingReference = booking.reference ?? null;
+        linkedBookingStatus = booking.status ?? null;
+        if (contract.tradeDirection === 'EXPORT') {
+          nextAction = this.workflowService.computeNextActionForBooking(
+            booking,
+            bookingMilestones,
+          );
+        }
       }
     }
 
@@ -326,18 +340,14 @@ export class ContractClearanceService {
       preClearanceFinalized: Boolean(cycle?.preClearanceFinalizedAt),
       exportClearanceFinalized: Boolean(cycle?.completedAt),
       linkedBookingId: cycle?.bookingId ?? null,
+      linkedBookingReference,
+      linkedBookingStatus,
       dutyAdvice,
       workflowFiles,
       t1,
       train,
-      gatepassGranted: gatepassMilestone?.status === 'COMPLETED',
-      gatepassAt:
-        gatepassMilestone?.status === 'COMPLETED'
-          ? (gatepassMilestone.metadata?.gatepassAt ??
-            (gatepassMilestone.triggeredAt
-              ? gatepassMilestone.triggeredAt.toISOString()
-              : null))
-          : null,
+      gatepassGranted: gatepass.granted,
+      gatepassAt: gatepass.grantedAt,
       t1Closed: t1ClosedMilestone?.status === 'COMPLETED',
       t1ClosedAt:
         t1ClosedMilestone?.status === 'COMPLETED' && t1ClosedMilestone.triggeredAt
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 09e4a7ffd..a22c7cad4 100644
--- a/apps/edr-freight-api/src/modules/contracts/contracts.controller.ts
+++ b/apps/edr-freight-api/src/modules/contracts/contracts.controller.ts
@@ -77,7 +77,6 @@ import {
 } from './dto/gl-operations.dto';
 import {
   AdviseContractDutyDto,
-  GatepassDto,
   RoAmendmentDto,
 } from './dto/phased-clearance.dto';
 
@@ -688,30 +687,6 @@ export class ContractsController {
     return this.clearanceService.djQueue(filter);
   }
 
-  @Get('clearance/dj-schedules')
-  @BookingStaff(FREIGHT_PERMS.contracts.clearanceDjActions)
-  @ApiOperation({ summary: 'Train schedules carrying customs bookings — GL DJ gate-pass table' })
-  djClearanceSchedules() {
-    return this.glOperationsService.djSchedules();
-  }
-
-  @Post('clearance/schedules/:scheduleId/gatepass')
-  @BookingStaff(FREIGHT_PERMS.contracts.clearanceDjActions)
-  @ApiOperation({
-    summary: 'GL DJ grants the gate pass for every customs booking on a train schedule',
-  })
-  grantScheduleGatepass(
-    @Param('scheduleId', ParseUUIDPipe) scheduleId: string,
-    @Body() dto: GatepassDto,
-    @CurrentUser() user: AuthUserPayload,
-  ) {
-    return this.glOperationsService.grantScheduleGatepass(
-      scheduleId,
-      dto?.gatepassAt,
-      resolveAuthUserId(user),
-    );
-  }
-
   // ── Path A self-clearance — Operations reviews the customer's own docs ───────
 
   @Get('clearance/ops-queue')
@@ -791,7 +766,7 @@ export class ContractsController {
   @Post(':id/validate-shipment')
   @ApiOperation({
     summary:
-      'Pre-create validation: overweight lines + 20ft weight-pairing errors for a shipment payload (no booking created).',
+      'Pre-create validation + authoritative price preview: full booking price breakdown (rail, first/last mile, surcharges), overweight lines and 20ft weight-pairing errors for a shipment payload (no booking created).',
   })
   validateShipment(
     @Param('id', ParseUUIDPipe) id: string,
@@ -947,21 +922,6 @@ export class ContractsController {
     return this.glOperationsService.closeT1(bookingId, resolveAuthUserId(user));
   }
 
-  @Post('bookings/:bookingId/gatepass')
-  @BookingStaff(FREIGHT_PERMS.contracts.clearanceDjActions)
-  @ApiOperation({ summary: 'GL DJ grants the gate pass for a customs booking (captures time)' })
-  grantGatepass(
-    @Param('bookingId', ParseUUIDPipe) bookingId: string,
-    @Body() dto: GatepassDto,
-    @CurrentUser() user: AuthUserPayload,
-  ) {
-    return this.glOperationsService.grantGatepass(
-      bookingId,
-      dto?.gatepassAt,
-      resolveAuthUserId(user),
-    );
-  }
-
   @Post('bookings/:bookingId/final-invoice')
   @BookingStaff(FREIGHT_PERMS.contracts.clearanceDjActions)
   @UseInterceptors(FileInterceptor('file'))
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 5bf6ddb4f..a9f9dcf5d 100644
--- a/apps/edr-freight-api/src/modules/contracts/contracts.module.ts
+++ b/apps/edr-freight-api/src/modules/contracts/contracts.module.ts
@@ -13,6 +13,7 @@ import { DropdownSettingsModule } from '../dropdown-settings/dropdown-settings.m
 import { SignaturesModule } from '../signatures/signatures.module';
 import { OtpModule } from '../otp/otp.module';
 import { BookingsModule } from '../bookings/bookings.module';
+import { TrainSchedulingModule } from '../train-scheduling/train-scheduling.module';
 
 import { ContractsController } from './contracts.controller';
 import { ContractsService } from './contracts.service';
@@ -78,6 +79,10 @@ import { ContractDocumentViewModelBuilder } from '../../contracts/contract-docum
     // BookingsModule provides BookingsRepository/BookingPricingService used by the
     // contract PDF builders (they read a Booking today — see docs/new-doc.md §3.3).
     forwardRef(() => BookingsModule),
+    // TrainSchedulingModule provides the config-driven booking-window gate used
+    // by ContractBookingService.createUnderContract. forwardRef because
+    // TrainSchedulingModule already imports ContractsModule.
+    forwardRef(() => TrainSchedulingModule),
     ExchangeModule.forRootAsync({
       inject: [ConfigService],
       useFactory: (config: ConfigService): ExchangeOptions =>
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 9e464db51..34a958fd2 100644
--- a/apps/edr-freight-api/src/modules/contracts/contracts.repository.ts
+++ b/apps/edr-freight-api/src/modules/contracts/contracts.repository.ts
@@ -135,6 +135,7 @@ export class ContractsRepository extends BaseRepository<Contract> {
     // Attach the generated contract PDF to each row so list/home can offer a
     // direct download. Loaded separately to keep pagination counts correct.
     await this.attachContractFiles(items);
+    await this.attachClearancePhases(items);
 
     const totalPages = pageSize > 0 ? Math.ceil(total / pageSize) : 0;
     return {
@@ -173,6 +174,30 @@ export class ContractsRepository extends BaseRepository<Contract> {
     }
   }
 
+  /**
+   * Attach each contract's persisted clearance phase (latest cycle's
+   * current_phase) so list consumers can show step-accurate customer actions
+   * ("Pay duty & upload slip" vs generic "Update clearance") without a
+   * per-contract clearance-view request. One query per page, like
+   * `attachContractFiles`.
+   */
+  private async attachClearancePhases(contracts: Contract[]): Promise<void> {
+    if (contracts.length === 0) return;
+    const ids = contracts.map((c) => c.id);
+    const rows: Array<{ contract_id: string; current_phase: string | null }> =
+      await this.dataSource.query(
+        `SELECT DISTINCT ON (contract_id) contract_id, current_phase
+           FROM freight.contract_clearance_cycles
+          WHERE contract_id = ANY($1)
+          ORDER BY contract_id, cycle_number DESC`,
+        [ids],
+      );
+    const byContract = new Map(rows.map((r) => [r.contract_id, r.current_phase]));
+    for (const contract of contracts) {
+      contract.clearancePhase = byContract.get(contract.id) ?? null;
+    }
+  }
+
   async getStatusCounts(): Promise<Record<string, number>> {
     const rows = await this.repository
       .createQueryBuilder('contract')
diff --git a/apps/edr-freight-api/src/modules/contracts/dto/phased-clearance.dto.ts b/apps/edr-freight-api/src/modules/contracts/dto/phased-clearance.dto.ts
index 6b784073b..34a903427 100644
--- a/apps/edr-freight-api/src/modules/contracts/dto/phased-clearance.dto.ts
+++ b/apps/edr-freight-api/src/modules/contracts/dto/phased-clearance.dto.ts
@@ -36,11 +36,3 @@ export class RoAmendmentDto {
   note?: string;
 }
 
-export class GatepassDto {
-  @ApiPropertyOptional({
-    description: 'When the gate pass was granted (ISO datetime; defaults to now)',
-  })
-  @IsOptional()
-  @IsString()
-  gatepassAt?: string;
-}
diff --git a/apps/edr-freight-api/src/modules/contracts/entities/contract.entity.ts b/apps/edr-freight-api/src/modules/contracts/entities/contract.entity.ts
index 0461d3736..07d08d3c0 100644
--- a/apps/edr-freight-api/src/modules/contracts/entities/contract.entity.ts
+++ b/apps/edr-freight-api/src/modules/contracts/entities/contract.entity.ts
@@ -254,4 +254,10 @@ export class Contract extends BaseEntity {
     createForeignKeyConstraints: false,
   })
   files?: FileRecord[];
+
+  /**
+   * Latest clearance cycle's current_phase, attached by
+   * ContractsRepository.attachClearancePhases for list responses. Not a column.
+   */
+  clearancePhase?: string | null;
 }
diff --git a/apps/edr-freight-api/src/modules/contracts/gl-operations.service.ts b/apps/edr-freight-api/src/modules/contracts/gl-operations.service.ts
index 8fed3a8ff..e639f0867 100644
--- a/apps/edr-freight-api/src/modules/contracts/gl-operations.service.ts
+++ b/apps/edr-freight-api/src/modules/contracts/gl-operations.service.ts
@@ -4,7 +4,7 @@ import {
   Injectable,
   NotFoundException,
 } from '@nestjs/common';
-import { DataSource, In, IsNull } from 'typeorm';
+import { DataSource, IsNull } from 'typeorm';
 import { Freight, GL_FINAL_INVOICE_TYPE, isT1TransportFileCode } from '@edr/types';
 
 import { BillingService } from '../billing/billing.service';
@@ -17,7 +17,6 @@ import {
   ClearanceIncident,
   IncidentType,
 } from './entities/clearance-incident.entity';
-import { ClearanceMilestone } from './entities/clearance-milestone.entity';
 import { ContractClearanceCycle } from './entities/contract-clearance-cycle.entity';
 import { ClearanceMilestoneService } from './clearance-milestone.service';
 import {
@@ -198,6 +197,7 @@ export class GlOperationsService {
     }
 
     return {
+      scheduleId: schedule?.id ?? null,
       wagonAllocated,
       departedAt: schedule?.actualDepartureAt
         ? new Date(schedule.actualDepartureAt).toISOString()
@@ -208,6 +208,41 @@ export class GlOperationsService {
     };
   }
 
+  /**
+   * Gate pass status for a booking, sourced from the train schedule's Djibouti
+   * gate-pass operation (secured via the train-scheduling "Save as Secured"
+   * action) rather than a clearance milestone. For EXPORT bookings this also
+   * backfills the arrival-chain milestones once secured, same as the retired
+   * clearance-side grant action used to.
+   */
+  async gatepassForBooking(
+    bookingId: string,
+  ): Promise<{ granted: boolean; grantedAt: string | null }> {
+    const train = await this.trainState(bookingId);
+    if (!train.scheduleId) return { granted: false, grantedAt: null };
+    const operation = await this.dataSource
+      .getRepository(ImportDjiboutiOperation)
+      .findOne({ where: { trainScheduleId: train.scheduleId } });
+    const grantedAt = operation?.gatepassGrantedAt
+      ? new Date(operation.gatepassGrantedAt).toISOString()
+      : null;
+
+    if (grantedAt) {
+      const booking = await this.getBooking(bookingId);
+      if ((booking.tradeDirection ?? 'IMPORT') === 'EXPORT') {
+        const milestones = await this.milestoneService.listForBooking(bookingId);
+        const byCode = new Map(milestones.map((m) => [m.milestoneCode, m]));
+        for (const code of GlOperationsService.EXPORT_ARRIVAL_CHAIN) {
+          if (byCode.get(code)?.status === 'PENDING') {
+            await this.milestoneService.completeForBooking(bookingId, code);
+          }
+        }
+      }
+    }
+
+    return { granted: Boolean(grantedAt), grantedAt };
+  }
+
   /**
    * T1 transit-document lifecycle state for an import shipment booking. Wagon
    * allocation opens the upload window; train departure locks it; train arrival
@@ -302,8 +337,11 @@ export class GlOperationsService {
           'The transport document must be uploaded before T1 can be closed.',
         );
       }
-      if (!done('GATEPASS_GRANTED')) {
-        throw new BadRequestException('Grant the gate pass before closing T1.');
+      const gatepass = await this.gatepassForBooking(bookingId);
+      if (!gatepass.granted) {
+        throw new BadRequestException(
+          'Secure the Djibouti gate pass on the train schedule before closing T1.',
+        );
       }
       // Export bookings seeded before T1_CLOSED joined the catalog lack the row.
       await this.milestoneService.ensureForBooking(bookingId, 'T1_CLOSED', tradeDirection);
@@ -322,182 +360,6 @@ export class GlOperationsService {
     'ARRIVED_AT_DJIBOUTI',
   ];
 
-  /**
-   * GL Djibouti grants the gate pass for a customs booking, capturing the time.
-   * Export: requires the train to have arrived at Djibouti; back-fills the
-   * arrival-chain milestones. Import: requires wagon allocation (pre-loading).
-   */
-  async grantGatepass(
-    bookingId: string,
-    gatepassAt?: string,
-    userId?: string,
-  ): Promise<{ bookingId: string; gatepassAt: string }> {
-    const booking = await this.getBooking(bookingId);
-    if (!booking.customsClearingEnabled) {
-      throw new BadRequestException('Gate pass applies to customs bookings only.');
-    }
-    const tradeDirection = booking.tradeDirection ?? 'IMPORT';
-    const milestones = await this.milestoneService.listForBooking(bookingId);
-    const byCode = new Map(milestones.map((m) => [m.milestoneCode, m]));
-
-    const existing = byCode.get('GATEPASS_GRANTED');
-    if (existing?.status === 'COMPLETED') {
-      return {
-        bookingId,
-        gatepassAt:
-          existing.metadata?.gatepassAt ??
-          (existing.triggeredAt ? new Date(existing.triggeredAt).toISOString() : ''),
-      };
-    }
-
-    const train = await this.trainState(bookingId);
-    if (tradeDirection === 'EXPORT') {
-      if (!train.arrivedAt) {
-        throw new BadRequestException(
-          'The train has not arrived at Djibouti yet — gate pass can be granted after arrival.',
-        );
-      }
-      for (const code of GlOperationsService.EXPORT_ARRIVAL_CHAIN) {
-        if (byCode.get(code)?.status === 'PENDING') {
-          await this.milestoneService.completeForBooking(bookingId, code, userId);
-        }
-      }
-    } else if (!train.wagonAllocated) {
-      throw new BadRequestException(
-        'Wagons must be allocated before the gate pass can be granted.',
-      );
-    }
-
-    const at = gatepassAt?.trim() || new Date().toISOString();
-    await this.milestoneService.completeWithMetadataForBooking(
-      bookingId,
-      'GATEPASS_GRANTED',
-      { gatepassAt: at },
-      userId,
-    );
-    return { bookingId, gatepassAt: at };
-  }
-
-  /** Train schedules carrying ≥1 customs booking — the GL Djibouti gate-pass table. */
-  async djSchedules(): Promise<Freight.DjClearanceSchedule[]> {
-    const schedules = await this.dataSource.getRepository(TrainSchedule).find({
-      relations: {
-        scheduleBookings: { booking: true },
-        originStation: true,
-        destinationStation: true,
-      },
-      order: { scheduledDepartureDate: 'DESC' },
-    });
-
-    const withCustoms = schedules
-      .filter((s) => s.status !== 'CANCELLED')
-      .map((s) => ({
-        schedule: s,
-        customs: (s.scheduleBookings ?? [])
-          .map((sb) => sb.booking)
-          .filter((b): b is Booking => Boolean(b?.customsClearingEnabled)),
-      }))
-      .filter((s) => s.customs.length > 0);
-
-    const bookingIds = withCustoms.flatMap((s) => s.customs.map((b) => b.id));
-    const gatepassRows = bookingIds.length
-      ? await this.dataSource.getRepository(ClearanceMilestone).find({
-          where: { bookingId: In(bookingIds), milestoneCode: 'GATEPASS_GRANTED' },
-        })
-      : [];
-    const gatepassByBooking = new Map(gatepassRows.map((m) => [m.bookingId, m]));
-
-    return withCustoms.map(({ schedule, customs }) => {
-      const freightTypes = [...new Set(customs.map((b) => b.freightType).filter(Boolean))];
-      return {
-        id: schedule.id,
-        trainNumber: schedule.trainNumber ?? null,
-        routeName: null,
-        origin: schedule.originStation?.label ?? schedule.originStation?.code ?? null,
-        destination:
-          schedule.destinationStation?.label ?? schedule.destinationStation?.code ?? null,
-        status: schedule.status,
-        scheduledDepartureDate: schedule.scheduledDepartureDate
-          ? new Date(schedule.scheduledDepartureDate).toISOString()
-          : null,
-        actualDepartureAt: schedule.actualDepartureAt
-          ? new Date(schedule.actualDepartureAt).toISOString()
-          : null,
-        actualArrivalAt: schedule.actualArrivalAt
-          ? new Date(schedule.actualArrivalAt).toISOString()
-          : null,
-        freightType:
-          freightTypes.length === 1 ? (freightTypes[0] as string) : freightTypes.length ? 'MIXED' : null,
-        customsBookings: customs.map((b) => {
-          const m = gatepassByBooking.get(b.id);
-          const granted = m?.status === 'COMPLETED';
-          return {
-            bookingId: b.id,
-            reference: b.reference ?? b.id,
-            tradeDirection: b.tradeDirection ?? 'IMPORT',
-            contractId: b.contractId ?? null,
-            gatepassGranted: granted,
-            gatepassAt: granted
-              ? (m?.metadata?.gatepassAt ??
-                (m?.triggeredAt ? new Date(m.triggeredAt).toISOString() : null))
-              : null,
-          };
-        }),
-      };
-    });
-  }
-
-  /**
-   * One-click gate pass for every customs booking on a train schedule. Per-booking
-   * guard failures are collected, not fatal. Import schedules also get the
-   * schedule-level ImportDjiboutiOperation gate pass so loading unblocks.
-   */
-  async grantScheduleGatepass(
-    scheduleId: string,
-    gatepassAt?: string,
-    userId?: string,
-  ): Promise<{ granted: number; skipped: Array<{ bookingId: string; error: string }> }> {
-    const schedule = await this.dataSource.getRepository(TrainSchedule).findOne({
-      where: { id: scheduleId },
-      relations: { scheduleBookings: { booking: true } },
-    });
-    if (!schedule) throw new NotFoundException(`Train schedule ${scheduleId} not found`);
-
-    const customs = (schedule.scheduleBookings ?? [])
-      .map((sb) => sb.booking)
-      .filter((b): b is Booking => Boolean(b?.customsClearingEnabled));
-    if (customs.length === 0) {
-      throw new BadRequestException('No customs bookings ride this schedule.');
-    }
-
-    let granted = 0;
-    const skipped: Array<{ bookingId: string; error: string }> = [];
-    for (const booking of customs) {
-      try {
-        await this.grantGatepass(booking.id, gatepassAt, userId);
-        granted += 1;
-      } catch (e) {
-        skipped.push({
-          bookingId: booking.id,
-          error: e instanceof Error ? e.message : 'Failed',
-        });
-      }
-    }
-
-    if (granted > 0 && customs.some((b) => (b.tradeDirection ?? 'IMPORT') === 'IMPORT')) {
-      const opRepo = this.dataSource.getRepository(ImportDjiboutiOperation);
-      let operation = await opRepo.findOne({ where: { trainScheduleId: scheduleId } });
-      if (!operation) {
-        operation = opRepo.create({ trainScheduleId: scheduleId });
-      }
-      if (!operation.gatepassGrantedAt) {
-        operation.gatepassGrantedAt = gatepassAt ? new Date(gatepassAt) : new Date();
-        await opRepo.save(operation);
-      }
-    }
-
-    return { granted, skipped };
-  }
 
   /**
    * GL Djibouti raises the post-offload final invoice (export): manual amount +
diff --git a/apps/edr-freight-api/src/modules/drivers/drivers.controller.ts b/apps/edr-freight-api/src/modules/drivers/drivers.controller.ts
index eb0628b96..b4da558e2 100644
--- a/apps/edr-freight-api/src/modules/drivers/drivers.controller.ts
+++ b/apps/edr-freight-api/src/modules/drivers/drivers.controller.ts
@@ -14,13 +14,17 @@ import { FleetManage, FleetView } from '../../common/booking-guards';
 import { DriversService } from './drivers.service';
 import { CreateDriverDto } from './dto/create-driver.dto';
 import { UpdateDriverDto } from './dto/update-driver.dto';
+import { FleetHistoryService } from '../fleet-history/fleet-history.service';
 
 @ApiTags('drivers')
 @ApiBearerAuth()
 @Controller('drivers')
 @FleetView()
 export class DriversController {
-  constructor(private readonly driversService: DriversService) {}
+  constructor(
+    private readonly driversService: DriversService,
+    private readonly fleetHistory: FleetHistoryService,
+  ) {}
 
   @Post()
   @FleetManage()
@@ -55,6 +59,12 @@ export class DriversController {
     return this.driversService.findById(id);
   }
 
+  @Get(':id/history')
+  @ApiOperation({ summary: 'Get driver assignment & activity history' })
+  history(@Param('id', ParseUUIDPipe) id: string) {
+    return this.fleetHistory.getDriverHistory(id);
+  }
+
   @Patch(':id')
   @FleetManage()
   @ApiOperation({ summary: 'Update a driver' })
diff --git a/apps/edr-freight-api/src/modules/drivers/drivers.service.ts b/apps/edr-freight-api/src/modules/drivers/drivers.service.ts
index 2464a26ac..6e7c1f69c 100644
--- a/apps/edr-freight-api/src/modules/drivers/drivers.service.ts
+++ b/apps/edr-freight-api/src/modules/drivers/drivers.service.ts
@@ -1,18 +1,27 @@
-import { Injectable, NotFoundException, ConflictException } from '@nestjs/common';
+import { Injectable, NotFoundException, ConflictException, BadRequestException } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
 import { Repository } from 'typeorm';
 import { CreateDriverDto } from './dto/create-driver.dto';
 import { UpdateDriverDto } from './dto/update-driver.dto';
 import { Driver, DriverStatus } from './entities/driver.entity';
+import { FleetHistoryService } from '../fleet-history/fleet-history.service';
+import { FleetEventType } from '../fleet-history/entities/fleet-event.entity';
 
 @Injectable()
 export class DriversService {
   constructor(
     @InjectRepository(Driver)
     private readonly driverRepo: Repository<Driver>,
+    private readonly history: FleetHistoryService,
   ) {}
 
   async create(dto: CreateDriverDto): Promise<Driver> {
+    if (dto.faydaVerified !== true) {
+      throw new BadRequestException(
+        'Driver identity must be verified with Fayda before saving',
+      );
+    }
+
     const existing = await this.driverRepo.findOne({
       where: [
         { licenseNumber: dto.licenseNumber },
@@ -33,8 +42,28 @@ export class DriversService {
       }
     }
 
+    if (dto.faydaSub) {
+      const dupe = await this.driverRepo.findOne({
+        where: { faydaSub: dto.faydaSub },
+      });
+      if (dupe) {
+        throw new ConflictException(
+          'A driver is already registered for this Fayda identity',
+        );
+      }
+    }
+
     const driver = this.driverRepo.create(dto);
-    return this.driverRepo.save(driver);
+    const saved = await this.driverRepo.save(driver);
+
+    await this.history.record({
+      eventType: FleetEventType.DRIVER_REGISTERED,
+      driverId: saved.id,
+      label: `${saved.firstName ?? ''} ${saved.lastName ?? ''}`.trim() || null,
+      toValue: saved.status ?? null,
+    });
+
+    return saved;
   }
 
   async findAll(query: {
@@ -106,7 +135,25 @@ export class DriversService {
       }
     }
 
+    if (dto.faydaSub && dto.faydaSub !== driver.faydaSub) {
+      const dupe = await this.driverRepo.findOne({
+        where: { faydaSub: dto.faydaSub },
+      });
+      if (dupe) {
+        throw new ConflictException(
+          'A driver is already registered for this Fayda identity',
+        );
+      }
+    }
+
     Object.assign(driver, dto);
+
+    if (driver.faydaVerified !== true) {
+      throw new BadRequestException(
+        'Driver identity must be verified with Fayda before saving',
+      );
+    }
+
     return this.driverRepo.save(driver);
   }
 
diff --git a/apps/edr-freight-api/src/modules/drivers/dto/create-driver.dto.ts b/apps/edr-freight-api/src/modules/drivers/dto/create-driver.dto.ts
index d8e2aec4a..c2f0bca81 100644
--- a/apps/edr-freight-api/src/modules/drivers/dto/create-driver.dto.ts
+++ b/apps/edr-freight-api/src/modules/drivers/dto/create-driver.dto.ts
@@ -1,5 +1,5 @@
-import { IsString, IsEmail, IsDateString, IsEnum, IsOptional, IsArray } from 'class-validator';
-import { DriverStatus } from '../entities/driver.entity';
+import { IsString, IsEmail, IsDateString, IsEnum, IsOptional, IsArray, IsBoolean } from 'class-validator';
+import { DriverStatus, DriverGender } from '../entities/driver.entity';
 
 export class CreateDriverDto {
   @IsString()
@@ -20,6 +20,10 @@ export class CreateDriverDto {
   @IsDateString()
   dateOfBirth!: string;
 
+  @IsOptional()
+  @IsEnum(DriverGender)
+  gender?: DriverGender;
+
   @IsDateString()
   licenseExpiryDate!: string;
 
@@ -42,4 +46,12 @@ export class CreateDriverDto {
   @IsOptional()
   @IsString()
   notes?: string;
+
+  @IsOptional()
+  @IsBoolean()
+  faydaVerified?: boolean;
+
+  @IsOptional()
+  @IsString()
+  faydaSub?: string;
 }
diff --git a/apps/edr-freight-api/src/modules/drivers/entities/driver.entity.ts b/apps/edr-freight-api/src/modules/drivers/entities/driver.entity.ts
index b3defe2db..58a08b849 100644
--- a/apps/edr-freight-api/src/modules/drivers/entities/driver.entity.ts
+++ b/apps/edr-freight-api/src/modules/drivers/entities/driver.entity.ts
@@ -8,6 +8,12 @@ export enum DriverStatus {
   ON_LEAVE = 'ON_LEAVE',
 }
 
+export enum DriverGender {
+  MALE = 'MALE',
+  FEMALE = 'FEMALE',
+  OTHER = 'OTHER',
+}
+
 @Entity({ name: 'drivers', schema: 'freight' })
 export class Driver extends BaseEntity {
   @Column({ name: 'license_number', unique: true, nullable: true })
@@ -28,6 +34,9 @@ export class Driver extends BaseEntity {
   @Column({ name: 'date_of_birth', type: 'date', nullable: true })
   dateOfBirth?: Date;
 
+  @Column({ type: 'varchar', nullable: true })
+  gender?: DriverGender | null;
+
   @Column({ name: 'license_expiry_date', type: 'date', nullable: true })
   licenseExpiryDate?: Date;
 
@@ -51,4 +60,12 @@ export class Driver extends BaseEntity {
 
   @Column({ type: 'numeric', precision: 3, scale: 2, nullable: true })
   rating?: number | null;
+
+  @Column({ name: 'fayda_verified', type: 'boolean', default: false, nullable: true })
+  faydaVerified?: boolean;
+
+  /** Fayda OIDC subject the identity was verified against. Unique — one driver
+   *  record per verified Fayda identity (NULLs allowed for legacy/unverified). */
+  @Column({ name: 'fayda_sub', type: 'varchar', unique: true, nullable: true })
+  faydaSub?: string | null;
 }
diff --git a/apps/edr-freight-api/src/modules/files/files.service.ts b/apps/edr-freight-api/src/modules/files/files.service.ts
index ec1fb6fa9..a5c641dd7 100644
--- a/apps/edr-freight-api/src/modules/files/files.service.ts
+++ b/apps/edr-freight-api/src/modules/files/files.service.ts
@@ -123,6 +123,16 @@ export class FilesService {
     return this.filesRepository.findByResource(resourceId, resource);
   }
 
+  /**
+   * Short-lived signed URL for a stored file's raw MinIO URL. The persisted
+   * `url` is an un-signed object path that a browser cannot fetch directly;
+   * callers that expose files for preview/download must sign them first.
+   */
+  async signUrl(rawUrl: string, expirySeconds = 300): Promise<string> {
+    const objectName = this.minioService.getObjectNameFromUrl(rawUrl);
+    return this.minioService.getSignedUrl(objectName, expirySeconds);
+  }
+
   async findByCode(
     resourceId: string,
     resource: string,
diff --git a/apps/edr-freight-api/src/modules/first-mile/dto/allocate-containers.dto.ts b/apps/edr-freight-api/src/modules/first-mile/dto/allocate-containers.dto.ts
deleted file mode 100644
index b750f1147..000000000
--- a/apps/edr-freight-api/src/modules/first-mile/dto/allocate-containers.dto.ts
+++ /dev/null
@@ -1,8 +0,0 @@
-export class FirstMileContainerAllocationDto {
-  containerId!: string;
-  vehicleId!: string;
-}
-
-export class AllocateFirstMileContainersDto {
-  allocations!: FirstMileContainerAllocationDto[];
-}
diff --git a/apps/edr-freight-api/src/modules/first-mile/dto/set-distances.dto.ts b/apps/edr-freight-api/src/modules/first-mile/dto/set-distances.dto.ts
new file mode 100644
index 000000000..84247708b
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/first-mile/dto/set-distances.dto.ts
@@ -0,0 +1,24 @@
+import { IsArray, IsNumber, IsOptional, IsUUID, Min, ValidateNested } from 'class-validator';
+import { Type } from 'class-transformer';
+
+export class VehicleDistanceInput {
+  @IsUUID()
+  vehicleId!: string;
+
+  @IsNumber()
+  @Min(0)
+  distanceKm!: number;
+}
+
+/** Per-vehicle actual distances for a first-mile pickup (multi-truck). */
+export class SetDistancesDto {
+  @IsArray()
+  @ValidateNested({ each: true })
+  @Type(() => VehicleDistanceInput)
+  distances!: VehicleDistanceInput[];
+
+  /** Recomputed remaining payment (total km × rate), from the client. */
+  @IsOptional()
+  @IsNumber()
+  remainingPayment?: number;
+}
diff --git a/apps/edr-freight-api/src/modules/first-mile/dto/set-vehicles.dto.ts b/apps/edr-freight-api/src/modules/first-mile/dto/set-vehicles.dto.ts
new file mode 100644
index 000000000..8656b2109
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/first-mile/dto/set-vehicles.dto.ts
@@ -0,0 +1,19 @@
+import { IsArray, IsOptional, IsString, IsUUID, ValidateNested } from 'class-validator';
+import { Type } from 'class-transformer';
+
+export class FirstMileVehicleInput {
+  @IsUUID()
+  vehicleId!: string;
+
+  @IsOptional()
+  @IsString()
+  containerNumber?: string;
+}
+
+/** Replace the full set of vehicles (with their container numbers) on a pickup. */
+export class SetVehiclesDto {
+  @IsArray()
+  @ValidateNested({ each: true })
+  @Type(() => FirstMileVehicleInput)
+  vehicles!: FirstMileVehicleInput[];
+}
diff --git a/apps/edr-freight-api/src/modules/first-mile/entities/first-mile-vehicle-assignment.entity.ts b/apps/edr-freight-api/src/modules/first-mile/entities/first-mile-vehicle-assignment.entity.ts
new file mode 100644
index 000000000..39bf51a50
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/first-mile/entities/first-mile-vehicle-assignment.entity.ts
@@ -0,0 +1,39 @@
+import { BaseEntity } from '@edr/api-common';
+import { Column, Entity, Index, JoinColumn, ManyToOne, Unique } from 'typeorm';
+
+import { Vehicle } from '../../vehicles/entities/vehicle.entity';
+import { FirstMile } from './first-mile.entity';
+
+/**
+ * One row per vehicle assigned to a first-mile pickup. A pickup can be served
+ * by several vehicles at once (multi-truck bookings); the legacy
+ * `first_mile.vehicle_id` column keeps pointing at the first assignment for
+ * backward compatibility.
+ */
+@Entity({ name: 'first_mile_vehicle_assignments', schema: 'freight' })
+@Unique(['firstMileId', 'vehicleId'])
+@Index(['vehicleId'])
+export class FirstMileVehicleAssignment extends BaseEntity {
+  @Column({ name: 'first_mile_id', type: 'uuid' })
+  firstMileId!: string;
+
+  @ManyToOne(() => FirstMile, (fm) => fm.vehicleAssignments, { nullable: false, onDelete: 'CASCADE' })
+  @JoinColumn({ name: 'first_mile_id' })
+  firstMile?: FirstMile;
+
+  @Column({ name: 'vehicle_id', type: 'uuid' })
+  vehicleId!: string;
+
+  @ManyToOne(() => Vehicle, { nullable: false, eager: false })
+  @JoinColumn({ name: 'vehicle_id' })
+  vehicle?: Vehicle;
+
+  /** Container this truck carries — auto-filled from the booking's container
+   *  number when known, else entered manually at assignment time. */
+  @Column({ name: 'container_number', type: 'varchar', nullable: true })
+  containerNumber?: string | null;
+
+  /** Actual distance driven by this truck (km), entered per vehicle. */
+  @Column({ name: 'distance_km', type: 'numeric', precision: 10, scale: 2, nullable: true })
+  distanceKm?: number | null;
+}
diff --git a/apps/edr-freight-api/src/modules/first-mile/entities/first-mile.entity.ts b/apps/edr-freight-api/src/modules/first-mile/entities/first-mile.entity.ts
index 27dcfef87..45a051028 100644
--- a/apps/edr-freight-api/src/modules/first-mile/entities/first-mile.entity.ts
+++ b/apps/edr-freight-api/src/modules/first-mile/entities/first-mile.entity.ts
@@ -4,6 +4,7 @@ import { Column, Entity, Index, JoinColumn, ManyToOne, OneToMany } from 'typeorm
 import { Booking } from '../../bookings/entities/booking.entity';
 import { Vehicle } from '../../vehicles/entities/vehicle.entity';
 import { FirstMileContainerAllocation } from './first-mile-container-allocation.entity';
+import { FirstMileVehicleAssignment } from './first-mile-vehicle-assignment.entity';
 
 export const FIRST_MILE_STATUSES = [
   'PAYMENT_PENDING',
@@ -61,4 +62,7 @@ export class FirstMile extends BaseEntity {
     { eager: false },
   )
   containerAllocations!: FirstMileContainerAllocation[];
+
+  @OneToMany(() => FirstMileVehicleAssignment, (va) => va.firstMile)
+  vehicleAssignments?: FirstMileVehicleAssignment[];
 }
diff --git a/apps/edr-freight-api/src/modules/first-mile/first-mile-invoice.service.ts b/apps/edr-freight-api/src/modules/first-mile/first-mile-invoice.service.ts
index 22520aac1..f4935a87b 100644
--- a/apps/edr-freight-api/src/modules/first-mile/first-mile-invoice.service.ts
+++ b/apps/edr-freight-api/src/modules/first-mile/first-mile-invoice.service.ts
@@ -57,7 +57,8 @@ export class FirstMileInvoiceService {
       return null;
     }
 
-    const totalAmount = record.remainingPayment || 0;
+    // numeric columns come back as strings — coerce before the finite/>0 check.
+    const totalAmount = Number(record.remainingPayment) || 0;
     if (!Number.isFinite(totalAmount) || totalAmount <= 0) {
       this.logger.warn(
         `Skipping invoice for first-mile record ${record.id}: no remaining payment.`,
@@ -71,7 +72,7 @@ export class FirstMileInvoiceService {
       type: 'DELIVERY_FEE',
       companyId: fm.booking!.companyId,
       companyProfileId: fm.booking!.companyProfileId || '',
-      currency: 'ETB',
+      currency: fm.booking!.paymentCurrency || 'ETB',
       lines: [
         {
           chargeType: 'DELIVERY',
diff --git a/apps/edr-freight-api/src/modules/first-mile/first-mile.controller.ts b/apps/edr-freight-api/src/modules/first-mile/first-mile.controller.ts
index d5f53ae0c..e43fbcae8 100644
--- a/apps/edr-freight-api/src/modules/first-mile/first-mile.controller.ts
+++ b/apps/edr-freight-api/src/modules/first-mile/first-mile.controller.ts
@@ -1,4 +1,5 @@
 import {
+  BadRequestException,
   Body,
   Controller,
   Delete,
@@ -17,13 +18,11 @@ import { TrainSchedulingManage, TrainSchedulingView } from '../../common/booking
 
 import { CreateFirstMileDto } from './dto/create-first-mile.dto';
 import { UpdateFirstMileDto } from './dto/update-first-mile.dto';
-import { AllocateFirstMileContainersDto } from './dto/allocate-containers.dto';
+import { SetVehiclesDto } from './dto/set-vehicles.dto';
+import { SetDistancesDto } from './dto/set-distances.dto';
 import { FirstMileStatus } from './entities/first-mile.entity';
 import { FirstMileService } from './first-mile.service';
 import { FirstMileInvoiceService } from './first-mile-invoice.service';
-import { BillingService } from '../billing/billing.service';
-import { BookingsService } from '../bookings/bookings.service';
-import { Freight } from '@edr/types';
 
 @ApiTags('first-mile')
 @ApiBearerAuth()
@@ -33,8 +32,6 @@ export class FirstMileController {
   constructor(
     private readonly firstMileService: FirstMileService,
     private readonly firstMileInvoiceService: FirstMileInvoiceService,
-    private readonly billingService: BillingService,
-    private readonly bookingsService: BookingsService
   ) { }
 
   @Get()
@@ -89,39 +86,43 @@ export class FirstMileController {
   @TrainSchedulingManage()
   @ApiOperation({ summary: 'Update a first-mile leg' })
   async update(@Param('id', ParseUUIDPipe) id: string, @Body() dto: UpdateFirstMileDto) {
-    const record = await this.firstMileService.update(id, dto);
-    // Auto-generate invoice if distance or payment was updated
-    const booking  = await this.bookingsService.findById(record.bookingId);
-    if (dto.exactKm !== undefined || dto.exactKm != record.exactKm || dto.remainingPayment !== undefined || dto.remainingPayment !== record.remainingPayment) {
-    await this.billingService.generateInvoice({
-      source: Freight.InvoiceSource.FirstMile,
-      sourceId: record.id,
-      type: "FIRST_MILE",
-      companyId: booking.companyId,
-      companyProfileId: booking.companyProfileId,
-      currency: "ETB",
+    // No invoice side-effects — invoices are generated only via the explicit
+    // POST :id/invoice endpoint (the "Generate Invoice" action).
+    return this.firstMileService.update(id, dto);
+  }
 
-      lines: [
-        {
-          chargeType: "FIRST_MILE",
-          description: "First Mile Transportation Service",
-          quantity: 1,
-          unitRate: record.remainingPayment,
-          amount: record.remainingPayment,
-          currency: "ETB",
-        },
-      ],
-
-      subtotalAmount: record.remainingPayment,
-      taxAmount: 0, // Replace if VAT/tax applies
-      totalAmount: record.remainingPayment,
-
-      dueInDays: 7,
-      status: Freight.InvoiceStatus.Pending,
-    });
-      await this.firstMileInvoiceService.ensureInvoiceFor(record);
+  @Post(':id/invoice')
+  @TrainSchedulingManage()
+  @ApiOperation({ summary: 'Generate the first-mile delivery-fee invoice' })
+  async generateInvoice(@Param('id', ParseUUIDPipe) id: string) {
+    const record = await this.firstMileService.findById(id);
+    const invoice = await this.firstMileInvoiceService.ensureInvoiceFor(record);
+    if (!invoice) {
+      throw new BadRequestException(
+        'Cannot generate invoice: the leg has no billable amount. Add distance and ensure a FIRST_MILE rate is configured, and the booking has a company.',
+      );
     }
-    return record;
+    return invoice;
+  }
+
+  @Post(':id/vehicles')
+  @TrainSchedulingManage()
+  @ApiOperation({ summary: 'Set the vehicles assigned to a first-mile pickup (multi-truck)' })
+  async setVehicles(
+    @Param('id', ParseUUIDPipe) id: string,
+    @Body() dto: SetVehiclesDto,
+  ) {
+    return this.firstMileService.setVehicles(id, dto.vehicles);
+  }
+
+  @Post(':id/distances')
+  @TrainSchedulingManage()
+  @ApiOperation({ summary: 'Set per-vehicle actual distances (does not generate an invoice)' })
+  async setDistances(
+    @Param('id', ParseUUIDPipe) id: string,
+    @Body() dto: SetDistancesDto,
+  ) {
+    return this.firstMileService.setDistances(id, dto.distances, dto.remainingPayment);
   }
 
   @Delete(':id')
@@ -131,14 +132,4 @@ export class FirstMileController {
   remove(@Param('id', ParseUUIDPipe) id: string) {
     return this.firstMileService.remove(id);
   }
-
-  @Post(':firstMileId/allocate-containers')
-  @TrainSchedulingManage()
-  @ApiOperation({ summary: 'Allocate containers to vehicles for a first-mile leg' })
-  allocateContainers(
-    @Param('firstMileId', ParseUUIDPipe) firstMileId: string,
-    @Body() dto: AllocateFirstMileContainersDto,
-  ) {
-    return this.firstMileService.allocateContainers(firstMileId, dto.allocations);
-  }
 }
diff --git a/apps/edr-freight-api/src/modules/first-mile/first-mile.module.ts b/apps/edr-freight-api/src/modules/first-mile/first-mile.module.ts
index 799ae14e6..51f5ccf4e 100644
--- a/apps/edr-freight-api/src/modules/first-mile/first-mile.module.ts
+++ b/apps/edr-freight-api/src/modules/first-mile/first-mile.module.ts
@@ -8,6 +8,7 @@ import { NotificationsModule } from '../notifications/notifications.module';
 import { VehiclesModule } from '../vehicles/vehicles.module';
 import { FirstMile } from './entities/first-mile.entity';
 import { FirstMileContainerAllocation } from './entities/first-mile-container-allocation.entity';
+import { FirstMileVehicleAssignment } from './entities/first-mile-vehicle-assignment.entity';
 import { FirstMileController } from './first-mile.controller';
 import { FirstMileInvoiceService } from './first-mile-invoice.service';
 import { FirstMileRepository } from './first-mile.repository';
@@ -15,7 +16,7 @@ import { FirstMileService } from './first-mile.service';
 
 @Module({
   imports: [
-    TypeOrmModule.forFeature([FirstMile, FirstMileContainerAllocation]),
+    TypeOrmModule.forFeature([FirstMile, FirstMileContainerAllocation, FirstMileVehicleAssignment]),
     forwardRef(() => BillingModule),
     forwardRef(() => BookingsModule),
     VehiclesModule,
diff --git a/apps/edr-freight-api/src/modules/first-mile/first-mile.service.ts b/apps/edr-freight-api/src/modules/first-mile/first-mile.service.ts
index 40d163220..5c12d94ee 100644
--- a/apps/edr-freight-api/src/modules/first-mile/first-mile.service.ts
+++ b/apps/edr-freight-api/src/modules/first-mile/first-mile.service.ts
@@ -1,5 +1,5 @@
-import { Injectable, Logger, NotFoundException } from '@nestjs/common';
-import { FindOptionsWhere, In } from 'typeorm';
+import { BadRequestException, Injectable, Logger, NotFoundException } from '@nestjs/common';
+import { FindOptionsWhere, In, IsNull, Not } from 'typeorm';
 import { InjectDataSource } from '@nestjs/typeorm';
 import { DataSource } from 'typeorm';
 import { VehicleAvailability } from '../vehicles/entities/vehicle.entity';
@@ -11,9 +11,12 @@ import { CreateFirstMileDto } from "./dto/create-first-mile.dto";
 import { UpdateFirstMileDto } from "./dto/update-first-mile.dto";
 import { FirstMile, FirstMileStatus } from "./entities/first-mile.entity";
 import { FirstMileContainerAllocation } from "./entities/first-mile-container-allocation.entity";
+import { FirstMileVehicleAssignment } from "./entities/first-mile-vehicle-assignment.entity";
 import { FirstMileRepository } from "./first-mile.repository";
 import { OnEvent } from "@nestjs/event-emitter";
-import { InvoiceEventPayload } from "../billing/billing.service";
+import { BillingService, InvoiceEventPayload } from "../billing/billing.service";
+import { FleetHistoryService } from "../fleet-history/fleet-history.service";
+import { FleetEventType } from "../fleet-history/entities/fleet-event.entity";
 
 type FirstMileListFilter = {
   status?: FirstMileStatus;
@@ -43,8 +46,78 @@ export class FirstMileService {
     private readonly vehiclesService: VehiclesService,
     private readonly driversService: DriversService,
     private readonly smsClient: SmsClientService,
+    private readonly history: FleetHistoryService,
+    private readonly billing: BillingService,
   ) { }
 
+  /** Attach real invoice info so the UI shows an invoice link only when one
+   *  exists — not merely because distance was entered. Batched (no N+1). */
+  private async attachInvoices(records: FirstMile[]): Promise<void> {
+    const invoices = await this.billing.findBySourceIds(
+      'first_mile',
+      records.map((r) => r.id),
+    );
+    const byId = new Map<string, { id: string; number: string; status: string }>();
+    for (const inv of invoices) {
+      if (!byId.has(inv.sourceId)) {
+        byId.set(inv.sourceId, { id: inv.id, number: inv.invoiceNumber, status: String(inv.status) });
+      }
+    }
+    for (const r of records) {
+      (r as FirstMile & { invoice?: unknown }).invoice = byId.get(r.id) ?? null;
+    }
+  }
+
+  /** Resolve a vehicle's driver + human labels, for stamping mile events onto
+   *  the driver's timeline and naming the vehicle. Best-effort — never throws. */
+  private async vehicleInfo(
+    vehicleId?: string | null,
+  ): Promise<{ driverId: string | null; plate: string | null; driverName: string | null }> {
+    if (!vehicleId) return { driverId: null, plate: null, driverName: null };
+    try {
+      const v = await this.vehiclesService.findById(vehicleId);
+      return {
+        driverId: v.assignedDriverId ?? null,
+        plate: v.plateNumber ?? v.code ?? null,
+        driverName: v.assignedDriverName ?? null,
+      };
+    } catch {
+      return { driverId: null, plate: null, driverName: null };
+    }
+  }
+
+  /** A leg counts as having a vehicle if it has a direct assignment or at least
+   *  one container allocation carrying a vehicle. Gates the IN_TRANSIT move. */
+  private async hasAssignedVehicle(
+    recordId: string,
+    directVehicleId?: string | null,
+  ): Promise<boolean> {
+    if (directVehicleId) return true;
+    const [junction, allocations] = await Promise.all([
+      this.dataSource.manager.count(FirstMileVehicleAssignment, {
+        where: { firstMileId: recordId },
+      }),
+      this.dataSource.manager.count(FirstMileContainerAllocation, {
+        where: { firstMileId: recordId, vehicleId: Not(IsNull()) },
+      }),
+    ]);
+    return junction > 0 || allocations > 0;
+  }
+
+  /** Human booking reference for a first-mile record, for the history timeline. */
+  private async resolveBookingRef(record: FirstMile): Promise<string | null> {
+    const loaded = (record as FirstMile & { booking?: { reference?: string } })
+      .booking?.reference;
+    if (loaded) return loaded;
+    if (!record.bookingId) return null;
+    try {
+      const b = await this.bookingsRepository.findById(record.bookingId);
+      return (b as { reference?: string } | null)?.reference ?? null;
+    } catch {
+      return null;
+    }
+  }
+
   /**
    * Look up a booking by its human-readable reference and confirm it has been
    * paid before any first-mile work proceeds. Throws if the reference is
@@ -135,14 +208,18 @@ export class FirstMileService {
           originYard: true,
           destinationYard: true,
           cargoType: true,
+          bookingContainers: { containerType: true, units: true },
         },
         vehicle: true,
+        vehicleAssignments: { vehicle: true },
       },
       order: { [sortBy]: sortOrder },
       skip: (page - 1) * pageSize,
       take: pageSize,
     });
 
+    await this.attachInvoices(data);
+
     return {
       data,
       meta: {
@@ -179,8 +256,10 @@ export class FirstMileService {
           originYard: true,
           destinationYard: true,
           cargoType: true,
+          bookingContainers: { containerType: true, units: true },
         },
         vehicle: true,
+        vehicleAssignments: { vehicle: true },
       },
     });
 
@@ -188,6 +267,8 @@ export class FirstMileService {
       throw new NotFoundException(`First-mile record ${id} not found`);
     }
 
+    await this.attachInvoices([record]);
+
     return record;
   }
 
@@ -210,6 +291,20 @@ export class FirstMileService {
 
     if (dto.vehicleId) {
       await this.vehiclesService.setAvailability(dto.vehicleId, VehicleAvailability.BUSY);
+      const info = await this.vehicleInfo(dto.vehicleId);
+      await this.history.record({
+        eventType: FleetEventType.MILE_VEHICLE_ASSIGNED,
+        vehicleId: dto.vehicleId,
+        firstMileId: record.id,
+        driverId: info.driverId,
+        label: record.status,
+        metadata: {
+          mile: 'FIRST',
+          bookingRef: await this.resolveBookingRef(record),
+          vehiclePlate: info.plate,
+          driverName: info.driverName,
+        },
+      });
     }
 
     return record;
@@ -248,6 +343,18 @@ export class FirstMileService {
   async update(id: string, dto: UpdateFirstMileDto): Promise<FirstMile> {
     const existing = await this.findById(id);
 
+    // A leg can only go IN_TRANSIT once a vehicle is assigned (allowing a vehicle
+    // assigned in this same request).
+    if (dto.status === 'IN_TRANSIT' && existing.status !== 'IN_TRANSIT') {
+      const vehicleId =
+        dto.vehicleId !== undefined ? dto.vehicleId : existing.vehicleId;
+      if (!(await this.hasAssignedVehicle(id, vehicleId))) {
+        throw new BadRequestException(
+          'Assign a vehicle before marking this first-mile leg in transit',
+        );
+      }
+    }
+
     const dtoAny = dto as any;
     const updated = await this.firstMileRepository.update(id, {
       ...(dto.bookingId !== undefined ? { bookingId: dto.bookingId } : {}),
@@ -278,6 +385,39 @@ export class FirstMileService {
       if (existing.vehicleId) {
         await this.vehiclesService.releaseIfUnused([existing.vehicleId]);
       }
+      // Audit the mile↔vehicle (re)assignment on both vehicle and driver lines.
+      const bookingRef = await this.resolveBookingRef(existing);
+      if (existing.vehicleId) {
+        const info = await this.vehicleInfo(existing.vehicleId);
+        await this.history.record({
+          eventType: FleetEventType.MILE_VEHICLE_RELEASED,
+          vehicleId: existing.vehicleId,
+          firstMileId: id,
+          driverId: info.driverId,
+          metadata: {
+            mile: 'FIRST',
+            bookingRef,
+            vehiclePlate: info.plate,
+            driverName: info.driverName,
+          },
+        });
+      }
+      if (dto.vehicleId) {
+        const info = await this.vehicleInfo(dto.vehicleId);
+        await this.history.record({
+          eventType: FleetEventType.MILE_VEHICLE_ASSIGNED,
+          vehicleId: dto.vehicleId,
+          firstMileId: id,
+          driverId: info.driverId,
+          label: updated.status,
+          metadata: {
+            mile: 'FIRST',
+            bookingRef,
+            vehiclePlate: info.plate,
+            driverName: info.driverName,
+          },
+        });
+      }
     }
 
     // Notify assigned driver on every explicit vehicle assignment or reassignment
@@ -285,6 +425,25 @@ export class FirstMileService {
       void this.notifyDriverAssignment(dto.vehicleId, existing);
     }
 
+    if (dto.status !== undefined && dto.status !== existing.status) {
+      const vehicleId = updated.vehicleId ?? existing.vehicleId ?? null;
+      const info = await this.vehicleInfo(vehicleId);
+      await this.history.record({
+        eventType: FleetEventType.MILE_STATUS_CHANGED,
+        firstMileId: id,
+        vehicleId,
+        driverId: info.driverId,
+        fromValue: existing.status,
+        toValue: dto.status,
+        metadata: {
+          mile: 'FIRST',
+          bookingRef: await this.resolveBookingRef(existing),
+          vehiclePlate: info.plate,
+          driverName: info.driverName,
+        },
+      });
+    }
+
     // Trip finished — release the vehicles it was holding
     if (dto.status === 'RECEIVED_TO_PORT' && existing.status !== 'RECEIVED_TO_PORT') {
       await this.releaseVehicles(updated);
@@ -295,12 +454,40 @@ export class FirstMileService {
 
   async updateStatus(id: string, status: FirstMileStatus): Promise<FirstMile> {
     const existing = await this.findById(id);
+
+    if (status === 'IN_TRANSIT' && existing.status !== 'IN_TRANSIT') {
+      if (!(await this.hasAssignedVehicle(id, existing.vehicleId))) {
+        throw new BadRequestException(
+          'Assign a vehicle before marking this first-mile leg in transit',
+        );
+      }
+    }
+
     const updated = await this.firstMileRepository.update(id, { status });
 
     if (!updated) {
       throw new NotFoundException(`First-mile record ${id} not found`);
     }
 
+    if (status !== existing.status) {
+      const vehicleId = updated.vehicleId ?? existing.vehicleId ?? null;
+      const info = await this.vehicleInfo(vehicleId);
+      await this.history.record({
+        eventType: FleetEventType.MILE_STATUS_CHANGED,
+        firstMileId: id,
+        vehicleId,
+        driverId: info.driverId,
+        fromValue: existing.status,
+        toValue: status,
+        metadata: {
+          mile: 'FIRST',
+          bookingRef: await this.resolveBookingRef(existing),
+          vehiclePlate: info.plate,
+          driverName: info.driverName,
+        },
+      });
+    }
+
     if (status === 'RECEIVED_TO_PORT' && existing.status !== 'RECEIVED_TO_PORT') {
       await this.releaseVehicles(updated);
     }
@@ -313,18 +500,154 @@ export class FirstMileService {
    * allocations), unless still in use by another active trip.
    */
   private async releaseVehicles(record: FirstMile): Promise<void> {
-    const recordAllocations = await this.dataSource.manager.find(FirstMileContainerAllocation, {
-      where: { firstMileId: record.id },
-    });
-    const vehicleIds = recordAllocations
-      .map((a) => a.vehicleId)
-      .filter((id): id is string => Boolean(id));
-    if (record.vehicleId) {
-      vehicleIds.push(record.vehicleId);
-    }
+    const [assignments, recordAllocations] = await Promise.all([
+      this.dataSource.manager.find(FirstMileVehicleAssignment, {
+        where: { firstMileId: record.id },
+      }),
+      this.dataSource.manager.find(FirstMileContainerAllocation, {
+        where: { firstMileId: record.id },
+      }),
+    ]);
+    const vehicleIds = [
+      ...new Set(
+        [
+          ...assignments.map((a) => a.vehicleId),
+          ...recordAllocations.map((a) => a.vehicleId),
+          record.vehicleId ?? null,
+        ].filter((id): id is string => Boolean(id)),
+      ),
+    ];
     await this.vehiclesService.releaseIfUnused(vehicleIds);
   }
 
+  /**
+   * Replace the full set of vehicles serving a first-mile pickup (multi-truck).
+   * Diffs against the current junction rows, syncing availability + audit history
+   * for each added/removed vehicle. The first vehicle is mirrored onto the legacy
+   * `vehicleId` column for back-compat with single-vehicle readers.
+   */
+  async setVehicles(
+    id: string,
+    inputs: Array<{ vehicleId: string; containerNumber?: string | null }>,
+  ): Promise<FirstMile> {
+    const existing = await this.findById(id);
+    // Dedupe by vehicleId, keeping the container number; preserve order.
+    const desiredMap = new Map<string, string | null>();
+    for (const inp of inputs) {
+      if (inp.vehicleId) desiredMap.set(inp.vehicleId, inp.containerNumber ?? null);
+    }
+    const desired = [...desiredMap.keys()];
+    const desiredSet = new Set(desired);
+
+    const manager = this.dataSource.manager;
+    const current = await manager.find(FirstMileVehicleAssignment, {
+      where: { firstMileId: id },
+    });
+    const junctionSet = new Set(current.map((a) => a.vehicleId));
+    // Fold the legacy vehicleId into the release set — a vehicle assigned via the
+    // old single-vehicle path has no junction row but must still be freed.
+    const releaseIds = [...new Set(
+      current.map((a) => a.vehicleId).concat(existing.vehicleId ? [existing.vehicleId] : []),
+    )];
+    const added = desired.filter((v) => !junctionSet.has(v));
+    const removed = releaseIds.filter((v) => !desiredSet.has(v));
+    // Vehicles that stay but whose container number changed.
+    const changed = current.filter(
+      (a) =>
+        desiredMap.has(a.vehicleId) &&
+        (a.containerNumber ?? null) !== (desiredMap.get(a.vehicleId) ?? null),
+    );
+
+    await this.dataSource.transaction(async (tx) => {
+      if (removed.length) {
+        await tx.delete(FirstMileVehicleAssignment, {
+          firstMileId: id,
+          vehicleId: In(removed),
+        });
+      }
+      for (const vehicleId of added) {
+        await tx.insert(FirstMileVehicleAssignment, {
+          firstMileId: id,
+          vehicleId,
+          containerNumber: desiredMap.get(vehicleId) ?? null,
+        });
+      }
+      for (const row of changed) {
+        await tx.update(
+          FirstMileVehicleAssignment,
+          { firstMileId: id, vehicleId: row.vehicleId },
+          { containerNumber: desiredMap.get(row.vehicleId) ?? null },
+        );
+      }
+    });
+
+    // Legacy primary vehicle = first of the set (null when cleared).
+    await this.firstMileRepository.update(id, { vehicleId: desired[0] ?? null } as any);
+
+    const bookingRef = await this.resolveBookingRef(existing);
+    for (const vehicleId of added) {
+      await this.vehiclesService.setAvailability(vehicleId, VehicleAvailability.BUSY);
+      void this.notifyDriverAssignment(vehicleId, existing);
+      const info = await this.vehicleInfo(vehicleId);
+      await this.history.record({
+        eventType: FleetEventType.MILE_VEHICLE_ASSIGNED,
+        vehicleId,
+        firstMileId: id,
+        driverId: info.driverId,
+        label: existing.status,
+        metadata: { mile: 'FIRST', bookingRef, vehiclePlate: info.plate, driverName: info.driverName },
+      });
+    }
+    for (const vehicleId of removed) {
+      await this.vehiclesService.releaseIfUnused([vehicleId]);
+      const info = await this.vehicleInfo(vehicleId);
+      await this.history.record({
+        eventType: FleetEventType.MILE_VEHICLE_RELEASED,
+        vehicleId,
+        firstMileId: id,
+        driverId: info.driverId,
+        metadata: { mile: 'FIRST', bookingRef, vehiclePlate: info.plate, driverName: info.driverName },
+      });
+    }
+
+    return this.findById(id);
+  }
+
+  /**
+   * Record each truck's actual distance. The pickup total (exact_km) is their
+   * sum and drives billing; `remainingPayment` (total km × rate) is recomputed
+   * client-side. Does NOT generate an invoice — that's a separate explicit step.
+   */
+  async setDistances(
+    id: string,
+    distances: Array<{ vehicleId: string; distanceKm: number }>,
+    remainingPayment?: number,
+  ): Promise<FirstMile> {
+    await this.findById(id);
+
+    // Distances are locked once the invoice exists.
+    const invoices = await this.billing.findBySourceIds('first_mile', [id]);
+    if (invoices.length) {
+      throw new BadRequestException(
+        'Distances cannot be changed after the invoice is generated',
+      );
+    }
+
+    for (const d of distances) {
+      await this.dataSource.manager.update(
+        FirstMileVehicleAssignment,
+        { firstMileId: id, vehicleId: d.vehicleId },
+        { distanceKm: d.distanceKm },
+      );
+    }
+    const total = distances.reduce((s, d) => s + (Number(d.distanceKm) || 0), 0);
+    await this.firstMileRepository.update(id, {
+      exactKm: total,
+      ...(remainingPayment != null ? { remainingPayment } : {}),
+    } as any);
+    return this.findById(id);
+  }
+
   private async notifyDriverAssignment(vehicleId: string, record: FirstMile): Promise<void> {
     try {
       const vehicle = await this.vehiclesService.findById(vehicleId);
@@ -383,56 +706,54 @@ export class FirstMileService {
   }
 
   async remove(id: string): Promise<void> {
-    await this.findById(id);
-    await this.firstMileRepository.softDelete(id);
-  }
+    const existing = await this.findById(id);
 
-  async allocateContainers(
-    firstMileId: string,
-    allocations: Array<{ containerId: string; vehicleId: string }>,
-  ) {
-    const firstMile = await this.findById(firstMileId);
-    if (!firstMile) {
-      throw new NotFoundException(`First-mile record ${firstMileId} not found`);
+    // Can't delete once billed.
+    const invoices = await this.billing.findBySourceIds('first_mile', [id]);
+    if (invoices.length) {
+      throw new BadRequestException(
+        'Cannot delete a first-mile leg after its invoice is generated',
+      );
     }
 
-    const previousAllocations = await this.dataSource.manager.find(FirstMileContainerAllocation, {
-      where: {
-        firstMileId,
-        containerId: In(allocations.map((a) => a.containerId)),
-      },
-    });
-    const previousVehicleIds = previousAllocations
-      .map((a) => a.vehicleId)
-      .filter((id): id is string => Boolean(id));
+    // Every vehicle this pickup holds — junction + legacy + container rows.
+    const [assignments, allocations] = await Promise.all([
+      this.dataSource.manager.find(FirstMileVehicleAssignment, {
+        where: { firstMileId: id },
+      }),
+      this.dataSource.manager.find(FirstMileContainerAllocation, {
+        where: { firstMileId: id },
+      }),
+    ]);
+    const vehicleIds = [
+      ...new Set(
+        [
+          ...assignments.map((a) => a.vehicleId),
+          ...allocations.map((a) => a.vehicleId),
+          existing.vehicleId ?? null,
+        ].filter((v): v is string => Boolean(v)),
+      ),
+    ];
 
-    await this.dataSource.transaction(async (manager) => {
-      for (const allocation of allocations) {
-        await manager.delete(FirstMileContainerAllocation, {
-          firstMileId,
-          containerId: allocation.containerId,
-        });
-        await manager.insert(FirstMileContainerAllocation, {
-          firstMileId,
-          containerId: allocation.containerId,
-          vehicleId: allocation.vehicleId,
-          containerType: "CONTAINER",
-          quantity: 1,
+    await this.firstMileRepository.softDelete(id);
+    if (assignments.length) {
+      await this.dataSource.manager.softDelete(FirstMileVehicleAssignment, { firstMileId: id });
+    }
+
+    // Free every vehicle no longer held by another active trip and audit release.
+    if (vehicleIds.length) {
+      await this.vehiclesService.releaseIfUnused(vehicleIds);
+      const bookingRef = await this.resolveBookingRef(existing);
+      for (const vehicleId of vehicleIds) {
+        const info = await this.vehicleInfo(vehicleId);
+        await this.history.record({
+          eventType: FleetEventType.MILE_VEHICLE_RELEASED,
+          vehicleId,
+          firstMileId: id,
+          driverId: info.driverId,
+          metadata: { mile: 'FIRST', bookingRef, vehiclePlate: info.plate, driverName: info.driverName },
         });
       }
-    });
-
-    const vehicleIds = new Set(allocations.map((a) => a.vehicleId));
-    await Promise.all(
-      [...vehicleIds].map((vehicleId) => this.vehiclesService.setAvailability(vehicleId, VehicleAvailability.BUSY)),
-    );
-    await this.vehiclesService.releaseIfUnused(
-      previousVehicleIds.filter((id) => !vehicleIds.has(id)),
-    );
-
-    return {
-      success: true,
-      allocated: allocations.length,
-    };
+    }
   }
 }
diff --git a/apps/edr-freight-api/src/modules/fleet-history/entities/fleet-event.entity.ts b/apps/edr-freight-api/src/modules/fleet-history/entities/fleet-event.entity.ts
new file mode 100644
index 000000000..5096adbc6
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/fleet-history/entities/fleet-event.entity.ts
@@ -0,0 +1,55 @@
+import { Entity, Column, Index } from 'typeorm';
+import { BaseEntity } from '@edr/api-common';
+
+/**
+ * Append-only audit log for fleet activity. One row per transition. Queried by
+ * `vehicleId` (vehicle timeline) or `driverId` (driver timeline); an event may
+ * carry both so a driver↔vehicle assignment or a mile assignment shows on both.
+ * `createdAt` (from BaseEntity) is the event time.
+ */
+export enum FleetEventType {
+  DRIVER_REGISTERED = 'DRIVER_REGISTERED',
+  VEHICLE_REGISTERED = 'VEHICLE_REGISTERED',
+  DRIVER_ASSIGNED = 'DRIVER_ASSIGNED',
+  DRIVER_UNASSIGNED = 'DRIVER_UNASSIGNED',
+  VEHICLE_STATUS_CHANGED = 'VEHICLE_STATUS_CHANGED',
+  VEHICLE_AVAILABILITY_CHANGED = 'VEHICLE_AVAILABILITY_CHANGED',
+  MILE_VEHICLE_ASSIGNED = 'MILE_VEHICLE_ASSIGNED',
+  MILE_VEHICLE_RELEASED = 'MILE_VEHICLE_RELEASED',
+  MILE_STATUS_CHANGED = 'MILE_STATUS_CHANGED',
+}
+
+@Entity({ name: 'fleet_events', schema: 'freight' })
+export class FleetEvent extends BaseEntity {
+  @Column({ name: 'event_type', type: 'varchar' })
+  eventType!: FleetEventType;
+
+  @Index()
+  @Column({ name: 'vehicle_id', type: 'uuid', nullable: true })
+  vehicleId?: string | null;
+
+  @Index()
+  @Column({ name: 'driver_id', type: 'uuid', nullable: true })
+  driverId?: string | null;
+
+  @Column({ name: 'first_mile_id', type: 'uuid', nullable: true })
+  firstMileId?: string | null;
+
+  @Column({ name: 'last_mile_id', type: 'uuid', nullable: true })
+  lastMileId?: string | null;
+
+  /** Previous value for a transition (e.g. old status/availability). */
+  @Column({ name: 'from_value', type: 'varchar', nullable: true })
+  fromValue?: string | null;
+
+  /** New value for a transition (e.g. new status/availability). */
+  @Column({ name: 'to_value', type: 'varchar', nullable: true })
+  toValue?: string | null;
+
+  /** Human-readable summary token (driver name, plate, booking ref, mile). */
+  @Column({ name: 'label', type: 'varchar', nullable: true })
+  label?: string | null;
+
+  @Column({ name: 'metadata', type: 'jsonb', nullable: true })
+  metadata?: Record<string, unknown> | null;
+}
diff --git a/apps/edr-freight-api/src/modules/fleet-history/fleet-history.module.ts b/apps/edr-freight-api/src/modules/fleet-history/fleet-history.module.ts
new file mode 100644
index 000000000..14828e0a9
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/fleet-history/fleet-history.module.ts
@@ -0,0 +1,17 @@
+import { Global, Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { FleetEvent } from './entities/fleet-event.entity';
+import { FleetHistoryService } from './fleet-history.service';
+
+/**
+ * Global so any fleet-touching service (vehicles, drivers, first/last-mile) can
+ * inject FleetHistoryService to append audit events without each module having
+ * to import this one.
+ */
+@Global()
+@Module({
+  imports: [TypeOrmModule.forFeature([FleetEvent])],
+  providers: [FleetHistoryService],
+  exports: [FleetHistoryService],
+})
+export class FleetHistoryModule {}
diff --git a/apps/edr-freight-api/src/modules/fleet-history/fleet-history.service.ts b/apps/edr-freight-api/src/modules/fleet-history/fleet-history.service.ts
new file mode 100644
index 000000000..9c61119b9
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/fleet-history/fleet-history.service.ts
@@ -0,0 +1,54 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+import { FleetEvent, FleetEventType } from './entities/fleet-event.entity';
+
+export interface FleetEventInput {
+  eventType: FleetEventType;
+  vehicleId?: string | null;
+  driverId?: string | null;
+  firstMileId?: string | null;
+  lastMileId?: string | null;
+  fromValue?: string | null;
+  toValue?: string | null;
+  label?: string | null;
+  metadata?: Record<string, unknown> | null;
+}
+
+@Injectable()
+export class FleetHistoryService {
+  private readonly logger = new Logger(FleetHistoryService.name);
+
+  constructor(
+    @InjectRepository(FleetEvent)
+    private readonly eventRepo: Repository<FleetEvent>,
+  ) {}
+
+  /**
+   * Append an audit event. Best-effort: recording history must never break the
+   * business operation that triggered it, so failures are logged and swallowed.
+   */
+  async record(input: FleetEventInput): Promise<void> {
+    try {
+      await this.eventRepo.save(this.eventRepo.create(input));
+    } catch (err) {
+      this.logger.error(
+        `Failed to record fleet event ${input.eventType}: ${String(err)}`,
+      );
+    }
+  }
+
+  getVehicleHistory(vehicleId: string): Promise<FleetEvent[]> {
+    return this.eventRepo.find({
+      where: { vehicleId },
+      order: { createdAt: 'DESC' },
+    });
+  }
+
+  getDriverHistory(driverId: string): Promise<FleetEvent[]> {
+    return this.eventRepo.find({
+      where: { driverId },
+      order: { createdAt: 'DESC' },
+    });
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/last-mile/dto/allocate-containers.dto.ts b/apps/edr-freight-api/src/modules/last-mile/dto/allocate-containers.dto.ts
deleted file mode 100644
index de86ac883..000000000
--- a/apps/edr-freight-api/src/modules/last-mile/dto/allocate-containers.dto.ts
+++ /dev/null
@@ -1,8 +0,0 @@
-export class LastMileContainerAllocationDto {
-  containerId!: string;
-  vehicleId!: string;
-}
-
-export class AllocateLastMileContainersDto {
-  allocations!: LastMileContainerAllocationDto[];
-}
diff --git a/apps/edr-freight-api/src/modules/last-mile/dto/set-distances.dto.ts b/apps/edr-freight-api/src/modules/last-mile/dto/set-distances.dto.ts
new file mode 100644
index 000000000..3b8b26bfe
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/last-mile/dto/set-distances.dto.ts
@@ -0,0 +1,24 @@
+import { IsArray, IsNumber, IsOptional, IsUUID, Min, ValidateNested } from 'class-validator';
+import { Type } from 'class-transformer';
+
+export class VehicleDistanceInput {
+  @IsUUID()
+  vehicleId!: string;
+
+  @IsNumber()
+  @Min(0)
+  distanceKm!: number;
+}
+
+/** Per-vehicle actual distances for a last-mile delivery (multi-truck). */
+export class SetDistancesDto {
+  @IsArray()
+  @ValidateNested({ each: true })
+  @Type(() => VehicleDistanceInput)
+  distances!: VehicleDistanceInput[];
+
+  /** Recomputed remaining payment (total km × rate), from the client. */
+  @IsOptional()
+  @IsNumber()
+  remainingPayment?: number;
+}
diff --git a/apps/edr-freight-api/src/modules/last-mile/dto/set-vehicles.dto.ts b/apps/edr-freight-api/src/modules/last-mile/dto/set-vehicles.dto.ts
new file mode 100644
index 000000000..e07eec0b4
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/last-mile/dto/set-vehicles.dto.ts
@@ -0,0 +1,19 @@
+import { IsArray, IsOptional, IsString, IsUUID, ValidateNested } from 'class-validator';
+import { Type } from 'class-transformer';
+
+export class LastMileVehicleInput {
+  @IsUUID()
+  vehicleId!: string;
+
+  @IsOptional()
+  @IsString()
+  containerNumber?: string;
+}
+
+/** Replace the full set of vehicles (with their container numbers) on a delivery. */
+export class SetVehiclesDto {
+  @IsArray()
+  @ValidateNested({ each: true })
+  @Type(() => LastMileVehicleInput)
+  vehicles!: LastMileVehicleInput[];
+}
diff --git a/apps/edr-freight-api/src/modules/last-mile/entities/last-mile-container-allocation.entity.ts b/apps/edr-freight-api/src/modules/last-mile/entities/last-mile-container-allocation.entity.ts
index 8a61c73bf..187d9aea1 100644
--- a/apps/edr-freight-api/src/modules/last-mile/entities/last-mile-container-allocation.entity.ts
+++ b/apps/edr-freight-api/src/modules/last-mile/entities/last-mile-container-allocation.entity.ts
@@ -24,7 +24,7 @@ export class LastMileContainerAllocation extends BaseEntity {
   @Column('uuid', { name: 'vehicle_id', nullable: true })
   vehicleId?: string | null;
 
-  @Column('text')
+  @Column('text', { name: 'container_type' })
   containerType!: string;
 
   @Column('integer', { default: 1 })
diff --git a/apps/edr-freight-api/src/modules/last-mile/entities/last-mile-vehicle-assignment.entity.ts b/apps/edr-freight-api/src/modules/last-mile/entities/last-mile-vehicle-assignment.entity.ts
new file mode 100644
index 000000000..eee414275
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/last-mile/entities/last-mile-vehicle-assignment.entity.ts
@@ -0,0 +1,39 @@
+import { BaseEntity } from '@edr/api-common';
+import { Column, Entity, Index, JoinColumn, ManyToOne, Unique } from 'typeorm';
+
+import { Vehicle } from '../../vehicles/entities/vehicle.entity';
+import { LastMile } from './last-mile.entity';
+
+/**
+ * One row per vehicle assigned to a last-mile delivery. A delivery can be
+ * served by several vehicles at once (multi-truck bookings); the legacy
+ * `last_mile.vehicle_id` column keeps pointing at the first assignment for
+ * backward compatibility.
+ */
+@Entity({ name: 'last_mile_vehicle_assignments', schema: 'freight' })
+@Unique(['lastMileId', 'vehicleId'])
+@Index(['vehicleId'])
+export class LastMileVehicleAssignment extends BaseEntity {
+  @Column({ name: 'last_mile_id', type: 'uuid' })
+  lastMileId!: string;
+
+  @ManyToOne(() => LastMile, (lm) => lm.vehicleAssignments, { nullable: false, onDelete: 'CASCADE' })
+  @JoinColumn({ name: 'last_mile_id' })
+  lastMile?: LastMile;
+
+  @Column({ name: 'vehicle_id', type: 'uuid' })
+  vehicleId!: string;
+
+  @ManyToOne(() => Vehicle, { nullable: false, eager: false })
+  @JoinColumn({ name: 'vehicle_id' })
+  vehicle?: Vehicle;
+
+  /** Container this truck carries — auto-filled from the booking's container
+   *  number when known, else entered manually at assignment time. */
+  @Column({ name: 'container_number', type: 'varchar', nullable: true })
+  containerNumber?: string | null;
+
+  /** Actual distance driven by this truck (km), entered per vehicle. */
+  @Column({ name: 'distance_km', type: 'numeric', precision: 10, scale: 2, nullable: true })
+  distanceKm?: number | null;
+}
diff --git a/apps/edr-freight-api/src/modules/last-mile/entities/last-mile.entity.ts b/apps/edr-freight-api/src/modules/last-mile/entities/last-mile.entity.ts
index 85d01b7f0..1f8bda8fc 100644
--- a/apps/edr-freight-api/src/modules/last-mile/entities/last-mile.entity.ts
+++ b/apps/edr-freight-api/src/modules/last-mile/entities/last-mile.entity.ts
@@ -4,6 +4,7 @@ import { Column, Entity, Index, JoinColumn, ManyToOne, OneToMany } from 'typeorm
 import { Booking } from '../../bookings/entities/booking.entity';
 import { Vehicle } from '../../vehicles/entities/vehicle.entity';
 import { LastMileContainerAllocation } from './last-mile-container-allocation.entity';
+import { LastMileVehicleAssignment } from './last-mile-vehicle-assignment.entity';
 
 export const LAST_MILE_STATUSES = [
   'PAYMENT_PENDING',
@@ -57,4 +58,7 @@ export class LastMile extends BaseEntity {
 
   @OneToMany(() => LastMileContainerAllocation, (ca) => ca.lastMile)
   containerAllocations?: LastMileContainerAllocation[];
+
+  @OneToMany(() => LastMileVehicleAssignment, (va) => va.lastMile)
+  vehicleAssignments?: LastMileVehicleAssignment[];
 }
diff --git a/apps/edr-freight-api/src/modules/last-mile/last-mile-invoice.service.ts b/apps/edr-freight-api/src/modules/last-mile/last-mile-invoice.service.ts
index c304a89e8..7b14f6887 100644
--- a/apps/edr-freight-api/src/modules/last-mile/last-mile-invoice.service.ts
+++ b/apps/edr-freight-api/src/modules/last-mile/last-mile-invoice.service.ts
@@ -54,6 +54,15 @@ export class LastMileInvoiceService {
       return null;
     }
 
+    // numeric columns come back as strings — coerce before billing.
+    const totalAmount = Number(record.remainingPayment) || 0;
+    if (!Number.isFinite(totalAmount) || totalAmount <= 0) {
+      this.logger.warn(
+        `Skipping invoice for last-mile record ${record.id}: no remaining payment.`,
+      );
+      return null;
+    }
+
     // Generate invoice with remainingPayment as totalAmount
     const input: GenerateInvoiceInput = {
       source: 'last_mile' as Freight.InvoiceSource,
@@ -61,17 +70,17 @@ export class LastMileInvoiceService {
       type: 'DELIVERY_FEE',
       companyId: lm.booking!.companyId,
       companyProfileId: lm.booking!.companyProfileId || '',
-      currency: 'ETB',
+      currency: lm.booking!.paymentCurrency || 'ETB',
       lines: [
         {
           chargeType: 'DELIVERY',
           description: 'Last-mile delivery',
           quantity: 1,
-          unitRate: record.remainingPayment || 0,
-          amount: record.remainingPayment || 0,
+          unitRate: totalAmount,
+          amount: totalAmount,
         },
       ],
-      totalAmount: record.remainingPayment || 0,
+      totalAmount,
     };
 
     return this.billing.generateInvoice(input);
diff --git a/apps/edr-freight-api/src/modules/last-mile/last-mile.controller.ts b/apps/edr-freight-api/src/modules/last-mile/last-mile.controller.ts
index 88a96e6c2..2931a1f85 100644
--- a/apps/edr-freight-api/src/modules/last-mile/last-mile.controller.ts
+++ b/apps/edr-freight-api/src/modules/last-mile/last-mile.controller.ts
@@ -1,4 +1,5 @@
 import {
+  BadRequestException,
   Body,
   Controller,
   Delete,
@@ -17,13 +18,11 @@ import { TrainSchedulingManage, TrainSchedulingView } from '../../common/booking
 
 import { CreateLastMileDto } from './dto/create-last-mile.dto';
 import { UpdateLastMileDto } from './dto/update-last-mile.dto';
-import { AllocateLastMileContainersDto } from './dto/allocate-containers.dto';
+import { SetVehiclesDto } from './dto/set-vehicles.dto';
+import { SetDistancesDto } from './dto/set-distances.dto';
 import { LastMileStatus } from './entities/last-mile.entity';
 import { LastMileService } from './last-mile.service';
 import { LastMileInvoiceService } from './last-mile-invoice.service';
-import { Freight } from '@edr/types';
-import { BillingService } from '../billing/billing.service';
-import { BookingsService } from '../bookings/bookings.service';
 
 @ApiTags('last-mile')
 @ApiBearerAuth()
@@ -33,8 +32,6 @@ export class LastMileController {
   constructor(
     private readonly lastMileService: LastMileService,
     private readonly lastMileInvoiceService: LastMileInvoiceService,
-    private readonly billingService: BillingService,
-    private readonly bookingsService: BookingsService
   ) {}
 
   @Get()
@@ -83,39 +80,9 @@ export class LastMileController {
   @TrainSchedulingManage()
   @ApiOperation({ summary: 'Update a last-mile leg' })
   async update(@Param('id', ParseUUIDPipe) id: string, @Body() dto: UpdateLastMileDto) {
-    const record = await this.lastMileService.update(id, dto);
-    // Auto-generate invoice if distance or payment was updated
-      const booking  = await this.bookingsService.findById(record.bookingId);
-        if (dto.exactKm !== undefined || dto.exactKm != record.exactKm || dto.remainingPayment !== undefined || dto.remainingPayment !== record.remainingPayment) {
-        await this.billingService.generateInvoice({
-          source: Freight.InvoiceSource.LastMile,
-          sourceId: record.id,
-          type: "LAST_MILE",
-          companyId: booking.companyId,
-          companyProfileId: booking.companyProfileId,
-          currency: "ETB",
-    
-          lines: [
-            {
-              chargeType: "LAST_MILE",
-              description: "Last Mile Transportation Service",
-              quantity: 1,
-              unitRate: record.remainingPayment,
-              amount: record.remainingPayment,
-              currency: "ETB",
-            },
-          ],
-    
-          subtotalAmount: record.remainingPayment,
-          taxAmount: 0, // Replace if VAT/tax applies
-          totalAmount: record.remainingPayment,
-    
-          dueInDays: 7,
-          status: Freight.InvoiceStatus.Pending,
-        });
-         await this.lastMileInvoiceService.ensureInvoiceFor(record);
-        }
-    return record;
+    // No invoice side-effects here — invoices are generated only via the
+    // explicit POST :id/invoice endpoint (the "Generate Invoice" action).
+    return this.lastMileService.update(id, dto);
   }
 
   @Delete(':id')
@@ -126,13 +93,38 @@ export class LastMileController {
     return this.lastMileService.remove(id);
   }
 
-  @Post(':id/allocate-containers')
+
+  @Post(':id/vehicles')
   @TrainSchedulingManage()
-  @ApiOperation({ summary: 'Allocate containers to vehicles' })
-  async allocateContainers(
+  @ApiOperation({ summary: 'Set the vehicles assigned to a last-mile delivery (multi-truck)' })
+  async setVehicles(
     @Param('id', ParseUUIDPipe) id: string,
-    @Body() dto: AllocateLastMileContainersDto,
+    @Body() dto: SetVehiclesDto,
   ) {
-    return this.lastMileService.allocateContainers(id, dto.allocations);
+    return this.lastMileService.setVehicles(id, dto.vehicles);
+  }
+
+  @Post(':id/distances')
+  @TrainSchedulingManage()
+  @ApiOperation({ summary: 'Set per-vehicle actual distances (does not generate an invoice)' })
+  async setDistances(
+    @Param('id', ParseUUIDPipe) id: string,
+    @Body() dto: SetDistancesDto,
+  ) {
+    return this.lastMileService.setDistances(id, dto.distances, dto.remainingPayment);
+  }
+
+  @Post(':id/invoice')
+  @TrainSchedulingManage()
+  @ApiOperation({ summary: 'Generate the delivery-fee invoice for a last-mile leg' })
+  async generateInvoice(@Param('id', ParseUUIDPipe) id: string) {
+    const record = await this.lastMileService.findById(id);
+    const invoice = await this.lastMileInvoiceService.ensureInvoiceFor(record);
+    if (!invoice) {
+      throw new BadRequestException(
+        'Cannot generate invoice: the leg has no billable amount. Add distance and ensure a LAST_MILE rate is configured, and the booking has a company.',
+      );
+    }
+    return invoice;
   }
 }
diff --git a/apps/edr-freight-api/src/modules/last-mile/last-mile.module.ts b/apps/edr-freight-api/src/modules/last-mile/last-mile.module.ts
index 32b688069..e639e4dfd 100644
--- a/apps/edr-freight-api/src/modules/last-mile/last-mile.module.ts
+++ b/apps/edr-freight-api/src/modules/last-mile/last-mile.module.ts
@@ -8,6 +8,7 @@ import { NotificationsModule } from '../notifications/notifications.module';
 import { VehiclesModule } from '../vehicles/vehicles.module';
 import { LastMile } from './entities/last-mile.entity';
 import { LastMileContainerAllocation } from './entities/last-mile-container-allocation.entity';
+import { LastMileVehicleAssignment } from './entities/last-mile-vehicle-assignment.entity';
 import { LastMileController } from './last-mile.controller';
 import { LastMileInvoiceService } from './last-mile-invoice.service';
 import { LastMileRepository } from './last-mile.repository';
@@ -15,7 +16,7 @@ import { LastMileService } from './last-mile.service';
 
 @Module({
   imports: [
-    TypeOrmModule.forFeature([LastMile, LastMileContainerAllocation]),
+    TypeOrmModule.forFeature([LastMile, LastMileContainerAllocation, LastMileVehicleAssignment]),
     BillingModule,
     forwardRef(() => BookingsModule),
     VehiclesModule,
diff --git a/apps/edr-freight-api/src/modules/last-mile/last-mile.service.ts b/apps/edr-freight-api/src/modules/last-mile/last-mile.service.ts
index 69eec29ae..22f25a6aa 100644
--- a/apps/edr-freight-api/src/modules/last-mile/last-mile.service.ts
+++ b/apps/edr-freight-api/src/modules/last-mile/last-mile.service.ts
@@ -1,17 +1,21 @@
-import { Injectable, Logger, NotFoundException } from '@nestjs/common';
-import { DataSource, FindOptionsWhere } from 'typeorm';
+import { BadRequestException, Injectable, Logger, NotFoundException } from '@nestjs/common';
+import { DataSource, FindOptionsWhere, In, IsNull, Not } from 'typeorm';
 
 import { BookingsRepository } from '../bookings/bookings.repository';
 import { DriversService } from '../drivers/drivers.service';
 import { SmsClientService } from '../notifications/sms-client.service';
 import { VehiclesService } from '../vehicles/vehicles.service';
+import { VehicleAvailability } from '../vehicles/entities/vehicle.entity';
 import { CreateLastMileDto } from './dto/create-last-mile.dto';
 import { UpdateLastMileDto } from './dto/update-last-mile.dto';
 import { LastMile, LastMileStatus } from './entities/last-mile.entity';
 import { LastMileContainerAllocation } from './entities/last-mile-container-allocation.entity';
+import { LastMileVehicleAssignment } from './entities/last-mile-vehicle-assignment.entity';
 import { LastMileRepository } from './last-mile.repository';
-import { InvoiceEventPayload } from '../billing/billing.service';
+import { BillingService, InvoiceEventPayload } from '../billing/billing.service';
 import { OnEvent } from '@nestjs/event-emitter';
+import { FleetHistoryService } from '../fleet-history/fleet-history.service';
+import { FleetEventType } from '../fleet-history/entities/fleet-event.entity';
 
 type LastMileListFilter = {
   status?: LastMileStatus;
@@ -41,8 +45,77 @@ export class LastMileService {
     private readonly driversService: DriversService,
     private readonly smsClient: SmsClientService,
     private readonly dataSource: DataSource,
+    private readonly history: FleetHistoryService,
+    private readonly billing: BillingService,
   ) {}
 
+  /** Attach real invoice info (number/status) to records so the UI can show an
+   *  invoice link only when one actually exists — NOT merely because distance
+   *  was entered. Batched to avoid N+1. */
+  private async attachInvoices(records: LastMile[]): Promise<void> {
+    const invoices = await this.billing.findBySourceIds(
+      'last_mile',
+      records.map((r) => r.id),
+    );
+    const byId = new Map<string, { id: string; number: string; status: string }>();
+    for (const inv of invoices) {
+      if (!byId.has(inv.sourceId)) {
+        byId.set(inv.sourceId, { id: inv.id, number: inv.invoiceNumber, status: String(inv.status) });
+      }
+    }
+    for (const r of records) {
+      (r as LastMile & { invoice?: unknown }).invoice = byId.get(r.id) ?? null;
+    }
+  }
+
+  /** Resolve a vehicle's driver + human labels, for stamping mile events onto
+   *  the driver's timeline and naming the vehicle. Best-effort — never throws. */
+  private async vehicleInfo(
+    vehicleId?: string | null,
+  ): Promise<{ driverId: string | null; plate: string | null; driverName: string | null }> {
+    if (!vehicleId) return { driverId: null, plate: null, driverName: null };
+    try {
+      const v = await this.vehiclesService.findById(vehicleId);
+      return {
+        driverId: v.assignedDriverId ?? null,
+        plate: v.plateNumber ?? v.code ?? null,
+        driverName: v.assignedDriverName ?? null,
+      };
+    } catch {
+      return { driverId: null, plate: null, driverName: null };
+    }
+  }
+
+  /** A leg counts as having a vehicle if it has a direct assignment or at least
+   *  one container allocation carrying a vehicle. Gates the IN_TRANSIT move. */
+  private async hasAssignedVehicle(
+    recordId: string,
+    directVehicleId?: string | null,
+  ): Promise<boolean> {
+    if (directVehicleId) return true;
+    const count = await this.dataSource.manager.count(LastMileContainerAllocation, {
+      where: { lastMileId: recordId, vehicleId: Not(IsNull()) },
+    });
+    return count > 0;
+  }
+
+  /** Human booking reference for a last-mile record, for the history timeline.
+   *  Uses the already-loaded relation when present, else looks it up. */
+  private async resolveBookingRef(
+    record: LastMile,
+  ): Promise<string | null> {
+    const loaded = (record as LastMile & { booking?: { reference?: string } })
+      .booking?.reference;
+    if (loaded) return loaded;
+    if (!record.bookingId) return null;
+    try {
+      const booking = await this.bookingsRepository.findById(record.bookingId);
+      return (booking as { reference?: string } | null)?.reference ?? null;
+    } catch {
+      return null;
+    }
+  }
+
   async acceptBooking(bookingReference: string): Promise<LastMile | null> {
     const booking = await this.bookingsRepository.findByReference(bookingReference);
 
@@ -97,14 +170,17 @@ export class LastMileService {
     const [data, total] = await this.lastMileRepository.findAndCount({
       where,
       relations: {
-        booking: { company: true, serviceType: true, originYard: true, destinationYard: true, cargoType: true },
+        booking: { company: true, serviceType: true, originYard: true, destinationYard: true, cargoType: true, bookingContainers: { containerType: true, units: true } },
         vehicle: true,
+        vehicleAssignments: { vehicle: true },
       },
       order: { [sortBy]: sortOrder },
       skip: (page - 1) * pageSize,
       take: pageSize,
     });
 
+    await this.attachInvoices(data);
+
     return {
       data,
       meta: {
@@ -119,8 +195,9 @@ export class LastMileService {
   async findById(id: string): Promise<LastMile> {
     const record = await this.lastMileRepository.findById(id, {
       relations: {
-        booking: { company: true, serviceType: true, originYard: true, destinationYard: true, cargoType: true },
+        booking: { company: true, serviceType: true, originYard: true, destinationYard: true, cargoType: true, bookingContainers: { containerType: true, units: true } },
         vehicle: true,
+        vehicleAssignments: { vehicle: true },
       },
     });
 
@@ -128,11 +205,13 @@ export class LastMileService {
       throw new NotFoundException(`Last-mile record ${id} not found`);
     }
 
+    await this.attachInvoices([record]);
+
     return record;
   }
 
   async create(dto: CreateLastMileDto): Promise<LastMile> {
-    return this.lastMileRepository.create({
+    const record = await this.lastMileRepository.create({
       bookingId: dto.bookingId,
       status: dto.status ?? 'READY_TO_TRANSIT',
       advancedPayment: dto.advancedPayment ?? 0,
@@ -142,16 +221,38 @@ export class LastMileService {
       vehicleId: dto.vehicleId ?? null,
       paid: (dto as any).paid ?? false,
     });
+
+    if (dto.vehicleId) {
+      await this.vehiclesService.setAvailability(dto.vehicleId, VehicleAvailability.BUSY);
+      const info = await this.vehicleInfo(dto.vehicleId);
+      await this.history.record({
+        eventType: FleetEventType.MILE_VEHICLE_ASSIGNED,
+        vehicleId: dto.vehicleId,
+        lastMileId: record.id,
+        driverId: info.driverId,
+        label: record.status,
+        metadata: {
+          mile: 'LAST',
+          bookingRef: await this.resolveBookingRef(record),
+          vehiclePlate: info.plate,
+          driverName: info.driverName,
+        },
+      });
+    }
+
+    return record;
   }
 
-  @OnEvent("lastmile.invoice.paid")
+  @OnEvent("last_mile.invoice.paid")
   async onBookingInvoicePaid(payload: InvoiceEventPayload): Promise<void> {
     try {
-      await this.lastMileRepository.update(payload.sourceId, { paid: true } as any);
-      this.logger.log(`Marked last-mile record ${payload.sourceId} as paid (invoice ${payload.invoiceId})`);
+      // Invoice paid → the delivery is complete. Route through update() so it
+      // also frees the trucks + records history (same as "Mark Delivered").
+      await this.update(payload.sourceId, { status: 'DELIVERED', paid: true } as unknown as UpdateLastMileDto);
+      this.logger.log(`Last-mile ${payload.sourceId} marked DELIVERED on invoice ${payload.invoiceId} payment`);
     } catch (err) {
       this.logger.error(
-        `Failed to update last-mile payment status for record ${payload.sourceId}: ${String(err)}`,
+        `Failed to deliver last-mile ${payload.sourceId} on payment: ${String(err)}`,
       );
     }
   }
@@ -159,6 +260,18 @@ export class LastMileService {
   async update(id: string, dto: UpdateLastMileDto): Promise<LastMile> {
     const existing = await this.findById(id);
 
+    // A leg can only go IN_TRANSIT once a vehicle is assigned (allowing a vehicle
+    // assigned in this same request).
+    if (dto.status === 'IN_TRANSIT' && existing.status !== 'IN_TRANSIT') {
+      const vehicleId =
+        dto.vehicleId !== undefined ? dto.vehicleId : existing.vehicleId;
+      if (!(await this.hasAssignedVehicle(id, vehicleId))) {
+        throw new BadRequestException(
+          'Assign a vehicle before marking this last-mile leg in transit',
+        );
+      }
+    }
+
     const dtoAny = dto as any;
     const updated = await this.lastMileRepository.update(id, {
       ...(dto.bookingId !== undefined ? { bookingId: dto.bookingId } : {}),
@@ -180,9 +293,231 @@ export class LastMileService {
       void this.notifyDriverAssignment(dto.vehicleId, existing);
     }
 
+    // Audit the mile↔vehicle (re)assignment on both vehicle and driver lines.
+    const bookingRef = await this.resolveBookingRef(existing);
+    if (dto.vehicleId !== undefined && dto.vehicleId !== existing.vehicleId) {
+      // Keep vehicle availability in sync: new vehicle goes BUSY, replaced one
+      // is freed if no other active trip still holds it.
+      if (dto.vehicleId) {
+        await this.vehiclesService.setAvailability(dto.vehicleId, VehicleAvailability.BUSY);
+      }
+      if (existing.vehicleId) {
+        await this.vehiclesService.releaseIfUnused([existing.vehicleId]);
+      }
+      if (existing.vehicleId) {
+        const info = await this.vehicleInfo(existing.vehicleId);
+        await this.history.record({
+          eventType: FleetEventType.MILE_VEHICLE_RELEASED,
+          vehicleId: existing.vehicleId,
+          lastMileId: id,
+          driverId: info.driverId,
+          metadata: {
+            mile: 'LAST',
+            bookingRef,
+            vehiclePlate: info.plate,
+            driverName: info.driverName,
+          },
+        });
+      }
+      if (dto.vehicleId) {
+        const info = await this.vehicleInfo(dto.vehicleId);
+        await this.history.record({
+          eventType: FleetEventType.MILE_VEHICLE_ASSIGNED,
+          vehicleId: dto.vehicleId,
+          lastMileId: id,
+          driverId: info.driverId,
+          label: updated.status,
+          metadata: {
+            mile: 'LAST',
+            bookingRef,
+            vehiclePlate: info.plate,
+            driverName: info.driverName,
+          },
+        });
+      }
+    }
+
+    if (dto.status !== undefined && dto.status !== existing.status) {
+      const vehicleId = updated.vehicleId ?? existing.vehicleId ?? null;
+      const info = await this.vehicleInfo(vehicleId);
+      await this.history.record({
+        eventType: FleetEventType.MILE_STATUS_CHANGED,
+        lastMileId: id,
+        vehicleId,
+        driverId: info.driverId,
+        fromValue: existing.status,
+        toValue: dto.status,
+        metadata: {
+          mile: 'LAST',
+          bookingRef,
+          vehiclePlate: info.plate,
+          driverName: info.driverName,
+        },
+      });
+    }
+
+    // Delivery finished — free the vehicles this trip was holding.
+    if (dto.status === 'DELIVERED' && existing.status !== 'DELIVERED') {
+      await this.releaseVehicles(updated);
+    }
+
     return updated;
   }
 
+  /**
+   * Free every vehicle held by this record — junction assignments, the legacy
+   * direct vehicle, and container allocations — unless still used by another
+   * active trip.
+   */
+  private async releaseVehicles(record: LastMile): Promise<void> {
+    const [assignments, recordAllocations] = await Promise.all([
+      this.dataSource.manager.find(LastMileVehicleAssignment, {
+        where: { lastMileId: record.id },
+      }),
+      this.dataSource.manager.find(LastMileContainerAllocation, {
+        where: { lastMileId: record.id },
+      }),
+    ]);
+    const vehicleIds = [
+      ...new Set(
+        [
+          ...assignments.map((a) => a.vehicleId),
+          ...recordAllocations.map((a) => a.vehicleId),
+          record.vehicleId ?? null,
+        ].filter((id): id is string => Boolean(id)),
+      ),
+    ];
+    await this.vehiclesService.releaseIfUnused(vehicleIds);
+  }
+
+  /**
+   * Replace the full set of vehicles serving a last-mile delivery (multi-truck).
+   * Diffs against the current junction rows, syncing availability + audit history
+   * for each added/removed vehicle. The first vehicle is mirrored onto the legacy
+   * `vehicleId` column for back-compat with single-vehicle readers.
+   */
+  async setVehicles(
+    id: string,
+    inputs: Array<{ vehicleId: string; containerNumber?: string | null }>,
+  ): Promise<LastMile> {
+    const existing = await this.findById(id);
+    // Dedupe by vehicleId, keeping the container number; preserve order.
+    const desiredMap = new Map<string, string | null>();
+    for (const inp of inputs) {
+      if (inp.vehicleId) desiredMap.set(inp.vehicleId, inp.containerNumber ?? null);
+    }
+    const desired = [...desiredMap.keys()];
+    const desiredSet = new Set(desired);
+
+    const manager = this.dataSource.manager;
+    const current = await manager.find(LastMileVehicleAssignment, {
+      where: { lastMileId: id },
+    });
+    const junctionSet = new Set(current.map((a) => a.vehicleId));
+    // Fold the legacy vehicleId into the release set — a vehicle assigned via the
+    // old single-vehicle path has no junction row but must still be freed.
+    const releaseIds = [...new Set(
+      current.map((a) => a.vehicleId).concat(existing.vehicleId ? [existing.vehicleId] : []),
+    )];
+    const added = desired.filter((v) => !junctionSet.has(v));
+    const removed = releaseIds.filter((v) => !desiredSet.has(v));
+    // Vehicles that stay but whose container number changed.
+    const changed = current.filter(
+      (a) =>
+        desiredMap.has(a.vehicleId) &&
+        (a.containerNumber ?? null) !== (desiredMap.get(a.vehicleId) ?? null),
+    );
+
+    await this.dataSource.transaction(async (tx) => {
+      if (removed.length) {
+        await tx.delete(LastMileVehicleAssignment, {
+          lastMileId: id,
+          vehicleId: In(removed),
+        });
+      }
+      for (const vehicleId of added) {
+        await tx.insert(LastMileVehicleAssignment, {
+          lastMileId: id,
+          vehicleId,
+          containerNumber: desiredMap.get(vehicleId) ?? null,
+        });
+      }
+      for (const row of changed) {
+        await tx.update(
+          LastMileVehicleAssignment,
+          { lastMileId: id, vehicleId: row.vehicleId },
+          { containerNumber: desiredMap.get(row.vehicleId) ?? null },
+        );
+      }
+    });
+
+    // Legacy primary vehicle = first of the set (null when cleared).
+    await this.lastMileRepository.update(id, { vehicleId: desired[0] ?? null } as any);
+
+    const bookingRef = await this.resolveBookingRef(existing);
+    for (const vehicleId of added) {
+      await this.vehiclesService.setAvailability(vehicleId, VehicleAvailability.BUSY);
+      void this.notifyDriverAssignment(vehicleId, existing);
+      const info = await this.vehicleInfo(vehicleId);
+      await this.history.record({
+        eventType: FleetEventType.MILE_VEHICLE_ASSIGNED,
+        vehicleId,
+        lastMileId: id,
+        driverId: info.driverId,
+        label: existing.status,
+        metadata: { mile: 'LAST', bookingRef, vehiclePlate: info.plate, driverName: info.driverName },
+      });
+    }
+    for (const vehicleId of removed) {
+      await this.vehiclesService.releaseIfUnused([vehicleId]);
+      const info = await this.vehicleInfo(vehicleId);
+      await this.history.record({
+        eventType: FleetEventType.MILE_VEHICLE_RELEASED,
+        vehicleId,
+        lastMileId: id,
+        driverId: info.driverId,
+        metadata: { mile: 'LAST', bookingRef, vehiclePlate: info.plate, driverName: info.driverName },
+      });
+    }
+
+    return this.findById(id);
+  }
+
+  /**
+   * Record each truck's actual distance. The delivery total (exact_km) is their
+   * sum and drives billing; `remainingPayment` (total km × rate) is recomputed
+   * client-side. Does NOT generate an invoice — that's a separate explicit step.
+   */
+  async setDistances(
+    id: string,
+    distances: Array<{ vehicleId: string; distanceKm: number }>,
+    remainingPayment?: number,
+  ): Promise<LastMile> {
+    await this.findById(id);
+
+    // Distances are locked once the invoice exists.
+    const invoices = await this.billing.findBySourceIds('last_mile', [id]);
+    if (invoices.length) {
+      throw new BadRequestException(
+        'Distances cannot be changed after the invoice is generated',
+      );
+    }
+
+    for (const d of distances) {
+      await this.dataSource.manager.update(
+        LastMileVehicleAssignment,
+        { lastMileId: id, vehicleId: d.vehicleId },
+        { distanceKm: d.distanceKm },
+      );
+    }
+    const total = distances.reduce((s, d) => s + (Number(d.distanceKm) || 0), 0);
+    await this.lastMileRepository.update(id, {
+      exactKm: total,
+      ...(remainingPayment != null ? { remainingPayment } : {}),
+    } as any);
+    return this.findById(id);
+  }
+
   private async notifyDriverAssignment(vehicleId: string, record: LastMile): Promise<void> {
     try {
       const vehicle = await this.vehiclesService.findById(vehicleId);
@@ -223,38 +558,54 @@ export class LastMileService {
   }
 
   async remove(id: string): Promise<void> {
-    await this.findById(id);
-    await this.lastMileRepository.softDelete(id);
-  }
+    const existing = await this.findById(id);
 
-  async allocateContainers(
-    lastMileId: string,
-    allocations: Array<{ containerId: string; vehicleId: string }>,
-  ) {
-    const lastMile = await this.findById(lastMileId);
-    if (!lastMile) {
-      throw new NotFoundException(`Last-mile record ${lastMileId} not found`);
+    // Can't delete once billed.
+    const invoices = await this.billing.findBySourceIds('last_mile', [id]);
+    if (invoices.length) {
+      throw new BadRequestException(
+        'Cannot delete a last-mile delivery after its invoice is generated',
+      );
     }
 
-    await this.dataSource.transaction(async (manager) => {
-      for (const allocation of allocations) {
-        await manager.delete(LastMileContainerAllocation, {
-          lastMileId,
-          containerId: allocation.containerId,
-        });
-        await manager.insert(LastMileContainerAllocation, {
-          lastMileId,
-          containerId: allocation.containerId,
-          vehicleId: allocation.vehicleId,
-          containerType: 'CONTAINER',
-          quantity: 1,
+    // Every vehicle this delivery holds — junction + legacy + container rows.
+    const assignments = await this.dataSource.manager.find(LastMileVehicleAssignment, {
+      where: { lastMileId: id },
+    });
+    const allocations = await this.dataSource.manager.find(LastMileContainerAllocation, {
+      where: { lastMileId: id },
+    });
+    const vehicleIds = [
+      ...new Set(
+        [
+          ...assignments.map((a) => a.vehicleId),
+          ...allocations.map((a) => a.vehicleId),
+          existing.vehicleId ?? null,
+        ].filter((v): v is string => Boolean(v)),
+      ),
+    ];
+
+    await this.lastMileRepository.softDelete(id);
+    if (assignments.length) {
+      await this.dataSource.manager.softDelete(LastMileVehicleAssignment, { lastMileId: id });
+    }
+
+    // Free every vehicle no longer held by another active trip (releaseIfUnused
+    // ignores this now soft-deleted record) and audit the release.
+    if (vehicleIds.length) {
+      await this.vehiclesService.releaseIfUnused(vehicleIds);
+      const bookingRef = await this.resolveBookingRef(existing);
+      for (const vehicleId of vehicleIds) {
+        const info = await this.vehicleInfo(vehicleId);
+        await this.history.record({
+          eventType: FleetEventType.MILE_VEHICLE_RELEASED,
+          vehicleId,
+          lastMileId: id,
+          driverId: info.driverId,
+          metadata: { mile: 'LAST', bookingRef, vehiclePlate: info.plate, driverName: info.driverName },
         });
       }
-    });
-
-    return {
-      success: true,
-      allocated: allocations.length,
-    };
+    }
   }
+
 }
diff --git a/apps/edr-freight-api/src/modules/notifications/notifications.module.ts b/apps/edr-freight-api/src/modules/notifications/notifications.module.ts
index 4e56c8b70..16d598eb0 100644
--- a/apps/edr-freight-api/src/modules/notifications/notifications.module.ts
+++ b/apps/edr-freight-api/src/modules/notifications/notifications.module.ts
@@ -8,6 +8,11 @@ import { EmailClientService } from "./email-client.service";
 import { EmailNotificationStrategy } from "./strategies/notification.email.strategy";
 import { SmsNotificationStrategy } from "./strategies/notification.sms.strategy";
 
+// Fall back to a sane broker URL so an unset RABBITMQ_URL can't produce
+// `urls: [undefined]` (which crashes amqp-connection-manager on 'heartbeat').
+const RABBITMQ_URL =
+  process.env.RABBITMQ_URL ?? process.env.PAYMENT_RABBITMQ_URL ?? "amqp://localhost:5672";
+
 @Module({
   imports: [
     ConfigModule,
@@ -16,7 +21,7 @@ import { SmsNotificationStrategy } from "./strategies/notification.sms.strategy"
         name: "SMS_SERVICE",
         transport: Transport.RMQ,
         options: {
-          urls: [process.env.RABBITMQ_URL as string],
+          urls: [RABBITMQ_URL],
           queue: process.env.SMS_QUEUE ?? "sms_queue",
           queueOptions: { durable: true },
         },
@@ -25,7 +30,7 @@ import { SmsNotificationStrategy } from "./strategies/notification.sms.strategy"
         name: "EMAIL_SERVICE",
         transport: Transport.RMQ,
         options: {
-          urls: [process.env.RABBITMQ_URL as string],
+          urls: [RABBITMQ_URL],
           queue: process.env.EMAIL_QUEUE ?? "email_queue",
           queueOptions: { durable: true },
         },
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 d773ebe1f..5b8a3ddca 100644
--- a/apps/edr-freight-api/src/modules/payment/payment.service.ts
+++ b/apps/edr-freight-api/src/modules/payment/payment.service.ts
@@ -479,7 +479,7 @@ export class PaymentService {
     alreadyFinalized?: boolean;
     reason?: string;
   }> {
-    console.log(`Received payment event: ${JSON.stringify(event)}`);
+    this.logger.log(`Received payment event: ${JSON.stringify(event)}`);
     if (event.eventType === "payment.succeeded") {
       const intent = await this.paymentRepo.findOneBy({
         refId: event.referenceId,
@@ -490,13 +490,12 @@ export class PaymentService {
           reason: `No local intent for reference ${event.referenceId}`,
         };
       }
-      console.log(`Processing payment succeeded event for intent: }`, intent);
       const { alreadyFinalized } = await this.markIntentSucceeded(intent.id, {
         providerTxnId: event.providerTxnId,
         paidAt: event.paidAt ? new Date(event.paidAt) : undefined,
         notify: true,
       });
-      console.log(
+      this.logger.log(
         `Payment finalized for intent ${intent.id}, alreadyFinalized: ${alreadyFinalized}`,
       );
 
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 f30ebd501..76db7fa78 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
@@ -21,6 +21,14 @@ export class CreateCargoTypeDto {
   @IsUUID()
   parentGroupId?: string;
 
+  @ApiPropertyOptional({
+    description:
+      'Wagon type used to carry this (bulk) cargo. Drives train scheduling wagon-type resolution; required for bulk commodities that are scheduled.',
+  })
+  @IsOptional()
+  @IsUUID('4')
+  wagonTypeId?: string | null;
+
   @ApiPropertyOptional({ default: false })
   @IsOptional()
   @IsBoolean()
diff --git a/apps/edr-freight-api/src/modules/rule-engine/dto/create-container-type.dto.ts b/apps/edr-freight-api/src/modules/rule-engine/dto/create-container-type.dto.ts
index 52cfe274b..e0baf7251 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/dto/create-container-type.dto.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/dto/create-container-type.dto.ts
@@ -30,6 +30,14 @@ export class CreateContainerTypeDto {
   @IsBoolean()
   isOpenTop?: boolean;
 
+  @ApiPropertyOptional({
+    description:
+      'Wagon type used to carry this container. Drives train scheduling wagon-type resolution; required when this container type is scheduled.',
+  })
+  @IsOptional()
+  @IsUUID('4')
+  wagonTypeId?: string | null;
+
   @ApiPropertyOptional({ default: true })
   @IsOptional()
   @IsBoolean()
diff --git a/apps/edr-freight-api/src/modules/rule-engine/dto/create-rate.dto.ts b/apps/edr-freight-api/src/modules/rule-engine/dto/create-rate.dto.ts
index 995718135..9a4cd642b 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/dto/create-rate.dto.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/dto/create-rate.dto.ts
@@ -1,6 +1,6 @@
 import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
 import { Transform } from 'class-transformer';
-import { IsDateString, IsIn, IsNumber, IsOptional, IsString, IsUUID, MaxLength, Min } from 'class-validator';
+import { IsIn, IsNumber, IsOptional, IsString, IsUUID, MaxLength, Min } from 'class-validator';
 import {
   RATE_APPLIES_TO,
   RATE_TRIGGERS,
@@ -51,15 +51,6 @@ export class CreateRateDto {
   @ApiProperty({ enum: RATE_UNITS, description: 'Unit basis for the rate' })
   @IsIn([...RATE_UNITS])
   rateUnit!: string;
-
-  @ApiProperty({ description: 'Date from which this rate is effective (ISO date)', example: '2025-01-01' })
-  @IsDateString()
-  effectiveFrom!: string;
-
-  @ApiPropertyOptional({ description: 'Date when this rate expires. Null = currently active', example: '2025-12-31' })
-  @IsOptional()
-  @IsDateString()
-  effectiveTo?: string;
 }
 
 export class SubmitRateForApprovalDto {
diff --git a/apps/edr-freight-api/src/modules/rule-engine/dto/create-weight-limit-rule.dto.ts b/apps/edr-freight-api/src/modules/rule-engine/dto/create-weight-limit-rule.dto.ts
index 6be37214b..d60a56944 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/dto/create-weight-limit-rule.dto.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/dto/create-weight-limit-rule.dto.ts
@@ -1,6 +1,6 @@
 import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
 import { Transform } from 'class-transformer';
-import { IsDateString, IsIn, IsNumber, IsOptional, IsUUID, Min } from 'class-validator';
+import { IsIn, IsNumber, IsOptional, IsUUID, Min } from 'class-validator';
 
 const TRADE_DIRECTIONS = ['IMPORT', 'EXPORT', 'BOTH', 'DOMESTIC'] as const;
 
@@ -22,12 +22,14 @@ export class CreateWeightLimitRuleDto {
   @Transform(({ value }) => Number(value))
   maxVgmTons!: number;
 
-  @ApiProperty({ description: 'Date from which this rule is active (ISO date)', example: '2024-01-01' })
-  @IsDateString()
-  effectiveFrom!: string;
-
-  @ApiPropertyOptional({ description: 'Date when this rule expires (ISO date). Null = currently active', example: '2025-12-31' })
+  @ApiPropertyOptional({
+    description:
+      'Hard per-unit weight ceiling in tons — above this the booking cannot be created. Null/omitted = no ceiling.',
+    minimum: 0,
+  })
   @IsOptional()
-  @IsDateString()
-  effectiveTo?: string;
+  @IsNumber()
+  @Min(0)
+  @Transform(({ value }) => (value === null || value === undefined || value === '' ? null : Number(value)))
+  maxCapacityTons?: number | null;
 }
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 c8ac35f25..ac8a2ea24 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/entities/cargo-type.entity.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/entities/cargo-type.entity.ts
@@ -1,11 +1,13 @@
 import { BaseEntity } from '@edr/api-common';
 import { CargoUnitOfMeasure } from '@edr/types';
 import { Column, Entity, Index, JoinColumn, ManyToOne, OneToMany } from 'typeorm';
+import { WagonType } from '../../wagon-types/entities/wagon-type.entity';
 
 @Entity({ schema: 'freight', name: 'cargo_types' })
 @Index(['isActive'])
 @Index(['displayOrder'])
 @Index(['parentGroupId'])
+@Index(['wagonTypeId'])
 @Index(['code'])
 export class CargoType extends BaseEntity {
   @Column({ name: 'code', type: 'varchar', length: 50, unique: true, default: '' })
@@ -25,6 +27,19 @@ export class CargoType extends BaseEntity {
   @Column({ name: 'unit_of_measure', type: 'varchar', length: 16, nullable: true })
   unitOfMeasure?: CargoUnitOfMeasure | null;
 
+  /**
+   * Wagon type that carries this (bulk) cargo. Replaces the former hardcoded
+   * cargo-code → wagon-code map: train scheduling resolves the bulk wagon type
+   * through this FK. Nullable — grouping rows and container/legacy cargo never
+   * carry it; scheduling throws if a scheduled bulk cargo type leaves it unset.
+   */
+  @Column({ name: 'wagon_type_id', type: 'uuid', nullable: true })
+  wagonTypeId?: string | null;
+
+  @ManyToOne(() => WagonType, { nullable: true, onDelete: 'RESTRICT' })
+  @JoinColumn({ name: 'wagon_type_id' })
+  wagonType?: WagonType | null;
+
   @Column({ name: 'requires_director_approval', type: 'boolean', default: false })
   requiresDirectorApproval!: boolean;
 
diff --git a/apps/edr-freight-api/src/modules/rule-engine/entities/container-type.entity.ts b/apps/edr-freight-api/src/modules/rule-engine/entities/container-type.entity.ts
index e03078c19..f7cbeed99 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/entities/container-type.entity.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/entities/container-type.entity.ts
@@ -1,10 +1,12 @@
 import { BaseEntity } from '@edr/api-common';
-import { Column, Entity, Index, OneToMany } from 'typeorm';
+import { Column, Entity, Index, JoinColumn, ManyToOne, OneToMany } from 'typeorm';
 import { WeightLimitRule } from './weight-limit-rule.entity';
+import { WagonType } from '../../wagon-types/entities/wagon-type.entity';
 
 @Entity({ schema: 'freight', name: 'container_types' })
 @Index(['code'])
 @Index(['isActive'])
+@Index(['wagonTypeId'])
 export class ContainerType extends BaseEntity {
   @Column({ name: 'code', type: 'varchar', length: 20, unique: true })
   code!: string;
@@ -24,6 +26,19 @@ export class ContainerType extends BaseEntity {
   @Column({ name: 'is_open_top', type: 'boolean', default: false, nullable: true })
   isOpenTop!: boolean;
 
+  /**
+   * Wagon type that carries this container. Replaces the former hardcoded
+   * container wagon-code default (NW5): train scheduling resolves the container
+   * wagon type through this FK. Nullable; scheduling throws if a scheduled
+   * container type leaves it unset.
+   */
+  @Column({ name: 'wagon_type_id', type: 'uuid', nullable: true })
+  wagonTypeId?: string | null;
+
+  @ManyToOne(() => WagonType, { nullable: true, onDelete: 'RESTRICT' })
+  @JoinColumn({ name: 'wagon_type_id' })
+  wagonType?: WagonType | null;
+
   @Column({ name: 'is_active', type: 'boolean', default: true })
   isActive!: boolean;
 
diff --git a/apps/edr-freight-api/src/modules/rule-engine/entities/rate-unit.util.ts b/apps/edr-freight-api/src/modules/rule-engine/entities/rate-unit.util.ts
new file mode 100644
index 000000000..cef613412
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/rule-engine/entities/rate-unit.util.ts
@@ -0,0 +1,71 @@
+import type { RateAppliesTo, RateTrigger, RateUnit } from './rate.entity';
+
+/**
+ * Which rate units make sense for a given rate shape. The weighting basis is
+ * driven by the *type* of thing being billed — a container leg bills per
+ * container, bulk freight per ton, an intercity move can be per-km, a
+ * cancellation is a flat/per-invoice fee, and overweight is always per excess
+ * ton. This keeps the rate table dynamic yet non-conflicting: the admin can
+ * only pick a unit the pricing engine knows how to apply.
+ *
+ * Returned lists are ordered with the most natural/default unit first.
+ */
+export function allowedRateUnits(input: {
+  appliesTo: RateAppliesTo;
+  trigger: RateTrigger;
+}): RateUnit[] {
+  const { appliesTo, trigger } = input;
+
+  // Surcharges (Applies to = Other) are governed by their trigger.
+  if (appliesTo === 'OTHER') {
+    switch (trigger) {
+      case 'OVERWEIGHT':
+        // Overweight always bills the excess tonnage — per ton, nothing else.
+        return ['PER_TON'];
+      case 'REEFER':
+      case 'HAZARDOUS':
+        // Scale with the freight shape: per container for boxes, per ton for bulk.
+        return ['PER_CONTAINER', 'PER_TON'];
+      case 'DEMURRAGE':
+        return ['PER_CONTAINER', 'PER_TON'];
+      case 'CANCELLATION':
+        return ['FLAT', 'PER_INVOICE'];
+      case 'CONSOLIDATION':
+        return ['PER_CONTAINER', 'FLAT'];
+      case 'SHIPPING_LINE':
+      case 'PIL_EXTRA_FEE':
+        return ['PER_CONTAINER', 'FLAT'];
+      default:
+        return ['FLAT', 'PER_TON', 'PER_CONTAINER'];
+    }
+  }
+
+  // Base freight + first/last mile scale with the cargo type.
+  switch (appliesTo) {
+    case 'CONTAINER':
+      return ['PER_CONTAINER', 'PER_WAGON'];
+    case 'BULK':
+      return ['PER_TON', 'PER_WAGON'];
+    case 'INTERCITY':
+      return ['PER_CONTAINER', 'PER_TON', 'PER_WAGON', 'PER_KM'];
+    case 'FIRST_MILE':
+    case 'LAST_MILE':
+      return ['PER_CONTAINER', 'PER_TON', 'PER_KM', 'FLAT'];
+    default:
+      return ['FLAT'];
+  }
+}
+
+/** The default (first / most natural) unit for a rate shape. */
+export function defaultRateUnit(input: { appliesTo: RateAppliesTo; trigger: RateTrigger }): RateUnit {
+  return allowedRateUnits(input)[0];
+}
+
+/** True when `unit` is a valid weighting basis for the given rate shape. */
+export function isRateUnitAllowed(input: {
+  appliesTo: RateAppliesTo;
+  trigger: RateTrigger;
+  unit: RateUnit;
+}): boolean {
+  return allowedRateUnits(input).includes(input.unit);
+}
diff --git a/apps/edr-freight-api/src/modules/rule-engine/entities/rate.entity.ts b/apps/edr-freight-api/src/modules/rule-engine/entities/rate.entity.ts
index b57b48cd8..50f8b3b99 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/entities/rate.entity.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/entities/rate.entity.ts
@@ -81,7 +81,6 @@ export type RateTrigger = typeof RATE_TRIGGERS[number];
 @Entity({ schema: 'freight', name: 'rates' })
 @Index(['rateType'])
 @Index(['status'])
-@Index(['effectiveFrom'])
 @Index(['containerTypeId'])
 @Index(['trigger'])
 export class Rate extends BaseEntity {
@@ -131,10 +130,4 @@ export class Rate extends BaseEntity {
 
   @Column({ name: 'approved_at', type: 'timestamptz', nullable: true })
   approvedAt?: Date | null;
-
-  @Column({ name: 'effective_from', type: 'date' })
-  effectiveFrom!: Date;
-
-  @Column({ name: 'effective_to', type: 'date', nullable: true })
-  effectiveTo?: Date | null;
 }
diff --git a/apps/edr-freight-api/src/modules/rule-engine/entities/weight-limit-rule.entity.ts b/apps/edr-freight-api/src/modules/rule-engine/entities/weight-limit-rule.entity.ts
index 39557eec9..7a30cc20d 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/entities/weight-limit-rule.entity.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/entities/weight-limit-rule.entity.ts
@@ -5,7 +5,6 @@ import { ContainerType } from './container-type.entity';
 @Entity({ schema: 'freight', name: 'weight_limit_rules' })
 @Index(['containerTypeId'])
 @Index(['tradeDirection'])
-@Index(['effectiveFrom'])
 export class WeightLimitRule extends BaseEntity {
   @Column({ name: 'container_type_id', type: 'uuid' })
   containerTypeId!: string;
@@ -20,9 +19,11 @@ export class WeightLimitRule extends BaseEntity {
   @Column({ name: 'max_vgm_tons', type: 'numeric', precision: 8, scale: 3, nullable: true })
   maxVgmTons!: number;
 
-  @Column({ name: 'effective_from', type: 'date', nullable: true })
-  effectiveFrom!: Date;
-
-  @Column({ name: 'effective_to', type: 'date', nullable: true })
-  effectiveTo?: Date | null;
+  /**
+   * Absolute per-unit weight ceiling in tons. Weight above maxVgmTons but at or
+   * below this is "overweight" (surcharge + warning); weight above this hard-
+   * blocks booking creation entirely. Null = no ceiling (overweight only).
+   */
+  @Column({ name: 'max_capacity_tons', type: 'numeric', precision: 8, scale: 3, nullable: true })
+  maxCapacityTons!: number | null;
 }
diff --git a/apps/edr-freight-api/src/modules/rule-engine/interfaces/rates.repository.interface.ts b/apps/edr-freight-api/src/modules/rule-engine/interfaces/rates.repository.interface.ts
index 52b991155..96db214c4 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/interfaces/rates.repository.interface.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/interfaces/rates.repository.interface.ts
@@ -4,6 +4,13 @@ import { Rate } from '../entities/rate.entity';
 export interface IRatesRepository {
   findById(id: string): Promise<Rate | null>;
   findLiveRates(): Promise<Rate[]>;
+  findByPattern(pattern: {
+    rateType: string;
+    rateUnit: string;
+    containerTypeId?: string | null;
+    cargoTypeId?: string | null;
+    tradeDirection?: string | null;
+  }): Promise<Rate | null>;
   findAll(options?: FindManyOptions<Rate>): Promise<Rate[]>;
   findAndCount(options?: FindManyOptions<Rate>): Promise<[Rate[], number]>;
   create(data: Partial<Rate>): Promise<Rate>;
diff --git a/apps/edr-freight-api/src/modules/rule-engine/interfaces/weight-limit-rules.repository.interface.ts b/apps/edr-freight-api/src/modules/rule-engine/interfaces/weight-limit-rules.repository.interface.ts
index cedbd1eee..3c175df4e 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/interfaces/weight-limit-rules.repository.interface.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/interfaces/weight-limit-rules.repository.interface.ts
@@ -7,6 +7,11 @@ export interface IWeightLimitRulesRepository {
     containerTypeId: string,
     tradeDirection: string,
   ): Promise<WeightLimitRule[]>;
+  findByPattern(
+    containerTypeId: string,
+    tradeDirection: string,
+    excludeId?: string,
+  ): Promise<WeightLimitRule | null>;
   findAll(options?: FindManyOptions<WeightLimitRule>): Promise<WeightLimitRule[]>;
   findAndCount(options?: FindManyOptions<WeightLimitRule>): Promise<[WeightLimitRule[], number]>;
   create(data: Partial<WeightLimitRule>): Promise<WeightLimitRule>;
diff --git a/apps/edr-freight-api/src/modules/rule-engine/repositories/cargo-types.repository.ts b/apps/edr-freight-api/src/modules/rule-engine/repositories/cargo-types.repository.ts
index 496c2ce7b..5fba70fe1 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/repositories/cargo-types.repository.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/repositories/cargo-types.repository.ts
@@ -33,7 +33,7 @@ export class CargoTypesRepository implements ICargoTypesRepository {
   }
 
   async update(id: string, data: Partial<CargoType>): Promise<CargoType | null> {
-    await this.repo.update(id, data);
+    await this.repo.update(id, data as never);
     return this.findById(id);
   }
 
diff --git a/apps/edr-freight-api/src/modules/rule-engine/repositories/container-types.repository.ts b/apps/edr-freight-api/src/modules/rule-engine/repositories/container-types.repository.ts
index fe0a8f41e..0e4fb2716 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/repositories/container-types.repository.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/repositories/container-types.repository.ts
@@ -33,7 +33,7 @@ export class ContainerTypesRepository implements IContainerTypesRepository {
   }
 
   async update(id: string, data: Partial<ContainerType>): Promise<ContainerType | null> {
-    await this.repo.update(id, data);
+    await this.repo.update(id, data as never);
     return this.findById(id);
   }
 
diff --git a/apps/edr-freight-api/src/modules/rule-engine/repositories/rates.repository.ts b/apps/edr-freight-api/src/modules/rule-engine/repositories/rates.repository.ts
index 0d49a0bf3..a7b8e69ab 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/repositories/rates.repository.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/repositories/rates.repository.ts
@@ -16,15 +16,50 @@ export class RatesRepository implements IRatesRepository {
   }
 
   findLiveRates(): Promise<Rate[]> {
-    const now = new Date();
     return this.repo
       .createQueryBuilder('rate')
       .where('rate.status = :status', { status: 'LIVE' })
-      .andWhere('rate.effective_from <= :now', { now })
-      .andWhere('(rate.effective_to IS NULL OR rate.effective_to > :now)', { now })
       .getMany();
   }
 
+  /**
+   * Find a non-superseded rate matching an identity pattern — the same tuple the
+   * `UQ_rates_pattern` unique index enforces. Used to reject duplicates before
+   * insert so the admin gets a friendly error instead of a raw constraint fault.
+   * NULL scope columns are matched with IS NULL, mirroring the COALESCE index.
+   */
+  findByPattern(pattern: {
+    rateType: string;
+    rateUnit: string;
+    containerTypeId?: string | null;
+    cargoTypeId?: string | null;
+    tradeDirection?: string | null;
+  }): Promise<Rate | null> {
+    const qb = this.repo
+      .createQueryBuilder('rate')
+      .where('rate.rate_type = :rateType', { rateType: pattern.rateType })
+      .andWhere('rate.rate_unit = :rateUnit', { rateUnit: pattern.rateUnit })
+      .andWhere('rate.status <> :superseded', { superseded: 'SUPERSEDED' });
+
+    if (pattern.containerTypeId) {
+      qb.andWhere('rate.container_type_id = :containerTypeId', { containerTypeId: pattern.containerTypeId });
+    } else {
+      qb.andWhere('rate.container_type_id IS NULL');
+    }
+    if (pattern.cargoTypeId) {
+      qb.andWhere('rate.cargo_type_id = :cargoTypeId', { cargoTypeId: pattern.cargoTypeId });
+    } else {
+      qb.andWhere('rate.cargo_type_id IS NULL');
+    }
+    if (pattern.tradeDirection) {
+      qb.andWhere('rate.trade_direction = :tradeDirection', { tradeDirection: pattern.tradeDirection });
+    } else {
+      qb.andWhere('rate.trade_direction IS NULL');
+    }
+
+    return qb.getOne();
+  }
+
   findAll(options?: FindManyOptions<Rate>): Promise<Rate[]> {
     return this.repo.find(options);
   }
@@ -39,7 +74,7 @@ export class RatesRepository implements IRatesRepository {
   }
 
   async update(id: string, data: Partial<Rate>): Promise<Rate | null> {
-    await this.repo.update(id, data);
+    await this.repo.update(id, data as never);
     return this.findById(id);
   }
 
diff --git a/apps/edr-freight-api/src/modules/rule-engine/repositories/weight-limit-rules.repository.ts b/apps/edr-freight-api/src/modules/rule-engine/repositories/weight-limit-rules.repository.ts
index 0d151c561..7432dfc34 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/repositories/weight-limit-rules.repository.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/repositories/weight-limit-rules.repository.ts
@@ -22,7 +22,6 @@ export class WeightLimitRulesRepository implements IWeightLimitRulesRepository {
     containerTypeId: string,
     tradeDirection: string,
   ): Promise<WeightLimitRule[]> {
-    const now = new Date();
     return this.repo
       .createQueryBuilder('rule')
       .innerJoinAndSelect('rule.containerType', 'ct')
@@ -31,11 +30,27 @@ export class WeightLimitRulesRepository implements IWeightLimitRulesRepository {
         dir: tradeDirection,
         both: 'BOTH',
       })
-      .andWhere('rule.effective_from <= :now', { now })
-      .andWhere('(rule.effective_to IS NULL OR rule.effective_to > :now)', { now })
       .getMany();
   }
 
+  /**
+   * Find a rule matching the (containerType, tradeDirection) identity — the
+   * tuple enforced by `UQ_weight_limit_rules_pattern`. Used to reject duplicates
+   * before insert. Optionally excludes a row by id so updates don't self-collide.
+   */
+  findByPattern(
+    containerTypeId: string,
+    tradeDirection: string,
+    excludeId?: string,
+  ): Promise<WeightLimitRule | null> {
+    const qb = this.repo
+      .createQueryBuilder('rule')
+      .where('rule.container_type_id = :containerTypeId', { containerTypeId })
+      .andWhere('rule.trade_direction = :tradeDirection', { tradeDirection });
+    if (excludeId) qb.andWhere('rule.id <> :excludeId', { excludeId });
+    return qb.getOne();
+  }
+
   findAll(options?: FindManyOptions<WeightLimitRule>): Promise<WeightLimitRule[]> {
     return this.repo.find(options);
   }
@@ -50,7 +65,7 @@ export class WeightLimitRulesRepository implements IWeightLimitRulesRepository {
   }
 
   async update(id: string, data: Partial<WeightLimitRule>): Promise<WeightLimitRule | null> {
-    await this.repo.update(id, data);
+    await this.repo.update(id, data as never);
     return this.findById(id);
   }
 
diff --git a/apps/edr-freight-api/src/modules/rule-engine/rule-engine.service.ts b/apps/edr-freight-api/src/modules/rule-engine/rule-engine.service.ts
index 4b082e5fd..0fee8e75a 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/rule-engine.service.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/rule-engine.service.ts
@@ -136,6 +136,10 @@ export class RuleEngineService {
       }
     }
 
+    hardBlocked.push(
+      ...(await this.capacityViolations(input.containers, input.tradeDirection)),
+    );
+
     for (const container of input.containers) {
       const rules = await this.weightLimitRulesRepo.findActiveByContainerTypeId(
         container.containerTypeId,
@@ -296,6 +300,40 @@ export class RuleEngineService {
     };
   }
 
+  /**
+   * Messages for container lines whose total weight exceeds the hard capacity
+   * ceiling (weight_limit_rules.max_capacity_tons). Non-empty ⇒ the booking
+   * must not be created at all. Overweight (above maxVgmTons but within
+   * capacity) is NOT reported here — that is a surcharge, not a block.
+   */
+  async capacityViolations(
+    containers: Array<{
+      containerTypeId: string;
+      quantity: number;
+      totalVgmTons: number;
+    }>,
+    tradeDirection: string,
+  ): Promise<string[]> {
+    const violations: string[] = [];
+    for (const container of containers) {
+      const rules = await this.weightLimitRulesRepo.findActiveByContainerTypeId(
+        container.containerTypeId,
+        tradeDirection,
+      );
+      const rule = rules[0];
+      if (!rule || rule.maxCapacityTons == null) continue;
+      const perUnit = Number(rule.maxCapacityTons);
+      const maxTotal = perUnit * container.quantity;
+      if (container.totalVgmTons > maxTotal) {
+        const label = rule.containerType?.code ?? container.containerTypeId;
+        violations.push(
+          `${label} total weight ${container.totalVgmTons}t exceeds the maximum capacity of ${maxTotal}t (${perUnit}t per unit) — the booking cannot be created; reduce the cargo weight`,
+        );
+      }
+    }
+    return violations;
+  }
+
   /**
    * Ensure ITMLS default approval chains exist (container + bulk). Idempotent.
    */
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 f80ada585..5470094a5 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
@@ -82,6 +82,7 @@ export class CargoTypesService {
       requiresDirectorApproval: dto.requiresDirectorApproval ?? false,
       isActive: dto.isActive ?? true,
       unitOfMeasure: dto.unitOfMeasure ?? null,
+      wagonTypeId: dto.wagonTypeId ?? null,
       displayOrder,
     });
   }
diff --git a/apps/edr-freight-api/src/modules/rule-engine/services/container-types.service.ts b/apps/edr-freight-api/src/modules/rule-engine/services/container-types.service.ts
index 38407f36a..629bf3023 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/services/container-types.service.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/services/container-types.service.ts
@@ -64,6 +64,7 @@ export class ContainerTypesService {
       isReefer: dto.isReefer ?? false,
       isOpenTop: dto.isOpenTop ?? false,
       isActive: dto.isActive ?? true,
+      wagonTypeId: dto.wagonTypeId ?? null,
       displayOrder,
     });
   }
diff --git a/apps/edr-freight-api/src/modules/rule-engine/services/rates.service.ts b/apps/edr-freight-api/src/modules/rule-engine/services/rates.service.ts
index c3ab6bab0..0027e18c1 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/services/rates.service.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/services/rates.service.ts
@@ -1,8 +1,15 @@
-import { BadRequestException, Inject, Injectable, NotFoundException } from '@nestjs/common';
+import {
+  BadRequestException,
+  ConflictException,
+  Inject,
+  Injectable,
+  NotFoundException,
+} from '@nestjs/common';
 import { CreateRateDto } from '../dto/create-rate.dto';
 import { UpdateRateDto } from '../dto/update-rate.dto';
 import { Rate } from '../entities/rate.entity';
 import { deriveRateType } from '../entities/rate-type.util';
+import { allowedRateUnits, isRateUnitAllowed } from '../entities/rate-unit.util';
 import { IRatesRepository, RATES_REPOSITORY } from '../interfaces/rates.repository.interface';
 
 @Injectable()
@@ -27,7 +34,7 @@ export class RatesService {
 
     const [data, total] = await this.repository.findAndCount({
       where,
-      order: { effectiveFrom: 'DESC' },
+      order: { createdAt: 'DESC' },
       skip: (page - 1) * pageSize,
       take: pageSize,
     });
@@ -46,6 +53,50 @@ export class RatesService {
     return entity;
   }
 
+  /**
+   * Normalise + validate the weighting unit for a rate shape. Overweight is
+   * always billed per excess ton, so its unit is forced to PER_TON regardless
+   * of what the client sent. Every other shape must pick a unit the pricing
+   * engine can actually apply (see `allowedRateUnits`).
+   */
+  private resolveRateUnit(
+    appliesTo: Rate['appliesTo'],
+    trigger: Rate['trigger'],
+    requestedUnit: Rate['rateUnit'],
+  ): Rate['rateUnit'] {
+    // Overweight is per-ton, full stop.
+    if (trigger === 'OVERWEIGHT') return 'PER_TON';
+
+    if (!isRateUnitAllowed({ appliesTo, trigger, unit: requestedUnit })) {
+      const allowed = allowedRateUnits({ appliesTo, trigger }).join(', ');
+      throw new BadRequestException(
+        `Rate unit "${requestedUnit}" is not valid for this rate. Allowed: ${allowed}.`,
+      );
+    }
+    return requestedUnit;
+  }
+
+  /**
+   * Reject a second rate with the same identity pattern (rateType + scope). With
+   * effective-date windows gone, two LIVE/DRAFT rates for the same pattern would
+   * make pricing ambiguous — so we allow exactly one per pattern.
+   */
+  private async assertNoDuplicatePattern(pattern: {
+    rateType: string;
+    rateUnit: string;
+    containerTypeId: string | null;
+    cargoTypeId: string | null;
+    tradeDirection: string | null;
+    ignoreId?: string;
+  }): Promise<void> {
+    const existing = await this.repository.findByPattern(pattern);
+    if (existing && existing.id !== pattern.ignoreId) {
+      throw new ConflictException(
+        'A rate for this exact combination already exists. Edit or delete the existing rate instead of creating a duplicate.',
+      );
+    }
+  }
+
   /** Create a rate in DRAFT status. */
   async create(dto: CreateRateDto, proposedByStaffId: string): Promise<Rate> {
     const appliesTo = dto.appliesTo as Rate['appliesTo'];
@@ -57,25 +108,28 @@ export class RatesService {
     const cargoTypeId = isSurcharge ? null : (dto.cargoTypeId ?? null);
     const tradeDirection = isSurcharge ? null : (dto.tradeDirection ?? null);
 
+    const rateType = deriveRateType({
+      appliesTo,
+      trigger,
+      tradeDirection,
+      isBulk: Boolean(cargoTypeId),
+    });
+    const rateUnit = this.resolveRateUnit(appliesTo, trigger, dto.rateUnit as Rate['rateUnit']);
+
+    await this.assertNoDuplicatePattern({ rateType, rateUnit, containerTypeId, cargoTypeId, tradeDirection });
+
     return this.repository.create({
       appliesTo,
       trigger,
-      rateType: deriveRateType({
-        appliesTo,
-        trigger,
-        tradeDirection,
-        isBulk: Boolean(cargoTypeId),
-      }),
+      rateType,
       containerTypeId,
       cargoTypeId,
       tradeDirection,
       currency: dto.currency ?? 'USD',
       rateValue: dto.rateValue,
-      rateUnit: dto.rateUnit as Rate['rateUnit'],
+      rateUnit,
       status: 'DRAFT',
       proposedByStaffId,
-      effectiveFrom: new Date(dto.effectiveFrom),
-      effectiveTo: dto.effectiveTo ? new Date(dto.effectiveTo) : undefined,
     });
   }
 
@@ -110,22 +164,35 @@ export class RatesService {
         ? dto.tradeDirection
         : existing.tradeDirection;
 
-    updates.containerTypeId = containerTypeId;
-    updates.cargoTypeId = cargoTypeId;
-    updates.tradeDirection = tradeDirection;
+    updates.containerTypeId = containerTypeId ?? null;
+    updates.cargoTypeId = cargoTypeId ?? null;
+    updates.tradeDirection = tradeDirection ?? null;
     // Keep the derived rateType in sync with whatever changed.
-    updates.rateType = deriveRateType({
+    const rateType = deriveRateType({
       appliesTo,
       trigger,
       tradeDirection,
       isBulk: Boolean(cargoTypeId),
     });
+    updates.rateType = rateType;
+
+    // Re-validate the unit against the (possibly changed) shape; overweight is
+    // forced to PER_TON.
+    const requestedUnit = (dto.rateUnit as Rate['rateUnit']) ?? existing.rateUnit;
+    updates.rateUnit = this.resolveRateUnit(appliesTo, trigger, requestedUnit);
+
+    // Guard the pattern uniqueness for the new identity, ignoring this row.
+    await this.assertNoDuplicatePattern({
+      rateType,
+      rateUnit: updates.rateUnit,
+      containerTypeId: updates.containerTypeId,
+      cargoTypeId: updates.cargoTypeId,
+      tradeDirection: updates.tradeDirection,
+      ignoreId: id,
+    });
 
     updates.currency = dto.currency ?? existing.currency ?? 'USD';
     if (dto.rateValue !== undefined) updates.rateValue = dto.rateValue;
-    if (dto.rateUnit) updates.rateUnit = dto.rateUnit as Rate['rateUnit'];
-    if (dto.effectiveFrom) updates.effectiveFrom = new Date(dto.effectiveFrom);
-    if (dto.effectiveTo) updates.effectiveTo = new Date(dto.effectiveTo);
     const updated = await this.repository.update(id, updates);
     if (!updated) throw new NotFoundException(`Rate ${id} not found`);
     return updated;
diff --git a/apps/edr-freight-api/src/modules/rule-engine/services/weight-limit-rules.service.ts b/apps/edr-freight-api/src/modules/rule-engine/services/weight-limit-rules.service.ts
index d171f55aa..44f5332f2 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/services/weight-limit-rules.service.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/services/weight-limit-rules.service.ts
@@ -1,4 +1,10 @@
-import { Inject, Injectable, NotFoundException } from '@nestjs/common';
+import {
+  BadRequestException,
+  ConflictException,
+  Inject,
+  Injectable,
+  NotFoundException,
+} from '@nestjs/common';
 import { CreateWeightLimitRuleDto } from '../dto/create-weight-limit-rule.dto';
 import { UpdateWeightLimitRuleDto } from '../dto/update-weight-limit-rule.dto';
 import { WeightLimitRule } from '../entities/weight-limit-rule.entity';
@@ -30,7 +36,7 @@ export class WeightLimitRulesService {
     const [data, total] = await this.repository.findAndCount({
       where,
       relations: { containerType: true },
-      order: { effectiveFrom: 'DESC' },
+      order: { createdAt: 'DESC' },
       skip: (page - 1) * pageSize,
       take: pageSize,
     });
@@ -44,26 +50,75 @@ export class WeightLimitRulesService {
     return entity;
   }
 
+  /**
+   * Reject a second rule for the same container + direction. One VGM limit per
+   * (container, direction) — otherwise the booking engine can't tell which
+   * applies.
+   */
+  private async assertNoDuplicate(
+    containerTypeId: string,
+    tradeDirection: string,
+    ignoreId?: string,
+  ): Promise<void> {
+    const existing = await this.repository.findByPattern(containerTypeId, tradeDirection, ignoreId);
+    if (existing) {
+      throw new ConflictException(
+        'A weight limit rule for this container type and trade direction already exists. Edit the existing rule instead.',
+      );
+    }
+  }
+
+  /**
+   * Capacity is the hard ceiling; the VGM limit is the soft overweight
+   * threshold. A ceiling below the threshold would make every overweight
+   * booking impossible to create, which is never what the operator means.
+   */
+  private assertCapacityAboveVgmLimit(
+    maxVgmTons: number,
+    maxCapacityTons: number | null | undefined,
+  ): void {
+    if (maxCapacityTons != null && Number(maxCapacityTons) < Number(maxVgmTons)) {
+      throw new BadRequestException(
+        'Max capacity must be greater than or equal to the max VGM limit.',
+      );
+    }
+  }
+
   /** Create a new weight limit rule. */
   async create(dto: CreateWeightLimitRuleDto): Promise<WeightLimitRule> {
+    await this.assertNoDuplicate(dto.containerTypeId, dto.tradeDirection);
+    this.assertCapacityAboveVgmLimit(dto.maxVgmTons, dto.maxCapacityTons);
     return this.repository.create({
       containerTypeId: dto.containerTypeId,
       tradeDirection: dto.tradeDirection,
       maxVgmTons: dto.maxVgmTons,
-      effectiveFrom: new Date(dto.effectiveFrom),
-      effectiveTo: dto.effectiveTo ? new Date(dto.effectiveTo) : null,
+      maxCapacityTons: dto.maxCapacityTons ?? null,
     });
   }
 
   /** Update an existing weight limit rule. */
   async update(id: string, dto: UpdateWeightLimitRuleDto): Promise<WeightLimitRule> {
-    await this.findById(id);
+    const existing = await this.findById(id);
     const patch: Partial<WeightLimitRule> = {};
     if (dto.containerTypeId !== undefined) patch.containerTypeId = dto.containerTypeId;
     if (dto.tradeDirection !== undefined) patch.tradeDirection = dto.tradeDirection;
     if (dto.maxVgmTons !== undefined) patch.maxVgmTons = dto.maxVgmTons;
-    if (dto.effectiveFrom !== undefined) patch.effectiveFrom = new Date(dto.effectiveFrom);
-    if (dto.effectiveTo !== undefined) patch.effectiveTo = new Date(dto.effectiveTo);
+    if (dto.maxCapacityTons !== undefined) patch.maxCapacityTons = dto.maxCapacityTons;
+
+    this.assertCapacityAboveVgmLimit(
+      patch.maxVgmTons ?? Number(existing.maxVgmTons),
+      patch.maxCapacityTons !== undefined ? patch.maxCapacityTons : existing.maxCapacityTons,
+    );
+
+    // Re-check uniqueness when the identity (container/direction) changes.
+    if (dto.containerTypeId !== undefined || dto.tradeDirection !== undefined) {
+      await this.assertNoDuplicate(
+        patch.containerTypeId ?? existing.containerTypeId,
+        patch.tradeDirection ?? existing.tradeDirection,
+        id,
+      );
+    }
+
     const updated = await this.repository.update(id, patch);
     if (!updated) throw new NotFoundException(`Weight limit rule ${id} not found`);
     return updated;
diff --git a/apps/edr-freight-api/src/modules/train-schedules/entities/train-schedule-booking.entity.ts b/apps/edr-freight-api/src/modules/train-schedules/entities/train-schedule-booking.entity.ts
index 4ffecea26..352704eea 100644
--- a/apps/edr-freight-api/src/modules/train-schedules/entities/train-schedule-booking.entity.ts
+++ b/apps/edr-freight-api/src/modules/train-schedules/entities/train-schedule-booking.entity.ts
@@ -1,9 +1,15 @@
 import { BaseEntity } from '@edr/api-common';
+import { LoadingStatus } from '@edr/types';
 import { Entity, Index, JoinColumn, ManyToOne, Column } from 'typeorm';
 
 import { Booking } from '../../bookings/entities/booking.entity';
 import { TrainSchedule } from './train-schedule.entity';
 
+export const TRAIN_SCHEDULE_BOOKING_LOADING_STATUSES = [
+  LoadingStatus.Unloaded,
+  LoadingStatus.Loaded,
+] as const;
+
 @Entity({ schema: 'freight', name: 'train_schedule_bookings' })
 @Index(['trainScheduleId', 'bookingId'], { unique: true })
 @Index(['bookingId'], { unique: true })
@@ -23,4 +29,7 @@ export class TrainScheduleBooking extends BaseEntity {
   @ManyToOne(() => Booking)
   @JoinColumn({ name: 'booking_id' })
   booking?: Booking;
+
+  @Column({ name: 'loading_status', type: 'varchar', length: 20, default: 'UNLOADED' })
+  loadingStatus!: string;
 }
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 d67d58811..0cc07dacc 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
@@ -111,6 +111,27 @@ export class TrainSchedule extends BaseEntity {
   @Column({ name: 'booking_cycle_no', type: 'int', default: 0 })
   bookingCycleNo!: number;
 
+  // ── Booking-window rule snapshot ──────────────────────────────────────────
+  // The scheduling rule this train was created with, frozen at creation. A later
+  // global-rules edit applies only to FUTURE schedules — an already-open schedule
+  // keeps its base rule. The batch board derives its display windows (open time +
+  // reopen cycles) from THIS snapshot, never from the live global config. NULL on
+  // legacy rows created before the snapshot existed (board falls back to live cfg).
+  @Column({ name: 'rule_window_open_hour', type: 'int', nullable: true })
+  ruleWindowOpenHour?: number | null;
+
+  @Column({ name: 'rule_window_duration_hours', type: 'numeric', precision: 6, scale: 4, nullable: true })
+  ruleWindowDurationHours?: number | null;
+
+  @Column({ name: 'rule_reopen_delay_minutes', type: 'int', nullable: true })
+  ruleReopenDelayMinutes?: number | null;
+
+  @Column({ name: 'rule_import_window_lead_days', type: 'int', nullable: true })
+  ruleImportWindowLeadDays?: number | null;
+
+  @Column({ name: 'rule_export_booking_lead_hours', type: 'int', nullable: true })
+  ruleExportBookingLeadHours?: number | null;
+
   @OneToMany(() => TrainScheduleBooking, (scheduleBooking) => scheduleBooking.trainSchedule)
   scheduleBookings?: TrainScheduleBooking[];
 }
diff --git a/apps/edr-freight-api/src/modules/train-schedules/train-schedule-bookings.repository.ts b/apps/edr-freight-api/src/modules/train-schedules/train-schedule-bookings.repository.ts
index 4ccfcd469..64607ecb8 100644
--- a/apps/edr-freight-api/src/modules/train-schedules/train-schedule-bookings.repository.ts
+++ b/apps/edr-freight-api/src/modules/train-schedules/train-schedule-bookings.repository.ts
@@ -47,4 +47,27 @@ export class TrainScheduleBookingsRepository extends BaseRepository<TrainSchedul
       select: { id: true, bookingId: true, trainScheduleId: true },
     });
   }
+
+  findByScheduleId(
+    trainScheduleId: string,
+    manager?: EntityManager,
+  ): Promise<TrainScheduleBooking[]> {
+    return this.repo(manager).find({
+      where: { trainScheduleId },
+      select: { id: true, bookingId: true, trainScheduleId: true, loadingStatus: true },
+    });
+  }
+
+  async updateLoadingStatusMany(
+    trainScheduleId: string,
+    bookingIds: string[],
+    loadingStatus: string,
+    manager?: EntityManager,
+  ): Promise<void> {
+    if (!bookingIds.length) return;
+    await this.repo(manager).update(
+      { trainScheduleId, bookingId: In(bookingIds) },
+      { loadingStatus },
+    );
+  }
 }
diff --git a/apps/edr-freight-api/src/modules/train-scheduling/batch-window.util.spec.ts b/apps/edr-freight-api/src/modules/train-scheduling/batch-window.util.spec.ts
index e765e5694..764589b73 100644
--- a/apps/edr-freight-api/src/modules/train-scheduling/batch-window.util.spec.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/batch-window.util.spec.ts
@@ -3,9 +3,9 @@ import {
   listBatchWindowsForDate,
   listBatchWindowsForBookings,
   BATCH_WINDOW_START_HOURS,
-  boardWindowForTimestamp,
-  listBoardWindowsForRange,
+  listConfigBookingWindows,
   groupBookingsIntoBoardWindows,
+  type BoardWindowConfig,
 } from './batch-window.util';
 
 describe('batch-window.util', () => {
@@ -54,83 +54,87 @@ describe('batch-window.util', () => {
   });
 });
 
-describe('batch-window board windows (midnight-based 3h slots)', () => {
-  it('maps 04:00 EAT to the 03:00–06:00 slot', () => {
-    // 01:00 UTC = 04:00 EAT on 11 Jun
-    const w = boardWindowForTimestamp(new Date('2026-06-11T01:00:00.000Z'));
-    expect(w.label).toContain('03:00');
-    expect(w.label).toContain('06:00');
-    expect(w.date).toBe('2026-06-11');
-    expect(w.dateLabel).toContain('11 Jun');
-  });
+describe('batch-window board windows (config-driven booking cycles)', () => {
+  // Default rules: open 08:00 EAT, 3 days before departure, 3h long, reopen 90m later.
+  const cfg: BoardWindowConfig = {
+    importWindowLeadDays: 3,
+    windowOpenHour: 8,
+    windowDurationHours: 3,
+    reopenDelayMinutes: 90,
+    exportBookingLeadHours: 24,
+  };
 
-  it('maps 00:30 EAT to the 00:00–03:00 slot of that EAT day', () => {
-    // 21:30 UTC on 10 Jun = 00:30 EAT on 11 Jun
-    const w = boardWindowForTimestamp(new Date('2026-06-10T21:30:00.000Z'));
-    expect(w.label).toContain('00:00');
-    expect(w.label).toContain('03:00');
-    expect(w.date).toBe('2026-06-11');
-  });
-
-  it('maps 23:00 EAT to the final 21:00–24:00 slot', () => {
-    // 20:00 UTC = 23:00 EAT on 11 Jun
-    const w = boardWindowForTimestamp(new Date('2026-06-11T20:00:00.000Z'));
-    expect(w.label).toContain('21:00');
-    expect(w.label).toContain('24:00');
-    expect(w.date).toBe('2026-06-11');
-  });
-
-  it('lists a continuous range open→departure clamped at both ends', () => {
-    // open 05 Jun 08:00 EAT (05:00 UTC) → departs 08 Jun 14:00 EAT (11:00 UTC)
-    const open = new Date('2026-06-05T05:00:00.000Z');
+  it('import: first window opens at windowOpenHour EAT, importWindowLeadDays before departure', () => {
+    // departs 08 Jun 14:00 EAT (11:00 UTC) → window day = 05 Jun, opens 08:00 EAT (05:00 UTC)
     const departure = new Date('2026-06-08T11:00:00.000Z');
-    const windows = listBoardWindowsForRange(open, departure);
+    const windows = listConfigBookingWindows('IMPORT', departure, cfg);
 
-    // Day 5: 06,09,12,15,18,21 = 6 ; Days 6,7: 8 each ; Day 8: 00,03,06,09,12 = 5
-    expect(windows).toHaveLength(6 + 8 + 8 + 5);
     expect(windows[0].date).toBe('2026-06-05');
-    expect(windows[0].label).toContain('06:00');
-    expect(windows[0].label).toContain('09:00');
-    const last = windows[windows.length - 1];
-    expect(last.date).toBe('2026-06-08');
-    expect(last.label).toContain('12:00');
-    expect(last.label).toContain('15:00');
-    // chronological + unique keys
-    const keys = windows.map((w) => w.key);
-    expect(new Set(keys).size).toBe(keys.length);
+    expect(windows[0].label).toContain('08:00');
+    expect(windows[0].start.toISOString()).toBe('2026-06-05T05:00:00.000Z');
+    // end = open + windowDurationHours (3h) = 08:00 → 11:00 EAT (08:00 UTC)
+    expect(windows[0].end.toISOString()).toBe('2026-06-05T08:00:00.000Z');
   });
 
-  it('handles a same-day open→departure range', () => {
-    const open = new Date('2026-06-05T05:00:00.000Z'); // 08:00 EAT (06–09 slot)
-    const departure = new Date('2026-06-05T11:00:00.000Z'); // 14:00 EAT (12–15 slot)
-    const windows = listBoardWindowsForRange(open, departure);
-    // 06,09,12 = 3 slots
-    expect(windows).toHaveLength(3);
+  it('import: reopens reopenDelayMinutes after close, same booking day', () => {
+    const departure = new Date('2026-06-08T11:00:00.000Z');
+    const windows = listConfigBookingWindows('IMPORT', departure, cfg);
+    // cycle 1: 08:00–11:00; reopen +90m → cycle 2 opens 12:30 EAT
+    expect(windows.length).toBeGreaterThanOrEqual(2);
+    expect(windows[1].start.toISOString()).toBe('2026-06-05T09:30:00.000Z'); // 12:30 EAT
+    // all cycles stay on the same EAT booking day
     expect(windows.every((w) => w.date === '2026-06-05')).toBe(true);
   });
 
-  it('buckets bookings by fullyExecutedAt and keeps empty + pending windows', () => {
-    const open = new Date('2026-06-05T05:00:00.000Z');
-    const departure = new Date('2026-06-06T11:00:00.000Z');
+  it('export: single FCFS window exportBookingLeadHours before departure', () => {
+    const departure = new Date('2026-06-08T11:00:00.000Z');
+    const windows = listConfigBookingWindows('EXPORT', departure, cfg);
+    expect(windows).toHaveLength(1);
+    // 24h before 11:00 UTC on 08 Jun = 11:00 UTC on 07 Jun
+    expect(windows[0].start.toISOString()).toBe('2026-06-07T11:00:00.000Z');
+    expect(windows[0].end.toISOString()).toBe(departure.toISOString());
+  });
+
+  it('buckets bookings into config cycles and keeps empty + pending windows', () => {
+    const departure = new Date('2026-06-08T11:00:00.000Z');
     const items = [
-      { id: 'a', ts: new Date('2026-06-05T05:30:00.000Z') }, // 08:30 EAT → 06–09 on 5th
+      { id: 'a', ts: new Date('2026-06-05T05:30:00.000Z') }, // 08:30 EAT → inside cycle 1
       { id: 'b', ts: null }, // pending
     ];
     const map = groupBookingsIntoBoardWindows(
       items,
       (i) => i.ts,
-      open,
+      'IMPORT',
       departure,
+      cfg,
       'pending-contract',
     );
     const pending = map.get('pending-contract');
     expect(pending?.items.map((i) => i.id)).toEqual(['b']);
     const withA = [...map.values()].find((b) => b.items.some((i) => i.id === 'a'));
     expect(withA?.window?.date).toBe('2026-06-05');
-    // empty slots are retained for the UI
+    // empty cycles are retained for the UI
     const emptyCount = [...map.values()].filter(
       (b) => b.window && b.items.length === 0,
     ).length;
     expect(emptyCount).toBeGreaterThan(0);
   });
+
+  it('attaches a booking made before the window opened to the first cycle', () => {
+    const departure = new Date('2026-06-08T11:00:00.000Z');
+    const items = [{ id: 'early', ts: new Date('2026-06-01T00:00:00.000Z') }];
+    const map = groupBookingsIntoBoardWindows(
+      items,
+      (i) => i.ts,
+      'IMPORT',
+      departure,
+      cfg,
+      'pending-contract',
+    );
+    const withEarly = [...map.values()].find((b) =>
+      b.items.some((i) => i.id === 'early'),
+    );
+    expect(withEarly?.window?.date).toBe('2026-06-05');
+    expect(withEarly?.window?.label).toContain('08:00');
+  });
 });
diff --git a/apps/edr-freight-api/src/modules/train-scheduling/batch-window.util.ts b/apps/edr-freight-api/src/modules/train-scheduling/batch-window.util.ts
index 650da3adc..b30b3f454 100644
--- a/apps/edr-freight-api/src/modules/train-scheduling/batch-window.util.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/batch-window.util.ts
@@ -181,6 +181,26 @@ export function computeExportWindowTimes(
   };
 }
 
+/**
+ * Earliest departure a train may be scheduled for — staff cannot schedule inside
+ * the lead window. IMPORT/DOMESTIC lead is in whole EAT days: with lead 3 and
+ * today the 11th, the 12th and 13th are blocked and the 14th is the first
+ * allowed departure day (00:00 EAT). EXPORT lead is in hours: earliest departure
+ * is `now + exportBookingLeadHours` (24h = 1 day). Mirrors the booking-window
+ * math so a schedulable date always has a real booking window before it.
+ */
+export function earliestSchedulableDeparture(
+  direction: string | null | undefined,
+  cfg: { importWindowLeadDays: number; exportBookingLeadHours: number },
+  now: Date,
+): Date {
+  if (direction === 'EXPORT') {
+    return new Date(now.getTime() + cfg.exportBookingLeadHours * 3_600_000);
+  }
+  const earliestDay = shiftEatDay(eatDay(now), cfg.importWindowLeadDays);
+  return eatDayToUtc(earliestDay, 0);
+}
+
 /** Which 3h EAT intake window a timestamp (e.g. fullyExecutedAt) belongs to. */
 export function getBatchWindowForTimestamp(date: Date): BatchWindow {
   const { year, month, day, hour } = eatParts(date);
@@ -230,14 +250,13 @@ export function listBatchWindowsForBookings(
 }
 
 // ---------------------------------------------------------------------------
-// Board-display windows: full-day, midnight-based 3h slots over a date range.
-// These are used ONLY for the batch-board UI grouping (not persisted, and
-// independent of the cron intake hours above).
+// Board-display windows: the REAL booking-window cycles derived from the
+// train_scheduling_global_rules config (window open hour, lead days, duration,
+// reopen delay) — NOT a fixed clock grid. Import shows each booking-window cycle
+// (opens at windowOpenHour EAT, lasts windowDurationHours, reopens after
+// reopenDelayMinutes until departure). Export shows the single FCFS lead window.
 // ---------------------------------------------------------------------------
 
-/** Midnight-based 3-hour slot starts (00–03, 03–06, … 21–24). */
-export const BOARD_WINDOW_HOURS = [0, 3, 6, 9, 12, 15, 18, 21] as const;
-
 /** A board window carries an EAT calendar date in addition to the slot times. */
 export interface BoardWindow extends BatchWindow {
   /** EAT calendar day as ISO `YYYY-MM-DD`. */
@@ -246,6 +265,15 @@ export interface BoardWindow extends BatchWindow {
   dateLabel: string;
 }
 
+/** Config fields the board needs to reconstruct booking-window cycles. */
+export interface BoardWindowConfig {
+  importWindowLeadDays: number;
+  windowOpenHour: number;
+  windowDurationHours: number;
+  reopenDelayMinutes: number;
+  exportBookingLeadHours: number;
+}
+
 const dayLabelFmt = new Intl.DateTimeFormat('en-GB', {
   weekday: 'short',
   day: '2-digit',
@@ -257,119 +285,133 @@ function pad2(n: number): string {
   return String(n).padStart(2, '0');
 }
 
-/** Build a midnight-based 3h board window for an EAT calendar day + slot start hour. */
-function boardWindowFromEatStart(
-  year: number,
-  month: number,
-  day: number,
-  startHour: number,
-): BoardWindow {
-  const start = eatToUtc(year, month, day, startHour);
-  const endHour = startHour + 3; // 21 -> 24 (handled by Date.UTC roll-over)
-  const end = eatToUtc(year, month, day, endHour);
-  const endLabel = endHour >= 24 ? '24:00' : `${pad2(endHour)}:00`;
+/** Wrap a [start, end] interval as a labelled BoardWindow keyed on its EAT day. */
+function boardWindowFromInterval(start: Date, end: Date): BoardWindow {
+  const { year, month, day } = eatParts(start);
   return {
     key: start.toISOString(),
     start,
     end,
-    label: formatWindowLabel(start, end, endLabel),
+    label: formatWindowLabel(start, end),
     date: `${year}-${pad2(month)}-${pad2(day)}`,
     dateLabel: dayLabelFmt.format(start),
   };
 }
 
-/** Which midnight-based 3h EAT slot a timestamp falls in. */
-export function boardWindowForTimestamp(date: Date): BoardWindow {
-  const { year, month, day, hour } = eatParts(date);
-  let startHour: (typeof BOARD_WINDOW_HOURS)[number] = 0;
-  for (const h of BOARD_WINDOW_HOURS) {
-    if (hour >= h) startHour = h;
-  }
-  return boardWindowFromEatStart(year, month, day, startHour);
-}
-
 /**
- * Continuous list of board windows from `openDate` to `departureDate` (inclusive),
- * clamped to the slot containing `openDate` on the first day and the slot
- * containing `departureDate` on the last day. Returned in chronological order.
+ * The real booking-window cycles for a schedule, straight from config.
+ *
+ * IMPORT: first window opens at `windowOpenHour` EAT on `departure − importWindowLeadDays`
+ * for `windowDurationHours`; if the train isn't full it reopens `reopenDelayMinutes`
+ * after each close, on the same booking day, until departure. This mirrors
+ * `computeImportWindowTimes` + `concludeCycle`'s reopen math so the board shows the
+ * exact windows the engine runs.
+ * EXPORT: a single FCFS window from `departure − exportBookingLeadHours` to departure.
+ *
+ * `anchorOpensAt` pins the FIRST window's open time to the schedule's stored
+ * `windowOpensAt` instead of recomputing it from config. Pass it so the board
+ * shows the real frozen window (and reopen cycles projected from it) even after
+ * the global rule changed — the recomputed open time would otherwise drift.
  */
-export function listBoardWindowsForRange(
-  openDate: Date,
-  departureDate: Date,
+export function listConfigBookingWindows(
+  direction: string | null | undefined,
+  departure: Date,
+  cfg: BoardWindowConfig,
+  anchorOpensAt?: Date | null,
 ): BoardWindow[] {
-  const startWin = boardWindowForTimestamp(openDate);
-  const endWin = boardWindowForTimestamp(departureDate);
-  // Guard against an inverted range (departure before open).
-  if (endWin.start.getTime() < startWin.start.getTime()) {
-    return [startWin];
+  if (direction === 'EXPORT') {
+    const start =
+      anchorOpensAt ??
+      new Date(departure.getTime() - cfg.exportBookingLeadHours * 3_600_000);
+    return [boardWindowFromInterval(start, departure)];
   }
 
   const windows: BoardWindow[] = [];
-  const seen = new Set<string>();
-  // Walk day-by-day in EAT, emitting each day's slots, stepping via UTC noon to
-  // avoid any boundary ambiguity, then filter to [startWin.start, endWin.start].
-  let cursor = new Date(eatToUtc(
-    Number(startWin.date.slice(0, 4)),
-    Number(startWin.date.slice(5, 7)),
-    Number(startWin.date.slice(8, 10)),
-    12,
-  ));
-  const lastDayMs = eatToUtc(
-    Number(endWin.date.slice(0, 4)),
-    Number(endWin.date.slice(5, 7)),
-    Number(endWin.date.slice(8, 10)),
-    12,
-  ).getTime();
+  const durationMs = cfg.windowDurationHours * 3_600_000;
+  const reopenMs = cfg.reopenDelayMinutes * 60_000;
+  const windowDay = shiftEatDay(eatDay(departure), -cfg.importWindowLeadDays);
 
-  while (cursor.getTime() <= lastDayMs) {
-    const { year, month, day } = eatParts(cursor);
-    for (const h of BOARD_WINDOW_HOURS) {
-      const w = boardWindowFromEatStart(year, month, day, h);
-      if (
-        w.start.getTime() >= startWin.start.getTime() &&
-        w.start.getTime() <= endWin.start.getTime() &&
-        !seen.has(w.key)
-      ) {
-        seen.add(w.key);
-        windows.push(w);
-      }
+  let opensAt = anchorOpensAt ?? eatDayToUtc(windowDay, cfg.windowOpenHour);
+  // Reopen stays on the same EAT booking day and before departure; cap at 12 cycles.
+  for (let cycle = 0; cycle < 12; cycle += 1) {
+    if (opensAt.getTime() >= departure.getTime()) break;
+    let closesAt = new Date(opensAt.getTime() + durationMs);
+    if (closesAt.getTime() > departure.getTime()) closesAt = departure;
+    windows.push(boardWindowFromInterval(opensAt, closesAt));
+
+    const nextOpensAt = new Date(closesAt.getTime() + reopenMs);
+    if (
+      nextOpensAt.getTime() >= departure.getTime() ||
+      eatDay(nextOpensAt) !== eatDay(opensAt)
+    ) {
+      break;
     }
-    cursor = new Date(cursor.getTime() + 24 * 60 * 60 * 1000);
+    opensAt = nextOpensAt;
   }
 
-  windows.sort(compareBatchWindows);
+  // Degenerate config (no window before departure) — surface a single window
+  // clamped to departure so the board still renders something meaningful.
+  if (windows.length === 0) {
+    windows.push(boardWindowFromInterval(new Date(departure.getTime() - durationMs), departure));
+  }
   return windows;
 }
 
+/** Which config booking-window a timestamp falls in; null if before/after all of them. */
+function configWindowForTimestamp(
+  windows: BoardWindow[],
+  date: Date,
+): BoardWindow | null {
+  const ms = date.getTime();
+  for (const w of windows) {
+    if (ms >= w.start.getTime() && ms < w.end.getTime()) return w;
+  }
+  return null;
+}
+
 /**
- * Group items into board windows spanning [openDate, departureDate]. Empty
- * windows are kept so the UI shows every slot. Items whose timestamp falls
- * outside the range still get their own window (nothing hidden). Items without
- * a timestamp go to `pendingKey`.
+ * Group items into the real config booking-window cycles for a schedule. Empty
+ * windows are kept so the UI shows every cycle. Items whose timestamp falls
+ * outside every window (e.g. a booking created before the window opened) are
+ * attached to the nearest window by start time so nothing is hidden. Items
+ * without a timestamp go to `pendingKey`.
  */
 export function groupBookingsIntoBoardWindows<T>(
   items: T[],
   getTimestamp: (item: T) => Date | null | undefined,
-  openDate: Date,
-  departureDate: Date,
+  direction: string | null | undefined,
+  departure: Date,
+  cfg: BoardWindowConfig,
   pendingKey = 'pending-contract',
+  anchorOpensAt?: Date | null,
 ): Map<string, { window: BoardWindow | null; items: T[] }> {
+  const windows = listConfigBookingWindows(direction, departure, cfg, anchorOpensAt);
   const map = new Map<string, { window: BoardWindow | null; items: T[] }>();
-
-  for (const w of listBoardWindowsForRange(openDate, departureDate)) {
+  for (const w of windows) {
     map.set(w.key, { window: w, items: [] });
   }
   map.set(pendingKey, { window: null, items: [] });
 
+  const firstWindow = windows[0] ?? null;
+  const lastWindow = windows[windows.length - 1] ?? null;
+
   for (const item of items) {
     const ts = getTimestamp(item);
     if (!ts) {
       map.get(pendingKey)!.items.push(item);
       continue;
     }
-    const w = boardWindowForTimestamp(ts);
-    if (!map.has(w.key)) {
-      map.set(w.key, { window: w, items: [] });
+    let w = configWindowForTimestamp(windows, ts);
+    if (!w) {
+      // Booked before the window opened → first cycle; after it closed → last cycle.
+      w =
+        firstWindow && ts.getTime() < firstWindow.start.getTime()
+          ? firstWindow
+          : lastWindow;
+    }
+    if (!w) {
+      map.get(pendingKey)!.items.push(item);
+      continue;
     }
     map.get(w.key)!.items.push(item);
   }
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 2c30a5964..0b239990b 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
@@ -310,7 +310,10 @@ export class BookingBatchService implements OnModuleInit {
   private async openRouteDayGroups(): Promise<RouteDayGroup[]> {
     const open = (
       await this.trainSchedulesRepository.findAll({
-        where: { bookingWindowStatus: "OPEN" },
+        where: [
+          { bookingWindowStatus: "OPEN", status: TrainScheduleStatusEnum.Draft },
+          { bookingWindowStatus: "OPEN", status: TrainScheduleStatusEnum.Scheduled },
+        ],
       })
     ).filter((s) => s.windowPhase == null);
     const groups = new Map<string, RouteDayGroup>();
@@ -590,6 +593,9 @@ export class BookingBatchService implements OnModuleInit {
     const board: BatchBoardSchedule[] = [];
     for (const s of schedules) {
       if (s.status === "ARRIVED" || s.status === "CANCELLED") continue;
+      // Batch board is IMPORT-only: export is FCFS with no batch/priority calc,
+      // and domestic/legacy schedules run the legacy fill, not the window batch.
+      if (s.direction !== "IMPORT") continue;
 
       const links = await linkRepo.find({ where: { trainScheduleId: s.id } });
       const linkedIds = new Set(links.map((l) => l.bookingId));
@@ -630,6 +636,12 @@ export class BookingBatchService implements OnModuleInit {
     if (s.status === "ARRIVED" || s.status === "CANCELLED") {
       throw new BadRequestException("Schedule is no longer active");
     }
+    // Batch board is IMPORT-only (export is FCFS, no batch/priority calc).
+    if (s.direction !== "IMPORT") {
+      throw new BadRequestException(
+        "The batch board only covers import schedules",
+      );
+    }
 
     const wagonLengths = await this.loadWagonLengths();
     const linkRepo = this.dataSource.getRepository(TrainScheduleBooking);
@@ -710,15 +722,43 @@ export class BookingBatchService implements OnModuleInit {
 
     const loco = s.trainSet?.locomotive ?? null;
 
-    // Display windows span the whole booking window: from when it opened
-    // (schedule creation) through the scheduled departure, in 3-hour EAT slots.
-    const openDate = s.createdAt ?? s.scheduledDepartureDate ?? new Date();
+    // Display windows are the REAL booking-window cycles this schedule was FROZEN
+    // with at creation (import: opens at its stored window time, lasts its rule's
+    // duration, reopens per its rule's delay; export: single FCFS lead window) —
+    // NOT the live global config. A later global-rules edit only re-derives
+    // not-yet-open schedules (restampPendingWindows), so an already-open schedule
+    // must keep drawing from its own snapshot, anchored on its stored open time.
+    // Legacy rows with no snapshot fall back to the live config.
+    const liveCfg = await this.trainSchedulingService.getWindowConfig();
+    const num = (v: unknown, fallback: number) => {
+      const n = v == null ? NaN : Number(v);
+      return Number.isFinite(n) ? n : fallback;
+    };
+    const windowCfg = {
+      windowOpenHour: num(s.ruleWindowOpenHour, liveCfg.windowOpenHour),
+      windowDurationHours: num(
+        s.ruleWindowDurationHours,
+        liveCfg.windowDurationHours,
+      ),
+      reopenDelayMinutes: num(s.ruleReopenDelayMinutes, liveCfg.reopenDelayMinutes),
+      importWindowLeadDays: num(
+        s.ruleImportWindowLeadDays,
+        liveCfg.importWindowLeadDays,
+      ),
+      exportBookingLeadHours: num(
+        s.ruleExportBookingLeadHours,
+        liveCfg.exportBookingLeadHours,
+      ),
+    };
     const departureDate = s.scheduledDepartureDate ?? new Date();
     const windowBuckets = groupBookingsIntoBoardWindows(
       items,
       (item) => (item.fullyExecutedAt ? new Date(item.fullyExecutedAt) : null),
-      openDate,
+      s.direction ?? null,
       departureDate,
+      windowCfg,
+      undefined,
+      s.windowOpensAt ?? null,
     );
 
     const emptyCounts = () => ({
diff --git a/apps/edr-freight-api/src/modules/train-scheduling/booking-window.service.ts b/apps/edr-freight-api/src/modules/train-scheduling/booking-window.service.ts
index f2fe5db07..da235c562 100644
--- a/apps/edr-freight-api/src/modules/train-scheduling/booking-window.service.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/booking-window.service.ts
@@ -7,6 +7,7 @@ import { TrainScheduleStatus as TrainScheduleStatusEnum } from '@edr/types';
 import { Booking } from '../bookings/entities/booking.entity';
 import { TrainSchedule } from '../train-schedules/entities/train-schedule.entity';
 import { TrainSchedulesRepository } from '../train-schedules/train-schedules.repository';
+import { NotificationsService } from '../notifications/notifications.service';
 import { BookingBatchService } from './booking-batch.service';
 import { TrainSchedulingService } from './train-scheduling.service';
 import { BATCH_TIMEZONE } from './booking-batch.constants';
@@ -19,12 +20,13 @@ import { type BookingWindowConfig } from './booking-window.config';
  * schedule row, so every transition is derived purely from the clock — a restart
  * resumes mid-phase with no loss (onModuleInit runs one tick immediately).
  *
- * Import phases: PRE_WINDOW → OPEN (customers book) → DOC_REVIEW (staff accept
- * documents) → PAYMENT (batch reserves in priority order, customers pay) →
- * reopen same day | CLOSED_FOR_DAY | DONE (full → auto-finalized).
+ * Import & domestic phases: PRE_WINDOW → OPEN (customers book) → DOC_REVIEW
+ * (staff accept documents) → PAYMENT (batch reserves in priority order, customers
+ * pay) → reopen same day | CLOSED_FOR_DAY | DONE (full → auto-finalized).
  * Export phases: PRE_WINDOW → OPEN → DONE (no batch, no priority).
- * Legacy/DOMESTIC schedules have windowPhase NULL and are served by the legacy
- * fill (runBatchFill), which this tick invokes every 5th minute.
+ * Only PRE-MIGRATION rows have windowPhase NULL; those are served by the legacy
+ * fill (runBatchFill), which this tick invokes every 5th minute. New schedules of
+ * every direction get a window phase.
  */
 @Injectable()
 export class BookingWindowService implements OnModuleInit {
@@ -37,6 +39,7 @@ export class BookingWindowService implements OnModuleInit {
     private readonly trainSchedulesRepository: TrainSchedulesRepository,
     private readonly bookingBatchService: BookingBatchService,
     private readonly trainSchedulingService: TrainSchedulingService,
+    private readonly notifications: NotificationsService,
   ) {}
 
   async onModuleInit(): Promise<void> {
@@ -156,6 +159,7 @@ export class BookingWindowService implements OnModuleInit {
         await this.bookingBatchService.setWindow(schedule.id, 'OPEN');
         schedule.bookingWindowStatus = 'OPEN';
       }
+      await this.notifyWindowOpened(schedule);
       this.logger.log(`Export booking window opened for schedule ${schedule.id}`);
       return true;
     }
@@ -193,6 +197,8 @@ export class BookingWindowService implements OnModuleInit {
         await this.bookingBatchService.setWindow(schedule.id, 'OPEN');
         schedule.bookingWindowStatus = 'OPEN';
       }
+      // Only announce the first opening of the day; reopen cycles don't re-notify.
+      if (schedule.bookingCycleNo === 1) await this.notifyWindowOpened(schedule);
       this.logger.log(
         `Import booking window opened for schedule ${schedule.id} (cycle ${schedule.bookingCycleNo})`,
       );
@@ -325,6 +331,67 @@ export class BookingWindowService implements OnModuleInit {
     }
   }
 
+  /**
+   * SMS + email every active-contract customer on this schedule's route when its
+   * booking window opens, so they can book from the portal home before it closes.
+   * Fire-and-forget; a failed notification never blocks the window transition.
+   */
+  private async notifyWindowOpened(schedule: TrainSchedule): Promise<void> {
+    try {
+      const rows: Array<{ phone: string | null; email: string | null }> =
+        await this.dataSource.query(
+          `SELECT DISTINCT
+                  COALESCE(co.contact_person_phone, co.phone) AS phone,
+                  COALESCE(co.email, co.general_manager_email) AS email
+             FROM freight.contract_routes cr
+             JOIN freight.contracts c
+               ON c.id = cr.contract_id
+              AND c.status IN ('CONTRACT_ACTIVE', 'FULLY_EXECUTED')
+              AND c.deleted_at IS NULL
+             JOIN freight.companies co ON co.id = c.company_id
+            WHERE cr.origin_yard_id = $1
+              AND cr.destination_yard_id = $2
+              AND cr.deleted_at IS NULL`,
+          [schedule.originStationId, schedule.destinationStationId],
+        );
+      if (!rows.length) return;
+
+      const closes = schedule.windowClosesAt
+        ? schedule.windowClosesAt.toLocaleString('en-GB', { timeZone: BATCH_TIMEZONE })
+        : 'later today';
+      const depart = schedule.scheduledDepartureDate.toLocaleDateString('en-GB', {
+        timeZone: BATCH_TIMEZONE,
+      });
+      const msg =
+        `Booking is now open for the train departing ${depart}. ` +
+        `Book your shipment from the portal home page before ${closes} EAT.`;
+
+      const seenPhone = new Set<string>();
+      const seenEmail = new Set<string>();
+      for (const r of rows) {
+        if (r.phone && !seenPhone.has(r.phone)) {
+          seenPhone.add(r.phone);
+          await this.notifications
+            .directSend('sms', r.phone, msg)
+            .catch((e) => this.logger.warn(`Window-open SMS failed: ${(e as Error).message}`));
+        }
+        if (r.email && !seenEmail.has(r.email)) {
+          seenEmail.add(r.email);
+          await this.notifications
+            .directSend('email', r.email, msg)
+            .catch((e) => this.logger.warn(`Window-open email failed: ${(e as Error).message}`));
+        }
+      }
+      this.logger.log(
+        `Notified ${seenPhone.size} phone / ${seenEmail.size} email contacts of open window for schedule ${schedule.id}`,
+      );
+    } catch (err) {
+      this.logger.warn(
+        `notifyWindowOpened failed for ${schedule.id}: ${(err as Error).message}`,
+      );
+    }
+  }
+
   private async setPhase(
     schedule: TrainSchedule,
     patch: Partial<
diff --git a/apps/edr-freight-api/src/modules/train-scheduling/dto/update-import-loading-status.dto.ts b/apps/edr-freight-api/src/modules/train-scheduling/dto/update-import-loading-status.dto.ts
new file mode 100644
index 000000000..25943050c
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/train-scheduling/dto/update-import-loading-status.dto.ts
@@ -0,0 +1,15 @@
+import { LoadingStatus } from '@edr/types';
+import { ApiProperty } from '@nestjs/swagger';
+import { ArrayMinSize, IsArray, IsEnum, IsUUID } from 'class-validator';
+
+export class UpdateImportLoadingStatusDto {
+  @ApiProperty({ type: [String] })
+  @IsArray()
+  @ArrayMinSize(1)
+  @IsUUID('4', { each: true })
+  bookingIds!: string[];
+
+  @ApiProperty({ enum: LoadingStatus })
+  @IsEnum(LoadingStatus)
+  loadingStatus!: LoadingStatus;
+}
diff --git a/apps/edr-freight-api/src/modules/train-scheduling/dto/update-train-scheduling-global-rules.dto.ts b/apps/edr-freight-api/src/modules/train-scheduling/dto/update-train-scheduling-global-rules.dto.ts
index 1171b0c90..2e82feb6a 100644
--- a/apps/edr-freight-api/src/modules/train-scheduling/dto/update-train-scheduling-global-rules.dto.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/dto/update-train-scheduling-global-rules.dto.ts
@@ -60,11 +60,13 @@ export class UpdateTrainSchedulingGlobalRulesDto {
   @Max(23)
   windowOpenHour?: number;
 
+  // Stored in hours. The UI enters this in minutes/hours/days and converts to
+  // hours before sending, so the floor is 1 minute (0.0166h) — not 15 min.
   @ApiPropertyOptional({ example: 3 })
   @IsOptional()
   @Type(() => Number)
   @IsNumber()
-  @Min(0.25)
+  @Min(0.0166)
   @Max(12)
   windowDurationHours?: number;
 
diff --git a/apps/edr-freight-api/src/modules/train-scheduling/entities/train-scheduling-global-rules.entity.ts b/apps/edr-freight-api/src/modules/train-scheduling/entities/train-scheduling-global-rules.entity.ts
index 7b8d9b26a..1a67bb791 100644
--- a/apps/edr-freight-api/src/modules/train-scheduling/entities/train-scheduling-global-rules.entity.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/entities/train-scheduling-global-rules.entity.ts
@@ -54,11 +54,13 @@ export class TrainSchedulingGlobalRules extends BaseEntity {
   @Column({ name: 'window_open_hour', type: 'int', default: 8 })
   windowOpenHour!: number;
 
+  // Stored in hours; 4 decimals so sub-minute UI durations (4 min = 0.0667h)
+  // are exact. See WidenWindowDurationHoursPrecision migration.
   @Column({
     name: 'window_duration_hours',
     type: 'numeric',
-    precision: 4,
-    scale: 2,
+    precision: 6,
+    scale: 4,
     default: 3,
   })
   windowDurationHours!: number;
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 8887fb4c6..773e4738a 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
@@ -28,6 +28,7 @@ import { GetEligibleBulkBookingsDto } from "./dto/get-eligible-bulk-bookings.dto
 import { GetEligibleContainerBookingsDto } from "./dto/get-eligible-container-bookings.dto";
 import { PinWagonsDto } from "./dto/pin-wagons.dto";
 import { UpdateContainerItemDto } from "./dto/update-container-item.dto";
+import { UpdateImportLoadingStatusDto } from "./dto/update-import-loading-status.dto";
 import { PreviewBulkTrainScheduleDto } from "./dto/preview-bulk-train-schedule.dto";
 import { PreviewContainerTrainScheduleDto } from "./dto/preview-container-train-schedule.dto";
 import { PreviewTrainScheduleDto } from "./dto/preview-train-schedule.dto";
@@ -60,16 +61,38 @@ export class TrainSchedulingController {
   @Get("my-booking-windows")
   @ApiOperation({
     summary:
-      "Upcoming/open booking windows on the signed-in customer's active contract lanes",
+      "Upcoming/open booking windows announced to the signed-in customer (all window-engine schedules; their own contract lanes carry a Book-now target)",
   })
   async getMyBookingWindows(@CurrentUser() user: AuthUserPayload) {
+    // Every customer sees announced windows; companyId (when resolvable) just
+    // enriches lanes they hold a contract on so "Book now" can target it.
     const companyId = await this.billingService.resolveCompanyId(
       resolveAuthUserId(user),
     );
-    if (!companyId) return [];
     return this.trainSchedulingService.getBookingWindowsForCompany(companyId);
   }
 
+  @Get("contracts/:contractId/booking-windows")
+  @ApiOperation({
+    summary:
+      "Upcoming/open booking windows on a contract's routes — gates the booking form for customer + Ethiopian GL",
+  })
+  getContractBookingWindows(
+    @Param("contractId", ParseUUIDPipe) contractId: string,
+  ) {
+    return this.trainSchedulingService.getBookingWindowsForContract(contractId);
+  }
+
+  @Get("booking-windows")
+  @TrainSchedulingView()
+  @ApiOperation({
+    summary:
+      "All announced booking windows across lanes (import cycle + export FCFS), for staff dashboards",
+  })
+  listBookingWindows() {
+    return this.trainSchedulingService.listAllBookingWindows();
+  }
+
   @Get("global-rules")
   @TrainSchedulingView()
   @ApiOperation({ summary: "Get global train scheduling rules (singleton)" })
@@ -325,6 +348,28 @@ export class TrainSchedulingController {
     return this.trainSchedulingService.getCompositionRemovals(id);
   }
 
+  @Get("schedules/:id/import-loading-bookings")
+  @TrainSchedulingView()
+  @ApiOperation({
+    summary: "List import bookings eligible for loading confirmation on this schedule",
+  })
+  getImportLoadingBookings(@Param("id", ParseUUIDPipe) id: string) {
+    return this.trainSchedulingService.getImportLoadingBookings(id);
+  }
+
+  @Patch("schedules/:id/import-loading-status")
+  @TrainSchedulingManage()
+  @ApiOperation({
+    summary:
+      "Mark import bookings loaded/unloaded on this schedule (tracking only, does not affect dispatch)",
+  })
+  updateImportLoadingStatus(
+    @Param("id", ParseUUIDPipe) id: string,
+    @Body() dto: UpdateImportLoadingStatusDto,
+  ) {
+    return this.trainSchedulingService.updateImportLoadingStatus(id, dto);
+  }
+
   @Post("schedules/:id/pin-wagons")
   @TrainSchedulingManage()
   @ApiOperation({ summary: "Pin physical wagons to train set slots" })
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 ce835e1e4..bf93cf391 100644
--- a/apps/edr-freight-api/src/modules/train-scheduling/train-scheduling.service.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/train-scheduling.service.ts
@@ -1,5 +1,6 @@
 import {
   AllocationLoadType,
+  LoadingStatus,
   SchedulingStatus,
   TrainCheckpointKind,
   TrainScheduleStatus as TrainScheduleStatusEnum,
@@ -9,15 +10,17 @@ import {
   BadRequestException,
   ConflictException,
   Injectable,
+  Logger,
   NotFoundException,
 } from '@nestjs/common';
 import { ConfigService } from '@nestjs/config';
 import { InjectDataSource } from '@nestjs/typeorm';
-import { DataSource, EntityManager, In, Not } from 'typeorm';
+import { DataSource, EntityManager, In, IsNull, Not } from 'typeorm';
 
 import { BookingsRepository } from '../bookings/bookings.repository';
 import { Booking } from '../bookings/entities/booking.entity';
 import { BookingContainer } from '../bookings/entities/booking-container.entity';
+import { ClearanceMilestone } from '../contracts/entities/clearance-milestone.entity';
 import { Container } from '../container-management/entities/container.entity';
 import { Locomotive } from '../locomotives/entities/locomotive.entity';
 import { LocomotivesRepository } from '../locomotives/locomotives.repository';
@@ -36,6 +39,8 @@ import { WagonAllocationBulkLoadsRepository } from '../train-schedules/wagon-all
 import { WagonAllocationContainerItemsRepository } from '../train-schedules/wagon-allocation-container-items.repository';
 import { WagonBookingAllocationsRepository } from '../train-schedules/wagon-booking-allocations.repository';
 import { WagonType } from '../wagon-types/entities/wagon-type.entity';
+import { CargoType } from '../rule-engine/entities/cargo-type.entity';
+import { ContainerType } from '../rule-engine/entities/container-type.entity';
 import { WagonTypesRepository } from '../wagon-types/wagon-types.repository';
 import { Wagon } from '../wagons/entities/wagon.entity';
 import { AssignBookingsDto } from './dto/assign-bookings.dto';
@@ -45,6 +50,7 @@ import { GetEligibleBulkBookingsDto } from './dto/get-eligible-bulk-bookings.dto
 import { GetEligibleContainerBookingsDto } from './dto/get-eligible-container-bookings.dto';
 import { PinWagonsDto } from './dto/pin-wagons.dto';
 import { UpdateContainerItemDto } from './dto/update-container-item.dto';
+import { UpdateImportLoadingStatusDto } from './dto/update-import-loading-status.dto';
 import { PreviewBulkTrainScheduleDto } from './dto/preview-bulk-train-schedule.dto';
 import { PreviewContainerTrainScheduleDto } from './dto/preview-container-train-schedule.dto';
 import { PreviewTrainScheduleDto } from './dto/preview-train-schedule.dto';
@@ -84,10 +90,6 @@ import {
   type ContainerPlacementInput,
   type WagonPlanSlot,
 } from './wagon-plan.util';
-import {
-  getDefaultContainerWagonTypeCode,
-  pickBulkWagonType,
-} from './wagon-type-resolver.util';
 import { deriveScheduleDirection } from './derive-schedule-direction.util';
 import { pickLowestFreeNumber, pickTrainNumberPool } from './train-number.util';
 import {
@@ -102,6 +104,7 @@ import {
 import {
   computeExportWindowTimes,
   computeImportWindowTimes,
+  earliestSchedulableDeparture,
   eatDay,
 } from './batch-window.util';
 import { TrainCheckpointEvent } from './entities/train-checkpoint-event.entity';
@@ -168,8 +171,30 @@ const DEFAULT_TRAIN_LIMITS: Required<TrainLimitConfig> = {
   max20ftPairWeightDiffTons: 10,
 };
 
+/** Raw row shape for the booking-window queries (company- and contract-scoped). */
+interface BookingWindowRow {
+  schedule_id: string;
+  contract_id: string | null;
+  contract_kind: string | null;
+  direction: string | null;
+  window_phase: string | null;
+  window_opens_at: Date | null;
+  window_closes_at: Date | null;
+  doc_review_ends_at: Date | null;
+  payment_phase_ends_at: Date | null;
+  booking_window_status: string;
+  booking_cycle_no: number;
+  scheduled_departure_date: Date;
+  origin_label: string | null;
+  origin_code: string | null;
+  destination_label: string | null;
+  destination_code: string | null;
+}
+
 @Injectable()
 export class TrainSchedulingService {
+  private readonly logger = new Logger(TrainSchedulingService.name);
+
   constructor(
     @InjectDataSource()
     private readonly dataSource: DataSource,
@@ -248,7 +273,76 @@ export class TrainSchedulingService {
     if (dto.docReviewMinutes != null) row.docReviewMinutes = dto.docReviewMinutes;
     if (dto.paymentWindowMinutes != null) row.paymentWindowMinutes = dto.paymentWindowMinutes;
     if (dto.reopenDelayMinutes != null) row.reopenDelayMinutes = dto.reopenDelayMinutes;
-    return this.dataSource.getRepository(TrainSchedulingGlobalRules).save(row);
+
+    // Fields that change the STAMPED open/close times of a schedule. docReview/
+    // payment/reopen are read live by the cron each tick, so they need no
+    // re-stamp; only the four below feed computeImport/ExportWindowTimes.
+    const windowTimingChanged =
+      dto.importWindowLeadDays != null ||
+      dto.windowOpenHour != null ||
+      dto.windowDurationHours != null ||
+      dto.exportBookingLeadHours != null;
+
+    const saved = await this.dataSource
+      .getRepository(TrainSchedulingGlobalRules)
+      .save(row);
+
+    // The cron reads config fresh every tick, so derived timings (doc review,
+    // payment, reopen) take effect on the next tick with no restart. But each
+    // schedule's initial open/close times were FROZEN at creation — re-stamp the
+    // ones whose window has not opened yet so a config edit applies to them too.
+    if (windowTimingChanged) {
+      await this.restampPendingWindows();
+    }
+
+    return saved;
+  }
+
+  /**
+   * Re-derive windowOpensAt/windowClosesAt for schedules whose booking window has
+   * not opened yet (windowPhase === 'PRE_WINDOW', still Draft/Scheduled, departure
+   * in the future) using the CURRENT global-rules config. Schedules already OPEN or
+   * past their window are left untouched — customers may have booked against the
+   * times they were shown, so those stay frozen. Returns the count re-stamped.
+   */
+  async restampPendingWindows(): Promise<number> {
+    const cfg = await this.getWindowConfig();
+    const now = new Date();
+    const schedules = await this.trainSchedulesRepository.findAll({
+      where: [
+        { status: TrainScheduleStatusEnum.Draft, windowPhase: 'PRE_WINDOW' },
+        { status: TrainScheduleStatusEnum.Scheduled, windowPhase: 'PRE_WINDOW' },
+      ],
+    });
+
+    const repo = this.dataSource.getRepository(TrainSchedule);
+    let restamped = 0;
+    for (const s of schedules) {
+      if (!s.scheduledDepartureDate || s.scheduledDepartureDate <= now) continue;
+      const times =
+        s.direction === 'EXPORT'
+          ? computeExportWindowTimes(s.scheduledDepartureDate, cfg)
+          : computeImportWindowTimes(s.scheduledDepartureDate, cfg, now);
+      // A not-yet-open schedule legitimately adopts the new rule, so refresh its
+      // snapshot alongside the re-stamped times — the board then draws the new
+      // window from this same rule.
+      await repo.update(s.id, {
+        windowOpensAt: times.windowOpensAt,
+        windowClosesAt: times.windowClosesAt,
+        ruleWindowOpenHour: cfg.windowOpenHour,
+        ruleWindowDurationHours: cfg.windowDurationHours,
+        ruleReopenDelayMinutes: cfg.reopenDelayMinutes,
+        ruleImportWindowLeadDays: cfg.importWindowLeadDays,
+        ruleExportBookingLeadHours: cfg.exportBookingLeadHours,
+      });
+      restamped += 1;
+    }
+    if (restamped > 0) {
+      this.logger.log(
+        `Re-stamped booking windows for ${restamped} pending schedule(s) after a global-rules change`,
+      );
+    }
+    return restamped;
   }
 
   /**
@@ -383,24 +477,54 @@ export class TrainSchedulingService {
       // Effective capacity is capped by the weakest locomotive in the set.
       const limitLoco = minLocomotiveLimits(lockedLocomotives) ?? undefined;
       const departure = new Date(dto.scheduleDate);
-      // IMPORT/EXPORT trains start with a CLOSED customer window; the window engine
-      // opens it on schedule (import: booking day at 08:00 EAT; export: 24h lead).
-      // DOMESTIC keeps the legacy always-OPEN behavior (windowPhase stays NULL).
+      // Every schedule starts with a CLOSED customer window; the window engine opens
+      // 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();
+
+      // 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 = {
+        ruleWindowOpenHour: windowCfg.windowOpenHour,
+        ruleWindowDurationHours: windowCfg.windowDurationHours,
+        ruleReopenDelayMinutes: windowCfg.reopenDelayMinutes,
+        ruleImportWindowLeadDays: windowCfg.importWindowLeadDays,
+        ruleExportBookingLeadHours: windowCfg.exportBookingLeadHours,
+      };
       const windowFields =
-        direction === 'IMPORT'
+        direction === 'EXPORT'
           ? {
               bookingWindowStatus: 'CLOSED',
               windowPhase: 'PRE_WINDOW',
-              ...computeImportWindowTimes(departure, windowCfg, new Date()),
+              ...ruleSnapshot,
+              ...computeExportWindowTimes(departure, windowCfg),
             }
-          : direction === 'EXPORT'
-            ? {
-                bookingWindowStatus: 'CLOSED',
-                windowPhase: 'PRE_WINDOW',
-                ...computeExportWindowTimes(departure, windowCfg),
-              }
-            : {};
+          : {
+              // IMPORT and DOMESTIC share the import booking-day window cycle.
+              bookingWindowStatus: 'CLOSED',
+              windowPhase: 'PRE_WINDOW',
+              ...ruleSnapshot,
+              ...computeImportWindowTimes(departure, windowCfg, new Date()),
+            };
       const schedule = manager.getRepository(TrainSchedule).create({
         trainSetId: trainSet.id,
         routeId: route.id,
@@ -480,16 +604,22 @@ export class TrainSchedulingService {
     );
 
     if (!validation.valid) {
+      // Put the violation detail in the message itself — global exception
+      // filters flatten the body, and "Booking validation failed" alone tells
+      // staff nothing (e.g. which wagon type is missing at the yard).
       throw new BadRequestException({
-        message: 'Booking validation failed',
+        message: `Booking validation failed: ${validation.violations.join('; ')}`,
         violations: validation.violations,
         warnings: validation.warnings,
       });
     }
 
     if (!validation.bookings.length) {
+      const shortfall = validation.deferredBookings
+        .map((d) => `${d.reference}: ${d.reason}`)
+        .join('; ');
       throw new BadRequestException({
-        message: 'No bookings fit on available fleet wagons',
+        message: `No wagons available for the selected bookings${shortfall ? ` — ${shortfall}` : ''}`,
         violations: ['Insufficient fleet wagons for the selected bookings'],
         warnings: validation.warnings,
         deferredBookings: validation.deferredBookings,
@@ -503,12 +633,14 @@ export class TrainSchedulingService {
     if (!limitLoco) {
       throw new BadRequestException('Schedule train set has no locomotives');
     }
-    if (limitLoco.maxPullWeightTons < totalWeightTons) {
+    // forceAssign lets staff overload the locomotive set knowingly — the
+    // validator has already surfaced it as a warning in that case.
+    if (!dto.forceAssign && limitLoco.maxPullWeightTons < totalWeightTons) {
       throw new BadRequestException(
         `Train set locomotives cannot pull ${totalWeightTons}T`,
       );
     }
-    if (limitLoco.maxTrainLengthMeters < totalLengthMeters) {
+    if (!dto.forceAssign && limitLoco.maxTrainLengthMeters < totalLengthMeters) {
       throw new BadRequestException(
         `Train set locomotives cannot support ${totalLengthMeters}m`,
       );
@@ -744,6 +876,87 @@ export class TrainSchedulingService {
     );
   }
 
+  async getImportLoadingBookings(scheduleId: string) {
+    const schedule = await this.trainSchedulesRepository.findById(scheduleId);
+    if (!schedule) {
+      throw new NotFoundException(`Train schedule ${scheduleId} not found`);
+    }
+
+    const [scheduleBookings, allocations] = await Promise.all([
+      this.trainScheduleBookingsRepository.findByScheduleId(scheduleId),
+      this.wagonBookingAllocationsRepository.findByScheduleId(scheduleId),
+    ]);
+    if (!scheduleBookings.length) {
+      return { count: 0, items: [] };
+    }
+
+    const allocatedBookingIds = new Set(allocations.map((a) => a.bookingId));
+    const statusByBookingId = new Map(
+      scheduleBookings.map((sb) => [sb.bookingId, sb.loadingStatus]),
+    );
+    const candidateIds = scheduleBookings
+      .map((sb) => sb.bookingId)
+      .filter((id) => allocatedBookingIds.has(id));
+    if (!candidateIds.length) {
+      return { count: 0, items: [] };
+    }
+
+    const bookings = await this.bookingsRepository.findByIdsForScheduling(candidateIds);
+    const items = bookings
+      .filter((b) => b.tradeDirection === 'IMPORT' && b.paymentStatus === 'PAID')
+      .map((b) => ({
+        id: b.id,
+        reference: b.reference ?? null,
+        customer: b.company?.name ?? null,
+        weightTons: b.cargoTotalWeightVgm,
+        loadingStatus: statusByBookingId.get(b.id) ?? LoadingStatus.Unloaded,
+      }));
+    return { count: items.length, items };
+  }
+
+  async updateImportLoadingStatus(scheduleId: string, dto: UpdateImportLoadingStatusDto) {
+    const schedule = await this.trainSchedulesRepository.findById(scheduleId);
+    if (!schedule) {
+      throw new NotFoundException(`Train schedule ${scheduleId} not found`);
+    }
+
+    const [scheduleBookings, allocations, bookings] = await Promise.all([
+      this.trainScheduleBookingsRepository.findByScheduleId(scheduleId),
+      this.wagonBookingAllocationsRepository.findByScheduleId(scheduleId),
+      this.bookingsRepository.findByIdsForScheduling(dto.bookingIds),
+    ]);
+
+    const scheduledIds = new Set(scheduleBookings.map((sb) => sb.bookingId));
+    const allocatedIds = new Set(allocations.map((a) => a.bookingId));
+    const bookingById = new Map(bookings.map((b) => [b.id, b]));
+
+    const invalid: string[] = [];
+    for (const id of dto.bookingIds) {
+      const booking = bookingById.get(id);
+      if (
+        !scheduledIds.has(id) ||
+        !allocatedIds.has(id) ||
+        !booking ||
+        booking.tradeDirection !== 'IMPORT' ||
+        booking.paymentStatus !== 'PAID'
+      ) {
+        invalid.push(id);
+      }
+    }
+    if (invalid.length) {
+      throw new BadRequestException(
+        `Not eligible for import loading confirmation on this schedule: ${invalid.join(', ')}`,
+      );
+    }
+
+    await this.trainScheduleBookingsRepository.updateLoadingStatusMany(
+      scheduleId,
+      dto.bookingIds,
+      dto.loadingStatus,
+    );
+    return this.getImportLoadingBookings(scheduleId);
+  }
+
   async pinWagons(scheduleId: string, dto: PinWagonsDto) {
     const schedule = await this.trainSchedulesRepository.findByIdWithFullGraph(scheduleId);
     if (!schedule) {
@@ -956,12 +1169,47 @@ export class TrainSchedulingService {
       notes: dto.notes ?? operation.notes ?? null,
     });
 
+    await this.completeGatepassMilestoneForSchedule(scheduleId, securedAt);
+
     console.log(
       `[NOTIFY] Gate pass secured for train ${schedule.trainNumber ?? schedule.id}; Djibouti Port entry is allowed.`,
     );
     return this.getImportDjiboutiOperation(schedule.id);
   }
 
+  /**
+   * Bridge write: also flips the legacy clearance-side GATEPASS_GRANTED
+   * milestone for every customs booking on this schedule, so contract/booking
+   * clearance views still reading that milestone (older deployed builds) see
+   * the gate pass as done. Drop once every clearance-api deployment reads
+   * ImportDjiboutiOperation.gatepassGrantedAt directly.
+   */
+  private async completeGatepassMilestoneForSchedule(
+    scheduleId: string,
+    securedAt: Date,
+  ): Promise<void> {
+    const bookings = await this.dataSource.getRepository(Booking).find({
+      where: { trainScheduleId: scheduleId, customsClearingEnabled: true },
+    });
+    if (bookings.length === 0) return;
+
+    const milestoneRepo = this.dataSource.getRepository(ClearanceMilestone);
+    const rows = await milestoneRepo.find({
+      where: {
+        bookingId: In(bookings.map((b) => b.id)),
+        milestoneCode: 'GATEPASS_GRANTED',
+      },
+    });
+
+    for (const row of rows) {
+      if (row.status === 'COMPLETED') continue;
+      row.status = 'COMPLETED';
+      row.triggeredAt = securedAt;
+      row.metadata = { ...(row.metadata ?? {}), gatepassAt: securedAt.toISOString() };
+      await milestoneRepo.save(row);
+    }
+  }
+
   async markImportReadyForLoading(scheduleId: string, dto: ImportDjiboutiActionDto = {}) {
     const schedule = await this.getImportDjiboutiSchedule(scheduleId);
     const operation = await this.getOrCreateImportDjiboutiOperation(scheduleId);
@@ -995,9 +1243,7 @@ export class TrainSchedulingService {
     const schedule = await this.getImportDjiboutiSchedule(scheduleId);
     const operation = await this.getOrCreateImportDjiboutiOperation(scheduleId);
     this.assertImportDjiboutiGatepassGranted(operation);
-    if (!operation.loadedOnTrainAt) {
-      throw new BadRequestException('Import train cannot depart Djibouti before loading is confirmed');
-    }
+    // Loading confirmation does not block departure (see assertImportDjiboutiMayDepart).
 
     if (schedule.status === TrainScheduleStatusEnum.Scheduled) {
       await this.dispatchSchedule(schedule.id);
@@ -1053,7 +1299,9 @@ export class TrainSchedulingService {
       performedBy: 'DOCUMENT_GENERATION',
     });
     const html = this.buildImportLoadListHtml(loadList);
-    const buffer = await this.pdfDocuments.htmlToPdfBuffer(html);
+    // Generic render — NOT the release-order fallback (would mislabel this as a
+    // gate-clearance / release order when Chromium is unavailable).
+    const buffer = await this.pdfDocuments.renderDocumentHtml(html, 'Import marshalling / load list');
     const reference = loadList.trainNumber ?? loadList.trainScheduleId;
     return {
       filename: `import-marshalling-${this.safeDocumentName(reference)}.pdf`,
@@ -1071,7 +1319,8 @@ export class TrainSchedulingService {
     }
 
     const html = this.buildExportLoadListHtml(schedule);
-    const buffer = await this.pdfDocuments.htmlToPdfBuffer(html);
+    // Generic render — NOT the release-order fallback (see importLoadListDocument).
+    const buffer = await this.pdfDocuments.renderDocumentHtml(html, 'Export marshalling / load list');
     const reference = schedule.trainNumber ?? schedule.id;
     return {
       filename: `export-marshalling-${this.safeDocumentName(reference)}.pdf`,
@@ -1371,9 +1620,9 @@ export class TrainSchedulingService {
       where: { trainScheduleId: schedule.id },
     });
     this.assertImportDjiboutiGatepassGranted(operation);
-    if (!operation?.loadedOnTrainAt) {
-      throw new BadRequestException('Import train cannot depart Djibouti before loading is confirmed');
-    }
+    // Loading confirmation does NOT gate dispatch. Per-booking loading is
+    // tracking only and the loaded-on-train step is optional — a scheduled train
+    // dispatches without waiting on loading.
   }
 
   private async getImportDjiboutiSchedule(scheduleId: string): Promise<TrainSchedule> {
@@ -1837,7 +2086,9 @@ export class TrainSchedulingService {
       await this.trainSchedulesRepository.updateStatus(
         id,
         TrainScheduleStatusEnum.Cancelled,
-        {},
+        // Retire the booking window so a canceled schedule never lingers as an
+        // "open window" in booking-window lists or the legacy batch fill.
+        { bookingWindowStatus: 'CLOSED', windowPhase: 'DONE' },
         manager,
       );
       if (schedule.trainSetId) {
@@ -2045,9 +2296,16 @@ export class TrainSchedulingService {
       max20ftPairWeightDiffTons: trainLimits.max20ftPairWeightDiffTons,
     };
 
+    // With forceAssign, capacity-shaped rules (train limits, total weight,
+    // locomotive capability) become warnings — staff owns the override. Physical
+    // impossibilities (no wagon of the required type at the yard, wrong route,
+    // wrong status) can never be forced and stay violations.
+    const pushLimit = (issues: string[]) =>
+      forceAssign ? warnings.push(...issues) : violations.push(...issues);
+
     if (resolvedMode === 'MIXED') {
-      violations.push(
-        ...validateMixedTrainLimits(wagonPlan, [containerWagonType, bulkWagonType], trainLimits),
+      pushLimit(
+        validateMixedTrainLimits(wagonPlan, [containerWagonType, bulkWagonType], trainLimits),
       );
       if (requireContainerPlacements) {
         const containerBookings = fittingBookings.filter((b) => b.freightType === 'CONTAINER');
@@ -2064,7 +2322,7 @@ export class TrainSchedulingService {
         );
       }
     } else {
-      violations.push(...validateTrainLimits(wagonPlan, wagonType, trainLimits));
+      pushLimit(validateTrainLimits(wagonPlan, wagonType, trainLimits));
 
       if (requireContainerPlacements && resolvedMode === 'CONTAINER') {
         violations.push(
@@ -2087,8 +2345,8 @@ export class TrainSchedulingService {
     );
     if (totalWeightTons > trainLimits.maxWeightTons) {
       const message = `Total booking weight ${totalWeightTons}T exceeds max train weight ${trainLimits.maxWeightTons}T`;
-      if (!violations.includes(message)) {
-        violations.push(message);
+      if (!violations.includes(message) && !warnings.includes(message)) {
+        pushLimit([message]);
       }
     }
 
@@ -2115,9 +2373,9 @@ export class TrainSchedulingService {
         (setLimits.maxPullWeightTons < totalWeightTons ||
           setLimits.maxTrainLengthMeters < totalLengthMeters)
       ) {
-        violations.push(
+        pushLimit([
           'Assigned locomotives cannot support the total train weight and length',
-        );
+        ]);
       }
     } else {
       const inServiceLocomotives = await this.locomotivesRepository.findAll({
@@ -2135,7 +2393,7 @@ export class TrainSchedulingService {
             Number(l.maxTrainLengthMeters) >= totalLengthMeters,
         )
       ) {
-        violations.push('No locomotive can support the total train weight and length');
+        pushLimit(['No locomotive can support the total train weight and length']);
       }
     }
 
@@ -2504,28 +2762,98 @@ export class TrainSchedulingService {
     return violations;
   }
 
+  /**
+   * Resolve the wagon type for a batch through the cargo-type / container-type
+   * `wagon_type_id` FK (replaces the former load-type string matching). Throws
+   * when the relevant type has no wagon type configured — scheduling is blocked
+   * until an admin assigns one on the cargo-type / container-type config screen.
+   */
   private async resolveWagonType(
     freightType: 'CONTAINER' | 'BULK',
     bookingIds: string[],
   ): Promise<WagonType> {
+    const bookings = await this.bookingsRepository.findByIdsForScheduling(bookingIds);
+
     if (freightType === 'CONTAINER') {
-      const [wagonType] = await this.wagonTypesRepository.findAll({
-        where: { code: getDefaultContainerWagonTypeCode(), isActive: true },
-      });
-      if (!wagonType) {
-        throw new NotFoundException(`Wagon type ${getDefaultContainerWagonTypeCode()} not found`);
+      // First container type present on the batch drives the container wagon
+      // type (matches the prior single-wagon-type-per-consist behavior).
+      const containerType = bookings
+        .flatMap((b) => b.bookingContainers ?? [])
+        .map((line) => line.containerType)
+        .find((ct): ct is NonNullable<typeof ct> => Boolean(ct));
+      if (!containerType) {
+        throw new BadRequestException('No container type found on the container booking(s)');
       }
+      const wagonType = await this.loadWagonTypeForType(
+        containerType.wagonTypeId ?? null,
+        `Container type "${containerType.label ?? containerType.code}"`,
+      );
       return wagonType;
     }
 
-    const bookings = await this.bookingsRepository.findByIdsForScheduling(bookingIds);
-    const cargoCode = bookings[0]?.cargoType?.code ?? null;
-    const wagonTypes = await this.wagonTypesRepository.findAll({ where: { isActive: true } });
-    const picked = pickBulkWagonType(wagonTypes, cargoCode);
-    if (!picked) {
-      throw new NotFoundException('No suitable bulk wagon type found');
+    const cargoType = bookings.map((b) => b.cargoType).find((ct) => Boolean(ct));
+    if (!cargoType) {
+      throw new BadRequestException('No cargo type found on the bulk booking(s)');
     }
-    return picked;
+    return this.loadWagonTypeForType(
+      cargoType.wagonTypeId ?? null,
+      `Cargo type "${cargoType.cargoTypeName ?? cargoType.code}"`,
+    );
+  }
+
+  /**
+   * Load an active wagon type by FK id, throwing a clear error when the id is
+   * unset (type not configured) or points at a missing/inactive wagon type.
+   */
+  private async loadWagonTypeForType(
+    wagonTypeId: string | null,
+    typeLabel: string,
+  ): Promise<WagonType> {
+    if (!wagonTypeId) {
+      throw new BadRequestException(
+        `${typeLabel} has no wagon type configured — set one on its configuration before scheduling.`,
+      );
+    }
+    const [wagonType] = await this.wagonTypesRepository.findAll({
+      where: { id: wagonTypeId, isActive: true },
+    });
+    if (!wagonType) {
+      throw new NotFoundException(
+        `${typeLabel} references wagon type ${wagonTypeId}, which was not found or is inactive.`,
+      );
+    }
+    return wagonType;
+  }
+
+  /**
+   * Soft wagon-type resolution for the customer-facing availability preview
+   * (getAvailableDaysForCargo). Reads the configured FK by cargo/container type;
+   * returns null (→ "no days") instead of throwing when nothing is configured,
+   * since this only estimates which days have wagons and creates no booking.
+   */
+  private async resolveWagonTypeForPreview(
+    freightType: 'CONTAINER' | 'BULK',
+    cargoTypeCode: string | null,
+  ): Promise<WagonType | null> {
+    if (freightType === 'BULK') {
+      if (!cargoTypeCode) return null;
+      const cargoType = await this.dataSource.getRepository(CargoType).findOne({
+        where: { code: cargoTypeCode },
+        relations: { wagonType: true },
+      });
+      return cargoType?.wagonType?.isActive ? cargoType.wagonType : null;
+    }
+
+    // Container preview: the input carries no specific container type, so use the
+    // wagon type of the first configured (active) container type.
+    const containerType = await this.dataSource
+      .getRepository(ContainerType)
+      .findOne({
+        where: { isActive: true, wagonTypeId: Not(IsNull()) },
+        relations: { wagonType: true },
+        order: { displayOrder: 'ASC' },
+      });
+    return containerType?.wagonType?.isActive ? containerType.wagonType : null;
   }
 
   private async persistTrainSetWagons(
@@ -2915,42 +3243,39 @@ export class TrainSchedulingService {
   }
 
   /**
-   * Upcoming/open booking windows for a customer's active-contract lanes —
-   * powers the portal home "booking windows" section. Only window-engine
-   * schedules (IMPORT cycle / EXPORT lead) are listed; DOMESTIC trains are
-   * always open and need no announcement.
+   * Upcoming/open booking windows announced on the portal home "booking
+   * windows" section. ALL window-engine schedules (IMPORT cycle / EXPORT lead)
+   * are listed so every customer sees what is opening — not just those on their
+   * contract lanes; DOMESTIC trains are always open and need no announcement.
+   *
+   * When `companyId` is given, a matching active contract on the lane is
+   * LEFT-JOINed in so the row carries `contractId`/`contractKind` (enabling
+   * "Book now"); customers with no covering contract still see the window with a
+   * null contract, and the portal routes them to the contract list to get one.
    */
-  async getBookingWindowsForCompany(companyId: string) {
-    const rows: Array<{
-      schedule_id: string;
-      direction: string | null;
-      window_phase: string | null;
-      window_opens_at: Date | null;
-      window_closes_at: Date | null;
-      booking_window_status: string;
-      booking_cycle_no: number;
-      scheduled_departure_date: Date;
-      origin_label: string | null;
-      origin_code: string | null;
-      destination_label: string | null;
-      destination_code: string | null;
-    }> = await this.dataSource.query(
-      `SELECT DISTINCT ts.id AS schedule_id,
+  async getBookingWindowsForCompany(companyId: string | null) {
+    const rows: Array<BookingWindowRow> = await this.dataSource.query(
+      `SELECT DISTINCT ON (ts.id)
+              ts.id AS schedule_id,
+              cr.contract_id AS contract_id,
+              c.contract_kind AS contract_kind,
               ts.direction,
               ts.window_phase,
               ts.window_opens_at,
               ts.window_closes_at,
+              ts.doc_review_ends_at,
+              ts.payment_phase_ends_at,
               ts.booking_window_status,
               ts.booking_cycle_no,
               ts.scheduled_departure_date,
               oy.label AS origin_label, oy.code AS origin_code,
               dy.label AS destination_label, dy.code AS destination_code
          FROM freight.train_schedules ts
-         JOIN freight.contract_routes cr
+         LEFT JOIN freight.contract_routes cr
            ON cr.origin_yard_id = ts.origin_station_id
           AND cr.destination_yard_id = ts.destination_station_id
           AND cr.deleted_at IS NULL
-         JOIN freight.contracts c
+         LEFT JOIN freight.contracts c
            ON c.id = cr.contract_id
           AND c.company_id = $1
           AND c.status IN ('CONTRACT_ACTIVE', 'FULLY_EXECUTED')
@@ -2962,22 +3287,123 @@ export class TrainSchedulingService {
           AND ts.window_phase IS NOT NULL
           AND ts.window_phase NOT IN ('DONE', 'CLOSED_FOR_DAY')
           AND ts.scheduled_departure_date >= now()
-        ORDER BY ts.window_opens_at ASC NULLS LAST`,
+        ORDER BY ts.id, c.id NULLS LAST, ts.window_opens_at ASC NULLS LAST`,
       [companyId],
     );
+    return rows
+      .map((r) => this.mapBookingWindowRow(r))
+      .sort((a, b) => {
+        const ta = a.windowOpensAt ? new Date(a.windowOpensAt).getTime() : Infinity;
+        const tb = b.windowOpensAt ? new Date(b.windowOpensAt).getTime() : Infinity;
+        return ta - tb;
+      });
+  }
+
+  /**
+   * Upcoming/open booking windows on a single contract's routes. Used to gate the
+   * booking form for the customer AND Ethiopian GL (who books on the customer's
+   * behalf): no window row with isOpenNow=true → booking entry is hidden.
+   */
+  async getBookingWindowsForContract(contractId: string) {
+    const rows: Array<BookingWindowRow> = await this.dataSource.query(
+      `SELECT DISTINCT ts.id AS schedule_id,
+              cr.contract_id AS contract_id,
+              c.contract_kind AS contract_kind,
+              ts.direction,
+              ts.window_phase,
+              ts.window_opens_at,
+              ts.window_closes_at,
+              ts.doc_review_ends_at,
+              ts.payment_phase_ends_at,
+              ts.booking_window_status,
+              ts.booking_cycle_no,
+              ts.scheduled_departure_date,
+              oy.label AS origin_label, oy.code AS origin_code,
+              dy.label AS destination_label, dy.code AS destination_code
+         FROM freight.train_schedules ts
+         JOIN freight.contract_routes cr
+           ON cr.origin_yard_id = ts.origin_station_id
+          AND cr.destination_yard_id = ts.destination_station_id
+          AND cr.contract_id = $1
+          AND cr.deleted_at IS NULL
+         JOIN freight.contracts c
+           ON c.id = cr.contract_id
+          AND c.deleted_at IS NULL
+         LEFT JOIN freight.yards oy ON oy.id = ts.origin_station_id
+         LEFT JOIN freight.yards dy ON dy.id = ts.destination_station_id
+        WHERE ts.deleted_at IS NULL
+          AND ts.status IN ('DRAFT', 'SCHEDULED')
+          AND ts.window_phase IS NOT NULL
+          AND ts.window_phase NOT IN ('DONE', 'CLOSED_FOR_DAY')
+          AND ts.scheduled_departure_date >= now()
+        ORDER BY ts.window_opens_at ASC NULLS LAST`,
+      [contractId],
+    );
+    return rows.map((r) => this.mapBookingWindowRow(r));
+  }
+
+  /**
+   * All announced booking windows across every lane — import window cycles AND
+   * export FCFS lead windows — for staff dashboards (GL clearance queue). Same
+   * phase filter as the customer-facing lists, no contract scoping.
+   */
+  async listAllBookingWindows() {
+    const rows: Array<
+      Omit<BookingWindowRow, 'contract_id' | 'contract_kind'> & {
+        train_number: string | null;
+      }
+    > = await this.dataSource.query(
+      `SELECT ts.id AS schedule_id,
+              ts.train_number,
+              ts.direction,
+              ts.window_phase,
+              ts.window_opens_at,
+              ts.window_closes_at,
+              ts.doc_review_ends_at,
+              ts.payment_phase_ends_at,
+              ts.booking_window_status,
+              ts.booking_cycle_no,
+              ts.scheduled_departure_date,
+              oy.label AS origin_label, oy.code AS origin_code,
+              dy.label AS destination_label, dy.code AS destination_code
+         FROM freight.train_schedules ts
+         LEFT JOIN freight.yards oy ON oy.id = ts.origin_station_id
+         LEFT JOIN freight.yards dy ON dy.id = ts.destination_station_id
+        WHERE ts.deleted_at IS NULL
+          AND ts.status IN ('DRAFT', 'SCHEDULED')
+          AND ts.window_phase IS NOT NULL
+          AND ts.window_phase NOT IN ('DONE', 'CLOSED_FOR_DAY')
+          AND ts.scheduled_departure_date >= now()
+        ORDER BY ts.window_opens_at ASC NULLS LAST`,
+    );
     return rows.map((r) => ({
+      ...this.mapBookingWindowRow({
+        ...r,
+        contract_id: null,
+        contract_kind: null,
+      }),
+      trainNumber: r.train_number,
+    }));
+  }
+
+  private mapBookingWindowRow(r: BookingWindowRow) {
+    return {
       scheduleId: r.schedule_id,
+      contractId: r.contract_id,
+      contractKind: r.contract_kind,
       direction: r.direction,
       windowPhase: r.window_phase,
       isOpenNow: r.window_phase === 'OPEN' && r.booking_window_status === 'OPEN',
       windowOpensAt: r.window_opens_at,
       windowClosesAt: r.window_closes_at,
+      docReviewEndsAt: r.doc_review_ends_at,
+      paymentPhaseEndsAt: r.payment_phase_ends_at,
       bookingWindowStatus: r.booking_window_status,
       bookingCycleNo: r.booking_cycle_no,
       departureDate: r.scheduled_departure_date,
       origin: r.origin_label ?? r.origin_code ?? null,
       destination: r.destination_label ?? r.destination_code ?? null,
-    }));
+    };
   }
 
   /** OPEN schedules a new booking may target (with rough remaining capacity).
@@ -3100,15 +3526,12 @@ export class TrainSchedulingService {
     );
     if (schedules.length === 0) return { days: [] };
 
-    const wagonTypes = await this.dataSource.getRepository(WagonType).find();
-
-    // Resolve the wagon type this cargo needs.
-    const requiredType =
-      input.freightType === 'BULK'
-        ? pickBulkWagonType(wagonTypes, input.cargoTypeCode)
-        : wagonTypes.find(
-            (wt) => wt.code === getDefaultContainerWagonTypeCode() && wt.isActive,
-          );
+    // Resolve the wagon type this cargo needs via the cargo/container-type FK.
+    // Soft (customer availability preview): no days if unresolved, never throws.
+    const requiredType = await this.resolveWagonTypeForPreview(
+      input.freightType,
+      input.cargoTypeCode ?? null,
+    );
     if (!requiredType) return { days: [] };
 
     // How many wagons of that type the cargo needs.
@@ -3174,6 +3597,53 @@ export class TrainSchedulingService {
     return days.includes(day);
   }
 
+  /**
+   * Enforce the config-driven booking window at booking-create time.
+   *
+   * A booking is only allowed when the route has an OPEN departure the customer
+   * can join for the requested day — which, because the window engine keeps
+   * `bookingWindowStatus === 'OPEN'` in lockstep with the live window, means:
+   *  - IMPORT: the day's window is currently open (opens at `windowOpenHour` EAT,
+   *    `importWindowLeadDays` before departure, for `windowDurationHours`).
+   *  - EXPORT: now is within `exportBookingLeadHours` before that departure (FCFS).
+   *
+   * `getBookableScheduleEntities` filters on `bookingWindowStatus === 'OPEN'`, so
+   * both gates are satisfied by checking that route for open departures. When a
+   * specific day is requested, require an open departure on that EAT day; when no
+   * day is given, require at least one open departure on the route at all.
+   * Throws `BadRequestException` when the window is closed. No-ops when the route
+   * yards are unknown (nothing to gate against).
+   */
+  async assertBookingWindowOpen(input: {
+    originYardId?: string | null;
+    destinationYardId?: string | null;
+    scheduledDate?: Date | string | null;
+    direction?: string | null;
+  }): Promise<void> {
+    const { originYardId, destinationYardId } = input;
+    if (!originYardId || !destinationYardId) return;
+
+    const { days } = await this.getAvailableDays(originYardId, destinationYardId);
+    if (days.length === 0) {
+      throw new BadRequestException(
+        input.direction === 'EXPORT'
+          ? 'The export booking window for this route is not open yet'
+          : 'The import booking window for this route is closed right now',
+      );
+    }
+
+    if (input.scheduledDate) {
+      const day = eatDay(new Date(input.scheduledDate));
+      if (!days.includes(day)) {
+        throw new BadRequestException(
+          input.direction === 'EXPORT'
+            ? 'No departure is within the export booking window on the selected day'
+            : 'The import booking window is not open for the selected day',
+        );
+      }
+    }
+  }
+
   private async mapScheduleDetail(
     schedule: import('../train-schedules/entities/train-schedule.entity').TrainSchedule,
   ) {
@@ -3212,6 +3682,21 @@ export class TrainSchedulingService {
       freightType: this.resolveScheduleFreightType(schedule),
       trainNumber: schedule.trainNumber ?? null,
       direction: schedule.direction ?? null,
+      // Booking-window phase + phase deadlines drive the countdown timers in the
+      // operations workspace (display only — the window engine enforces them).
+      windowPhase: schedule.windowPhase ?? null,
+      windowOpensAt: schedule.windowOpensAt
+        ? schedule.windowOpensAt.toISOString()
+        : null,
+      windowClosesAt: schedule.windowClosesAt
+        ? schedule.windowClosesAt.toISOString()
+        : null,
+      docReviewEndsAt: schedule.docReviewEndsAt
+        ? schedule.docReviewEndsAt.toISOString()
+        : null,
+      paymentPhaseEndsAt: schedule.paymentPhaseEndsAt
+        ? schedule.paymentPhaseEndsAt.toISOString()
+        : null,
       route: schedule.route
         ? { id: schedule.route.id, name: formatRouteLabel(schedule.route) }
         : null,
@@ -3374,7 +3859,7 @@ export class TrainSchedulingService {
 
     if (!validation.valid) {
       throw new BadRequestException({
-        message: 'Booking validation failed',
+        message: `Booking validation failed: ${validation.violations.join('; ')}`,
         violations: validation.violations,
         warnings: validation.warnings,
       });
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 8c3199461..35d5ce185 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
@@ -210,7 +210,14 @@ export function expandBookingContainerUnits(bookings: Booking[]): ContainerUnitR
       const wagonsPerUnit = Number(line.containerType?.wagonsPerUnit ?? (sizeFt >= 40 ? 1 : 0.5));
       const perWagon = containersPerWagonFromType(wagonsPerUnit);
       const teuSlots = teuSlotsForSizeFt(sizeFt);
+      // The REAL per-container numbers/weights entered at booking time. Unit i of
+      // the line maps to units[i] (sortOrder order); the line-level number is only
+      // a legacy fallback — never invent numbers here.
+      const units = [...(line.units ?? [])].sort(
+        (a, b) => Number(a.sortOrder ?? 0) - Number(b.sortOrder ?? 0),
+      );
       for (let i = 0; i < qty; i += 1) {
+        const unit = units[i];
         rows.push({
           bookingId: booking.id,
           bookingReference: booking.reference,
@@ -219,12 +226,13 @@ export function expandBookingContainerUnits(bookings: Booking[]): ContainerUnitR
           containerTypeId: line.containerTypeId ?? '',
           containerTypeCode: code,
           label: `${booking.reference} · ${i + 1}/${qty} · ${code}`,
-          grossWeightTons: Number(line.vgmPerUnitTons),
+          grossWeightTons: Number(unit?.vgmTons ?? line.vgmPerUnitTons),
           sizeFt,
           wagonsPerUnit,
           containersPerWagon: perWagon,
           teuSlots,
-          containerNumber: line.containerNumber ?? null,
+          containerNumber:
+            unit?.containerNumber?.trim() || line.containerNumber || null,
         });
       }
     }
diff --git a/apps/edr-freight-api/src/modules/train-scheduling/wagon-type-resolver.util.ts b/apps/edr-freight-api/src/modules/train-scheduling/wagon-type-resolver.util.ts
deleted file mode 100644
index bac0330f2..000000000
--- a/apps/edr-freight-api/src/modules/train-scheduling/wagon-type-resolver.util.ts
+++ /dev/null
@@ -1,49 +0,0 @@
-import { WagonType } from '../wagon-types/entities/wagon-type.entity';
-
-const CARGO_CODE_TO_WAGON_TYPE: Record<string, string> = {
-  COFFEE: 'KW2',
-  GRAIN: 'KW2',
-  WHEAT: 'KW2',
-  SORGHUM: 'KW2',
-  CORN: 'KW2',
-  FERTILIZER: 'PW2',
-  SUGAR: 'PW2',
-  COAL: 'KW3',
-  STEEL: 'CW3',
-  ORE: 'CW3',
-};
-
-const DEFAULT_BULK_WAGON_TYPE = 'CW3';
-const DEFAULT_CONTAINER_WAGON_TYPE = 'NW5';
-
-/**
- * Resolve wagon type code from cargo type code for bulk freight.
- */
-export function resolveBulkWagonTypeCode(cargoTypeCode?: string | null): string {
-  if (!cargoTypeCode) return DEFAULT_BULK_WAGON_TYPE;
-  const normalized = cargoTypeCode.trim().toUpperCase();
-  return CARGO_CODE_TO_WAGON_TYPE[normalized] ?? DEFAULT_BULK_WAGON_TYPE;
-}
-
-/**
- * Pick the best matching wagon type entity for bulk cargo.
- */
-export function pickBulkWagonType(
-  wagonTypes: WagonType[],
-  cargoTypeCode?: string | null,
-): WagonType | undefined {
-  const preferredCode = resolveBulkWagonTypeCode(cargoTypeCode);
-  const direct = wagonTypes.find((wt) => wt.code === preferredCode && wt.isActive);
-  if (direct) return direct;
-
-  return wagonTypes.find(
-    (wt) =>
-      wt.isActive &&
-      !wt.supportsContainer &&
-      wt.code !== DEFAULT_CONTAINER_WAGON_TYPE,
-  );
-}
-
-export function getDefaultContainerWagonTypeCode(): string {
-  return DEFAULT_CONTAINER_WAGON_TYPE;
-}
diff --git a/apps/edr-freight-api/src/modules/vehicles/vehicles.controller.ts b/apps/edr-freight-api/src/modules/vehicles/vehicles.controller.ts
index 8e6d8a0a8..f0a77791a 100644
--- a/apps/edr-freight-api/src/modules/vehicles/vehicles.controller.ts
+++ b/apps/edr-freight-api/src/modules/vehicles/vehicles.controller.ts
@@ -14,13 +14,17 @@ import { FleetManage, FleetView } from '../../common/booking-guards';
 import { VehiclesService } from './vehicles.service';
 import { CreateVehicleDto } from './dto/create-vehicle.dto';
 import { UpdateVehicleDto } from './dto/update-vehicle.dto';
+import { FleetHistoryService } from '../fleet-history/fleet-history.service';
 
 @ApiTags('vehicles')
 @ApiBearerAuth()
 @Controller('vehicles')
 @FleetView()
 export class VehiclesController {
-  constructor(private readonly vehiclesService: VehiclesService) {}
+  constructor(
+    private readonly vehiclesService: VehiclesService,
+    private readonly fleetHistory: FleetHistoryService,
+  ) {}
 
   @Post()
   @FleetManage()
@@ -57,6 +61,12 @@ export class VehiclesController {
     return this.vehiclesService.findById(id);
   }
 
+  @Get(':id/history')
+  @ApiOperation({ summary: 'Get vehicle assignment, status & mile history' })
+  history(@Param('id', ParseUUIDPipe) id: string) {
+    return this.fleetHistory.getVehicleHistory(id);
+  }
+
   @Patch(':id')
   @FleetManage()
   @ApiOperation({ summary: 'Update a vehicle' })
diff --git a/apps/edr-freight-api/src/modules/vehicles/vehicles.service.ts b/apps/edr-freight-api/src/modules/vehicles/vehicles.service.ts
index 69568e483..25260e86f 100644
--- a/apps/edr-freight-api/src/modules/vehicles/vehicles.service.ts
+++ b/apps/edr-freight-api/src/modules/vehicles/vehicles.service.ts
@@ -9,12 +9,15 @@ import { FirstMileContainerAllocation } from '../first-mile/entities/first-mile-
 import { LastMile, LastMileStatus } from '../last-mile/entities/last-mile.entity';
 import { LastMileContainerAllocation } from '../last-mile/entities/last-mile-container-allocation.entity';
 import { BookingContainerAllocation } from '../bookings/entities/booking-container-allocation.entity';
+import { FleetHistoryService } from '../fleet-history/fleet-history.service';
+import { FleetEventType } from '../fleet-history/entities/fleet-event.entity';
 
 @Injectable()
 export class VehiclesService {
   constructor(
     @InjectRepository(Vehicle)
     private readonly vehicleRepo: Repository<Vehicle>,
+    private readonly history: FleetHistoryService,
   ) {}
 
   async create(dto: CreateVehicleDto): Promise<Vehicle> {
@@ -34,7 +37,28 @@ export class VehiclesService {
       registrationNumber,
     });
 
-    return this.vehicleRepo.save(vehicle);
+    const saved = await this.vehicleRepo.save(vehicle);
+
+    await this.history.record({
+      eventType: FleetEventType.VEHICLE_REGISTERED,
+      vehicleId: saved.id,
+      label: saved.plateNumber ?? saved.code ?? null,
+      toValue: saved.availability ?? null,
+    });
+    if (saved.assignedDriverId) {
+      await this.history.record({
+        eventType: FleetEventType.DRIVER_ASSIGNED,
+        vehicleId: saved.id,
+        driverId: saved.assignedDriverId,
+        label: saved.assignedDriverName ?? null,
+        metadata: {
+          vehiclePlate: saved.plateNumber ?? saved.code ?? null,
+          driverName: saved.assignedDriverName ?? null,
+        },
+      });
+    }
+
+    return saved;
   }
 
   async findAll(query: {
@@ -97,12 +121,76 @@ export class VehiclesService {
       }
     }
 
+    const prev = {
+      assignedDriverId: vehicle.assignedDriverId,
+      assignedDriverName: vehicle.assignedDriverName,
+      status: vehicle.status,
+      availability: vehicle.availability,
+    };
+
     Object.assign(vehicle, dto);
-    return this.vehicleRepo.save(vehicle);
+    const saved = await this.vehicleRepo.save(vehicle);
+
+    // Driver (re)assignment — emit an unassign for the old driver and/or an
+    // assign for the new one so both drivers' timelines and the vehicle's line up.
+    if (
+      dto.assignedDriverId !== undefined &&
+      dto.assignedDriverId !== prev.assignedDriverId
+    ) {
+      const vehiclePlate = saved.plateNumber ?? saved.code ?? null;
+      if (prev.assignedDriverId) {
+        await this.history.record({
+          eventType: FleetEventType.DRIVER_UNASSIGNED,
+          vehicleId: id,
+          driverId: prev.assignedDriverId,
+          label: prev.assignedDriverName ?? null,
+          metadata: { vehiclePlate, driverName: prev.assignedDriverName ?? null },
+        });
+      }
+      if (saved.assignedDriverId) {
+        await this.history.record({
+          eventType: FleetEventType.DRIVER_ASSIGNED,
+          vehicleId: id,
+          driverId: saved.assignedDriverId,
+          label: saved.assignedDriverName ?? null,
+          metadata: { vehiclePlate, driverName: saved.assignedDriverName ?? null },
+        });
+      }
+    }
+    if (dto.status !== undefined && dto.status !== prev.status) {
+      await this.history.record({
+        eventType: FleetEventType.VEHICLE_STATUS_CHANGED,
+        vehicleId: id,
+        fromValue: prev.status ?? null,
+        toValue: saved.status ?? null,
+      });
+    }
+    if (dto.availability !== undefined && dto.availability !== prev.availability) {
+      await this.history.record({
+        eventType: FleetEventType.VEHICLE_AVAILABILITY_CHANGED,
+        vehicleId: id,
+        fromValue: prev.availability ?? null,
+        toValue: saved.availability ?? null,
+      });
+    }
+
+    return saved;
   }
 
   async setAvailability(id: string, availability: VehicleAvailability): Promise<void> {
+    // Read the current value so the audit event records an accurate from→to and
+    // we skip logging no-op writes (setAvailability is called in release loops).
+    const vehicle = await this.vehicleRepo.findOne({ where: { id } });
+    const previous = vehicle?.availability;
     await this.vehicleRepo.update(id, { availability });
+    if (previous !== availability) {
+      await this.history.record({
+        eventType: FleetEventType.VEHICLE_AVAILABILITY_CHANGED,
+        vehicleId: id,
+        fromValue: previous ?? null,
+        toValue: availability,
+      });
+    }
   }
 
   /**
diff --git a/apps/edr-freight-api/src/modules/verifayda/entities/fayda-verification-session.entity.ts b/apps/edr-freight-api/src/modules/verifayda/entities/fayda-verification-session.entity.ts
new file mode 100644
index 000000000..3435acabc
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/verifayda/entities/fayda-verification-session.entity.ts
@@ -0,0 +1,49 @@
+import { Column, Entity, Index } from 'typeorm';
+import { BaseEntity } from '@edr/api-common';
+
+/**
+ * One row per started Fayda verification. Mirrors the passenger-api Prisma
+ * model `FaydaVerificationSession`, but stored in the freight schema via
+ * TypeORM. `state` is the single-use CSRF token that links the eSignet
+ * redirect back to this session.
+ */
+@Entity({ name: 'fayda_verification_sessions', schema: 'freight' })
+@Index(['expiresAt'])
+@Index(['iamUserId'])
+export class FaydaVerificationSession extends BaseEntity {
+  @Column({ name: 'state', unique: true })
+  state!: string;
+
+  @Column({ name: 'code_verifier' })
+  codeVerifier!: string;
+
+  /** VERIFY | LOGIN */
+  @Column({ name: 'purpose', default: 'VERIFY' })
+  purpose!: string;
+
+  /** WEB | MOBILE — recorded for audit */
+  @Column({ name: 'platform', default: 'WEB' })
+  platform!: string;
+
+  @Column({ name: 'save_to_account', type: 'boolean', default: false })
+  saveToAccount!: boolean;
+
+  /** PENDING | COMPLETED | FAILED */
+  @Column({ name: 'status', default: 'PENDING' })
+  status!: string;
+
+  @Column({ name: 'error_code', type: 'varchar', nullable: true })
+  errorCode?: string | null;
+
+  @Column({ name: 'error_description', type: 'text', nullable: true })
+  errorDescription?: string | null;
+
+  @Column({ name: 'iam_user_id', type: 'uuid', nullable: true })
+  iamUserId?: string | null;
+
+  @Column({ name: 'expires_at', type: 'timestamptz' })
+  expiresAt!: Date;
+
+  @Column({ name: 'completed_at', type: 'timestamptz', nullable: true })
+  completedAt?: Date | null;
+}
diff --git a/apps/edr-freight-api/src/modules/verifayda/fayda-callback.controller.ts b/apps/edr-freight-api/src/modules/verifayda/fayda-callback.controller.ts
new file mode 100644
index 000000000..1c5569750
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/verifayda/fayda-callback.controller.ts
@@ -0,0 +1,33 @@
+import { Controller, Get, Query } from '@nestjs/common';
+import { ApiOkResponse, ApiOperation, ApiTags } from '@nestjs/swagger';
+import { IsPublic } from '@tria-plc/api-common/modules/auth/decorators/public.decorator';
+import { VerifaydaCallbackDto } from './verifayda.dto';
+
+/**
+ * Plain acknowledgement endpoint for the Fayda redirect_uri when it points at
+ * the API instead of the web app (e.g. MOBILE clients or connectivity checks).
+ * Registered at /callback (excluded from the global /api prefix in main.ts).
+ * It does NOT consume the verification session — the client must still call
+ * GET /api/fayda/verification/complete with the echoed code+state.
+ */
+@ApiTags('Fayda Verification')
+@Controller('callback')
+export class FaydaCallbackController {
+  @Get()
+  @IsPublic()
+  @ApiOperation({ summary: 'Acknowledge a Fayda redirect (returns OK, echoes code/state)' })
+  @ApiOkResponse({
+    schema: { example: { status: 'ok', code: '...', state: '...' } },
+  })
+  ok(@Query() query: VerifaydaCallbackDto) {
+    return {
+      status: 'ok',
+      ...(query.code ? { code: query.code } : {}),
+      ...(query.state ? { state: query.state } : {}),
+      ...(query.error ? { error: query.error } : {}),
+      ...(query.error_description ? { error_description: query.error_description } : {}),
+    };
+  }
+}
+
+//    return res.redirect(url.toString());
diff --git a/apps/edr-freight-api/src/modules/verifayda/optional-jwt.guard.ts b/apps/edr-freight-api/src/modules/verifayda/optional-jwt.guard.ts
new file mode 100644
index 000000000..8673aa60e
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/verifayda/optional-jwt.guard.ts
@@ -0,0 +1,30 @@
+import { CanActivate, ExecutionContext, Injectable } from '@nestjs/common';
+import { Reflector } from '@nestjs/core';
+import { InjectDataSource } from '@nestjs/typeorm';
+import { JwtGuard as IamJwtGuard } from '@tria-plc/api-common/modules/auth/services/jwt.guard';
+import { DataSource } from 'typeorm';
+
+/**
+ * Like the IAM JwtGuard, but never rejects the request.
+ *
+ * When a valid IAM bearer token is present, `request.user` is populated with
+ * the package `TCurrentUser`. Missing or invalid tokens continue as guests.
+ */
+@Injectable()
+export class OptionalJwtGuard extends IamJwtGuard implements CanActivate {
+  constructor(
+    reflector: Reflector,
+    @InjectDataSource() dataSource: DataSource,
+  ) {
+    super(reflector, dataSource);
+  }
+
+  async canActivate(context: ExecutionContext): Promise<boolean> {
+    try {
+      await super.canActivate(context);
+    } catch {
+      context.switchToHttp().getRequest().user = undefined;
+    }
+    return true;
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/verifayda/utils/client-assertion.util.spec.ts b/apps/edr-freight-api/src/modules/verifayda/utils/client-assertion.util.spec.ts
new file mode 100644
index 000000000..9b4316fc7
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/verifayda/utils/client-assertion.util.spec.ts
@@ -0,0 +1,71 @@
+import { exportJWK, generateKeyPair, importJWK, jwtVerify, type JWK } from 'jose';
+import { generateClientAssertion } from './client-assertion.util';
+
+describe('generateClientAssertion', () => {
+  let privateJwk: JWK;
+  let publicJwk: JWK;
+
+  beforeAll(async () => {
+    const kp = await generateKeyPair('RS256', { extractable: true });
+    privateJwk = await exportJWK(kp.privateKey);
+    publicJwk = await exportJWK(kp.publicKey);
+  });
+
+  it('produces a JWT verifiable with the matching public key', async () => {
+    const jwt = await generateClientAssertion({
+      clientId: 'edr-passenger-test',
+      audience: 'https://esignet.example.com/token',
+      privateJwk,
+    });
+
+    const verifier = await importJWK(publicJwk, 'RS256');
+    const { payload, protectedHeader } = await jwtVerify(jwt, verifier, {
+      issuer: 'edr-passenger-test',
+      subject: 'edr-passenger-test',
+      audience: 'https://esignet.example.com/token',
+    });
+
+    expect(protectedHeader.alg).toBe('RS256');
+    expect(protectedHeader.typ).toBe('JWT');
+    expect(payload.iss).toBe('edr-passenger-test');
+    expect(payload.sub).toBe('edr-passenger-test');
+    expect(payload.aud).toBe('https://esignet.example.com/token');
+    expect(typeof payload.iat).toBe('number');
+    expect(typeof payload.exp).toBe('number');
+  });
+
+  it('defaults exp to 120 seconds after iat', async () => {
+    const jwt = await generateClientAssertion({
+      clientId: 'c',
+      audience: 'https://a/token',
+      privateJwk,
+    });
+    const verifier = await importJWK(publicJwk, 'RS256');
+    const { payload } = await jwtVerify(jwt, verifier);
+    expect(payload.exp! - payload.iat!).toBe(120);
+  });
+
+  it('honors a custom expiresIn', async () => {
+    const jwt = await generateClientAssertion({
+      clientId: 'c',
+      audience: 'https://a/token',
+      privateJwk,
+      expiresIn: '5m',
+    });
+    const verifier = await importJWK(publicJwk, 'RS256');
+    const { payload } = await jwtVerify(jwt, verifier);
+    expect(payload.exp! - payload.iat!).toBe(300);
+  });
+
+  it('fails verification against a wrong audience', async () => {
+    const jwt = await generateClientAssertion({
+      clientId: 'c',
+      audience: 'https://a/token',
+      privateJwk,
+    });
+    const verifier = await importJWK(publicJwk, 'RS256');
+    await expect(
+      jwtVerify(jwt, verifier, { audience: 'https://other/token' }),
+    ).rejects.toThrow();
+  });
+});
diff --git a/apps/edr-freight-api/src/modules/verifayda/utils/client-assertion.util.ts b/apps/edr-freight-api/src/modules/verifayda/utils/client-assertion.util.ts
new file mode 100644
index 000000000..dc3558ccc
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/verifayda/utils/client-assertion.util.ts
@@ -0,0 +1,22 @@
+import { SignJWT, importJWK, type JWK } from 'jose';
+
+export interface GenerateClientAssertionInput {
+  clientId: string;
+  audience: string;
+  privateJwk: JWK;
+  expiresIn?: string;
+}
+
+export async function generateClientAssertion(
+  input: GenerateClientAssertionInput,
+): Promise<string> {
+  const privateKey = await importJWK(input.privateJwk, 'RS256');
+  return new SignJWT({})
+    .setProtectedHeader({ alg: 'RS256', typ: 'JWT' })
+    .setIssuer(input.clientId)
+    .setSubject(input.clientId)
+    .setAudience(input.audience)
+    .setIssuedAt()
+    .setExpirationTime(input.expiresIn ?? '2m')
+    .sign(privateKey);
+}
diff --git a/apps/edr-freight-api/src/modules/verifayda/utils/pkce.util.spec.ts b/apps/edr-freight-api/src/modules/verifayda/utils/pkce.util.spec.ts
new file mode 100644
index 000000000..d359a07f2
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/verifayda/utils/pkce.util.spec.ts
@@ -0,0 +1,65 @@
+import { createHash } from 'crypto';
+import {
+  base64Url,
+  generateCodeChallenge,
+  generateCodeVerifier,
+  generateState,
+} from './pkce.util';
+
+describe('pkce.util', () => {
+  describe('base64Url', () => {
+    it('strips padding and replaces + and / with - and _', () => {
+      const input = Buffer.from([0xfb, 0xff, 0xbf, 0xfe]);
+      const out = base64Url(input);
+      expect(out).not.toMatch(/[+/=]/);
+    });
+  });
+
+  describe('generateCodeVerifier', () => {
+    it('returns a base64url-safe string', () => {
+      expect(generateCodeVerifier()).toMatch(/^[A-Za-z0-9_-]+$/);
+    });
+
+    it('produces unique values across calls', () => {
+      const a = generateCodeVerifier();
+      const b = generateCodeVerifier();
+      expect(a).not.toEqual(b);
+    });
+
+    it('produces at least 43 characters (RFC 7636 minimum)', () => {
+      expect(generateCodeVerifier().length).toBeGreaterThanOrEqual(43);
+    });
+  });
+
+  describe('generateCodeChallenge', () => {
+    it('equals base64url(sha256(verifier))', () => {
+      const verifier = 'fixed-test-verifier';
+      const expected = createHash('sha256')
+        .update(verifier)
+        .digest('base64')
+        .replace(/\+/g, '-')
+        .replace(/\//g, '_')
+        .replace(/=/g, '');
+      expect(generateCodeChallenge(verifier)).toBe(expected);
+    });
+
+    it('is deterministic for the same verifier', () => {
+      const verifier = generateCodeVerifier();
+      expect(generateCodeChallenge(verifier)).toBe(generateCodeChallenge(verifier));
+    });
+
+    it('differs for different verifiers', () => {
+      expect(generateCodeChallenge('a')).not.toBe(generateCodeChallenge('b'));
+    });
+  });
+
+  describe('generateState', () => {
+    it('returns a base64url-safe string', () => {
+      expect(generateState()).toMatch(/^[A-Za-z0-9_-]+$/);
+    });
+
+    it('produces unique values across calls', () => {
+      expect(generateState()).not.toEqual(generateState());
+    });
+  });
+});
diff --git a/apps/edr-freight-api/src/modules/verifayda/utils/pkce.util.ts b/apps/edr-freight-api/src/modules/verifayda/utils/pkce.util.ts
new file mode 100644
index 000000000..89e9437d2
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/verifayda/utils/pkce.util.ts
@@ -0,0 +1,21 @@
+import { createHash, randomBytes } from 'crypto';
+
+export function base64Url(buffer: Buffer): string {
+  return buffer
+    .toString('base64')
+    .replace(/\+/g, '-')
+    .replace(/\//g, '_')
+    .replace(/=/g, '');
+}
+
+export function generateCodeVerifier(): string {
+  return base64Url(randomBytes(64));
+}
+
+export function generateCodeChallenge(codeVerifier: string): string {
+  return base64Url(createHash('sha256').update(codeVerifier).digest());
+}
+
+export function generateState(): string {
+  return base64Url(randomBytes(32));
+}
diff --git a/apps/edr-freight-api/src/modules/verifayda/verifayda.controller.ts b/apps/edr-freight-api/src/modules/verifayda/verifayda.controller.ts
new file mode 100644
index 000000000..977e677f8
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/verifayda/verifayda.controller.ts
@@ -0,0 +1,107 @@
+import {
+  Body,
+  Controller,
+  Get,
+  HttpCode,
+  HttpStatus,
+  Post,
+  Query,
+  Req,
+  UseGuards,
+} from '@nestjs/common';
+import {
+  ApiBearerAuth,
+  ApiOkResponse,
+  ApiOperation,
+  ApiTags,
+} from '@nestjs/swagger';
+import type { TCurrentUser } from '@tria-plc/api-common/modules/auth/types/current-user.type';
+import { IsPublic } from '@tria-plc/api-common/modules/auth/decorators/public.decorator';
+import { JwtGuard } from '@tria-plc/api-common/modules/auth/services/jwt.guard';
+import { OptionalJwtGuard } from './optional-jwt.guard';
+import {
+  CompleteVerificationResultDto,
+  StartVerificationDto,
+  VerifaydaCallbackDto,
+  VerificationStatusDto,
+} from './verifayda.dto';
+import { VerifaydaService } from './verifayda.service';
+
+/** Minimal slices of the Express req we touch (avoids a hard dependency on
+ * `@types/express`, which isn't resolved in this package). */
+interface RequestWithOptionalUser {
+  user?: TCurrentUser;
+}
+interface RequestWithUser {
+  user: TCurrentUser;
+}
+
+@ApiTags('Fayda Verification')
+@Controller('fayda/verification')
+export class VerifaydaController {
+  constructor(private readonly service: VerifaydaService) {}
+
+  @Post('start')
+  @IsPublic()
+  @HttpCode(HttpStatus.OK)
+  @UseGuards(OptionalJwtGuard)
+  @ApiBearerAuth('JWT-auth')
+  @ApiOperation({
+    summary: 'Start a VeriFayda 2.0 verification session',
+    description: `Creates a verification session and returns the eSignet authorize URL the frontend should send the user to.
+
+- Works for **logged-in users** and **guests**. If a valid bearer token is present, the verification is tied to that user.
+- **VERIFY** (default): the user proves their identity and \`/complete\` returns the verified attributes (name, email, phone, dob, gender).
+- **LOGIN**: \`/complete\` resolves/creates the user and returns a JWT.
+- The returned \`authorizationUrl\` already carries the PKCE \`code_challenge\`, CSRF \`state\`, requested \`claims\`, and \`code_challenge_method=S256\`. The frontend simply navigates to it (full page or popup).`,
+  })
+  @ApiOkResponse({
+    description: 'Authorize URL the frontend should redirect the user to.',
+    schema: {
+      example: {
+        authorizationUrl:
+          'https://esignet.example.com/authorize?client_id=...&state=...&code_challenge=...',
+      },
+    },
+  })
+  async start(
+    @Body() dto: StartVerificationDto,
+    @Req() req: RequestWithOptionalUser,
+  ): Promise<{ authorizationUrl: string }> {
+    const authorizationUrl = await this.service.startVerification({
+      purpose: dto.purpose ?? 'VERIFY',
+      platform: dto.platform ?? 'WEB',
+      userId: req.user?.id,
+      wantsPasswordSetup: dto.wantsPasswordSetup ?? false,
+    });
+    return { authorizationUrl };
+  }
+
+  @Get('complete')
+  @IsPublic()
+  @ApiOperation({
+    summary: 'Complete a verification (Fayda redirect / client callback lands here)',
+    description: `This is the registered Fayda \`redirect_uri\`. Fayda redirects the browser here with \`?code&state\``,
+  })
+  @ApiOkResponse({ type: CompleteVerificationResultDto })
+  async complete(
+    @Query() dto: VerifaydaCallbackDto,
+  ): Promise<CompleteVerificationResultDto> {
+    return this.service.completeVerification(dto);
+  }
+
+  @Get('status')
+  @UseGuards(JwtGuard)
+  @ApiBearerAuth('JWT-auth')
+  @ApiOperation({
+    summary: "Get the current user's Fayda verification status",
+    description:
+      'Returns whether the authenticated user has linked a verified Fayda identity to their account, when, and the name on file.',
+  })
+  @ApiOkResponse({ type: VerificationStatusDto })
+  async status(
+    @Req() req: RequestWithUser,
+  ): Promise<VerificationStatusDto> {
+    return this.service.getVerificationStatus(req.user.id);
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/verifayda/verifayda.dto.ts b/apps/edr-freight-api/src/modules/verifayda/verifayda.dto.ts
new file mode 100644
index 000000000..1885b11e9
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/verifayda/verifayda.dto.ts
@@ -0,0 +1,105 @@
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+import { IsIn, IsOptional, IsString } from 'class-validator';
+
+export class StartVerificationDto {
+  @ApiPropertyOptional({
+    enum: ['LOGIN', 'VERIFY'],
+    default: 'VERIFY',
+    description:
+      'Reason for verification. VERIFY returns the verified identity attributes; LOGIN resolves/creates a user and returns a JWT.',
+  })
+  @IsOptional()
+  @IsIn(['LOGIN', 'VERIFY'])
+  purpose?: 'LOGIN' | 'VERIFY';
+
+  @ApiPropertyOptional({
+    enum: ['WEB', 'MOBILE'],
+    default: 'WEB',
+    description:
+      'Client platform. Selects which OAuth redirect_uri is sent to eSignet: WEB uses FAYDA_WEB_REDIRECT_URI, MOBILE uses FAYDA_REDIRECT_URI. Both land on the same /complete endpoint with identical handling.',
+  })
+  @IsOptional()
+  @IsIn(['WEB', 'MOBILE'])
+  platform?: 'WEB' | 'MOBILE';
+
+  @ApiPropertyOptional({
+    type: Boolean,
+    default: false,
+    description:
+      'Set to true when the user opts in to full account registration (checkbox). ' +
+      'When true, the /complete response includes a short-lived token and promptPasswordSetup=true ' +
+      'so the frontend can immediately prompt for a password via POST /v1/auth/set-fayda-password.',
+  })
+  @IsOptional()
+  wantsPasswordSetup?: boolean;
+}
+
+export class CompleteVerificationResultDto {
+  @ApiProperty({ enum: ['LOGIN', 'VERIFY'] })
+  purpose!: 'LOGIN' | 'VERIFY';
+
+  @ApiProperty() verified!: boolean;
+
+  @ApiPropertyOptional({ description: 'JWT. LOGIN: session token for the authenticated user. VERIFY: short-lived token for calling /v1/auth/set-fayda-password.' })
+  token?: string;
+
+  @ApiPropertyOptional()
+  refreshToken?: string;
+
+  @ApiPropertyOptional({
+    description: 'Authenticated user summary (LOGIN flow only; same shape as /auth/login).',
+  })
+  user?: {
+    id: string;
+    email: string;
+    role: string;
+    passengerId?: string;
+    agentId?: string;
+  };
+
+  @ApiPropertyOptional({ description: 'Verified full name from Fayda (VERIFY flow).' })
+  fullName?: string;
+
+  @ApiPropertyOptional({ description: 'Verified email from Fayda (VERIFY flow).' })
+  email?: string;
+
+  @ApiPropertyOptional({ description: 'Verified phone number from Fayda (VERIFY flow).' })
+  phoneNumber?: string;
+
+  @ApiPropertyOptional({
+    description: 'Verified date of birth from Fayda, ISO yyyy-MM-dd (VERIFY flow).',
+  })
+  birthdate?: string;
+
+  @ApiPropertyOptional({ description: 'Verified gender from Fayda (VERIFY flow).' })
+  gender?: string;
+
+  @ApiPropertyOptional({ description: 'Whether the verified identity was saved to IAM. False if the IAM write failed.' })
+  userDataSaved?: boolean;
+
+  @ApiPropertyOptional({ description: 'IAM user ID of the verified identity (VERIFY flow).' })
+  iamUserId?: string;
+
+  @ApiPropertyOptional({ description: 'True when the IAM account has not yet set a password (VERIFY flow).' })
+  requiresPassword?: boolean;
+
+  @ApiPropertyOptional({
+    description:
+      'True when the user opted in to immediate password setup (wantsPasswordSetup=true at start) ' +
+      'AND they have not yet set a password. Frontend should navigate to the set-password screen.',
+  })
+  promptPasswordSetup?: boolean;
+}
+
+export class VerifaydaCallbackDto {
+  @ApiPropertyOptional() @IsOptional() @IsString() code?: string;
+  @ApiPropertyOptional() @IsOptional() @IsString() state?: string;
+  @ApiPropertyOptional() @IsOptional() @IsString() error?: string;
+  @ApiPropertyOptional() @IsOptional() @IsString() error_description?: string;
+}
+
+export class VerificationStatusDto {
+  @ApiProperty() verified!: boolean;
+  @ApiPropertyOptional() verifiedAt?: Date;
+  @ApiPropertyOptional() fullName?: string;
+}
diff --git a/apps/edr-freight-api/src/modules/verifayda/verifayda.errors.ts b/apps/edr-freight-api/src/modules/verifayda/verifayda.errors.ts
new file mode 100644
index 000000000..a7d531102
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/verifayda/verifayda.errors.ts
@@ -0,0 +1,19 @@
+import { BadGatewayException, ConflictException } from '@nestjs/common';
+
+export class FaydaTokenExchangeException extends BadGatewayException {
+  constructor(message = 'Fayda token exchange failed') {
+    super({ code: 'FAYDA_TOKEN_EXCHANGE_FAILED', message });
+  }
+}
+
+export class FaydaUserInfoException extends BadGatewayException {
+  constructor(message = 'Fayda userinfo fetch failed') {
+    super({ code: 'FAYDA_USERINFO_FAILED', message });
+  }
+}
+
+export class FaydaIdentityConflictException extends ConflictException {
+  constructor(message = 'This Fayda identity is already linked to another account') {
+    super({ code: 'FAYDA_IDENTITY_CONFLICT', message });
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/verifayda/verifayda.module.ts b/apps/edr-freight-api/src/modules/verifayda/verifayda.module.ts
new file mode 100644
index 000000000..82fb9435c
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/verifayda/verifayda.module.ts
@@ -0,0 +1,14 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { VerifaydaController } from './verifayda.controller';
+import { FaydaCallbackController } from './fayda-callback.controller';
+import { VerifaydaService } from './verifayda.service';
+import { FaydaVerificationSession } from './entities/fayda-verification-session.entity';
+
+@Module({
+  imports: [TypeOrmModule.forFeature([FaydaVerificationSession])],
+  controllers: [VerifaydaController, FaydaCallbackController],
+  providers: [VerifaydaService],
+  exports: [VerifaydaService],
+})
+export class VerifaydaModule {}
diff --git a/apps/edr-freight-api/src/modules/verifayda/verifayda.service.ts b/apps/edr-freight-api/src/modules/verifayda/verifayda.service.ts
new file mode 100644
index 000000000..6e3e2e095
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/verifayda/verifayda.service.ts
@@ -0,0 +1,597 @@
+import {
+  BadRequestException,
+  Injectable,
+  Logger,
+  ServiceUnavailableException,
+  UnauthorizedException,
+} from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { InjectDataSource, InjectRepository } from '@nestjs/typeorm';
+import { DataSource, Repository } from 'typeorm';
+import { generateToken, generateRefreshToken } from '@tria-plc/api-common/utils/token';
+import { FaydaConfig, FaydaPlatform } from '../../config/fayda.config';
+import { FaydaVerificationSession } from './entities/fayda-verification-session.entity';
+import {
+  generateCodeChallenge,
+  generateCodeVerifier,
+  generateState,
+} from './utils/pkce.util';
+import { generateClientAssertion } from './utils/client-assertion.util';
+import { VerifaydaCallbackDto, VerificationStatusDto } from './verifayda.dto';
+import {
+  FaydaTokenExchangeException,
+  FaydaUserInfoException,
+} from './verifayda.errors';
+import {
+  FaydaTokenResponse,
+  FaydaUserInfo,
+  NormalizedFaydaUserInfo,
+  VerifaydaPurpose,
+} from './verifayda.types';
+
+export interface StartVerificationInput {
+  purpose: VerifaydaPurpose;
+  platform?: FaydaPlatform;
+  userId?: string;   // iamUserId of the authenticated user, if any
+  wantsPasswordSetup?: boolean;
+}
+
+export interface FaydaUserSummary {
+  id: string;
+  email: string;
+  role: string;
+}
+
+/**
+ * Result of completing a verification. `verified` is always true on success.
+ * LOGIN additionally returns a JWT + user; VERIFY returns the verified identity
+ * attributes (name, email, phone, dob, gender) for the caller to consume.
+ */
+export interface CompleteVerificationResult {
+  purpose: VerifaydaPurpose;
+  verified: boolean;
+  token?: string;
+  refreshToken?: string;
+  requiresPassword?: boolean;
+  promptPasswordSetup?: boolean;
+  iamUserId?: string;
+  user?: FaydaUserSummary;
+  fullName?: string;
+  email?: string;
+  phoneNumber?: string;
+  birthdate?: string;
+  gender?: string;
+  userDataSaved?: boolean;
+}
+
+@Injectable()
+export class VerifaydaService {
+  private readonly logger = new Logger(VerifaydaService.name);
+
+  private readonly faydaConfig: FaydaConfig;
+
+  constructor(
+    private readonly config: ConfigService,
+    @InjectRepository(FaydaVerificationSession)
+    private readonly sessionRepo: Repository<FaydaVerificationSession>,
+    @InjectDataSource() private readonly dataSource: DataSource,
+  ) {
+    const fayda = this.config.get<FaydaConfig>('fayda');
+    if (!fayda) {
+      throw new Error('Fayda config namespace not registered');
+    }
+    this.faydaConfig = fayda;
+  }
+
+  // ==========================================================================
+  // OIDC flow
+  // ==========================================================================
+
+  async startVerification(input: StartVerificationInput): Promise<string> {
+    if (!this.faydaConfig.enabled) {
+      throw new ServiceUnavailableException({
+        code: 'FAYDA_DISABLED',
+        message: 'Fayda integration is not enabled',
+      });
+    }
+
+    const state = generateState();
+    const codeVerifier = generateCodeVerifier();
+    const codeChallenge = generateCodeChallenge(codeVerifier);
+    const expiresAt = new Date(
+      Date.now() + this.faydaConfig.sessionTtlMinutes * 60_000,
+    );
+
+    await this.sessionRepo.save(
+      this.sessionRepo.create({
+        state,
+        codeVerifier,
+        purpose: input.purpose,
+        platform: input.platform ?? 'WEB',
+        saveToAccount: input.wantsPasswordSetup ?? false,
+        iamUserId: input.userId ?? null,
+        expiresAt,
+      }),
+    );
+
+    this.logger.log(
+      `Fayda verification started: purpose=${input.purpose} platform=${input.platform ?? 'WEB'} userId=${input.userId ?? 'none'}`,
+    );
+
+    return this.buildAuthorizationUrl({
+      state,
+      codeChallenge,
+      redirectUri: this.redirectUriForPlatform(input.platform ?? 'WEB'),
+    });
+  }
+
+  /** WEB clients use `webRedirectUri`; MOBILE uses the base `redirectUri`. */
+  private redirectUriForPlatform(platform?: FaydaPlatform): string {
+    return platform === 'MOBILE'
+      ? this.faydaConfig.redirectUri
+      : this.faydaConfig.webRedirectUri;
+  }
+
+  async completeVerification(
+    query: VerifaydaCallbackDto,
+  ): Promise<CompleteVerificationResult> {
+    if (query.error) {
+      this.logger.warn(`Fayda callback returned error: ${query.error}`);
+      if (query.state) {
+        await this.markSessionFailed(
+          query.state,
+          query.error,
+          query.error_description,
+        );
+      }
+      throw new BadRequestException({
+        code: 'FAYDA_AUTH_ERROR',
+        message: query.error,
+        description: query.error_description,
+      });
+    }
+
+    if (!query.code || !query.state) {
+      throw new BadRequestException({
+        code: 'FAYDA_MISSING_PARAMETERS',
+        message: 'code and state are required',
+      });
+    }
+
+    const session = await this.sessionRepo.findOne({
+      where: { state: query.state },
+    });
+    if (!session || session.status !== 'PENDING') {
+      this.logger.warn('Fayda complete with unknown or non-pending state');
+      throw new BadRequestException({
+        code: 'FAYDA_INVALID_STATE',
+        message: 'Verification session is invalid or already used',
+      });
+    }
+    if (session.expiresAt.getTime() < Date.now()) {
+      await this.markSessionFailed(query.state, 'session_expired');
+      throw new BadRequestException({
+        code: 'FAYDA_SESSION_EXPIRED',
+        message: 'Verification session has expired; start again',
+      });
+    }
+
+    try {
+      const tokens = await this.exchangeCodeForTokens(
+        query.code,
+        session.codeVerifier,
+        this.redirectUriForPlatform(session.platform as FaydaPlatform),
+      );
+      const userInfo = await this.fetchUserInfo(tokens.access_token);
+      const normalized = this.normalizeUserInfo(userInfo);
+
+      if (!normalized.sub) {
+        throw new FaydaUserInfoException('Fayda userinfo missing required sub');
+      }
+
+      let result: CompleteVerificationResult;
+      if (session.purpose === 'LOGIN') {
+        const { userId } = await this.handleLoginSuccess(normalized);
+        const login = await this.issueLoginToken(userId);
+        result = { purpose: 'LOGIN', verified: true, ...login };
+      } else {
+        // VERIFY — prove identity, save to IAM, return verified attributes + short-lived token.
+        const { iamUserId, userDataSaved } = await this.upsertIamUser(normalized);
+
+        let sessionToken: { token: string; refreshToken: string; requiresPassword: boolean } | undefined;
+        if (iamUserId) {
+          try {
+            sessionToken = await this.createFaydaSession(iamUserId);
+          } catch (err) {
+            this.logger.warn(`Fayda session creation failed: ${(err as Error).message}`);
+          }
+        }
+
+        result = {
+          purpose: 'VERIFY',
+          verified: true,
+          fullName: normalized.fullName,
+          email: normalized.email,
+          phoneNumber: normalized.phoneNumber,
+          birthdate: normalized.birthdate,
+          gender: normalized.gender,
+          userDataSaved,
+          iamUserId: iamUserId ?? undefined,
+          token: sessionToken?.token,
+          refreshToken: sessionToken?.refreshToken,
+          requiresPassword: sessionToken?.requiresPassword,
+          promptPasswordSetup: session.saveToAccount && (sessionToken?.requiresPassword ?? false),
+        };
+      }
+
+      await this.sessionRepo.update(session.id, {
+        status: 'COMPLETED',
+        completedAt: new Date(),
+        codeVerifier: '',
+      });
+
+      this.logger.log(
+        `Fayda verification completed: purpose=${session.purpose} platform=${session.platform}`,
+      );
+      return result;
+    } catch (err) {
+      const reason = this.classifyFailureReason(err);
+      this.logger.error(
+        `Fayda verification failed: reason=${reason} message=${(err as Error).message}`,
+      );
+      await this.markSessionFailed(
+        query.state,
+        reason,
+        (err as Error).message,
+      );
+      throw err;
+    }
+  }
+
+  private async issueLoginToken(
+    _userId: string,
+  ): Promise<{ token: string; user: FaydaUserSummary }> {
+    throw new UnauthorizedException({
+      code: 'FAYDA_LOGIN_MIGRATED_TO_IAM',
+      message: 'Fayda login tokens are issued by the IAM package auth endpoints.',
+    });
+  }
+
+  async getVerificationStatus(iamUserId: string): Promise<VerificationStatusDto> {
+    const rows = await this.dataSource.query<{ verified_by: string | null; updated_at: Date | null; name: { en: string; am: string } | null }[]>(
+      `SELECT verified_by, updated_at, name FROM iam.users WHERE id = $1 LIMIT 1`,
+      [iamUserId],
+    );
+    const iam = rows[0] ?? null;
+    const faydaVerified = iam?.verified_by === 'fayda';
+    const faydaVerifiedAt = faydaVerified && iam?.updated_at ? new Date(iam.updated_at) : undefined;
+    const fullName = iam?.name?.en ?? iam?.name?.am ?? undefined;
+    return { verified: faydaVerified, verifiedAt: faydaVerifiedAt, fullName };
+  }
+
+  // ==========================================================================
+  // OIDC internals
+  // ==========================================================================
+
+  private buildAuthorizationUrl(args: {
+    state: string;
+    codeChallenge: string;
+    redirectUri: string;
+  }): string {
+    const params = new URLSearchParams({
+      client_id: this.faydaConfig.clientId,
+      response_type: 'code',
+      redirect_uri: args.redirectUri,
+      scope: this.faydaConfig.scope,
+      state: args.state,
+      code_challenge: args.codeChallenge,
+      code_challenge_method: 'S256',
+      acr_values: this.faydaConfig.acrValues,
+      claims_locales: this.faydaConfig.claimsLocales,
+    });
+
+    // Every claim is marked essential so eSignet shows them locked/pre-checked
+    // on the consent screen — the user cannot toggle any off; they either
+    // consent to all of them or the whole flow is cancelled (?error=...).
+    const claims = {
+      userinfo: {
+        name: { essential: true },
+        phone_number: { essential: true },
+        email: { essential: true },
+        birthdate: { essential: true },
+        gender: { essential: true },
+        address: { essential: true },
+        nationality: { essential: true },
+        picture: { essential: true },
+      },
+      id_token: {},
+    };
+    params.set('claims', JSON.stringify(claims));
+
+    return `${this.faydaConfig.authorizationEndpoint}?${params.toString()}`;
+  }
+
+  private async exchangeCodeForTokens(
+    code: string,
+    codeVerifier: string,
+    redirectUri: string,
+  ): Promise<FaydaTokenResponse> {
+    const clientAssertion = await generateClientAssertion({
+      clientId: this.faydaConfig.clientId,
+      audience: this.faydaConfig.tokenEndpoint,
+      privateJwk: this.faydaConfig.privateJwk,
+    });
+
+    const body = new URLSearchParams({
+      grant_type: 'authorization_code',
+      code,
+      redirect_uri: redirectUri,
+      client_id: this.faydaConfig.clientId,
+      client_assertion_type:
+        'urn:ietf:params:oauth:client-assertion-type:jwt-bearer',
+      client_assertion: clientAssertion,
+      code_verifier: codeVerifier,
+    });
+
+    const response = await fetch(this.faydaConfig.tokenEndpoint, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+      body,
+    });
+
+    if (!response.ok) {
+      let detail = '';
+      try {
+        detail = await response.text();
+      } catch {
+        // ignore
+      }
+      throw new FaydaTokenExchangeException(
+        `Fayda token endpoint returned ${response.status}${detail ? `: ${detail}` : ''}`,
+      );
+    }
+
+    return (await response.json()) as FaydaTokenResponse;
+  }
+
+  private async fetchUserInfo(accessToken: string): Promise<FaydaUserInfo> {
+    const response = await fetch(this.faydaConfig.userInfoEndpoint, {
+      method: 'GET',
+      headers: { Authorization: `Bearer ${accessToken}` },
+    });
+
+    if (!response.ok) {
+      throw new FaydaUserInfoException(
+        `Fayda userinfo endpoint returned ${response.status}`,
+      );
+    }
+
+    const contentType = response.headers.get('content-type') ?? '';
+    const raw = await response.text();
+
+    if (contentType.includes('application/json')) {
+      return JSON.parse(raw) as FaydaUserInfo;
+    }
+
+    // Signed JWT response — decode payload (signature verification = production TODO)
+    if (raw.split('.').length === 3) {
+      const payloadB64 = raw.split('.')[1];
+      const normalizedB64 = payloadB64.replace(/-/g, '+').replace(/_/g, '/');
+      const json = Buffer.from(normalizedB64, 'base64').toString('utf8');
+      return JSON.parse(json) as FaydaUserInfo;
+    }
+
+    throw new FaydaUserInfoException(
+      'Unsupported Fayda userinfo response format',
+    );
+  }
+
+  private normalizeUserInfo(raw: FaydaUserInfo): NormalizedFaydaUserInfo {
+    const nameEn   = raw['name#en'] as string | undefined;
+    const nameAm   = raw['name#am'] as string | undefined;
+    const genderEn = raw['gender#en'] as string | undefined;
+    const genderAm = raw['gender#am'] as string | undefined;
+    const addressEn = raw['address#en'] as string | undefined;
+    const addressAm = raw['address#am'] as string | undefined;
+    const rawPhone  = (raw.phone_number ?? raw['phone_number#en'] ?? raw['phone_number#am'] ?? raw.phone) as string | undefined;
+
+    return {
+      sub: raw.sub,
+      fullName: (raw.name as string | undefined) ?? nameEn ?? nameAm,
+      phoneNumber: rawPhone ? this.standardizePhoneNumber(rawPhone) : undefined,
+      rawPhoneNumber: rawPhone,
+      email: raw.email as string | undefined,
+      gender: genderEn ?? genderAm ?? (raw.gender as string | undefined),
+      birthdate: raw.birthdate as string | undefined,
+      picture: raw.picture as string | undefined,
+      nameEn,
+      nameAm,
+      genderEn,
+      genderAm,
+      addressEn,
+      addressAm,
+    };
+  }
+
+  private standardizePhoneNumber(phone: string): string {
+    const digits = phone.replace(/\D/g, '');
+    if (digits.startsWith('251')) return `+${digits}`;
+    if (digits.startsWith('0'))   return `+251${digits.slice(1)}`;
+    return `+${digits}`;
+  }
+
+  // LOGIN via Fayda is handled entirely by the IAM package's own OIDC flow.
+  // This method is kept as a stub so completeVerification() still compiles;
+  // it throws immediately without touching the database.
+  private async handleLoginSuccess(
+    _normalized: NormalizedFaydaUserInfo,
+  ): Promise<{ userId: string }> {
+    throw new UnauthorizedException({
+      code: 'FAYDA_LOGIN_MIGRATED_TO_IAM',
+      message: 'Fayda login tokens are issued by the IAM package at /v1/auth/fayda endpoints.',
+    });
+  }
+
+  private async upsertIamUser(
+    normalized: NormalizedFaydaUserInfo,
+  ): Promise<{ iamUserId: string | null; userDataSaved: boolean }> {
+    try {
+      const iamMetadata = {
+        sub: normalized.sub,
+        address: { am: normalized.addressAm ?? '', en: normalized.addressEn ?? '' },
+        email: normalized.email ?? '',
+        gender: { am: normalized.genderAm ?? '', en: normalized.genderEn ?? '' },
+        name:   { am: normalized.nameAm   ?? '', en: normalized.nameEn   ?? '' },
+        phoneNumber: normalized.rawPhoneNumber ?? '',
+      };
+
+      // Step 1 — already linked to this Fayda sub; ensure verified_by is set
+      const bySub = await this.dataSource.query<{ id: string }[]>(
+        `SELECT id FROM iam.users WHERE metadata->>'sub' = $1 LIMIT 1`,
+        [normalized.sub],
+      );
+      if (bySub.length > 0) {
+        await this.dataSource.query(
+          `UPDATE iam.users SET verified_by = 'fayda', updated_at = NOW() WHERE id = $1`,
+          [bySub[0].id],
+        );
+        return { iamUserId: bySub[0].id, userDataSaved: true };
+      }
+
+      // Step 2 — existing user by phone or email, not yet Fayda-verified
+      const conditions: string[] = [];
+      const params: unknown[] = [];
+      if (normalized.phoneNumber) {
+        params.push(normalized.phoneNumber);
+        conditions.push(`phone_number = $${params.length}`);
+      }
+      if (normalized.email) {
+        params.push(normalized.email);
+        conditions.push(`email = $${params.length}`);
+      }
+      if (conditions.length > 0) {
+        const byContact = await this.dataSource.query<{ id: string }[]>(
+          `SELECT id FROM iam.users WHERE ${conditions.join(' OR ')} LIMIT 1`,
+          params,
+        );
+        if (byContact.length > 0) {
+          const existingId = byContact[0].id;
+          await this.dataSource.query(
+            `UPDATE iam.users
+                SET metadata    = COALESCE(metadata, '{}'::jsonb) || $1::jsonb,
+                    verified_by = 'fayda',
+                    updated_at  = NOW()
+              WHERE id = $2`,
+            [JSON.stringify(iamMetadata), existingId],
+          );
+          return { iamUserId: existingId, userDataSaved: true };
+        }
+      }
+
+      // Step 3 — new user
+      const name     = { am: normalized.nameAm ?? '', en: normalized.nameEn ?? '' };
+      const username = normalized.phoneNumber ?? normalized.email ?? normalized.sub;
+      const inserted = await this.dataSource.query<{ id: string }[]>(
+        `INSERT INTO iam.users (
+            id, name, username, email, phone_number, metadata,
+            user_type, status, is_active, has_set_password,
+            is_phone_number_verified, verified_by,
+            created_at, updated_at
+          ) VALUES (
+            gen_random_uuid(), $1::jsonb, $2, $3, $4, $5::jsonb,
+            'individual', 'submitted', true, false,
+            false, 'fayda',
+            NOW(), NOW()
+          ) RETURNING id`,
+        [
+          JSON.stringify(name),
+          username,
+          normalized.email   ?? null,
+          normalized.phoneNumber ?? null,
+          JSON.stringify(iamMetadata),
+        ],
+      );
+      return { iamUserId: inserted[0].id, userDataSaved: true };
+    } catch (err) {
+      this.logger.error(`Fayda IAM upsert failed: ${(err as Error).message}`);
+      return { iamUserId: null, userDataSaved: false };
+    }
+  }
+
+  private async createFaydaSession(
+    iamUserId: string,
+  ): Promise<{ token: string; refreshToken: string; requiresPassword: boolean }> {
+    const rows = await this.dataSource.query<{
+      id: string;
+      email: string;
+      name: { en: string; am: string } | null;
+      username: string;
+      phone_number: string | null;
+      has_set_password: boolean;
+      status: string;
+    }[]>(
+      `SELECT id, email, name, username, phone_number, has_set_password, status
+         FROM iam.users WHERE id = $1 LIMIT 1`,
+      [iamUserId],
+    );
+    if (!rows.length) throw new Error(`IAM user ${iamUserId} not found`);
+    const u = rows[0];
+
+    const userInfo = {
+      id: u.id,
+      email: u.email ?? '',
+      name: u.name ?? { en: '', am: '' },
+      userType: 'individual',
+      status: u.status,
+      hasSetPassword: u.has_set_password,
+      isPhoneNumberVerified: false,
+      hasFinishedRegistration: false,
+      hasFinishedDMSOnboarding: false,
+      username: u.username,
+      phoneNumber: u.phone_number ?? '',
+      roles: [],
+      permissions: [],
+      employee: [],
+    };
+
+    const sessions = await this.dataSource.query<{ id: string }[]>(
+      `INSERT INTO iam.sessions
+          (id, email, device, "userInfo", expiry_time, refresh_count, status, user_id)
+        VALUES (gen_random_uuid(), $1, 'fayda-verify', $2::jsonb, NOW() + INTERVAL '1 day', 0, 'ACTIVE', $3)
+        ON CONFLICT (user_id, device) DO UPDATE
+          SET status = 'ACTIVE', "userInfo" = EXCLUDED."userInfo",
+              expiry_time = NOW() + INTERVAL '1 day', updated_at = NOW()
+        RETURNING id`,
+      [u.email ?? '', JSON.stringify(userInfo), iamUserId],
+    );
+
+    const sessionId = sessions[0].id;
+    const token = generateToken({ id: sessionId });
+    const refreshToken = generateRefreshToken({ id: sessionId });
+
+    return { token, refreshToken, requiresPassword: !u.has_set_password };
+  }
+
+  private async markSessionFailed(
+    state: string,
+    errorCode: string,
+    errorDescription?: string,
+  ): Promise<void> {
+    await this.sessionRepo.update(
+      { state, status: 'PENDING' },
+      {
+        status: 'FAILED',
+        errorCode,
+        errorDescription: errorDescription ?? null,
+        completedAt: new Date(),
+        codeVerifier: '',
+      },
+    );
+  }
+
+  private classifyFailureReason(err: unknown): string {
+    if (err instanceof FaydaTokenExchangeException) return 'token_exchange_failed';
+    if (err instanceof FaydaUserInfoException) return 'userinfo_failed';
+    return 'verification_failed';
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/verifayda/verifayda.types.ts b/apps/edr-freight-api/src/modules/verifayda/verifayda.types.ts
new file mode 100644
index 000000000..442a22d2f
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/verifayda/verifayda.types.ts
@@ -0,0 +1,45 @@
+export type VerifaydaPurpose = 'LOGIN' | 'VERIFY';
+
+export interface FaydaTokenResponse {
+  access_token: string;
+  id_token?: string;
+  token_type: string;
+  expires_in?: number;
+  scope?: string;
+}
+
+export interface FaydaUserInfo {
+  sub: string;
+  name?: string;
+  'name#en'?: string;
+  'name#am'?: string;
+  phone_number?: string;
+  'phone_number#en'?: string;
+  'phone_number#am'?: string;
+  phone?: string;
+  email?: string;
+  gender?: string;
+  birthdate?: string;
+  picture?: string;
+  address?: Record<string, unknown>;
+  [key: string]: unknown;
+}
+
+export interface NormalizedFaydaUserInfo {
+  sub: string;
+  // Convenience / display fields
+  fullName?: string;
+  phoneNumber?: string;   // standardized e.g. +251911234567
+  email?: string;
+  gender?: string;
+  birthdate?: string;
+  picture?: string;
+  // Raw localized fields — preserved for IAM-identical writes
+  nameEn?: string;
+  nameAm?: string;
+  genderEn?: string;
+  genderAm?: string;
+  addressEn?: string;
+  addressAm?: string;
+  rawPhoneNumber?: string; // unstandardized, stored in IAM metadata
+}
diff --git a/apps/edr-freight-api/src/modules/warehouses/dto/allocation-rule.dto.ts b/apps/edr-freight-api/src/modules/warehouses/dto/allocation-rule.dto.ts
index 43cd6f61a..8d18d2a1f 100644
--- a/apps/edr-freight-api/src/modules/warehouses/dto/allocation-rule.dto.ts
+++ b/apps/edr-freight-api/src/modules/warehouses/dto/allocation-rule.dto.ts
@@ -1,9 +1,10 @@
 import { ApiProperty, ApiPropertyOptional, PartialType } from '@nestjs/swagger';
-import { IsBoolean, IsInt, IsOptional, IsString } from 'class-validator';
+import { IsBoolean, IsInt, IsOptional, IsString, Matches } from 'class-validator';
 
 export class CreateAllocationRuleDto {
   @ApiProperty()
   @IsString()
+  @Matches(/^[A-Za-z\s]+$/, { message: 'name may only contain letters and spaces' })
   name!: string;
 
   @ApiPropertyOptional({ default: 100 })
diff --git a/apps/edr-freight-api/src/modules/warehouses/dto/create-warehouse.dto.ts b/apps/edr-freight-api/src/modules/warehouses/dto/create-warehouse.dto.ts
index 788c798bf..5a8025948 100644
--- a/apps/edr-freight-api/src/modules/warehouses/dto/create-warehouse.dto.ts
+++ b/apps/edr-freight-api/src/modules/warehouses/dto/create-warehouse.dto.ts
@@ -1,5 +1,5 @@
 import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
-import { IsEnum, IsNumber, IsOptional, IsString, IsUUID, MaxLength, Min } from 'class-validator';
+import { IsEnum, IsNumber, IsOptional, IsString, IsUUID, Matches, MaxLength, Min } from 'class-validator';
 
 import { WAREHOUSE_TYPES, WarehouseType } from '../entities/warehouse.entity';
 
@@ -7,6 +7,7 @@ export class CreateWarehouseDto {
   @ApiProperty()
   @IsString()
   @MaxLength(160)
+  @Matches(/^[A-Za-z\s]+$/, { message: 'name may only contain letters and spaces' })
   name!: string;
 
   @ApiProperty()
diff --git a/apps/edr-freight-api/src/modules/warehouses/dto/fee-rule.dto.ts b/apps/edr-freight-api/src/modules/warehouses/dto/fee-rule.dto.ts
index e2c20901d..22e9f9491 100644
--- a/apps/edr-freight-api/src/modules/warehouses/dto/fee-rule.dto.ts
+++ b/apps/edr-freight-api/src/modules/warehouses/dto/fee-rule.dto.ts
@@ -1,6 +1,6 @@
 import { ApiProperty, ApiPropertyOptional, PartialType } from '@nestjs/swagger';
 import { Type } from 'class-transformer';
-import { IsArray, IsEnum, IsInt, IsNumber, IsOptional, IsString, IsUUID, Min, ValidateNested } from 'class-validator';
+import { IsArray, IsEnum, IsInt, IsNumber, IsOptional, IsString, IsUUID, Matches, Min, ValidateNested } from 'class-validator';
 
 import { FEE_RULE_TYPES, FeeRuleType } from '../entities/warehouse-fee-rule.entity';
 
@@ -25,6 +25,7 @@ export class FeeRuleTierDto {
 export class CreateFeeRuleDto {
   @ApiProperty()
   @IsString()
+  @Matches(/^[A-Za-z\s]+$/, { message: 'name may only contain letters and spaces' })
   name!: string;
 
   @ApiProperty({ enum: FEE_RULE_TYPES })
diff --git a/apps/edr-freight-api/src/modules/warehouses/dto/filter-inventory.dto.ts b/apps/edr-freight-api/src/modules/warehouses/dto/filter-inventory.dto.ts
index 9f89e7c2c..49fb22fde 100644
--- a/apps/edr-freight-api/src/modules/warehouses/dto/filter-inventory.dto.ts
+++ b/apps/edr-freight-api/src/modules/warehouses/dto/filter-inventory.dto.ts
@@ -52,6 +52,11 @@ export class FilterWarehouseInventoryDto {
   @IsEnum(WAREHOUSE_INVENTORY_STATUSES)
   status?: WarehouseInventoryStatus;
 
+  @ApiPropertyOptional({ enum: ['IMPORT', 'EXPORT'] })
+  @IsOptional()
+  @IsEnum(['IMPORT', 'EXPORT'])
+  direction?: 'IMPORT' | 'EXPORT';
+
   @ApiPropertyOptional()
   @IsOptional()
   @IsString()
diff --git a/apps/edr-freight-api/src/modules/warehouses/warehouse-inventory.service.ts b/apps/edr-freight-api/src/modules/warehouses/warehouse-inventory.service.ts
index 11f34c892..c9844051b 100644
--- a/apps/edr-freight-api/src/modules/warehouses/warehouse-inventory.service.ts
+++ b/apps/edr-freight-api/src/modules/warehouses/warehouse-inventory.service.ts
@@ -430,6 +430,7 @@ export class WarehouseInventoryService {
       ...(filter.status ? { status: filter.status } : {}),
       ...(createdAt ? { createdAt } : {}),
       ...(filter.facilityId ? { warehouse: { stationId: filter.facilityId } } : {}),
+      ...(filter.direction ? { booking: { tradeDirection: filter.direction } } : {}),
     };
 
     const search = filter.search?.trim();
@@ -919,6 +920,23 @@ export class WarehouseInventoryService {
           }),
         );
 
+        // Receiving the booking flags every container unit as received into the
+        // port (self-haul export: the delivering truck's goods are now in) so
+        // staff can raise the per-container GRN over what's received.
+        await manager.query(
+          `UPDATE freight.booking_container_units bcu
+              SET received_to_port = true,
+                  received_at = COALESCE(bcu.received_at, NOW()),
+                  updated_at = NOW()
+             FROM freight.booking_containers bc
+            WHERE bc.id = bcu.booking_container_id
+              AND bc.booking_id = $1
+              AND bc.deleted_at IS NULL
+              AND bcu.deleted_at IS NULL
+              AND bcu.received_to_port = false`,
+          [bookingId],
+        );
+
         await this.activityLog.record(
           {
             activityType: 'INVENTORY_RECEIVED',
@@ -1773,6 +1791,26 @@ export class WarehouseInventoryService {
 
       await this.applyCapacityDelta(manager, dto, weight, volume, containerCount);
 
+      // Per-container receive: flag this container's unit as received into the
+      // port so staff can raise the GRN over what's received.
+      if (dto.bookingId && dto.containerId) {
+        await manager.query(
+          `UPDATE freight.booking_container_units bcu
+              SET received_to_port = true,
+                  received_at = COALESCE(bcu.received_at, NOW()),
+                  updated_at = NOW()
+             FROM freight.booking_containers bc, freight.containers cont
+            WHERE bc.id = bcu.booking_container_id
+              AND bc.booking_id = $1
+              AND bc.deleted_at IS NULL
+              AND cont.id = $2
+              AND cont.container_number = bcu.container_number
+              AND bcu.deleted_at IS NULL
+              AND bcu.received_to_port = false`,
+          [dto.bookingId, dto.containerId],
+        );
+      }
+
       await this.activityLog.record(
         {
             activityType: 'INVENTORY_RECEIVED',
@@ -2032,6 +2070,22 @@ export class WarehouseInventoryService {
     const isTruckLeaving = dto.grossWeight !== undefined && Boolean(dto.gateOutTime);
     if (isTruckLeaving) {
       await this.invoices.assertClearanceAllowed(id);
+
+      if (item.bookingId) {
+        const [truckInfo]: Array<{ customerTruckAssignedAt: string | null }> =
+          await this.dataSource.query(
+            `SELECT customer_truck_assigned_at AS "customerTruckAssignedAt"
+               FROM freight.bookings
+              WHERE id = $1 AND deleted_at IS NULL`,
+            [item.bookingId],
+          );
+        const usesCustomerTruck = Boolean(truckInfo?.customerTruckAssignedAt);
+        if (usesCustomerTruck && !this.extractCustomerDeliveryApproval(item.notes)) {
+          throw new BadRequestException(
+            'Customer must approve delivery (sign the handover) before the exit paper can be generated',
+          );
+        }
+      }
     }
     const releaseDate = isTruckLeaving
       ? dto.releaseDate ? new Date(dto.releaseDate) : new Date()
@@ -2051,6 +2105,29 @@ export class WarehouseInventoryService {
         notes: this.replaceExitInspectionNote(item.notes, exitInspectionNote),
       });
       if (!isTruckLeaving && item.bookingId) {
+        // Per-truck arrival: mark the customer truck carrying THIS item's
+        // container as arrived (matched via the physical container number).
+        if (item.containerId) {
+          await manager.query(
+            `UPDATE freight.customer_truck_assignments a
+                SET arrived_at = COALESCE(a.arrived_at, NOW()), updated_at = NOW()
+               FROM freight.customer_truck_containers c
+               JOIN freight.containers cont ON cont.container_number = c.container_number
+              WHERE c.assignment_id = a.id
+                AND c.deleted_at IS NULL
+                AND c.booking_id = $1
+                AND cont.id = $2
+                AND a.arrived_at IS NULL
+                AND a.deleted_at IS NULL`,
+            [item.bookingId, item.containerId],
+          );
+          // NB: import arrival changes nothing on the goods — received_to_port is
+          // an EXPORT concept (set when a truck delivers into the port). Import
+          // load + weight are captured on truck departure, not arrival.
+        }
+        // Booking-level flag stamped on the FIRST truck arrival. The import
+        // handover is signed ONCE (before the first truck leaves), even though
+        // trucks pick up per-container — COALESCE keeps the first timestamp.
         await manager.query(
           `UPDATE freight.bookings
               SET customer_truck_arrived_at = COALESCE(customer_truck_arrived_at, NOW()),
@@ -2130,6 +2207,48 @@ export class WarehouseInventoryService {
     }
     await this.invoices.assertClearanceAllowed(id);
 
+    // Import self-haul: the exit paper names the pickup truck + all containers it
+    // carries, so gate staff can verify the goods leaving on that truck.
+    let truck: {
+      plateNumber: string;
+      driverName: string;
+      truckType: string;
+      containerNumbers: string;
+      truckWeightTons: string | number | null;
+      grossWeightKg: string | number | null;
+      departedAt: string | null;
+    } | null = null;
+    if (row?.tradeDirection === 'IMPORT' && row?.containerNumber && row?.bookingId) {
+      const [truckRow] = await this.dataSource.query(
+        `SELECT a.plate_number AS "plateNumber",
+                a.driver_name AS "driverName",
+                a.truck_type AS "truckType",
+                a.gross_weight_kg AS "grossWeightKg",
+                a.departed_at AS "departedAt",
+                string_agg(DISTINCT c2.container_number, ', ' ORDER BY c2.container_number) AS "containerNumbers",
+                COALESCE((
+                  SELECT SUM(bcu.vgm_tons)
+                    FROM freight.customer_truck_containers cc
+                    JOIN freight.booking_container_units bcu
+                      ON bcu.container_number = cc.container_number AND bcu.deleted_at IS NULL
+                    JOIN freight.booking_containers bc
+                      ON bc.id = bcu.booking_container_id AND bc.deleted_at IS NULL
+                     AND bc.booking_id = c.booking_id
+                   WHERE cc.assignment_id = a.id AND cc.deleted_at IS NULL
+                ), 0) AS "truckWeightTons"
+           FROM freight.customer_truck_containers c
+           JOIN freight.customer_truck_assignments a
+             ON a.id = c.assignment_id AND a.deleted_at IS NULL
+           JOIN freight.customer_truck_containers c2
+             ON c2.assignment_id = a.id AND c2.deleted_at IS NULL
+          WHERE c.booking_id = $1 AND c.container_number = $2 AND c.deleted_at IS NULL
+          GROUP BY a.id, a.plate_number, a.driver_name, a.truck_type, c.booking_id
+          LIMIT 1`,
+        [row.bookingId, row.containerNumber],
+      );
+      truck = truckRow ?? null;
+    }
+
     const bookingReference = row?.bookingReference || 'N/A';
     const reference =
       row?.releaseOrderReference ||
@@ -2153,6 +2272,17 @@ export class WarehouseInventoryService {
       inventoryStatus: row?.status ?? null,
       clearanceStatus: 'CLEARED FOR WAREHOUSE EXIT',
       exitInspectionSummary: this.extractExitInspectionNote(row?.notes),
+      truckPlateNumber: truck?.plateNumber ?? null,
+      truckDriverName: truck?.driverName ?? null,
+      truckType: truck?.truckType ?? null,
+      truckGateOut: truck?.departedAt ?? null,
+      // Prefer the weighed gross captured on departure; fall back to the summed
+      // container VGM when the truck hasn't been weighed yet.
+      truckWeightKg: truck
+        ? Number(truck.grossWeightKg ?? 0) > 0
+          ? Number(truck.grossWeightKg)
+          : Number(truck.truckWeightTons ?? 0) * 1000
+        : null,
     });
 
     return {
@@ -3082,6 +3212,11 @@ export class WarehouseInventoryService {
     inventoryStatus: string | null;
     clearanceStatus: string;
     exitInspectionSummary?: string | null;
+    truckPlateNumber?: string | null;
+    truckDriverName?: string | null;
+    truckType?: string | null;
+    truckGateOut?: string | null;
+    truckWeightKg?: number | null;
   }): string {
     const esc = (value: unknown) =>
       String(value ?? '-')
@@ -3106,12 +3241,37 @@ export class WarehouseInventoryService {
       ['Container Number', data.containerNumber],
       ['Cargo / Goods Description', data.cargoDescription],
       ['Quantity', data.quantity],
-      ['Declared Weight', `${data.weight.toLocaleString()} kg`],
+      [
+        data.truckPlateNumber ? 'Gross Weight (Loaded on Truck)' : 'Declared Weight',
+        `${(data.truckPlateNumber && data.truckWeightKg
+          ? data.truckWeightKg
+          : data.weight
+        ).toLocaleString()} kg`,
+      ],
       ['Warehouse', data.warehouse],
       ['Yard', data.yard],
       ['Zone', data.zone],
       ['Inventory Status', data.inventoryStatus],
       ['Clearance Status', data.clearanceStatus],
+      ...(data.truckPlateNumber
+        ? ([
+            ['Pickup Truck Plate', data.truckPlateNumber],
+            ['Truck Driver', data.truckDriverName],
+            ['Truck Type', data.truckType],
+            [
+              'Gate-Out Time',
+              data.truckGateOut
+                ? new Date(data.truckGateOut).toLocaleString('en-GB', {
+                    year: 'numeric',
+                    month: 'short',
+                    day: '2-digit',
+                    hour: '2-digit',
+                    minute: '2-digit',
+                  })
+                : null,
+            ],
+          ] as [string, string | null][])
+        : []),
       ...(data.exitInspectionSummary ? [['Exit Inspection', data.exitInspectionSummary] as [string, string]] : []),
     ];
 
diff --git a/apps/edr-freight-api/src/modules/warehouses/warehouse-release-document.service.ts b/apps/edr-freight-api/src/modules/warehouses/warehouse-release-document.service.ts
index f8c0dd355..68e630e0b 100644
--- a/apps/edr-freight-api/src/modules/warehouses/warehouse-release-document.service.ts
+++ b/apps/edr-freight-api/src/modules/warehouses/warehouse-release-document.service.ts
@@ -20,6 +20,18 @@ export class WarehouseReleaseDocumentService {
     });
   }
 
+  /**
+   * Render arbitrary document HTML to PDF via the shared renderer WITHOUT the
+   * release-order fallback. Non-release documents (e.g. the import/export
+   * marshalling load list) must use this so a Chromium-less fallback degrades to
+   * a plain-text dump of *their own* content — instead of masquerading as a
+   * "Warehouse Gate Clearance / Release Order", which the release-specific
+   * fallback would otherwise draw regardless of the input HTML.
+   */
+  renderDocumentHtml(html: string, label = 'Document'): Promise<Buffer> {
+    return this.pdf.htmlToPdfBuffer(html, { label });
+  }
+
   private htmlToBasicPdfBuffer(html: string): Buffer {
     const doc = this.extractReleaseDocument(html);
     const body: string[] = [
diff --git a/apps/edr-freight-api/src/scripts/seed-paid-import-export-mile-demo.ts b/apps/edr-freight-api/src/scripts/seed-paid-import-export-mile-demo.ts
new file mode 100644
index 000000000..6b2a422e8
--- /dev/null
+++ b/apps/edr-freight-api/src/scripts/seed-paid-import-export-mile-demo.ts
@@ -0,0 +1,28 @@
+import 'reflect-metadata';
+import { config } from 'dotenv';
+import { resolve } from 'path';
+
+config({ path: resolve(__dirname, '../../.env') });
+
+import { NestFactory } from '@nestjs/core';
+import { AppModule } from '../app.module';
+import { PaidImportExportMileDemoSeeder } from '../seed/paid-import-export-mile-demo.seeder';
+
+async function main() {
+  const app = await NestFactory.createApplicationContext(AppModule, {
+    logger: ['error', 'warn', 'log'],
+  });
+
+  try {
+    const seeder = app.get(PaidImportExportMileDemoSeeder);
+    await seeder.run();
+    console.log('Paid import/export mile demo bookings seeded.');
+  } finally {
+    await app.close();
+  }
+}
+
+main().catch((err) => {
+  console.error('Paid import/export mile demo booking seed failed:', err);
+  process.exit(1);
+});
diff --git a/apps/edr-freight-api/src/seed/marshalling-demo-trains.seeder.ts b/apps/edr-freight-api/src/seed/marshalling-demo-trains.seeder.ts
index 2d3c47c26..53d6c9eec 100644
--- a/apps/edr-freight-api/src/seed/marshalling-demo-trains.seeder.ts
+++ b/apps/edr-freight-api/src/seed/marshalling-demo-trains.seeder.ts
@@ -3,6 +3,7 @@ import { WagonStatus } from '@edr/types';
 import { DataSource } from 'typeorm';
 
 import { Booking } from '../modules/bookings/entities/booking.entity';
+import { Company } from '../modules/companies/entities/company.entity';
 import { Locomotive } from '../modules/locomotives/entities/locomotive.entity';
 import { CargoType } from '../modules/rule-engine/entities/cargo-type.entity';
 import { ServiceType } from '../modules/rule-engine/entities/service-type.entity';
@@ -116,6 +117,11 @@ export class MarshallingDemoTrainsSeeder {
         ? await warehouseZoneRepo.findOne({ where: { yardId: warehouseYard.id } })
         : null;
 
+      // bookings.company_id is NOT NULL — reuse any seeded company for the demo.
+      const company = await this.dataSource
+        .getRepository(Company)
+        .findOne({ where: {}, order: { createdAt: 'ASC' } });
+
       const missing = [
         !djiboutiYard ? 'Djibouti yard' : '',
         !ethiopiaYard ? 'Ethiopia yard' : '',
@@ -124,6 +130,7 @@ export class MarshallingDemoTrainsSeeder {
         !warehouse ? 'INDODE_OPEN warehouse' : '',
         !warehouseYard ? 'warehouse yard' : '',
         !warehouseZone ? 'warehouse zone' : '',
+        !company ? 'company' : '',
       ].filter(Boolean);
       if (missing.length) {
         this.logger.warn(`Cannot seed marshalling demo trains, missing: ${missing.join(', ')}`);
@@ -141,6 +148,7 @@ export class MarshallingDemoTrainsSeeder {
           warehouse: warehouse!,
           warehouseYard: warehouseYard!,
           warehouseZone: warehouseZone!,
+          company: company!,
         });
         if (created) seeded += 1;
       }
@@ -164,6 +172,7 @@ export class MarshallingDemoTrainsSeeder {
       warehouse: Warehouse;
       warehouseYard: WarehouseYard;
       warehouseZone: WarehouseZone;
+      company: Company;
     },
   ): Promise<boolean> {
     const bookingRepo = this.dataSource.getRepository(Booking);
@@ -231,6 +240,7 @@ export class MarshallingDemoTrainsSeeder {
       const booking = await bookingRepo.save(
         bookingRepo.create({
           reference: bookingReference,
+          companyId: refs.company.id,
           originYardId: originYard.id,
           destinationYardId: destinationYard.id,
           serviceTypeId: refs.serviceType.id,
diff --git a/apps/edr-freight-api/src/seed/paid-import-export-mile-demo.seeder.ts b/apps/edr-freight-api/src/seed/paid-import-export-mile-demo.seeder.ts
new file mode 100644
index 000000000..708afb86b
--- /dev/null
+++ b/apps/edr-freight-api/src/seed/paid-import-export-mile-demo.seeder.ts
@@ -0,0 +1,299 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { randomUUID } from 'crypto';
+import { DataSource } from 'typeorm';
+
+import { BookingContainer } from '../modules/bookings/entities/booking-container.entity';
+import { Booking } from '../modules/bookings/entities/booking.entity';
+import { Company, CompanyStatus, CompanyType } from '../modules/companies/entities/company.entity';
+import { FirstMile } from '../modules/first-mile/entities/first-mile.entity';
+import { LastMile } from '../modules/last-mile/entities/last-mile.entity';
+import { ContainerType } from '../modules/rule-engine/entities/container-type.entity';
+import { ServiceType } from '../modules/rule-engine/entities/service-type.entity';
+import { Yard } from '../modules/rule-engine/entities/yard.entity';
+
+const SERVICE_TYPE_CODE = 'RAIL_CONTAINER_PAID_MILE';
+const COMPANY_TIN = 'PAIDMILE001';
+const COMPANY_EMAIL = 'paid-mile-demo@edr.local';
+
+const YARDS = [
+  { code: 'DJIBOUTI', label: 'Djibouti', country: 'Djibouti', displayOrder: 1 },
+  { code: 'ADDIS_ABABA', label: 'Addis Ababa', country: 'Ethiopia', displayOrder: 2 },
+];
+
+const CONTAINER_TYPES = [
+  { code: '20FT', label: '20FT', sizeFt: 20 },
+  { code: '40FT', label: '40FT', sizeFt: 40 },
+];
+
+/**
+ * Six paid, approved container bookings that mirror the real trucking legs:
+ *  - EXPORT (Ethiopia -> Djibouti) carries a FIRST-MILE leg (factory -> rail terminal).
+ *  - IMPORT (Djibouti -> Ethiopia) carries a LAST-MILE leg (dry port -> final delivery).
+ * Each booking is paymentStatus PAID and its single mile leg is marked paid + ready to transit.
+ */
+const DEMO_BOOKINGS = [
+  // ── IMPORT: last mile only ─────────────────────────────────────────────
+  {
+    reference: 'PAID-IMP-001',
+    tradeDirection: 'IMPORT',
+    containerCode: '40FT',
+    quantity: 8,
+    totalWeightTons: 224,
+    originCode: 'DJIBOUTI',
+    destinationCode: 'ADDIS_ABABA',
+    scheduledDate: '2026-07-01T08:00:00.000Z',
+    lastMileDeliveryAddress: 'Akaki Industrial Zone, Addis Ababa',
+    lastMileDeliveryLat: 8.8808,
+    lastMileDeliveryLng: 38.7876,
+  },
+  {
+    reference: 'PAID-IMP-002',
+    tradeDirection: 'IMPORT',
+    containerCode: '20FT',
+    quantity: 12,
+    totalWeightTons: 240,
+    originCode: 'DJIBOUTI',
+    destinationCode: 'ADDIS_ABABA',
+    scheduledDate: '2026-07-02T08:00:00.000Z',
+    lastMileDeliveryAddress: 'Kality Logistics Hub, Addis Ababa',
+    lastMileDeliveryLat: 8.9137,
+    lastMileDeliveryLng: 38.7815,
+  },
+  {
+    reference: 'PAID-IMP-003',
+    tradeDirection: 'IMPORT',
+    containerCode: '40FT',
+    quantity: 6,
+    totalWeightTons: 180,
+    originCode: 'DJIBOUTI',
+    destinationCode: 'ADDIS_ABABA',
+    scheduledDate: '2026-07-03T08:00:00.000Z',
+    lastMileDeliveryAddress: 'Bole Lemi Industrial Park, Addis Ababa',
+    lastMileDeliveryLat: 8.9806,
+    lastMileDeliveryLng: 38.8736,
+  },
+  // ── EXPORT: first mile only ────────────────────────────────────────────
+  {
+    reference: 'PAID-EXP-001',
+    tradeDirection: 'EXPORT',
+    containerCode: '40FT',
+    quantity: 7,
+    totalWeightTons: 196,
+    originCode: 'ADDIS_ABABA',
+    destinationCode: 'DJIBOUTI',
+    scheduledDate: '2026-07-01T10:00:00.000Z',
+    firstMilePickupAddress: 'Bole Lemi Industrial Park, Addis Ababa',
+    firstMilePickupLat: 8.9806,
+    firstMilePickupLng: 38.8736,
+  },
+  {
+    reference: 'PAID-EXP-002',
+    tradeDirection: 'EXPORT',
+    containerCode: '20FT',
+    quantity: 11,
+    totalWeightTons: 220,
+    originCode: 'ADDIS_ABABA',
+    destinationCode: 'DJIBOUTI',
+    scheduledDate: '2026-07-02T10:00:00.000Z',
+    firstMilePickupAddress: 'Akaki Industrial Zone, Addis Ababa',
+    firstMilePickupLat: 8.8808,
+    firstMilePickupLng: 38.7876,
+  },
+  {
+    reference: 'PAID-EXP-003',
+    tradeDirection: 'EXPORT',
+    containerCode: '40FT',
+    quantity: 4,
+    totalWeightTons: 128,
+    originCode: 'ADDIS_ABABA',
+    destinationCode: 'DJIBOUTI',
+    scheduledDate: '2026-07-03T10:00:00.000Z',
+    firstMilePickupAddress: 'Kality Logistics Hub, Addis Ababa',
+    firstMilePickupLat: 8.9137,
+    firstMilePickupLng: 38.7815,
+  },
+] as const;
+
+@Injectable()
+export class PaidImportExportMileDemoSeeder {
+  private readonly logger = new Logger(PaidImportExportMileDemoSeeder.name);
+
+  constructor(private readonly dataSource: DataSource) {}
+
+  async run() {
+    await this.dataSource.transaction(async (manager) => {
+      await manager.getRepository(Yard).upsert(
+        YARDS.map((yard) => ({ ...yard, isActive: true })),
+        { conflictPaths: { code: true } },
+      );
+
+      await manager.getRepository(ServiceType).upsert(
+        {
+          code: SERVICE_TYPE_CODE,
+          serviceName: 'Rail Container with Paid First/Last Mile',
+          description: 'Demo service type for paid import/export bookings with a single mile leg',
+          canBeBookedAlone: true,
+          includesFirstMile: true,
+          includesLastMile: true,
+          includesCustoms: false,
+          priorityBonusPoints: 0,
+          isActive: true,
+          displayOrder: 11,
+        },
+        { conflictPaths: { code: true } },
+      );
+
+      await manager.getRepository(ContainerType).upsert(
+        CONTAINER_TYPES.map((containerType, index) => ({
+          ...containerType,
+          wagonsPerUnit: 1,
+          isReefer: false,
+          isOpenTop: false,
+          isActive: true,
+          displayOrder: index + 1,
+        })),
+        { conflictPaths: { code: true } },
+      );
+
+      await manager.getRepository(Company).upsert(
+        {
+          name: 'Paid Import/Export Mile Demo Customer',
+          type: CompanyType.Customer,
+          status: CompanyStatus.Active,
+          tin: COMPANY_TIN,
+          vatNumber: COMPANY_TIN,
+          fanNumber: 'PMD0000000000001',
+          country: 'Ethiopia',
+          address: 'Addis Ababa',
+          phone: '251900000202',
+          email: COMPANY_EMAIL,
+          website: null,
+          contactPersonName: 'Paid Mile Demo',
+          contactPersonPhone: '251900000202',
+          generalManagerName: 'Demo Manager',
+          generalManagerEmail: COMPANY_EMAIL,
+          generalManagerPhone: '251900000202',
+        },
+        { conflictPaths: { tin: true } },
+      );
+
+      const [serviceType, company, yards, containerTypes] = await Promise.all([
+        manager.getRepository(ServiceType).findOneByOrFail({ code: SERVICE_TYPE_CODE }),
+        manager.getRepository(Company).findOneByOrFail({ tin: COMPANY_TIN }),
+        manager.getRepository(Yard).find(),
+        manager.getRepository(ContainerType).find(),
+      ]);
+
+      const yardByCode = new Map(yards.map((yard) => [yard.code, yard]));
+      const containerTypeByCode = new Map(
+        containerTypes.map((containerType) => [containerType.code, containerType]),
+      );
+
+      for (const demoBooking of DEMO_BOOKINGS) {
+        const origin = yardByCode.get(demoBooking.originCode);
+        const destination = yardByCode.get(demoBooking.destinationCode);
+        const containerType = containerTypeByCode.get(demoBooking.containerCode);
+
+        if (!origin || !destination || !containerType) {
+          throw new Error(`paid_import_export_mile_demo_dependency_missing:${demoBooking.reference}`);
+        }
+
+        const isImport = demoBooking.tradeDirection === 'IMPORT';
+        const wagonsRequired =
+          Number(demoBooking.quantity) * Number(containerType.wagonsPerUnit ?? 1);
+        const vgmPerUnitTons = demoBooking.totalWeightTons / demoBooking.quantity;
+
+        await manager.getRepository(Booking).upsert(
+          {
+            reference: demoBooking.reference,
+            companyId: company.id,
+            status: 'APPROVED',
+            scheduledDate: new Date(demoBooking.scheduledDate),
+            estimatedShipmentDate: new Date(demoBooking.scheduledDate),
+            totalAmount: demoBooking.totalWeightTons * 25,
+            paymentStatus: 'PAID',
+            contractType: 'NEW',
+            serviceTypeId: serviceType.id,
+            // Only the leg that matches the trade direction carries an address.
+            firstMilePickupAddress: isImport ? null : demoBooking.firstMilePickupAddress,
+            firstMilePickupLat: isImport ? null : demoBooking.firstMilePickupLat,
+            firstMilePickupLng: isImport ? null : demoBooking.firstMilePickupLng,
+            lastMileDeliveryAddress: isImport ? demoBooking.lastMileDeliveryAddress : null,
+            lastMileDeliveryLat: isImport ? demoBooking.lastMileDeliveryLat : null,
+            lastMileDeliveryLng: isImport ? demoBooking.lastMileDeliveryLng : null,
+            equipmentReturn: 'WITHOUT_RETURN',
+            originYardId: origin.id,
+            destinationYardId: destination.id,
+            tradeDirection: demoBooking.tradeDirection,
+            freightType: 'CONTAINER',
+            cargoTypeId: null,
+            cargoFreeText: 'Demo container cargo',
+            shippingLineId: null,
+            cargoTotalWeightVgm: demoBooking.totalWeightTons,
+            isHazardous: false,
+            isReefer: false,
+            paymentCurrency: 'ETB',
+            approvedByStaffAt: new Date(),
+            priorityScore: 20,
+            wagonsRequired,
+            schedulingStatus: 'NOT_SCHEDULED',
+            versionNumber: 1,
+          },
+          { conflictPaths: { reference: true } },
+        );
+
+        const booking = await manager.getRepository(Booking).findOneByOrFail({
+          reference: demoBooking.reference,
+        });
+
+        await manager.getRepository(BookingContainer).delete({ bookingId: booking.id });
+        await manager.getRepository(BookingContainer).insert({
+          id: randomUUID(),
+          bookingId: booking.id,
+          containerTypeId: containerType.id,
+          quantity: demoBooking.quantity,
+          vgmPerUnitTons,
+          totalVgmTons: demoBooking.totalWeightTons,
+          wagonsRequired,
+          weightLimitRuleId: null,
+          isOverweight: vgmPerUnitTons > 35,
+          overweightExcessTons: vgmPerUnitTons > 35 ? vgmPerUnitTons - 35 : null,
+        });
+
+        // Reset any existing legs for idempotency, then create the single paid leg.
+        await manager.getRepository(FirstMile).delete({ bookingId: booking.id });
+        await manager.getRepository(LastMile).delete({ bookingId: booking.id });
+
+        const paidAmount = demoBooking.totalWeightTons * 25;
+
+        if (isImport) {
+          await manager.getRepository(LastMile).insert({
+            bookingId: booking.id,
+            status: 'READY_TO_TRANSIT',
+            advancedPayment: paidAmount,
+            remainingPayment: 0,
+            paid: true,
+            estimatedKm: 22,
+            exactKm: null,
+            vehicleId: null,
+          });
+        } else {
+          await manager.getRepository(FirstMile).insert({
+            bookingId: booking.id,
+            status: 'READY_TO_TRANSIT',
+            advancedPayment: paidAmount,
+            remainingPayment: 0,
+            paid: true,
+            estimatedKm: 18,
+            exactKm: null,
+            vehicleId: null,
+          });
+        }
+      }
+    });
+
+    this.logger.log(
+      'Seeded 6 paid bookings: 3 import (last-mile) + 3 export (first-mile).',
+    );
+  }
+}
diff --git a/apps/edr-freight-api/src/seed/pricing-data.seeder.ts b/apps/edr-freight-api/src/seed/pricing-data.seeder.ts
index 02a05602e..aa3f2c9bb 100644
--- a/apps/edr-freight-api/src/seed/pricing-data.seeder.ts
+++ b/apps/edr-freight-api/src/seed/pricing-data.seeder.ts
@@ -319,37 +319,11 @@ private async seedWeightLimits(wlRepo: any, ctRepo: any): Promise<void> {
   const twenty = await ctRepo.findOneByOrFail({ code: "20FT" });
   const forty = await ctRepo.findOneByOrFail({ code: "40FT" });
 
-  const base = new Date("2026-01-01");
-
   const rules = [
-    {
-      containerTypeId: twenty.id,
-      tradeDirection: "IMPORT",
-      maxVgmTons: 26,
-      effectiveFrom: base,
-      isActive: true,
-    },
-    {
-      containerTypeId: twenty.id,
-      tradeDirection: "EXPORT",
-      maxVgmTons: 26,
-      effectiveFrom: base,
-      isActive: true,
-    },
-    {
-      containerTypeId: forty.id,
-      tradeDirection: "IMPORT",
-      maxVgmTons: 28,
-      effectiveFrom: base,
-      isActive: true,
-    },
-    {
-      containerTypeId: forty.id,
-      tradeDirection: "EXPORT",
-      maxVgmTons: 28,
-      effectiveFrom: base,
-      isActive: true,
-    },
+    { containerTypeId: twenty.id, tradeDirection: "IMPORT", maxVgmTons: 26 },
+    { containerTypeId: twenty.id, tradeDirection: "EXPORT", maxVgmTons: 26 },
+    { containerTypeId: forty.id, tradeDirection: "IMPORT", maxVgmTons: 28 },
+    { containerTypeId: forty.id, tradeDirection: "EXPORT", maxVgmTons: 28 },
   ];
 
   for (const rule of rules) {
@@ -361,10 +335,7 @@ private async seedWeightLimits(wlRepo: any, ctRepo: any): Promise<void> {
     });
 
     if (existing) {
-      await wlRepo.update(existing.id, {
-        maxVgmTons: rule.maxVgmTons,
-        effectiveFrom: rule.effectiveFrom,
-      });
+      await wlRepo.update(existing.id, { maxVgmTons: rule.maxVgmTons });
     } else {
       await wlRepo.insert(rule);
     }
@@ -409,7 +380,6 @@ private async seedWeightLimits(wlRepo: any, ctRepo: any): Promise<void> {
     ctByCode: Map<string, any>,
     cargoByCode: Map<string, any>,
   ): Promise<Rate[]> {
-    const effectiveFrom = new Date("2026-01-01");
     const now = new Date();
 
     // Each rate is self-describing: `appliesTo` + `trigger` decide how the
@@ -445,6 +415,9 @@ private async seedWeightLimits(wlRepo: any, ctRepo: any): Promise<void> {
       { appliesTo: "OTHER", trigger: "REEFER", rateType: "REEFER_SURCHARGE", rateValue: 2, rateUnit: "PER_TON" },
       { appliesTo: "OTHER", trigger: "SHIPPING_LINE", rateType: "DOUBLE_HANDLING", rateValue: 100, rateUnit: "PER_CONTAINER" },
       { appliesTo: "OTHER", trigger: "CONSOLIDATION", rateType: "LASHING", rateValue: 50, rateUnit: "PER_CONTAINER" },
+      // ── First/last-mile road haulage (per km) — drives the mile invoices ──
+      { appliesTo: "OTHER", trigger: "ALWAYS", rateType: "FIRST_MILE", rateValue: 20, rateUnit: "PER_KM" },
+      { appliesTo: "OTHER", trigger: "ALWAYS", rateType: "LAST_MILE", rateValue: 25, rateUnit: "PER_KM" },
     ];
 
     // Idempotent: insert each canonical rate only if no row with the same
@@ -479,7 +452,6 @@ private async seedWeightLimits(wlRepo: any, ctRepo: any): Promise<void> {
         proposedByStaffId: STAFF_USER_ID,
         approvedByCeoId: CEO_USER_ID,
         approvedAt: now,
-        effectiveFrom,
       }))
       .filter((d) => !existingBySignature.has(signature(d)));
 
diff --git a/apps/edr-freight-web/backoffice/public/assets/edr_image.jpg b/apps/edr-freight-web/backoffice/public/assets/edr_image.jpg
new file mode 100644
index 000000000..b89941eea
Binary files /dev/null and b/apps/edr-freight-web/backoffice/public/assets/edr_image.jpg differ
diff --git a/apps/edr-freight-web/backoffice/public/assets/edr_image.png b/apps/edr-freight-web/backoffice/public/assets/edr_image.png
new file mode 100644
index 000000000..1654c747c
Binary files /dev/null and b/apps/edr-freight-web/backoffice/public/assets/edr_image.png differ
diff --git a/apps/edr-freight-web/backoffice/src/App.tsx b/apps/edr-freight-web/backoffice/src/App.tsx
index 53d636145..f7b26af00 100644
--- a/apps/edr-freight-web/backoffice/src/App.tsx
+++ b/apps/edr-freight-web/backoffice/src/App.tsx
@@ -23,6 +23,7 @@ import {
   Users,
   Wallet,
 } from "lucide-react";
+import { useEffect } from "react";
 import {
   Navigate,
   Outlet,
@@ -52,8 +53,9 @@ import ContractClearanceListPage from "./pages/contracts/ContractClearanceListPa
 import ContractClearanceDetailPage from "./pages/contracts/ContractClearanceDetailPage";
 import GlDjiboutiClearanceListPage from "./pages/contracts/GlDjiboutiClearanceListPage";
 import GlClearanceDetailPage from "./pages/contracts/GlClearanceDetailPage";
-import ShipmentRequestsPage from "./pages/contracts/ShipmentRequestsPage";
-import ShipmentRequestDetailPage from "./pages/contracts/ShipmentRequestDetailPage";
+// Hidden for now — Shipment Requests pages disabled (imports kept commented).
+// import ShipmentRequestsPage from "./pages/contracts/ShipmentRequestsPage";
+// import ShipmentRequestDetailPage from "./pages/contracts/ShipmentRequestDetailPage";
 import GlCreateBookingForm from "./components/contracts/GlCreateBookingForm";
 import DocumentClearanceDetailPage from "./pages/bookings/DocumentClearanceDetailPage";
 import CustomerDetailPage from "./pages/customers/CustomerDetailPage";
@@ -83,6 +85,8 @@ import UsersPage from "./pages/dashboard/user-management/UsersPage";
 import FileUploadSettingsPage from "./pages/documents/FileUploadSettingsPage";
 import DropdownSettingsPage from "./pages/dropdown_settings/DropdownSettingsPage";
 import FleetResourcePage from "./pages/fleet/FleetResourcePage";
+import VehicleDetailPage from "./pages/fleet/VehicleDetailPage";
+import DriverDetailPage from "./pages/fleet/DriverDetailPage";
 import RoutesPage from "./pages/fleet/RoutesPage";
 import FuelPurchasePage from "./pages/fleet/FuelPurchasePage";
 import FuelStatsPage from "./pages/fleet/FuelStatsPage";
@@ -120,6 +124,7 @@ import WarehouseInvoicesPage from "./pages/warehouses/WarehouseInvoicesPage";
 import WarehouseListPage from "./pages/warehouses/WarehouseListPage";
 import WarehouseRulesPage from "./pages/warehouses/WarehouseRulesPage";
 import { HealthCheck } from "./features/health/HealthCheck";
+import FaydaCallbackPage from "./pages/FaydaCallbackPage";
 
 const buildSidebarSections = (demoItems: SidebarItem[]): SidebarSection[] => [
   {
@@ -131,17 +136,17 @@ const buildSidebarSections = (demoItems: SidebarItem[]): SidebarSection[] => [
         icon: <LayoutDashboard />,
       },
       {
-        label: "User Management",
+        label: "Staff",
         href: "/um",
         icon: <Users />,
       },
       {
-        label: "Booking requests",
+        label: "Bookings",
         href: "/dashboard/booking-requests",
         icon: <FileText />,
       },
       {
-        label: "Contract requests",
+        label: "Contracts",
         href: "/dashboard/contract-requests",
         icon: <FileSignature />,
         permission: FREIGHT_PERMS.contracts.view,
@@ -170,7 +175,7 @@ const buildSidebarSections = (demoItems: SidebarItem[]): SidebarSection[] => [
     title: "Operations",
     items: [
       {
-        label: "Document Clearance",
+        label: "Clearance",
         href: "/dashboard/contracts/clearance",
         icon: <ShieldCheck />,
         permission: [
@@ -178,6 +183,7 @@ const buildSidebarSections = (demoItems: SidebarItem[]): SidebarSection[] => [
           FREIGHT_PERMS.contracts.clearanceEtActions,
         ],
       },
+      // Hidden for now — Shipment Requests nav item disabled.
       // {
       //   label: "Shipment Requests",
       //   href: "/dashboard/shipment-requests",
@@ -307,7 +313,7 @@ const buildSidebarSections = (demoItems: SidebarItem[]): SidebarSection[] => [
     title: "Port & Terminal",
     items: [
       {
-        label: "Import Operations",
+        label: "Imports",
         href: "/dashboard/import-warehouse",
         icon: <PackageOpen />,
         children: [
@@ -328,7 +334,7 @@ const buildSidebarSections = (demoItems: SidebarItem[]): SidebarSection[] => [
           },
           {
             label: "Terminal Inventory",
-            href: "/dashboard/warehouse-inventory",
+            href: "/dashboard/warehouse-inventory?direction=IMPORT",
             icon: <Package />,
           },
           {
@@ -339,7 +345,7 @@ const buildSidebarSections = (demoItems: SidebarItem[]): SidebarSection[] => [
         ],
       },
       {
-        label: "Export Operations",
+        label: "Exports",
         href: "/dashboard/export-warehouse",
         icon: <Truck />,
         children: [
@@ -375,7 +381,7 @@ const buildSidebarSections = (demoItems: SidebarItem[]): SidebarSection[] => [
           },
           {
             label: "Terminal Inventory",
-            href: "/dashboard/warehouse-inventory",
+            href: "/dashboard/warehouse-inventory?direction=EXPORT",
             icon: <Package />,
           },
         ],
@@ -511,6 +517,38 @@ const filterSidebarByPermission = (
     .filter((section) => section.items.length > 0);
 };
 
+const APP_TITLE = "EDR Freight Backoffice";
+
+/** Flatten sidebar sections (incl. nested children) into {href, label} pairs. */
+const flattenSidebarItems = (
+  sections: SidebarSection[],
+): { href: string; label: string }[] =>
+  sections.flatMap((section) =>
+    section.items.flatMap((item) => [
+      ...(item.href ? [{ href: item.href, label: item.label }] : []),
+      ...(item.children ?? [])
+        .filter((child): child is SidebarItem & { href: string } =>
+          Boolean(child.href),
+        )
+        .map((child) => ({ href: child.href, label: child.label })),
+    ]),
+  );
+
+/** Find the sidebar label whose href matches (exactly or as a prefix of) the current path. */
+const findActiveSidebarLabel = (
+  pathname: string,
+  sections: SidebarSection[],
+): string | undefined => {
+  const path = pathname.toLowerCase();
+  const candidates = flattenSidebarItems(sections)
+    .map(({ href, label }) => ({ label, href: href.split("?")[0].toLowerCase() }))
+    .sort((a, b) => b.href.length - a.href.length);
+
+  return candidates.find(
+    ({ href }) => path === href || path.startsWith(`${href}/`),
+  )?.label;
+};
+
 const DashboardShell = () => {
   const navigate = useNavigate();
   const location = useLocation();
@@ -536,6 +574,14 @@ const DashboardShell = () => {
         : null
     : null;
 
+  useEffect(() => {
+    const activeLabel = findActiveSidebarLabel(
+      location.pathname,
+      sidebarSections,
+    );
+    document.title = activeLabel ? `${activeLabel} | ${APP_TITLE}` : APP_TITLE;
+  }, [location.pathname, sidebarSections]);
+
   if (glClearanceHome && !location.pathname.startsWith(glClearanceHome)) {
     return <Navigate to={glClearanceHome} replace />;
   }
@@ -567,6 +613,7 @@ const App = () => {
       <Routes>
         <Route path="/auth" element={<LoginPage />} />
         <Route path="/um/*" element={<UserManagementHostPage />} />
+        <Route path="/callback" element={<FaydaCallbackPage />} />
         <Route path="*" element={<Navigate to="/auth" replace />} />
       </Routes>
     );
@@ -576,6 +623,7 @@ const App = () => {
     <Routes>
       <Route path="/um/*" element={<UserManagementHostPage />} />
       <Route path="/health" element={<HealthCheck />} />
+      <Route path="/callback" element={<FaydaCallbackPage />} />
       <Route path="/" element={<Navigate to="/dashboard/overview" replace />} />
       <Route
         path="/dashboard"
@@ -672,6 +720,7 @@ const App = () => {
             </RequirePermission>
           }
         />
+        {/* Hidden for now — Shipment Requests pages disabled.
         <Route
           path="shipment-requests"
           element={
@@ -692,6 +741,7 @@ const App = () => {
             </RequirePermission>
           }
         />
+        */}
         {/* GL (Path B) contract clearance review hub */}
         <Route
           path="contracts/clearance"
@@ -923,6 +973,14 @@ const App = () => {
             </RequirePermission>
           }
         />
+        <Route
+          path="vehicles/:id"
+          element={
+            <RequirePermission permission={FREIGHT_PERMS.fleet.view}>
+              <VehicleDetailPage />
+            </RequirePermission>
+          }
+        />
         <Route
           path="drivers"
           element={
@@ -931,6 +989,14 @@ const App = () => {
             </RequirePermission>
           }
         />
+        <Route
+          path="drivers/:id"
+          element={
+            <RequirePermission permission={FREIGHT_PERMS.fleet.view}>
+              <DriverDetailPage />
+            </RequirePermission>
+          }
+        />
         <Route
           path="operations/train-scheduling"
           element={
diff --git a/apps/edr-freight-web/backoffice/src/auth/types.ts b/apps/edr-freight-web/backoffice/src/auth/types.ts
index 41742039c..6279c8491 100644
--- a/apps/edr-freight-web/backoffice/src/auth/types.ts
+++ b/apps/edr-freight-web/backoffice/src/auth/types.ts
@@ -21,6 +21,8 @@ interface AuthEmployeePosition {
   isDelegate?: boolean;
   parentPositionId?: string | null;
   permissions?: AuthPermission[];
+  /** Some IAM payloads nest the position record instead of flattening its key. */
+  position?: { id?: string; key?: string; name?: LocaleText };
 }
 
 interface AuthEmployeeRecord {
diff --git a/apps/edr-freight-web/backoffice/src/components/ContainerAllocationTable.tsx b/apps/edr-freight-web/backoffice/src/components/ContainerAllocationTable.tsx
index 8971d4ccb..67407486f 100644
--- a/apps/edr-freight-web/backoffice/src/components/ContainerAllocationTable.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/ContainerAllocationTable.tsx
@@ -33,7 +33,6 @@ export interface ContainerAllocationTableProps {
  * Displays containers with type/qty, vehicle dropdown per row, and save action.
  */
 export function ContainerAllocationTable({
-  bookingId,
   containers,
   onSave,
 }: ContainerAllocationTableProps) {
@@ -43,7 +42,10 @@ export function ContainerAllocationTable({
 
   const { data: vehicles = [], isLoading: vehiclesLoading } = useQuery({
     queryKey: ["vehicles", "free"],
-    queryFn: () => vehiclesService.getAll({ status: "ACTIVE", availability: "FREE" }),
+    queryFn: async () => {
+      const res = await vehiclesService.getAll({ status: "ACTIVE", availability: "FREE" });
+      return res.data ?? [];
+    },
   });
 
   const vehicleOptions = useMemo(
@@ -85,13 +87,12 @@ export function ContainerAllocationTable({
   });
 
   const allocatedCount = Object.values(allocations).filter(Boolean).length;
-  const allAllocated = allocatedCount === containers.length;
 
   if (vehiclesLoading) {
     return (
-      <Box display="flex" justifyContent="center" p="xl">
+      <Group justify="center" p="xl">
         <Loader size="sm" />
-      </Box>
+      </Group>
     );
   }
 
diff --git a/apps/edr-freight-web/backoffice/src/components/FirstMileContainerAllocationTable.tsx b/apps/edr-freight-web/backoffice/src/components/FirstMileContainerAllocationTable.tsx
deleted file mode 100644
index 78c5160ca..000000000
--- a/apps/edr-freight-web/backoffice/src/components/FirstMileContainerAllocationTable.tsx
+++ /dev/null
@@ -1,164 +0,0 @@
-import { useState, useMemo } from "react";
-import { useMutation, useQuery } from "@tanstack/react-query";
-import {
-  Box,
-  Button,
-  Group,
-  Loader,
-  Select,
-  Stack,
-  Table,
-  Text,
-  Alert,
-} from "@mantine/core";
-import { AlertCircle } from "lucide-react";
-import toast from "react-hot-toast";
-
-import { vehiclesService } from "@/services/vehicles.service";
-
-export interface ContainerAllocationRow {
-  id: string;
-  type: string;
-  qty: number;
-}
-
-export interface FirstMileContainerAllocationTableProps {
-  firstMileId: string;
-  containers: ContainerAllocationRow[];
-  onSave: (allocations: Array<{ containerId: string; vehicleId: string }>) => Promise<void>;
-}
-
-/**
- * Manual container-to-vehicle allocation table for first-mile pickups.
- * Displays containers with type/qty, vehicle dropdown per row, and save action.
- */
-export function FirstMileContainerAllocationTable({
-  firstMileId,
-  containers,
-  onSave,
-}: FirstMileContainerAllocationTableProps) {
-  const [allocations, setAllocations] = useState<Record<string, string | null>>(
-    () => containers.reduce((acc, c) => ({ ...acc, [c.id]: null }), {}),
-  );
-
-  const { data: vehicles = [], isLoading: vehiclesLoading } = useQuery({
-    queryKey: ["vehicles", "free"],
-    queryFn: () => vehiclesService.getAll({ status: "ACTIVE", availability: "FREE" }),
-  });
-
-  const vehicleOptions = useMemo(
-    () =>
-      vehicles.map((v) => ({
-        value: v.id,
-        label: `${v.plateNumber} (${v.vehicleType})`,
-        description: `${v.model} · ${v.manufacturer}`,
-      })),
-    [vehicles],
-  );
-
-  const saveAllocation = useMutation({
-    mutationFn: async () => {
-      const mappings = containers
-        .filter((c) => allocations[c.id])
-        .map((c) => ({
-          containerId: c.id,
-          vehicleId: allocations[c.id]!,
-        }));
-
-      if (mappings.length === 0) {
-        throw new Error("No containers allocated to vehicles");
-      }
-
-      await onSave(mappings);
-    },
-    onSuccess: () => {
-      toast.success("Container allocations saved");
-      setAllocations(
-        containers.reduce((acc, c) => ({ ...acc, [c.id]: null }), {}),
-      );
-    },
-    onError: (error) => {
-      toast.error(
-        error instanceof Error ? error.message : "Failed to save allocations",
-      );
-    },
-  });
-
-  const allocatedCount = Object.values(allocations).filter(Boolean).length;
-  const allAllocated = allocatedCount === containers.length;
-
-  if (vehiclesLoading) {
-    return (
-      <Box display="flex" justifyContent="center" p="xl">
-        <Loader size="sm" />
-      </Box>
-    );
-  }
-
-  return (
-    <Stack gap="md">
-      {vehicles.length === 0 && (
-        <Alert icon={<AlertCircle size={16} />} color="yellow">
-          No free vehicles available. Free up or add vehicles before allocating containers.
-        </Alert>
-      )}
-
-      <Box style={{ overflowX: "auto" }}>
-        <Table verticalSpacing="md" horizontalSpacing="md" highlightOnHover>
-          <Table.Thead>
-            <Table.Tr>
-              <Table.Th>Container ID</Table.Th>
-              <Table.Th>Type</Table.Th>
-              <Table.Th>Qty</Table.Th>
-              <Table.Th>Assigned Vehicle</Table.Th>
-            </Table.Tr>
-          </Table.Thead>
-          <Table.Tbody>
-            {containers.map((container) => (
-              <Table.Tr key={container.id}>
-                <Table.Td>
-                  <Text fw={600} size="sm">
-                    {container.id}
-                  </Text>
-                </Table.Td>
-                <Table.Td>{container.type}</Table.Td>
-                <Table.Td>{container.qty}</Table.Td>
-                <Table.Td>
-                  <Select
-                    placeholder="Select vehicle"
-                    data={vehicleOptions}
-                    value={allocations[container.id] ?? null}
-                    onChange={(value) =>
-                      setAllocations((prev) => ({
-                        ...prev,
-                        [container.id]: value,
-                      }))
-                    }
-                    searchable
-                    clearable
-                    disabled={vehicles.length === 0}
-                    style={{ minWidth: 200 }}
-                  />
-                </Table.Td>
-              </Table.Tr>
-            ))}
-          </Table.Tbody>
-        </Table>
-      </Box>
-
-      <Group justify="space-between">
-        <Text size="sm" c="dimmed">
-          {allocatedCount} of {containers.length} containers allocated
-        </Text>
-        <Button
-          color="edr-green"
-          loading={saveAllocation.isPending}
-          disabled={allocatedCount === 0 || vehicles.length === 0}
-          onClick={() => saveAllocation.mutate()}
-        >
-          Save Allocations
-        </Button>
-      </Group>
-    </Stack>
-  );
-}
diff --git a/apps/edr-freight-web/backoffice/src/components/LastMileContainerAllocationTable.tsx b/apps/edr-freight-web/backoffice/src/components/LastMileContainerAllocationTable.tsx
deleted file mode 100644
index cc619cb9a..000000000
--- a/apps/edr-freight-web/backoffice/src/components/LastMileContainerAllocationTable.tsx
+++ /dev/null
@@ -1,164 +0,0 @@
-import { useState, useMemo } from "react";
-import { useMutation, useQuery } from "@tanstack/react-query";
-import {
-  Box,
-  Button,
-  Group,
-  Loader,
-  Select,
-  Stack,
-  Table,
-  Text,
-  Alert,
-} from "@mantine/core";
-import { AlertCircle } from "lucide-react";
-import toast from "react-hot-toast";
-
-import { vehiclesService } from "@/services/vehicles.service";
-
-export interface LastMileContainerRow {
-  id: string;
-  type: string;
-  qty: number;
-}
-
-export interface LastMileContainerAllocationTableProps {
-  lastMileId: string;
-  containers: LastMileContainerRow[];
-  onSave: (allocations: Array<{ containerId: string; vehicleId: string }>) => Promise<void>;
-}
-
-/**
- * Manual container-to-vehicle allocation table for last-mile deliveries.
- * Displays containers with type/qty, vehicle dropdown per row, and save action.
- */
-export function LastMileContainerAllocationTable({
-  lastMileId,
-  containers,
-  onSave,
-}: LastMileContainerAllocationTableProps) {
-  const [allocations, setAllocations] = useState<Record<string, string | null>>(
-    () => containers.reduce((acc, c) => ({ ...acc, [c.id]: null }), {}),
-  );
-
-  const { data: vehicles = [], isLoading: vehiclesLoading } = useQuery({
-    queryKey: ["vehicles", "free"],
-    queryFn: () => vehiclesService.getAll({ status: "ACTIVE", availability: "FREE" }),
-  });
-
-  const vehicleOptions = useMemo(
-    () =>
-      vehicles.map((v) => ({
-        value: v.id,
-        label: `${v.plateNumber} (${v.vehicleType})`,
-        description: `${v.model} · ${v.manufacturer}`,
-      })),
-    [vehicles],
-  );
-
-  const saveAllocation = useMutation({
-    mutationFn: async () => {
-      const mappings = containers
-        .filter((c) => allocations[c.id])
-        .map((c) => ({
-          containerId: c.id,
-          vehicleId: allocations[c.id]!,
-        }));
-
-      if (mappings.length === 0) {
-        throw new Error("No containers allocated to vehicles");
-      }
-
-      await onSave(mappings);
-    },
-    onSuccess: () => {
-      toast.success("Container allocations saved");
-      setAllocations(
-        containers.reduce((acc, c) => ({ ...acc, [c.id]: null }), {}),
-      );
-    },
-    onError: (error) => {
-      toast.error(
-        error instanceof Error ? error.message : "Failed to save allocations",
-      );
-    },
-  });
-
-  const allocatedCount = Object.values(allocations).filter(Boolean).length;
-  const allAllocated = allocatedCount === containers.length;
-
-  if (vehiclesLoading) {
-    return (
-      <Box display="flex" justifyContent="center" p="xl">
-        <Loader size="sm" />
-      </Box>
-    );
-  }
-
-  return (
-    <Stack gap="md">
-      {vehicles.length === 0 && (
-        <Alert icon={<AlertCircle size={16} />} color="yellow">
-          No free vehicles available. Free up or add vehicles before allocating containers.
-        </Alert>
-      )}
-
-      <Box style={{ overflowX: "auto" }}>
-        <Table verticalSpacing="md" horizontalSpacing="md" highlightOnHover>
-          <Table.Thead>
-            <Table.Tr>
-              <Table.Th>Container ID</Table.Th>
-              <Table.Th>Type</Table.Th>
-              <Table.Th>Qty</Table.Th>
-              <Table.Th>Assigned Vehicle</Table.Th>
-            </Table.Tr>
-          </Table.Thead>
-          <Table.Tbody>
-            {containers.map((container) => (
-              <Table.Tr key={container.id}>
-                <Table.Td>
-                  <Text fw={600} size="sm">
-                    {container.id}
-                  </Text>
-                </Table.Td>
-                <Table.Td>{container.type}</Table.Td>
-                <Table.Td>{container.qty}</Table.Td>
-                <Table.Td>
-                  <Select
-                    placeholder="Select vehicle"
-                    data={vehicleOptions}
-                    value={allocations[container.id] ?? null}
-                    onChange={(value) =>
-                      setAllocations((prev) => ({
-                        ...prev,
-                        [container.id]: value,
-                      }))
-                    }
-                    searchable
-                    clearable
-                    disabled={vehicles.length === 0}
-                    style={{ minWidth: 200 }}
-                  />
-                </Table.Td>
-              </Table.Tr>
-            ))}
-          </Table.Tbody>
-        </Table>
-      </Box>
-
-      <Group justify="space-between">
-        <Text size="sm" c="dimmed">
-          {allocatedCount} of {containers.length} containers allocated
-        </Text>
-        <Button
-          color="edr-green"
-          loading={saveAllocation.isPending}
-          disabled={allocatedCount === 0 || vehicles.length === 0}
-          onClick={() => saveAllocation.mutate()}
-        >
-          Save Allocations
-        </Button>
-      </Group>
-    </Stack>
-  );
-}
diff --git a/apps/edr-freight-web/backoffice/src/components/auth/AuthShell.tsx b/apps/edr-freight-web/backoffice/src/components/auth/AuthShell.tsx
new file mode 100644
index 000000000..c4fd7f39e
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/components/auth/AuthShell.tsx
@@ -0,0 +1,148 @@
+import type { ReactNode } from "react";
+import { Box, Image, Stack, Text, Title } from "@mantine/core";
+import { ChevronDown, Globe } from "lucide-react";
+
+const EDR_IMAGE = "/assets/edr_image.png";
+const EDR_LOGO = "/assets/logo.svg";
+
+/** Muted deep-green brand wash for the left panel. */
+const LEFT_PANEL_BG =
+  "linear-gradient(158deg, #2E6B55 0%, #21503F 46%, #16352A 100%)";
+
+/** Radial opacity mask: image fully opaque at its center, fading to nothing at the edges. */
+const IMAGE_FADE_MASK =
+  "linear-gradient(-90deg, #000 95%, #0009 97%, #0000 100%), linear-gradient(0deg, #000 80%, #0001 100%)";
+
+export interface AuthShellProps {
+  children: ReactNode;
+  /** Headline shown in the top-left of the green panel. */
+  tagline?: string;
+  taglineBody?: string;
+}
+
+const LeftPanel = ({
+  tagline,
+  taglineBody,
+}: Pick<AuthShellProps, "tagline" | "taglineBody">) => (
+  <Box
+    className="relative hidden shrink-0 overflow-hidden rounded-2xl shadow-[0_8px_32px_rgba(15,23,42,0.12)] lg:flex lg:h-auto lg:min-h-0 lg:flex-1 lg:basis-1/2 lg:rounded-[28px]"
+    style={{ background: LEFT_PANEL_BG }}
+  >
+    {/* Top-left: logo, title, description — stacked, left aligned. */}
+    <Stack
+      gap="xl"
+      className="relative z-10 p-8 lg:p-10"
+      style={{ maxWidth: 520 }}
+    >
+      <Image
+        src={EDR_LOGO}
+        alt="EDR Freight"
+        h={40}
+        w="auto"
+        fit="contain"
+        style={{ filter: "brightness(0) invert(1)", alignSelf: "flex-start" }}
+      />
+
+      <Stack gap="sm">
+        <Title
+          order={1}
+          c="white"
+          fz={38}
+          fw={800}
+          lh={1.08}
+          style={{ letterSpacing: "-0.02em" }}
+        >
+          {tagline ?? "Ethiopian Djibouti Railway"}
+        </Title>
+        <Text fz="md" lh={1.6} c="rgba(255,255,255,0.82)" maw={440}>
+          {taglineBody ??
+            "Manage bookings, track cargo, and run day-to-day logistics for the Ethio–Djibouti Railway from a single backoffice."}
+        </Text>
+      </Stack>
+    </Stack>
+
+    {/* Bottom-right: brand image with a center-to-edge opacity fade, no color tint. */}
+    <Image
+      src={EDR_IMAGE}
+      alt=""
+      aria-hidden
+      fit="cover"
+      pos="absolute"
+      right={0}
+      bottom={0}
+      w="80%"
+      h="60%"
+      style={{
+        WebkitMaskImage: IMAGE_FADE_MASK,
+        maskImage: IMAGE_FADE_MASK,
+        pointerEvents: "none",
+        opacity: 0.9,
+        maskComposite: "intersect",
+      }}
+    />
+  </Box>
+);
+
+const RightPanelDecor = () => (
+  <div
+    className="pointer-events-none absolute inset-0 overflow-hidden"
+    aria-hidden
+  >
+    <div className="absolute -right-16 -top-20 h-56 w-56 rounded-full bg-primary/[0.06] blur-3xl" />
+    <div className="absolute -bottom-12 left-1/4 h-40 w-40 rounded-full bg-primary/[0.04] blur-2xl" />
+    <svg
+      className="absolute inset-0 h-full w-full text-gray-200/40"
+      xmlns="http://www.w3.org/2000/svg"
+    >
+      <defs>
+        <pattern
+          id="auth-grid"
+          width="28"
+          height="28"
+          patternUnits="userSpaceOnUse"
+        >
+          <circle cx="1" cy="1" r="0.75" fill="currentColor" />
+        </pattern>
+      </defs>
+      <rect width="100%" height="100%" fill="url(#auth-grid)" />
+    </svg>
+  </div>
+);
+
+const LanguageSelector = () => (
+  <div className="flex cursor-pointer items-center gap-1.5 rounded-full border border-gray-200/80 bg-white px-3 py-1.5 text-sm text-gray-600 shadow-sm">
+    <Globe className="h-4 w-4 text-gray-500" />
+    <span>Eng</span>
+    <ChevronDown className="h-4 w-4 text-gray-400" />
+  </div>
+);
+
+export default function AuthShell({
+  children,
+  tagline,
+  taglineBody,
+}: AuthShellProps) {
+  return (
+    <div className="flex h-[100dvh] overflow-hidden bg-[#e8eaef] px-4 py-3 antialiased sm:px-6 sm:py-4 md:px-[70px]">
+      <div className="flex h-full min-h-0 w-full flex-col gap-3 lg:flex-row lg:gap-4">
+        <LeftPanel tagline={tagline} taglineBody={taglineBody} />
+
+        <div className="relative flex min-h-0 min-w-0 flex-1 flex-col overflow-hidden rounded-2xl bg-white shadow-[0_8px_32px_rgba(15,23,42,0.08)] lg:basis-1/2 lg:rounded-[28px]">
+          <RightPanelDecor />
+
+          <div className="relative z-10 flex shrink-0 justify-end px-4 pt-4 sm:px-6 sm:pt-6 lg:px-8 lg:pt-8">
+            <LanguageSelector />
+          </div>
+
+          <div className="relative z-10 min-h-0 flex-1 overflow-y-auto overscroll-contain">
+            <div className="flex min-h-full justify-center">
+              <div className="my-auto w-full max-w-xl rounded-3xl px-5 py-6 sm:px-7 sm:py-8 lg:px-9 lg:py-9">
+                {children}
+              </div>
+            </div>
+          </div>
+        </div>
+      </div>
+    </div>
+  );
+}
diff --git a/apps/edr-freight-web/backoffice/src/components/bookings/BookingActionsToolbar.tsx b/apps/edr-freight-web/backoffice/src/components/bookings/BookingActionsToolbar.tsx
index e451f2d2c..349d68f32 100644
--- a/apps/edr-freight-web/backoffice/src/components/bookings/BookingActionsToolbar.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/bookings/BookingActionsToolbar.tsx
@@ -1,5 +1,5 @@
-import { Download, Zap, FileText, Clock } from "lucide-react";
-import { Stack, Text, Button } from "@mantine/core";
+import { Zap, Clock } from "lucide-react";
+import { Stack, Text } from "@mantine/core";
 
 import type { BookingDetail } from "@/types/booking";
 import { BookingActionsMenu } from "./BookingActionsMenu";
@@ -14,21 +14,11 @@ interface BookingActionsToolbarProps {
   mutations: Mutations;
 }
 
-/** Detail-page actions: primary toolbar + downloads. */
-export function BookingActionsToolbar({ booking, mutations }: BookingActionsToolbarProps) {
+/** Detail-page actions: primary staff-action toolbar. */
+export function BookingActionsToolbar({ booking }: BookingActionsToolbarProps) {
   const row = toBookingListRow(booking);
   const { status } = booking;
 
-  const downloadBlob = async (fn: () => Promise<Blob>, filename: string) => {
-    const blob = await fn();
-    const url = URL.createObjectURL(blob);
-    const a = document.createElement("a");
-    a.href = url;
-    a.download = filename;
-    a.click();
-    URL.revokeObjectURL(url);
-  };
-
   if (status === "REJECTED" || status === "CANCELLED" || status === "COMPLETED") {
     return null;
   }
@@ -101,23 +91,6 @@ export function BookingActionsToolbar({ booking, mutations }: BookingActionsTool
           <BookingActionsMenu row={row} variant="toolbar" />
         </Stack>
       </SectionCard>
-
-      {status === "CONTRACT_READY" && (
-        <SectionCard icon={FileText} title="Documents">
-          <Button
-            variant="default"
-            leftSection={<Download size={16} />}
-            onClick={() =>
-              downloadBlob(
-                () => mutations.downloadContract(),
-                `contract-${booking.reference}.txt`,
-              )
-            }
-          >
-            Download contract
-          </Button>
-        </SectionCard>
-      )}
     </Stack>
   );
 }
diff --git a/apps/edr-freight-web/backoffice/src/components/bookings/detail/BookingContainerUnitsCard.tsx b/apps/edr-freight-web/backoffice/src/components/bookings/detail/BookingContainerUnitsCard.tsx
new file mode 100644
index 000000000..cd925c03c
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/components/bookings/detail/BookingContainerUnitsCard.tsx
@@ -0,0 +1,202 @@
+import { useMemo } from "react";
+import { Boxes, Container as ContainerIcon, Snowflake, Flame } from "lucide-react";
+import { Badge, Box, Group, Stack, Table, Text, ThemeIcon } from "@mantine/core";
+
+import type { BookingDetail } from "@/types/booking";
+import { SectionCard } from "./SectionCard";
+
+export interface BookingContainerUnitsCardProps {
+  booking: BookingDetail;
+}
+
+interface FlatUnit {
+  id: string;
+  containerNumber: string;
+  sealNumber?: string | null;
+  vgmTons: number;
+  isHazardous?: boolean;
+  isReefer?: boolean;
+  typeLabel: string;
+  sizeFt?: number;
+}
+
+/**
+ * The physical container manifest: one row per container with its number, type,
+ * seal, and weight (VGM). Per-unit numbers are only captured for contract-drawdown
+ * bookings — when a line has no units the card falls back to the aggregate
+ * type/qty/weight so it still renders something for plain bookings.
+ */
+export function BookingContainerUnitsCard({ booking }: BookingContainerUnitsCardProps) {
+  const lines = booking.bookingContainers ?? [];
+
+  const units: FlatUnit[] = useMemo(
+    () =>
+      lines.flatMap((line) =>
+        (line.units ?? []).map((u) => ({
+          id: u.id,
+          containerNumber: u.containerNumber,
+          sealNumber: u.sealNumber,
+          vgmTons: Number(u.vgmTons) || 0,
+          isHazardous: u.isHazardous,
+          isReefer: u.isReefer,
+          typeLabel: line.containerType?.label ?? line.containerType?.code ?? "—",
+          sizeFt: line.containerType?.sizeFt,
+        })),
+      ),
+    [lines],
+  );
+
+  // Container bookings only — bulk has no container manifest.
+  if (booking.freightType === "BULK" || lines.length === 0) return null;
+
+  const totalUnits = units.length;
+  const totalVgm = units.reduce((sum, u) => sum + u.vgmTons, 0);
+
+  return (
+    <SectionCard
+      icon={Boxes}
+      title="Containers"
+      subtitle={
+        totalUnits > 0
+          ? "Each physical container with its number and weight"
+          : "Per-container numbers were not captured for this booking"
+      }
+      accent="teal"
+      extra={
+        totalUnits > 0 ? (
+          <Badge color="teal" variant="light" radius="sm">
+            {totalUnits} container{totalUnits === 1 ? "" : "s"}
+          </Badge>
+        ) : (
+          <Badge color="gray" variant="light" radius="sm">
+            {lines.length} line{lines.length === 1 ? "" : "s"}
+          </Badge>
+        )
+      }
+    >
+      {totalUnits > 0 ? (
+        <Stack gap="md">
+          <Box style={{ overflowX: "auto" }}>
+            <Table verticalSpacing="sm" horizontalSpacing="md" highlightOnHover>
+              <Table.Thead>
+                <Table.Tr>
+                  <Table.Th style={{ width: 40 }}>#</Table.Th>
+                  <Table.Th>Container No.</Table.Th>
+                  <Table.Th>Type</Table.Th>
+                  <Table.Th>Seal</Table.Th>
+                  <Table.Th ta="right">Weight (VGM)</Table.Th>
+                </Table.Tr>
+              </Table.Thead>
+              <Table.Tbody>
+                {units.map((u, i) => (
+                  <Table.Tr key={u.id}>
+                    <Table.Td>
+                      <Text size="sm" c="dimmed">
+                        {i + 1}
+                      </Text>
+                    </Table.Td>
+                    <Table.Td>
+                      <Group gap={8} wrap="nowrap" align="center">
+                        <ThemeIcon size={26} radius="md" variant="light" color="teal">
+                          <ContainerIcon size={15} />
+                        </ThemeIcon>
+                        <Text size="sm" fw={700} ff="monospace">
+                          {u.containerNumber}
+                        </Text>
+                        {u.isReefer ? (
+                          <ThemeIcon size={20} radius="sm" variant="light" color="blue" title="Reefer">
+                            <Snowflake size={12} />
+                          </ThemeIcon>
+                        ) : null}
+                        {u.isHazardous ? (
+                          <ThemeIcon size={20} radius="sm" variant="light" color="red" title="Hazardous">
+                            <Flame size={12} />
+                          </ThemeIcon>
+                        ) : null}
+                      </Group>
+                    </Table.Td>
+                    <Table.Td>
+                      <Group gap={6} wrap="nowrap">
+                        <Text size="sm">{u.typeLabel}</Text>
+                        {u.sizeFt ? (
+                          <Badge color="gray" variant="light" radius="sm" size="sm">
+                            {u.sizeFt}FT
+                          </Badge>
+                        ) : null}
+                      </Group>
+                    </Table.Td>
+                    <Table.Td>
+                      <Text size="sm" c={u.sealNumber ? undefined : "dimmed"}>
+                        {u.sealNumber || "—"}
+                      </Text>
+                    </Table.Td>
+                    <Table.Td ta="right">
+                      <Text size="sm" fw={700}>
+                        {u.vgmTons.toFixed(3)} t
+                      </Text>
+                    </Table.Td>
+                  </Table.Tr>
+                ))}
+              </Table.Tbody>
+            </Table>
+          </Box>
+
+          <Group
+            justify="space-between"
+            pt="sm"
+            style={{ borderTop: "1px solid var(--mantine-color-gray-2)" }}
+          >
+            <Text size="sm" fw={600} c="dimmed">
+              Total weight (VGM)
+            </Text>
+            <Text size="sm" fw={800} c="teal.7">
+              {totalVgm.toFixed(3)} t
+            </Text>
+          </Group>
+        </Stack>
+      ) : (
+        // Fallback: no per-unit numbers — show the aggregate lines.
+        <Box style={{ overflowX: "auto" }}>
+          <Table verticalSpacing="sm" horizontalSpacing="md" highlightOnHover>
+            <Table.Thead>
+              <Table.Tr>
+                <Table.Th>Type</Table.Th>
+                <Table.Th>Qty</Table.Th>
+                <Table.Th>VGM / unit</Table.Th>
+                <Table.Th ta="right">Total VGM</Table.Th>
+              </Table.Tr>
+            </Table.Thead>
+            <Table.Tbody>
+              {lines.map((line) => {
+                const perUnit = Number(line.vgmPerUnitTons) || 0;
+                return (
+                  <Table.Tr key={line.id}>
+                    <Table.Td>
+                      <Group gap={6} wrap="nowrap">
+                        <Text size="sm" fw={600}>
+                          {line.containerType?.label ?? line.containerType?.code ?? "—"}
+                        </Text>
+                        {line.containerType?.sizeFt ? (
+                          <Badge color="gray" variant="light" radius="sm" size="sm">
+                            {line.containerType.sizeFt}FT
+                          </Badge>
+                        ) : null}
+                      </Group>
+                    </Table.Td>
+                    <Table.Td>{line.quantity}</Table.Td>
+                    <Table.Td>{perUnit.toFixed(3)} t</Table.Td>
+                    <Table.Td ta="right">
+                      <Text size="sm" fw={700}>
+                        {(line.quantity * perUnit).toFixed(3)} t
+                      </Text>
+                    </Table.Td>
+                  </Table.Tr>
+                );
+              })}
+            </Table.Tbody>
+          </Table>
+        </Box>
+      )}
+    </SectionCard>
+  );
+}
diff --git a/apps/edr-freight-web/backoffice/src/components/bookings/detail/index.ts b/apps/edr-freight-web/backoffice/src/components/bookings/detail/index.ts
index a023fafda..003f3d4de 100644
--- a/apps/edr-freight-web/backoffice/src/components/bookings/detail/index.ts
+++ b/apps/edr-freight-web/backoffice/src/components/bookings/detail/index.ts
@@ -8,6 +8,7 @@ export * from "./BookingDetailHeader";
 export * from "./BookingLifecycleStepper";
 export * from "./BookingRouteCard";
 export * from "./BookingContainersCard";
+export * from "./BookingContainerUnitsCard";
 export * from "./BookingApprovalCard";
 export * from "./BookingReviewNotesCard";
 export * from "./BookingPaymentCard";
diff --git a/apps/edr-freight-web/backoffice/src/components/contracts/ExportClearanceStepper.tsx b/apps/edr-freight-web/backoffice/src/components/contracts/ExportClearanceStepper.tsx
index d7cd9207b..b13e38961 100644
--- a/apps/edr-freight-web/backoffice/src/components/contracts/ExportClearanceStepper.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/contracts/ExportClearanceStepper.tsx
@@ -14,7 +14,7 @@ import {
   Text,
   Textarea,
 } from "@mantine/core";
-import { DateInput, DateTimePicker } from "@mantine/dates";
+import { DateInput } from "@mantine/dates";
 import {
   AlertTriangle,
   CheckCircle2,
@@ -397,15 +397,10 @@ export function ExportClearanceStepper({
 
           <Stepper.Step
             label="Gate pass"
-            description="GL Djibouti grants after arrival"
+            description="Secured on the train schedule after arrival"
             icon={clearance.gatepassGranted ? <CheckCircle2 size={14} /> : <Truck size={14} />}
           >
-            <GatepassStep
-              bookingId={actionBookingId}
-              clearance={clearance}
-              canAct={showDj && canDj}
-              onChanged={onChanged}
-            />
+            <GatepassStep clearance={clearance} />
           </Stepper.Step>
 
           <Stepper.Step
@@ -491,27 +486,19 @@ function ConfirmExportReleaseFallback({
   );
 }
 
-function GatepassStep({
-  bookingId,
-  clearance,
-  canAct,
-  onChanged,
-}: {
-  bookingId: string | null;
-  clearance: ClearanceViewLike;
-  canAct: boolean;
-  onChanged?: () => void;
-}) {
-  const [opened, setOpened] = useState(false);
-  const [at, setAt] = useState<Date | null>(new Date());
-  const [loading, setLoading] = useState(false);
+/**
+ * Gate pass status, read-only. Secured on the train schedule's "Save as
+ * Secured" action (train-scheduling-v2) — clearance no longer grants it directly.
+ */
+function GatepassStep({ clearance }: { clearance: ClearanceViewLike }) {
+  const scheduleId = clearance.train?.scheduleId ?? null;
 
   if (clearance.gatepassGranted) {
     return (
       <StepStatus
         done
         pendingLabel=""
-        doneLabel={`Gate pass granted${
+        doneLabel={`Gate pass secured${
           clearance.gatepassAt ? ` · ${new Date(clearance.gatepassAt).toLocaleString()}` : ""
         }`}
       />
@@ -526,68 +513,21 @@ function GatepassStep({
         done={false}
         pendingLabel={
           arrived
-            ? "Train arrived — GL Djibouti can grant the gate pass."
+            ? "Train arrived — secure the gate pass on the train schedule."
             : "Available once the train arrives at Djibouti."
         }
         doneLabel=""
       />
-      {canAct && bookingId ? (
-        <>
-          <Button
-            color="edr-green"
-            leftSection={<Truck size={16} />}
-            disabled={!arrived}
-            onClick={() => {
-              setAt(new Date());
-              setOpened(true);
-            }}
-          >
-            Grant gate pass
-          </Button>
-          <Modal
-            opened={opened}
-            onClose={() => setOpened(false)}
-            title={<Text fw={700}>Grant gate pass</Text>}
-            radius="md"
-            size="sm"
-          >
-            <Stack gap="md">
-              <DateTimePicker
-                label="Gate pass time"
-                value={at}
-                onChange={(v) => setAt(v ? new Date(v) : null)}
-                required
-              />
-              <Group justify="flex-end">
-                <Button variant="default" onClick={() => setOpened(false)} disabled={loading}>
-                  Cancel
-                </Button>
-                <Button
-                  color="edr-green"
-                  loading={loading}
-                  onClick={async () => {
-                    setLoading(true);
-                    try {
-                      await contractsService.grantGatepass(
-                        bookingId,
-                        (at ?? new Date()).toISOString(),
-                      );
-                      toast.success("Gate pass granted");
-                      setOpened(false);
-                      onChanged?.();
-                    } catch (e) {
-                      toast.error(e instanceof Error ? e.message : "Failed");
-                    } finally {
-                      setLoading(false);
-                    }
-                  }}
-                >
-                  Grant
-                </Button>
-              </Group>
-            </Stack>
-          </Modal>
-        </>
+      {scheduleId ? (
+        <Button
+          component="a"
+          href={`/dashboard/operations/train-scheduling-v2/${scheduleId}`}
+          variant="light"
+          color="edr-green"
+          leftSection={<Truck size={16} />}
+        >
+          Secure gate pass on train schedule
+        </Button>
       ) : 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 f9bd7683d..6f52d287f 100644
--- a/apps/edr-freight-web/backoffice/src/components/contracts/GlCreateBookingForm.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/contracts/GlCreateBookingForm.tsx
@@ -4,9 +4,10 @@ import {
   useParams,
   useSearchParams,
 } from "react-router-dom";
-import { useQuery } from "@tanstack/react-query";
+import { useMutation, useQuery } from "@tanstack/react-query";
 import {
   Alert,
+  Badge,
   Box,
   Button,
   Center,
@@ -18,6 +19,7 @@ import {
   Paper,
   Select,
   Stack,
+  Switch,
   Text,
   Textarea,
   TextInput,
@@ -25,6 +27,7 @@ import {
 } from "@mantine/core";
 import {
   AlertCircle,
+  AlertTriangle,
   CalendarDays,
   CheckCircle2,
   ChevronLeft,
@@ -58,16 +61,36 @@ import {
   StepLabel,
 } from "./gl-booking-form/form-ui";
 
+/** All booking-window times are communicated in East Africa Time. */
+const EAT_TZ = "Africa/Addis_Ababa";
+
+function fmtWindowOpensAt(iso: string): string {
+  const date = new Date(iso).toLocaleDateString("en-GB", {
+    weekday: "short",
+    day: "numeric",
+    month: "short",
+    timeZone: EAT_TZ,
+  });
+  const time = new Date(iso).toLocaleTimeString("en-GB", {
+    hour: "2-digit",
+    minute: "2-digit",
+    hour12: false,
+    timeZone: EAT_TZ,
+  });
+  return `${date} · ${time}`;
+}
+
 interface UnitDraft {
   containerNumber: string;
   sealNumber: string;
   vgmTons: number | string;
+  /** Per-unit flags — the line's hazardous/reefer counts are derived from these. */
+  hazardous: boolean;
+  reefer: boolean;
 }
 
 interface ContainerLineDraft {
   containerSize: string;
-  hazardousQuantity: number | string;
-  reeferQuantity: number | string;
   units: UnitDraft[];
 }
 
@@ -80,7 +103,13 @@ interface BulkLineDraft {
 }
 
 function emptyUnit(): UnitDraft {
-  return { containerNumber: "", sealNumber: "", vgmTons: "" };
+  return {
+    containerNumber: "",
+    sealNumber: "",
+    vgmTons: "",
+    hazardous: false,
+    reefer: false,
+  };
 }
 
 function bulkUnitOfMeasure(
@@ -106,6 +135,33 @@ export default function GlCreateBookingForm() {
     enabled: Boolean(requestId),
   });
 
+  // Same window-gating the customer sees: GL may only create a booking while a
+  // booking window is OPEN for one of the contract's routes.
+  const contractId = contract?.id ?? id;
+  const { data: bookingWindows, isLoading: windowsLoading } = useQuery({
+    ...api.trainScheduling.contractBookingWindows.queryOptions({
+      input: { contractId: contractId ?? "" },
+    }),
+    enabled: Boolean(contractId),
+  });
+
+  const windowOpen = useMemo(
+    () => (bookingWindows ?? []).some((w) => w.isOpenNow),
+    [bookingWindows],
+  );
+
+  // Soonest future window across all routes, used for the "next window" notice.
+  const nextWindow = useMemo(() => {
+    const now = Date.now();
+    return (bookingWindows ?? [])
+      .filter((w) => w.windowOpensAt && new Date(w.windowOpensAt).getTime() > now)
+      .sort(
+        (a, b) =>
+          new Date(a.windowOpensAt!).getTime() -
+          new Date(b.windowOpensAt!).getTime(),
+      )[0];
+  }, [bookingWindows]);
+
   const [scheduledDate, setScheduledDate] = useState("");
   const [contractRouteId, setContractRouteId] = useState<string | null>(null);
   const [notes, setNotes] = useState("");
@@ -152,11 +208,13 @@ export default function GlCreateBookingForm() {
       setContainerLines(
         lines.containers.map((c) => ({
           containerSize: c.containerSize,
-          hazardousQuantity: c.hazardousQuantity ?? "0",
-          reeferQuantity: c.reeferQuantity ?? "",
-          units: Array.from({ length: Math.max(1, c.quantity) }, () =>
-            emptyUnit(),
-          ),
+          // The request carries counts; pre-toggle the first N units so GL sees
+          // the customer's declared hazardous/reefer split and can adjust it.
+          units: Array.from({ length: Math.max(1, c.quantity) }, (_, i) => ({
+            ...emptyUnit(),
+            hazardous: i < Number(c.hazardousQuantity ?? 0),
+            reefer: i < Number(c.reeferQuantity ?? 0),
+          })),
         })),
       );
     } else if (lines.bulk) {
@@ -182,8 +240,6 @@ export default function GlCreateBookingForm() {
       setContainerLines(
         containerSizes.map((size) => ({
           containerSize: size,
-          hazardousQuantity: "0",
-          reeferQuantity: "0",
           units: [emptyUnit()],
         })),
       );
@@ -214,8 +270,8 @@ export default function GlCreateBookingForm() {
       containers: containerLines.map((l) => ({
         containerSize: l.containerSize,
         quantity: l.units.length,
-        hazardousQuantity: Number(l.hazardousQuantity || 0),
-        reeferQuantity: Number(l.reeferQuantity || 0),
+        hazardousQuantity: l.units.filter((u) => u.hazardous).length,
+        reeferQuantity: l.units.filter((u) => u.reefer).length,
       })),
       bulkQuantity: bulkLines.reduce(
         (s, l) => s + Number(l.cargoWeightTons || l.itemCount || 0),
@@ -314,12 +370,16 @@ export default function GlCreateBookingForm() {
     );
 
   const canSubmit =
+    windowOpen &&
     Boolean(scheduledDate) &&
     (!needsRouteSelect || Boolean(contractRouteId)) &&
     (isContainer ? containerLines.some((l) => l.units.length > 0) : bulkLines.length > 0);
 
-  const handleSubmit = () => {
-    if (!scheduledDate || !contract) return;
+  /** The create-booking DTO from the current form state — shared by the
+   * authoritative price preview and the actual submit so what GL confirms is
+   * exactly what gets booked. */
+  const buildPayload = (): Freight.CreateBookingUnderContractDto | null => {
+    if (!scheduledDate || !contract) return null;
 
     const payload: Freight.CreateBookingUnderContractDto = {
       scheduledDate,
@@ -333,12 +393,10 @@ export default function GlCreateBookingForm() {
         .map((l) => ({
           containerSize: l.containerSize,
           quantity: l.units.length,
-          ...(l.hazardousQuantity !== ""
-            ? { hazardousQuantity: Number(l.hazardousQuantity) }
-            : {}),
-          ...(l.reeferQuantity !== ""
-            ? { reeferQuantity: Number(l.reeferQuantity) }
-            : {}),
+          // Counts are derived from the per-unit toggles — they can never
+          // exceed the line quantity.
+          hazardousQuantity: l.units.filter((u) => u.hazardous).length,
+          reeferQuantity: l.units.filter((u) => u.reefer).length,
           units: l.units.map((u) => ({
             containerNumber: u.containerNumber,
             ...(u.sealNumber ? { sealNumber: u.sealNumber } : {}),
@@ -361,6 +419,59 @@ export default function GlCreateBookingForm() {
       }));
     }
 
+    return payload;
+  };
+
+  // Authoritative price preview (same pricing pass the booking persists at
+  // create): rail freight + first/last mile + overweight + every surcharge.
+  // Fired when the price modal opens; the modal falls back to the contract
+  // unit-rate estimate while it loads.
+  const validateShipmentMutation = useMutation({
+    mutationFn: (dto: Freight.CreateBookingUnderContractDto) =>
+      contractsService.validateShipment(id ?? "", dto),
+  });
+  const validation = validateShipmentMutation.data ?? null;
+
+  const serverTotal = useMemo(() => {
+    const items = validation?.lineItems;
+    if (!items?.length) return null;
+    return {
+      currency: validation?.currency ?? priceTotal?.currency ?? "ETB",
+      lines: items.map((li) => ({
+        label: li.description,
+        unitPrice: li.unitAmount,
+        unit: li.unit.toLowerCase(),
+        quantity: li.quantity,
+        amount: li.amount,
+      })),
+      total:
+        validation?.totalAmount ?? items.reduce((s, l) => s + l.amount, 0),
+    };
+  }, [validation, priceTotal]);
+
+  const displayTotal = serverTotal ?? priceTotal;
+  const pairingErrors = validation?.pairingErrors ?? [];
+  const capacityErrors = validation?.capacityErrors ?? [];
+  const overweightLines = validation?.overweightLines ?? [];
+
+  const openPriceModal = () => {
+    setPriceOpen(true);
+    const payload = buildPayload();
+    if (payload) {
+      validateShipmentMutation.reset();
+      validateShipmentMutation.mutate(payload);
+    }
+  };
+
+  const handleSubmit = () => {
+    if (!contract || !windowOpen) return;
+    // Never book past unresolved 20ft pairing hard-blocks.
+    if (pairingErrors.length > 0) return;
+    // A line above the container type's max capacity can never book.
+    if (capacityErrors.length > 0) return;
+    const payload = buildPayload();
+    if (!payload) return;
+
     mutations.createBooking.mutate(payload, {
       onSuccess: async (booking) => {
         if (requestId) {
@@ -451,6 +562,33 @@ export default function GlCreateBookingForm() {
         </Alert>
       ) : null}
 
+      {!windowsLoading && !windowOpen ? (
+        <Alert
+          color="orange"
+          variant="light"
+          radius="md"
+          icon={<AlertCircle size={16} />}
+          title="Booking window is closed"
+          mb="lg"
+        >
+          GL can create a booking only while a window is open.{" "}
+          {nextWindow?.windowOpensAt ? (
+            <>
+              Next window: <b>{fmtWindowOpensAt(nextWindow.windowOpensAt)} EAT</b>{" "}
+              for{" "}
+              <b>
+                {nextWindow.origin ?? "Origin"} → {nextWindow.destination ?? "Destination"}
+              </b>
+              .
+            </>
+          ) : (
+            <>No upcoming booking window scheduled.</>
+          )}
+        </Alert>
+      ) : null}
+
+      {windowsLoading || windowOpen ? (
+        <>
       <Stack gap="lg" maw={896} mx="auto">
         <StepCard>
           <StepHeader
@@ -521,7 +659,7 @@ export default function GlCreateBookingForm() {
                     <Text fz={14} fw={700} mb={10}>
                       {line.containerSize} containers
                     </Text>
-                    <Group gap={12} grow mb={12} align="flex-start">
+                    <Group gap={12} mb={12} align="flex-start">
                       <NumberInput
                         label="Quantity *"
                         min={1}
@@ -529,37 +667,24 @@ export default function GlCreateBookingForm() {
                         onChange={(v) => syncUnits(lineIdx, Number(v) || 0)}
                         radius={10}
                         styles={fieldStyles}
+                        w={160}
                       />
                       {contract.isHazardous ? (
-                        <NumberInput
-                          label="Hazardous qty"
-                          min={0}
-                          value={line.hazardousQuantity}
-                          onChange={(v) =>
-                            patchLine(lineIdx, { hazardousQuantity: v })
-                          }
-                          radius={10}
-                          styles={fieldStyles}
-                        />
+                        <Badge variant="light" color="red" radius="sm" mt={30}>
+                          {line.units.filter((u) => u.hazardous).length} hazardous
+                        </Badge>
                       ) : null}
                       {contract.isReefer ? (
-                        <NumberInput
-                          label="Reefer qty"
-                          min={0}
-                          value={line.reeferQuantity}
-                          onChange={(v) =>
-                            patchLine(lineIdx, { reeferQuantity: v })
-                          }
-                          radius={10}
-                          styles={fieldStyles}
-                        />
+                        <Badge variant="light" color="blue" radius="sm" mt={30}>
+                          {line.units.filter((u) => u.reefer).length} refrigerated
+                        </Badge>
                       ) : null}
                     </Group>
 
                     <StepLabel>Per-container details</StepLabel>
                     <Stack gap={10} mt={8}>
                       {line.units.map((unit, unitIdx) => (
-                        <Group key={unitIdx} gap={10} grow align="flex-start">
+                        <Group key={unitIdx} gap={10} align="flex-start" wrap="nowrap">
                           <TextInput
                             label={unitIdx === 0 ? "Container number *" : undefined}
                             placeholder="e.g. MSCU1234567"
@@ -571,6 +696,7 @@ export default function GlCreateBookingForm() {
                             }
                             radius={10}
                             styles={fieldStyles}
+                            style={{ flex: 1 }}
                           />
                           <TextInput
                             label={unitIdx === 0 ? "Seal number" : undefined}
@@ -583,6 +709,7 @@ export default function GlCreateBookingForm() {
                             }
                             radius={10}
                             styles={fieldStyles}
+                            style={{ flex: 1 }}
                           />
                           <NumberInput
                             label={unitIdx === 0 ? "VGM (tons) *" : undefined}
@@ -595,7 +722,52 @@ export default function GlCreateBookingForm() {
                             }
                             radius={10}
                             styles={fieldStyles}
+                            style={{ flex: 1 }}
                           />
+                          {/* Per-unit flags: toggle exactly the containers that are
+                              hazardous / refrigerated; line counts derive from these. */}
+                          {contract.isHazardous ? (
+                            <Stack gap={6} align="center" style={{ flexShrink: 0 }}>
+                              {unitIdx === 0 ? (
+                                <Text fz={12} fw={600} c="#4A5A68">
+                                  Hazardous
+                                </Text>
+                              ) : null}
+                              <Switch
+                                color="red"
+                                size="sm"
+                                mt={unitIdx === 0 ? 0 : 8}
+                                aria-label={`Container ${unitIdx + 1} hazardous`}
+                                checked={unit.hazardous}
+                                onChange={(e) =>
+                                  patchUnit(lineIdx, unitIdx, {
+                                    hazardous: e.currentTarget.checked,
+                                  })
+                                }
+                              />
+                            </Stack>
+                          ) : null}
+                          {contract.isReefer ? (
+                            <Stack gap={6} align="center" style={{ flexShrink: 0 }}>
+                              {unitIdx === 0 ? (
+                                <Text fz={12} fw={600} c="#4A5A68">
+                                  Reefer
+                                </Text>
+                              ) : null}
+                              <Switch
+                                color="blue"
+                                size="sm"
+                                mt={unitIdx === 0 ? 0 : 8}
+                                aria-label={`Container ${unitIdx + 1} refrigerated`}
+                                checked={unit.reefer}
+                                onChange={(e) =>
+                                  patchUnit(lineIdx, unitIdx, {
+                                    reefer: e.currentTarget.checked,
+                                  })
+                                }
+                              />
+                            </Stack>
+                          ) : null}
                         </Group>
                       ))}
                     </Stack>
@@ -745,7 +917,7 @@ export default function GlCreateBookingForm() {
             radius="md"
             leftSection={<Receipt size={16} />}
             disabled={!canSubmit}
-            onClick={() => setPriceOpen(true)}
+            onClick={openPriceModal}
           >
             Review price &amp; book
           </Button>
@@ -776,11 +948,89 @@ export default function GlCreateBookingForm() {
           </Group>
         }
       >
-        {priceTotal ? (
+        {displayTotal ? (
           <Stack gap="md">
+            {validateShipmentMutation.isPending && (
+              <Group gap={8} c="dimmed">
+                <Loader size="xs" color="edr-green" />
+                <Text fz="sm" c="dimmed">
+                  Computing the final price breakdown and checking container
+                  weights…
+                </Text>
+              </Group>
+            )}
+
+            {pairingErrors.length > 0 && (
+              <Alert
+                color="red"
+                variant="light"
+                radius="md"
+                icon={<AlertCircle size={16} />}
+                title="Cannot create booking — 20ft wagon pairing"
+              >
+                <Stack gap={6}>
+                  {pairingErrors.map((msg, i) => (
+                    <Text key={i} fz="sm" c="red.8">
+                      {msg}
+                    </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.
+                  </Text>
+                </Stack>
+              </Alert>
+            )}
+
+            {capacityErrors.length > 0 && (
+              <Alert
+                color="red"
+                variant="light"
+                radius="md"
+                icon={<AlertCircle size={16} />}
+                title="Cannot create booking — over maximum capacity"
+              >
+                <Stack gap={6}>
+                  {capacityErrors.map((msg, i) => (
+                    <Text key={i} fz="sm" c="red.8">
+                      {msg}
+                    </Text>
+                  ))}
+                  <Text fz="xs" c="red.7" mt={2}>
+                    Reduce the cargo weight or split it across more containers
+                    to book this shipment.
+                  </Text>
+                </Stack>
+              </Alert>
+            )}
+
+            {overweightLines.length > 0 && (
+              <Alert
+                color="yellow"
+                variant="light"
+                radius="md"
+                icon={<AlertTriangle size={16} />}
+                title="Overweight containers"
+              >
+                <Stack gap={6}>
+                  {overweightLines.map((line, i) => (
+                    <Text key={i} fz="sm" c="#9A5B00">
+                      {line.containerTypeCode}: {line.totalVgmTons}t exceeds
+                      limit {line.maxAllowedTons}t (+{line.excessTons}t
+                      overweight)
+                    </Text>
+                  ))}
+                  <Text fz="xs" c="#9A5B00" mt={2}>
+                    An overweight surcharge applies (included in the total
+                    below).
+                  </Text>
+                </Stack>
+              </Alert>
+            )}
+
             <Paper withBorder radius={16} p="lg" style={{ borderColor: "#E6ECF2" }}>
               <Stack gap={10}>
-                {priceTotal.lines.map((line, i) => (
+                {displayTotal.lines.map((line, i) => (
                   <Group key={i} justify="space-between" wrap="nowrap" gap="sm">
                     <Box style={{ minWidth: 0 }}>
                       <Text fz="sm" fw={500}>
@@ -788,16 +1038,16 @@ export default function GlCreateBookingForm() {
                       </Text>
                       <Text fz="xs" c="dimmed">
                         {line.quantity.toLocaleString()} ×{" "}
-                        {line.unitPrice.toLocaleString()} {priceTotal.currency} ·{" "}
+                        {line.unitPrice.toLocaleString()} {displayTotal.currency} ·{" "}
                         {formatRateUnit(line.unit)}
                       </Text>
                     </Box>
                     <Text fz="sm" fw={600} style={{ whiteSpace: "nowrap" }}>
-                      {line.amount.toLocaleString()} {priceTotal.currency}
+                      {line.amount.toLocaleString()} {displayTotal.currency}
                     </Text>
                   </Group>
                 ))}
-                {priceTotal.lines.length === 0 && (
+                {displayTotal.lines.length === 0 && (
                   <Text fz="sm" c="dimmed">
                     No priced lines — check the cargo details.
                   </Text>
@@ -815,9 +1065,9 @@ export default function GlCreateBookingForm() {
                   Total
                 </Text>
                 <Text fw={800} fz={28}>
-                  {priceTotal.total.toLocaleString()}{" "}
+                  {displayTotal.total.toLocaleString()}{" "}
                   <Text span fz={16} fw={700} c="dimmed">
-                    {priceTotal.currency}
+                    {displayTotal.currency}
                   </Text>
                 </Text>
               </Group>
@@ -838,6 +1088,11 @@ export default function GlCreateBookingForm() {
                 radius="md"
                 leftSection={<CheckCircle2 size={16} />}
                 loading={mutations.createBooking.isPending}
+                disabled={
+                  validateShipmentMutation.isPending ||
+                  pairingErrors.length > 0 ||
+                  capacityErrors.length > 0
+                }
                 onClick={handleSubmit}
               >
                 Confirm &amp; book
@@ -846,6 +1101,8 @@ export default function GlCreateBookingForm() {
           </Stack>
         ) : null}
       </Modal>
+        </>
+      ) : null}
     </PageContainer>
   );
 }
diff --git a/apps/edr-freight-web/backoffice/src/components/contracts/GlUpcomingWindowsSection.tsx b/apps/edr-freight-web/backoffice/src/components/contracts/GlUpcomingWindowsSection.tsx
new file mode 100644
index 000000000..dc95729c1
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/components/contracts/GlUpcomingWindowsSection.tsx
@@ -0,0 +1,334 @@
+import { useMemo, useState } from "react";
+import {
+  ActionIcon,
+  Badge,
+  Box,
+  Card,
+  Group,
+  SimpleGrid,
+  Skeleton,
+  Stack,
+  Text,
+} from "@mantine/core";
+import { useQuery } from "@tanstack/react-query";
+import {
+  ArrowRight,
+  CalendarClock,
+  ChevronLeft,
+  ChevronRight,
+} from "lucide-react";
+import { CountdownTimer } from "@edr/ui-common";
+
+import { api } from "@/services/api";
+import type { StaffBookingWindow } from "@/types/trainScheduling";
+
+/** All window times are communicated in East Africa Time. */
+const TZ = "Africa/Addis_Ababa";
+/** Cards visible per carousel page. */
+const PER_PAGE = 3;
+
+function fmtDay(iso: string): string {
+  return new Date(iso).toLocaleDateString("en-GB", {
+    weekday: "short",
+    day: "numeric",
+    month: "short",
+    timeZone: TZ,
+  });
+}
+
+function fmtTime(iso: string): string {
+  return new Date(iso).toLocaleTimeString("en-GB", {
+    hour: "2-digit",
+    minute: "2-digit",
+    hour12: false,
+    timeZone: TZ,
+  });
+}
+
+function windowLabel(w: StaffBookingWindow): string {
+  if (w.windowOpensAt && w.windowClosesAt) {
+    return `${fmtDay(w.windowOpensAt)} · ${fmtTime(w.windowOpensAt)} – ${fmtTime(
+      w.windowClosesAt,
+    )} EAT`;
+  }
+  if (w.windowOpensAt) {
+    return `Opens ${fmtDay(w.windowOpensAt)} · ${fmtTime(w.windowOpensAt)} EAT`;
+  }
+  return (w.windowPhase ?? w.bookingWindowStatus).replace(/_/g, " ");
+}
+
+/**
+ * The countdown for whichever phase the window is currently in, mirroring the
+ * customer portal. `expiredText` names the NEXT step so a deadline that lapses
+ * between refetches announces what comes next rather than the bare "Expired".
+ */
+function phaseCountdown(
+  w: StaffBookingWindow,
+): { label: string; deadline: string; expiredText: string } | null {
+  switch (w.windowPhase) {
+    case "PRE_WINDOW":
+      return w.windowOpensAt
+        ? {
+            label: "Opens in",
+            deadline: w.windowOpensAt,
+            expiredText: "Opening now…",
+          }
+        : null;
+    case "OPEN":
+      return w.windowClosesAt
+        ? {
+            label: "Closes in",
+            deadline: w.windowClosesAt,
+            expiredText: "Review starting…",
+          }
+        : null;
+    case "DOC_REVIEW":
+      return w.docReviewEndsAt
+        ? {
+            label: "Doc review ends in",
+            deadline: w.docReviewEndsAt,
+            expiredText: "Payment starting…",
+          }
+        : null;
+    case "PAYMENT":
+      return w.paymentPhaseEndsAt
+        ? {
+            label: "Payment ends in",
+            deadline: w.paymentPhaseEndsAt,
+            expiredText: "Closing…",
+          }
+        : null;
+    default:
+      return null;
+  }
+}
+
+/** Drop windows whose booking window (or the train itself) has already passed. */
+function isPast(w: StaffBookingWindow): boolean {
+  const now = Date.now();
+  const closes = w.windowClosesAt ? new Date(w.windowClosesAt).getTime() : null;
+  const departs = w.departureDate ? new Date(w.departureDate).getTime() : null;
+  // Still live while in a post-close staff phase (doc review / payment).
+  if (w.windowPhase === "DOC_REVIEW" || w.windowPhase === "PAYMENT") return false;
+  if (departs != null && departs <= now) return true;
+  if (closes != null && closes <= now) return true;
+  return false;
+}
+
+function WindowCard({ w }: { w: StaffBookingWindow }) {
+  const cd = phaseCountdown(w);
+  const open = w.isOpenNow;
+  const isImport = w.direction === "IMPORT";
+
+  return (
+    <Box
+      p="md"
+      style={{
+        borderRadius: 14,
+        height: "100%",
+        border: `1px solid ${
+          open
+            ? "var(--mantine-color-edr-green-3)"
+            : "var(--mantine-color-gray-2)"
+        }`,
+        background: open
+          ? "linear-gradient(160deg, var(--mantine-color-edr-green-0) 0%, #ffffff 85%)"
+          : "var(--mantine-color-body)",
+        boxShadow: open ? "0 2px 10px rgba(10,111,77,0.10)" : "none",
+        transition: "border-color 150ms ease, box-shadow 150ms ease",
+      }}
+    >
+      <Stack gap={8} h="100%" justify="space-between">
+        <Box>
+          <Group justify="space-between" wrap="nowrap" gap={8}>
+            {w.direction ? (
+              <Badge
+                variant="light"
+                color={isImport ? "blue" : "teal"}
+                radius="sm"
+                size="sm"
+              >
+                {isImport ? "Import" : "Export"}
+              </Badge>
+            ) : (
+              <span />
+            )}
+            <Badge
+              variant={open ? "filled" : "light"}
+              color={open ? "edr-green" : "gray"}
+              radius="sm"
+              size="sm"
+            >
+              {open
+                ? "Open now"
+                : (w.windowPhase ?? w.bookingWindowStatus).replace(/_/g, " ")}
+            </Badge>
+          </Group>
+
+          <Group gap={6} wrap="nowrap" mt={10}>
+            <Text fz={15} fw={700} truncate>
+              {w.origin ?? "—"}
+            </Text>
+            <ArrowRight size={14} style={{ flexShrink: 0, opacity: 0.5 }} />
+            <Text fz={15} fw={700} truncate>
+              {w.destination ?? "—"}
+            </Text>
+          </Group>
+          {w.trainNumber ? (
+            <Text fz={12} c="dimmed" truncate>
+              Train {w.trainNumber}
+            </Text>
+          ) : null}
+
+          <Group gap={6} wrap="nowrap" mt={8}>
+            <CalendarClock size={13} style={{ flexShrink: 0, opacity: 0.6 }} />
+            <Text fz={12} c="dimmed" truncate>
+              {windowLabel(w)}
+            </Text>
+          </Group>
+          {w.departureDate ? (
+            <Text fz={12} c="dimmed">
+              Departs {fmtDay(w.departureDate)}
+            </Text>
+          ) : null}
+        </Box>
+
+        {cd ? (
+          <Box
+            px={10}
+            py={6}
+            style={{
+              borderRadius: 10,
+              background: open
+                ? "rgba(10,111,77,0.08)"
+                : "var(--mantine-color-gray-0)",
+            }}
+          >
+            <CountdownTimer
+              deadline={cd.deadline}
+              label={cd.label}
+              expiredText={cd.expiredText}
+              size="xs"
+            />
+          </Box>
+        ) : null}
+      </Stack>
+    </Box>
+  );
+}
+
+/**
+ * All announced booking windows (import cycles + export FCFS) across every lane,
+ * shown to GL ET on the clearance queue as a paged carousel — three lanes per
+ * page, arrows to flip. Mirrors the customer's portal "Booking Windows" card.
+ * Hidden when nothing is pending.
+ */
+export function GlUpcomingWindowsSection() {
+  const { data, isLoading } = useQuery(
+    api.trainScheduling.allBookingWindows.queryOptions({
+      refetchInterval: 60_000,
+    }),
+  );
+  const [page, setPage] = useState(0);
+
+  const windows = useMemo(() => {
+    const rows = (data ?? []).filter(
+      (w) => w.windowPhase != null && w.windowPhase !== "DONE" && !isPast(w),
+    );
+    // Canceled schedules are retired to windowPhase='DONE' server-side, so the
+    // guard above already excludes them; they never reach the upcoming list.
+    // Open lanes first, then by opening time.
+    return rows.sort((a, b) => {
+      const openDiff = Number(b.isOpenNow) - Number(a.isOpenNow);
+      if (openDiff !== 0) return openDiff;
+      const at = a.windowOpensAt ? new Date(a.windowOpensAt).getTime() : Infinity;
+      const bt = b.windowOpensAt ? new Date(b.windowOpensAt).getTime() : Infinity;
+      return at - bt;
+    });
+  }, [data]);
+
+  const pageCount = Math.max(1, Math.ceil(windows.length / PER_PAGE));
+  const safePage = Math.min(page, pageCount - 1);
+  const visible = windows.slice(
+    safePage * PER_PAGE,
+    safePage * PER_PAGE + PER_PAGE,
+  );
+
+  if (!isLoading && windows.length === 0) return null;
+
+  return (
+    <Card withBorder shadow="sm" radius="lg" p="lg">
+      <Group justify="space-between" align="flex-start" mb="md" wrap="nowrap">
+        <Group gap={8} wrap="nowrap">
+          <CalendarClock size={18} />
+          <Box>
+            <Text fw={700} fz={16}>
+              Booking windows
+            </Text>
+            <Text fz={13} c="dimmed">
+              Import and export booking windows across all lanes (EAT)
+            </Text>
+          </Box>
+        </Group>
+
+        {pageCount > 1 ? (
+          <Group gap={8} wrap="nowrap">
+            <ActionIcon
+              variant="default"
+              radius="xl"
+              size="lg"
+              aria-label="Previous windows"
+              disabled={safePage <= 0}
+              onClick={() => setPage((p) => Math.max(0, p - 1))}
+            >
+              <ChevronLeft size={18} />
+            </ActionIcon>
+            <Group gap={5} wrap="nowrap">
+              {Array.from({ length: pageCount }, (_, i) => (
+                <Box
+                  key={i}
+                  onClick={() => setPage(i)}
+                  style={{
+                    width: i === safePage ? 18 : 7,
+                    height: 7,
+                    borderRadius: 999,
+                    cursor: "pointer",
+                    background:
+                      i === safePage
+                        ? "var(--mantine-color-edr-green-6)"
+                        : "var(--mantine-color-gray-3)",
+                    transition: "width 200ms ease, background 200ms ease",
+                  }}
+                />
+              ))}
+            </Group>
+            <ActionIcon
+              variant="default"
+              radius="xl"
+              size="lg"
+              aria-label="Next windows"
+              disabled={safePage >= pageCount - 1}
+              onClick={() => setPage((p) => Math.min(pageCount - 1, p + 1))}
+            >
+              <ChevronRight size={18} />
+            </ActionIcon>
+          </Group>
+        ) : null}
+      </Group>
+
+      {isLoading ? (
+        <SimpleGrid cols={{ base: 1, sm: 2, lg: 3 }} spacing="md">
+          {[1, 2, 3].map((i) => (
+            <Skeleton key={i} height={150} radius="md" />
+          ))}
+        </SimpleGrid>
+      ) : (
+        <SimpleGrid key={safePage} cols={{ base: 1, sm: 2, lg: 3 }} spacing="md">
+          {visible.map((w) => (
+            <WindowCard key={`${w.scheduleId}-${w.bookingCycleNo}`} w={w} />
+          ))}
+        </SimpleGrid>
+      )}
+    </Card>
+  );
+}
diff --git a/apps/edr-freight-web/backoffice/src/components/contracts/PhasedClearanceActionPanel.tsx b/apps/edr-freight-web/backoffice/src/components/contracts/PhasedClearanceActionPanel.tsx
index 82ac61382..d0b7f2c87 100644
--- a/apps/edr-freight-web/backoffice/src/components/contracts/PhasedClearanceActionPanel.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/contracts/PhasedClearanceActionPanel.tsx
@@ -4,7 +4,6 @@ import {
   Badge,
   Button,
   Group,
-  Modal,
   NumberInput,
   Paper,
   SegmentedControl,
@@ -15,7 +14,6 @@ import {
   Text,
   TextInput,
 } from "@mantine/core";
-import { DateTimePicker } from "@mantine/dates";
 import { PhasedFileDropzone, PhasedMultiFileDropzone } from "@/components/contracts/PhasedFileDropzone";
 import {
   TransitPermitMultiUpload,
@@ -536,17 +534,12 @@ export function PhasedClearanceActionPanel({
 
             <Stepper.Step
               label="Gate pass"
-              description="GL Djibouti grants after wagon allocation"
+              description="Secured on the train schedule after wagon allocation"
               icon={
                 clearance.gatepassGranted ? <CheckCircle2 size={14} /> : <Truck size={14} />
               }
             >
-              <ImportGatepassStep
-                bookingId={actionBookingId}
-                clearance={clearance}
-                canAct={showDj && canDj}
-                onChanged={onChanged}
-              />
+              <ImportGatepassStep clearance={clearance} />
             </Stepper.Step>
 
             <Stepper.Step
@@ -816,28 +809,19 @@ function ImportT1Section({
   );
 }
 
-/** GL DJ grants the import gate pass once wagons are allocated (captures time). */
-function ImportGatepassStep({
-  bookingId,
-  clearance,
-  canAct,
-  onChanged,
-}: {
-  bookingId: string | null;
-  clearance: ClearanceViewLike;
-  canAct: boolean;
-  onChanged?: () => void;
-}) {
-  const [opened, setOpened] = useState(false);
-  const [at, setAt] = useState<Date | null>(new Date());
-  const [loading, setLoading] = useState(false);
+/**
+ * Gate pass status, read-only. Secured on the train schedule's "Save as
+ * Secured" action (train-scheduling-v2) — clearance no longer grants it directly.
+ */
+function ImportGatepassStep({ clearance }: { clearance: ClearanceViewLike }) {
+  const scheduleId = clearance.train?.scheduleId ?? null;
 
   if (clearance.gatepassGranted) {
     return (
       <StepStatus
         done
         pendingLabel=""
-        doneLabel={`Gate pass granted${
+        doneLabel={`Gate pass secured${
           clearance.gatepassAt ? ` · ${new Date(clearance.gatepassAt).toLocaleString()}` : ""
         }`}
       />
@@ -852,68 +836,21 @@ function ImportGatepassStep({
         done={false}
         pendingLabel={
           wagonAllocated
-            ? "Wagons allocated — GL Djibouti can grant the gate pass."
+            ? "Wagons allocated — secure the gate pass on the train schedule."
             : "Available once wagons are allocated."
         }
         doneLabel=""
       />
-      {canAct && bookingId ? (
-        <>
-          <Button
-            color="edr-green"
-            leftSection={<Truck size={16} />}
-            disabled={!wagonAllocated}
-            onClick={() => {
-              setAt(new Date());
-              setOpened(true);
-            }}
-          >
-            Grant gate pass
-          </Button>
-          <Modal
-            opened={opened}
-            onClose={() => setOpened(false)}
-            title={<Text fw={700}>Grant gate pass</Text>}
-            radius="md"
-            size="sm"
-          >
-            <Stack gap="md">
-              <DateTimePicker
-                label="Gate pass time"
-                value={at}
-                onChange={(v) => setAt(v ? new Date(v) : null)}
-                required
-              />
-              <Group justify="flex-end">
-                <Button variant="default" onClick={() => setOpened(false)} disabled={loading}>
-                  Cancel
-                </Button>
-                <Button
-                  color="edr-green"
-                  loading={loading}
-                  onClick={async () => {
-                    setLoading(true);
-                    try {
-                      await contractsService.grantGatepass(
-                        bookingId,
-                        (at ?? new Date()).toISOString(),
-                      );
-                      toast.success("Gate pass granted");
-                      setOpened(false);
-                      onChanged?.();
-                    } catch (e) {
-                      toast.error(e instanceof Error ? e.message : "Failed");
-                    } finally {
-                      setLoading(false);
-                    }
-                  }}
-                >
-                  Grant
-                </Button>
-              </Group>
-            </Stack>
-          </Modal>
-        </>
+      {scheduleId ? (
+        <Button
+          component="a"
+          href={`/dashboard/operations/train-scheduling-v2/${scheduleId}`}
+          variant="light"
+          color="edr-green"
+          leftSection={<Truck size={16} />}
+        >
+          Secure gate pass on train schedule
+        </Button>
       ) : null}
     </Stack>
   );
diff --git a/apps/edr-freight-web/backoffice/src/components/contracts/detail/ContractDetailTabCards.tsx b/apps/edr-freight-web/backoffice/src/components/contracts/detail/ContractDetailTabCards.tsx
index 44ece975d..de8ff1953 100644
--- a/apps/edr-freight-web/backoffice/src/components/contracts/detail/ContractDetailTabCards.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/contracts/detail/ContractDetailTabCards.tsx
@@ -208,6 +208,10 @@ function codeLabel(code?: string | null): string | null {
 
 export interface ContractDocumentsCardProps {
   files: ContractFile[];
+  /** Card heading. Defaults to "Documents". */
+  title?: string;
+  /** Message shown when there are no files. */
+  emptyText?: string;
   /** Open the file inline in a viewer modal. */
   onView?: (file: ContractFile) => void;
   /** Download the file to disk. */
@@ -217,13 +221,15 @@ export interface ContractDocumentsCardProps {
 /** Rich list of the contract's attached documents: type, size, view + download. */
 export function ContractDocumentsCard({
   files,
+  title = "Documents",
+  emptyText = "No documents attached to this contract.",
   onView,
   onDownload,
 }: ContractDocumentsCardProps) {
   return (
     <SectionCard
       icon={FileText}
-      title="Documents"
+      title={title}
       accent="indigo"
       extra={
         <Badge color="gray" variant="light" radius="sm">
@@ -233,7 +239,7 @@ export function ContractDocumentsCard({
     >
       {files.length === 0 ? (
         <Text size="sm" c="dimmed">
-          No documents attached to this contract.
+          {emptyText}
         </Text>
       ) : (
         <Stack gap="xs">
diff --git a/apps/edr-freight-web/backoffice/src/components/contracts/gl-actions/TransportDocumentCard.tsx b/apps/edr-freight-web/backoffice/src/components/contracts/gl-actions/TransportDocumentCard.tsx
index 52bcfef98..1ef5d1139 100644
--- a/apps/edr-freight-web/backoffice/src/components/contracts/gl-actions/TransportDocumentCard.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/contracts/gl-actions/TransportDocumentCard.tsx
@@ -32,7 +32,7 @@ export function TransportDocumentCard({ bookingId }: { bookingId: string }) {
             if (!file) return;
             setLoading(true);
             try {
-              await contractsService.uploadTransportDocument(bookingId, file);
+              await contractsService.uploadTransportDocument(bookingId, { transportDocument: file });
               toast.success("Transport document uploaded");
             } catch (e) {
               toast.error(e instanceof Error ? e.message : "Upload failed");
diff --git a/apps/edr-freight-web/backoffice/src/components/fleet/FleetFormDialog.tsx b/apps/edr-freight-web/backoffice/src/components/fleet/FleetFormDialog.tsx
index e1d1d4977..f314ab35e 100644
--- a/apps/edr-freight-web/backoffice/src/components/fleet/FleetFormDialog.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/fleet/FleetFormDialog.tsx
@@ -1,6 +1,8 @@
 import { useEffect, useMemo, useState } from "react";
-import { Loader2, Calendar } from "lucide-react";
+import { Loader2, ShieldCheck } from "lucide-react";
 import {
+  Alert,
+  Badge,
   Button,
   Group,
   Modal,
@@ -12,7 +14,6 @@ import {
   Text,
   Textarea,
   TextInput,
-  ActionIcon,
 } from "@mantine/core";
 
 import {
@@ -20,6 +21,10 @@ import {
   type FleetFormFieldDef,
 } from "@/pages/fleet/config/resources";
 import type { FleetRecord } from "@/services/fleet/fleet.service";
+import {
+  verifaydaService,
+  type FaydaCallbackMessage,
+} from "@/services/verifayda.service";
 
 export interface FleetFormDialogProps {
   open: boolean;
@@ -31,8 +36,32 @@ export interface FleetFormDialogProps {
   isSubmitting: boolean;
   selectOptionsLoading?: boolean;
   onSubmit: (values: Record<string, unknown>) => void;
+  /**
+   * Show a "Verify with Fayda" step: opens the eSignet popup and prefills
+   * firstName/lastName/email/phoneNumber/dateOfBirth from the verified
+   * identity, stamping faydaVerified + faydaSub on the payload.
+   */
+  verifyWithFayda?: boolean;
 }
 
+// Fayda returns gender as "Male"/"Female"; snap it onto the form's uppercase
+// option values (MALE/FEMALE/OTHER) so the Select prefills instead of rendering
+// blank. Unknown/empty values fall through to undefined (field left untouched).
+const normalizeGender = (raw?: string): string | undefined => {
+  const up = (raw ?? "").trim().toUpperCase();
+  if (up === "MALE" || up === "M") return "MALE";
+  if (up === "FEMALE" || up === "F") return "FEMALE";
+  return up ? "OTHER" : undefined;
+};
+
+// Fayda may return the birthdate as "2001/12/01" (slashes), but the date input
+// and validator expect ISO "2001-12-01". Normalize separators + trim to 10 chars
+// so the DOB field prefills instead of silently staying blank.
+const normalizeBirthdate = (raw?: string): string | undefined => {
+  const iso = (raw ?? "").trim().replace(/\//g, "-").slice(0, 10);
+  return /^\d{4}-\d{2}-\d{2}$/.test(iso) ? iso : undefined;
+};
+
 const buildInitialValues = (
   fields: FleetFormFieldDef[],
   emptyValues: Record<string, unknown>,
@@ -72,9 +101,12 @@ const FleetFormDialog = ({
   isSubmitting,
   selectOptionsLoading,
   onSubmit,
+  verifyWithFayda,
 }: FleetFormDialogProps) => {
   const [values, setValues] = useState<Record<string, unknown>>({});
   const [errors, setErrors] = useState<Record<string, string>>({});
+  const [faydaLoading, setFaydaLoading] = useState(false);
+  const [faydaError, setFaydaError] = useState<string | null>(null);
 
   // Seed the form ONLY when the dialog opens or the edited record changes — NOT
   // when `fields`/`emptyValues` get new object refs (they're rebuilt whenever the
@@ -87,10 +119,88 @@ const FleetFormDialog = ({
     if (open) {
       setValues(buildInitialValues(fields, emptyValues, initialRecord));
       setErrors({});
+      setFaydaError(null);
+      setFaydaLoading(false);
     }
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [open, recordId]);
 
+  // Receive the ?code&state relayed by the /callback popup, exchange it for
+  // the verified identity, and prefill the matching form fields.
+  useEffect(() => {
+    if (!open || !verifyWithFayda) return;
+    const onMessage = async (event: MessageEvent<FaydaCallbackMessage>) => {
+      if (event.origin !== window.location.origin) return;
+      if (event.data?.type !== "fayda-callback") return;
+
+      if (event.data.error) {
+        setFaydaLoading(false);
+        setFaydaError(event.data.errorDescription ?? event.data.error);
+        return;
+      }
+      if (!event.data.code || !event.data.state) return;
+
+      try {
+        const result = await verifaydaService.complete(event.data.code, event.data.state);
+        if (!result.verified) {
+          setFaydaError("Identity could not be verified");
+          return;
+        }
+        const nameParts = (result.fullName ?? "").trim().split(/\s+/).filter(Boolean);
+        const [firstName, ...rest] = nameParts;
+        const gender = normalizeGender(result.gender);
+        const dateOfBirth = normalizeBirthdate(result.birthdate);
+        setValues((current) => ({
+          ...current,
+          ...(firstName ? { firstName } : {}),
+          ...(rest.length ? { lastName: rest.join(" ") } : {}),
+          ...(result.email ? { email: result.email } : {}),
+          ...(result.phoneNumber ? { phoneNumber: result.phoneNumber } : {}),
+          ...(dateOfBirth ? { dateOfBirth } : {}),
+          ...(gender ? { gender } : {}),
+          faydaVerified: true,
+          ...(result.iamUserId ? { faydaSub: result.iamUserId } : {}),
+        }));
+        setFaydaError(null);
+      } catch (err) {
+        const message =
+          (err as { response?: { data?: { message?: string } } })?.response?.data?.message ??
+          (err instanceof Error ? err.message : "Verification failed");
+        setFaydaError(message);
+      } finally {
+        setFaydaLoading(false);
+      }
+    };
+    window.addEventListener("message", onMessage);
+    return () => window.removeEventListener("message", onMessage);
+  }, [open, verifyWithFayda]);
+
+  const handleFaydaVerify = async () => {
+    setFaydaError(null);
+    setFaydaLoading(true);
+    try {
+      const { authorizationUrl } = await verifaydaService.start();
+      const popup = window.open(
+        authorizationUrl,
+        "fayda-verify",
+        "width=480,height=760,noopener=no",
+      );
+      if (!popup) {
+        setFaydaLoading(false);
+        setFaydaError("Pop-up blocked — allow pop-ups for this site and retry.");
+      }
+      // Loading stays on until the popup posts back; reopening the dialog resets it.
+    } catch (err) {
+      setFaydaLoading(false);
+      const message =
+        (err as { response?: { data?: { message?: string } } })?.response?.data?.message ??
+        (err instanceof Error ? err.message : "Could not start verification");
+      setFaydaError(message);
+    }
+  };
+
+  const faydaVerified = values.faydaVerified === true;
+
   const shortFields = useMemo(
     () => fields.filter((f) => f.type !== "textarea"),
     [fields],
@@ -127,6 +237,12 @@ const FleetFormDialog = ({
           const date = new Date(stringValue + "T00:00:00Z");
           if (isNaN(date.getTime())) {
             next[field.name] = `${field.label} is not a valid date`;
+          } else if (field.dateBound === "future") {
+            const startOfToday = new Date();
+            startOfToday.setUTCHours(0, 0, 0, 0);
+            if (date <= startOfToday) {
+              next[field.name] = `${field.label} must be in the future`;
+            }
           } else if (date > new Date()) {
             next[field.name] = `${field.label} cannot be in the future`;
           }
@@ -147,6 +263,12 @@ const FleetFormDialog = ({
   }, [fields]);
 
   const handleSubmit = () => {
+    // Hard gate: a driver record cannot be saved until its identity is verified
+    // with Fayda. Mirrored server-side in DriversService.
+    if (verifyWithFayda && !faydaVerified) {
+      setFaydaError("Verify the driver's identity with Fayda before saving.");
+      return;
+    }
     if (!validate()) return;
     const payload = Object.fromEntries(
       Object.entries(values)
@@ -167,6 +289,9 @@ const FleetFormDialog = ({
   const renderField = (field: FleetFormFieldDef) => {
     const value = values[field.name];
     const error = errors[field.name];
+    // Fayda-owned identity fields (name/email/phone/DOB/gender) are populated
+    // only by verification and never hand-edited.
+    const isDisabled = Boolean(field.disabled || field.faydaLocked);
 
     if (field.type === "select") {
       return (
@@ -186,7 +311,7 @@ const FleetFormDialog = ({
           }
           error={error}
           searchable
-          disabled={selectOptionsLoading}
+          disabled={selectOptionsLoading || isDisabled}
           rightSection={
             selectOptionsLoading ? (
               <Loader2 size={14} className="animate-spin" />
@@ -216,7 +341,7 @@ const FleetFormDialog = ({
           error={error}
           searchable
           clearable
-          disabled={selectOptionsLoading}
+          disabled={selectOptionsLoading || isDisabled}
           rightSection={
             selectOptionsLoading ? (
               <Loader2 size={14} className="animate-spin" />
@@ -240,7 +365,7 @@ const FleetFormDialog = ({
             }))
           }
           error={error}
-          disabled={field.disabled}
+          disabled={isDisabled}
         />
       );
     }
@@ -260,7 +385,7 @@ const FleetFormDialog = ({
           }
           error={error}
           minRows={3}
-          disabled={field.disabled}
+          disabled={isDisabled}
         />
       );
     }
@@ -280,13 +405,8 @@ const FleetFormDialog = ({
             }))
           }
           error={error}
-          disabled={field.disabled}
+          disabled={isDisabled}
           description={field.description || "Select a date"}
-          rightSection={
-            <ActionIcon size="sm" variant="subtle" color="green">
-              <Calendar size={16} />
-            </ActionIcon>
-          }
           size="sm"
           radius="md"
           styles={{
@@ -318,7 +438,7 @@ const FleetFormDialog = ({
           }))
         }
         error={error}
-        disabled={field.disabled}
+        disabled={isDisabled}
       />
     );
   };
@@ -333,6 +453,40 @@ const FleetFormDialog = ({
       centered
     >
       <Stack gap="md">
+        {verifyWithFayda && (
+          <Group justify="space-between" wrap="nowrap">
+            {faydaVerified ? (
+              <Badge
+                color="green"
+                variant="light"
+                size="lg"
+                leftSection={<ShieldCheck size={14} />}
+              >
+                Identity verified with Fayda
+              </Badge>
+            ) : (
+              <Text size="sm" c="dimmed">
+                Identity must be verified with Fayda before this driver can be
+                saved.
+              </Text>
+            )}
+            <Button
+              variant={faydaVerified ? "default" : "light"}
+              color="edr-green"
+              size="xs"
+              leftSection={<ShieldCheck size={14} />}
+              loading={faydaLoading}
+              onClick={handleFaydaVerify}
+            >
+              {faydaVerified ? "Re-verify" : "Verify with Fayda"}
+            </Button>
+          </Group>
+        )}
+        {verifyWithFayda && faydaError && (
+          <Alert color="red" variant="light">
+            {faydaError}
+          </Alert>
+        )}
         <SimpleGrid cols={{ base: 1, sm: 2 }} spacing="md">
           {shortFields.map(renderField)}
         </SimpleGrid>
@@ -345,6 +499,7 @@ const FleetFormDialog = ({
             color="edr-green"
             loading={isSubmitting}
             onClick={handleSubmit}
+            disabled={verifyWithFayda && !faydaVerified}
           >
             Save
           </Button>
diff --git a/apps/edr-freight-web/backoffice/src/components/fleet/FleetHistoryModal.tsx b/apps/edr-freight-web/backoffice/src/components/fleet/FleetHistoryModal.tsx
new file mode 100644
index 000000000..43f2bce4f
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/components/fleet/FleetHistoryModal.tsx
@@ -0,0 +1,207 @@
+import { Center, Loader, Modal, Text, Timeline } from "@mantine/core";
+import { useQuery } from "@tanstack/react-query";
+import {
+  Activity,
+  CircleDot,
+  Route,
+  Truck,
+  UserCheck,
+  UserMinus,
+  UserPlus,
+} from "lucide-react";
+
+import {
+  fleetHistoryService,
+  type FleetHistoryEvent,
+} from "@/services/fleet-history.service";
+import type { FleetRecord } from "@/services/fleet/fleet.service";
+
+export interface FleetHistoryModalProps {
+  opened: boolean;
+  onClose: () => void;
+  entity: "driver" | "vehicle";
+  record: FleetRecord | null;
+}
+
+const asObj = (r: FleetRecord | null) => (r ?? {}) as Record<string, unknown>;
+
+const titleFor = (entity: "driver" | "vehicle", record: FleetRecord | null) => {
+  const r = asObj(record);
+  if (entity === "vehicle") {
+    return `Vehicle history — ${r.plateNumber ?? r.code ?? ""}`.trim();
+  }
+  return `Driver history — ${[r.firstName, r.lastName]
+    .filter(Boolean)
+    .join(" ")}`.trim();
+};
+
+const mileLabel = (e: FleetHistoryEvent) =>
+  e.metadata?.mile === "LAST" ? "Last-mile" : "First-mile";
+
+const arrow = (from?: string | null, to?: string | null) =>
+  `${from ?? "—"} → ${to ?? "—"}`;
+
+const metaStr = (e: FleetHistoryEvent, key: string) => {
+  const v = e.metadata?.[key];
+  return typeof v === "string" && v ? v : null;
+};
+
+function describe(e: FleetHistoryEvent, entity: "driver" | "vehicle") {
+  const vehiclePlate = metaStr(e, "vehiclePlate");
+  const driverName = metaStr(e, "driverName") ?? (e.label || null);
+  const bookingRef = metaStr(e, "bookingRef");
+
+  // Compose the detail line with whatever the current view doesn't already
+  // know: on a driver's timeline show which vehicle; always show the booking.
+  const detail = (extra?: string) =>
+    [
+      entity === "driver" && vehiclePlate ? `Vehicle ${vehiclePlate}` : "",
+      bookingRef ? `Booking ${bookingRef}` : "",
+      extra ?? "",
+    ]
+      .filter(Boolean)
+      .join(" · ");
+
+  switch (e.eventType) {
+    case "DRIVER_REGISTERED":
+      return {
+        icon: <UserCheck size={14} />,
+        title: "Driver registered",
+        text: e.toValue ? `Status: ${e.toValue}` : "",
+      };
+    case "VEHICLE_REGISTERED":
+      return {
+        icon: <Truck size={14} />,
+        title: "Vehicle registered",
+        text: e.toValue ? `Availability: ${e.toValue}` : "",
+      };
+    case "DRIVER_ASSIGNED":
+      return {
+        icon: <UserPlus size={14} />,
+        title: entity === "vehicle" ? "Driver assigned" : "Assigned to vehicle",
+        text:
+          entity === "vehicle"
+            ? driverName
+              ? `Driver ${driverName}`
+              : ""
+            : vehiclePlate
+              ? `Vehicle ${vehiclePlate}`
+              : "",
+      };
+    case "DRIVER_UNASSIGNED":
+      return {
+        icon: <UserMinus size={14} />,
+        title:
+          entity === "vehicle"
+            ? "Driver unassigned"
+            : "Unassigned from vehicle",
+        text:
+          entity === "vehicle"
+            ? driverName
+              ? `Driver ${driverName}`
+              : ""
+            : vehiclePlate
+              ? `Vehicle ${vehiclePlate}`
+              : "",
+      };
+    case "VEHICLE_STATUS_CHANGED":
+      return {
+        icon: <CircleDot size={14} />,
+        title: "Status changed",
+        text: arrow(e.fromValue, e.toValue),
+      };
+    case "VEHICLE_AVAILABILITY_CHANGED":
+      return {
+        icon: <Activity size={14} />,
+        title: `Marked ${e.toValue ?? ""}`.trim(),
+        text: e.fromValue ? arrow(e.fromValue, e.toValue) : "",
+      };
+    case "MILE_VEHICLE_ASSIGNED":
+      return {
+        icon: <Route size={14} />,
+        title: `${mileLabel(e)}: vehicle assigned`,
+        text: detail(e.label ? `Status: ${e.label}` : ""),
+      };
+    case "MILE_VEHICLE_RELEASED":
+      return {
+        icon: <Route size={14} />,
+        title: `${mileLabel(e)}: vehicle released`,
+        text: detail(),
+      };
+    case "MILE_STATUS_CHANGED":
+      return {
+        icon: <Route size={14} />,
+        title: `${mileLabel(e)} status`,
+        text: detail(arrow(e.fromValue, e.toValue)),
+      };
+    default:
+      return { icon: <CircleDot size={14} />, title: e.eventType, text: "" };
+  }
+}
+
+const fmt = (iso: string) => {
+  const d = new Date(iso);
+  return Number.isNaN(d.getTime()) ? iso : d.toLocaleString();
+};
+
+const FleetHistoryModal = ({
+  opened,
+  onClose,
+  entity,
+  record,
+}: FleetHistoryModalProps) => {
+  const id = asObj(record).id ? String(asObj(record).id) : "";
+
+  const { data, isLoading } = useQuery({
+    queryKey: ["fleet-history", entity, id],
+    queryFn: () =>
+      entity === "vehicle"
+        ? fleetHistoryService.vehicle(id)
+        : fleetHistoryService.driver(id),
+    enabled: opened && Boolean(id),
+  });
+
+  const events = data ?? [];
+
+  return (
+    <Modal
+      opened={opened}
+      onClose={onClose}
+      title={<Text fw={600}>{titleFor(entity, record)}</Text>}
+      radius="lg"
+      size="lg"
+      centered
+    >
+      {isLoading ? (
+        <Center py="xl">
+          <Loader size="sm" />
+        </Center>
+      ) : events.length === 0 ? (
+        <Text c="dimmed" ta="center" py="lg" size="sm">
+          No history recorded yet. Activity appears here as this{" "}
+          {entity} is assigned, reassigned, or its status changes.
+        </Text>
+      ) : (
+        <Timeline active={events.length} bulletSize={24} lineWidth={2}>
+          {events.map((e) => {
+            const d = describe(e, entity);
+            return (
+              <Timeline.Item key={e.id} bullet={d.icon} title={d.title}>
+                {d.text && (
+                  <Text size="sm" c="dimmed">
+                    {d.text}
+                  </Text>
+                )}
+                <Text size="xs" mt={4} c="dimmed">
+                  {fmt(e.createdAt)}
+                </Text>
+              </Timeline.Item>
+            );
+          })}
+        </Timeline>
+      )}
+    </Modal>
+  );
+};
+
+export default FleetHistoryModal;
diff --git a/apps/edr-freight-web/backoffice/src/components/fleet/FleetRecordActions.tsx b/apps/edr-freight-web/backoffice/src/components/fleet/FleetRecordActions.tsx
index 9096f52a1..de010e380 100644
--- a/apps/edr-freight-web/backoffice/src/components/fleet/FleetRecordActions.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/fleet/FleetRecordActions.tsx
@@ -1,4 +1,4 @@
-import { Edit2, Trash2, Eye, Users, MoreVertical } from "lucide-react";
+import { Edit2, Trash2, Eye, Users, MoreVertical, History } from "lucide-react";
 import { ActionIcon, Menu, MenuItem, Tooltip } from "@mantine/core";
 import { useNavigate } from "react-router-dom";
 
@@ -11,6 +11,8 @@ export interface FleetRecordActionsProps {
   onEdit: (record: FleetRecord) => void;
   onRemove: (record: FleetRecord) => void;
   onAssignDriver?: (record: FleetRecord) => void;
+  onHistory?: (record: FleetRecord) => void;
+  onViewDetail?: (record: FleetRecord) => void;
   layout?: "row" | "compact";
 }
 
@@ -20,12 +22,18 @@ const FleetRecordActions = ({
   onEdit,
   onRemove,
   onAssignDriver,
+  onHistory,
+  onViewDetail,
   layout = "row",
 }: FleetRecordActionsProps) => {
   const navigate = useNavigate();
   const removeLabel = config.removeActionLabel ?? "Delete";
   const showDetail = Boolean(config.detailPath && "id" in record);
+  const showViewDetail = Boolean(onViewDetail);
   const isVehicle = config.slug === "vehicles";
+  const showHistory =
+    Boolean(onHistory) &&
+    (config.slug === "drivers" || config.slug === "vehicles");
 
   const handleDetail = () => {
     if (!config.detailPath || !("id" in record)) return;
@@ -57,6 +65,22 @@ const FleetRecordActions = ({
           >
             Edit
           </MenuItem>
+          {showViewDetail ? (
+            <MenuItem
+              onClick={() => onViewDetail?.(record)}
+              leftSection={<Eye size={14} strokeWidth={2} />}
+            >
+              View detail
+            </MenuItem>
+          ) : null}
+          {showHistory ? (
+            <MenuItem
+              onClick={() => onHistory?.(record)}
+              leftSection={<History size={14} strokeWidth={2} />}
+            >
+              History
+            </MenuItem>
+          ) : null}
           {showDetail ? (
             <MenuItem
               onClick={handleDetail}
@@ -101,6 +125,14 @@ const FleetRecordActions = ({
         >
           Edit
         </MenuItem>
+        {showViewDetail ? (
+          <MenuItem
+            onClick={() => onViewDetail?.(record)}
+            leftSection={<Eye size={14} strokeWidth={2} />}
+          >
+            View detail
+          </MenuItem>
+        ) : null}
         {showDetail ? (
           <MenuItem
             onClick={handleDetail}
diff --git a/apps/edr-freight-web/backoffice/src/components/fleet/fleetFormat.tsx b/apps/edr-freight-web/backoffice/src/components/fleet/fleetFormat.tsx
index 709f288ce..b2a34eadc 100644
--- a/apps/edr-freight-web/backoffice/src/components/fleet/fleetFormat.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/fleet/fleetFormat.tsx
@@ -4,7 +4,7 @@ import { Badge, Text } from "@mantine/core";
 import type { ColumnFormat } from "@/pages/ruleEngine/config/resources";
 import { formatCell as formatRuleEngineCell } from "@/components/ruleEngine/ruleEngineFormat";
 
-export type FleetColumnFormat = ColumnFormat | "statusBadge";
+export type FleetColumnFormat = ColumnFormat | "statusBadge" | "verifiedBadge";
 
 const optionLabelMap = new Map<string, Map<string, string>>();
 
@@ -20,6 +20,16 @@ export const formatFleetCell = (
   format?: FleetColumnFormat,
   accessorKey?: string,
 ): ReactNode => {
+  if (format === "verifiedBadge") {
+    return value === true ? (
+      <Badge variant="light" color="green" size="sm" radius="md">
+        Verified
+      </Badge>
+    ) : (
+      <Text size="sm" c="dimmed">—</Text>
+    );
+  }
+
   if (format === "statusBadge") {
     const status = value == null || value === "" ? "—" : String(value);
     const getStatusColor = (st: string): string => {
diff --git a/apps/edr-freight-web/backoffice/src/components/layout/FreightSidebar.tsx b/apps/edr-freight-web/backoffice/src/components/layout/FreightSidebar.tsx
index 59efe49a7..391a8157d 100644
--- a/apps/edr-freight-web/backoffice/src/components/layout/FreightSidebar.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/layout/FreightSidebar.tsx
@@ -18,6 +18,7 @@ import {
 } from "react";
 
 import type { SidebarItem, SidebarSection } from "./types";
+import { Link } from "react-router-dom";
 
 export interface FreightSidebarProps {
   sections: SidebarSection[];
@@ -35,15 +36,15 @@ const BRAND_LOGO = "/assets/logo.svg";
 const navClassNames = (active: boolean) =>
   active
     ? {
-        root: "rounded-md transition-all duration-150 bg-edr-soft! ring-1 ring-inset ring-edr-primary/40 [&_svg]:size-[16px]",
-        label: "text-edr-primary-dark! font-medium! text-sm!",
-        section: "text-edr-primary-dark!",
-      }
+      root: "rounded-md transition-all py-1.5! duration-150 bg-edr-soft! ring-1 ring-inset ring-edr-primary/40 [&_svg]:size-[16px]",
+      label: "text-edr-primary-dark! font-medium! text-sm!",
+      section: "text-edr-primary-dark!",
+    }
     : {
-        root: "rounded-md transition-all duration-150 hover:bg-[#EEF2F6]! [&_svg]:size-4",
-        label: "text-edr-text! font-medium! text-sm! hover:text-edr-ink!",
-        section: "text-edr-text!",
-      };
+      root: "rounded-md transition-all py-1.5! duration-150 hover:bg-[#EEF2F6]! [&_svg]:size-4",
+      label: "text-edr-text! font-medium! text-sm! hover:text-edr-ink!",
+      section: "text-edr-text!",
+    };
 
 const itemKey = (parentKey: string, item: SidebarItem, index: number) =>
   `${parentKey}/${item.href ?? item.label}/${index}`;
@@ -65,7 +66,9 @@ const FreightSidebar = ({
   const isHrefActive = useCallback(
     (href: string) => {
       const normalized = href.toLowerCase();
-      return activePath === normalized || activePath.startsWith(`${normalized}/`);
+      return (
+        activePath === normalized || activePath.startsWith(`${normalized}/`)
+      );
     },
     [activePath],
   );
@@ -109,9 +112,7 @@ const FreightSidebar = ({
 
       if (hasChildren) {
         const isLink = !!item.href;
-        const active =
-          (isLink ? isHrefActive(item.href!) : false) ||
-          branchActive(item.children!);
+        const active = isLink ? isHrefActive(item.href!) : false;
         const isOpen = openMap[key] ?? false;
 
         return (
@@ -124,7 +125,7 @@ const FreightSidebar = ({
             active={active}
             opened={isOpen}
             classNames={navClassNames(active)}
-            onClick={ () => toggle(key)}
+            onClick={() => toggle(key)}
             rightSection={
               <Box
                 component="span"
@@ -140,7 +141,9 @@ const FreightSidebar = ({
                 <ChevronDown
                   size={16}
                   className="text-edr-muted transition-transform duration-200"
-                  style={{ transform: isOpen ? "rotate(-180deg)" : "rotate(180deg)" }}
+                  style={{
+                    transform: isOpen ? "rotate(-180deg)" : "rotate(180deg)",
+                  }}
                 />
               </Box>
             }
@@ -161,8 +164,9 @@ const FreightSidebar = ({
           label={item.label}
           leftSection={item.icon}
           active={active}
+          component={Link}
           classNames={navClassNames(active)}
-          onClick={() => onNavigate?.(item.href!)}
+          to={item.href!}
         />
       );
     },
@@ -178,7 +182,7 @@ const FreightSidebar = ({
             tt="uppercase"
             px="sm"
             mb={6}
-            className={ "text-edr-muted!" }
+            className={"text-edr-muted!"}
             style={{ fontWeight: 500, fontSize: 10, letterSpacing: "0.05em" }}
           >
             {section.title}
@@ -232,14 +236,24 @@ const FreightSidebar = ({
           </Box>
         </Group>
         {onClose && (
-          <UnstyledButton onClick={onClose} hiddenFrom="sm" aria-label="Close sidebar">
+          <UnstyledButton
+            onClick={onClose}
+            hiddenFrom="sm"
+            aria-label="Close sidebar"
+          >
             <X size={18} className="text-edr-muted" strokeWidth={1.8} />
           </UnstyledButton>
         )}
       </Box>
 
       {/* Nav */}
-      <AppShell.Section grow component={ScrollArea} type="never" px="sm" pb="md">
+      <AppShell.Section
+        grow
+        component={ScrollArea}
+        type="never"
+        px="sm"
+        pb="md"
+      >
         <Stack gap="lg">{renderedSections}</Stack>
       </AppShell.Section>
     </AppShell.Navbar>
diff --git a/apps/edr-freight-web/backoffice/src/components/operations/LastMileSteps.tsx b/apps/edr-freight-web/backoffice/src/components/operations/LastMileSteps.tsx
new file mode 100644
index 000000000..d4860a414
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/components/operations/LastMileSteps.tsx
@@ -0,0 +1,93 @@
+import { Group, Stack, Text, Timeline, Tooltip } from "@mantine/core";
+import { Check } from "lucide-react";
+
+/** One stage of the last-mile delivery workflow. */
+export interface LastMileStepState {
+  label: string;
+  done: boolean;
+  active: boolean;
+  /** Optional stamp/value shown next to the step (plate, time, distance…). */
+  detail?: string | null;
+}
+
+/**
+ * Compact 6-dot progress bar for a table row — filled = done, ringed = current,
+ * hollow = pending. Hover a dot for its label + stamp.
+ */
+export function LastMileStepBar({ steps }: { steps: LastMileStepState[] }) {
+  return (
+    <Group gap={4} wrap="nowrap">
+      {steps.map((s, i) => {
+        const color = s.done
+          ? "var(--mantine-color-green-6)"
+          : s.active
+            ? "var(--mantine-color-blue-5)"
+            : "var(--mantine-color-gray-4)";
+        return (
+          <Tooltip
+            key={i}
+            withArrow
+            label={`${s.label}${s.detail ? ` · ${s.detail}` : ""}`}
+          >
+            <span
+              style={{
+                width: 10,
+                height: 10,
+                borderRadius: "50%",
+                background: s.done ? color : "transparent",
+                border: `2px solid ${color}`,
+                boxShadow: s.active
+                  ? "0 0 0 2px var(--mantine-color-blue-1)"
+                  : undefined,
+                display: "inline-block",
+                flex: "0 0 auto",
+              }}
+            />
+          </Tooltip>
+        );
+      })}
+    </Group>
+  );
+}
+
+/**
+ * Vertical stepper for the detail view — completed steps bulleted + green, the
+ * current step highlighted, each showing its stamp/value when known.
+ */
+export function LastMileStepper({ steps }: { steps: LastMileStepState[] }) {
+  const activeIndex = steps.findIndex((s) => s.active);
+  // Timeline highlights items with index < `active`; count of done steps drives it.
+  const doneCount = steps.filter((s) => s.done).length;
+  return (
+    <Timeline
+      active={activeIndex === -1 ? steps.length : doneCount}
+      bulletSize={22}
+      lineWidth={2}
+      color="green"
+    >
+      {steps.map((s, i) => (
+        <Timeline.Item
+          key={i}
+          bullet={s.done ? <Check size={12} /> : undefined}
+          title={
+            <Text size="sm" fw={s.active ? 600 : 500} c={s.active ? "blue" : undefined}>
+              {s.label}
+            </Text>
+          }
+          lineVariant={s.done ? "solid" : "dashed"}
+        >
+          <Stack gap={0}>
+            <Text size="xs" c="dimmed">
+              {s.done ? "Done" : s.active ? "Current step" : "Pending"}
+            </Text>
+            {s.detail && (
+              <Text size="xs" c="dimmed">
+                {s.detail}
+              </Text>
+            )}
+          </Stack>
+        </Timeline.Item>
+      ))}
+    </Timeline>
+  );
+}
diff --git a/apps/edr-freight-web/backoffice/src/components/ruleEngine/RuleEngineFormDialog.tsx b/apps/edr-freight-web/backoffice/src/components/ruleEngine/RuleEngineFormDialog.tsx
index 6ae71cdc0..8553bcf0b 100644
--- a/apps/edr-freight-web/backoffice/src/components/ruleEngine/RuleEngineFormDialog.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/ruleEngine/RuleEngineFormDialog.tsx
@@ -179,7 +179,16 @@ const RuleEngineFormDialog = ({
   const formRows = useMemo(() => buildFormRows(visibleFields), [visibleFields]);
 
   const setField = (name: string, value: unknown) => {
-    setValues((current) => ({ ...current, [name]: value }));
+    setValues((current) => {
+      const next = { ...current, [name]: value };
+      // Changing what a rate applies to (or its surcharge trigger) can invalidate
+      // the previously-chosen unit — reset it so the admin re-picks from the new
+      // allowed set instead of submitting a stale, rejected unit.
+      if ((name === "appliesTo" || name === "trigger") && "rateUnit" in current) {
+        next.rateUnit = "";
+      }
+      return next;
+    });
   };
 
   const handleSubmit = (event: React.FormEvent) => {
@@ -250,6 +259,9 @@ const RuleEngineFormDialog = ({
     const label = <FieldLabel label={field.label} required={field.required} />;
 
     if (field.type === "select") {
+      // Dynamic options (e.g. rate unit) resolve from the live form values so
+      // the choices track the other fields the admin has picked.
+      const options = field.optionsFromValues ? field.optionsFromValues(values) : (field.options ?? []);
       return (
         <Select
           key={field.name}
@@ -261,7 +273,7 @@ const RuleEngineFormDialog = ({
           value={resolveSelectValue(field, values)}
           onChange={(v) => setField(field.name, v === RULE_ENGINE_SELECT_NONE ? "" : v)}
           disabled={selectOptionsLoading}
-          data={(field.options ?? [])
+          data={options
             .filter((opt) => opt.value !== "")
             .map((opt) => ({
               label: opt.label,
diff --git a/apps/edr-freight-web/backoffice/src/components/trainScheduling/DurationField.tsx b/apps/edr-freight-web/backoffice/src/components/trainScheduling/DurationField.tsx
new file mode 100644
index 000000000..06c9013d4
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/components/trainScheduling/DurationField.tsx
@@ -0,0 +1,123 @@
+import { useEffect, useMemo, useRef, useState } from "react";
+import { Group, NumberInput, Select, Stack } from "@mantine/core";
+
+export type DurationUnit = "minutes" | "hours" | "days";
+
+const UNIT_MINUTES: Record<DurationUnit, number> = {
+  minutes: 1,
+  hours: 60,
+  days: 1440,
+};
+
+const UNIT_OPTIONS: { value: DurationUnit; label: string }[] = [
+  { value: "minutes", label: "min" },
+  { value: "hours", label: "hr" },
+  { value: "days", label: "day" },
+];
+
+/** Convert a value expressed in `from` units to `to` units. */
+function convert(value: number, from: DurationUnit, to: DurationUnit): number {
+  return (value * UNIT_MINUTES[from]) / UNIT_MINUTES[to];
+}
+
+/** Pick the largest unit that keeps a value a clean-ish whole number, so a
+ * stored 0.0667h loads back as "4 min" rather than "0.0667 hr". */
+function bestDisplayUnit(minutes: number): DurationUnit {
+  if (minutes <= 0) return "minutes";
+  if (minutes % 1440 === 0) return "days";
+  if (minutes % 60 === 0) return "hours";
+  return "minutes";
+}
+
+export interface DurationFieldProps {
+  label: string;
+  description?: string;
+  /** Current value, expressed in `nativeUnit` (what the API/DB stores). */
+  value: number | string;
+  /** The unit the parent stores/sends. The field converts to this on change. */
+  nativeUnit: DurationUnit;
+  /** Called with the value converted back to `nativeUnit` (or "" when blank). */
+  onChange: (nativeValue: number | "") => void;
+  /** Smallest allowed value, in `nativeUnit`. */
+  min?: number;
+  disabled?: boolean;
+}
+
+export default function DurationField({
+  label,
+  description,
+  value,
+  nativeUnit,
+  onChange,
+  min,
+  disabled,
+}: DurationFieldProps) {
+  const nativeMinutes = useMemo(() => {
+    const num = value === "" || value == null ? NaN : Number(value);
+    return Number.isFinite(num) ? num * UNIT_MINUTES[nativeUnit] : NaN;
+  }, [value, nativeUnit]);
+
+  // Display unit is user-driven; seed it from the incoming value once.
+  const [unit, setUnit] = useState<DurationUnit>(() =>
+    Number.isFinite(nativeMinutes) ? bestDisplayUnit(nativeMinutes) : nativeUnit,
+  );
+
+  // The value usually arrives async (after the initial "" render), so the
+  // useState seed above runs before it exists. Re-pick the friendliest display
+  // unit the first time a real value shows up — but never again, so the user's
+  // manual unit choice sticks.
+  const seeded = useRef(false);
+  useEffect(() => {
+    if (!seeded.current && Number.isFinite(nativeMinutes)) {
+      seeded.current = true;
+      setUnit(bestDisplayUnit(nativeMinutes));
+    }
+  }, [nativeMinutes]);
+
+  const displayValue: number | "" = Number.isFinite(nativeMinutes)
+    ? Number(convert(nativeMinutes, "minutes", unit).toFixed(4))
+    : "";
+
+  const emitNative = (display: number | "", displayUnit: DurationUnit) => {
+    if (display === "" || !Number.isFinite(Number(display))) {
+      onChange("");
+      return;
+    }
+    const native = convert(Number(display), displayUnit, nativeUnit);
+    onChange(Number(native.toFixed(6)));
+  };
+
+  return (
+    <Stack gap={4}>
+      <Group gap="xs" align="flex-end" wrap="nowrap">
+        <NumberInput
+          label={label}
+          description={description}
+          value={displayValue}
+          onChange={(v) =>
+            emitNative(v === "" ? "" : Number(v), unit)
+          }
+          clampBehavior="none"
+          allowDecimal
+          min={min != null ? convert(min, nativeUnit, unit) : 0}
+          disabled={disabled}
+          style={{ flex: 1 }}
+        />
+        <Select
+          aria-label={`${label} unit`}
+          data={UNIT_OPTIONS}
+          value={unit}
+          onChange={(next) => {
+            if (!next) return;
+            // Only the display unit changes; the stored native value stays put.
+            // displayValue re-derives from it on the next render.
+            setUnit(next as DurationUnit);
+          }}
+          allowDeselect={false}
+          disabled={disabled}
+          w={90}
+        />
+      </Group>
+    </Stack>
+  );
+}
diff --git a/apps/edr-freight-web/backoffice/src/components/trainScheduling/ImportLoadingConfirmationPanel.tsx b/apps/edr-freight-web/backoffice/src/components/trainScheduling/ImportLoadingConfirmationPanel.tsx
new file mode 100644
index 000000000..ab1d907e6
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/components/trainScheduling/ImportLoadingConfirmationPanel.tsx
@@ -0,0 +1,172 @@
+import { useMemo, useState } from "react";
+import { PackageCheck } from "lucide-react";
+import { Badge, Button, Checkbox, Group, Loader, Paper, Stack, Text } from "@mantine/core";
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+import toast from "react-hot-toast";
+
+import { api } from "@/services/api";
+import type {
+  ImportLoadingBooking,
+  ImportLoadingBookingsResponse,
+  LoadingStatus,
+} from "@/types/trainScheduling";
+
+function ImportLoadingBookingRow({
+  booking,
+  selected,
+  onToggle,
+}: {
+  booking: ImportLoadingBooking;
+  selected: boolean;
+  onToggle: () => void;
+}) {
+  return (
+    <Group
+      align="flex-start"
+      wrap="nowrap"
+      p="sm"
+      style={{
+        border: `1px solid ${
+          selected ? "var(--mantine-color-edr-green-3)" : "var(--mantine-color-gray-2)"
+        }`,
+        borderRadius: 12,
+        background: selected ? "var(--mantine-color-edr-green-0)" : "white",
+        transition: "border-color 120ms ease, background 120ms ease",
+      }}
+    >
+      <Checkbox checked={selected} onChange={onToggle} mt={4} color="edr-green" />
+      <Stack gap={4} style={{ flex: 1 }}>
+        <Group gap="xs" wrap="wrap">
+          <PackageCheck size={14} />
+          <Text fw={600} size="sm">
+            {booking.reference ?? booking.id}
+          </Text>
+          <Badge
+            variant="light"
+            size="xs"
+            color={booking.loadingStatus === "LOADED" ? "edr-green" : "gray"}
+          >
+            {booking.loadingStatus}
+          </Badge>
+        </Group>
+        <Text size="xs" c="dimmed">
+          {booking.customer ?? "Unknown customer"}
+        </Text>
+        <Text size="xs" c="dimmed">
+          {booking.weightTons}T
+        </Text>
+      </Stack>
+    </Group>
+  );
+}
+
+export function ImportLoadingConfirmationPanel({
+  scheduleId,
+  items,
+  isLoading,
+}: {
+  scheduleId: string;
+  items: ImportLoadingBooking[];
+  isLoading?: boolean;
+}) {
+  const [selectedIds, setSelectedIds] = useState<string[]>([]);
+  const queryClient = useQueryClient();
+
+  const updateStatus = useMutation<
+    ImportLoadingBookingsResponse,
+    Error,
+    { id: string; bookingIds: string[]; loadingStatus: LoadingStatus }
+  >({
+    ...api.trainScheduling.updateImportLoadingStatus.mutationOptions(),
+    onSuccess: () => {
+      setSelectedIds([]);
+      queryClient.invalidateQueries({
+        queryKey: api.trainScheduling.importLoadingBookings.queryKey({ id: scheduleId }),
+      });
+    },
+    onError: (error) => {
+      toast.error(error instanceof Error ? error.message : "Could not update loading status");
+    },
+  });
+
+  const toggle = (id: string) => {
+    setSelectedIds((prev) =>
+      prev.includes(id) ? prev.filter((x) => x !== id) : [...prev, id],
+    );
+  };
+
+  const allIds = useMemo(() => items.map((b) => b.id), [items]);
+
+  if (isLoading) {
+    return (
+      <Group justify="center" py="md">
+        <Loader size="sm" />
+        <Text size="sm" c="dimmed">
+          Loading import bookings…
+        </Text>
+      </Group>
+    );
+  }
+
+  if (!items.length) {
+    return (
+      <Paper p="lg" radius="lg" withBorder bg="gray.0">
+        <Text size="sm" c="dimmed" ta="center">
+          No paid import bookings with wagons allocated on this schedule
+        </Text>
+      </Paper>
+    );
+  }
+
+  return (
+    <Stack gap="md">
+      <Group justify="space-between" wrap="wrap">
+        <Text size="sm" fw={500}>
+          Import bookings ({items.length})
+        </Text>
+        <Group gap="sm">
+          <Button variant="light" size="compact-sm" onClick={() => setSelectedIds(allIds)}>
+            Select all
+          </Button>
+          <Button variant="subtle" size="compact-sm" onClick={() => setSelectedIds([])}>
+            Clear
+          </Button>
+        </Group>
+      </Group>
+
+      <Stack gap="sm">
+        {items.map((booking) => (
+          <ImportLoadingBookingRow
+            key={booking.id}
+            booking={booking}
+            selected={selectedIds.includes(booking.id)}
+            onToggle={() => toggle(booking.id)}
+          />
+        ))}
+      </Stack>
+
+      <Group gap="sm">
+        <Button
+          color="edr-green"
+          disabled={!selectedIds.length}
+          loading={updateStatus.isPending}
+          onClick={() =>
+            updateStatus.mutate({ id: scheduleId, bookingIds: selectedIds, loadingStatus: "LOADED" })
+          }
+        >
+          Mark loaded
+        </Button>
+        <Button
+          variant="outline"
+          disabled={!selectedIds.length}
+          loading={updateStatus.isPending}
+          onClick={() =>
+            updateStatus.mutate({ id: scheduleId, bookingIds: selectedIds, loadingStatus: "UNLOADED" })
+          }
+        >
+          Mark unloaded
+        </Button>
+      </Group>
+    </Stack>
+  );
+}
diff --git a/apps/edr-freight-web/backoffice/src/components/trainScheduling/ScheduleWorkspacePanel.tsx b/apps/edr-freight-web/backoffice/src/components/trainScheduling/ScheduleWorkspacePanel.tsx
new file mode 100644
index 000000000..2a7689582
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/components/trainScheduling/ScheduleWorkspacePanel.tsx
@@ -0,0 +1,618 @@
+import { useMemo, useState } from "react";
+import { isAxiosError } from "axios";
+import {
+  Badge,
+  Box,
+  Button,
+  Group,
+  Modal,
+  Paper,
+  Progress,
+  ScrollArea,
+  Select,
+  Stack,
+  Text,
+  ThemeIcon,
+  Tooltip,
+} from "@mantine/core";
+import { useMutation, useQuery } from "@tanstack/react-query";
+import {
+  AlertTriangle,
+  ArrowLeftRight,
+  ArrowRight,
+  CheckCircle2,
+  Inbox,
+  PackageCheck,
+  Repeat,
+  Train,
+  Weight,
+  X,
+} from "lucide-react";
+
+import { CountdownTimer } from "@edr/ui-common";
+
+import { BookingStatusBadge } from "@/components/bookings/BookingStatusBadge";
+import { api } from "@/services/api";
+import { useToast } from "@/hooks/use-toast";
+import type {
+  EligibleContainerBooking,
+  FreightType,
+  TrainScheduleDetail,
+} from "@/types/trainScheduling";
+
+interface ScheduleWorkspacePanelProps {
+  schedule: TrainScheduleDetail;
+  /** Refetch the schedule detail after a mutation so both panels refresh. */
+  onChanged: () => void;
+}
+
+const GREEN = "var(--mantine-color-edr-green-6)";
+
+/** Pull the API's violation detail out of an error (e.g. "No CW3 wagon available…"). */
+function apiErrorMessage(error: unknown, fallback: string): string {
+  if (isAxiosError(error)) {
+    const data = error.response?.data as Record<string, unknown> | undefined;
+    const violations = data?.violations;
+    if (Array.isArray(violations) && violations.length) return violations.join(", ");
+    if (typeof data?.message === "string") return data.message;
+    if (Array.isArray(data?.message)) return (data.message as string[]).join(", ");
+  }
+  return fallback;
+}
+
+/**
+ * Deadline + label for the window phase this schedule is currently in.
+ * Phases run: window open (windowClosesAt) → document review (docReviewEndsAt)
+ * → payment (paymentPhaseEndsAt). Display only. Returns null off-phase.
+ */
+function phaseCountdown(
+  schedule: TrainScheduleDetail,
+): { label: string; deadline: string } | null {
+  switch (schedule.windowPhase) {
+    case "OPEN":
+      return schedule.windowClosesAt
+        ? { label: "Booking window closes in", deadline: schedule.windowClosesAt }
+        : null;
+    case "DOC_REVIEW":
+      return schedule.docReviewEndsAt
+        ? { label: "Document review ends in", deadline: schedule.docReviewEndsAt }
+        : null;
+    case "PAYMENT":
+      return schedule.paymentPhaseEndsAt
+        ? { label: "Payment window ends in", deadline: schedule.paymentPhaseEndsAt }
+        : null;
+    default:
+      return null;
+  }
+}
+
+/** Cargo weight already allocated to this train (sum of on-train bookings). */
+function usedWeight(schedule: TrainScheduleDetail): number {
+  return (schedule.bookings ?? []).reduce(
+    (sum, b) => sum + (Number(b.weightTons) || 0),
+    0,
+  );
+}
+
+/** Max pull weight across all locomotives on the set (0 when unknown). */
+function pullCapacity(schedule: TrainScheduleDetail): number {
+  const set = schedule.trainSet;
+  if (!set) return 0;
+  const locos =
+    set.locomotives && set.locomotives.length > 0
+      ? set.locomotives
+      : set.locomotive
+        ? [set.locomotive]
+        : [];
+  return locos.reduce((sum, l) => sum + (Number(l.maxPullWeightTons) || 0), 0);
+}
+
+export function ScheduleWorkspacePanel({
+  schedule,
+  onChanged,
+}: ScheduleWorkspacePanelProps) {
+  const { toast } = useToast();
+
+  const freightType: FreightType | undefined =
+    schedule.freightType === "CONTAINER" || schedule.freightType === "BULK"
+      ? schedule.freightType
+      : undefined;
+
+  const locked = ["DISPATCHED", "ARRIVED"].includes(schedule.status);
+  const canManage = ["DRAFT", "SCHEDULED"].includes(schedule.status);
+
+  // Pool = accepted, ready-to-pay bookings on THIS train's route+day that are not
+  // yet linked to any schedule (same filter the auto-batch uses).
+  const poolQuery = useQuery(
+    api.trainScheduling.eligibleBookings.queryOptions({
+      input: {
+        filters: {
+          originStationId: schedule.originStation?.id,
+          destinationStationId: schedule.destinationStation?.id,
+          trainScheduleId: schedule.id,
+        },
+        freightType,
+      },
+      enabled: Boolean(schedule.originStation?.id && schedule.destinationStation?.id),
+    }),
+  );
+
+  const onTrainIds = useMemo(
+    () => new Set((schedule.bookings ?? []).map((b) => b.id)),
+    [schedule.bookings],
+  );
+
+  const pool: EligibleContainerBooking[] = useMemo(
+    () => (poolQuery.data?.items ?? []).filter((b) => !onTrainIds.has(b.id)),
+    [poolQuery.data, onTrainIds],
+  );
+
+  const onTrain = schedule.bookings ?? [];
+
+  // ── Mutations (reuse the existing endpoints) ───────────────────────────────
+  const assign = useMutation(api.trainScheduling.assignBookings.mutationOptions());
+  const unassign = useMutation(api.trainScheduling.unassignBooking.mutationOptions());
+  const moveSchedule = useMutation(
+    api.trainScheduling.moveBookingSchedule.mutationOptions(),
+  );
+
+  const [moveBookingId, setMoveBookingId] = useState<string | null>(null);
+  const [moveTarget, setMoveTarget] = useState<string | null>(null);
+
+  const { data: targets } = useQuery(
+    api.trainScheduling.bookableSchedules.queryOptions({
+      input: {
+        originYardId: schedule.originStation?.id,
+        destinationYardId: schedule.destinationStation?.id,
+      },
+      enabled: Boolean(
+        schedule.originStation?.id && schedule.destinationStation?.id,
+      ),
+    }),
+  );
+  const moveOptions = useMemo(
+    () =>
+      (targets ?? [])
+        .filter((s) => s.id !== schedule.id)
+        .map((s) => ({
+          value: s.id,
+          label: `${s.routeName ?? `${s.origin} → ${s.destination}`} · ${new Date(
+            s.scheduleDate,
+          ).toLocaleString()} · ${s.remainingWagons}/${s.maxWagons} free`,
+        })),
+    [targets, schedule.id],
+  );
+
+  // ── Capacity meter (by cargo weight vs locomotive pull) ────────────────────
+  const used = usedWeight(schedule);
+  const capacity = pullCapacity(schedule);
+  const pct = capacity > 0 ? Math.min(100, Math.round((used / capacity) * 100)) : 0;
+  const over = capacity > 0 && used > capacity;
+
+  const forceAdd = (bookingId: string, ref: string, weightTons: number) => {
+    const wouldOverfill = capacity > 0 && used + (weightTons || 0) > capacity;
+    assign
+      .mutateAsync({
+        id: schedule.id,
+        freightType,
+        payload: {
+          bookingIds: [...onTrainIds, bookingId],
+          forceAssign: true,
+        },
+      })
+      .then(() => {
+        toast({
+          title: `${ref} added to train`,
+          description: wouldOverfill
+            ? "Force-added past the pull-weight limit — review capacity."
+            : "Wagons auto-pinned.",
+          variant: wouldOverfill ? "destructive" : undefined,
+        });
+        onChanged();
+        void poolQuery.refetch();
+      })
+      .catch((error) =>
+        toast({
+          title: "Could not add booking",
+          description: apiErrorMessage(error, "Validation failed — check capacity and status."),
+          variant: "destructive",
+        }),
+      );
+  };
+
+  const removeFromTrain = (bookingId: string, ref: string) => {
+    unassign
+      .mutateAsync({ id: schedule.id, bookingId })
+      .then(() => {
+        toast({ title: `${ref} removed from train` });
+        onChanged();
+        void poolQuery.refetch();
+      })
+      .catch((error) =>
+        toast({
+          title: "Could not remove booking",
+          description: apiErrorMessage(error, "Please try again."),
+          variant: "destructive",
+        }),
+      );
+  };
+
+  const doMove = () => {
+    if (!moveBookingId || !moveTarget) return;
+    moveSchedule
+      .mutateAsync({ bookingId: moveBookingId, trainScheduleId: moveTarget })
+      .then(() => {
+        toast({ title: "Booking reassigned to another train" });
+        setMoveBookingId(null);
+        onChanged();
+        void poolQuery.refetch();
+      })
+      .catch((error) =>
+        toast({
+          title: "Could not reassign booking",
+          description: apiErrorMessage(error, "Target train may be closed or full."),
+          variant: "destructive",
+        }),
+      );
+  };
+
+  return (
+    <Paper radius="xl" p="lg" withBorder style={{ borderColor: "var(--mantine-color-gray-2)" }}>
+      <Stack gap="lg">
+        {/* Header + capacity meter */}
+        <Group justify="space-between" align="flex-start" wrap="wrap" gap="md">
+          <Group gap="sm" align="center" wrap="nowrap">
+            <ThemeIcon size={40} radius="md" variant="light" color="edr-green">
+              <PackageCheck size={20} />
+            </ThemeIcon>
+            <div>
+              <Text fw={700}>Allocation workspace</Text>
+              <Text size="xs" c="dimmed">
+                Manually add ready-to-pay bookings, remove, or reassign them
+              </Text>
+            </div>
+          </Group>
+
+          <Box miw={240} style={{ flex: "0 1 320px" }}>
+            <Group justify="space-between" mb={4} gap={4}>
+              <Group gap={6} align="center">
+                <Weight size={14} color={over ? "#B42318" : undefined} />
+                <Text size="xs" fw={600} c={over ? "red" : "dimmed"}>
+                  Load {used.toFixed(1)}T
+                  {capacity > 0 ? ` / ${capacity.toFixed(0)}T pull` : ""}
+                </Text>
+              </Group>
+              {over ? (
+                <Badge color="red" variant="light" size="sm" radius="sm">
+                  Over capacity
+                </Badge>
+              ) : (
+                <Text size="xs" c="dimmed">
+                  {capacity > 0 ? `${pct}%` : "—"}
+                </Text>
+              )}
+            </Group>
+            <Progress
+              value={capacity > 0 ? pct : 0}
+              color={over ? "red" : pct > 85 ? "orange" : "edr-green"}
+              radius="xl"
+              size="md"
+            />
+          </Box>
+        </Group>
+
+        {(() => {
+          const cd = phaseCountdown(schedule);
+          return cd ? (
+            <Group
+              gap={8}
+              p="xs"
+              wrap="nowrap"
+              align="center"
+              style={{
+                borderRadius: 10,
+                background: "var(--mantine-color-blue-0)",
+                border: "1px solid var(--mantine-color-blue-2)",
+              }}
+            >
+              <CountdownTimer deadline={cd.deadline} label={cd.label} size="sm" />
+            </Group>
+          ) : null;
+        })()}
+
+        {over ? (
+          <Group
+            gap={8}
+            p="xs"
+            wrap="nowrap"
+            align="center"
+            style={{
+              borderRadius: 10,
+              background: "var(--mantine-color-red-0)",
+              border: "1px solid var(--mantine-color-red-2)",
+            }}
+          >
+            <AlertTriangle size={16} color="#B42318" />
+            <Text size="xs" c="red.8" fw={500}>
+              This train is loaded beyond its locomotive pull weight. Force-adds are
+              allowed, but review before dispatch.
+            </Text>
+          </Group>
+        ) : null}
+
+        {locked ? (
+          <Text size="sm" c="dimmed">
+            This train is {schedule.status.toLowerCase()} — bookings can no longer be
+            changed.
+          </Text>
+        ) : null}
+
+        {/* Two-panel board */}
+        <Group align="stretch" gap="lg" grow wrap="wrap">
+          {/* Pool */}
+          <PanelColumn
+            title="Ready to pay"
+            hint="Accepted · this route & day"
+            count={pool.length}
+            accent="#F2A516"
+            loading={poolQuery.isLoading}
+            emptyIcon={Inbox}
+            emptyText="No ready-to-pay bookings waiting for this train."
+          >
+            {pool.map((b) => (
+              <BookingCard
+                key={b.id}
+                reference={b.reference}
+                customer={b.customer}
+                weightTons={b.weightTons}
+                status={b.status}
+                right={
+                  canManage ? (
+                    <Tooltip label="Force-add to this train" withArrow>
+                      <Button
+                        size="compact-sm"
+                        color="edr-green"
+                        radius="md"
+                        rightSection={<ArrowRight size={14} />}
+                        loading={assign.isPending}
+                        onClick={() => forceAdd(b.id, b.reference, b.weightTons)}
+                      >
+                        Add
+                      </Button>
+                    </Tooltip>
+                  ) : null
+                }
+              />
+            ))}
+          </PanelColumn>
+
+          {/* On train */}
+          <PanelColumn
+            title="On this train"
+            hint="Allocated bookings"
+            count={onTrain.length}
+            accent="#0EA371"
+            emptyIcon={Train}
+            emptyText="No bookings allocated yet. Add one from the pool."
+          >
+            {onTrain.map((b) => (
+              <BookingCard
+                key={b.id}
+                reference={b.reference ?? b.id.slice(0, 8)}
+                customer={b.customer}
+                weightTons={b.weightTons}
+                status={b.status}
+                right={
+                  canManage ? (
+                    <Group gap={6} wrap="nowrap" justify="flex-end">
+                      <Tooltip label="Reassign to another train" withArrow>
+                        <Button
+                          size="compact-sm"
+                          variant="subtle"
+                          color="orange"
+                          radius="md"
+                          leftSection={<Repeat size={13} />}
+                          onClick={() => {
+                            setMoveBookingId(b.id);
+                            setMoveTarget(null);
+                          }}
+                        >
+                          Move
+                        </Button>
+                      </Tooltip>
+                      <Tooltip label="Remove from this train" withArrow>
+                        <Button
+                          size="compact-sm"
+                          variant="light"
+                          color="red"
+                          radius="md"
+                          leftSection={<X size={13} />}
+                          loading={unassign.isPending}
+                          onClick={() =>
+                            removeFromTrain(b.id, b.reference ?? b.id.slice(0, 8))
+                          }
+                        >
+                          Remove
+                        </Button>
+                      </Tooltip>
+                    </Group>
+                  ) : null
+                }
+              />
+            ))}
+          </PanelColumn>
+        </Group>
+      </Stack>
+
+      {/* Reassign modal */}
+      <Modal
+        opened={Boolean(moveBookingId)}
+        onClose={() => setMoveBookingId(null)}
+        title={
+          <Group gap={8}>
+            <ArrowLeftRight size={18} />
+            <Text fw={700}>Reassign booking to another train</Text>
+          </Group>
+        }
+        centered
+        radius="lg"
+      >
+        <Stack gap="md">
+          <Select
+            label="Target train (same route, open window)"
+            placeholder="Select an open schedule"
+            data={moveOptions}
+            value={moveTarget}
+            onChange={setMoveTarget}
+            searchable
+            nothingFoundMessage="No other open schedules on this route"
+          />
+          <Group justify="flex-end">
+            <Button variant="default" onClick={() => setMoveBookingId(null)}>
+              Cancel
+            </Button>
+            <Button
+              color="edr-green"
+              disabled={!moveTarget}
+              loading={moveSchedule.isPending}
+              leftSection={<CheckCircle2 size={16} />}
+              onClick={doMove}
+            >
+              Reassign
+            </Button>
+          </Group>
+        </Stack>
+      </Modal>
+    </Paper>
+  );
+}
+
+// ── Sub-components ───────────────────────────────────────────────────────────
+
+function PanelColumn({
+  title,
+  hint,
+  count,
+  accent,
+  loading,
+  emptyIcon: EmptyIcon,
+  emptyText,
+  children,
+}: {
+  title: string;
+  hint: string;
+  count: number;
+  accent: string;
+  loading?: boolean;
+  emptyIcon: typeof Inbox;
+  emptyText: string;
+  children: React.ReactNode;
+}) {
+  const isEmpty = !loading && count === 0;
+  return (
+    <Paper
+      radius="lg"
+      withBorder
+      p="md"
+      miw={280}
+      style={{
+        flex: 1,
+        borderColor: "var(--mantine-color-gray-2)",
+        background: `linear-gradient(180deg, ${accent}0A 0%, transparent 90px)`,
+      }}
+    >
+      <Group justify="space-between" align="center" mb="sm">
+        <Group gap={8} align="center">
+          <Box w={8} h={8} style={{ borderRadius: 999, background: accent }} />
+          <Text fw={700} size="sm">
+            {title}
+          </Text>
+          <Badge variant="light" color="gray" radius="sm" size="sm">
+            {count}
+          </Badge>
+        </Group>
+        <Text size="xs" c="dimmed">
+          {hint}
+        </Text>
+      </Group>
+
+      {isEmpty ? (
+        <Stack align="center" gap={6} py={32}>
+          <EmptyIcon size={24} color="var(--mantine-color-gray-4)" />
+          <Text size="xs" c="dimmed" ta="center" maw={220}>
+            {emptyText}
+          </Text>
+        </Stack>
+      ) : (
+        <ScrollArea.Autosize mah={420} type="hover">
+          <Stack gap={8} pr={4}>
+            {loading ? (
+              <Text size="xs" c="dimmed" py="md" ta="center">
+                Loading…
+              </Text>
+            ) : (
+              children
+            )}
+          </Stack>
+        </ScrollArea.Autosize>
+      )}
+    </Paper>
+  );
+}
+
+function BookingCard({
+  reference,
+  customer,
+  weightTons,
+  status,
+  right,
+}: {
+  reference: string;
+  customer?: string | null;
+  weightTons?: number | null;
+  status?: string | null;
+  right?: React.ReactNode;
+}) {
+  return (
+    <Paper
+      radius="md"
+      withBorder
+      p="sm"
+      style={{
+        borderColor: "var(--mantine-color-gray-2)",
+        transition: "border-color 120ms ease, box-shadow 120ms ease",
+      }}
+      onMouseEnter={(e) => {
+        e.currentTarget.style.borderColor = GREEN;
+      }}
+      onMouseLeave={(e) => {
+        e.currentTarget.style.borderColor = "var(--mantine-color-gray-2)";
+      }}
+    >
+      <Group justify="space-between" align="center" wrap="nowrap" gap="sm">
+        <Stack gap={3} style={{ minWidth: 0 }}>
+          <Group gap={8} align="center" wrap="nowrap">
+            <Text size="sm" fw={700} truncate>
+              {reference}
+            </Text>
+            {status ? <BookingStatusBadge status={status} /> : null}
+          </Group>
+          <Group gap={10} align="center" wrap="nowrap">
+            <Text size="xs" c="dimmed" truncate>
+              {customer ?? "—"}
+            </Text>
+            {weightTons != null ? (
+              <Group gap={3} align="center" wrap="nowrap">
+                <Weight size={11} color="var(--mantine-color-gray-5)" />
+                <Text size="xs" c="dimmed">
+                  {Number(weightTons).toFixed(1)}T
+                </Text>
+              </Group>
+            ) : null}
+          </Group>
+        </Stack>
+        {right ? <Box style={{ flexShrink: 0 }}>{right}</Box> : null}
+      </Group>
+    </Paper>
+  );
+}
diff --git a/apps/edr-freight-web/backoffice/src/components/warehouses/CreateWarehouseModal.tsx b/apps/edr-freight-web/backoffice/src/components/warehouses/CreateWarehouseModal.tsx
index ad8b4109d..6494906b4 100644
--- a/apps/edr-freight-web/backoffice/src/components/warehouses/CreateWarehouseModal.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/warehouses/CreateWarehouseModal.tsx
@@ -14,7 +14,7 @@ import { useMutation, useQuery } from '@tanstack/react-query';
 import { api } from '@/services/api';
 import { useToast } from '@/hooks/use-toast';
 import type { SaveWarehousePayload, Warehouse, WarehouseType } from '@/types/warehouse';
-import { extractErrorMessage, statusOptions, warehouseTypeOptions } from './options';
+import { extractErrorMessage, lettersOnly, statusOptions, warehouseTypeOptions } from './options';
 
 interface CreateWarehouseModalProps {
   opened: boolean;
@@ -120,7 +120,7 @@ export function CreateWarehouseModal({ opened, onClose, warehouse }: CreateWareh
             placeholder="Modjo Open Warehouse"
             required
             value={form.name}
-            onChange={(e) => { const v = e.currentTarget.value; setForm((f) => ({ ...f, name: v })); }}
+            onChange={(e) => { const v = lettersOnly(e.currentTarget.value); setForm((f) => ({ ...f, name: v })); }}
           />
           <TextInput
             label="Code"
diff --git a/apps/edr-freight-web/backoffice/src/components/warehouses/options.ts b/apps/edr-freight-web/backoffice/src/components/warehouses/options.ts
index aba631d33..42663877d 100644
--- a/apps/edr-freight-web/backoffice/src/components/warehouses/options.ts
+++ b/apps/edr-freight-web/backoffice/src/components/warehouses/options.ts
@@ -48,6 +48,9 @@ export const formatDate = (value: string | null | undefined) => {
   });
 };
 
+// Name fields (warehouse / fee rule / allocation rule) accept letters and spaces only — no numbers.
+export const lettersOnly = (value: string) => value.replace(/[^A-Za-z\s]/g, '');
+
 export const extractErrorMessage = (error: unknown, fallback = 'Something went wrong') => {
   const responseData = (error as { response?: { data?: unknown } })?.response?.data;
   const data = responseData && typeof responseData === 'object' ? (responseData as Record<string, unknown>) : undefined;
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 70a134396..bd1c51e47 100644
--- a/apps/edr-freight-web/backoffice/src/constants/QUERY_KEYS.ts
+++ b/apps/edr-freight-web/backoffice/src/constants/QUERY_KEYS.ts
@@ -70,7 +70,6 @@ export const QUERY_KEYS = {
       ["contracts", "clearance-queue", region ?? "ET"] as const,
     clearanceHistory: (region?: string) =>
       ["contracts", "clearance-history", region ?? "ET"] as const,
-    djSchedules: ["contracts", "clearance-dj-schedules"] as const,
     milestones: (id: string) => ["contracts", "milestones", id] as const,
     capacity: (id: string) => ["contracts", "capacity", id] as const,
     bookingMilestones: (bookingId: string) =>
@@ -109,6 +108,8 @@ export const QUERY_KEYS = {
       ["train-scheduling", "unassigned", id] as const,
     compositionRemovals: (id: string) =>
       ["train-scheduling", "removals", id] as const,
+    importLoadingBookings: (id: string) =>
+      ["train-scheduling", "import-loading-bookings", id] as const,
   },
 
   FLEET: {
diff --git a/apps/edr-freight-web/backoffice/src/constants/URLS.ts b/apps/edr-freight-web/backoffice/src/constants/URLS.ts
index 083dd0efc..8112b4299 100644
--- a/apps/edr-freight-web/backoffice/src/constants/URLS.ts
+++ b/apps/edr-freight-web/backoffice/src/constants/URLS.ts
@@ -201,6 +201,7 @@ export const URL_CONSTANTS = {
     CLEARANCE_HISTORY: "/contracts/clearance/history",
     OPS_CLEARANCE_HISTORY: "/contracts/clearance/ops-history",
     BOOKINGS: (id: string) => `/contracts/${id}/bookings`,
+    VALIDATE_SHIPMENT: (id: string) => `/contracts/${id}/validate-shipment`,
     CAPACITY: (id: string) => `/contracts/${id}/capacity`,
     // Shipment requests (GENERAL + customs, Path B): customer → GL queue → booking.
     BOOKING_REQUEST_QUEUE: "/contracts/booking-requests/queue",
@@ -231,11 +232,6 @@ export const URL_CONSTANTS = {
       `/contracts/bookings/${bookingId}/t1-documents`,
     BOOKING_T1_CLOSE: (bookingId: string) =>
       `/contracts/bookings/${bookingId}/t1-close`,
-    CLEARANCE_DJ_SCHEDULES: "/contracts/clearance/dj-schedules",
-    CLEARANCE_SCHEDULE_GATEPASS: (scheduleId: string) =>
-      `/contracts/clearance/schedules/${scheduleId}/gatepass`,
-    BOOKING_GATEPASS: (bookingId: string) =>
-      `/contracts/bookings/${bookingId}/gatepass`,
     BOOKING_FINAL_INVOICE: (bookingId: string) =>
       `/contracts/bookings/${bookingId}/final-invoice`,
     BOOKING_FINAL_INVOICE_CONFIRM: (bookingId: string) =>
@@ -281,11 +277,12 @@ export const URL_CONSTANTS = {
       `/train-scheduling/schedules/${id}/run-allocation`,
     DOC_REVIEW_COMPLETE: (id: string) =>
       `/train-scheduling/schedules/${id}/doc-review-complete`,
-    RUN_ALLOCATION: (id: string) => `/train-scheduling/schedules/${id}/run-allocation`,
     ASSIGN_UNASSIGNED_BOOKING: (id: string) =>
       `/train-scheduling/schedules/${id}/assign-unassigned-booking`,
     BOOKING_WINDOW: (id: string) =>
       `/train-scheduling/schedules/${id}/booking-window`,
+    CONTRACT_BOOKING_WINDOWS: (contractId: string) =>
+      `/train-scheduling/contracts/${contractId}/booking-windows`,
     MARK_BOOKING_PAID: (bookingId: string) =>
       `/train-scheduling/bookings/${bookingId}/mark-paid`,
     EXPIRE_BOOKING: (bookingId: string) =>
@@ -293,6 +290,7 @@ export const URL_CONSTANTS = {
     MOVE_BOOKING_SCHEDULE: (bookingId: string) =>
       `/train-scheduling/bookings/${bookingId}/move-schedule`,
     GLOBAL_RULES: "/train-scheduling/global-rules",
+    BOOKING_WINDOWS: "/train-scheduling/booking-windows",
     PREVIEW: "/train-scheduling/preview",
     ASSIGN_BOOKINGS: (id: string) =>
       `/train-scheduling/schedules/${id}/assign-bookings`,
@@ -322,6 +320,10 @@ export const URL_CONSTANTS = {
     PIN_WAGONS: (id: string) => `/train-scheduling/schedules/${id}/pin-wagons`,
     FINALIZE: (id: string) => `/train-scheduling/schedules/${id}/finalize`,
     DISPATCH: (id: string) => `/train-scheduling/schedules/${id}/dispatch`,
+    IMPORT_LOADING_BOOKINGS: (id: string) =>
+      `/train-scheduling/schedules/${id}/import-loading-bookings`,
+    IMPORT_LOADING_STATUS: (id: string) =>
+      `/train-scheduling/schedules/${id}/import-loading-status`,
     IMPORT_DJIBOUTI: (id: string) =>
       `/train-scheduling/schedules/${id}/import-djibouti`,
     IMPORT_DJIBOUTI_DOCUMENTS: (id: string) =>
diff --git a/apps/edr-freight-web/backoffice/src/features/bookings/booking-actions.config.ts b/apps/edr-freight-web/backoffice/src/features/bookings/booking-actions.config.ts
index 66bb9b1ea..818a82c52 100644
--- a/apps/edr-freight-web/backoffice/src/features/bookings/booking-actions.config.ts
+++ b/apps/edr-freight-web/backoffice/src/features/bookings/booking-actions.config.ts
@@ -2,7 +2,6 @@ import type { LucideIcon } from "lucide-react";
 import {
   Ban,
   Check,
-  FileSignature,
   MessageSquareWarning,
   Play,
   ShieldCheck,
@@ -211,29 +210,6 @@ const CANCEL_ACTION: BookingActionDef = {
   inputPlaceholder: "Reason for cancellation…",
 };
 
-const VIEW_CONTRACT_ACTION: BookingActionDef = {
-  id: "viewContract",
-  label: "View contract",
-  shortLabel: "Contract",
-  description: "Open contract document and signatures",
-  confirmTitle: "",
-  confirmDescription: "",
-  variant: "outline",
-  icon: FileSignature,
-};
-
-const SIGN_CONTRACT_STAFF_ACTION: BookingActionDef = {
-  id: "signContractStaff",
-  label: "Sign contract",
-  shortLabel: "Sign",
-  description: "Open contract page and apply staff counter-signature",
-  confirmTitle: "",
-  confirmDescription: "",
-  variant: "default",
-  icon: FileSignature,
-  primary: true,
-};
-
 // Opens the booking detail straight on the Clearance tab so Marketing can
 // review the customer's clearance documents (non-customs bookings only).
 const REVIEW_CLEARANCE_ACTION: BookingActionDef = {
@@ -340,22 +316,14 @@ export function getBookingActions(
       actions = withCancel(approvalActions(approvalSteps));
       break;
     case "APPROVED":
-      actions = [{ ...VIEW_CONTRACT_ACTION, primary: true }, CANCEL_ACTION];
+      actions = [CANCEL_ACTION];
       break;
     case "CONTRACT_READY":
-      actions = [{ ...VIEW_CONTRACT_ACTION, primary: true }];
-      break;
     case "SIGNED_CUSTOMER":
-      actions = [SIGN_CONTRACT_STAFF_ACTION, VIEW_CONTRACT_ACTION];
-      break;
     case "FULLY_EXECUTED":
-      actions = [
-        {
-          ...VIEW_CONTRACT_ACTION,
-          label: "View executed contract",
-          primary: true,
-        },
-      ];
+      // Contract view/sign/executed buttons intentionally removed from the
+      // booking-request page.
+      actions = [];
       break;
     case "AWAITING_DOCUMENTS":
     case "DOCUMENTS_UNDER_REVIEW":
diff --git a/apps/edr-freight-web/backoffice/src/features/bookings/mapBookingListRow.ts b/apps/edr-freight-web/backoffice/src/features/bookings/mapBookingListRow.ts
index ec4708868..a5bc34170 100644
--- a/apps/edr-freight-web/backoffice/src/features/bookings/mapBookingListRow.ts
+++ b/apps/edr-freight-web/backoffice/src/features/bookings/mapBookingListRow.ts
@@ -18,6 +18,7 @@ export function toBookingListRow(booking: BookingDetail): BookingListRow {
   return {
     id: booking.id,
     reference: booking.reference,
+    contractReference: booking.contractReference ?? null,
     approvalSteps: booking.approvalSteps,
     customerLabel: booking.isGovernment
       ? (booking.governmentInstitution ?? "Government")
diff --git a/apps/edr-freight-web/backoffice/src/hooks/bookings/useBookings.ts b/apps/edr-freight-web/backoffice/src/hooks/bookings/useBookings.ts
index 8ea6f6f27..1dc2b13ef 100644
--- a/apps/edr-freight-web/backoffice/src/hooks/bookings/useBookings.ts
+++ b/apps/edr-freight-web/backoffice/src/hooks/bookings/useBookings.ts
@@ -78,7 +78,13 @@ export function useBookingMutations(bookingId: string) {
       note?: string;
     }) => api.bookings.reviewOperation.call({ id: bookingId, ...payload }),
     onSuccess: (data) => onSuccess(data, "Operation request reviewed"),
-    onError: () => toast.error("Failed to review operation request"),
+    onError: (error) => {
+      toast.error(parseApiError(error, "Failed to review operation request"));
+      // The transition may have committed even when the response errored (e.g.
+      // a post-accept step failed). Refetch so the UI shows the true state
+      // instead of requiring a manual refresh.
+      void invalidateBookingDetail(qc, bookingId);
+    },
   });
 
   const approveStep = useMutation({
diff --git a/apps/edr-freight-web/backoffice/src/hooks/contracts/useContracts.ts b/apps/edr-freight-web/backoffice/src/hooks/contracts/useContracts.ts
index 56229415f..04a4720aa 100644
--- a/apps/edr-freight-web/backoffice/src/hooks/contracts/useContracts.ts
+++ b/apps/edr-freight-web/backoffice/src/hooks/contracts/useContracts.ts
@@ -68,15 +68,6 @@ export function useDjClearanceQueue(enabled = true) {
   });
 }
 
-/** Train schedules carrying customs bookings — GL DJ gate-pass table. */
-export function useDjClearanceSchedules(enabled = true) {
-  return useQuery({
-    queryKey: QUERY_KEYS.CONTRACTS.djSchedules,
-    queryFn: () => contractsService.getDjClearanceSchedules(),
-    enabled,
-  });
-}
-
 /** Path A self-clearance queue (Operations reviews non-customs contracts). */
 export function useOpsClearanceQueue(enabled = true) {
   return useQuery({
diff --git a/apps/edr-freight-web/backoffice/src/hooks/rule-engine/useRuleEngine.ts b/apps/edr-freight-web/backoffice/src/hooks/rule-engine/useRuleEngine.ts
index ad16feac3..dcc8b21ed 100644
--- a/apps/edr-freight-web/backoffice/src/hooks/rule-engine/useRuleEngine.ts
+++ b/apps/edr-freight-web/backoffice/src/hooks/rule-engine/useRuleEngine.ts
@@ -174,6 +174,23 @@ export const useContainerTypeOptions = (
       buildContainerTypeSelectOptions(result.data ?? [], includeNone),
   });
 
+/**
+ * Active wagon-type options for the cargo-type / container-type "Wagon type"
+ * picker. The FK the selection sets drives train-scheduling wagon resolution.
+ */
+export const useWagonTypeOptions = (enabled = true) =>
+  useQuery({
+    ...api.wagonTypes.list.queryOptions(),
+    enabled,
+    select: (rows: { id: string; code: string; name: string; isActive?: boolean }[]) =>
+      rows
+        .filter((wt) => wt.isActive !== false)
+        .map((wt) => ({
+          label: wt.name ? `${wt.name} (${wt.code})` : wt.code,
+          value: wt.id,
+        })),
+  });
+
 const LIVE_RATE_PAGE_SIZE = 500;
 
 export const useLiveRateOptions = (enabled = true) =>
diff --git a/apps/edr-freight-web/backoffice/src/hooks/use-toast.ts b/apps/edr-freight-web/backoffice/src/hooks/use-toast.ts
index 7b15a028d..48acaa38d 100644
--- a/apps/edr-freight-web/backoffice/src/hooks/use-toast.ts
+++ b/apps/edr-freight-web/backoffice/src/hooks/use-toast.ts
@@ -1,3 +1,4 @@
+import { useCallback } from 'react';
 import toast from 'react-hot-toast';
 
 interface ToastOptions {
@@ -8,7 +9,9 @@ interface ToastOptions {
 }
 
 export function useToast() {
-  const showToast = (options: ToastOptions) => {
+  // Stable identity so callers can safely list `toast` in effect/callback deps
+  // without re-firing on every render.
+  const showToast = useCallback((options: ToastOptions) => {
     const { title, description, variant = 'default', duration = 3000 } = options;
 
     const message = title ? `${title}${description ? ': ' + description : ''}` : description || '';
@@ -18,7 +21,7 @@ export function useToast() {
     } else {
       toast.success(message, { duration });
     }
-  };
+  }, []);
 
   return { toast: showToast };
 }
diff --git a/apps/edr-freight-web/backoffice/src/lib/permissions.ts b/apps/edr-freight-web/backoffice/src/lib/permissions.ts
index 9fe564312..0abb91e99 100644
--- a/apps/edr-freight-web/backoffice/src/lib/permissions.ts
+++ b/apps/edr-freight-web/backoffice/src/lib/permissions.ts
@@ -73,15 +73,23 @@ export function getPermissionKeys(user: AuthUser | null | undefined): string[] {
   return [...keys];
 }
 
-/** Position keys held by the user (e.g. "ethiopian_gl", "djibouti_gl"). */
+/**
+ * Position keys held by the user (e.g. "ethiopian_gl", "djibouti_gl").
+ * Tolerates IAM payload shape variants: the key flat on the employee position,
+ * nested under `position.key`, or the GL modeled as a role instead.
+ */
 export function getPositionKeys(user: AuthUser | null | undefined): string[] {
   if (!user) return [];
   const keys = new Set<string>();
   for (const emp of user.employee ?? []) {
     for (const pos of emp.positions ?? []) {
       if (pos.key) keys.add(pos.key);
+      if (pos.position?.key) keys.add(pos.position.key);
     }
   }
+  for (const role of user.roles ?? []) {
+    if (role.key) keys.add(role.key);
+  }
   return [...keys];
 }
 
diff --git a/apps/edr-freight-web/backoffice/src/lib/queryClient.ts b/apps/edr-freight-web/backoffice/src/lib/queryClient.ts
index 32b94f325..781ffba74 100644
--- a/apps/edr-freight-web/backoffice/src/lib/queryClient.ts
+++ b/apps/edr-freight-web/backoffice/src/lib/queryClient.ts
@@ -27,7 +27,6 @@ export const queryClient = new QueryClient({
   defaultOptions: {
     queries: {
       retry: 1,
-      refetchOnWindowFocus: false,
       staleTime: 30_000,
     },
   },
diff --git a/apps/edr-freight-web/backoffice/src/pages/FaydaCallbackPage.tsx b/apps/edr-freight-web/backoffice/src/pages/FaydaCallbackPage.tsx
new file mode 100644
index 000000000..5febb664a
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/pages/FaydaCallbackPage.tsx
@@ -0,0 +1,56 @@
+import { useEffect, useState } from "react";
+import { Center, Loader, Stack, Text } from "@mantine/core";
+
+import type { FaydaCallbackMessage } from "@/services/verifayda.service";
+
+/**
+ * Landing page for the eSignet redirect_uri (FAYDA_WEB_REDIRECT_URI →
+ * http://localhost:5183/callback). Runs inside the verification popup:
+ * relays ?code&state (or ?error) to the window that opened it via
+ * postMessage, then closes itself. The opener performs the /complete call
+ * so the single-use session is only consumed once, in one place.
+ */
+const FaydaCallbackPage = () => {
+  const [standalone, setStandalone] = useState(false);
+
+  useEffect(() => {
+    const params = new URLSearchParams(window.location.search);
+    const message: FaydaCallbackMessage = {
+      type: "fayda-callback",
+      code: params.get("code") ?? undefined,
+      state: params.get("state") ?? undefined,
+      error: params.get("error") ?? undefined,
+      errorDescription: params.get("error_description") ?? undefined,
+    };
+
+    if (window.opener && window.opener !== window) {
+      (window.opener as Window).postMessage(message, window.location.origin);
+      window.close();
+    } else {
+      // Opened as a full-page redirect instead of a popup — nothing to relay to.
+      setStandalone(true);
+    }
+  }, []);
+
+  return (
+    <Center h="100vh">
+      <Stack align="center" gap="sm">
+        {standalone ? (
+          <>
+            <Text fw={600}>Verification window lost its parent page</Text>
+            <Text size="sm" c="dimmed">
+              Close this tab and restart the verification from the form.
+            </Text>
+          </>
+        ) : (
+          <>
+            <Loader size="sm" />
+            <Text size="sm" c="dimmed">Completing Fayda verification…</Text>
+          </>
+        )}
+      </Stack>
+    </Center>
+  );
+};
+
+export default FaydaCallbackPage;
diff --git a/apps/edr-freight-web/backoffice/src/pages/auth/LoginPage.tsx b/apps/edr-freight-web/backoffice/src/pages/auth/LoginPage.tsx
index 89e8557c3..849049bc2 100644
--- a/apps/edr-freight-web/backoffice/src/pages/auth/LoginPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/auth/LoginPage.tsx
@@ -1,162 +1,40 @@
 import { type FormEvent, useState } from "react";
 import {
-  Eye,
-  EyeOff,
-  ArrowUpRight,
-  Globe,
-  ChevronDown,
-} from "lucide-react";
+  Alert,
+  Box,
+  Button,
+  Center,
+  Group,
+  Image,
+  PasswordInput,
+  PinInput,
+  Stack,
+  Text,
+  TextInput,
+  Title,
+} from "@mantine/core";
+import { AlertCircle, ArrowLeft } from "lucide-react";
 import { useNavigate } from "react-router-dom";
 
 import { useAuth } from "@/auth/useAuth";
+import AuthShell from "@/components/auth/AuthShell";
+import { extractApiError } from "@/utils/result";
 
 /** Normalise Ethiopian local phone (09…/07…) to E.164; pass email through unchanged. */
 const normaliseIdentifier = (raw: string): string => {
   const v = raw.trim();
   const digits = v.replace(/\D/g, "");
   if (digits.length >= 9 && (v.startsWith("0") || v.startsWith("+251"))) {
-    const local = digits.startsWith("251") ? digits.slice(3) : digits.replace(/^0/, "");
+    const local = digits.startsWith("251")
+      ? digits.slice(3)
+      : digits.replace(/^0/, "");
     return `+251${local}`;
   }
   return v.toLowerCase();
 };
 
-const LOGIN_IMAGE = "/assets/login.png";
 const EDR_LOGO = "/assets/logo.svg";
 
-const fieldClass =
-  "h-11 w-full rounded-xl border border-gray-200/90 bg-white px-4 text-sm text-gray-900 shadow-sm placeholder:text-gray-400 outline-none transition-all duration-200 hover:border-gray-300 focus:border-primary focus:bg-white focus:ring-4 focus:ring-primary/10";
-
-const primaryButtonClass =
-  "h-11 w-full rounded-full bg-primary text-sm font-semibold text-primary-foreground shadow-[0_8px_20px_-6px_rgba(16,94,52,0.5)] transition-all duration-200 hover:bg-primary/90 hover:shadow-[0_10px_24px_-6px_rgba(16,94,52,0.55)] active:scale-[0.99] disabled:cursor-not-allowed disabled:opacity-60 disabled:shadow-none";
-
-const LeftPanelDecor = () => (
-  <div
-    className="pointer-events-none absolute inset-0 overflow-hidden"
-    aria-hidden
-  >
-    <svg
-      className="absolute -bottom-24 -left-24 h-[420px] w-[420px] text-white/[0.07]"
-      viewBox="0 0 400 400"
-      fill="none"
-    >
-      {[0, 1, 2, 3, 4, 5].map((ring) => (
-        <circle
-          key={ring}
-          cx="200"
-          cy="200"
-          r={60 + ring * 36}
-          stroke="currentColor"
-          strokeWidth="1"
-        />
-      ))}
-    </svg>
-    <div className="absolute right-0 top-0 h-40 w-40 rounded-full bg-white/[0.06] blur-2xl" />
-  </div>
-);
-
-const RightPanelDecor = () => (
-  <div
-    className="pointer-events-none absolute inset-0 overflow-hidden"
-    aria-hidden
-  >
-    <div className="absolute -right-16 -top-20 h-56 w-56 rounded-full bg-primary/[0.06] blur-3xl" />
-    <div className="absolute -bottom-12 left-1/4 h-40 w-40 rounded-full bg-primary/[0.04] blur-2xl" />
-    <svg
-      className="absolute inset-0 h-full w-full text-gray-200/40"
-      xmlns="http://www.w3.org/2000/svg"
-    >
-      <defs>
-        <pattern
-          id="login-grid"
-          width="28"
-          height="28"
-          patternUnits="userSpaceOnUse"
-        >
-          <circle cx="1" cy="1" r="0.75" fill="currentColor" />
-        </pattern>
-      </defs>
-      <rect width="100%" height="100%" fill="url(#login-grid)" />
-    </svg>
-  </div>
-);
-
-const LeftPanel = () => (
-  <div className="relative hidden shrink-0 flex-col overflow-hidden rounded-2xl shadow-[0_8px_32px_rgba(15,23,42,0.1)] lg:flex lg:h-auto lg:min-h-0 lg:flex-1 lg:basis-1/2 lg:rounded-[28px]">
-    <img
-      src={LOGIN_IMAGE}
-      alt="Ethio Djibouti Railway"
-      className="absolute inset-0 h-full w-full object-cover object-center"
-    />
-    <div className="absolute inset-0 bg-gradient-to-br from-[#0a2e1a]/92 via-[#0f4a2a]/55 to-[#1a5c34]/45" />
-    <LeftPanelDecor />
-
-    <div className="relative z-10 flex shrink-0 items-center justify-between px-4 pt-4 sm:px-6 sm:pt-6 lg:px-8 lg:pt-8">
-      <img
-        src={EDR_LOGO}
-        alt="EDR Freight"
-        className="h-7 w-auto brightness-0 invert sm:h-9"
-      />
-      <a
-        href="#"
-        className="flex items-center gap-1.5 rounded-full border border-white/70 bg-white/10 px-3 py-1.5 text-xs font-medium text-white backdrop-blur-sm transition-colors hover:bg-white/20 sm:px-4 sm:py-2 sm:text-sm"
-      >
-        Support
-        <ArrowUpRight className="h-3.5 w-3.5 sm:h-4 sm:w-4" />
-      </a>
-    </div>
-
-    <div className="relative z-10 mt-auto hidden px-8 pb-8 lg:block">
-      <div className="max-w-md rounded-2xl border border-white/15 bg-black/30 p-5 backdrop-blur-md">
-        <div className="mb-2 flex items-center gap-2">
-          <div className="h-2 w-2 shrink-0 rounded-full bg-primary" />
-          <span className="text-sm font-semibold text-white">
-            Empower Your Freight Operations
-          </span>
-        </div>
-        <p className="text-sm leading-relaxed text-white/85">
-          Sign in to manage bookings, track cargo, and run logistics operations
-          on the Ethio Djibouti Railway freight platform.
-        </p>
-      </div>
-    </div>
-  </div>
-);
-
-const LanguageSelector = () => (
-  <div className="flex cursor-pointer items-center gap-1.5 rounded-full border border-gray-200/80 bg-white px-3 py-1.5 text-sm text-gray-600 shadow-sm">
-    <Globe className="h-4 w-4 text-gray-500" />
-    <span>Eng</span>
-    <ChevronDown className="h-4 w-4 text-gray-400" />
-  </div>
-);
-
-const FormFooter = () => (
-  <div className="relative z-10 flex shrink-0 flex-col items-center justify-between gap-3 border-t border-gray-100 px-4 py-4 text-xs text-gray-400 sm:flex-row sm:gap-4 sm:px-6 sm:py-4 lg:px-8 lg:pb-6">
-    <span className="shrink-0">© 2026 EDR Freight</span>
-    <div className="flex flex-wrap items-center justify-center gap-3 sm:justify-end sm:gap-6">
-      <a
-        href="#"
-        className="font-semibold text-gray-700 transition-colors hover:text-primary"
-      >
-        Terms & Conditions
-      </a>
-      <a
-        href="#"
-        className="font-semibold text-gray-700 transition-colors hover:text-primary"
-      >
-        Privacy Policy
-      </a>
-      <a
-        href="#"
-        className="font-semibold text-gray-700 transition-colors hover:text-primary"
-      >
-        Help & Support
-      </a>
-    </div>
-  </div>
-);
-
 const LoginPage = () => {
   const navigate = useNavigate();
   const { login, verifyMfa } = useAuth();
@@ -165,7 +43,6 @@ const LoginPage = () => {
   const [otp, setOtp] = useState("");
   const [needsMfa, setNeedsMfa] = useState(false);
   const [submitting, setSubmitting] = useState(false);
-  const [showPassword, setShowPassword] = useState(false);
   const [normalizedIdentifier, setNormalizedIdentifier] = useState("");
   const [error, setError] = useState<string | null>(null);
 
@@ -179,15 +56,14 @@ const LoginPage = () => {
       setNormalizedIdentifier(normalized);
 
       const result = await login({ email: normalized, password });
-      console.log(result);
       if (result.mfaRequired) {
         setNeedsMfa(true);
         return;
       }
 
       // navigate("/dashboard/overview", { replace: true });
-    } catch {
-      setError("Unable to sign in with those credentials.");
+    } catch (err) {
+      setError(extractApiError(err).message);
     } finally {
       setSubmitting(false);
     }
@@ -201,194 +77,132 @@ const LoginPage = () => {
     try {
       await verifyMfa({ email: normalizedIdentifier, otp: otp.trim() });
       navigate("/dashboard/overview", { replace: true });
-    } catch {
-      setError("Unable to verify the one-time code.");
+    } catch (err) {
+      setError(extractApiError(err).message);
     } finally {
       setSubmitting(false);
     }
   };
 
   const loginForm = (
-    <form className="flex w-full flex-col" onSubmit={handleSubmit}>
-      <div className="mb-4 flex justify-center sm:mb-6">
-        <img src={EDR_LOGO} alt="EDR Freight" className="h-9 w-auto sm:h-11" />
-      </div>
+    <Box component="form" onSubmit={handleSubmit}>
+      <Center mb={{ base: "md", sm: "lg" }}>
+        <Image src={EDR_LOGO} alt="EDR Freight" h={{ base: 36, sm: 44 }} w="auto" fit="contain" />
+      </Center>
 
-      <div className="mb-4 space-y-1.5 text-center sm:mb-5">
-        <h1 className="text-xl font-bold tracking-tight text-gray-900 sm:text-2xl">
-          Get Started
-        </h1>
-        <p className="text-sm leading-relaxed text-gray-500">
+      <Stack gap={6} mb={{ base: "md", sm: "lg" }} ta="center">
+        <Title order={1} fz={{ base: "xl", sm: "26px" }} fw={700} lh={1.2}>
+          Welcome back!
+        </Title>
+        <Text size="sm" c="dimmed">
           Log in to access the freight backoffice & explore all logistics
           resources.
-        </p>
-      </div>
+        </Text>
+      </Stack>
 
-      <div className="flex w-full flex-col gap-4">
-        <div className="space-y-1.5">
-          <label className="text-sm font-medium text-gray-800">
-            Email or Phone <span className="text-red-500">*</span>
-          </label>
-          <input
-            type="text"
-            value={identifier}
-            onChange={(event) => setIdentifier(event.target.value)}
-            placeholder="name@company.com or 09XXXXXXXX"
-            autoComplete="username"
-            className={fieldClass}
-          />
-        </div>
+      <Stack gap="md">
+        <TextInput
+          label="Email or Phone"
+          placeholder="name@company.com or 09XXXXXXXX"
+          autoComplete="username"
+          required
+          disabled={submitting}
+          value={identifier}
+          onChange={(event) => setIdentifier(event.target.value)}
+        />
 
-        <div className="space-y-1.5">
-          <label className="text-sm font-medium text-gray-800">
-            Password <span className="text-red-500">*</span>
-          </label>
-          <div className="relative">
-            <input
-              type={showPassword ? "text" : "password"}
-              value={password}
-              onChange={(event) => setPassword(event.target.value)}
-              placeholder="Enter your password"
-              className={`${fieldClass} pr-11`}
-            />
-            <button
-              type="button"
-              onClick={() => setShowPassword((current) => !current)}
-              className="absolute right-3 top-1/2 -translate-y-1/2 text-gray-400 transition-colors hover:text-gray-600"
-              aria-label={showPassword ? "Hide password" : "Show password"}
-            >
-              {showPassword ? (
-                <EyeOff className="h-5 w-5" />
-              ) : (
-                <Eye className="h-5 w-5" />
-              )}
-            </button>
-          </div>
-        </div>
+        <PasswordInput
+          label="Password"
+          placeholder="Enter your password"
+          required
+          disabled={submitting}
+          value={password}
+          onChange={(event) => setPassword(event.target.value)}
+        />
 
         {error ? (
-          <div className="rounded-lg border border-red-200 bg-red-50 px-3 py-2.5 text-sm text-red-700">
+          <Alert color="red" variant="light" icon={<AlertCircle size={18} />}>
             {error}
-          </div>
+          </Alert>
         ) : null}
 
-        <button
-          type="submit"
-          disabled={submitting}
-          className={primaryButtonClass}
-        >
-          {submitting ? "Signing in..." : "Sign In"}
-        </button>
-
-        <p className="text-center text-sm text-gray-500">
-          Need an account?{" "}
-          <a href="#" className="font-semibold text-primary hover:underline">
-            Contact your admin
-          </a>
-        </p>
-      </div>
-    </form>
+        <Button type="submit" color="edr-green" fullWidth loading={submitting}>
+          Sign In
+        </Button>
+      </Stack>
+    </Box>
   );
 
   const mfaForm = (
-    <form className="flex w-full flex-col" onSubmit={handleVerifyMfa}>
-      <div className="mb-4 flex justify-center sm:mb-6">
-        <img src={EDR_LOGO} alt="EDR Freight" className="h-9 w-auto sm:h-11" />
-      </div>
+    <Box component="form" onSubmit={handleVerifyMfa}>
+      <Center mb={{ base: "md", sm: "lg" }}>
+        <Image src={EDR_LOGO} alt="EDR Freight" h={{ base: 36, sm: 44 }} w="auto" fit="contain" />
+      </Center>
 
-      <div className="mb-4 space-y-1.5 text-center sm:mb-5">
-        <h1 className="text-xl font-bold tracking-tight text-gray-900 sm:text-2xl">
+      <Stack gap={6} mb={{ base: "md", sm: "lg" }} ta="center">
+        <Title order={1} fz={{ base: "xl", sm: "26px" }} fw={700} lh={1.2}>
           Multi-factor verification
-        </h1>
-        <p className="text-sm leading-relaxed text-gray-500">
+        </Title>
+        <Text size="sm" c="dimmed">
           We sent a verification code to{" "}
-          <span className="font-medium text-gray-700">
+          <Text component="span" fw={500} c="var(--mantine-color-text)">
             {normalizedIdentifier}
-          </span>
+          </Text>
           . Enter it below to complete sign in.
-        </p>
-      </div>
+        </Text>
+      </Stack>
 
-      <div className="flex w-full flex-col gap-4">
-        <div className="space-y-1.5">
-          <label className="text-sm font-medium text-gray-800">
-            Verification code <span className="text-red-500">*</span>
-          </label>
-          <input
+      <Stack gap="md">
+        <Stack gap={6} align="center">
+          <Text size="sm" fw={500} c="edr-text">
+            Verification code
+          </Text>
+          <PinInput
+            length={6}
+            type="number"
+            oneTimeCode
             value={otp}
-            onChange={(event) => setOtp(event.target.value)}
-            placeholder="Enter the code"
-            className={fieldClass}
+            placeholder="0"
+            disabled={submitting}
+            styles={{ input: { textAlign: "center" } }}
+            onChange={setOtp}
           />
-        </div>
+        </Stack>
 
         {error ? (
-          <div className="rounded-lg border border-red-200 bg-red-50 px-3 py-2.5 text-sm text-red-700">
+          <Alert color="red" variant="light" icon={<AlertCircle size={18} />}>
             {error}
-          </div>
+          </Alert>
         ) : null}
 
-        <div className="flex w-full gap-3">
-          <button
+        <Group grow>
+          <Button
             type="button"
+            variant="default"
+            leftSection={<ArrowLeft size={14} />}
+            disabled={submitting}
             onClick={() => {
               setNeedsMfa(false);
               setOtp("");
               setError(null);
             }}
-            className="h-11 min-w-0 flex-1 rounded-full border border-gray-200 bg-white text-sm font-semibold text-gray-700 transition-colors hover:border-gray-300 hover:bg-gray-50"
           >
             Back
-          </button>
-          <button
+          </Button>
+          <Button
             type="submit"
-            disabled={submitting}
-            className={`${primaryButtonClass} min-w-0 flex-1`}
+            color="edr-green"
+            loading={submitting}
+            disabled={otp.trim().length !== 6}
           >
-            {submitting ? "Verifying..." : "Verify"}
-          </button>
-        </div>
-      </div>
-    </form>
+            Verify
+          </Button>
+        </Group>
+      </Stack>
+    </Box>
   );
 
-  return (
-    <>
-      <link rel="preconnect" href="https://fonts.googleapis.com" />
-      <link rel="preconnect" href="https://fonts.gstatic.com" crossOrigin="" />
-      <link
-        href="https://fonts.googleapis.com/css2?family=Outfit:wght@400;500;600;700&display=swap"
-        rel="stylesheet"
-      />
-
-      <div
-        className="flex h-[100dvh] overflow-hidden bg-[#e8eaef] px-4 py-3 antialiased sm:px-6 sm:py-4 md:px-[70px]"
-        style={{ fontFamily: "'Outfit', var(--font-sans)" }}
-      >
-        <div className="flex h-full min-h-0 w-full flex-col gap-3 lg:flex-row lg:gap-4">
-          <LeftPanel />
-
-          <div className="relative flex min-h-0 min-w-0 flex-1 flex-col overflow-hidden rounded-2xl bg-[#f5f7fa] shadow-[0_8px_32px_rgba(15,23,42,0.08)] lg:basis-1/2 lg:rounded-[28px]">
-            <RightPanelDecor />
-
-            <div className="relative z-10 flex shrink-0 justify-end px-4 pt-4 sm:px-6 sm:pt-6 lg:px-8 lg:pt-8">
-              <LanguageSelector />
-            </div>
-
-            <div className="relative z-10 min-h-0 flex-1 overflow-y-auto overscroll-contain">
-              <div className="flex min-h-full justify-center px-4 py-4 sm:px-6 sm:py-6 lg:px-8 lg:py-8">
-                <div className="my-auto w-full max-w-xl  rounded-3xl border border-gray-100/80 bg-white px-5 py-6 shadow-[0_4px_24px_rgba(15,23,42,0.06)] sm:px-7 sm:py-8 lg:px-9 lg:py-9">
-                  {!needsMfa ? loginForm : mfaForm}
-                </div>
-              </div>
-            </div>
-
-            <FormFooter />
-          </div>
-        </div>
-      </div>
-    </>
-  );
+  return <AuthShell>{!needsMfa ? loginForm : mfaForm}</AuthShell>;
 };
 
 export default LoginPage;
diff --git a/apps/edr-freight-web/backoffice/src/pages/bookings/BookingDetailPage.tsx b/apps/edr-freight-web/backoffice/src/pages/bookings/BookingDetailPage.tsx
index d49e24f95..7408b9aca 100644
--- a/apps/edr-freight-web/backoffice/src/pages/bookings/BookingDetailPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/bookings/BookingDetailPage.tsx
@@ -18,8 +18,8 @@ import {
   type BookingDetailView,
 } from "@/components/bookings/detail";
 import Breadcrumbs from "@/components/ui/Breadcrumbs";
-import ContainerAllocationTable from "@/components/ContainerAllocationTable";
-import { api } from "@/services/api";
+import { ContainerAllocationTable } from "@/components/ContainerAllocationTable";
+import { api } from "@/auth/http";
 import { QUERY_KEYS } from "@/constants/QUERY_KEYS";
 
 const BookingDetailPage = () => {
@@ -160,9 +160,9 @@ const BookingDetailPage = () => {
                   type: c.containerType?.label ?? "Unknown",
                   qty: c.quantity,
                 }))}
-                onSave={(allocations) =>
-                  allocateMutation.mutateAsync({ allocations })
-                }
+                onSave={async (allocations) => {
+                  await allocateMutation.mutateAsync({ allocations });
+                }}
               />
               <BookingApprovalCard
                 steps={approvalSteps}
diff --git a/apps/edr-freight-web/backoffice/src/pages/bookings/BookingRequestDetailPage.tsx b/apps/edr-freight-web/backoffice/src/pages/bookings/BookingRequestDetailPage.tsx
index ebfe22cb7..d1830b45a 100644
--- a/apps/edr-freight-web/backoffice/src/pages/bookings/BookingRequestDetailPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/bookings/BookingRequestDetailPage.tsx
@@ -1,7 +1,6 @@
 import { useNavigate, useParams, useSearchParams } from "react-router-dom";
 import {
   ArrowLeft,
-  FileSignature,
   Layers,
   LayoutGrid,
   Milestone,
@@ -36,31 +35,19 @@ import {
   BookingCargoCard,
   BookingCompanyCard,
   BookingContractSummaryCard,
-  BookingDocumentsCard,
+  BookingContainerUnitsCard,
   ClearanceReviewSection,
   ContractOrdersPanel,
-  type BookingFileView,
 } from "@/components/bookings/detail";
 import { WarehouseInfoCard } from "@/components/warehouses";
 import { getStatusMeta } from "@/features/bookings/booking-status.config";
 import { toBookingListRow } from "@/features/bookings/mapBookingListRow";
 import type { BookingDetail } from "@/types/booking";
-import { downloadBookingFile } from "@/services/files.service";
 import {
   useBookingDetail,
   useBookingMutations,
 } from "@/hooks/bookings/useBookings";
 import { useScrollToHash } from "@/hooks/useScrollToHash";
-import toast from "react-hot-toast";
-
-// Signature / generated-contract files are surfaced on the contract page, not
-// in the booking's Documents list.
-const SIGNATURE_FILE_CODES = new Set([
-  "signature",
-  "signature_customer",
-  "signature_staff",
-  "contract",
-]);
 
 export default function BookingRequestDetailPage() {
   const { id } = useParams<{ id: string }>();
@@ -77,14 +64,6 @@ export default function BookingRequestDetailPage() {
   } = useBookingDetail(id);
   const mutations = useBookingMutations(id ?? "");
 
-  const handleDownloadFile = async (file: BookingFileView) => {
-    try {
-      await downloadBookingFile(file.id, file.name);
-    } catch {
-      toast.error("Could not download file.");
-    }
-  };
-
   if (isLoading) {
     return (
       <PageContainer>
@@ -149,11 +128,6 @@ export default function BookingRequestDetailPage() {
 
   const row = toBookingListRow(booking);
   const statusMeta = getStatusMeta(booking.status);
-  const showContractButton = [
-    "CONTRACT_READY",
-    "SIGNED_CUSTOMER",
-    "FULLY_EXECUTED",
-  ].includes(booking.status);
   const showApprovalCard =
     booking.status === "PENDING_APPROVAL" ||
     booking.status === "APPROVED_PENDING_SIGNATURE";
@@ -246,11 +220,7 @@ export default function BookingRequestDetailPage() {
                 </Tabs.List>
 
                 <Tabs.Panel value="overview">
-                  <OverviewPanel
-                    booking={booking}
-                    row={row}
-                    onDownload={handleDownloadFile}
-                  />
+                  <OverviewPanel booking={booking} row={row} />
                 </Tabs.Panel>
                 {isGeneralContract && (
                   <Tabs.Panel value="orders">
@@ -270,11 +240,7 @@ export default function BookingRequestDetailPage() {
                 )}
               </Tabs>
             ) : (
-              <OverviewPanel
-                booking={booking}
-                row={row}
-                onDownload={handleDownloadFile}
-              />
+              <OverviewPanel booking={booking} row={row} />
             )}
           </Grid.Col>
 
@@ -306,20 +272,6 @@ export default function BookingRequestDetailPage() {
                     View document clearance
                   </Button>
                 )}
-                {showContractButton && (
-                  <Button
-                    fullWidth
-                    color="edr-green"
-                    leftSection={<FileSignature size={16} />}
-                    onClick={() =>
-                      navigate(
-                        `/dashboard/booking-requests/${booking.id}/contract`,
-                      )
-                    }
-                  >
-                    View & sign contract
-                  </Button>
-                )}
                 {showApprovalCard && (
                   <ApprovalStepsCard booking={booking} mutations={mutations} />
                 )}
@@ -332,15 +284,13 @@ export default function BookingRequestDetailPage() {
   );
 }
 
-/** The booking's primary detail cards — route, services, cargo, contract, docs. */
+/** The booking's primary detail cards — route, services, cargo, containers. */
 function OverviewPanel({
   booking,
   row,
-  onDownload,
 }: {
   booking: BookingDetail;
   row: ReturnType<typeof toBookingListRow>;
-  onDownload: (file: BookingFileView) => void;
 }) {
   return (
     <Stack gap="lg">
@@ -351,15 +301,10 @@ function OverviewPanel({
       />
       <BookingMileServicesCard booking={booking} />
       <BookingCargoCard booking={booking} />
+      <BookingContainerUnitsCard booking={booking} />
       {booking.contractSummary && (
         <BookingContractSummaryCard summary={booking.contractSummary} />
       )}
-      <BookingDocumentsCard
-        files={(booking.files ?? []).filter(
-          (f) => !SIGNATURE_FILE_CODES.has(f.code ?? ""),
-        )}
-        onDownload={onDownload}
-      />
     </Stack>
   );
 }
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 d61a47139..477900ee1 100644
--- a/apps/edr-freight-web/backoffice/src/pages/bookings/BookingRequestsPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/bookings/BookingRequestsPage.tsx
@@ -4,6 +4,7 @@ import {
   Button,
   Card,
   Group,
+  Select,
   Stack,
   Tabs,
   Text,
@@ -30,17 +31,12 @@ import { BookingActionsMenu } from "@/components/bookings/BookingActionsMenu";
 import { BookingApprovalProgressCell } from "@/components/bookings/BookingApprovalProgressCell";
 import { BookingPriorityBadge } from "@/components/bookings/BookingPriorityBadge";
 import { BookingStatusBadge } from "@/components/bookings/BookingStatusBadge";
-import {
-  BookingStatusTabs,
-  type BookingStatusTabKey,
-} from "@/components/bookings/BookingStatusTabs";
+// BookingStatusTabs / Operations* queues removed — replaced by booking-kind tabs.
 import { BookingTableEmpty } from "@/components/bookings/BookingTableEmpty";
-import { OperationsBookingQueue } from "@/components/bookings/OperationsBookingQueue";
-import { OperationsScheduledBookings } from "@/components/bookings/OperationsScheduledBookings";
 import { bookingTable } from "@/components/bookings/booking-ui.styles";
 import { KpiStrip, PageContainer, PageHeader } from "@/components/page";
 import { AllocateBookingWizard } from "@/components/trainScheduling/AllocateBookingWizard";
-import { BOOKING_LIST_TABS } from "@/features/bookings/booking-status.config";
+import { BOOKING_STATUS_STYLES } from "@/features/bookings/booking-status.config";
 import { toBookingListRow } from "@/features/bookings/mapBookingListRow";
 import {
   useBookingDetail,
@@ -57,11 +53,29 @@ import {
   type ColumnDef,
 } from "@edr/ui-common";
 
-function getStatusesForTab(tab: BookingStatusTabKey): string | undefined {
-  const match = BOOKING_LIST_TABS.find((t) => t.key === tab);
-  if (!match?.statuses?.length) return undefined;
-  return match.statuses.join(",");
-}
+/** The two booking-kind tabs: one-time vs general-contract bookings. */
+type BookingKindTab = "ONE_TIME" | "GENERAL_CONTRACT";
+
+const BOOKING_KIND_TABS: { value: BookingKindTab; label: string }[] = [
+  { value: "ONE_TIME", label: "One-time booking" },
+  { value: "GENERAL_CONTRACT", label: "General booking" },
+];
+
+/** Status options for the filter select — built from the shared status styles. */
+const STATUS_OPTIONS = Object.entries(BOOKING_STATUS_STYLES).map(
+  ([value, { label }]) => ({ value, label }),
+);
+
+const TRADE_DIRECTION_OPTIONS = [
+  { value: "IMPORT", label: "Import" },
+  { value: "EXPORT", label: "Export" },
+  { value: "DOMESTIC", label: "Domestic" },
+];
+
+const FREIGHT_TYPE_OPTIONS = [
+  { value: "CONTAINER", label: "Container" },
+  { value: "BULK", label: "Bulk" },
+];
 
 function formatDate(value: string | null | undefined): string {
   if (!value) return "—";
@@ -75,14 +89,16 @@ function formatDate(value: string | null | undefined): string {
       });
 }
 
-type OperationsSubTab = "ready" | "scheduled";
-
 export default function BookingRequestsPage() {
   const navigate = useNavigate();
   const { pagination, setPagination } = usePagination({ pageSize: 10 });
   const [query, setQuery] = useState("");
-  const [activeTab, setActiveTab] = useState<BookingStatusTabKey>("all");
-  const [operationsSubTab, setOperationsSubTab] = useState<OperationsSubTab>("ready");
+  // Booking-kind tabs (one-time vs general contract) replace the old status tabs.
+  const [kindTab, setKindTab] = useState<BookingKindTab>("ONE_TIME");
+  // Per-tab filter selects (each nullable = "all").
+  const [statusFilter, setStatusFilter] = useState<string | null>(null);
+  const [directionFilter, setDirectionFilter] = useState<string | null>(null);
+  const [freightTypeFilter, setFreightTypeFilter] = useState<string | null>(null);
   const [allocateOpen, setAllocateOpen] = useState(false);
   const [allocateIds, setAllocateIds] = useState<string[]>([]);
   const suppressRowClickRef = useRef(false);
@@ -93,47 +109,26 @@ export default function BookingRequestsPage() {
     }, 400);
   }, []);
 
-  const tabStatuses = getStatusesForTab(activeTab);
-  const isOperationsTab = activeTab === "operations";
-
   const filter: BookingListFilter = useMemo(() => {
-    if (isOperationsTab) {
-      if (operationsSubTab === "ready") {
-        return {
-          page: 1,
-          pageSize: 100,
-          statuses: "PAID",
-          assignedToSchedule: "false",
-          sortBy: "createdAt",
-          sortOrder: "DESC",
-          tab: activeTab,
-        };
-      }
-      return {
-        page: 1,
-        pageSize: 100,
-        statuses: "PAID",
-        schedulingStatuses: "SCHEDULED,DISPATCHED",
-        sortBy: "scheduledDate",
-        sortOrder: "ASC",
-        tab: activeTab,
-      };
-    }
     return {
       page: pagination.pageIndex + 1,
       pageSize: pagination.pageSize,
       sortBy: "createdAt",
       sortOrder: "DESC",
-      tab: activeTab,
-      ...(tabStatuses ? { statuses: tabStatuses } : {}),
+      // React Query cache key per kind tab.
+      tab: kindTab,
+      bookingType: kindTab,
+      ...(statusFilter ? { statuses: statusFilter } : {}),
+      ...(directionFilter ? { tradeDirection: directionFilter } : {}),
+      ...(freightTypeFilter ? { freightType: freightTypeFilter } : {}),
     };
   }, [
-    isOperationsTab,
-    operationsSubTab,
     pagination.pageIndex,
     pagination.pageSize,
-    activeTab,
-    tabStatuses,
+    kindTab,
+    statusFilter,
+    directionFilter,
+    freightTypeFilter,
   ]);
 
   const { data, isLoading, isError, refetch, isFetching } = useBookingList(filter);
@@ -154,7 +149,8 @@ export default function BookingRequestsPage() {
     return items.filter(
       (b) =>
         b.reference.toLowerCase().includes(q) ||
-        b.customerLabel.toLowerCase().includes(q),
+        b.customerLabel.toLowerCase().includes(q) ||
+        (b.contractReference?.toLowerCase().includes(q) ?? false),
     );
   }, [data?.items, query]);
 
@@ -171,18 +167,6 @@ export default function BookingRequestsPage() {
     void refetchSummary();
   }, [refetch, refetchSummary]);
 
-  const handleAllocateFromQueue = useCallback(
-    (ids: string[]) => {
-      const selected = rows.filter((b) => ids.includes(b.id));
-      const sorted = [...selected].sort(
-        (a, b) => (b.priorityScore ?? 0) - (a.priorityScore ?? 0),
-      );
-      setAllocateIds(sorted.map((b) => b.id));
-      setAllocateOpen(true);
-    },
-    [rows],
-  );
-
   const handleRowClick = useCallback(
     (row: BookingListRow) => {
       if (suppressRowClickRef.current) return;
@@ -213,6 +197,22 @@ export default function BookingRequestsPage() {
         );
       },
     },
+    {
+      id: "contract",
+      header: () => <span className={bookingTable.headerCell}>Contract</span>,
+      cell: ({ row }) => {
+        const ref = row.original.contractReference;
+        return (
+          <div className="py-1">
+            {ref ? (
+              <span className="truncate font-mono text-xs text-foreground">{ref}</span>
+            ) : (
+              <span className="text-xs text-muted-foreground">—</span>
+            )}
+          </div>
+        );
+      },
+    },
     {
       id: "route",
       header: () => <span className={bookingTable.headerCell}>Route</span>,
@@ -356,6 +356,8 @@ export default function BookingRequestsPage() {
             ]}
           />
 
+          {/* Status tabs replaced by booking-kind tabs (one-time / general). The
+              old BookingStatusTabs is commented out — status is now a filter select.
           <BookingStatusTabs
             active={activeTab}
             onChange={(tab) => {
@@ -364,73 +366,97 @@ export default function BookingRequestsPage() {
             }}
             counts={tabCounts}
           />
+          */}
+
+          <Tabs
+            value={kindTab}
+            onChange={(value) => {
+              setKindTab((value as BookingKindTab) ?? "ONE_TIME");
+              setPagination({ pageIndex: 0, pageSize: pagination.pageSize });
+            }}
+          >
+            <Tabs.List>
+              {BOOKING_KIND_TABS.map((t) => (
+                <Tabs.Tab key={t.value} value={t.value}>
+                  {t.label}
+                </Tabs.Tab>
+              ))}
+            </Tabs.List>
+          </Tabs>
 
           <Card p={0}>
             <Stack gap={0}>
               <Box px="md" pt="md" pb="sm" w="100%">
-                <Group justify="space-between" gap="md" wrap="wrap">
-                  <TextInput
-                    placeholder="Search reference or customer…"
-                    leftSection={<Search size={18} />}
-                    value={query}
-                    onChange={(e) => setQuery(e.target.value)}
-                    rightSection={
-                      query && (
-                        <ActionIcon
-                          size="sm"
-                          color="gray"
-                          radius="md"
-                          variant="transparent"
-                          onClick={() => setQuery("")}
-                        >
-                          <X size={16} />
-                        </ActionIcon>
-                      )
-                    }
-                    style={{ flex: 1, minWidth: "200px" }}
-                    radius="lg"
-                  />
-                  <Text size="sm" c="dimmed">
-                    {total} record{total !== 1 ? "s" : ""}
-                  </Text>
-                </Group>
+                <Stack gap="sm">
+                  <Group justify="space-between" gap="md" wrap="wrap">
+                    <TextInput
+                      placeholder="Search booking, contract or customer…"
+                      leftSection={<Search size={18} />}
+                      value={query}
+                      onChange={(e) => setQuery(e.target.value)}
+                      rightSection={
+                        query && (
+                          <ActionIcon
+                            size="sm"
+                            color="gray"
+                            radius="md"
+                            variant="transparent"
+                            onClick={() => setQuery("")}
+                          >
+                            <X size={16} />
+                          </ActionIcon>
+                        )
+                      }
+                      style={{ flex: 1, minWidth: "200px" }}
+                      radius="lg"
+                    />
+                    <Text size="sm" c="dimmed">
+                      {total} record{total !== 1 ? "s" : ""}
+                    </Text>
+                  </Group>
+                  <Group gap="sm" wrap="wrap">
+                    <Select
+                      placeholder="All statuses"
+                      data={STATUS_OPTIONS}
+                      value={statusFilter}
+                      onChange={(v) => {
+                        setStatusFilter(v);
+                        setPagination({ pageIndex: 0, pageSize: pagination.pageSize });
+                      }}
+                      clearable
+                      searchable
+                      radius="lg"
+                      style={{ minWidth: 200 }}
+                    />
+                    <Select
+                      placeholder="All directions"
+                      data={TRADE_DIRECTION_OPTIONS}
+                      value={directionFilter}
+                      onChange={(v) => {
+                        setDirectionFilter(v);
+                        setPagination({ pageIndex: 0, pageSize: pagination.pageSize });
+                      }}
+                      clearable
+                      radius="lg"
+                      style={{ minWidth: 170 }}
+                    />
+                    <Select
+                      placeholder="All freight types"
+                      data={FREIGHT_TYPE_OPTIONS}
+                      value={freightTypeFilter}
+                      onChange={(v) => {
+                        setFreightTypeFilter(v);
+                        setPagination({ pageIndex: 0, pageSize: pagination.pageSize });
+                      }}
+                      clearable
+                      radius="lg"
+                      style={{ minWidth: 170 }}
+                    />
+                  </Group>
+                </Stack>
               </Box>
 
-              {isOperationsTab ? (
-                <Box px="md" pb="md">
-                  <Stack gap="md">
-                    <Tabs
-                      value={operationsSubTab}
-                      onChange={(value) =>
-                        setOperationsSubTab((value as OperationsSubTab) ?? "ready")
-                      }
-                    >
-                      <Tabs.List>
-                        <Tabs.Tab value="ready">Ready to allocate</Tabs.Tab>
-                        <Tabs.Tab value="scheduled">On train / scheduled</Tabs.Tab>
-                      </Tabs.List>
-                    </Tabs>
-                    {isError ? (
-                      <BookingTableEmpty
-                        isError
-                        hasSearch={false}
-                        onRetry={handleRefresh}
-                      />
-                    ) : operationsSubTab === "ready" ? (
-                      <OperationsBookingQueue
-                        bookings={rows}
-                        isLoading={isLoading}
-                        onAllocate={handleAllocateFromQueue}
-                      />
-                    ) : (
-                      <OperationsScheduledBookings
-                        bookings={rows}
-                        isLoading={isLoading}
-                      />
-                    )}
-                  </Stack>
-                </Box>
-              ) : showEmpty ? (
+              {showEmpty ? (
                 <Box px="md" pb="md">
                   <BookingTableEmpty
                     isError={isError}
diff --git a/apps/edr-freight-web/backoffice/src/pages/contracts/ContractClearanceListPage.tsx b/apps/edr-freight-web/backoffice/src/pages/contracts/ContractClearanceListPage.tsx
index 034958303..1121329fb 100644
--- a/apps/edr-freight-web/backoffice/src/pages/contracts/ContractClearanceListPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/contracts/ContractClearanceListPage.tsx
@@ -50,6 +50,7 @@ import {
   useEtClearanceQueue,
 } from "@/hooks/contracts/useContracts";
 import { FREIGHT_PERMS, hasPermission } from "@/lib/permissions";
+import { GlUpcomingWindowsSection } from "@/components/contracts/GlUpcomingWindowsSection";
 
 type ViewMode = "table" | "cards";
 type QueueTab = "all" | "et";
@@ -446,6 +447,8 @@ export default function ContractClearanceListPage() {
           ]}
         />
 
+        <GlUpcomingWindowsSection />
+
         <Card p={0} withBorder shadow="sm" radius="lg">
           <Stack gap={0}>
             {queueTabOptions.length > 1 ? (
diff --git a/apps/edr-freight-web/backoffice/src/pages/contracts/ContractRequestDetailPage.tsx b/apps/edr-freight-web/backoffice/src/pages/contracts/ContractRequestDetailPage.tsx
index 8502a996c..c81f5b919 100644
--- a/apps/edr-freight-web/backoffice/src/pages/contracts/ContractRequestDetailPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/contracts/ContractRequestDetailPage.tsx
@@ -61,9 +61,11 @@ import {
   useContractMutations,
 } from "@/hooks/contracts/useContracts";
 import { contractsService } from "@/services/contracts.service";
+import { api } from "@/services/api";
 import { QUERY_KEYS } from "@/constants/QUERY_KEYS";
 import { fileViewUrl } from "@/constants/apiConfig";
 import { downloadBookingFile } from "@/services/files.service";
+import type { CustomerDocument } from "@/types/customer";
 import type { Freight } from "@edr/types";
 
 // Clearance phase — staff can still ACT (approve / query / finalize).
@@ -152,6 +154,34 @@ export default function ContractRequestDetailPage() {
     enabled: Boolean(id) && showClearanceTabQuery,
   });
 
+  // Customer profile documents (national ID, TIN, import/business license) for
+  // the company this contract belongs to. Shown as a separate section in the
+  // Documents tab, alongside the contract's own attached files.
+  const companyId = contract?.companyId ?? "";
+  const profileDocumentsQuery = useQuery(
+    api.customers.documents.queryOptions({
+      input: { id: companyId },
+      enabled: Boolean(companyId),
+    }),
+  );
+  const profileDocumentsRaw = Array.isArray(profileDocumentsQuery.data)
+    ? profileDocumentsQuery.data
+    : [];
+  // Reshape to the contract-file shape so we can reuse ContractDocumentsCard.
+  const profileDocuments = profileDocumentsRaw.map(
+    (doc: CustomerDocument) =>
+      ({
+        id: doc.id,
+        code: doc.code,
+        name: doc.name,
+        url: doc.url ?? "",
+        mimeType: doc.mimeType,
+        size: doc.size,
+        resourceId: companyId,
+        resource: "company",
+      }) satisfies NonNullable<Freight.IContract["files"]>[number],
+  );
+
   const downloadContractPdf = async () => {
     if (!contract?.id) return;
     try {
@@ -247,6 +277,11 @@ export default function ContractRequestDetailPage() {
   const selfClear = !contract.customsClearingEnabled;
   const files = contract.files ?? [];
   const contractPdf = files.find((f) => f.code === "contract");
+  // Signature files (code `signature_<role>`) are baked into the contract PDF —
+  // don't list them as standalone documents in the Documents tab.
+  const contractDocuments = files.filter(
+    (f) => !f.code.startsWith("signature_"),
+  );
   const hasContractDocument = Boolean(
     contractPdf || contract.contractGeneratedAt,
   );
@@ -406,9 +441,9 @@ export default function ContractRequestDetailPage() {
               value="documents"
               leftSection={<Files size={16} />}
               rightSection={
-                files.length > 0 ? (
+                contractDocuments.length + profileDocuments.length > 0 ? (
                   <Badge size="xs" variant="light" color="gray" radius="sm">
-                    {files.length}
+                    {contractDocuments.length + profileDocuments.length}
                   </Badge>
                 ) : null
               }
@@ -453,7 +488,18 @@ export default function ContractRequestDetailPage() {
             ) : currentTab === "documents" ? (
               <Stack gap="lg">
                 <ContractDocumentsCard
-                  files={files}
+                  files={contractDocuments}
+                  onView={handleViewFile}
+                  onDownload={handleDownloadFile}
+                />
+                <ContractDocumentsCard
+                  files={profileDocuments}
+                  title="Customer profile documents"
+                  emptyText={
+                    profileDocumentsQuery.isLoading
+                      ? "Loading customer documents…"
+                      : "No profile documents on file for this customer."
+                  }
                   onView={handleViewFile}
                   onDownload={handleDownloadFile}
                 />
@@ -550,21 +596,58 @@ export default function ContractRequestDetailPage() {
                     No cargo scope lines.
                   </Text>
                 ) : (
-                  <Stack gap="xs">
-                    {(contract.cargoScope ?? []).map((s) => (
-                      <Group key={s.id} gap={8} wrap="nowrap">
-                        <BoxIcon
-                          size={15}
-                          color="var(--mantine-color-edr-green-6)"
-                        />
-                        <Text size="sm">
-                          {s.containerSize ??
-                            s.cargoFreeText ??
-                            s.cargoTypeId ??
-                            "Cargo"}
-                        </Text>
-                      </Group>
-                    ))}
+                  <Stack gap="sm">
+                    {(contract.cargoScope ?? []).map((s) => {
+                      const isContainer = Boolean(s.containerSize);
+                      // Bulk lines carry their commodity detail (name + unit);
+                      // container lines carry the size (20ft / 40ft).
+                      const title = isContainer
+                        ? `${s.containerSize} container`
+                        : (s.cargoType?.cargoTypeName ??
+                          s.cargoFreeText ??
+                          s.cargoType?.code ??
+                          "Bulk cargo");
+                      // quantityCap unit: containers for a size line, else the
+                      // cargo type's unit of measure (tons / items / …), default tons.
+                      const capUnit = isContainer
+                        ? "containers"
+                        : (s.cargoType?.unitOfMeasure?.toLowerCase() ?? "tons");
+                      return (
+                        <Group key={s.id} gap={8} wrap="nowrap" align="flex-start">
+                          <BoxIcon
+                            size={15}
+                            color="var(--mantine-color-edr-green-6)"
+                            style={{ marginTop: 2, flexShrink: 0 }}
+                          />
+                          <div>
+                            <Text size="sm" fw={500}>
+                              {title}
+                            </Text>
+                            <Group gap={6} mt={2}>
+                              <Badge
+                                variant="light"
+                                color={isContainer ? "blue" : "grape"}
+                                radius="sm"
+                                size="xs"
+                                tt="uppercase"
+                              >
+                                {isContainer ? "Container" : "Bulk"}
+                              </Badge>
+                              {s.cargoType?.code ? (
+                                <Text size="xs" c="dimmed">
+                                  Code: {s.cargoType.code}
+                                </Text>
+                              ) : null}
+                              <Text size="xs" c="dimmed">
+                                {s.quantityCap != null
+                                  ? `Cap: ${s.quantityCap} ${capUnit}`
+                                  : "Cap: uncapped"}
+                              </Text>
+                            </Group>
+                          </div>
+                        </Group>
+                      );
+                    })}
                   </Stack>
                 )}
               </SectionCard>
diff --git a/apps/edr-freight-web/backoffice/src/pages/contracts/GlClearanceDetailPage.tsx b/apps/edr-freight-web/backoffice/src/pages/contracts/GlClearanceDetailPage.tsx
index a94dd4e05..d5e3f3954 100644
--- a/apps/edr-freight-web/backoffice/src/pages/contracts/GlClearanceDetailPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/contracts/GlClearanceDetailPage.tsx
@@ -185,7 +185,7 @@ export default function GlClearanceDetailPage() {
           </Tabs.List>
 
           <Tabs.Panel value="workflow">
-            <Grid gutter="lg">
+            <Grid>
               <Grid.Col span={{ base: 12, lg: 7 }}>
                 {data.kind === "booking" ? (
                   <ClearanceReviewSection bookingId={id!} hideSummary readOnly />
diff --git a/apps/edr-freight-web/backoffice/src/pages/contracts/GlDjiboutiClearanceListPage.tsx b/apps/edr-freight-web/backoffice/src/pages/contracts/GlDjiboutiClearanceListPage.tsx
index 3957fb7a5..0b7456851 100644
--- a/apps/edr-freight-web/backoffice/src/pages/contracts/GlDjiboutiClearanceListPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/contracts/GlDjiboutiClearanceListPage.tsx
@@ -1,326 +1,65 @@
-import { useMemo, useState } from "react";
 import { useNavigate } from "react-router-dom";
-import {
-  Badge,
-  Button,
-  Card,
-  Group,
-  Loader,
-  Modal,
-  Stack,
-  Tabs,
-  Text,
-} from "@mantine/core";
-import { DateTimePicker } from "@mantine/dates";
-import { ChevronRight, Ship, Train, Truck } from "lucide-react";
-import { DataTable, type ColumnDef } from "@edr/ui-common";
-import type { Freight } from "@edr/types";
-import toast from "react-hot-toast";
+import { Badge, Card, Group, Loader, Stack, Text } from "@mantine/core";
+import { ChevronRight, Ship } from "lucide-react";
 
 import { PageContainer } from "@/components/page/PageContainer";
 import { PageHeader } from "@/components/page/PageHeader";
-import {
-  useDjClearanceQueue,
-  useDjClearanceSchedules,
-} from "@/hooks/contracts/useContracts";
-import { contractsService } from "@/services/contracts.service";
+import { useDjClearanceQueue } from "@/hooks/contracts/useContracts";
 
 export default function GlDjiboutiClearanceListPage() {
   const navigate = useNavigate();
   const { data: contractQueue, isLoading: contractsLoading } = useDjClearanceQueue();
-  const schedulesQuery = useDjClearanceSchedules();
 
   const contractItems = contractQueue?.items ?? [];
-  const scheduleItems = schedulesQuery.data ?? [];
-
-  const [gatepassTarget, setGatepassTarget] =
-    useState<Freight.DjClearanceSchedule | null>(null);
-  const [gatepassAt, setGatepassAt] = useState<Date | null>(new Date());
-  const [granting, setGranting] = useState(false);
-
-  const columns = useMemo<ColumnDef<Freight.DjClearanceSchedule>[]>(
-    () => [
-      {
-        header: "Train",
-        accessorKey: "trainNumber",
-        cell: ({ row }) => (
-          <Text size="sm" fw={700}>
-            {row.original.trainNumber ?? "—"}
-          </Text>
-        ),
-      },
-      {
-        header: "Route",
-        id: "route",
-        cell: ({ row }) => (
-          <Text size="sm">
-            {row.original.origin ?? "—"} → {row.original.destination ?? "—"}
-          </Text>
-        ),
-      },
-      {
-        header: "Scheduled departure",
-        id: "scheduled",
-        cell: ({ row }) => (
-          <Text size="sm">
-            {row.original.scheduledDepartureDate
-              ? new Date(row.original.scheduledDepartureDate).toLocaleDateString()
-              : "—"}
-          </Text>
-        ),
-      },
-      {
-        header: "Departed",
-        id: "departed",
-        cell: ({ row }) => (
-          <Text size="sm">
-            {row.original.actualDepartureAt
-              ? new Date(row.original.actualDepartureAt).toLocaleString()
-              : "—"}
-          </Text>
-        ),
-      },
-      {
-        header: "Arrived",
-        id: "arrived",
-        cell: ({ row }) => (
-          <Text size="sm">
-            {row.original.actualArrivalAt
-              ? new Date(row.original.actualArrivalAt).toLocaleString()
-              : "—"}
-          </Text>
-        ),
-      },
-      {
-        header: "Status",
-        accessorKey: "status",
-        cell: ({ row }) => (
-          <Badge variant="light" color={statusColor(row.original.status)} radius="sm">
-            {row.original.status}
-          </Badge>
-        ),
-      },
-      {
-        header: "Customs bookings",
-        id: "customs",
-        cell: ({ row }) => {
-          const bookings = row.original.customsBookings;
-          const directions = [...new Set(bookings.map((b) => b.tradeDirection))];
-          return (
-            <Group gap={6} wrap="nowrap">
-              <Badge variant="light" color="edr-green" radius="sm">
-                {bookings.length}
-              </Badge>
-              {directions.map((d) => (
-                <Badge key={d} variant="outline" color={d === "IMPORT" ? "edr-green" : "blue"} radius="sm">
-                  {d}
-                </Badge>
-              ))}
-            </Group>
-          );
-        },
-      },
-      {
-        header: "Gate pass",
-        id: "gatepass",
-        cell: ({ row }) => {
-          const bookings = row.original.customsBookings;
-          const allGranted =
-            bookings.length > 0 && bookings.every((b) => b.gatepassGranted);
-          const grantedAt = bookings.find((b) => b.gatepassAt)?.gatepassAt ?? null;
-          if (allGranted) {
-            return (
-              <Badge variant="light" color="edr-green" radius="sm">
-                Granted{grantedAt ? ` · ${new Date(grantedAt).toLocaleString()}` : ""}
-              </Badge>
-            );
-          }
-          return (
-            <Button
-              size="xs"
-              color="edr-green"
-              leftSection={<Truck size={14} />}
-              onClick={(e) => {
-                e.stopPropagation();
-                setGatepassAt(new Date());
-                setGatepassTarget(row.original);
-              }}
-            >
-              Gate pass
-            </Button>
-          );
-        },
-      },
-    ],
-    [],
-  );
 
   return (
     <PageContainer>
       <PageHeader
         title="GL Djibouti — Clearance"
-        subtitle="Customs contracts handed off to Djibouti GL, plus train schedules for gate-pass control."
+        subtitle="Customs contracts handed off to Djibouti GL."
       />
-      <Tabs defaultValue="contracts" keepMounted={false}>
-        <Tabs.List mb="md">
-          <Tabs.Tab value="contracts">Contracts ({contractItems.length})</Tabs.Tab>
-          <Tabs.Tab value="schedules" leftSection={<Train size={14} />}>
-            Schedules ({scheduleItems.length})
-          </Tabs.Tab>
-        </Tabs.List>
-
-        <Tabs.Panel value="contracts">
-          {contractsLoading ? (
-            <Group justify="center" py={60}>
-              <Loader color="edr-green" />
-            </Group>
-          ) : (
-            <Stack gap="sm">
-              {contractItems.length === 0 ? (
-                <Text c="dimmed" ta="center" py="xl">
-                  No Djibouti customs contracts yet.
-                </Text>
-              ) : (
-                contractItems.map((c) => (
-                  <Card
-                    key={c.id}
-                    withBorder
-                    radius="md"
-                    padding="md"
-                    style={{ cursor: "pointer" }}
-                    onClick={() => navigate(`/dashboard/gl-djibouti/clearance/${c.id}`)}
-                  >
-                    <Group justify="space-between" wrap="nowrap">
-                      <Group gap="sm">
-                        <Ship size={18} className="text-[color:var(--freight-brand)]" />
-                        <div>
-                          <Text fw={700}>{c.reference}</Text>
-                          <Text size="sm" c="dimmed">
-                            {c.tradeDirection} · {c.status}
-                          </Text>
-                        </div>
-                      </Group>
-                      <Group gap="xs">
-                        <Badge variant="light" color="edr-green">
-                          Contract
-                        </Badge>
-                        <ChevronRight size={18} className="text-muted-foreground" />
-                      </Group>
-                    </Group>
-                  </Card>
-                ))
-              )}
-            </Stack>
-          )}
-        </Tabs.Panel>
-
-        <Tabs.Panel value="schedules">
-          <DataTable
-            columns={columns}
-            data={scheduleItems}
-            status={
-              schedulesQuery.isLoading
-                ? "loading"
-                : schedulesQuery.isError
-                  ? "error"
-                  : "success"
-            }
-            error={
-              schedulesQuery.isError
-                ? {
-                    message: "Failed to load train schedules.",
-                    onRetry: () => void schedulesQuery.refetch(),
-                  }
-                : undefined
-            }
-            emptyMessage="No train schedules carry customs bookings yet."
-          />
-        </Tabs.Panel>
-      </Tabs>
-
-      <Modal
-        opened={gatepassTarget != null}
-        onClose={() => setGatepassTarget(null)}
-        title={
-          <Group gap={8}>
-            <Truck size={18} />
-            <Text fw={700}>
-              Gate pass — train {gatepassTarget?.trainNumber ?? ""}
+      {contractsLoading ? (
+        <Group justify="center" py={60}>
+          <Loader color="edr-green" />
+        </Group>
+      ) : (
+        <Stack gap="sm">
+          {contractItems.length === 0 ? (
+            <Text c="dimmed" ta="center" py="xl">
+              No Djibouti customs contracts yet.
             </Text>
-          </Group>
-        }
-        radius="md"
-        size="sm"
-      >
-        <Stack gap="md">
-          <Text size="sm" c="dimmed">
-            Grants the gate pass for all{" "}
-            {gatepassTarget?.customsBookings.length ?? 0} customs booking
-            {(gatepassTarget?.customsBookings.length ?? 0) === 1 ? "" : "s"} on this
-            train.
-          </Text>
-          <DateTimePicker
-            label="Gate pass time"
-            value={gatepassAt}
-            onChange={(v) => setGatepassAt(v ? new Date(v) : null)}
-            required
-          />
-          <Group justify="flex-end">
-            <Button
-              variant="default"
-              onClick={() => setGatepassTarget(null)}
-              disabled={granting}
-            >
-              Cancel
-            </Button>
-            <Button
-              color="edr-green"
-              loading={granting}
-              leftSection={<Truck size={16} />}
-              onClick={async () => {
-                if (!gatepassTarget) return;
-                setGranting(true);
-                try {
-                  const result = await contractsService.grantScheduleGatepass(
-                    gatepassTarget.id,
-                    (gatepassAt ?? new Date()).toISOString(),
-                  );
-                  if (result.skipped.length > 0) {
-                    toast.error(
-                      `${result.granted} granted, ${result.skipped.length} skipped: ${result.skipped[0]?.error ?? ""}`,
-                    );
-                  } else {
-                    toast.success(
-                      `Gate pass granted for ${result.granted} booking${result.granted === 1 ? "" : "s"}`,
-                    );
-                  }
-                  setGatepassTarget(null);
-                  void schedulesQuery.refetch();
-                } catch (e) {
-                  toast.error(e instanceof Error ? e.message : "Failed");
-                } finally {
-                  setGranting(false);
-                }
-              }}
-            >
-              Grant gate pass
-            </Button>
-          </Group>
+          ) : (
+            contractItems.map((c) => (
+              <Card
+                key={c.id}
+                withBorder
+                radius="md"
+                padding="md"
+                style={{ cursor: "pointer" }}
+                onClick={() => navigate(`/dashboard/gl-djibouti/clearance/${c.id}`)}
+              >
+                <Group justify="space-between" wrap="nowrap">
+                  <Group gap="sm">
+                    <Ship size={18} className="text-[color:var(--freight-brand)]" />
+                    <div>
+                      <Text fw={700}>{c.reference}</Text>
+                      <Text size="sm" c="dimmed">
+                        {c.tradeDirection} · {c.status}
+                      </Text>
+                    </div>
+                  </Group>
+                  <Group gap="xs">
+                    <Badge variant="light" color="edr-green">
+                      Contract
+                    </Badge>
+                    <ChevronRight size={18} className="text-muted-foreground" />
+                  </Group>
+                </Group>
+              </Card>
+            ))
+          )}
         </Stack>
-      </Modal>
+      )}
     </PageContainer>
   );
 }
-
-function statusColor(status: string): string {
-  switch (status) {
-    case "SCHEDULED":
-      return "blue";
-    case "DISPATCHED":
-      return "yellow";
-    case "ARRIVED":
-      return "edr-green";
-    default:
-      return "gray";
-  }
-}
diff --git a/apps/edr-freight-web/backoffice/src/pages/customers/CustomerDetailPage.tsx b/apps/edr-freight-web/backoffice/src/pages/customers/CustomerDetailPage.tsx
index 7f62ea3f5..ad888b1f6 100644
--- a/apps/edr-freight-web/backoffice/src/pages/customers/CustomerDetailPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/customers/CustomerDetailPage.tsx
@@ -135,9 +135,11 @@ export default function CustomerDetailPage() {
     }),
   );
 
-  const bookings = bookingsQuery.data ?? [];
-  const documents = documentsQuery.data ?? [];
-  const payments = paymentsQuery.data ?? [];
+  const bookings = Array.isArray(bookingsQuery.data) ? bookingsQuery.data : [];
+  const documents = Array.isArray(documentsQuery.data)
+    ? documentsQuery.data
+    : [];
+  const payments = Array.isArray(paymentsQuery.data) ? paymentsQuery.data : [];
   const invoices = invoicesQuery.data?.items ?? [];
   const invoiceTotal = invoicesQuery.data?.total ?? 0;
   const invoicePageCount = Math.max(
diff --git a/apps/edr-freight-web/backoffice/src/pages/fleet/DriverDetailPage.tsx b/apps/edr-freight-web/backoffice/src/pages/fleet/DriverDetailPage.tsx
new file mode 100644
index 000000000..d5e8655be
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/pages/fleet/DriverDetailPage.tsx
@@ -0,0 +1,286 @@
+import { useMemo } from "react";
+import { useParams, useNavigate } from "react-router-dom";
+import { useQuery } from "@tanstack/react-query";
+import {
+  ActionIcon,
+  Badge,
+  Card,
+  Center,
+  Container,
+  Group,
+  Loader,
+  SimpleGrid,
+  Stack,
+  Table,
+  Tabs,
+  Text,
+  Timeline,
+  Title,
+} from "@mantine/core";
+import {
+  ArrowLeft,
+  History,
+  Route,
+  ShieldCheck,
+  Truck,
+  User,
+} from "lucide-react";
+
+import { driversService } from "@/services/drivers.service";
+import { vehiclesService } from "@/services/vehicles.service";
+import { fleetHistoryService, type FleetHistoryEvent } from "@/services/fleet-history.service";
+
+const fmtDate = (iso?: string | null) => {
+  if (!iso) return "—";
+  const d = new Date(iso);
+  return Number.isNaN(d.getTime()) ? "—" : d.toLocaleDateString();
+};
+const fmtDateTime = (iso?: string | null) => {
+  if (!iso) return "—";
+  const d = new Date(iso);
+  return Number.isNaN(d.getTime()) ? "—" : d.toLocaleString();
+};
+const meta = (e: FleetHistoryEvent, k: string) => {
+  const v = e.metadata?.[k];
+  return typeof v === "string" && v ? v : null;
+};
+
+const InfoRow = ({ label, value }: { label: string; value: React.ReactNode }) => (
+  <Group justify="space-between" wrap="nowrap">
+    <Text size="xs" c="dimmed" tt="uppercase">{label}</Text>
+    <Text size="sm" fw={500} ta="right">{value}</Text>
+  </Group>
+);
+const Loading = () => (
+  <Center py="xl"><Loader size="sm" /></Center>
+);
+
+const DriverDetailPage = () => {
+  const { id = "" } = useParams<{ id: string }>();
+  const navigate = useNavigate();
+
+  const { data: driver, isLoading } = useQuery({
+    queryKey: ["driver", id],
+    queryFn: () => driversService.getById(id).then((r) => r.data),
+    enabled: Boolean(id),
+  });
+
+  const name = driver ? `${driver.firstName ?? ""} ${driver.lastName ?? ""}`.trim() : "";
+  const licenseExpired =
+    driver?.licenseExpiryDate && new Date(driver.licenseExpiryDate) < new Date();
+
+  return (
+    <Container size="xl" py="xl" px="lg">
+      <Group gap="sm" mb="md" wrap="nowrap">
+        <ActionIcon variant="subtle" onClick={() => navigate("/dashboard/drivers")} aria-label="Back">
+          <ArrowLeft size={18} />
+        </ActionIcon>
+        <User size={22} />
+        <Stack gap={0}>
+          <Title order={4}>{name || "Driver"}</Title>
+          {driver && (
+            <Group gap="xs">
+              <Badge size="sm" variant="light">{driver.status}</Badge>
+              {driver.faydaVerified && (
+                <Badge size="sm" variant="light" color="green" leftSection={<ShieldCheck size={12} />}>
+                  Fayda verified
+                </Badge>
+              )}
+              {licenseExpired && (
+                <Badge size="sm" variant="light" color="red">License expired</Badge>
+              )}
+              <Text size="xs" c="dimmed">{driver.licenseNumber}</Text>
+            </Group>
+          )}
+        </Stack>
+      </Group>
+
+      {isLoading ? (
+        <Loading />
+      ) : !driver ? (
+        <Text c="dimmed">Driver not found.</Text>
+      ) : (
+        <Tabs defaultValue="overview">
+          <Tabs.List>
+            <Tabs.Tab value="overview" leftSection={<User size={14} />}>Overview</Tabs.Tab>
+            <Tabs.Tab value="vehicles" leftSection={<Truck size={14} />}>Vehicles</Tabs.Tab>
+            <Tabs.Tab value="history" leftSection={<History size={14} />}>History</Tabs.Tab>
+            <Tabs.Tab value="trips" leftSection={<Route size={14} />}>Trips</Tabs.Tab>
+          </Tabs.List>
+
+          <Tabs.Panel value="overview" pt="lg">
+            <Card withBorder radius="md" padding="md">
+              <SimpleGrid cols={{ base: 1, sm: 2 }} spacing="sm">
+                <InfoRow label="Name" value={name || "—"} />
+                <InfoRow label="Phone" value={driver.phoneNumber ?? "—"} />
+                <InfoRow label="Email" value={driver.email ?? "—"} />
+                <InfoRow label="License no." value={driver.licenseNumber ?? "—"} />
+                <InfoRow
+                  label="License expiry"
+                  value={
+                    <Text size="sm" fw={500} c={licenseExpired ? "red" : undefined}>
+                      {fmtDate(driver.licenseExpiryDate)}
+                    </Text>
+                  }
+                />
+                <InfoRow label="Date of birth" value={fmtDate(driver.dateOfBirth)} />
+                <InfoRow label="Status" value={driver.status ?? "—"} />
+                <InfoRow label="Fayda verified" value={driver.faydaVerified ? "Yes" : "No"} />
+                <InfoRow
+                  label="Authorized vehicles"
+                  value={driver.vehicleTypesAuthorized?.join(", ") || "—"}
+                />
+                <InfoRow label="Total trips" value={driver.totalTrips ?? "—"} />
+                <InfoRow label="Rating" value={driver.rating ?? "—"} />
+                <InfoRow label="Address" value={driver.address ?? "—"} />
+                <InfoRow label="Emergency contact" value={driver.emergencyContact ?? "—"} />
+              </SimpleGrid>
+            </Card>
+          </Tabs.Panel>
+
+          <Tabs.Panel value="vehicles" pt="lg">
+            <VehiclesTab driverId={id} />
+          </Tabs.Panel>
+
+          <Tabs.Panel value="history" pt="lg">
+            <HistoryTab driverId={id} />
+          </Tabs.Panel>
+
+          <Tabs.Panel value="trips" pt="lg">
+            <TripsTab driverId={id} />
+          </Tabs.Panel>
+        </Tabs>
+      )}
+    </Container>
+  );
+};
+
+const useDriverHistory = (driverId: string) =>
+  useQuery({
+    queryKey: ["driver-history", driverId],
+    queryFn: () => fleetHistoryService.driver(driverId),
+  });
+
+/** id → "code · plate" map so events without a stored plate still show a name. */
+const useVehicleMap = () => {
+  const { data } = useQuery({
+    queryKey: ["vehicles-all"],
+    queryFn: () => vehiclesService.getAll({}).then((r) => r.data),
+  });
+  return useMemo(() => {
+    const m = new Map<string, string>();
+    for (const v of data ?? []) {
+      m.set(v.id, [v.code, v.plateNumber].filter(Boolean).join(" · ") || v.id);
+    }
+    return m;
+  }, [data]);
+};
+
+const VehiclesTab = ({ driverId }: { driverId: string }) => {
+  const { data = [], isLoading } = useDriverHistory(driverId);
+  const vmap = useVehicleMap();
+  const rows = data
+    .filter((e) => e.eventType === "DRIVER_ASSIGNED")
+    .map((e) => ({
+      id: e.id,
+      plate: meta(e, "vehiclePlate") || (e.vehicleId ? vmap.get(e.vehicleId) : null) || "Vehicle",
+      at: e.createdAt,
+    }));
+  if (isLoading) return <Loading />;
+  return (
+    <Stack gap={4}>
+      <Text size="sm" fw={600}>Vehicles driven ({rows.length})</Text>
+      {rows.length === 0 ? (
+        <Text size="sm" c="dimmed">No vehicle assignments recorded.</Text>
+      ) : (
+        <Table striped highlightOnHover>
+          <Table.Thead>
+            <Table.Tr><Table.Th>Vehicle</Table.Th><Table.Th>Assigned</Table.Th></Table.Tr>
+          </Table.Thead>
+          <Table.Tbody>
+            {rows.map((r) => (
+              <Table.Tr key={r.id}>
+                <Table.Td>{r.plate}</Table.Td>
+                <Table.Td>{fmtDateTime(r.at)}</Table.Td>
+              </Table.Tr>
+            ))}
+          </Table.Tbody>
+        </Table>
+      )}
+    </Stack>
+  );
+};
+
+const HistoryTab = ({ driverId }: { driverId: string }) => {
+  const { data = [], isLoading } = useDriverHistory(driverId);
+  if (isLoading) return <Loading />;
+  if (!data.length) return <Text c="dimmed">No activity recorded yet.</Text>;
+  return (
+    <Timeline active={data.length} bulletSize={18} lineWidth={2}>
+      {data.map((e) => (
+        <Timeline.Item key={e.id} title={<Text size="sm" fw={500}>{e.eventType.replaceAll("_", " ")}</Text>}>
+          {(meta(e, "vehiclePlate") || meta(e, "bookingRef") || e.label) && (
+            <Text size="xs" c="dimmed">
+              {[meta(e, "vehiclePlate"), meta(e, "bookingRef") && `Booking ${meta(e, "bookingRef")}`, e.label]
+                .filter(Boolean)
+                .join(" · ")}
+            </Text>
+          )}
+          <Text size="xs" c="dimmed" mt={2}>{fmtDateTime(e.createdAt)}</Text>
+        </Timeline.Item>
+      ))}
+    </Timeline>
+  );
+};
+
+const TripsTab = ({ driverId }: { driverId: string }) => {
+  const { data = [], isLoading } = useDriverHistory(driverId);
+  const vmap = useVehicleMap();
+  const trips = useMemo(
+    () =>
+      data
+        .filter((e) => e.eventType === "MILE_VEHICLE_ASSIGNED")
+        .map((e) => ({
+          id: e.id,
+          mile: meta(e, "mile") === "LAST" ? "Last-mile" : "First-mile",
+          booking: meta(e, "bookingRef") ?? "—",
+          vehicle: meta(e, "vehiclePlate") || (e.vehicleId ? vmap.get(e.vehicleId) : null) || "—",
+          status: e.label ?? "—",
+          at: e.createdAt,
+        })),
+    [data, vmap],
+  );
+  if (isLoading) return <Loading />;
+  return (
+    <Stack gap={4}>
+      <Text size="sm" fw={600}>Trips assigned ({trips.length})</Text>
+      {trips.length === 0 ? (
+        <Text size="sm" c="dimmed">No trips recorded.</Text>
+      ) : (
+        <Table.ScrollContainer minWidth={640}>
+          <Table striped highlightOnHover>
+            <Table.Thead>
+              <Table.Tr>
+                <Table.Th>Mile</Table.Th><Table.Th>Booking</Table.Th>
+                <Table.Th>Vehicle</Table.Th><Table.Th>Status</Table.Th><Table.Th>When</Table.Th>
+              </Table.Tr>
+            </Table.Thead>
+            <Table.Tbody>
+              {trips.map((t) => (
+                <Table.Tr key={t.id}>
+                  <Table.Td><Badge size="sm" variant="light">{t.mile}</Badge></Table.Td>
+                  <Table.Td>{t.booking}</Table.Td>
+                  <Table.Td>{t.vehicle}</Table.Td>
+                  <Table.Td>{t.status}</Table.Td>
+                  <Table.Td>{fmtDateTime(t.at)}</Table.Td>
+                </Table.Tr>
+              ))}
+            </Table.Tbody>
+          </Table>
+        </Table.ScrollContainer>
+      )}
+    </Stack>
+  );
+};
+
+export default DriverDetailPage;
diff --git a/apps/edr-freight-web/backoffice/src/pages/fleet/FinancialReportsPage.tsx b/apps/edr-freight-web/backoffice/src/pages/fleet/FinancialReportsPage.tsx
index 73a7456af..a62c4cbc5 100644
--- a/apps/edr-freight-web/backoffice/src/pages/fleet/FinancialReportsPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/fleet/FinancialReportsPage.tsx
@@ -1,26 +1,10 @@
 import { useMemo, useState } from 'react';
 import { useQuery } from '@tanstack/react-query';
-import { Card, Button, Stack, Group, Grid, Select, Text, ThemeIcon, RingProgress, Container } from '@mantine/core';
+import { Card, Stack, Group, Grid, Select, Text, RingProgress, Container, Title } from '@mantine/core';
+import Breadcrumbs from '@/components/ui/Breadcrumbs';
 import { QUERY_KEYS } from '@/constants/QUERY_KEYS';
-import { api } from '@/services/api';
+import { api } from '@/auth/http';
 import { vehiclesService } from '@/services/vehicles.service';
-import { freightBrand } from '@/theme/freight-brand';
-
-interface FuelStats {
-  vehicleId: string;
-  totalPurchases: number;
-  totalFuel: number;
-  totalCost: number;
-  averageCostPerLiter: number;
-}
-
-interface MaintenanceStats {
-  vehicleId: string;
-  totalCost: number;
-  numberOfMaintenanceItems: number;
-  averageCostPerMaintenance: number;
-  costByType: Record<string, number>;
-}
 
 interface CombinedReport {
   vehicleId: string;
@@ -31,6 +15,9 @@ interface CombinedReport {
   maintenancePercentage: number;
 }
 
+const etb = (n: number) =>
+  'ETB ' + Number(n).toLocaleString('en-US', { minimumFractionDigits: 2, maximumFractionDigits: 2 });
+
 export function FinancialReportsPage() {
   const [selectedVehicle, setSelectedVehicle] = useState<string | null>(null);
   const [months, setMonths] = useState('12');
@@ -45,13 +32,21 @@ export function FinancialReportsPage() {
 
   const { data: fuelStats } = useQuery({
     queryKey: QUERY_KEYS.FUEL.stats(selectedVehicle || ''),
-    queryFn: () => selectedVehicle ? api.get(`/fuel/stats/${selectedVehicle}?months=${months}`) : Promise.resolve(null),
+    queryFn: async () => {
+      if (!selectedVehicle) return Promise.resolve(null);
+      const res = await api.get(`/fuel/stats/${selectedVehicle}?months=${months}`);
+      return res.data;
+    },
     enabled: !!selectedVehicle,
   });
 
   const { data: maintenanceStats } = useQuery({
     queryKey: QUERY_KEYS.MAINTENANCE.stats(selectedVehicle || ''),
-    queryFn: () => selectedVehicle ? api.get(`/maintenance/stats/${selectedVehicle}`) : Promise.resolve(null),
+    queryFn: async () => {
+      if (!selectedVehicle) return Promise.resolve(null);
+      const res = await api.get(`/maintenance/stats/${selectedVehicle}`);
+      return res.data;
+    },
     enabled: !!selectedVehicle,
   });
 
@@ -60,11 +55,11 @@ export function FinancialReportsPage() {
     [vehicles]
   );
 
-  const report = useMemo(() => {
-    if (!fuelStats || !maintenanceStats) return null;
+  const report = useMemo<CombinedReport | null>(() => {
+    if (!fuelStats && !maintenanceStats) return null;
 
-    const fuelCost = Number(fuelStats.totalCost) || 0;
-    const maintenanceCost = Number(maintenanceStats.totalCost) || 0;
+    const fuelCost = Number(fuelStats?.totalCost ?? 0) || 0;
+    const maintenanceCost = Number(maintenanceStats?.totalCost ?? 0) || 0;
     const total = fuelCost + maintenanceCost;
 
     return {
@@ -93,6 +88,9 @@ export function FinancialReportsPage() {
   return (
     <Container size="xl" py="xl" px="lg">
       <Stack gap="md">
+      <Breadcrumbs items={[{ label: 'Fleet' }, { label: 'Financial Reports' }]} />
+      <Title order={1}>Financial Reports</Title>
+
       <Card>
         <Card.Section p="md" withBorder>
           <Text fw={500}>Fleet Financial Analysis</Text>
@@ -126,13 +124,13 @@ export function FinancialReportsPage() {
         <>
           <Grid>
             <Grid.Col span={{ base: 12, sm: 6, md: 3 }}>
-              <StatCard label="Total Operating Cost" value={`$${report.totalOperatingCost.toFixed(2)}`} />
+              <StatCard label="Total Operating Cost" value={etb(report.totalOperatingCost)} />
             </Grid.Col>
             <Grid.Col span={{ base: 12, sm: 6, md: 3 }}>
-              <StatCard label="Fuel Cost" value={`$${report.fuelCost.toFixed(2)}`} />
+              <StatCard label="Fuel Cost" value={etb(report.fuelCost)} />
             </Grid.Col>
             <Grid.Col span={{ base: 12, sm: 6, md: 3 }}>
-              <StatCard label="Maintenance Cost" value={`$${report.maintenanceCost.toFixed(2)}`} />
+              <StatCard label="Maintenance Cost" value={etb(report.maintenanceCost)} />
             </Grid.Col>
             <Grid.Col span={{ base: 12, sm: 6, md: 3 }}>
               <Card withBorder>
@@ -141,7 +139,7 @@ export function FinancialReportsPage() {
                     Monthly Avg
                   </Text>
                   <Text fw={700} size="lg">
-                    ${(report.totalOperatingCost / parseInt(months)).toFixed(2)}
+                    {etb(report.totalOperatingCost / parseInt(months))}
                   </Text>
                 </Card.Section>
               </Card>
@@ -166,7 +164,7 @@ export function FinancialReportsPage() {
                       <RingProgress
                         sections={[{ value: report.fuelPercentage, color: 'edr-accent' }]}
                         label={
-                          <Text size="xs" align="center">
+                          <Text size="xs" ta="center">
                             {report.fuelPercentage}%
                           </Text>
                         }
@@ -184,7 +182,7 @@ export function FinancialReportsPage() {
                       <RingProgress
                         sections={[{ value: report.maintenancePercentage, color: 'edr-red' }]}
                         label={
-                          <Text size="xs" align="center">
+                          <Text size="xs" ta="center">
                             {report.maintenancePercentage}%
                           </Text>
                         }
@@ -228,7 +226,7 @@ export function FinancialReportsPage() {
                       <Text size="sm" c="dimmed">
                         Avg Maintenance Cost
                       </Text>
-                      <Text fw={500}>${maintenanceStats?.averageCostPerMaintenance?.toFixed(2) || '0.00'}</Text>
+                      <Text fw={500}>{etb(maintenanceStats?.averageCostPerMaintenance ?? 0)}</Text>
                     </div>
                   </Stack>
                 </Card.Section>
diff --git a/apps/edr-freight-web/backoffice/src/pages/fleet/FleetDashboard.tsx b/apps/edr-freight-web/backoffice/src/pages/fleet/FleetDashboard.tsx
index a311a16eb..32341505a 100644
--- a/apps/edr-freight-web/backoffice/src/pages/fleet/FleetDashboard.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/fleet/FleetDashboard.tsx
@@ -1,7 +1,8 @@
 import { useMemo } from 'react';
 import { useQuery } from '@tanstack/react-query';
-import { Card, Stack, Group, Grid, Text, ThemeIcon, Progress, Badge, Table, RingProgress, Container, Title, Box, Tabs, Button } from '@mantine/core';
-import { Truck, Fuel, Wrench, TrendingUp, AlertCircle, Users, User, MapPin, Calendar, BarChart3 } from 'lucide-react';
+import { Card, Stack, Group, Grid, Text, ThemeIcon, Progress, Badge, Table, RingProgress, Container, Title, Box, Tabs } from '@mantine/core';
+import { Truck, Fuel, Wrench, AlertCircle, Users, User, MapPin } from 'lucide-react';
+import type { LucideIcon } from 'lucide-react';
 import Breadcrumbs from '@/components/ui/Breadcrumbs';
 import { QUERY_KEYS } from '@/constants/QUERY_KEYS';
 import { api } from '@/auth/http';
@@ -39,7 +40,20 @@ interface FleetMetrics {
   assignedDrivers: number;
 }
 
-const StatCard = ({ icon: Icon, label, value, color = 'edr-green', change }: any) => (
+/** ETB money, whole-birr for dashboard headlines. */
+const etb = (n: number) => `ETB ${(Number(n) || 0).toLocaleString('en-US', { maximumFractionDigits: 0 })}`;
+/** Safe percentage — 0 when the denominator is 0 (empty fleet). */
+const pct = (n: number, d: number) => (d > 0 ? (n / d) * 100 : 0);
+
+interface StatCardProps {
+  icon: LucideIcon;
+  label: string;
+  value: string | number;
+  color?: string;
+  change?: number;
+}
+
+const StatCard = ({ icon: Icon, label, value, color = 'edr-green', change }: StatCardProps) => (
   <Card withBorder p="lg" style={{ borderTop: `3px solid ${freightBrand.primary}` }}>
     <Group justify="space-between" mb="sm">
       <ThemeIcon size="xl" radius="md" color={color} variant="light">
@@ -111,8 +125,8 @@ export function FleetDashboard() {
     const totalDrivers = (drivers as Driver[]).length;
     const assignedDrivers = (drivers as Driver[]).filter(d => d.assignedVehicle).length;
 
-    const fuelTotal = fuelStats?.totalCost || 0;
-    const maintenanceTotal = maintenanceStats?.totalCost || 0;
+    const fuelTotal = Number(fuelStats?.totalCost) || 0;
+    const maintenanceTotal = Number(maintenanceStats?.totalCost) || 0;
 
     return {
       totalVehicles,
@@ -152,10 +166,10 @@ export function FleetDashboard() {
           <StatCard icon={Users} label="Total Drivers" value={metrics.totalDrivers} color="edr-blue" />
         </Grid.Col>
         <Grid.Col span={{ base: 12, sm: 6, md: 3 }}>
-          <StatCard icon={Fuel} label="Fuel Spend" value={`$${metrics.totalFuelSpend.toFixed(0)}`} color="edr-accent" />
+          <StatCard icon={Fuel} label="Fuel Spend" value={etb(metrics.totalFuelSpend)} color="edr-accent" />
         </Grid.Col>
         <Grid.Col span={{ base: 12, sm: 6, md: 3 }}>
-          <StatCard icon={Wrench} label="Maintenance" value={`$${metrics.totalMaintenanceSpend.toFixed(0)}`} color="edr-red" />
+          <StatCard icon={Wrench} label="Maintenance" value={etb(metrics.totalMaintenanceSpend)} color="edr-red" />
         </Grid.Col>
       </Grid>
 
@@ -173,7 +187,7 @@ export function FleetDashboard() {
                     <Text size="sm">Active Vehicles</Text>
                     <Text fw={700}>{metrics.activeVehicles} / {metrics.totalVehicles}</Text>
                   </Group>
-                  <Progress value={(metrics.activeVehicles / metrics.totalVehicles) * 100} color="edr-green" />
+                  <Progress value={pct(metrics.activeVehicles, metrics.totalVehicles)} color="edr-green" />
                 </div>
 
                 <div>
@@ -189,7 +203,7 @@ export function FleetDashboard() {
                     <Text size="sm">Idle / Under Maintenance</Text>
                     <Text fw={700}>{metrics.totalVehicles - metrics.activeVehicles}</Text>
                   </Group>
-                  <Progress value={((metrics.totalVehicles - metrics.activeVehicles) / metrics.totalVehicles) * 100} color="edr-amber-soft" />
+                  <Progress value={pct(metrics.totalVehicles - metrics.activeVehicles, metrics.totalVehicles)} color="edr-amber-soft" />
                 </div>
               </Stack>
             </Card.Section>
@@ -212,7 +226,7 @@ export function FleetDashboard() {
                     label={
                       <div style={{ textAlign: 'center' }}>
                         <Text fw={700} size="sm">
-                          ${operatingCost.toFixed(0)}
+                          {etb(operatingCost)}
                         </Text>
                         <Text size="xs" c="dimmed">
                           Total Cost
@@ -325,13 +339,12 @@ export function FleetDashboard() {
                       </Table.Td>
                       <Table.Td>{d.licenseNumber || 'N/A'}</Table.Td>
                       <Table.Td>
-                        <Stack gap={0} size="xs">
+                        <Stack gap={0}>
                           {d.phone && (
-                            <Text size="xs">
-                              <Group gap={4} inline>
-                                <MapPin size={12} /> {d.phone}
-                              </Group>
-                            </Text>
+                            <Group gap={4}>
+                              <MapPin size={12} />
+                              <Text size="xs">{d.phone}</Text>
+                            </Group>
                           )}
                           {d.email && <Text size="xs">{d.email}</Text>}
                         </Stack>
diff --git a/apps/edr-freight-web/backoffice/src/pages/fleet/FleetResourcePage.tsx b/apps/edr-freight-web/backoffice/src/pages/fleet/FleetResourcePage.tsx
index 13be9ef71..f7bee5b41 100644
--- a/apps/edr-freight-web/backoffice/src/pages/fleet/FleetResourcePage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/fleet/FleetResourcePage.tsx
@@ -10,6 +10,7 @@ import { Navigate, useLocation } from "react-router-dom";
 
 import FleetCardGrid from "@/components/fleet/FleetCardGrid";
 import FleetFormDialog from "@/components/fleet/FleetFormDialog";
+import FleetHistoryModal from "@/components/fleet/FleetHistoryModal";
 import FleetRecordActions from "@/components/fleet/FleetRecordActions";
 import FleetToolbar from "@/components/fleet/FleetToolbar";
 import { formatFleetCell, registerFleetOptionLabels } from "@/components/fleet/fleetFormat";
@@ -42,6 +43,7 @@ const FleetResourcePage = () => {
   const [editing, setEditing] = useState<FleetRecord | null>(null);
   const [removeTarget, setRemoveTarget] = useState<FleetRecord | null>(null);
   const [assigningDriver, setAssigningDriver] = useState<FleetRecord | null>(null);
+  const [historyTarget, setHistoryTarget] = useState<FleetRecord | null>(null);
   const [selectedDriver, setSelectedDriver] = useState<string>("");
   const { viewMode, setViewMode } = useFleetViewMode(slug);
 
@@ -273,6 +275,7 @@ const FleetResourcePage = () => {
             }}
             onRemove={setRemoveTarget}
             onAssignDriver={setAssigningDriver}
+            onHistory={setHistoryTarget}
           />
         </div>
       ),
@@ -354,7 +357,7 @@ const FleetResourcePage = () => {
   const itemLabel = config.label.toLowerCase();
 
   return (
-    <Container size="xxl" py="lg">
+    <Container size="xxl" py="lg" px="lg">
       <Breadcrumbs items={[{ label: config.label }]} />
 
       <Stack gap="lg" mt="sm">
@@ -510,6 +513,7 @@ const FleetResourcePage = () => {
         isSubmitting={create.isPending || update.isPending}
         selectOptionsLoading={selectOptionsLoading}
         onSubmit={handleFormSubmit}
+        verifyWithFayda={Boolean(config.faydaVerification)}
       />
 
       <Modal
@@ -580,6 +584,13 @@ const FleetResourcePage = () => {
           </Group>
         </Stack>
       </Modal>
+
+      <FleetHistoryModal
+        opened={Boolean(historyTarget)}
+        onClose={() => setHistoryTarget(null)}
+        entity={slug === "vehicles" ? "vehicle" : "driver"}
+        record={historyTarget}
+      />
     </Container>
   );
 };
diff --git a/apps/edr-freight-web/backoffice/src/pages/fleet/FuelPurchasePage.tsx b/apps/edr-freight-web/backoffice/src/pages/fleet/FuelPurchasePage.tsx
index b3c168df3..6ca9f8870 100644
--- a/apps/edr-freight-web/backoffice/src/pages/fleet/FuelPurchasePage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/fleet/FuelPurchasePage.tsx
@@ -1,11 +1,11 @@
 import { useState } from "react";
 import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
 import {
-  Box,
   Button,
   Card,
   Container,
   Group,
+  Loader,
   Modal,
   NumberInput,
   Select,
@@ -17,13 +17,12 @@ import {
   Badge,
   Grid,
 } from "@mantine/core";
-import { Plus, Trash2 } from "lucide-react";
+import { Plus } from "lucide-react";
 import Breadcrumbs from "@/components/ui/Breadcrumbs";
 import { useToast } from "@/hooks/use-toast";
 import { api } from "@/auth/http";
 import { QUERY_KEYS } from "@/constants/QUERY_KEYS";
 import { vehiclesService, type Vehicle as VehicleType } from "@/services/vehicles.service";
-import { freightBrand } from "@/theme/freight-brand";
 
 interface FuelPurchase {
   id: string;
@@ -67,7 +66,7 @@ export default function FuelPurchasePage() {
   });
 
   // Fetch fuel purchases
-  const { data: purchasesData = [] } = useQuery({
+  const { data: purchasesData = [], isLoading: isLoadingPurchases } = useQuery({
     queryKey: ["fuel-purchases"],
     queryFn: async () => {
       const res = await api.get("/fuel/purchases");
@@ -104,8 +103,8 @@ export default function FuelPurchasePage() {
     onError: (error: any) => {
       toast({
         title: "Error recording purchase",
-        message: error?.response?.data?.message || "Failed to record fuel purchase",
-        color: "red",
+        description: error?.response?.data?.message || "Failed to record fuel purchase",
+        variant: "destructive",
       });
     },
   });
@@ -118,6 +117,17 @@ export default function FuelPurchasePage() {
 
   const totalCost = formData.liters * formData.costPerLiter;
 
+  // Aggregate stats (guarded against divide-by-zero when there are no purchases)
+  const totalLiters = (purchasesData as FuelPurchase[]).reduce(
+    (sum, p) => sum + Number(p.liters),
+    0
+  );
+  const totalPurchaseCost = (purchasesData as FuelPurchase[]).reduce(
+    (sum, p) => sum + Number(p.totalCost),
+    0
+  );
+  const avgPricePerLiter = totalLiters > 0 ? totalPurchaseCost / totalLiters : 0;
+
   return (
     <Container size="xl" py="xl" px="lg">
       <Breadcrumbs items={[{ label: "Fleet" }, { label: "Fuel Management" }, { label: "Record Purchase" }]} />
@@ -147,10 +157,7 @@ export default function FuelPurchasePage() {
               Total Liters
             </Text>
             <Text fw={700} size="lg">
-              {purchasesData
-                .reduce((sum: number, p: FuelPurchase) => sum + Number(p.liters), 0)
-                .toFixed(2)}{" "}
-              L
+              {totalLiters.toFixed(2)} L
             </Text>
           </Card>
         </Grid.Col>
@@ -160,9 +167,7 @@ export default function FuelPurchasePage() {
               Total Cost
             </Text>
             <Text fw={700} size="lg">
-              ETB {purchasesData
-                .reduce((sum: number, p: FuelPurchase) => sum + Number(p.totalCost), 0)
-                .toLocaleString("en-US", { maximumFractionDigits: 2 })}
+              ETB {totalPurchaseCost.toLocaleString("en-US", { maximumFractionDigits: 2 })}
             </Text>
           </Card>
         </Grid.Col>
@@ -172,11 +177,7 @@ export default function FuelPurchasePage() {
               Avg Price/L
             </Text>
             <Text fw={700} size="lg">
-              ETB{" "}
-              {(
-                purchasesData.reduce((sum: number, p: FuelPurchase) => sum + Number(p.totalCost), 0) /
-                  purchasesData.reduce((sum: number, p: FuelPurchase) => sum + Number(p.liters), 0) || 0
-              ).toFixed(2)}
+              ETB {avgPricePerLiter.toFixed(2)}
             </Text>
           </Card>
         </Grid.Col>
@@ -197,6 +198,23 @@ export default function FuelPurchasePage() {
             </Table.Tr>
           </Table.Thead>
           <Table.Tbody>
+            {isLoadingPurchases ? (
+              <Table.Tr>
+                <Table.Td colSpan={7}>
+                  <Group justify="center" py="md">
+                    <Loader size="sm" />
+                  </Group>
+                </Table.Td>
+              </Table.Tr>
+            ) : purchasesData.length === 0 ? (
+              <Table.Tr>
+                <Table.Td colSpan={7}>
+                  <Text c="dimmed" ta="center" py="md">
+                    No fuel purchases recorded yet.
+                  </Text>
+                </Table.Td>
+              </Table.Tr>
+            ) : null}
             {(purchasesData as FuelPurchase[])?.map((purchase) => (
               <Table.Tr key={purchase.id}>
                 <Table.Td>{(purchase as any).vehicle?.registrationNumber || (purchase as any).vehicle?.plateNumber || purchase.vehicleId}</Table.Td>
diff --git a/apps/edr-freight-web/backoffice/src/pages/fleet/FuelStatsPage.tsx b/apps/edr-freight-web/backoffice/src/pages/fleet/FuelStatsPage.tsx
index 04c872966..904347cf0 100644
--- a/apps/edr-freight-web/backoffice/src/pages/fleet/FuelStatsPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/fleet/FuelStatsPage.tsx
@@ -1,20 +1,11 @@
 import { useQuery } from "@tanstack/react-query";
-import { Box, Card, Container, Grid, Group, Select, Stack, Table, Text, Title, Badge } from "@mantine/core";
+import { Card, Container, Grid, Group, Loader, Select, Stack, Text, Title } from "@mantine/core";
 import Breadcrumbs from "@/components/ui/Breadcrumbs";
 import { api } from "@/auth/http";
 import { QUERY_KEYS } from "@/constants/QUERY_KEYS";
 import { vehiclesService, type Vehicle as VehicleType } from "@/services/vehicles.service";
 import { useState } from "react";
 
-interface FuelStats {
-  vehicleId: string;
-  totalPurchases: number;
-  totalLiters: number;
-  totalCost: number;
-  averagePricePerLiter: number;
-  dateRange: { startDate: string; endDate: string };
-}
-
 export default function FuelStatsPage() {
   const [selectedVehicleId, setSelectedVehicleId] = useState<string>("");
   const [monthsBack, setMonthsBack] = useState<string>("12");
@@ -29,7 +20,7 @@ export default function FuelStatsPage() {
   });
 
   // Fetch fuel stats
-  const { data: statsData } = useQuery({
+  const { data: statsData, isFetching: isStatsFetching } = useQuery({
     queryKey: ["fuel-stats", selectedVehicleId, monthsBack],
     queryFn: async () => {
       if (!selectedVehicleId) return null;
@@ -102,7 +93,7 @@ export default function FuelStatsPage() {
                   Total Purchases
                 </Text>
                 <Text fw={700} size="lg">
-                  {statsData.totalPurchases}
+                  {Number(statsData.totalPurchases) || 0}
                 </Text>
               </Card>
             </Grid.Col>
@@ -112,7 +103,7 @@ export default function FuelStatsPage() {
                   Total Fuel
                 </Text>
                 <Text fw={700} size="lg">
-                  {statsData.totalLiters.toFixed(2)} L
+                  {(Number(statsData.totalLiters) || 0).toFixed(2)} L
                 </Text>
               </Card>
             </Grid.Col>
@@ -122,7 +113,7 @@ export default function FuelStatsPage() {
                   Total Cost
                 </Text>
                 <Text fw={700} size="lg">
-                  ETB {statsData.totalCost.toLocaleString("en-US", { maximumFractionDigits: 2 })}
+                  ETB {(Number(statsData.totalCost) || 0).toLocaleString("en-US", { maximumFractionDigits: 2 })}
                 </Text>
               </Card>
             </Grid.Col>
@@ -132,7 +123,7 @@ export default function FuelStatsPage() {
                   Avg Price/L
                 </Text>
                 <Text fw={700} size="lg">
-                  ETB {statsData.averagePricePerLiter.toFixed(2)}
+                  ETB {(Number(statsData.averagePricePerLiter) || 0).toFixed(2)}
                 </Text>
               </Card>
             </Grid.Col>
@@ -172,15 +163,15 @@ export default function FuelStatsPage() {
                 <Text size="sm">
                   {selectedVehicle?.plateNumber} consumed{" "}
                   <Text fw={700} span>
-                    {statsData.totalLiters.toFixed(2)} liters
+                    {(Number(statsData.totalLiters) || 0).toFixed(2)} liters
                   </Text>{" "}
                   over the last {monthsBack} months, costing{" "}
                   <Text fw={700} span>
-                    ETB {statsData.totalCost.toLocaleString("en-US", { maximumFractionDigits: 2 })}
+                    ETB {(Number(statsData.totalCost) || 0).toLocaleString("en-US", { maximumFractionDigits: 2 })}
                   </Text>
                   . Average fuel price was{" "}
                   <Text fw={700} span>
-                    ETB {statsData.averagePricePerLiter.toFixed(2)} per liter
+                    ETB {(Number(statsData.averagePricePerLiter) || 0).toFixed(2)} per liter
                   </Text>
                   .
                 </Text>
@@ -188,6 +179,12 @@ export default function FuelStatsPage() {
             </Stack>
           </Card>
         </>
+      ) : selectedVehicleId && isStatsFetching ? (
+        <Card withBorder padding="lg">
+          <Group justify="center">
+            <Loader />
+          </Group>
+        </Card>
       ) : (
         <Card withBorder padding="lg">
           <Text c="dimmed" ta="center">
diff --git a/apps/edr-freight-web/backoffice/src/pages/fleet/MaintenancePage.tsx b/apps/edr-freight-web/backoffice/src/pages/fleet/MaintenancePage.tsx
index b2bd155d3..3aa2506b5 100644
--- a/apps/edr-freight-web/backoffice/src/pages/fleet/MaintenancePage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/fleet/MaintenancePage.tsx
@@ -1,12 +1,26 @@
-import { useState, useMemo } from 'react';
+import { useState } from 'react';
 import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
-import { Card, Button, Modal, Stack, Group, Grid, Select, TextInput, NumberInput, Table, Badge, Text, Container } from '@mantine/core';
-import { DateInput } from '@mantine/dates';
+import {
+  Card,
+  Button,
+  Modal,
+  Stack,
+  Group,
+  Select,
+  TextInput,
+  NumberInput,
+  Table,
+  Badge,
+  Text,
+  Title,
+  Container,
+} from '@mantine/core';
 import { Plus } from 'lucide-react';
+import Breadcrumbs from '@/components/ui/Breadcrumbs';
+import { useToast } from '@/hooks/use-toast';
 import { QUERY_KEYS } from '@/constants/QUERY_KEYS';
-import { api } from '@/services/api';
-import { vehiclesService } from '@/services/vehicles.service';
-import { freightBrand } from '@/theme/freight-brand';
+import { api } from '@/auth/http';
+import { vehiclesService, type Vehicle as VehicleType } from '@/services/vehicles.service';
 
 interface MaintenanceSchedule {
   id: string;
@@ -21,21 +35,23 @@ interface MaintenanceSchedule {
   serviceProvider?: string;
 }
 
+const emptyForm = {
+  maintenanceType: 'PREVENTIVE',
+  description: '',
+  scheduledDate: new Date().toISOString().split('T')[0],
+  estimatedCost: 0,
+  serviceProvider: '',
+  notes: '',
+};
+
 export function MaintenancePage() {
+  const { toast } = useToast();
+  const queryClient = useQueryClient();
   const [selectedVehicle, setSelectedVehicle] = useState<string | null>(null);
   const [openScheduleModal, setOpenScheduleModal] = useState(false);
-  const [formData, setFormData] = useState({
-    maintenanceType: 'PREVENTIVE',
-    description: '',
-    scheduledDate: new Date(),
-    estimatedCost: 0,
-    serviceProvider: '',
-    notes: '',
-  });
+  const [formData, setFormData] = useState(emptyForm);
 
-  const queryClient = useQueryClient();
-
-  const { data: vehicles } = useQuery({
+  const { data: vehiclesData } = useQuery({
     queryKey: QUERY_KEYS.VEHICLES.list(),
     queryFn: async () => {
       const res = await vehiclesService.getAll({ limit: 1000 });
@@ -45,36 +61,49 @@ export function MaintenancePage() {
 
   const { data: upcoming, isLoading } = useQuery({
     queryKey: QUERY_KEYS.MAINTENANCE.upcoming(selectedVehicle || ''),
-    queryFn: () => selectedVehicle ? api.get(`/maintenance/upcoming/${selectedVehicle}`) : Promise.resolve([]),
+    queryFn: async () => {
+      if (!selectedVehicle) return [];
+      const res = await api.get(`/maintenance/upcoming/${selectedVehicle}`);
+      return res.data || [];
+    },
     enabled: !!selectedVehicle,
   });
 
+  const upcomingList: MaintenanceSchedule[] = Array.isArray(upcoming) ? upcoming : [];
+
   const scheduleMutation = useMutation({
     mutationFn: async () => {
       if (!selectedVehicle) return;
-      return api.post('/maintenance/schedules', {
+      const res = await api.post('/maintenance/schedules', {
         vehicleId: selectedVehicle,
         ...formData,
       });
+      return res.data;
     },
     onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: QUERY_KEYS.MAINTENANCE.upcoming(selectedVehicle || '') });
+      toast({ title: 'Maintenance scheduled' });
+      queryClient.invalidateQueries({
+        queryKey: QUERY_KEYS.MAINTENANCE.upcoming(selectedVehicle || ''),
+      });
       setOpenScheduleModal(false);
-      setFormData({
-        maintenanceType: 'PREVENTIVE',
-        description: '',
-        scheduledDate: new Date(),
-        estimatedCost: 0,
-        serviceProvider: '',
-        notes: '',
+      setFormData(emptyForm);
+    },
+    onError: (err: any) => {
+      toast({
+        title: 'Error',
+        description: err?.response?.data?.message ?? 'Failed',
+        variant: 'destructive',
       });
     },
   });
 
-  const vehicleOptions = useMemo(
-    () => vehicles?.map(v => ({ label: v.registrationNumber || v.id, value: v.id })) || [],
-    [vehicles]
-  );
+  const vehicleOptions =
+    vehiclesData?.map((v: VehicleType) => ({
+      value: v.id,
+      label: v.plateNumber
+        ? `${v.plateNumber} - ${v.manufacturer} ${v.model}`
+        : v.registrationNumber || v.id,
+    })) || [];
 
   const statusColor = (status: string) => {
     const colors: Record<string, string> = {
@@ -88,66 +117,85 @@ export function MaintenancePage() {
 
   return (
     <Container size="xl" py="xl" px="lg">
+      <Breadcrumbs items={[{ label: 'Fleet' }, { label: 'Maintenance' }]} />
+
+      <Group justify="space-between" mb="lg">
+        <Title order={1}>Maintenance</Title>
+        <Button
+          onClick={() => setOpenScheduleModal(true)}
+          color="edr-green"
+          leftSection={<Plus size={16} />}
+          disabled={!selectedVehicle}
+        >
+          New Schedule
+        </Button>
+      </Group>
+
       <Stack gap="md">
-      <Card>
-        <Card.Section p="md" withBorder>
-          <Group justify="space-between">
-            <Text fw={500}>Schedule Maintenance</Text>
-            <Button onClick={() => setOpenScheduleModal(true)} color="edr-green" leftSection={<Plus size={16} />}>
-              New Schedule
-            </Button>
-          </Group>
-        </Card.Section>
-        <Card.Section p="md">
+        <Card withBorder padding="md">
           <Select
             label="Select Vehicle"
             placeholder="Pick a vehicle"
             data={vehicleOptions}
             value={selectedVehicle}
             onChange={setSelectedVehicle}
+            searchable
           />
-        </Card.Section>
-      </Card>
-
-      {selectedVehicle && (
-        <Card>
-          <Card.Section p="md" withBorder>
-            <Text fw={500}>Upcoming Maintenance</Text>
-          </Card.Section>
-          <Card.Section p="md">
-            {isLoading ? (
-              <Text>Loading...</Text>
-            ) : (upcoming || []).length > 0 ? (
-              <Table>
-                <Table.Thead>
-                  <Table.Tr>
-                    <Table.Th>Type</Table.Th>
-                    <Table.Th>Description</Table.Th>
-                    <Table.Th>Scheduled</Table.Th>
-                    <Table.Th>Est. Cost</Table.Th>
-                    <Table.Th>Status</Table.Th>
-                  </Table.Tr>
-                </Table.Thead>
-                <Table.Tbody>
-                  {(upcoming as MaintenanceSchedule[]).map(m => (
-                    <Table.Tr key={m.id}>
-                      <Table.Td>{m.maintenanceType}</Table.Td>
-                      <Table.Td>{m.description}</Table.Td>
-                      <Table.Td>{new Date(m.scheduledDate).toLocaleDateString()}</Table.Td>
-                      <Table.Td>${m.estimatedCost?.toFixed(2) || '—'}</Table.Td>
-                      <Table.Td>
-                        <Badge color={statusColor(m.status)}>{m.status}</Badge>
-                      </Table.Td>
-                    </Table.Tr>
-                  ))}
-                </Table.Tbody>
-              </Table>
-            ) : (
-              <Text c="dimmed">No upcoming maintenance</Text>
-            )}
-          </Card.Section>
         </Card>
-      )}
+
+        {!selectedVehicle ? (
+          <Card withBorder padding="lg">
+            <Text c="dimmed" ta="center">
+              Select a vehicle to view its maintenance schedule
+            </Text>
+          </Card>
+        ) : (
+          <Card withBorder>
+            <Card.Section p="md" withBorder>
+              <Text fw={500}>Upcoming Maintenance</Text>
+            </Card.Section>
+            <Card.Section p="md">
+              {isLoading ? (
+                <Text>Loading...</Text>
+              ) : upcomingList.length > 0 ? (
+                <Table striped highlightOnHover>
+                  <Table.Thead>
+                    <Table.Tr>
+                      <Table.Th>Type</Table.Th>
+                      <Table.Th>Description</Table.Th>
+                      <Table.Th>Scheduled</Table.Th>
+                      <Table.Th>Est. Cost</Table.Th>
+                      <Table.Th>Status</Table.Th>
+                    </Table.Tr>
+                  </Table.Thead>
+                  <Table.Tbody>
+                    {upcomingList.map((m) => (
+                      <Table.Tr key={m.id}>
+                        <Table.Td>{m.maintenanceType}</Table.Td>
+                        <Table.Td>{m.description}</Table.Td>
+                        <Table.Td>{new Date(m.scheduledDate).toLocaleDateString()}</Table.Td>
+                        <Table.Td>
+                          {m.estimatedCost != null
+                            ? `ETB ${Number(m.estimatedCost).toLocaleString('en-US', {
+                                minimumFractionDigits: 2,
+                                maximumFractionDigits: 2,
+                              })}`
+                            : '—'}
+                        </Table.Td>
+                        <Table.Td>
+                          <Badge color={statusColor(m.status)}>{m.status}</Badge>
+                        </Table.Td>
+                      </Table.Tr>
+                    ))}
+                  </Table.Tbody>
+                </Table>
+              ) : (
+                <Text c="dimmed">No upcoming maintenance</Text>
+              )}
+            </Card.Section>
+          </Card>
+        )}
+      </Stack>
 
       <Modal
         opened={openScheduleModal}
@@ -160,47 +208,52 @@ export function MaintenancePage() {
             label="Type"
             data={['PREVENTIVE', 'CORRECTIVE', 'INSPECTION', 'REPAIR']}
             value={formData.maintenanceType}
-            onChange={v => setFormData({ ...formData, maintenanceType: v || 'PREVENTIVE' })}
+            onChange={(v) => setFormData({ ...formData, maintenanceType: v || 'PREVENTIVE' })}
           />
           <TextInput
             label="Description"
             placeholder="What needs to be done?"
             value={formData.description}
-            onChange={e => setFormData({ ...formData, description: e.currentTarget.value })}
+            onChange={(e) => setFormData({ ...formData, description: e.currentTarget.value })}
           />
-          <DateInput
+          <TextInput
             label="Scheduled Date"
+            type="date"
             value={formData.scheduledDate}
-            onChange={d => setFormData({ ...formData, scheduledDate: d || new Date() })}
+            onChange={(e) => setFormData({ ...formData, scheduledDate: e.currentTarget.value })}
           />
           <NumberInput
             label="Estimated Cost"
+            min={0}
             value={formData.estimatedCost}
-            onChange={v => setFormData({ ...formData, estimatedCost: Number(v) })}
+            onChange={(v) => setFormData({ ...formData, estimatedCost: Number(v) })}
           />
           <TextInput
             label="Service Provider"
             placeholder="e.g., John's Auto Repair"
             value={formData.serviceProvider}
-            onChange={e => setFormData({ ...formData, serviceProvider: e.currentTarget.value })}
+            onChange={(e) => setFormData({ ...formData, serviceProvider: e.currentTarget.value })}
           />
           <TextInput
             label="Notes"
             placeholder="Additional notes"
             value={formData.notes}
-            onChange={e => setFormData({ ...formData, notes: e.currentTarget.value })}
+            onChange={(e) => setFormData({ ...formData, notes: e.currentTarget.value })}
           />
           <Group justify="flex-end">
             <Button variant="light" onClick={() => setOpenScheduleModal(false)}>
               Cancel
             </Button>
-            <Button onClick={() => scheduleMutation.mutate()} loading={scheduleMutation.isPending}>
+            <Button
+              onClick={() => scheduleMutation.mutate()}
+              loading={scheduleMutation.isPending}
+              disabled={!selectedVehicle}
+            >
               Schedule
             </Button>
           </Group>
         </Stack>
       </Modal>
-      </Stack>
     </Container>
   );
 }
diff --git a/apps/edr-freight-web/backoffice/src/pages/fleet/RoutesPage.tsx b/apps/edr-freight-web/backoffice/src/pages/fleet/RoutesPage.tsx
index a40579027..bdba6dc97 100644
--- a/apps/edr-freight-web/backoffice/src/pages/fleet/RoutesPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/fleet/RoutesPage.tsx
@@ -24,7 +24,6 @@ import {
   SimpleGrid,
   Stack,
   Text,
-  TextInput,
   ThemeIcon,
   Tooltip,
 } from "@mantine/core";
diff --git a/apps/edr-freight-web/backoffice/src/pages/fleet/TrackingPage.tsx b/apps/edr-freight-web/backoffice/src/pages/fleet/TrackingPage.tsx
index 8230a7446..f60c7f72b 100644
--- a/apps/edr-freight-web/backoffice/src/pages/fleet/TrackingPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/fleet/TrackingPage.tsx
@@ -1,6 +1,6 @@
 import { useState, useMemo } from 'react';
 import { useQuery } from '@tanstack/react-query';
-import { Container, Grid, Card, Stack, Group, Select, Text, Badge, Button, Box, Table, ThemeIcon, SimpleGrid } from '@mantine/core';
+import { Container, Grid, Card, Stack, Group, Select, Text, Badge, Button, Box, Table, SimpleGrid } from '@mantine/core';
 import { MapPin, Navigation, Radio, Activity } from 'lucide-react';
 import Breadcrumbs from '@/components/ui/Breadcrumbs';
 import { QUERY_KEYS } from '@/constants/QUERY_KEYS';
@@ -24,8 +24,8 @@ interface GPSLocation {
   lastUpdate?: string;
 }
 
-// Mock GPS data for demo
-const generateMockGPS = (index: number): GPSLocation => ({
+// Mock GPS data for demo (no real GPS backend exists — these are simulated values)
+const generateMockGPS = (): GPSLocation => ({
   lat: 9.0 + Math.random() * 0.5,
   lng: 38.7 + Math.random() * 0.5,
   speed: Math.floor(Math.random() * 120),
@@ -36,7 +36,6 @@ const generateMockGPS = (index: number): GPSLocation => ({
 export function TrackingPage() {
   const [selectedVehicleId, setSelectedVehicleId] = useState<string | null>(null);
   const [mapCenter] = useState({ lat: 9.0, lng: 38.8 });
-  const mapZoom = 10;
 
   const { data: vehicles = [] } = useQuery({
     queryKey: QUERY_KEYS.VEHICLES.list(),
@@ -48,9 +47,9 @@ export function TrackingPage() {
 
   // Generate mock GPS data for each vehicle
   const vehiclesWithGPS = useMemo(() => {
-    return (vehicles as Vehicle[]).map((v, idx) => ({
+    return (vehicles as Vehicle[]).map((v) => ({
       ...v,
-      gps: generateMockGPS(idx),
+      gps: generateMockGPS(),
     }));
   }, [vehicles]);
 
@@ -84,9 +83,14 @@ export function TrackingPage() {
       <Stack gap="xl">
         <Group justify="space-between">
           <div>
-            <Text fw={700} size="xl">
-              Real-Time Vehicle Tracking
-            </Text>
+            <Group gap="xs" align="center">
+              <Text fw={700} size="xl">
+                Real-Time Vehicle Tracking
+              </Text>
+              <Badge color="yellow" variant="light">
+                Simulated GPS
+              </Badge>
+            </Group>
             <Text c="dimmed" size="sm">
               Monitor vehicle locations, speed, and status
             </Text>
@@ -109,17 +113,18 @@ export function TrackingPage() {
               </Card.Section>
 
               <Card.Section p="md">
-                <Box
-                  pos="relative"
-                  style={{
-                    width: mapWidth,
-                    height: mapHeight,
-                    backgroundColor: '#f0f8f7',
-                    border: `2px solid ${freightBrand.primary}`,
-                    borderRadius: '8px',
-                    overflow: 'hidden',
-                  }}
-                >
+                <Box style={{ overflowX: 'auto', maxWidth: '100%' }}>
+                  <Box
+                    pos="relative"
+                    style={{
+                      width: mapWidth,
+                      height: mapHeight,
+                      backgroundColor: '#f0f8f7',
+                      border: `2px solid ${freightBrand.primary}`,
+                      borderRadius: '8px',
+                      overflow: 'hidden',
+                    }}
+                  >
                   {/* Grid background */}
                   <svg
                     width={mapWidth}
@@ -199,7 +204,11 @@ export function TrackingPage() {
                       📍 Addis Ababa, Ethiopia
                     </Text>
                   </Box>
+                  </Box>
                 </Box>
+                <Text size="xs" c="dimmed" mt="xs">
+                  Simulated map — coordinates, speed, and heading are demo values, not live GPS.
+                </Text>
               </Card.Section>
             </Card>
           </Grid.Col>
@@ -314,7 +323,7 @@ export function TrackingPage() {
                 <Stack gap="md">
                   <Text fw={500}>Tracked Vehicles ({trackableVehicles.length})</Text>
                   <div style={{ maxHeight: '300px', overflowY: 'auto' }}>
-                    <Table size="sm">
+                    <Table>
                       <Table.Tbody>
                         {trackableVehicles.map(v => (
                           <Table.Tr
diff --git a/apps/edr-freight-web/backoffice/src/pages/fleet/VehicleDetailPage.tsx b/apps/edr-freight-web/backoffice/src/pages/fleet/VehicleDetailPage.tsx
new file mode 100644
index 000000000..6a3956685
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/pages/fleet/VehicleDetailPage.tsx
@@ -0,0 +1,453 @@
+import { useMemo } from "react";
+import { useParams, useNavigate } from "react-router-dom";
+import { useQuery } from "@tanstack/react-query";
+import {
+  ActionIcon,
+  Badge,
+  Card,
+  Center,
+  Container,
+  Group,
+  Loader,
+  SimpleGrid,
+  Stack,
+  Table,
+  Tabs,
+  Text,
+  Timeline,
+  Title,
+} from "@mantine/core";
+import {
+  ArrowLeft,
+  Fuel,
+  History,
+  Route,
+  Truck,
+  User,
+  Wrench,
+} from "lucide-react";
+
+import { api } from "@/auth/http";
+import { vehiclesService } from "@/services/vehicles.service";
+import { driversService } from "@/services/drivers.service";
+import { fleetHistoryService } from "@/services/fleet-history.service";
+
+interface MaintenanceCost {
+  id: string;
+  incurredDate: string;
+  costAmount: number;
+  costType: string;
+  description?: string | null;
+  serviceProvider?: string | null;
+  invoiceNumber?: string | null;
+}
+interface FuelPurchase {
+  id: string;
+  purchaseDate: string;
+  liters: number;
+  costPerLiter: number;
+  totalCost: number;
+  fuelStation?: string | null;
+  odometerReading?: number | null;
+}
+interface MileRecord {
+  id: string;
+  status: string;
+  exactKm?: number | null;
+  estimatedKm?: number | null;
+  remainingPayment?: number | null;
+  advancedPayment?: number | null;
+  booking?: { reference?: string } | null;
+  bookingId: string;
+}
+
+const fmtDate = (iso?: string | null) => {
+  if (!iso) return "—";
+  const d = new Date(iso);
+  return Number.isNaN(d.getTime()) ? "—" : d.toLocaleDateString();
+};
+const fmtDateTime = (iso?: string | null) => {
+  if (!iso) return "—";
+  const d = new Date(iso);
+  return Number.isNaN(d.getTime()) ? "—" : d.toLocaleString();
+};
+const money = (n?: number | null) =>
+  n == null ? "—" : `ETB ${Number(n).toLocaleString(undefined, { maximumFractionDigits: 2 })}`;
+
+const InfoRow = ({ label, value }: { label: string; value: React.ReactNode }) => (
+  <Group justify="space-between" wrap="nowrap">
+    <Text size="xs" c="dimmed" tt="uppercase">{label}</Text>
+    <Text size="sm" fw={500} ta="right">{value}</Text>
+  </Group>
+);
+
+const Loading = () => (
+  <Center py="xl"><Loader size="sm" /></Center>
+);
+
+const VehicleDetailPage = () => {
+  const { id = "" } = useParams<{ id: string }>();
+  const navigate = useNavigate();
+
+  const { data: vehicle, isLoading } = useQuery({
+    queryKey: ["vehicle", id],
+    queryFn: () => vehiclesService.getById(id).then((r) => r.data),
+    enabled: Boolean(id),
+  });
+
+  const plate = vehicle
+    ? [vehicle.code, vehicle.plateNumber].filter(Boolean).join(" · ")
+    : "";
+
+  return (
+    <Container size="xl" py="xl" px="lg">
+      <Group gap="sm" mb="md" wrap="nowrap">
+        <ActionIcon variant="subtle" onClick={() => navigate("/dashboard/vehicles")} aria-label="Back">
+          <ArrowLeft size={18} />
+        </ActionIcon>
+        <Truck size={22} />
+        <Stack gap={0}>
+          <Title order={4}>{plate || "Vehicle"}</Title>
+          {vehicle && (
+            <Group gap="xs">
+              <Badge size="sm" variant="light">{vehicle.status}</Badge>
+              <Badge size="sm" variant="light" color={vehicle.availability === "FREE" ? "green" : "orange"}>
+                {vehicle.availability}
+              </Badge>
+              {vehicle.vehicleType && <Text size="xs" c="dimmed">{vehicle.vehicleType}</Text>}
+            </Group>
+          )}
+        </Stack>
+      </Group>
+
+      {isLoading ? (
+        <Loading />
+      ) : !vehicle ? (
+        <Text c="dimmed">Vehicle not found.</Text>
+      ) : (
+        <Tabs defaultValue="overview">
+          <Tabs.List>
+            <Tabs.Tab value="overview" leftSection={<Truck size={14} />}>Overview</Tabs.Tab>
+            <Tabs.Tab value="driver" leftSection={<User size={14} />}>Driver</Tabs.Tab>
+            <Tabs.Tab value="history" leftSection={<History size={14} />}>History</Tabs.Tab>
+            <Tabs.Tab value="maintenance" leftSection={<Wrench size={14} />}>Maintenance</Tabs.Tab>
+            <Tabs.Tab value="fuel" leftSection={<Fuel size={14} />}>Fuel</Tabs.Tab>
+            <Tabs.Tab value="mile" leftSection={<Route size={14} />}>First/Last mile</Tabs.Tab>
+          </Tabs.List>
+
+          <Tabs.Panel value="overview" pt="lg">
+            <Card withBorder radius="md" padding="md">
+              <SimpleGrid cols={{ base: 1, sm: 2 }} spacing="sm">
+                <InfoRow label="Plate" value={vehicle.plateNumber ?? "—"} />
+                <InfoRow label="Code" value={vehicle.code ?? "—"} />
+                <InfoRow label="Registration" value={vehicle.registrationNumber ?? "—"} />
+                <InfoRow label="Type" value={vehicle.vehicleType ?? "—"} />
+                <InfoRow label="Manufacturer" value={vehicle.manufacturer ?? "—"} />
+                <InfoRow label="Model" value={vehicle.model ?? "—"} />
+                <InfoRow label="Year" value={vehicle.year ?? "—"} />
+                <InfoRow label="Fuel type" value={vehicle.fuelType ?? "—"} />
+                <InfoRow label="Capacity" value={vehicle.capacity ?? "—"} />
+                <InfoRow label="Power plate" value={vehicle.powerPlateNo ?? "—"} />
+                <InfoRow label="Trailer plate" value={vehicle.trailerPlateNo ?? "—"} />
+                <InfoRow label="Status" value={vehicle.status ?? "—"} />
+                <InfoRow label="Availability" value={vehicle.availability ?? "—"} />
+                <InfoRow label="Assigned driver" value={vehicle.assignedDriverName ?? "—"} />
+              </SimpleGrid>
+            </Card>
+          </Tabs.Panel>
+
+          <Tabs.Panel value="driver" pt="lg">
+            <DriverTab vehicleId={id} driverId={vehicle.assignedDriverId} fallbackName={vehicle.assignedDriverName} />
+          </Tabs.Panel>
+
+          <Tabs.Panel value="history" pt="lg">
+            <HistoryTab vehicleId={id} />
+          </Tabs.Panel>
+
+          <Tabs.Panel value="maintenance" pt="lg">
+            <MaintenanceTab vehicleId={id} />
+          </Tabs.Panel>
+
+          <Tabs.Panel value="fuel" pt="lg">
+            <FuelTab vehicleId={id} />
+          </Tabs.Panel>
+
+          <Tabs.Panel value="mile" pt="lg">
+            <MileTab vehicleId={id} />
+          </Tabs.Panel>
+        </Tabs>
+      )}
+    </Container>
+  );
+};
+
+const DriverTab = ({
+  vehicleId,
+  driverId,
+  fallbackName,
+}: {
+  vehicleId: string;
+  driverId?: string | null;
+  fallbackName?: string | null;
+}) => {
+  const { data: driver } = useQuery({
+    queryKey: ["driver", driverId],
+    queryFn: () => driversService.getById(driverId!).then((r) => r.data),
+    enabled: Boolean(driverId),
+  });
+  // All drivers that have driven this vehicle, from the assignment history.
+  const { data: history = [], isLoading } = useQuery({
+    queryKey: ["vehicle-history", vehicleId],
+    queryFn: () => fleetHistoryService.vehicle(vehicleId),
+  });
+  const drivers = history
+    .filter((e) => e.eventType === "DRIVER_ASSIGNED")
+    .map((e) => ({
+      id: e.id,
+      driverId: e.driverId,
+      name: (typeof e.metadata?.driverName === "string" && e.metadata.driverName) || e.label || "Driver",
+      at: e.createdAt,
+    }));
+
+  return (
+    <Stack gap="lg">
+      {driverId && driver ? (
+        <Card withBorder radius="md" padding="md">
+          <Text size="sm" fw={600} mb="sm">Current driver</Text>
+          <SimpleGrid cols={{ base: 1, sm: 2 }} spacing="sm">
+            <InfoRow label="Name" value={`${driver.firstName ?? ""} ${driver.lastName ?? ""}`.trim() || "—"} />
+            <InfoRow label="Phone" value={driver.phoneNumber ?? "—"} />
+            <InfoRow label="Email" value={driver.email ?? "—"} />
+            <InfoRow label="License no." value={driver.licenseNumber ?? "—"} />
+            <InfoRow label="License expiry" value={fmtDate(driver.licenseExpiryDate)} />
+            <InfoRow label="Status" value={driver.status ?? "—"} />
+          </SimpleGrid>
+        </Card>
+      ) : (
+        <Text c="dimmed">{fallbackName ? `Assigned: ${fallbackName}` : "No driver currently assigned."}</Text>
+      )}
+
+      <Stack gap={4}>
+        <Text size="sm" fw={600}>Driver history ({drivers.length})</Text>
+        {isLoading ? (
+          <Loading />
+        ) : drivers.length === 0 ? (
+          <Text size="sm" c="dimmed">No driver assignments recorded.</Text>
+        ) : (
+          <Table striped highlightOnHover>
+            <Table.Thead>
+              <Table.Tr>
+                <Table.Th>Driver</Table.Th><Table.Th>Assigned</Table.Th>
+              </Table.Tr>
+            </Table.Thead>
+            <Table.Tbody>
+              {drivers.map((d) => (
+                <Table.Tr key={d.id}>
+                  <Table.Td>{d.name}</Table.Td>
+                  <Table.Td>{fmtDateTime(d.at)}</Table.Td>
+                </Table.Tr>
+              ))}
+            </Table.Tbody>
+          </Table>
+        )}
+      </Stack>
+    </Stack>
+  );
+};
+
+const HistoryTab = ({ vehicleId }: { vehicleId: string }) => {
+  const { data = [], isLoading } = useQuery({
+    queryKey: ["vehicle-history", vehicleId],
+    queryFn: () => fleetHistoryService.vehicle(vehicleId),
+  });
+  if (isLoading) return <Loading />;
+  if (!data.length) return <Text c="dimmed">No activity recorded yet.</Text>;
+  return (
+    <Timeline active={data.length} bulletSize={18} lineWidth={2}>
+      {data.map((e) => (
+        <Timeline.Item key={e.id} title={<Text size="sm" fw={500}>{e.eventType.replaceAll("_", " ")}</Text>}>
+          {(e.label || e.fromValue || e.toValue) && (
+            <Text size="xs" c="dimmed">
+              {[e.label, e.fromValue && e.toValue ? `${e.fromValue} → ${e.toValue}` : e.toValue]
+                .filter(Boolean)
+                .join(" · ")}
+            </Text>
+          )}
+          <Text size="xs" c="dimmed" mt={2}>{fmtDateTime(e.createdAt)}</Text>
+        </Timeline.Item>
+      ))}
+    </Timeline>
+  );
+};
+
+const MaintenanceTab = ({ vehicleId }: { vehicleId: string }) => {
+  const { data = [], isLoading } = useQuery({
+    queryKey: ["vehicle-maintenance", vehicleId],
+    queryFn: () => api.get<MaintenanceCost[]>(`/maintenance/history/${vehicleId}`).then((r) => r.data),
+  });
+  const total = useMemo(() => data.reduce((s, m) => s + (Number(m.costAmount) || 0), 0), [data]);
+  if (isLoading) return <Loading />;
+  return (
+    <Stack gap="sm">
+      <Group justify="space-between">
+        <Text size="sm" c="dimmed">Last 12 months</Text>
+        <Text size="sm" fw={600}>Total: {money(total)}</Text>
+      </Group>
+      {data.length === 0 ? (
+        <Text c="dimmed">No maintenance records.</Text>
+      ) : (
+        <Table.ScrollContainer minWidth={600}>
+          <Table striped highlightOnHover>
+            <Table.Thead>
+              <Table.Tr>
+                <Table.Th>Date</Table.Th><Table.Th>Type</Table.Th><Table.Th>Amount</Table.Th>
+                <Table.Th>Description</Table.Th><Table.Th>Provider</Table.Th>
+              </Table.Tr>
+            </Table.Thead>
+            <Table.Tbody>
+              {data.map((m) => (
+                <Table.Tr key={m.id}>
+                  <Table.Td>{fmtDate(m.incurredDate)}</Table.Td>
+                  <Table.Td><Badge size="sm" variant="light">{m.costType}</Badge></Table.Td>
+                  <Table.Td>{money(m.costAmount)}</Table.Td>
+                  <Table.Td>{m.description ?? "—"}</Table.Td>
+                  <Table.Td>{m.serviceProvider ?? "—"}</Table.Td>
+                </Table.Tr>
+              ))}
+            </Table.Tbody>
+          </Table>
+        </Table.ScrollContainer>
+      )}
+    </Stack>
+  );
+};
+
+const FuelTab = ({ vehicleId }: { vehicleId: string }) => {
+  const { data = [], isLoading } = useQuery({
+    queryKey: ["vehicle-fuel", vehicleId],
+    queryFn: () => {
+      const end = new Date();
+      const start = new Date();
+      start.setMonth(start.getMonth() - 12);
+      const qs = `startDate=${start.toISOString()}&endDate=${end.toISOString()}`;
+      return api.get<FuelPurchase[]>(`/fuel/purchases/${vehicleId}?${qs}`).then((r) => r.data);
+    },
+  });
+  const totals = useMemo(
+    () => ({
+      liters: data.reduce((s, f) => s + (Number(f.liters) || 0), 0),
+      cost: data.reduce((s, f) => s + (Number(f.totalCost) || 0), 0),
+    }),
+    [data],
+  );
+  if (isLoading) return <Loading />;
+  return (
+    <Stack gap="sm">
+      <SimpleGrid cols={{ base: 2, sm: 3 }} spacing="sm">
+        <Card withBorder radius="md" padding="sm">
+          <Text size="xs" c="dimmed">Total litres</Text>
+          <Text fw={700}>{totals.liters.toLocaleString(undefined, { maximumFractionDigits: 1 })} L</Text>
+        </Card>
+        <Card withBorder radius="md" padding="sm">
+          <Text size="xs" c="dimmed">Total fuel cost</Text>
+          <Text fw={700}>{money(totals.cost)}</Text>
+        </Card>
+        <Card withBorder radius="md" padding="sm">
+          <Text size="xs" c="dimmed">Purchases</Text>
+          <Text fw={700}>{data.length}</Text>
+        </Card>
+      </SimpleGrid>
+      {data.length === 0 ? (
+        <Text c="dimmed">No fuel purchases in the last 12 months.</Text>
+      ) : (
+        <Table.ScrollContainer minWidth={640}>
+          <Table striped highlightOnHover>
+            <Table.Thead>
+              <Table.Tr>
+                <Table.Th>Date</Table.Th><Table.Th>Litres</Table.Th><Table.Th>Cost/L</Table.Th>
+                <Table.Th>Total</Table.Th><Table.Th>Odometer</Table.Th><Table.Th>Station</Table.Th>
+              </Table.Tr>
+            </Table.Thead>
+            <Table.Tbody>
+              {data.map((f) => (
+                <Table.Tr key={f.id}>
+                  <Table.Td>{fmtDate(f.purchaseDate)}</Table.Td>
+                  <Table.Td>{f.liters} L</Table.Td>
+                  <Table.Td>{money(f.costPerLiter)}</Table.Td>
+                  <Table.Td>{money(f.totalCost)}</Table.Td>
+                  <Table.Td>{f.odometerReading ?? "—"}</Table.Td>
+                  <Table.Td>{f.fuelStation ?? "—"}</Table.Td>
+                </Table.Tr>
+              ))}
+            </Table.Tbody>
+          </Table>
+        </Table.ScrollContainer>
+      )}
+    </Stack>
+  );
+};
+
+const mileTotal = (rows: MileRecord[]) =>
+  rows.reduce((s, r) => s + (Number(r.remainingPayment) || 0), 0);
+
+const MileTable = ({ title, rows }: { title: string; rows: MileRecord[] }) => (
+  <Stack gap={4}>
+    <Group justify="space-between">
+      <Text size="sm" fw={600}>{title} ({rows.length})</Text>
+      <Text size="sm" fw={600}>Total: {money(mileTotal(rows))}</Text>
+    </Group>
+    {rows.length === 0 ? (
+      <Text size="sm" c="dimmed">None.</Text>
+    ) : (
+      <Table striped>
+        <Table.Thead>
+          <Table.Tr>
+            <Table.Th>Booking</Table.Th><Table.Th>Status</Table.Th>
+            <Table.Th>Distance (km)</Table.Th><Table.Th>Cost</Table.Th>
+          </Table.Tr>
+        </Table.Thead>
+        <Table.Tbody>
+          {rows.map((r) => (
+            <Table.Tr key={r.id}>
+              <Table.Td>{r.booking?.reference ?? r.bookingId}</Table.Td>
+              <Table.Td><Badge size="sm" variant="light">{r.status}</Badge></Table.Td>
+              <Table.Td>{r.exactKm ?? r.estimatedKm ?? "—"}</Table.Td>
+              <Table.Td>{money(r.remainingPayment)}</Table.Td>
+            </Table.Tr>
+          ))}
+        </Table.Tbody>
+      </Table>
+    )}
+  </Stack>
+);
+
+const MileTab = ({ vehicleId }: { vehicleId: string }) => {
+  const first = useQuery({
+    queryKey: ["vehicle-first-mile", vehicleId],
+    queryFn: () =>
+      api.get<{ data: MileRecord[] }>(`/first-mile?vehicleId=${vehicleId}&pageSize=1000`).then((r) => r.data.data ?? []),
+  });
+  const last = useQuery({
+    queryKey: ["vehicle-last-mile", vehicleId],
+    queryFn: () =>
+      api.get<{ data: MileRecord[] }>(`/last-mile?vehicleId=${vehicleId}&pageSize=1000`).then((r) => r.data.data ?? []),
+  });
+  if (first.isLoading || last.isLoading) return <Loading />;
+  const firstRows = first.data ?? [];
+  const lastRows = last.data ?? [];
+  const grandTotal = mileTotal(firstRows) + mileTotal(lastRows);
+  return (
+    <Stack gap="lg">
+      <Card withBorder radius="md" padding="sm">
+        <Group justify="space-between">
+          <Text size="sm" c="dimmed">Total first + last mile revenue for this vehicle</Text>
+          <Text fw={700}>{money(grandTotal)}</Text>
+        </Group>
+      </Card>
+      <MileTable title="First-mile" rows={firstRows} />
+      <MileTable title="Last-mile" rows={lastRows} />
+    </Stack>
+  );
+};
+
+export default VehicleDetailPage;
diff --git a/apps/edr-freight-web/backoffice/src/pages/fleet/config/drivers.ts b/apps/edr-freight-web/backoffice/src/pages/fleet/config/drivers.ts
index 1274b0972..fdfdd367d 100644
--- a/apps/edr-freight-web/backoffice/src/pages/fleet/config/drivers.ts
+++ b/apps/edr-freight-web/backoffice/src/pages/fleet/config/drivers.ts
@@ -8,11 +8,18 @@ const DRIVER_STATUS_OPTIONS = [
   { label: "On leave", value: "ON_LEAVE" },
 ];
 
+const DRIVER_GENDER_OPTIONS = [
+  { label: "Male", value: "MALE" },
+  { label: "Female", value: "FEMALE" },
+  { label: "Other", value: "OTHER" },
+];
+
 export const driversConfig: FleetResourceConfig = {
   slug: "drivers",
   label: "Drivers",
   subtitle: "Manage driver records and licenses",
   basePath: "/dashboard/drivers",
+  detailPath: "/dashboard/drivers/:id",
   addLabel: "Add Driver",
   entityLabel: "Driver",
   searchPlaceholder: "Search drivers…",
@@ -29,24 +36,28 @@ export const driversConfig: FleetResourceConfig = {
       options: DRIVER_STATUS_OPTIONS,
     },
   ],
+  faydaVerification: true,
   searchKeys: ["firstName", "lastName", "email", "phoneNumber", "licenseNumber", "status"],
   columns: [
-    { id: "licenseNumber", header: "License Number", accessorKey: "licenseNumber", format: "code", size: 140 },
+    { id: "licenseNumber", header: "Driver's License Number", accessorKey: "licenseNumber", format: "code", size: 180 },
     { id: "firstName", header: "First Name", accessorKey: "firstName", format: "code", size: 120 },
     { id: "lastName", header: "Last Name", accessorKey: "lastName", format: "code", size: 120 },
     { id: "email", header: "Email", accessorKey: "email", format: "code", size: 180 },
     { id: "phoneNumber", header: "Phone", accessorKey: "phoneNumber", format: "code", size: 120 },
+    { id: "gender", header: "Gender", accessorKey: "gender", format: "code", size: 90 },
     { id: "licenseExpiryDate", header: "License Expiry", accessorKey: "licenseExpiryDate", format: "code", size: 130 },
     { id: "status", header: "Status", accessorKey: "status", format: "statusBadge", size: 100 },
+    { id: "faydaVerified", header: "Fayda", accessorKey: "faydaVerified", format: "verifiedBadge", size: 90 },
   ],
   formFields: [
-    { name: "licenseNumber", label: "License Number", type: "text", required: true },
-    { name: "firstName", label: "First Name", type: "text", required: true },
-    { name: "lastName", label: "Last Name", type: "text", required: true },
-    { name: "email", label: "Email", type: "email", required: true },
-    { name: "phoneNumber", label: "Phone Number", type: "text", required: true },
-    { name: "dateOfBirth", label: "Date of Birth", type: "date", required: true },
-    { name: "licenseExpiryDate", label: "License Expiry Date", type: "date", required: true },
+    { name: "licenseNumber", label: "Driver's License Number", type: "text", required: true },
+    { name: "firstName", label: "First Name", type: "text", required: true, faydaLocked: true },
+    { name: "lastName", label: "Last Name", type: "text", required: true, faydaLocked: true },
+    { name: "email", label: "Email", type: "email", required: true, faydaLocked: true },
+    { name: "phoneNumber", label: "Phone Number", type: "text", required: true, faydaLocked: true },
+    { name: "dateOfBirth", label: "Date of Birth", type: "date", required: true, faydaLocked: true },
+    { name: "gender", label: "Gender", type: "select", options: DRIVER_GENDER_OPTIONS, faydaLocked: true },
+    { name: "licenseExpiryDate", label: "License Expiry Date", type: "date", required: true, dateBound: "future" },
     { name: "status", label: "Status", type: "select", required: true, options: DRIVER_STATUS_OPTIONS },
     { name: "vehicleTypesAuthorized", label: "Authorized Vehicle Types", type: "multiselect", options: VEHICLE_TYPE_OPTIONS },
     { name: "address", label: "Address", type: "textarea" },
@@ -60,6 +71,7 @@ export const driversConfig: FleetResourceConfig = {
     email: "",
     phoneNumber: "",
     dateOfBirth: "",
+    gender: "",
     licenseExpiryDate: "",
     status: "ACTIVE",
     vehicleTypesAuthorized: [],
diff --git a/apps/edr-freight-web/backoffice/src/pages/fleet/config/resources.ts b/apps/edr-freight-web/backoffice/src/pages/fleet/config/resources.ts
index 41ef390ca..3ac7f2458 100644
--- a/apps/edr-freight-web/backoffice/src/pages/fleet/config/resources.ts
+++ b/apps/edr-freight-web/backoffice/src/pages/fleet/config/resources.ts
@@ -33,17 +33,27 @@ export interface FleetResourceColumn {
   id: string;
   header: string;
   accessorKey: string;
-  format?: ColumnFormat | "statusBadge";
+  format?: ColumnFormat | "statusBadge" | "verifiedBadge";
   size?: number;
 }
 
 export interface FleetFormFieldDef extends FormFieldDef {
   dynamicOptions?: FleetDynamicOptions;
   noneOption?: boolean;
+  /**
+   * Field is owned by the Fayda identity — populated only by verification and
+   * never hand-edited. Rendered disabled in the form.
+   */
+  faydaLocked?: boolean;
+  /**
+   * Direction a `date` field is constrained to. "future" = must be after today
+   * (e.g. a license expiry); "past" (default) = cannot be in the future.
+   */
+  dateBound?: "past" | "future";
 }
 
 export interface FleetListFilterDef {
-  key: "status" | "currentYardId" | "wagonTypeId" | "trainId";
+  key: "status" | "availability" | "currentYardId" | "wagonTypeId" | "trainId";
   label: string;
   options?: Array<{ value: string; label: string }>;
   allLabel?: string;
@@ -73,6 +83,8 @@ export interface FleetResourceConfig {
   cardCodeKey?: string;
   cardSubtitleKey?: string;
   searchKeys: string[];
+  /** Offer Fayda identity verification in the add/edit form (drivers). */
+  faydaVerification?: boolean;
 }
 
 export const FLEET_BASE_PATH_BY_SLUG: Record<FleetResourceSlug, string> = {
diff --git a/apps/edr-freight-web/backoffice/src/pages/fleet/config/vehicles.ts b/apps/edr-freight-web/backoffice/src/pages/fleet/config/vehicles.ts
index de6eb09c7..5e76584ed 100644
--- a/apps/edr-freight-web/backoffice/src/pages/fleet/config/vehicles.ts
+++ b/apps/edr-freight-web/backoffice/src/pages/fleet/config/vehicles.ts
@@ -34,6 +34,7 @@ export const vehiclesConfig: FleetResourceConfig = {
   label: "Vehicles",
   subtitle: "Manage vehicle master data for fleet operations",
   basePath: "/dashboard/vehicles",
+  detailPath: "/dashboard/vehicles/:id",
   addLabel: "Add Vehicle",
   entityLabel: "Vehicle",
   searchPlaceholder: "Search vehicles…",
diff --git a/apps/edr-freight-web/backoffice/src/pages/operations/FirstMilePage.tsx b/apps/edr-freight-web/backoffice/src/pages/operations/FirstMilePage.tsx
index cec4d4351..2b130848c 100644
--- a/apps/edr-freight-web/backoffice/src/pages/operations/FirstMilePage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/operations/FirstMilePage.tsx
@@ -5,17 +5,22 @@ import {
   Eye,
   MoreHorizontal,
   PackageCheck,
+  Plus,
   Printer,
+  Receipt,
   RefreshCw,
   Ruler,
   Trash,
   Truck,
+  X,
 } from "lucide-react";
 import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import { useNavigate } from "react-router-dom";
 import type { ColumnDef } from "@edr/ui-common";
 import { DataTable, DataTableFooter, usePagination } from "@edr/ui-common";
 import {
   ActionIcon,
+  Autocomplete,
   Badge,
   Box,
   Button,
@@ -31,12 +36,12 @@ import {
   Stack,
   Text,
   TextInput,
+  Tooltip,
   UnstyledButton,
-  Alert,
 } from "@mantine/core";
 
 import { ruleEngineTable } from "@/components/ruleEngine/ruleEngineStyles";
-import { FirstMileContainerAllocationTable } from "@/components/FirstMileContainerAllocationTable";
+import { LastMileStepper, type LastMileStepState } from "@/components/operations/LastMileSteps";
 import { ReceiveInventoryModal } from "@/components/warehouses/ReceiveInventoryModal";
 import { QUERY_KEYS } from "@/constants/QUERY_KEYS";
 import { useToast } from "@/hooks/use-toast";
@@ -44,16 +49,16 @@ import {
   FIRST_MILE_STATUSES,
   type FirstMileApiStatus,
   type FirstMileRecord,
+  type FirstMileVehicle,
   firstMileService,
 } from "@/services/first-mile.service";
 import { bookingsService } from "@/services/bookings.service";
 import { vehiclesService } from "@/services/vehicles.service";
 import { ratesService } from "@/services/rates.service";
-import { api } from "@/auth/http";
 import type { BookingDetail } from "@/types/booking";
 
-const formatPrice = (amount: number) =>
-  `ETB ${amount.toLocaleString("en-US", {
+const formatPrice = (amount: number | string | null | undefined, currency = "ETB") =>
+  `${currency || "ETB"} ${(Number(amount) || 0).toLocaleString("en-US", {
     minimumFractionDigits: 2,
     maximumFractionDigits: 2,
   })}`;
@@ -65,6 +70,24 @@ const STATUS_META: Record<FirstMileApiStatus, { label: string; color: string }>
   RECEIVED_TO_PORT: { label: "Received to Port", color: "green" },
 };
 
+// Middle-truncate a long invoice number for the table (full value on hover).
+// "INV-20260704-00002" → "INV-2…02"
+const shortInvoiceNo = (n: string) =>
+  n && n.length > 9 ? `${n.slice(0, 5)}…${n.slice(-2)}` : n;
+
+// Invoice payment state → badge color, keyed by upper-cased status.
+const INVOICE_STATUS_META: Record<string, { label: string; color: string }> = {
+  PAID: { label: "Paid", color: "green" },
+  PARTIALLY_PAID: { label: "Partially Paid", color: "teal" },
+  PENDING: { label: "Pending", color: "yellow" },
+  UNPAID: { label: "Unpaid", color: "yellow" },
+  OPEN: { label: "Open", color: "yellow" },
+  ISSUED: { label: "Issued", color: "blue" },
+  OVERDUE: { label: "Overdue", color: "red" },
+  CANCELLED: { label: "Cancelled", color: "gray" },
+  VOID: { label: "Void", color: "gray" },
+};
+
 const NEXT_STATUS: Partial<Record<FirstMileApiStatus, FirstMileApiStatus>> = {
   PAYMENT_PENDING: "READY_TO_TRANSIT",
   READY_TO_TRANSIT: "IN_TRANSIT",
@@ -91,10 +114,84 @@ const vehicleLabel = (record: FirstMileRecord) => {
   return parts.join(" · ");
 };
 
-const isAssigned = (record: FirstMileRecord) => Boolean(record.vehicleId);
+const isAssigned = (record: FirstMileRecord) =>
+  Boolean(record.vehicleId) || Boolean(record.vehicleAssignments?.length);
+
+/** Real per-physical-container numbers on a booking, in order. Prefers each
+ *  line's `units` (the actual numbers) over the line-level number (often a
+ *  "TBD-…" placeholder). One entry per physical container, for per-truck prefill. */
+const bookingContainerNumbers = (record: FirstMileRecord): string[] => {
+  const out: string[] = [];
+  const real = (n?: string | null): n is string =>
+    Boolean(n) && !/^TBD/i.test(n!.trim());
+  for (const c of record.booking?.bookingContainers ?? []) {
+    const units = [...(c.units ?? [])].sort(
+      (a, b) => (a.sortOrder ?? 0) - (b.sortOrder ?? 0),
+    );
+    if (units.length) {
+      for (const u of units) if (real(u.containerNumber)) out.push(u.containerNumber!);
+    } else if (real(c.containerNumber)) {
+      out.push(c.containerNumber!);
+    }
+  }
+  return out;
+};
+
+/** Progress stages of the first-mile pickup workflow, for the detail stepper. */
+const computeFirstMileSteps = (record: FirstMileRecord): LastMileStepState[] => {
+  const exactKm = record.exactKm;
+  const inTransitOrPast =
+    record.status === "IN_TRANSIT" || record.status === "RECEIVED_TO_PORT";
+  const flags = [
+    record.status !== "PAYMENT_PENDING", // Ready to Transit
+    isAssigned(record),                  // Assign vehicle
+    inTransitOrPast,                     // In transit
+    exactKm != null,                     // Add distance
+    Boolean(record.invoice),             // Generate Invoice
+    record.status === "RECEIVED_TO_PORT",// Received to port
+  ];
+  // Current step = earliest incomplete one.
+  const activeIdx = flags.findIndex((f) => !f);
+  const labels = [
+    "Ready to Transit",
+    "Assign vehicle",
+    "In transit",
+    "Add distance",
+    "Generate Invoice",
+    "Received to port",
+  ];
+  const vehCount = record.vehicleAssignments?.length ?? (record.vehicleId ? 1 : 0);
+  const primaryPlate =
+    record.vehicle?.plateNumber ??
+    record.vehicleAssignments?.[0]?.vehicle?.plateNumber ??
+    null;
+  const details: (string | null)[] = [
+    null,
+    vehCount > 1 ? `${vehCount} vehicles` : primaryPlate,
+    null,
+    exactKm != null ? `${exactKm} KM` : null,
+    record.invoice?.number ?? null,
+    null,
+  ];
+  return labels.map((label, i) => ({
+    label,
+    done: flags[i],
+    active: i === activeIdx,
+    detail: details[i],
+  }));
+};
+
+// Paid = record flag set OR its invoice reached PAID.
+const isPaidRecord = (r: FirstMileRecord) =>
+  Boolean((r as { paid?: boolean }).paid) ||
+  (r.invoice?.status ?? "").toUpperCase() === "PAID";
+// Post payment pending = a post payment is owed but not yet paid.
+const isPostPaymentPending = (r: FirstMileRecord) =>
+  Number(r.remainingPayment) > 0 && !isPaidRecord(r);
 
 // Map API record → display fields used in modals and trip slip
 const bookingRef = (r: FirstMileRecord) => r.booking?.reference ?? r.bookingId;
+const currencyOf = (r: FirstMileRecord) => r.booking?.paymentCurrency ?? "ETB";
 const customerName = (r: FirstMileRecord) => r.booking?.company?.name ?? "—";
 const pickupLocation = (r: FirstMileRecord) => r.booking?.firstMilePickupAddress ?? "—";
 const cargoDesc = (r: FirstMileRecord) => {
@@ -151,8 +248,8 @@ const BookingInfo = ({ record }: { record: FirstMileRecord }) => {
           {hasPickupAddress && <InfoRow label="Pickup location" value={pickupLocation(record)} />}
           <InfoRow label="Destination (origin yard)" value={destinationYardName(record)} />
           <InfoRow label="Cargo" value={cargoDesc(record)} />
-          <InfoRow label="Advanced Payment" value={formatPrice(record.advancedPayment)} />
-          <InfoRow label="Post Payment" value={formatPrice(record.remainingPayment)} />
+          <InfoRow label="Advanced Payment" value={formatPrice(record.advancedPayment, currencyOf(record))} />
+          <InfoRow label="Post Payment" value={formatPrice(record.remainingPayment, currencyOf(record))} />
           <InfoRow label="Contact" value={contactPersonName(record)} />
           <InfoRow label="Phone" value={contactPhone(record)} />
           <InfoRow label="Requested date" value={requestedDate(record)} />
@@ -165,21 +262,48 @@ const BookingInfo = ({ record }: { record: FirstMileRecord }) => {
   );
 };
 
-const tripSlipRows = (record: FirstMileRecord): [string, string][] => [
-  ["Customer", customerName(record)],
-  ["Service", serviceTypeName(record)],
-  ["Pickup location", pickupLocation(record)],
-  ["Destination yard", destinationYardName(record)],
-  ["Cargo", cargoDesc(record)],
-  ["Advanced Payment", formatPrice(record.advancedPayment)],
-  ["Post Payment", formatPrice(record.remainingPayment)],
-  ["Vehicle", vehicleLabel(record) ?? "Unassigned"],
-  ["Contact", `${contactPersonName(record)} · ${contactPhone(record)}`],
-  ["Requested date", requestedDate(record)],
-  ["Est. Distance (KM)", record.estimatedKm != null ? String(record.estimatedKm) : "—"],
-  ["Actual Distance (KM)", record.exactKm != null ? String(record.exactKm) : "—"],
-  ["Status", STATUS_META[record.status].label],
-];
+type TripSlipVehicle = NonNullable<FirstMileRecord["vehicleAssignments"]>[number];
+
+const tripSlipRows = (
+  record: FirstMileRecord,
+  vehicle?: TripSlipVehicle | null,
+): [string, string][] => {
+  // Per-vehicle block when a specific truck is chosen (its own driver, container
+  // and distance); else fall back to the record-level vehicle summary.
+  const vehicleRows: [string, string][] = vehicle
+    ? [
+        [
+          "Vehicle",
+          vehicle.vehicle
+            ? [vehicle.vehicle.code, vehicle.vehicle.plateNumber].filter(Boolean).join(" · ")
+            : vehicle.vehicleId,
+        ],
+        ["Driver", vehicle.vehicle?.assignedDriverName || "—"],
+        [
+          "Container(s)",
+          vehicle.containerNumber || bookingContainerNumbers(record).join(", ") || "—",
+        ],
+        ["Distance (KM)", vehicle.distanceKm != null ? String(vehicle.distanceKm) : "—"],
+      ]
+    : [
+        ["Vehicle", vehicleLabel(record) ?? "Unassigned"],
+        ["Actual Distance (KM)", record.exactKm != null ? String(record.exactKm) : "—"],
+      ];
+  return [
+    ["Customer", customerName(record)],
+    ["Service", serviceTypeName(record)],
+    ["Pickup location", pickupLocation(record)],
+    ["Destination yard", destinationYardName(record)],
+    ["Cargo", cargoDesc(record)],
+    ["Advanced Payment", formatPrice(record.advancedPayment, currencyOf(record))],
+    ["Post Payment", formatPrice(record.remainingPayment, currencyOf(record))],
+    ...vehicleRows,
+    ["Contact", `${contactPersonName(record)} · ${contactPhone(record)}`],
+    ["Requested date", requestedDate(record)],
+    ["Est. Distance (KM)", record.estimatedKm != null ? String(record.estimatedKm) : "—"],
+    ["Status", STATUS_META[record.status].label],
+  ];
+};
 
 const SampleStamp = () => (
   <Box style={{ height: 96, display: "flex", alignItems: "center" }}>
@@ -245,7 +369,13 @@ const SignatureBlock = ({ title, stamp }: { title: string; stamp?: ReactNode })
   </Stack>
 );
 
-const TripSlipDocument = ({ record }: { record: FirstMileRecord }) => (
+const TripSlipDocument = ({
+  record,
+  vehicle,
+}: {
+  record: FirstMileRecord;
+  vehicle?: TripSlipVehicle | null;
+}) => (
   <Stack gap="md">
     <Stack gap={2} align="center">
       <Text fw={700}>EDR Freight</Text>
@@ -257,7 +387,7 @@ const TripSlipDocument = ({ record }: { record: FirstMileRecord }) => (
     </Group>
     <Divider />
     <SimpleGrid cols={2} spacing="xs">
-      {tripSlipRows(record).map(([label, value]) => (
+      {tripSlipRows(record, vehicle).map(([label, value]) => (
         <InfoRow key={label} label={label} value={value} />
       ))}
     </SimpleGrid>
@@ -272,8 +402,8 @@ const TripSlipDocument = ({ record }: { record: FirstMileRecord }) => (
 const escapeHtml = (v: string) =>
   v.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
 
-const buildTripSlipHtml = (record: FirstMileRecord) => {
-  const rows = tripSlipRows(record)
+const buildTripSlipHtml = (record: FirstMileRecord, vehicle?: TripSlipVehicle | null) => {
+  const rows = tripSlipRows(record, vehicle)
     .map(([l, v]) => `<tr><td class="lbl">${escapeHtml(l)}</td><td>${escapeHtml(v)}</td></tr>`)
     .join("");
   const sig = (title: string, withStamp: boolean) => `
@@ -319,6 +449,7 @@ const buildTripSlipHtml = (record: FirstMileRecord) => {
 const FirstMilePage = () => {
   const { toast } = useToast();
   const qc = useQueryClient();
+  const navigate = useNavigate();
   const { pagination, setPagination } = usePagination({ pageSize: 10 });
 
   const [search, setSearch] = useState("");
@@ -331,8 +462,14 @@ const FirstMilePage = () => {
   const [detailOpen, setDetailOpen] = useState(false);
   const [tripSlipOpen, setTripSlipOpen] = useState(false);
   const [tripSlipRecord, setTripSlipRecord] = useState<FirstMileRecord | null>(null);
+  // Which vehicle the trip slip is for (per-truck), + the pre-print picker.
+  const [tripSlipVehicleId, setTripSlipVehicleId] = useState<string | null>(null);
+  const [tripSlipSelectOpen, setTripSlipSelectOpen] = useState(false);
   const [activeId, setActiveId] = useState<string | null>(null);
-  const [vehicleValue, setVehicleValue] = useState<string | null>(null);
+  // Multi-vehicle assign: one row per truck — vehicle + the container it carries.
+  const [vehicleRows, setVehicleRows] = useState<
+    Array<{ vehicleId: string | null; containerNumber: string }>
+  >([{ vehicleId: null, containerNumber: "" }]);
 
   const [acceptOpen, setAcceptOpen] = useState(false);
   const [acceptStep, setAcceptStep] = useState<1 | 2>(1);
@@ -341,14 +478,11 @@ const FirstMilePage = () => {
   const [bookingSearch, setBookingSearch] = useState("");
 
   const [distanceOpen, setDistanceOpen] = useState(false);
-  const [distanceValue, setDistanceValue] = useState("");
-  const [invoiceOpen, setInvoiceOpen] = useState(false);
-  const [invoiceRecord, setInvoiceRecord] = useState<FirstMileRecord | null>(null);
+  // Per-vehicle actual distance, keyed by vehicleId.
+  const [distanceRows, setDistanceRows] = useState<Record<string, string>>({});
   const [warehouseReceiveOpen, setWarehouseReceiveOpen] = useState(false);
   const [warehouseReceiveRecord, setWarehouseReceiveRecord] = useState<FirstMileRecord | null>(null);
 
-  const [containerAllocationOpen, setContainerAllocationOpen] = useState(false);
-  const [containerAllocationFirstMileId, setContainerAllocationFirstMileId] = useState<string | null>(null);
 
   const { data: listData, isLoading } = useQuery({
     queryKey: QUERY_KEYS.FIRST_MILE.list(),
@@ -411,14 +545,36 @@ const FirstMilePage = () => {
     },
   });
 
-  const updateDistanceMutation = useMutation({
-    mutationFn: ({ id, exactKm, remainingPayment }: { id: string; exactKm: number; remainingPayment?: number }) =>
-      firstMileService.update(id, { exactKm, ...(remainingPayment != null && { remainingPayment }) }),
+  const setVehiclesMutation = useMutation({
+    mutationFn: ({
+      id,
+      vehicles,
+    }: {
+      id: string;
+      vehicles: Array<{ vehicleId: string; containerNumber?: string | null }>;
+    }) => firstMileService.setVehicles(id, vehicles),
     onSuccess: () => {
       void qc.invalidateQueries({ queryKey: QUERY_KEYS.FIRST_MILE.list() });
-      if (activeRecord) {
-        toast({ title: "Distance updated", description: `${bookingRef(activeRecord)} → ${distanceValue} km` });
-      }
+      void qc.invalidateQueries({ queryKey: ["vehicles"] });
+    },
+    onError: () => {
+      toast({ title: "Assign failed", variant: "destructive" });
+    },
+  });
+
+  const setDistancesMutation = useMutation({
+    mutationFn: ({
+      id,
+      distances,
+      remainingPayment,
+    }: {
+      id: string;
+      distances: Array<{ vehicleId: string; distanceKm: number }>;
+      remainingPayment?: number;
+    }) => firstMileService.setDistances(id, distances, remainingPayment),
+    onSuccess: () => {
+      void qc.invalidateQueries({ queryKey: QUERY_KEYS.FIRST_MILE.list() });
+      toast({ title: "Distances saved", description: activeRecord ? bookingRef(activeRecord) : undefined });
       closeDistance();
     },
     onError: () => {
@@ -437,6 +593,17 @@ const FirstMilePage = () => {
     },
   });
 
+  const generateInvoiceMutation = useMutation({
+    mutationFn: (id: string) => firstMileService.generateInvoice(id),
+    onSuccess: () => {
+      void qc.invalidateQueries({ queryKey: QUERY_KEYS.FIRST_MILE.list() });
+      toast({ title: "Invoice generated" });
+    },
+    onError: () => {
+      toast({ title: "Invoice generation failed", variant: "destructive" });
+    },
+  });
+
   const acceptMutation = useMutation({
     mutationFn: async ({ reference, vehicleId }: { reference: string; vehicleId: string | null }) => {
       const res = await firstMileService.accept(reference);
@@ -461,25 +628,71 @@ const FirstMilePage = () => {
     },
   });
 
-  const allocateMutation = useMutation({
-    mutationFn: (data) => api.post(`/first-mile/${containerAllocationFirstMileId}/allocate-containers`, data),
-    onSuccess: () => {
-      toast({ title: "Containers allocated" });
-      void qc.invalidateQueries({ queryKey: QUERY_KEYS.FIRST_MILE.byId(containerAllocationFirstMileId ?? "") });
-      void qc.invalidateQueries({ queryKey: ["vehicles"] });
-      setContainerAllocationOpen(false);
-      setContainerAllocationFirstMileId(null);
-    },
-    onError: () => {
-      toast({ title: "Allocation failed", variant: "destructive" });
-    },
-  });
-
   const activeRecord = useMemo(
     () => records.find((r) => r.id === activeId) ?? null,
     [records, activeId],
   );
 
+  // Picker options = free vehicles PLUS the ones already on this record (which are
+  // BUSY, so absent from the free list) so a reassign shows its current trucks
+  // selected instead of blank.
+  const assignVehicleOptions = useMemo(() => {
+    const opts = [...vehicleOptions];
+    const seen = new Set(opts.map((o) => o.value));
+    const pushVehicle = (v?: FirstMileVehicle | null) => {
+      if (v && !seen.has(v.id)) {
+        seen.add(v.id);
+        const parts = [`${v.manufacturer} ${v.model}`, v.plateNumber];
+        if (v.code) parts.unshift(v.code);
+        opts.push({ value: v.id, label: parts.join(" · ") });
+      }
+    };
+    for (const a of activeRecord?.vehicleAssignments ?? []) pushVehicle(a.vehicle);
+    pushVehicle(activeRecord?.vehicle);
+    for (const a of activeRecord?.vehicleAssignments ?? []) {
+      if (!seen.has(a.vehicleId)) {
+        seen.add(a.vehicleId);
+        opts.push({
+          value: a.vehicleId,
+          label: a.containerNumber ? `Assigned · ${a.containerNumber}` : "Assigned vehicle",
+        });
+      }
+    }
+    if (activeRecord?.vehicleId && !seen.has(activeRecord.vehicleId)) {
+      opts.push({ value: activeRecord.vehicleId, label: "Assigned vehicle" });
+    }
+    return opts;
+  }, [vehicleOptions, activeRecord]);
+
+  // Full booking (with container units) for the assign modal's container dropdown.
+  // Fetched on open so container numbers show regardless of what the list embeds.
+  const { data: assignBooking } = useQuery({
+    queryKey: activeRecord?.bookingId
+      ? QUERY_KEYS.BOOKINGS.byId(activeRecord.bookingId)
+      : ["bookings", "detail", "none"],
+    queryFn: () => bookingsService.getById(activeRecord!.bookingId),
+    enabled: assignOpen && !bulkMode && Boolean(activeRecord?.bookingId),
+  });
+
+  // Container-number options for the dropdown = the booking's real per-container
+  // numbers (units), falling back to whatever the list record carried.
+  const containerOptions = useMemo(() => {
+    const real = (n?: string | null): n is string =>
+      Boolean(n) && !/^TBD/i.test(n!.trim());
+    const out: string[] = [];
+    for (const c of assignBooking?.bookingContainers ?? []) {
+      const units = [...(c.units ?? [])].sort(
+        (a, b) => (a.sortOrder ?? 0) - (b.sortOrder ?? 0),
+      );
+      if (units.length) {
+        for (const u of units) if (real(u.containerNumber)) out.push(u.containerNumber);
+      } else if (real(c.containerNumber)) {
+        out.push(c.containerNumber);
+      }
+    }
+    return out.length ? out : activeRecord ? bookingContainerNumbers(activeRecord) : [];
+  }, [assignBooking, activeRecord]);
+
   const selectedIds = useMemo(
     () => Object.keys(rowSelection).filter((id) => rowSelection[id]),
     [rowSelection],
@@ -533,26 +746,22 @@ const FirstMilePage = () => {
   };
 
   const openDistance = (id: string) => {
+    const rec = records.find((r) => r.id === id);
+    const rows: Record<string, string> = {};
+    for (const a of rec?.vehicleAssignments ?? []) {
+      rows[a.vehicleId] = a.distanceKm != null ? String(a.distanceKm) : "";
+    }
     setActiveId(id);
-    setDistanceValue("");
+    setDistanceRows(rows);
     setDistanceOpen(true);
   };
 
   const closeDistance = () => {
     setDistanceOpen(false);
     setActiveId(null);
-    setDistanceValue("");
+    setDistanceRows({});
   };
 
-  const openInvoice = (record: FirstMileRecord) => {
-    setInvoiceRecord(record);
-    setInvoiceOpen(true);
-  };
-
-  const closeInvoice = () => {
-    setInvoiceOpen(false);
-    setInvoiceRecord(null);
-  };
 
   const openWarehouseReceive = (record: FirstMileRecord) => {
     setWarehouseReceiveRecord(record);
@@ -564,38 +773,32 @@ const FirstMilePage = () => {
     setWarehouseReceiveRecord(null);
   };
 
-  const openContainerAllocation = (firstMileId: string) => {
-    setContainerAllocationFirstMileId(firstMileId);
-    setContainerAllocationOpen(true);
-  };
-
-  const closeContainerAllocation = () => {
-    setContainerAllocationOpen(false);
-    setContainerAllocationFirstMileId(null);
-  };
-
   const handleSaveDistance = () => {
-    const distance = parseFloat(distanceValue);
-    if (!activeId || isNaN(distance) || distance < 0) {
-      toast({ title: "Invalid distance", description: "Enter a valid distance value.", variant: "destructive" });
+    const distances = Object.entries(distanceRows)
+      .map(([vehicleId, val]) => ({ vehicleId, distanceKm: parseFloat(val) }))
+      .filter((d) => !Number.isNaN(d.distanceKm) && d.distanceKm >= 0);
+
+    if (!activeId || !distances.length) {
+      toast({ title: "Invalid distance", description: "Enter a distance for at least one vehicle.", variant: "destructive" });
       return;
     }
 
+    const total = distances.reduce((s, d) => s + d.distanceKm, 0);
     let remainingPayment: number | undefined;
     if (ratesData?.data) {
       const firstMileRate = ratesData.data.find(
         (r) => r.rateType === "FIRST_MILE" && (r.status === "LIVE" || r.status === "DRAFT")
       );
       if (firstMileRate) {
-        const rateValue = parseFloat(firstMileRate.rateValue);
-        remainingPayment = distance * rateValue;
+        remainingPayment = total * parseFloat(firstMileRate.rateValue);
       }
     }
 
-    updateDistanceMutation.mutate({ id: activeId, exactKm: distance, remainingPayment });
+    setDistancesMutation.mutate({ id: activeId, distances, remainingPayment });
   };
 
   const matchesFilter = (r: FirstMileRecord) => {
+    if (filterPostPaymentPending && !isPostPaymentPending(r)) return false;
     switch (statusFilter) {
       case "ALL": return true;
       case "ASSIGNED": return isAssigned(r);
@@ -622,6 +825,11 @@ const FirstMilePage = () => {
     return counts;
   }, [records]);
 
+  const postPaymentPendingCount = useMemo(
+    () => records.filter(isPostPaymentPending).length,
+    [records],
+  );
+
   const filteredRecords = useMemo(() => {
     const term = search.trim().toLowerCase();
     return records.filter((r) => {
@@ -643,16 +851,29 @@ const FirstMilePage = () => {
 
   const openAssign = (id: string | null) => {
     const resolved = id ?? filteredRecords.find((r) => !isAssigned(r))?.id ?? null;
+    const rec = records.find((r) => r.id === resolved);
+    // Prefill each row's container number from the booking's container numbers
+    // (by order) when the assignment doesn't already carry one.
+    const nums = rec ? bookingContainerNumbers(rec) : [];
+    const rows =
+      rec?.vehicleAssignments?.length
+        ? rec.vehicleAssignments.map((a, i) => ({
+            vehicleId: a.vehicleId,
+            containerNumber: a.containerNumber ?? nums[i] ?? "",
+          }))
+        : rec?.vehicleId
+          ? [{ vehicleId: rec.vehicleId, containerNumber: nums[0] ?? "" }]
+          : [{ vehicleId: null, containerNumber: nums[0] ?? "" }];
     setBulkMode(false);
     setActiveId(resolved);
-    setVehicleValue(null);
+    setVehicleRows(rows.length ? rows : [{ vehicleId: null, containerNumber: nums[0] ?? "" }]);
     setAssignOpen(true);
   };
 
   const openBulkAssign = () => {
     setBulkMode(true);
     setActiveId(null);
-    setVehicleValue(null);
+    setVehicleRows([{ vehicleId: null, containerNumber: "" }]);
     setAssignOpen(true);
   };
 
@@ -660,28 +881,31 @@ const FirstMilePage = () => {
     setAssignOpen(false);
     setBulkMode(false);
     setActiveId(null);
-    setVehicleValue(null);
+    setVehicleRows([{ vehicleId: null, containerNumber: "" }]);
   };
 
   const handleAssign = () => {
-    if (!vehicleValue) {
-      toast({ title: "Select a vehicle", description: "Choose a vehicle to assign.", variant: "destructive" });
-      return;
-    }
-
+    const seen = new Set<string>();
+    const vehicles = vehicleRows
+      .filter((r): r is { vehicleId: string; containerNumber: string } => Boolean(r.vehicleId))
+      .filter((r) => (seen.has(r.vehicleId) ? false : seen.add(r.vehicleId)))
+      .map((r) => ({ vehicleId: r.vehicleId, containerNumber: r.containerNumber.trim() || null }));
+    const count = vehicles.length;
     const targetIds = bulkMode
       ? selectedIds
       : [activeId ?? filteredRecords.find((r) => !isAssigned(r))?.id].filter((id): id is string => Boolean(id));
 
     if (!targetIds.length) return;
 
-    const selectedLabel = vehicleOptions.find((o) => o.value === vehicleValue)?.label ?? vehicleValue;
-
-    Promise.all(targetIds.map((id) => updateMutation.mutateAsync({ id, data: { vehicleId: vehicleValue } })))
+    // Empty set = unassign all (setVehicles releases the removed vehicles).
+    Promise.all(targetIds.map((id) => setVehiclesMutation.mutateAsync({ id, vehicles })))
       .then(() => {
         toast({
-          title: "Vehicle assigned",
-          description: bulkMode ? `${targetIds.length} pickups → ${selectedLabel}` : selectedLabel,
+          title: count === 0 ? "Vehicles unassigned" : count > 1 ? "Vehicles assigned" : "Vehicle assigned",
+          description:
+            count === 0
+              ? bulkMode ? `${targetIds.length} pickups` : undefined
+              : `${bulkMode ? `${targetIds.length} pickups · ` : ""}${count} vehicle${count > 1 ? "s" : ""}`,
         });
         if (bulkMode) setRowSelection({});
         closeAssign();
@@ -702,10 +926,27 @@ const FirstMilePage = () => {
   };
 
   const handlePrintTripSlip = (record: FirstMileRecord) => {
+    // Always open the picker so the operator chooses which truck to print.
     setTripSlipRecord(record);
+    setTripSlipVehicleId(null);
+    setTripSlipSelectOpen(true);
+  };
+
+  const printBookingSlip = () => {
+    setTripSlipVehicleId(null);
+    setTripSlipSelectOpen(false);
     setTripSlipOpen(true);
   };
 
+  const chooseTripSlipVehicle = (vehicleId: string) => {
+    setTripSlipVehicleId(vehicleId);
+    setTripSlipSelectOpen(false);
+    setTripSlipOpen(true);
+  };
+
+  const tripSlipVehicle =
+    tripSlipRecord?.vehicleAssignments?.find((a) => a.vehicleId === tripSlipVehicleId) ?? null;
+
   const printTripSlip = () => {
     if (!tripSlipRecord) return;
     const win = window.open("", "_blank", "width=820,height=920");
@@ -713,8 +954,17 @@ const FirstMilePage = () => {
       toast({ title: "Pop-up blocked", description: "Allow pop-ups to print the trip slip.", variant: "destructive" });
       return;
     }
-    win.document.write(buildTripSlipHtml(tripSlipRecord));
+    win.document.write(buildTripSlipHtml(tripSlipRecord, tripSlipVehicle));
     win.document.close();
+    win.focus();
+    // Explicit print after the doc paints (onload can miss with document.write).
+    setTimeout(() => {
+      try {
+        win.print();
+      } catch {
+        /* window may have been closed */
+      }
+    }, 250);
   };
 
   const columns = useMemo((): ColumnDef<FirstMileRecord>[] => {
@@ -754,47 +1004,49 @@ const FirstMilePage = () => {
         meta: { headerClassName, cellClassName },
         cell: ({ row }) => customerName(row.original),
       },
-      {
-        id: "pickup",
-        header: "Pickup",
-        meta: { headerClassName, cellClassName },
-        cell: ({ row }) => pickupLocation(row.original),
-      },
-      {
-        id: "destination",
-        header: "Destination",
-        meta: { headerClassName, cellClassName },
-        cell: ({ row }) => destinationYardName(row.original),
-      },
-      {
-        id: "cargo",
-        header: "Cargo",
-        meta: { headerClassName, cellClassName },
-        cell: ({ row }) => cargoDesc(row.original),
-      },
-      {
-        id: "advancedPayment",
-        header: "Advanced Payment",
-        meta: { headerClassName, cellClassName },
-        cell: ({ row }) => formatPrice(row.original.advancedPayment),
-      },
       {
         id: "postPayment",
         header: "Post Payment",
         meta: { headerClassName, cellClassName },
-        cell: ({ row }) => formatPrice(row.original.remainingPayment),
+        cell: ({ row }) => formatPrice(row.original.remainingPayment, currencyOf(row.original)),
       },
       {
         id: "vehicle",
         header: "Vehicle",
         meta: { headerClassName, cellClassName },
-        cell: ({ row }) => vehicleLabel(row.original) ?? <Text c="dimmed">—</Text>,
-      },
-      {
-        id: "estimatedKm",
-        header: "Est. Distance (KM)",
-        meta: { headerClassName, cellClassName },
-        cell: ({ row }) => row.original.estimatedKm != null ? row.original.estimatedKm : <Text c="dimmed">—</Text>,
+        cell: ({ row }) => {
+          const assigns = row.original.vehicleAssignments ?? [];
+          if (assigns.length > 1) {
+            const labelFor = (a: (typeof assigns)[number]) => {
+              const v = a.vehicle;
+              const l = v ? [v.code, v.plateNumber].filter(Boolean).join(" · ") : a.vehicleId;
+              return a.containerNumber ? `${l} · ${a.containerNumber}` : l;
+            };
+            return (
+              <Tooltip
+                withArrow
+                multiline
+                label={
+                  <div style={{ whiteSpace: "pre-line" }}>
+                    {assigns.map(labelFor).join("\n")}
+                  </div>
+                }
+              >
+                <Group gap={4} wrap="nowrap" style={{ whiteSpace: "nowrap" }}>
+                  <Text size="sm" style={{ whiteSpace: "nowrap" }}>
+                    {assigns[0].vehicle
+                      ? [assigns[0].vehicle.code, assigns[0].vehicle.plateNumber].filter(Boolean).join(" · ")
+                      : assigns[0].vehicleId}
+                  </Text>
+                  <Badge size="sm" variant="light" color="blue">
+                    +{assigns.length - 1}
+                  </Badge>
+                </Group>
+              </Tooltip>
+            );
+          }
+          return vehicleLabel(row.original) ?? <Text c="dimmed">Unassigned</Text>;
+        },
       },
       {
         id: "exactKm",
@@ -807,35 +1059,31 @@ const FirstMilePage = () => {
         header: "Invoice",
         meta: { headerClassName, cellClassName },
         cell: ({ row }) => {
-          const hasDistance = row.original.exactKm != null && row.original.exactKm > 0;
-          const isPaid = (row.original as any).paid;
-          if (!hasDistance) {
+          // Only show once actually generated — not merely on distance.
+          const invoice = row.original.invoice;
+          if (!invoice) {
             return <Text c="dimmed">—</Text>;
           }
-          if (isPaid) {
-            return (
-              <Group gap="xs" wrap="nowrap">
-                <UnstyledButton
-                  onClick={() => openInvoice(row.original)}
-                  c="blue"
-                  fw={500}
-                  style={{ textDecoration: "underline", cursor: "pointer" }}
-                >
-                  #345
-                </UnstyledButton>
-                <Badge color="green" variant="light" size="sm">Paid</Badge>
-              </Group>
-            );
-          }
+          const status = String((row.original as any).paid ? "PAID" : invoice.status || "").toUpperCase();
+          const badge = INVOICE_STATUS_META[status] ?? { color: "gray", label: status || "—" };
           return (
-            <UnstyledButton
-              onClick={() => openInvoice(row.original)}
-              c="blue"
-              fw={500}
-              style={{ textDecoration: "underline", cursor: "pointer" }}
-            >
-              #345
-            </UnstyledButton>
+            <Group gap="xs" wrap="nowrap">
+              <UnstyledButton
+                onClick={() =>
+                  invoice.id
+                    ? navigate(`/dashboard/invoices/${invoice.id}`)
+                    : toast({ title: "Invoice link unavailable", description: "Refresh after the API restart.", variant: "destructive" })
+                }
+                c="blue"
+                fw={500}
+                style={{ textDecoration: "underline", cursor: "pointer" }}
+              >
+                <Tooltip label={invoice.number} withArrow>
+                  <span>{shortInvoiceNo(invoice.number)}</span>
+                </Tooltip>
+              </UnstyledButton>
+              {status && <Badge color={badge.color} variant="filled" size="sm">{badge.label}</Badge>}
+            </Group>
           );
         },
       },
@@ -848,16 +1096,6 @@ const FirstMilePage = () => {
           return <Badge color={meta.color} variant="light" size="sm">{meta.label}</Badge>;
         },
       },
-      {
-        id: "assignment",
-        header: "Assignment",
-        meta: { headerClassName, cellClassName },
-        cell: ({ row }) => (
-          <Badge color={isAssigned(row.original) ? "green" : "orange"} variant="light" size="sm">
-            {isAssigned(row.original) ? "Assigned" : "Unassigned"}
-          </Badge>
-        ),
-      },
       {
         id: "actions",
         header: "Actions",
@@ -870,7 +1108,12 @@ const FirstMilePage = () => {
           const canReceiveToWarehouse = row.original.status === "RECEIVED_TO_PORT";
           return (
             <Group gap={4} justify="flex-end" wrap="nowrap">
-              <Menu position="bottom-end" width={200} withinPortal>
+              <Menu
+                position="bottom-end"
+                width={200}
+                withinPortal
+                styles={{ dropdown: { maxHeight: 320, overflowY: "auto" } }}
+              >
                 <Menu.Target>
                   <ActionIcon variant="subtle" color="gray" aria-label="Pickup actions">
                     <MoreHorizontal size={16} />
@@ -879,10 +1122,14 @@ const FirstMilePage = () => {
                 <Menu.Dropdown>
                   <Menu.Item
                     leftSection={<ArrowRight size={15} />}
-                    disabled={!nextStatus}
+                    disabled={!nextStatus || (nextStatus === "IN_TRANSIT" && !assigned)}
                     onClick={() => handleAdvanceStatus(row.original)}
                   >
-                    {nextStatus ? `Mark ${STATUS_META[nextStatus].label}` : STATUS_META[row.original.status].label}
+                    {nextStatus === "IN_TRANSIT" && !assigned
+                      ? "Assign a vehicle first"
+                      : nextStatus
+                        ? `Mark ${STATUS_META[nextStatus].label}`
+                        : STATUS_META[row.original.status].label}
                   </Menu.Item>
                   <Menu.Divider />
                   <Menu.Item
@@ -894,7 +1141,7 @@ const FirstMilePage = () => {
                   </Menu.Item>
                   <Menu.Item
                     leftSection={<RefreshCw size={15} />}
-                    disabled={!assigned}
+                    disabled={!assigned || Boolean(row.original.invoice)}
                     onClick={() => openAssign(row.original.id)}
                   >
                     Reassign
@@ -915,10 +1162,21 @@ const FirstMilePage = () => {
                   </Menu.Item>
                   <Menu.Item
                     leftSection={<Ruler size={15} />}
+                    disabled={Boolean(row.original.invoice)}
                     onClick={() => openDistance(row.original.id)}
                   >
                     Add distance
                   </Menu.Item>
+                  <Menu.Item
+                    leftSection={<Receipt size={15} />}
+                    disabled={
+                      !(row.original.exactKm != null && row.original.exactKm > 0) ||
+                      Boolean(row.original.invoice)
+                    }
+                    onClick={() => generateInvoiceMutation.mutate(row.original.id)}
+                  >
+                    {row.original.invoice ? "Invoice generated" : "Generate Invoice"}
+                  </Menu.Item>
                   {canPrint && (
                     <Menu.Item
                       leftSection={<Printer size={15} />}
@@ -933,6 +1191,7 @@ const FirstMilePage = () => {
                       <Menu.Item
                         leftSection={<Trash size={15} />}
                         color="red"
+                        disabled={Boolean(row.original.invoice)}
                         onClick={() => {
                           if (confirm(`Delete first-mile record ${bookingRef(row.original)}?`)) {
                             deleteMutation.mutate(row.original.id);
@@ -954,7 +1213,7 @@ const FirstMilePage = () => {
   }, [vehicleOptions]);
 
   return (
-    <Stack gap="md">
+    <Stack gap="md" p="md">
       <Card radius="lg" padding={0} withBorder style={{ borderColor: "var(--mantine-color-gray-2)" }}>
         <Stack gap={0}>
           <Box px="md" pt="md" pb="sm" w="100%">
@@ -1004,7 +1263,7 @@ const FirstMilePage = () => {
                     setPagination((p) => ({ ...p, pageIndex: 0 }));
                   }}
                 >
-                  Post Payment Pending
+                  Post Payment Pending ({postPaymentPendingCount})
                 </Button>
               </Group>
             </Stack>
@@ -1050,7 +1309,7 @@ const FirstMilePage = () => {
         <Stack gap="md">
           {bulkMode ? (
             <Text size="sm">
-              Assigning a vehicle to{" "}
+              Assigning vehicles to{" "}
               <Text span fw={600}>{selectedIds.length}</Text>{" "}
               selected {selectedIds.length === 1 ? "pickup" : "pickups"}.
             </Text>
@@ -1060,28 +1319,84 @@ const FirstMilePage = () => {
             <Text size="sm" c="dimmed">No unassigned pickups available.</Text>
           )}
           <Divider />
-          <Select
-            label="Vehicle"
-            placeholder={vehicleOptions.length === 0 ? "No free vehicles" : "Select a vehicle"}
-            description={
-              vehicleOptions.length === 0
-                ? "No free vehicles available — all vehicles are busy, in maintenance, or retired. Free up a vehicle in Fleet › Vehicles first."
-                : undefined
-            }
-            data={vehicleOptions}
-            value={vehicleValue}
-            onChange={setVehicleValue}
-            searchable
-            disabled={vehicleOptions.length === 0}
-          />
+          <Stack gap="xs">
+            {vehicleRows.map((row, i) => (
+              <Group key={i} gap="xs" wrap="nowrap" align="flex-end">
+                <Select
+                  style={{ flex: 1.4 }}
+                  label={i === 0 ? "Vehicle" : undefined}
+                  placeholder={assignVehicleOptions.length === 0 ? "No free vehicles" : "Select a vehicle"}
+                  data={assignVehicleOptions.filter(
+                    (o) => o.value === row.vehicleId || !vehicleRows.some((r) => r.vehicleId === o.value),
+                  )}
+                  value={row.vehicleId}
+                  onChange={(v) =>
+                    setVehicleRows((prev) => prev.map((x, idx) => (idx === i ? { ...x, vehicleId: v } : x)))
+                  }
+                  searchable
+                  clearable
+                  disabled={assignVehicleOptions.length === 0}
+                />
+                <Autocomplete
+                  style={{ flex: 1 }}
+                  label={i === 0 ? "Container no." : undefined}
+                  placeholder="Container number"
+                  data={containerOptions.filter(
+                    (n) =>
+                      n === row.containerNumber ||
+                      !vehicleRows.some((r, idx) => idx !== i && r.containerNumber === n),
+                  )}
+                  value={row.containerNumber}
+                  onChange={(value) =>
+                    setVehicleRows((prev) =>
+                      prev.map((x, idx) => (idx === i ? { ...x, containerNumber: value } : x)),
+                    )
+                  }
+                />
+                {vehicleRows.length > 1 && (
+                  <ActionIcon
+                    variant="subtle"
+                    color="red"
+                    aria-label="Remove vehicle"
+                    onClick={() => setVehicleRows((prev) => prev.filter((_, idx) => idx !== i))}
+                  >
+                    <X size={16} />
+                  </ActionIcon>
+                )}
+              </Group>
+            ))}
+            <Button
+              variant="light"
+              size="xs"
+              leftSection={<Plus size={14} />}
+              onClick={() =>
+                setVehicleRows((prev) => [
+                  ...prev,
+                  {
+                    vehicleId: null,
+                    containerNumber:
+                      (activeRecord ? bookingContainerNumbers(activeRecord)[prev.length] : "") ?? "",
+                  },
+                ])
+              }
+              disabled={
+                assignVehicleOptions.length === 0 ||
+                vehicleRows.some((r) => !r.vehicleId) ||
+                vehicleRows.filter((r) => r.vehicleId).length >= assignVehicleOptions.length
+              }
+              style={{ alignSelf: "flex-start" }}
+            >
+              Add vehicle
+            </Button>
+          </Stack>
           <Group justify="flex-end" gap="sm">
             <Button variant="default" onClick={closeAssign}>Cancel</Button>
             <Button
               onClick={handleAssign}
-              loading={updateMutation.isPending}
+              loading={setVehiclesMutation.isPending}
               disabled={bulkMode ? selectedIds.length === 0 : !activeRecord}
             >
-              {!bulkMode && activeRecord && isAssigned(activeRecord) ? "Reassign" : "Assign"}
+              {!bulkMode && activeRecord && isAssigned(activeRecord) ? "Update vehicles" : "Assign"}
             </Button>
           </Group>
         </Stack>
@@ -1098,12 +1413,98 @@ const FirstMilePage = () => {
       >
         <Stack gap="md">
           {activeRecord && <BookingInfo record={activeRecord} />}
+          {activeRecord && (activeRecord.vehicleAssignments?.length ?? 0) > 0 && (
+            <Card withBorder padding="md" radius="md">
+              <Text fw={600} size="sm" mb="sm">Assigned vehicles</Text>
+              <Stack gap="xs">
+                {activeRecord.vehicleAssignments!.map((a) => {
+                  const v = a.vehicle;
+                  const label = v
+                    ? [v.code, v.plateNumber].filter(Boolean).join(" · ")
+                    : a.vehicleId;
+                  return (
+                    <Group key={a.id} justify="space-between" wrap="nowrap">
+                      <Text size="sm">{label}</Text>
+                      {a.containerNumber ? (
+                        <Badge size="sm" variant="light" color="blue">
+                          {a.containerNumber}
+                        </Badge>
+                      ) : (
+                        <Text size="xs" c="dimmed">No container no.</Text>
+                      )}
+                    </Group>
+                  );
+                })}
+              </Stack>
+            </Card>
+          )}
+          {activeRecord && (
+            <Card withBorder padding="md" radius="md">
+              <Text fw={600} size="sm" mb="sm">Pickup steps</Text>
+              <LastMileStepper steps={computeFirstMileSteps(activeRecord)} />
+            </Card>
+          )}
           <Group justify="flex-end">
             <Button variant="default" onClick={() => { setDetailOpen(false); setActiveId(null); }}>Close</Button>
           </Group>
         </Stack>
       </Modal>
 
+      {/* Trip slip — pick a vehicle (multi-truck) */}
+      <Modal
+        opened={tripSlipSelectOpen}
+        onClose={() => setTripSlipSelectOpen(false)}
+        title={<Text fw={600}>Print trip slip — select vehicle</Text>}
+        radius="lg"
+        centered
+      >
+        <Stack gap="sm">
+          <Text size="sm" c="dimmed">
+            {tripSlipRecord ? bookingRef(tripSlipRecord) : ""} — pick a truck to print its slip.
+          </Text>
+          {(tripSlipRecord?.vehicleAssignments ?? []).map((a) => {
+            const v = a.vehicle;
+            const label = v ? [v.code, v.plateNumber].filter(Boolean).join(" · ") : a.vehicleId;
+            return (
+              <Card
+                key={a.id}
+                withBorder
+                radius="md"
+                padding="sm"
+                onClick={() => chooseTripSlipVehicle(a.vehicleId)}
+                style={{ cursor: "pointer" }}
+                className="hover:bg-gray-50"
+              >
+                <Group justify="space-between" wrap="nowrap" align="center">
+                  <Stack gap={2} style={{ minWidth: 0 }}>
+                    <Group gap="xs" wrap="nowrap">
+                      <Truck size={15} />
+                      <Text size="sm" fw={600} truncate>{label}</Text>
+                    </Group>
+                    <Text size="xs" c="dimmed" truncate>
+                      Driver: {v?.assignedDriverName || "—"}
+                    </Text>
+                    <Text size="xs" c="dimmed" truncate>
+                      Container: {a.containerNumber || "—"}
+                    </Text>
+                  </Stack>
+                  <ActionIcon variant="light" color="edr-green" size="lg" aria-label="Print">
+                    <Printer size={16} />
+                  </ActionIcon>
+                </Group>
+              </Card>
+            );
+          })}
+          {(tripSlipRecord?.vehicleAssignments?.length ?? 0) === 0 && (
+            <Text size="sm" c="dimmed" ta="center" py="xs">No vehicles assigned yet.</Text>
+          )}
+          <Divider label="or" labelPosition="center" />
+          <Button variant="subtle" size="sm" onClick={printBookingSlip}>
+            Print booking slip (no vehicle)
+          </Button>
+        </Stack>
+      </Modal>
+
       {/* Trip slip modal */}
       <Modal
         opened={tripSlipOpen}
@@ -1114,7 +1515,7 @@ const FirstMilePage = () => {
         centered
       >
         <Stack gap="md">
-          {tripSlipRecord && <TripSlipDocument record={tripSlipRecord} />}
+          {tripSlipRecord && <TripSlipDocument record={tripSlipRecord} vehicle={tripSlipVehicle} />}
           <Divider />
           <Group justify="flex-end" gap="sm">
             <Button variant="default" onClick={() => setTripSlipOpen(false)}>Close</Button>
@@ -1288,171 +1689,57 @@ const FirstMilePage = () => {
         <Stack gap="md">
           {activeRecord && (
             <Card withBorder padding="md" radius="md" bg="var(--mantine-color-gray-0)">
-              <Stack gap="sm">
+              <Group justify="space-between">
                 <Text fw={600} size="sm">{bookingRef(activeRecord)}</Text>
-                <Group justify="space-between">
-                  <Text size="xs" c="dimmed">Customer</Text>
-                  <Text size="sm">{customerName(activeRecord)}</Text>
-                </Group>
-                <Group justify="space-between">
-                  <Text size="xs" c="dimmed">Est. Distance (KM)</Text>
-                  <Text size="sm">{activeRecord.estimatedKm ?? "—"}</Text>
-                </Group>
-              </Stack>
+                <Text size="xs" c="dimmed">Est. {activeRecord.estimatedKm ?? "—"} km</Text>
+              </Group>
             </Card>
           )}
-          <NumberInput
-            label="Actual Distance (KM)"
-            placeholder="Enter distance"
-            value={distanceValue}
-            onChange={(v) => setDistanceValue(String(v ?? ""))}
-            min={0}
-            step={0.1}
-            decimalScale={2}
-          />
+          {(activeRecord?.vehicleAssignments?.length ?? 0) === 0 ? (
+            <Text size="sm" c="dimmed">Assign a vehicle before entering distance.</Text>
+          ) : (
+            <Stack gap="sm">
+              {activeRecord!.vehicleAssignments!.map((a) => {
+                const v = a.vehicle;
+                const label = v ? [v.code, v.plateNumber].filter(Boolean).join(" · ") : a.vehicleId;
+                return (
+                  <NumberInput
+                    key={a.id}
+                    label={`${label}${a.containerNumber ? ` · ${a.containerNumber}` : ""}`}
+                    placeholder="Distance (km)"
+                    value={distanceRows[a.vehicleId] ?? ""}
+                    onChange={(val) =>
+                      setDistanceRows((prev) => ({ ...prev, [a.vehicleId]: String(val ?? "") }))
+                    }
+                    min={0}
+                    step={0.1}
+                    decimalScale={2}
+                  />
+                );
+              })}
+              <Group justify="space-between">
+                <Text size="xs" c="dimmed">Total</Text>
+                <Text size="sm" fw={600}>
+                  {Object.values(distanceRows)
+                    .reduce((s, val) => s + (parseFloat(val) || 0), 0)
+                    .toFixed(2)}{" "}
+                  km
+                </Text>
+              </Group>
+            </Stack>
+          )}
           <Group justify="flex-end" gap="sm">
             <Button variant="default" onClick={closeDistance}>Cancel</Button>
             <Button
               onClick={handleSaveDistance}
-              loading={updateDistanceMutation.isPending}
-              disabled={!distanceValue}
+              loading={setDistancesMutation.isPending}
+              disabled={Object.values(distanceRows).every((v) => !v)}
             >
               Save
             </Button>
           </Group>
         </Stack>
       </Modal>
-
-      {/* Invoice modal */}
-      <Modal
-        opened={invoiceOpen}
-        onClose={closeInvoice}
-        title={<Text fw={600}>Invoice #345</Text>}
-        size="lg"
-        radius="lg"
-        centered
-      >
-        <Stack gap="md">
-          {invoiceRecord && (
-            <>
-              <Card withBorder padding="md" radius="md" bg="var(--mantine-color-gray-0)">
-                <Stack gap="sm">
-                  <Group justify="space-between">
-                    <Text fw={700}>EDR Freight</Text>
-                    <Text fw={600} size="sm">Invoice #345</Text>
-                  </Group>
-                  <Divider />
-                  <SimpleGrid cols={2} spacing="sm">
-                    <InfoRow label="Booking" value={bookingRef(invoiceRecord)} />
-                    <InfoRow label="Customer" value={customerName(invoiceRecord)} />
-                    <InfoRow label="Pickup" value={pickupLocation(invoiceRecord)} />
-                    <InfoRow label="Destination" value={destinationYardName(invoiceRecord)} />
-                    <InfoRow label="Est. Distance" value={invoiceRecord.estimatedKm ? `${invoiceRecord.estimatedKm} km` : "—"} />
-                    <InfoRow label="Actual Distance" value={invoiceRecord.exactKm ? `${invoiceRecord.exactKm} km` : "—"} />
-                    <InfoRow label="Advanced Payment" value={formatPrice(invoiceRecord.advancedPayment)} />
-                    <InfoRow label="Post Payment" value={formatPrice(invoiceRecord.remainingPayment)} />
-                  </SimpleGrid>
-                  <Divider />
-                  <Group justify="flex-end">
-                    <Stack gap={0} align="flex-end" style={{ minWidth: 200 }}>
-                      <Group justify="space-between" w="100%">
-                        <Text size="sm" c="dimmed">Post Payment</Text>
-                        <Text size="sm">{formatPrice(invoiceRecord.remainingPayment)}</Text>
-                      </Group>
-                      <Group justify="space-between" w="100%">
-                        <Text size="sm" c="dimmed">Advanced Payment</Text>
-                        <Text size="sm">{formatPrice(invoiceRecord.advancedPayment)}</Text>
-                      </Group>
-                      <Divider my="xs" />
-                      {(() => {
-                        const postPayment = parseFloat(String(invoiceRecord.remainingPayment));
-                        const advancedPayment = parseFloat(String(invoiceRecord.advancedPayment));
-                        const difference = postPayment - advancedPayment;
-
-                        if (difference > 0) {
-                          return (
-                            <Group justify="space-between" w="100%">
-                              <Text size="sm" fw={600}>Remaining to Pay</Text>
-                              <Text fw={700} c="orange">{formatPrice(difference)}</Text>
-                            </Group>
-                          );
-                        } else if (difference < 0) {
-                          return (
-                            <Group justify="space-between" w="100%">
-                              <Text size="sm" fw={600}>Refund</Text>
-                              <Text fw={700} c="green">{formatPrice(Math.abs(difference))}</Text>
-                            </Group>
-                          );
-                        } else {
-                          return (
-                            <Group justify="space-between" w="100%">
-                              <Text size="sm" fw={600}>Status</Text>
-                              <Text fw={700} c="blue">Settled</Text>
-                            </Group>
-                          );
-                        }
-                      })()}
-                    </Stack>
-                  </Group>
-                </Stack>
-              </Card>
-            </>
-          )}
-          <Group justify="flex-end" gap="sm">
-            <Button variant="default" onClick={closeInvoice}>Close</Button>
-          </Group>
-        </Stack>
-      </Modal>
-
-      {/* Container Allocation modal */}
-      <Modal
-        opened={containerAllocationOpen}
-        onClose={closeContainerAllocation}
-        title={<Text fw={600}>Allocate Containers to Vehicles</Text>}
-        size="xl"
-        radius="lg"
-        centered
-      >
-        <Stack gap="md">
-          {activeRecord && (
-            <>
-              {/* Capacity guidance */}
-              {activeRecord.booking?.cargoType?.label === "BULK" ? (
-                <Alert color="blue" title="Bulk Cargo Allocation">
-                  <Text size="sm">
-                    Select multiple containers per vehicle based on capacity. Each vehicle can carry multiple containers if capacity allows.
-                  </Text>
-                  <Text size="xs" c="dimmed" mt="xs">
-                    Capacity: TBD — TODO: add vehicle capacity_tons to vehicle API if missing
-                  </Text>
-                </Alert>
-              ) : (
-                <Alert color="blue">
-                  <Text size="sm">
-                    One vehicle per container. Each container will be assigned to a single vehicle.
-                  </Text>
-                </Alert>
-              )}
-              <Divider />
-
-              {/* Container table */}
-              <FirstMileContainerAllocationTable
-                firstMileId={activeRecord.id}
-                containers={[
-                  // TODO: Get containers from booking/first-mile data
-                  // For now placeholder with TODO comment
-                ]}
-                onSave={async (allocations) => {
-                  await allocateMutation.mutateAsync(allocations);
-                }}
-              />
-            </>
-          )}
-          <Group justify="flex-end" gap="sm">
-            <Button variant="default" onClick={closeContainerAllocation}>Close</Button>
-          </Group>
-        </Stack>
-      </Modal>
     </Stack>
   );
 };
diff --git a/apps/edr-freight-web/backoffice/src/pages/operations/LastMilePage.tsx b/apps/edr-freight-web/backoffice/src/pages/operations/LastMilePage.tsx
index 7ec9d1b33..4b5cec080 100644
--- a/apps/edr-freight-web/backoffice/src/pages/operations/LastMilePage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/operations/LastMilePage.tsx
@@ -3,17 +3,23 @@ import {
   ArrowRight,
   Eye,
   MoreHorizontal,
+  Plus,
   Printer,
+  Receipt,
   RefreshCw,
   Ruler,
   Trash,
   Truck,
+  X,
 } from "lucide-react";
 import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import { useNavigate } from "react-router-dom";
 import type { ColumnDef } from "@edr/ui-common";
 import { DataTable, DataTableFooter, usePagination } from "@edr/ui-common";
 import {
   ActionIcon,
+  Alert,
+  Autocomplete,
   Badge,
   Box,
   Button,
@@ -23,6 +29,7 @@ import {
   Group,
   Menu,
   Modal,
+  MultiSelect,
   NumberInput,
   ScrollArea,
   Select,
@@ -30,10 +37,12 @@ import {
   Stack,
   Text,
   TextInput,
+  Tooltip,
   UnstyledButton,
 } from "@mantine/core";
 import type { ArrivalQueueItem, ImportUnloadedItem, WarehouseInventoryItem } from "@/types/warehouse";
 import { warehouseService } from "@/services/warehouse.service";
+import { bookingsService } from "@/services/bookings.service";
 
 import { ruleEngineTable } from "@/components/ruleEngine/ruleEngineStyles";
 import { QUERY_KEYS } from "@/constants/QUERY_KEYS";
@@ -42,17 +51,17 @@ import {
   LAST_MILE_STATUSES,
   type LastMileApiStatus,
   type LastMileRecord,
+  type LastMileVehicle,
   lastMileService,
 } from "@/services/last-mile.service";
 import { vehiclesService } from "@/services/vehicles.service";
 import { driversService, type Driver } from "@/services/drivers.service";
 import { ratesService } from "@/services/rates.service";
-import { LastMileContainerAllocationTable, type LastMileContainerRow } from "@/components/LastMileContainerAllocationTable";
 import { ReleaseOrderModal, type ReleaseOrderTruckPrefill } from "@/components/warehouses/ReleaseOrderModal";
-import { api } from "@/auth/http";
+import { LastMileStepper, type LastMileStepState } from "@/components/operations/LastMileSteps";
 
-const formatPrice = (amount: number) =>
-  `ETB ${amount.toLocaleString("en-US", {
+const formatPrice = (amount: number | string | null | undefined, currency = "ETB") =>
+  `${currency || "ETB"} ${(Number(amount) || 0).toLocaleString("en-US", {
     minimumFractionDigits: 2,
     maximumFractionDigits: 2,
   })}`;
@@ -64,6 +73,24 @@ const STATUS_META: Record<LastMileApiStatus, { label: string; color: string }> =
   DELIVERED: { label: "Delivered", color: "green" },
 };
 
+// Middle-truncate a long invoice number for the table (full value on hover).
+// "INV-20260704-00002" → "INV-2…02"
+const shortInvoiceNo = (n: string) =>
+  n && n.length > 9 ? `${n.slice(0, 5)}…${n.slice(-2)}` : n;
+
+// Invoice payment state → badge color, keyed by upper-cased status.
+const INVOICE_STATUS_META: Record<string, { label: string; color: string }> = {
+  PAID: { label: "Paid", color: "green" },
+  PARTIALLY_PAID: { label: "Partially Paid", color: "teal" },
+  PENDING: { label: "Pending", color: "yellow" },
+  UNPAID: { label: "Unpaid", color: "yellow" },
+  OPEN: { label: "Open", color: "yellow" },
+  ISSUED: { label: "Issued", color: "blue" },
+  OVERDUE: { label: "Overdue", color: "red" },
+  CANCELLED: { label: "Cancelled", color: "gray" },
+  VOID: { label: "Void", color: "gray" },
+};
+
 const NEXT_STATUS: Partial<Record<LastMileApiStatus, LastMileApiStatus>> = {
   PAYMENT_PENDING: "READY_TO_TRANSIT",
   READY_TO_TRANSIT: "IN_TRANSIT",
@@ -90,9 +117,123 @@ const vehicleLabel = (record: LastMileRecord) => {
   return parts.join(" · ");
 };
 
+/** One vehicle (with trailer) carries two containers. */
+const CONTAINERS_PER_VEHICLE = 2;
+const containerCount = (record: LastMileRecord) =>
+  (record.booking?.bookingContainers ?? []).reduce(
+    (sum, c) => sum + (Number(c.quantity) || 0),
+    0,
+  );
+/** Trucks needed for a booking = ceil(containers / 2). 0 when no container data. */
+const requiredVehicles = (record: LastMileRecord) => {
+  const n = containerCount(record);
+  return n > 0 ? Math.ceil(n / CONTAINERS_PER_VEHICLE) : 0;
+};
+
+/** Real per-physical-container numbers on a booking, in order. Prefers each
+ *  line's `units` (the actual numbers) over the line-level number (often a
+ *  "TBD-…" placeholder). One entry per physical container, for per-truck prefill. */
+const bookingContainerNumbers = (record: LastMileRecord): string[] => {
+  const out: string[] = [];
+  const real = (n?: string | null): n is string =>
+    Boolean(n) && !/^TBD/i.test(n!.trim());
+  for (const c of record.booking?.bookingContainers ?? []) {
+    const units = [...(c.units ?? [])].sort(
+      (a, b) => (a.sortOrder ?? 0) - (b.sortOrder ?? 0),
+    );
+    if (units.length) {
+      for (const u of units) if (real(u.containerNumber)) out.push(u.containerNumber!);
+    } else if (real(c.containerNumber)) {
+      out.push(c.containerNumber!);
+    }
+  }
+  return out;
+};
+
+/** Container badges for a booking: the container number when known, else the
+ *  type × quantity. */
+const containerLabels = (record: LastMileRecord): string[] => {
+  const out: string[] = [];
+  for (const c of record.booking?.bookingContainers ?? []) {
+    const size = c.containerSize ? ` · ${c.containerSize}` : "";
+    if (c.containerNumber) {
+      out.push(`${c.containerNumber}${size}`);
+    } else {
+      const type =
+        c.containerType?.code ??
+        c.containerType?.label ??
+        c.containerType?.name ??
+        (c.containerSize || "Container");
+      out.push(`${type} × ${c.quantity}`);
+    }
+  }
+  return out;
+};
+
 const isAssigned = (record: LastMileRecord) => Boolean(record.vehicleId);
 
+// Paid = record flag set OR its invoice reached PAID.
+const isPaidRecord = (r: LastMileRecord) =>
+  Boolean((r as { paid?: boolean }).paid) ||
+  (r.invoice?.status ?? "").toUpperCase() === "PAID";
+// Post payment pending = a post payment is owed but not yet paid.
+const isPostPaymentPending = (r: LastMileRecord) =>
+  Number(r.remainingPayment) > 0 && !isPaidRecord(r);
+
+const fmtStamp = (iso?: string | null) => {
+  if (!iso) return null;
+  const d = new Date(iso);
+  return Number.isNaN(d.getTime()) ? null : d.toLocaleString();
+};
+
+/**
+ * Derive the 6-step last-mile workflow state for a record. Step completion is
+ * read from the record + its pickup-ready (warehouse release) row:
+ * assign→vehicleId, arrived→release order issued, leave→releaseDate,
+ * in-transit/delivered→status, distance→exactKm.
+ */
+const computeLastMileSteps = (
+  record: LastMileRecord,
+  releaseRow?: ImportUnloadedItem,
+): LastMileStepState[] => {
+  const exactKm = (record as { exactKm?: number | null }).exactKm;
+  // Truck arrival/leave live in the transient warehouse pickup-ready queue and
+  // vanish once the item is released. So once the leg is IN_TRANSIT/DELIVERED,
+  // treat both as done (the truck must have arrived + left to get there).
+  const past = record.status === "IN_TRANSIT" || record.status === "DELIVERED";
+  const flags = [
+    record.status !== "PAYMENT_PENDING",
+    Boolean(record.vehicleId),
+    past || Boolean(releaseRow?.releaseOrderReference),
+    past || Boolean(releaseRow?.releaseDate),
+    past,
+    exactKm != null,
+    exactKm != null, // Generate Invoice — auto-generated when distance is saved
+    record.status === "DELIVERED",
+  ];
+  // Current step = earliest incomplete one.
+  const activeIdx = flags.findIndex((f) => !f);
+  const labels = ["Ready to Transit", "Assign vehicle", "Truck arrived", "Truck leave", "In transit", "Add distance", "Generate Invoice", "Delivered"];
+  const details: (string | null)[] = [
+    null,
+    record.vehicle?.plateNumber ?? null,
+    releaseRow?.releaseOrderReference ?? null,
+    fmtStamp(releaseRow?.releaseDate),
+    null,
+    exactKm != null ? `${exactKm} KM` : null,
+    exactKm != null ? "Invoice ready" : null,
+    fmtStamp(releaseRow?.deliveredAt),
+  ];
+  return labels.map((label, i) => ({
+    label,
+    done: flags[i],
+    active: i === activeIdx,
+    detail: details[i],
+  }));
+};
+
 const bookingRef = (r: LastMileRecord) => r.booking?.reference ?? r.bookingId;
+const currencyOf = (r: LastMileRecord) => r.booking?.paymentCurrency ?? "ETB";
 const customerName = (r: LastMileRecord) => r.booking?.company?.name ?? "—";
 const deliveryLocation = (r: LastMileRecord) => r.booking?.lastMileDeliveryAddress ?? "—";
 const cargoDesc = (r: LastMileRecord) => {
@@ -195,8 +336,8 @@ const BookingInfo = ({ record }: { record: LastMileRecord }) => {
           <InfoRow label="Pickup (origin yard)" value={originYardName(record)} />
           {hasDeliveryAddress && <InfoRow label="Destination" value={deliveryLocation(record)} />}
           <InfoRow label="Cargo" value={cargoDesc(record)} />
-          <InfoRow label="Advanced Payment" value={formatPrice(record.advancedPayment)} />
-          <InfoRow label="Post Payment" value={formatPrice(record.remainingPayment)} />
+          <InfoRow label="Advanced Payment" value={formatPrice(record.advancedPayment, currencyOf(record))} />
+          <InfoRow label="Post Payment" value={formatPrice(record.remainingPayment, currencyOf(record))} />
           <InfoRow label="Contact" value={contactPersonName(record)} />
           <InfoRow label="Phone" value={contactPhone(record)} />
           <InfoRow label="Requested date" value={requestedDate(record)} />
@@ -209,21 +350,46 @@ const BookingInfo = ({ record }: { record: LastMileRecord }) => {
   );
 };
 
-const tripSlipRows = (record: LastMileRecord): [string, string][] => [
-  ["Customer", customerName(record)],
-  ["Service", serviceTypeName(record)],
-  ["Pickup (origin yard)", originYardName(record)],
-  ["Destination", deliveryLocation(record)],
-  ["Cargo", cargoDesc(record)],
-  ["Advanced Payment", formatPrice(record.advancedPayment)],
-  ["Post Payment", formatPrice(record.remainingPayment)],
-  ["Vehicle", vehicleLabel(record) ?? "Unassigned"],
-  ["Contact", `${contactPersonName(record)} · ${contactPhone(record)}`],
-  ["Requested date", requestedDate(record)],
-  ["Est. Distance (KM)", record.estimatedKm != null ? String(record.estimatedKm) : "—"],
-  ["Actual Distance (KM)", record.exactKm != null ? String(record.exactKm) : "—"],
-  ["Status", STATUS_META[record.status].label],
-];
+type TripSlipVehicle = NonNullable<LastMileRecord["vehicleAssignments"]>[number];
+
+const tripSlipRows = (
+  record: LastMileRecord,
+  vehicle?: TripSlipVehicle | null,
+): [string, string][] => {
+  // Per-vehicle block when a specific truck is chosen (its own driver, container(s)
+  // and distance); else fall back to the record-level vehicle summary.
+  const vehicleRows: [string, string][] = vehicle
+    ? [
+        [
+          "Vehicle",
+          vehicle.vehicle
+            ? [vehicle.vehicle.code, vehicle.vehicle.plateNumber].filter(Boolean).join(" · ")
+            : vehicle.vehicleId,
+        ],
+        ["Driver", vehicle.vehicle?.assignedDriverName || "—"],
+        [
+          "Container(s)",
+          vehicle.containerNumber || bookingContainerNumbers(record).join(", ") || "—",
+        ],
+        ["Distance (KM)", vehicle.distanceKm != null ? String(vehicle.distanceKm) : "—"],
+      ]
+    : [
+        ["Vehicle", vehicleLabel(record) ?? "Unassigned"],
+        ["Actual Distance (KM)", record.exactKm != null ? String(record.exactKm) : "—"],
+      ];
+  return [
+    ["Customer", customerName(record)],
+    ["Service", serviceTypeName(record)],
+    ["Pickup (origin yard)", originYardName(record)],
+    ["Destination", deliveryLocation(record)],
+    ["Cargo", cargoDesc(record)],
+    ["Post Payment", formatPrice(record.remainingPayment, currencyOf(record))],
+    ...vehicleRows,
+    ["Contact", `${contactPersonName(record)} · ${contactPhone(record)}`],
+    ["Requested date", requestedDate(record)],
+    ["Status", STATUS_META[record.status].label],
+  ];
+};
 
 const SampleStamp = () => (
   <Box style={{ height: 96, display: "flex", alignItems: "center" }}>
@@ -281,7 +447,13 @@ const SignatureBlock = ({ title, stamp }: { title: string; stamp?: ReactNode })
   </Stack>
 );
 
-const TripSlipDocument = ({ record }: { record: LastMileRecord }) => (
+const TripSlipDocument = ({
+  record,
+  vehicle,
+}: {
+  record: LastMileRecord;
+  vehicle?: TripSlipVehicle | null;
+}) => (
   <Stack gap="md">
     <Stack gap={2} align="center">
       <Text fw={700}>EDR Freight</Text>
@@ -293,7 +465,7 @@ const TripSlipDocument = ({ record }: { record: LastMileRecord }) => (
     </Group>
     <Divider />
     <SimpleGrid cols={2} spacing="xs">
-      {tripSlipRows(record).map(([label, value]) => (
+      {tripSlipRows(record, vehicle).map(([label, value]) => (
         <InfoRow key={label} label={label} value={value} />
       ))}
     </SimpleGrid>
@@ -308,8 +480,8 @@ const TripSlipDocument = ({ record }: { record: LastMileRecord }) => (
 const escapeHtml = (v: string) =>
   v.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
 
-const buildTripSlipHtml = (record: LastMileRecord) => {
-  const rows = tripSlipRows(record)
+const buildTripSlipHtml = (record: LastMileRecord, vehicle?: TripSlipVehicle | null) => {
+  const rows = tripSlipRows(record, vehicle)
     .map(([l, v]) => `<tr><td class="lbl">${escapeHtml(l)}</td><td>${escapeHtml(v)}</td></tr>`)
     .join("");
   const sig = (title: string, withStamp: boolean) => `
@@ -343,7 +515,7 @@ const buildTripSlipHtml = (record: LastMileRecord) => {
       .ring-inner span { font-size: 9px; font-weight: 700; letter-spacing: 1px; }
       .ring-inner strong { font-size: 13px; font-weight: 800; }
     </style></head>
-    <body onload="window.print()">
+    <body>
       <div class="head"><h1>EDR Freight</h1><p>Last Mile Trip Slip</p></div>
       <div class="meta"><span>${escapeHtml(bookingRef(record))}</span><span>${escapeHtml(requestedDate(record))}</span></div>
       <table>${rows}</table>
@@ -355,6 +527,7 @@ const buildTripSlipHtml = (record: LastMileRecord) => {
 const LastMilePage = () => {
   const { toast } = useToast();
   const qc = useQueryClient();
+  const navigate = useNavigate();
   const { pagination, setPagination } = usePagination({ pageSize: 10 });
 
   const [search, setSearch] = useState("");
@@ -367,23 +540,28 @@ const LastMilePage = () => {
   const [detailOpen, setDetailOpen] = useState(false);
   const [tripSlipOpen, setTripSlipOpen] = useState(false);
   const [tripSlipRecord, setTripSlipRecord] = useState<LastMileRecord | null>(null);
+  // Which vehicle the trip slip is for (per-truck), + the pre-print picker.
+  const [tripSlipVehicleId, setTripSlipVehicleId] = useState<string | null>(null);
+  const [tripSlipSelectOpen, setTripSlipSelectOpen] = useState(false);
   const [activeId, setActiveId] = useState<string | null>(null);
-  const [vehicleValue, setVehicleValue] = useState<string | null>(null);
+  // Multi-vehicle assign: one row per truck — vehicle + the container it carries.
+  const [vehicleRows, setVehicleRows] = useState<
+    Array<{ vehicleId: string | null; containerNumber: string }>
+  >([{ vehicleId: null, containerNumber: "" }]);
 
   // 2-step "Assign Mile" accept modal (arrival queue → vehicle)
   const [acceptOpen, setAcceptOpen] = useState(false);
   const [acceptStep, setAcceptStep] = useState<1 | 2>(1);
   const [selectedArrivalItems, setSelectedArrivalItems] = useState<ArrivalQueueItem[]>([]);
-  const [acceptVehicleValue, setAcceptVehicleValue] = useState<string | null>(null);
+  const [acceptVehicleValues, setAcceptVehicleValues] = useState<string[]>([]);
   const [arrivalSearch, setArrivalSearch] = useState("");
 
   const [distanceOpen, setDistanceOpen] = useState(false);
-  const [distanceValue, setDistanceValue] = useState("");
-  const [invoiceOpen, setInvoiceOpen] = useState(false);
-  const [invoiceRecord, setInvoiceRecord] = useState<LastMileRecord | null>(null);
+  // Per-vehicle actual distance, keyed by vehicleId.
+  const [distanceRows, setDistanceRows] = useState<Record<string, string>>({});
+  // Record pending invoice-generation confirmation (shows a summary first).
+  const [invoiceConfirm, setInvoiceConfirm] = useState<LastMileRecord | null>(null);
 
-  const [allocationOpen, setAllocationOpen] = useState(false);
-  const [allocationContainers, setAllocationContainers] = useState<LastMileContainerRow[]>([]);
   const [releaseItem, setReleaseItem] = useState<WarehouseInventoryItem | null>(null);
   const [releaseTruckPrefill, setReleaseTruckPrefill] = useState<ReleaseOrderTruckPrefill | null>(null);
 
@@ -462,14 +640,36 @@ const LastMilePage = () => {
     },
   });
 
-  const updateDistanceMutation = useMutation({
-    mutationFn: ({ id, exactKm, remainingPayment }: { id: string; exactKm: number; remainingPayment?: number }) =>
-      lastMileService.update(id, { exactKm, ...(remainingPayment != null && { remainingPayment }) }),
+  const setVehiclesMutation = useMutation({
+    mutationFn: ({
+      id,
+      vehicles,
+    }: {
+      id: string;
+      vehicles: Array<{ vehicleId: string; containerNumber?: string | null }>;
+    }) => lastMileService.setVehicles(id, vehicles),
     onSuccess: () => {
-      void qc.invalidateQueries({ queryKey: QUERY_KEYS.LAST_MILE.list() });
-      if (activeRecord) {
-        toast({ title: "Distance updated", description: `${bookingRef(activeRecord)} → ${distanceValue} km` });
-      }
+      void qc.invalidateQueries({ queryKey: QUERY_KEYS.LAST_MILE.ROOT });
+      void qc.invalidateQueries({ queryKey: ["vehicles"] });
+    },
+    onError: () => {
+      toast({ title: "Assign failed", variant: "destructive" });
+    },
+  });
+
+  const distanceMutation = useMutation({
+    mutationFn: ({
+      id,
+      distances,
+      remainingPayment,
+    }: {
+      id: string;
+      distances: Array<{ vehicleId: string; distanceKm: number }>;
+      remainingPayment?: number;
+    }) => lastMileService.setDistances(id, distances, remainingPayment),
+    onSuccess: () => {
+      void qc.invalidateQueries({ queryKey: QUERY_KEYS.LAST_MILE.ROOT });
+      toast({ title: "Distances saved", description: activeRecord ? bookingRef(activeRecord) : undefined });
       closeDistance();
     },
     onError: () => {
@@ -477,6 +677,17 @@ const LastMilePage = () => {
     },
   });
 
+  const generateInvoiceMutation = useMutation({
+    mutationFn: (id: string) => lastMileService.generateInvoice(id),
+    onSuccess: () => {
+      void qc.invalidateQueries({ queryKey: QUERY_KEYS.LAST_MILE.ROOT });
+      toast({ title: "Invoice generated" });
+    },
+    onError: () => {
+      toast({ title: "Invoice generation failed", variant: "destructive" });
+    },
+  });
+
   const deleteMutation = useMutation({
     mutationFn: (id: string) => lastMileService.remove(id),
     onSuccess: () => {
@@ -488,19 +699,6 @@ const LastMilePage = () => {
     },
   });
 
-  const allocateMutation = useMutation({
-    mutationFn: (data: Array<{ containerId: string; vehicleId: string }>) =>
-      api.post(`/last-mile/${activeId}/allocate-containers`, data),
-    onSuccess: () => {
-      toast({ title: "Containers allocated", variant: "default" });
-      void qc.invalidateQueries({ queryKey: QUERY_KEYS.LAST_MILE.byId(activeId ?? "") });
-      void qc.invalidateQueries({ queryKey: ["vehicles"] });
-      closeAllocation();
-    },
-    onError: () => {
-      toast({ title: "Allocation failed", variant: "destructive" });
-    },
-  });
 
   const { data: arrivalQueueData, isLoading: arrivalLoading } = useQuery({
     queryKey: ["warehouse-inventory", "arrival-queue"],
@@ -522,12 +720,13 @@ const LastMilePage = () => {
   }, [arrivalQueue, arrivalSearch, existingLastMileBookingIds]);
 
   const acceptMutation = useMutation({
-    mutationFn: async ({ items, vehicleId }: { items: ArrivalQueueItem[]; vehicleId: string | null }) => {
+    mutationFn: async ({ items, vehicleIds }: { items: ArrivalQueueItem[]; vehicleIds: string[] }) => {
       const created = await Promise.all(
         items.map((item) => lastMileService.accept(item.bookingReference).then((r) => r.data)),
       );
-      if (vehicleId) {
-        await Promise.all(created.map((record) => lastMileService.update(record.id, { vehicleId })));
+      if (vehicleIds.length) {
+        const vehicles = vehicleIds.map((v) => ({ vehicleId: v }));
+        await Promise.all(created.map((record) => lastMileService.setVehicles(record.id, vehicles)));
       }
       return created;
     },
@@ -549,7 +748,7 @@ const LastMilePage = () => {
     setAcceptOpen(true);
     setAcceptStep(1);
     setSelectedArrivalItems([]);
-    setAcceptVehicleValue(null);
+    setAcceptVehicleValues([]);
     setArrivalSearch("");
   };
 
@@ -557,7 +756,7 @@ const LastMilePage = () => {
     setAcceptOpen(false);
     setAcceptStep(1);
     setSelectedArrivalItems([]);
-    setAcceptVehicleValue(null);
+    setAcceptVehicleValues([]);
     setArrivalSearch("");
   };
 
@@ -571,62 +770,50 @@ const LastMilePage = () => {
 
   const handleAcceptConfirm = () => {
     if (!selectedArrivalItems.length) return;
-    acceptMutation.mutate({ items: selectedArrivalItems, vehicleId: acceptVehicleValue });
+    acceptMutation.mutate({ items: selectedArrivalItems, vehicleIds: acceptVehicleValues });
   };
 
   const openDistance = (id: string) => {
+    const rec = records.find((r) => r.id === id);
+    const rows: Record<string, string> = {};
+    for (const a of rec?.vehicleAssignments ?? []) {
+      rows[a.vehicleId] = a.distanceKm != null ? String(a.distanceKm) : "";
+    }
     setActiveId(id);
-    setDistanceValue("");
+    setDistanceRows(rows);
     setDistanceOpen(true);
   };
 
   const closeDistance = () => {
     setDistanceOpen(false);
     setActiveId(null);
-    setDistanceValue("");
+    setDistanceRows({});
   };
 
-  const openInvoice = (record: LastMileRecord) => {
-    setInvoiceRecord(record);
-    setInvoiceOpen(true);
-  };
 
-  const closeInvoice = () => {
-    setInvoiceOpen(false);
-    setInvoiceRecord(null);
-  };
-
-  const openAllocation = (id: string, containers?: LastMileContainerRow[]) => {
-    setActiveId(id);
-    setAllocationContainers(containers ?? []);
-    setAllocationOpen(true);
-  };
-
-  const closeAllocation = () => {
-    setAllocationOpen(false);
-    setActiveId(null);
-    setAllocationContainers([]);
-  };
 
   const handleSaveDistance = () => {
-    const distance = parseFloat(distanceValue);
-    if (!activeId || isNaN(distance) || distance < 0) {
-      toast({ title: "Invalid distance", description: "Enter a valid distance value.", variant: "destructive" });
+    const distances = Object.entries(distanceRows)
+      .map(([vehicleId, val]) => ({ vehicleId, distanceKm: parseFloat(val) }))
+      .filter((d) => !Number.isNaN(d.distanceKm) && d.distanceKm >= 0);
+
+    if (!activeId || !distances.length) {
+      toast({ title: "Invalid distance", description: "Enter a distance for at least one vehicle.", variant: "destructive" });
       return;
     }
 
+    const total = distances.reduce((s, d) => s + d.distanceKm, 0);
     let remainingPayment: number | undefined;
     if (ratesData?.data) {
       const lastMileRate = ratesData.data.find(
         (r) => r.rateType === "LAST_MILE" && (r.status === "LIVE" || r.status === "DRAFT")
       );
       if (lastMileRate) {
-        const rateValue = parseFloat(lastMileRate.rateValue);
-        remainingPayment = distance * rateValue;
+        remainingPayment = total * parseFloat(lastMileRate.rateValue);
       }
     }
 
-    updateDistanceMutation.mutate({ id: activeId, exactKm: distance, remainingPayment });
+    distanceMutation.mutate({ id: activeId, distances, remainingPayment });
   };
 
   const activeRecord = useMemo(
@@ -634,6 +821,68 @@ const LastMilePage = () => {
     [records, activeId],
   );
 
+  // Vehicle picker options for the assign modal = free vehicles PLUS the ones
+  // already on this record (which are BUSY, so absent from the free list) so a
+  // reassign shows its current trucks selected instead of blank.
+  const assignVehicleOptions = useMemo(() => {
+    const opts = [...vehicleOptions];
+    const seen = new Set(opts.map((o) => o.value));
+    const pushVehicle = (v?: LastMileVehicle | null) => {
+      if (v && !seen.has(v.id)) {
+        seen.add(v.id);
+        const parts = [`${v.manufacturer} ${v.model}`, v.plateNumber];
+        if (v.code) parts.unshift(v.code);
+        opts.push({ value: v.id, label: parts.join(" · ") });
+      }
+    };
+    for (const a of activeRecord?.vehicleAssignments ?? []) pushVehicle(a.vehicle);
+    pushVehicle(activeRecord?.vehicle);
+    // Fallback: an assigned vehicle whose relation didn't load still needs an
+    // option so the reassign Select can render it as selected (not blank).
+    for (const a of activeRecord?.vehicleAssignments ?? []) {
+      if (!seen.has(a.vehicleId)) {
+        seen.add(a.vehicleId);
+        opts.push({
+          value: a.vehicleId,
+          label: a.containerNumber ? `Assigned · ${a.containerNumber}` : "Assigned vehicle",
+        });
+      }
+    }
+    if (activeRecord?.vehicleId && !seen.has(activeRecord.vehicleId)) {
+      opts.push({ value: activeRecord.vehicleId, label: "Assigned vehicle" });
+    }
+    return opts;
+  }, [vehicleOptions, activeRecord]);
+
+  // Full booking (with container units) for the assign modal's container dropdown.
+  // Fetched on open so container numbers show regardless of what the list embeds.
+  const { data: assignBooking } = useQuery({
+    queryKey: activeRecord?.bookingId
+      ? QUERY_KEYS.BOOKINGS.byId(activeRecord.bookingId)
+      : ["bookings", "detail", "none"],
+    queryFn: () => bookingsService.getById(activeRecord!.bookingId),
+    enabled: assignOpen && !bulkMode && Boolean(activeRecord?.bookingId),
+  });
+
+  // Container-number options for the dropdown = the booking's real per-container
+  // numbers (units), falling back to whatever the list record carried.
+  const containerOptions = useMemo(() => {
+    const real = (n?: string | null): n is string =>
+      Boolean(n) && !/^TBD/i.test(n!.trim());
+    const out: string[] = [];
+    for (const c of assignBooking?.bookingContainers ?? []) {
+      const units = [...(c.units ?? [])].sort(
+        (a, b) => (a.sortOrder ?? 0) - (b.sortOrder ?? 0),
+      );
+      if (units.length) {
+        for (const u of units) if (real(u.containerNumber)) out.push(u.containerNumber);
+      } else if (real(c.containerNumber)) {
+        out.push(c.containerNumber);
+      }
+    }
+    return out.length ? out : activeRecord ? bookingContainerNumbers(activeRecord) : [];
+  }, [assignBooking, activeRecord]);
+
   const pickupReadyByBooking = useMemo(() => {
     const map = new Map<string, ImportUnloadedItem>();
     for (const row of pickupReadyRows) {
@@ -675,11 +924,16 @@ const LastMilePage = () => {
     return counts;
   }, [records]);
 
+  const postPaymentPendingCount = useMemo(
+    () => records.filter(isPostPaymentPending).length,
+    [records],
+  );
+
   const filteredRecords = useMemo(() => {
     const term = search.trim().toLowerCase();
     return records.filter((r) => {
       if (!matchesFilter(r)) return false;
-      if (filterPostPaymentPending && !(r.remainingPayment > 0)) return false;
+      if (filterPostPaymentPending && !isPostPaymentPending(r)) return false;
       if (!term) return true;
       return [bookingRef(r), customerName(r), deliveryLocation(r), cargoDesc(r)]
         .join(" ")
@@ -697,16 +951,29 @@ const LastMilePage = () => {
 
   const openAssign = (id: string | null) => {
     const resolved = id ?? filteredRecords.find((r) => !isAssigned(r))?.id ?? null;
+    const rec = records.find((r) => r.id === resolved);
+    // Prefill each row's container number from the booking's container numbers
+    // (by order) when the assignment doesn't already carry one.
+    const nums = rec ? bookingContainerNumbers(rec) : [];
+    const rows =
+      rec?.vehicleAssignments?.length
+        ? rec.vehicleAssignments.map((a, i) => ({
+            vehicleId: a.vehicleId,
+            containerNumber: a.containerNumber ?? nums[i] ?? "",
+          }))
+        : rec?.vehicleId
+          ? [{ vehicleId: rec.vehicleId, containerNumber: nums[0] ?? "" }]
+          : [{ vehicleId: null, containerNumber: nums[0] ?? "" }];
     setBulkMode(false);
     setActiveId(resolved);
-    setVehicleValue(null);
+    setVehicleRows(rows.length ? rows : [{ vehicleId: null, containerNumber: nums[0] ?? "" }]);
     setAssignOpen(true);
   };
 
   const openBulkAssign = () => {
     setBulkMode(true);
     setActiveId(null);
-    setVehicleValue(null);
+    setVehicleRows([{ vehicleId: null, containerNumber: "" }]);
     setAssignOpen(true);
   };
 
@@ -714,28 +981,31 @@ const LastMilePage = () => {
     setAssignOpen(false);
     setBulkMode(false);
     setActiveId(null);
-    setVehicleValue(null);
+    setVehicleRows([{ vehicleId: null, containerNumber: "" }]);
   };
 
   const handleAssign = () => {
-    if (!vehicleValue) {
-      toast({ title: "Select a vehicle", description: "Choose a vehicle to assign.", variant: "destructive" });
-      return;
-    }
-
+    const seen = new Set<string>();
+    const vehicles = vehicleRows
+      .filter((r): r is { vehicleId: string; containerNumber: string } => Boolean(r.vehicleId))
+      .filter((r) => (seen.has(r.vehicleId) ? false : seen.add(r.vehicleId)))
+      .map((r) => ({ vehicleId: r.vehicleId, containerNumber: r.containerNumber.trim() || null }));
+    const count = vehicles.length;
     const targetIds = bulkMode
       ? selectedIds
       : [activeId ?? filteredRecords.find((r) => !isAssigned(r))?.id].filter((id): id is string => Boolean(id));
 
     if (!targetIds.length) return;
 
-    const selectedLabel = vehicleOptions.find((o) => o.value === vehicleValue)?.label ?? vehicleValue;
-
-    Promise.all(targetIds.map((id) => updateMutation.mutateAsync({ id, data: { vehicleId: vehicleValue } })))
+    // Empty set = unassign all (setVehicles releases the removed vehicles).
+    Promise.all(targetIds.map((id) => setVehiclesMutation.mutateAsync({ id, vehicles })))
       .then(() => {
         toast({
-          title: "Vehicle assigned",
-          description: bulkMode ? `${targetIds.length} deliveries → ${selectedLabel}` : selectedLabel,
+          title: count === 0 ? "Vehicles unassigned" : count > 1 ? "Vehicles assigned" : "Vehicle assigned",
+          description:
+            count === 0
+              ? bulkMode ? `${targetIds.length} deliveries` : undefined
+              : `${bulkMode ? `${targetIds.length} deliveries · ` : ""}${count} vehicle${count > 1 ? "s" : ""}`,
         });
         if (bulkMode) setRowSelection({});
         closeAssign();
@@ -756,7 +1026,21 @@ const LastMilePage = () => {
   };
 
   const handlePrintTripSlip = (record: LastMileRecord) => {
+    // Always open the picker so the operator chooses which truck to print.
     setTripSlipRecord(record);
+    setTripSlipVehicleId(null);
+    setTripSlipSelectOpen(true);
+  };
+
+  const printBookingSlip = () => {
+    setTripSlipVehicleId(null);
+    setTripSlipSelectOpen(false);
+    setTripSlipOpen(true);
+  };
+
+  const chooseTripSlipVehicle = (vehicleId: string) => {
+    setTripSlipVehicleId(vehicleId);
+    setTripSlipSelectOpen(false);
     setTripSlipOpen(true);
   };
 
@@ -784,6 +1068,15 @@ const LastMilePage = () => {
     setReleaseItem(toReleaseInventoryItem(row));
   };
 
+  // Truck leaving the warehouse = the leg is now in transit. Advance the status
+  // (same as "Mark In Transit") alongside the warehouse exit-weighing flow.
+  const handleTruckLeaving = (record: LastMileRecord) => {
+    openTruckArrival(record);
+    if (record.status === "READY_TO_TRANSIT") {
+      updateMutation.mutate({ id: record.id, data: { status: "IN_TRANSIT" } });
+    }
+  };
+
   const closeTruckArrival = () => {
     setReleaseItem(null);
     setReleaseTruckPrefill(null);
@@ -791,6 +1084,9 @@ const LastMilePage = () => {
     void qc.invalidateQueries({ queryKey: QUERY_KEYS.LAST_MILE.ROOT });
   };
 
+  const tripSlipVehicle =
+    tripSlipRecord?.vehicleAssignments?.find((a) => a.vehicleId === tripSlipVehicleId) ?? null;
+
   const printTripSlip = () => {
     if (!tripSlipRecord) return;
     const win = window.open("", "_blank", "width=820,height=920");
@@ -798,8 +1094,17 @@ const LastMilePage = () => {
       toast({ title: "Pop-up blocked", description: "Allow pop-ups to print the trip slip.", variant: "destructive" });
       return;
     }
-    win.document.write(buildTripSlipHtml(tripSlipRecord));
+    win.document.write(buildTripSlipHtml(tripSlipRecord, tripSlipVehicle));
     win.document.close();
+    win.focus();
+    // Explicit print after the doc paints (onload can miss with document.write).
+    setTimeout(() => {
+      try {
+        win.print();
+      } catch {
+        /* window may have been closed */
+      }
+    }, 250);
   };
 
   const columns = useMemo((): ColumnDef<LastMileRecord>[] => {
@@ -839,47 +1144,49 @@ const LastMilePage = () => {
         meta: { headerClassName, cellClassName },
         cell: ({ row }) => customerName(row.original),
       },
-      {
-        id: "pickup",
-        header: "Pickup",
-        meta: { headerClassName, cellClassName },
-        cell: ({ row }) => originYardName(row.original),
-      },
-      {
-        id: "destination",
-        header: "Destination",
-        meta: { headerClassName, cellClassName },
-        cell: ({ row }) => deliveryLocation(row.original),
-      },
-      {
-        id: "cargo",
-        header: "Cargo",
-        meta: { headerClassName, cellClassName },
-        cell: ({ row }) => cargoDesc(row.original),
-      },
-      {
-        id: "advancedPayment",
-        header: "Advanced Payment",
-        meta: { headerClassName, cellClassName },
-        cell: ({ row }) => formatPrice(row.original.advancedPayment),
-      },
       {
         id: "postPayment",
         header: "Post Payment",
         meta: { headerClassName, cellClassName },
-        cell: ({ row }) => formatPrice(row.original.remainingPayment),
+        cell: ({ row }) => formatPrice(row.original.remainingPayment, currencyOf(row.original)),
       },
       {
         id: "vehicle",
         header: "Vehicle",
         meta: { headerClassName, cellClassName },
-        cell: ({ row }) => vehicleLabel(row.original) ?? <Text c="dimmed">—</Text>,
-      },
-      {
-        id: "estimatedKm",
-        header: "Est. Distance (KM)",
-        meta: { headerClassName, cellClassName },
-        cell: ({ row }) => row.original.estimatedKm != null ? row.original.estimatedKm : <Text c="dimmed">—</Text>,
+        cell: ({ row }) => {
+          const assigns = row.original.vehicleAssignments ?? [];
+          if (assigns.length > 1) {
+            const labelFor = (a: (typeof assigns)[number]) => {
+              const v = a.vehicle;
+              const l = v ? [v.code, v.plateNumber].filter(Boolean).join(" · ") : a.vehicleId;
+              return a.containerNumber ? `${l} · ${a.containerNumber}` : l;
+            };
+            return (
+              <Tooltip
+                withArrow
+                multiline
+                label={
+                  <div style={{ whiteSpace: "pre-line" }}>
+                    {assigns.map(labelFor).join("\n")}
+                  </div>
+                }
+              >
+                <Group gap={4} wrap="nowrap" style={{ whiteSpace: "nowrap" }}>
+                  <Text size="sm" style={{ whiteSpace: "nowrap" }}>
+                    {assigns[0].vehicle
+                      ? [assigns[0].vehicle.code, assigns[0].vehicle.plateNumber].filter(Boolean).join(" · ")
+                      : assigns[0].vehicleId}
+                  </Text>
+                  <Badge size="sm" variant="light" color="blue">
+                    +{assigns.length - 1}
+                  </Badge>
+                </Group>
+              </Tooltip>
+            );
+          }
+          return vehicleLabel(row.original) ?? <Text c="dimmed">Unassigned</Text>;
+        },
       },
       {
         id: "exactKm",
@@ -892,35 +1199,32 @@ const LastMilePage = () => {
         header: "Invoice",
         meta: { headerClassName, cellClassName },
         cell: ({ row }) => {
-          const hasDistance = row.original.exactKm != null && row.original.exactKm > 0;
-          const isPaid = (row.original as any).paid;
-          if (!hasDistance) {
+          // Only show an invoice once it's actually been generated — NOT merely
+          // because distance was entered.
+          const invoice = row.original.invoice;
+          if (!invoice) {
             return <Text c="dimmed">—</Text>;
           }
-          if (isPaid) {
-            return (
-              <Group gap="xs" wrap="nowrap">
-                <UnstyledButton
-                  onClick={() => openInvoice(row.original)}
-                  c="blue"
-                  fw={500}
-                  style={{ textDecoration: "underline", cursor: "pointer" }}
-                >
-                  #345
-                </UnstyledButton>
-                <Badge color="green" variant="light" size="sm">Paid</Badge>
-              </Group>
-            );
-          }
+          const status = String((row.original as any).paid ? "PAID" : invoice.status || "").toUpperCase();
+          const badge = INVOICE_STATUS_META[status] ?? { color: "gray", label: status || "—" };
           return (
-            <UnstyledButton
-              onClick={() => openInvoice(row.original)}
-              c="blue"
-              fw={500}
-              style={{ textDecoration: "underline", cursor: "pointer" }}
-            >
-              #345
-            </UnstyledButton>
+            <Group gap="xs" wrap="nowrap">
+              <UnstyledButton
+                onClick={() =>
+                  invoice.id
+                    ? navigate(`/dashboard/invoices/${invoice.id}`)
+                    : toast({ title: "Invoice link unavailable", description: "Refresh after the API restart.", variant: "destructive" })
+                }
+                c="blue"
+                fw={500}
+                style={{ textDecoration: "underline", cursor: "pointer" }}
+              >
+                <Tooltip label={invoice.number} withArrow>
+                  <span>{shortInvoiceNo(invoice.number)}</span>
+                </Tooltip>
+              </UnstyledButton>
+              {status && <Badge color={badge.color} variant="filled" size="sm">{badge.label}</Badge>}
+            </Group>
           );
         },
       },
@@ -933,16 +1237,6 @@ const LastMilePage = () => {
           return <Badge color={meta.color} variant="light" size="sm">{meta.label}</Badge>;
         },
       },
-      {
-        id: "assignment",
-        header: "Assignment",
-        meta: { headerClassName, cellClassName },
-        cell: ({ row }) => (
-          <Badge color={isAssigned(row.original) ? "green" : "orange"} variant="light" size="sm">
-            {isAssigned(row.original) ? "Assigned" : "Unassigned"}
-          </Badge>
-        ),
-      },
       {
         id: "actions",
         header: "Actions",
@@ -955,10 +1249,33 @@ const LastMilePage = () => {
           const delivered = row.original.status === "DELIVERED";
           const releaseRow =
             pickupReadyByBooking.get(row.original.bookingId) ?? pickupReadyByBooking.get(bookingRef(row.original));
-          const truckArrivalLabel = releaseRow?.releaseOrderReference ? "Truck Leaving" : "Truck Arrival";
+          // Gate on PERSISTENT state (status/vehicle/distance), not the truck
+          // arrival/leave signals — those live in the warehouse queue and vanish
+          // once the item is released, so they can't gate the status advance.
+          const status = row.original.status;
+          const hasDistance = row.original.exactKm != null;
+          // Advance: PAYMENT_PENDING→Ready, READY_TO_TRANSIT→In-transit (needs a
+          // vehicle), IN_TRANSIT→Delivered (needs distance/invoice).
+          const canAdvance =
+            status === "PAYMENT_PENDING" ||
+            (status === "READY_TO_TRANSIT" && assigned) ||
+            (status === "IN_TRANSIT" && hasDistance);
+          const canAssignStep = !assigned && status !== "DELIVERED";
+          const canDistance = status === "IN_TRANSIT";
+          // Truck arrival/leaving are independent — each driven by its own
+          // warehouse state — but both are done once the leg is IN_TRANSIT/DELIVERED.
+          const pastTransit = status === "IN_TRANSIT" || status === "DELIVERED";
+          const canArrive = assigned && !releaseRow?.releaseOrderReference && !pastTransit;
+          const canLeave =
+            Boolean(releaseRow?.releaseOrderReference) && !releaseRow?.releaseDate && !pastTransit;
           return (
             <Group gap={4} justify="flex-end" wrap="nowrap">
-              <Menu position="bottom-end" width={200} withinPortal>
+              <Menu
+                position="bottom-end"
+                width={200}
+                withinPortal
+                styles={{ dropdown: { maxHeight: 320, overflowY: "auto" } }}
+              >
                 <Menu.Target>
                   <ActionIcon variant="subtle" color="gray" aria-label="Delivery actions">
                     <MoreHorizontal size={16} />
@@ -967,32 +1284,57 @@ const LastMilePage = () => {
                 <Menu.Dropdown>
                   <Menu.Item
                     leftSection={<ArrowRight size={15} />}
-                    disabled={!nextStatus}
+                    disabled={!nextStatus || !canAdvance}
                     onClick={() => handleAdvanceStatus(row.original)}
                   >
-                    {nextStatus ? `Mark ${STATUS_META[nextStatus].label}` : STATUS_META[row.original.status].label}
+                    {nextStatus
+                      ? `Mark ${STATUS_META[nextStatus].label}`
+                      : STATUS_META[row.original.status].label}
                   </Menu.Item>
                   <Menu.Divider />
                   <Menu.Item
                     leftSection={<Truck size={15} />}
-                    disabled={assigned || delivered}
+                    disabled={!canAssignStep}
                     onClick={() => openAssign(row.original.id)}
                   >
                     Assign
                   </Menu.Item>
                   <Menu.Item
                     leftSection={<RefreshCw size={15} />}
-                    disabled={!assigned || delivered}
+                    disabled={!assigned || delivered || Boolean(row.original.invoice)}
                     onClick={() => openAssign(row.original.id)}
                   >
                     Reassign
                   </Menu.Item>
+                  <Menu.Item
+                    color="red"
+                    leftSection={<X size={15} />}
+                    disabled={!assigned || delivered || Boolean(row.original.invoice)}
+                    onClick={() =>
+                      setVehiclesMutation.mutate(
+                        { id: row.original.id, vehicles: [] },
+                        {
+                          onSuccess: () =>
+                            toast({ title: "Vehicles unassigned", description: bookingRef(row.original) }),
+                        },
+                      )
+                    }
+                  >
+                    Unassign
+                  </Menu.Item>
                   <Menu.Item
                     leftSection={<Truck size={15} />}
-                    disabled={!assigned}
+                    disabled={!canArrive}
                     onClick={() => openTruckArrival(row.original)}
                   >
-                    {truckArrivalLabel}
+                    Truck Arrival
+                  </Menu.Item>
+                  <Menu.Item
+                    leftSection={<Truck size={15} />}
+                    disabled={!canLeave}
+                    onClick={() => handleTruckLeaving(row.original)}
+                  >
+                    Truck Leaving
                   </Menu.Item>
                   <Menu.Divider />
                   <Menu.Item
@@ -1003,11 +1345,21 @@ const LastMilePage = () => {
                   </Menu.Item>
                   <Menu.Item
                     leftSection={<Ruler size={15} />}
-                    disabled={delivered}
+                    disabled={!canDistance || Boolean(row.original.invoice)}
                     onClick={() => openDistance(row.original.id)}
                   >
                     Add distance
                   </Menu.Item>
+                  <Menu.Item
+                    leftSection={<Receipt size={15} />}
+                    disabled={
+                      !(row.original.exactKm != null && row.original.exactKm > 0) ||
+                      Boolean(row.original.invoice)
+                    }
+                    onClick={() => setInvoiceConfirm(row.original)}
+                  >
+                    {row.original.invoice ? "Invoice generated" : "Generate Invoice"}
+                  </Menu.Item>
                   {canPrint && (
                     <Menu.Item
                       leftSection={<Printer size={15} />}
@@ -1022,7 +1374,7 @@ const LastMilePage = () => {
                       <Menu.Item
                         leftSection={<Trash size={15} />}
                         color="red"
-                        disabled={delivered}
+                        disabled={delivered || Boolean(row.original.invoice)}
                         onClick={() => {
                           if (confirm(`Delete last-mile record ${bookingRef(row.original)}?`)) {
                             deleteMutation.mutate(row.original.id);
@@ -1044,7 +1396,7 @@ const LastMilePage = () => {
   }, [vehicleOptions, pickupReadyByBooking]);
 
   return (
-    <Stack gap="md">
+    <Stack gap="md" p="md">
       <Card radius="lg" padding={0} withBorder style={{ borderColor: "var(--mantine-color-gray-2)" }}>
         <Stack gap={0}>
           <Box px="md" pt="md" pb="sm" w="100%">
@@ -1094,7 +1446,7 @@ const LastMilePage = () => {
                     setPagination((p) => ({ ...p, pageIndex: 0 }));
                   }}
                 >
-                  Post Payment Pending
+                  Post Payment Pending ({postPaymentPendingCount})
                 </Button>
               </Group>
             </Stack>
@@ -1228,19 +1580,26 @@ const LastMilePage = () => {
               </Stack>
             </Card>
             <Divider />
-            <Select
-              label="Assign Vehicle (optional)"
-              placeholder={vehicleOptions.length === 0 ? "No free vehicles" : "Select a vehicle"}
+            <MultiSelect
+              label="Assign Vehicles (optional)"
+              placeholder={
+                vehicleOptions.length === 0
+                  ? "No free vehicles"
+                  : acceptVehicleValues.length === 0
+                    ? "Add vehicles"
+                    : undefined
+              }
               description={
                 vehicleOptions.length === 0
-                  ? "No free vehicles available — you can still accept and assign a vehicle later."
-                  : undefined
+                  ? "No free vehicles available — you can still accept and assign vehicles later."
+                  : "Pick one or more trucks for this delivery."
               }
               data={vehicleOptions}
-              value={acceptVehicleValue}
-              onChange={setAcceptVehicleValue}
+              value={acceptVehicleValues}
+              onChange={setAcceptVehicleValues}
               searchable
               clearable
+              hidePickedOptions
               disabled={vehicleOptions.length === 0}
             />
             <Group justify="space-between" gap="sm">
@@ -1281,29 +1640,123 @@ const LastMilePage = () => {
           ) : (
             <Text size="sm" c="dimmed">No unassigned deliveries available.</Text>
           )}
-          <Divider />
-          <Select
-            label="Vehicle"
-            placeholder={vehicleOptions.length === 0 ? "No free vehicles" : "Select a vehicle"}
-            description={
-              vehicleOptions.length === 0
-                ? "No free vehicles available — all vehicles are busy, in maintenance, or retired. Free up a vehicle in Fleet › Vehicles first."
-                : undefined
+          {!bulkMode && activeRecord && (() => {
+            const containers = containerCount(activeRecord);
+            const needed = requiredVehicles(activeRecord);
+            const picked = vehicleRows.filter((r) => r.vehicleId).length;
+            if (needed === 0) {
+              return (
+                <Alert variant="light" color="gray" title="One truck (with trailer) carries 2 containers">
+                  No container count on this booking — assign trucks as needed.
+                </Alert>
+              );
             }
-            data={vehicleOptions}
-            value={vehicleValue}
-            onChange={setVehicleValue}
-            searchable
-            disabled={vehicleOptions.length === 0}
-          />
+            const ok = picked === needed;
+            return (
+              <Alert
+                variant="light"
+                color={ok ? "green" : "yellow"}
+                title={`${containers} container${containers === 1 ? "" : "s"} · needs ${needed} vehicle${needed === 1 ? "" : "s"}`}
+              >
+                One truck (with trailer) carries {CONTAINERS_PER_VEHICLE} containers.
+                {picked > 0 && !ok &&
+                  ` You've selected ${picked} — ${picked < needed ? "add more" : "that's more than needed"}.`}
+              </Alert>
+            );
+          })()}
+          {!bulkMode && activeRecord && containerLabels(activeRecord).length > 0 && (
+            <Card withBorder padding="xs" radius="md" bg="var(--mantine-color-gray-0)">
+              <Text size="xs" fw={600} c="dimmed" mb={4}>
+                Containers ({containerLabels(activeRecord).length})
+              </Text>
+              <Group gap={6}>
+                {containerLabels(activeRecord).map((label, i) => (
+                  <Badge key={i} size="sm" variant="outline" color="gray">
+                    {label}
+                  </Badge>
+                ))}
+              </Group>
+            </Card>
+          )}
+          <Divider />
+          <Stack gap="xs">
+            {vehicleRows.map((row, i) => (
+              <Group key={i} gap="xs" wrap="nowrap" align="flex-end">
+                <Select
+                  style={{ flex: 1.4 }}
+                  label={i === 0 ? "Vehicle" : undefined}
+                  placeholder={assignVehicleOptions.length === 0 ? "No free vehicles" : "Select a vehicle"}
+                  data={assignVehicleOptions.filter(
+                    (o) => o.value === row.vehicleId || !vehicleRows.some((r) => r.vehicleId === o.value),
+                  )}
+                  value={row.vehicleId}
+                  onChange={(v) =>
+                    setVehicleRows((prev) => prev.map((x, idx) => (idx === i ? { ...x, vehicleId: v } : x)))
+                  }
+                  searchable
+                  clearable
+                  disabled={assignVehicleOptions.length === 0}
+                />
+                <Autocomplete
+                  style={{ flex: 1 }}
+                  label={i === 0 ? "Container no." : undefined}
+                  placeholder="Container number"
+                  data={containerOptions.filter(
+                    (n) =>
+                      n === row.containerNumber ||
+                      !vehicleRows.some((r, idx) => idx !== i && r.containerNumber === n),
+                  )}
+                  value={row.containerNumber}
+                  onChange={(value) =>
+                    setVehicleRows((prev) =>
+                      prev.map((x, idx) => (idx === i ? { ...x, containerNumber: value } : x)),
+                    )
+                  }
+                />
+                {vehicleRows.length > 1 && (
+                  <ActionIcon
+                    variant="subtle"
+                    color="red"
+                    aria-label="Remove vehicle"
+                    onClick={() => setVehicleRows((prev) => prev.filter((_, idx) => idx !== i))}
+                  >
+                    <X size={16} />
+                  </ActionIcon>
+                )}
+              </Group>
+            ))}
+            <Button
+              variant="light"
+              size="xs"
+              leftSection={<Plus size={14} />}
+              onClick={() =>
+                setVehicleRows((prev) => [
+                  ...prev,
+                  {
+                    vehicleId: null,
+                    containerNumber:
+                      (activeRecord ? bookingContainerNumbers(activeRecord)[prev.length] : "") ?? "",
+                  },
+                ])
+              }
+              disabled={
+                assignVehicleOptions.length === 0 ||
+                vehicleRows.some((r) => !r.vehicleId) ||
+                vehicleRows.filter((r) => r.vehicleId).length >= assignVehicleOptions.length
+              }
+              style={{ alignSelf: "flex-start" }}
+            >
+              Add vehicle
+            </Button>
+          </Stack>
           <Group justify="flex-end" gap="sm">
             <Button variant="default" onClick={closeAssign}>Cancel</Button>
             <Button
               onClick={handleAssign}
-              loading={updateMutation.isPending}
+              loading={setVehiclesMutation.isPending}
               disabled={bulkMode ? selectedIds.length === 0 : !activeRecord}
             >
-              {!bulkMode && activeRecord && isAssigned(activeRecord) ? "Reassign" : "Assign"}
+              {!bulkMode && activeRecord && isAssigned(activeRecord) ? "Update vehicles" : "Assign"}
             </Button>
           </Group>
         </Stack>
@@ -1320,6 +1773,43 @@ const LastMilePage = () => {
       >
         <Stack gap="md">
           {activeRecord && <BookingInfo record={activeRecord} />}
+          {activeRecord && (activeRecord.vehicleAssignments?.length ?? 0) > 0 && (
+            <Card withBorder padding="md" radius="md">
+              <Text fw={600} size="sm" mb="sm">Assigned vehicles</Text>
+              <Stack gap="xs">
+                {activeRecord.vehicleAssignments!.map((a) => {
+                  const v = a.vehicle;
+                  const label = v
+                    ? [v.code, v.plateNumber].filter(Boolean).join(" · ")
+                    : a.vehicleId;
+                  return (
+                    <Group key={a.id} justify="space-between" wrap="nowrap">
+                      <Text size="sm">{label}</Text>
+                      {a.containerNumber ? (
+                        <Badge size="sm" variant="light" color="blue">
+                          {a.containerNumber}
+                        </Badge>
+                      ) : (
+                        <Text size="xs" c="dimmed">No container no.</Text>
+                      )}
+                    </Group>
+                  );
+                })}
+              </Stack>
+            </Card>
+          )}
+          {activeRecord && (
+            <Card withBorder padding="md" radius="md">
+              <Text fw={600} size="sm" mb="sm">Delivery steps</Text>
+              <LastMileStepper
+                steps={computeLastMileSteps(
+                  activeRecord,
+                  pickupReadyByBooking.get(activeRecord.bookingId) ??
+                    pickupReadyByBooking.get(bookingRef(activeRecord)),
+                )}
+              />
+            </Card>
+          )}
           <Group justify="flex-end">
             <Button variant="default" onClick={() => { setDetailOpen(false); setActiveId(null); }}>Close</Button>
           </Group>
@@ -1336,7 +1826,7 @@ const LastMilePage = () => {
         centered
       >
         <Stack gap="md">
-          {tripSlipRecord && <TripSlipDocument record={tripSlipRecord} />}
+          {tripSlipRecord && <TripSlipDocument record={tripSlipRecord} vehicle={tripSlipVehicle} />}
           <Divider />
           <Group justify="flex-end" gap="sm">
             <Button variant="default" onClick={() => setTripSlipOpen(false)}>Close</Button>
@@ -1345,6 +1835,61 @@ const LastMilePage = () => {
         </Stack>
       </Modal>
 
+      {/* Trip slip — pick a vehicle (multi-truck) */}
+      <Modal
+        opened={tripSlipSelectOpen}
+        onClose={() => setTripSlipSelectOpen(false)}
+        title={<Text fw={600}>Print trip slip — select vehicle</Text>}
+        radius="lg"
+        centered
+      >
+        <Stack gap="sm">
+          <Text size="sm" c="dimmed">
+            {tripSlipRecord ? bookingRef(tripSlipRecord) : ""} — pick a truck to print its slip.
+          </Text>
+          {(tripSlipRecord?.vehicleAssignments ?? []).map((a) => {
+            const v = a.vehicle;
+            const label = v ? [v.code, v.plateNumber].filter(Boolean).join(" · ") : a.vehicleId;
+            return (
+              <Card
+                key={a.id}
+                withBorder
+                radius="md"
+                padding="sm"
+                onClick={() => chooseTripSlipVehicle(a.vehicleId)}
+                style={{ cursor: "pointer" }}
+                className="hover:bg-gray-50"
+              >
+                <Group justify="space-between" wrap="nowrap" align="center">
+                  <Stack gap={2} style={{ minWidth: 0 }}>
+                    <Group gap="xs" wrap="nowrap">
+                      <Truck size={15} />
+                      <Text size="sm" fw={600} truncate>{label}</Text>
+                    </Group>
+                    <Text size="xs" c="dimmed" truncate>
+                      Driver: {v?.assignedDriverName || "—"}
+                    </Text>
+                    <Text size="xs" c="dimmed" truncate>
+                      Container: {a.containerNumber || "—"}
+                    </Text>
+                  </Stack>
+                  <ActionIcon variant="light" color="edr-green" size="lg" aria-label="Print">
+                    <Printer size={16} />
+                  </ActionIcon>
+                </Group>
+              </Card>
+            );
+          })}
+          {(tripSlipRecord?.vehicleAssignments?.length ?? 0) === 0 && (
+            <Text size="sm" c="dimmed" ta="center" py="xs">No vehicles assigned yet.</Text>
+          )}
+          <Divider label="or" labelPosition="center" />
+          <Button variant="subtle" size="sm" onClick={printBookingSlip}>
+            Print booking slip (no vehicle)
+          </Button>
+        </Stack>
+      </Modal>
+
       {/* Add Actual Distance modal */}
       <Modal
         opened={distanceOpen}
@@ -1357,34 +1902,51 @@ const LastMilePage = () => {
         <Stack gap="md">
           {activeRecord && (
             <Card withBorder padding="md" radius="md" bg="var(--mantine-color-gray-0)">
-              <Stack gap="sm">
+              <Group justify="space-between">
                 <Text fw={600} size="sm">{bookingRef(activeRecord)}</Text>
-                <Group justify="space-between">
-                  <Text size="xs" c="dimmed">Customer</Text>
-                  <Text size="sm">{customerName(activeRecord)}</Text>
-                </Group>
-                <Group justify="space-between">
-                  <Text size="xs" c="dimmed">Est. Distance (KM)</Text>
-                  <Text size="sm">{activeRecord.estimatedKm ?? "—"}</Text>
-                </Group>
-              </Stack>
+                <Text size="xs" c="dimmed">Est. {activeRecord.estimatedKm ?? "—"} km</Text>
+              </Group>
             </Card>
           )}
-          <NumberInput
-            label="Actual Distance (KM)"
-            placeholder="Enter distance"
-            value={distanceValue}
-            onChange={(v) => setDistanceValue(String(v ?? ""))}
-            min={0}
-            step={0.1}
-            decimalScale={2}
-          />
+          {(activeRecord?.vehicleAssignments?.length ?? 0) === 0 ? (
+            <Text size="sm" c="dimmed">Assign a vehicle before entering distance.</Text>
+          ) : (
+            <Stack gap="sm">
+              {activeRecord!.vehicleAssignments!.map((a) => {
+                const v = a.vehicle;
+                const label = v ? [v.code, v.plateNumber].filter(Boolean).join(" · ") : a.vehicleId;
+                return (
+                  <NumberInput
+                    key={a.id}
+                    label={`${label}${a.containerNumber ? ` · ${a.containerNumber}` : ""}`}
+                    placeholder="Distance (km)"
+                    value={distanceRows[a.vehicleId] ?? ""}
+                    onChange={(val) =>
+                      setDistanceRows((prev) => ({ ...prev, [a.vehicleId]: String(val ?? "") }))
+                    }
+                    min={0}
+                    step={0.1}
+                    decimalScale={2}
+                  />
+                );
+              })}
+              <Group justify="space-between">
+                <Text size="xs" c="dimmed">Total</Text>
+                <Text size="sm" fw={600}>
+                  {Object.values(distanceRows)
+                    .reduce((s, val) => s + (parseFloat(val) || 0), 0)
+                    .toFixed(2)}{" "}
+                  km
+                </Text>
+              </Group>
+            </Stack>
+          )}
           <Group justify="flex-end" gap="sm">
             <Button variant="default" onClick={closeDistance}>Cancel</Button>
             <Button
               onClick={handleSaveDistance}
-              loading={updateDistanceMutation.isPending}
-              disabled={!distanceValue}
+              loading={distanceMutation.isPending}
+              disabled={Object.values(distanceRows).every((v) => !v)}
             >
               Save
             </Button>
@@ -1392,155 +1954,63 @@ const LastMilePage = () => {
         </Stack>
       </Modal>
 
-      {/* Invoice modal */}
+      {/* Generate Invoice — confirmation summary */}
       <Modal
-        opened={invoiceOpen}
-        onClose={closeInvoice}
-        title={<Text fw={600}>Invoice #345</Text>}
-        size="lg"
+        opened={Boolean(invoiceConfirm)}
+        onClose={() => setInvoiceConfirm(null)}
+        title={<Text fw={600}>Generate Invoice</Text>}
         radius="lg"
         centered
       >
-        <Stack gap="md">
-          {invoiceRecord && (
-            <>
-              <Card withBorder padding="md" radius="md" bg="var(--mantine-color-gray-0)">
-                <Stack gap="sm">
-                  <Group justify="space-between">
-                    <Text fw={700}>EDR Freight</Text>
-                    <Text fw={600} size="sm">Invoice #345</Text>
-                  </Group>
-                  <Divider />
-                  <SimpleGrid cols={2} spacing="sm">
-                    <InfoRow label="Booking" value={bookingRef(invoiceRecord)} />
-                    <InfoRow label="Customer" value={customerName(invoiceRecord)} />
-                    <InfoRow label="Pickup" value={originYardName(invoiceRecord)} />
-                    <InfoRow label="Destination" value={deliveryLocation(invoiceRecord)} />
-                    <InfoRow label="Est. Distance" value={invoiceRecord.estimatedKm ? `${invoiceRecord.estimatedKm} km` : "—"} />
-                    <InfoRow label="Actual Distance" value={invoiceRecord.exactKm ? `${invoiceRecord.exactKm} km` : "—"} />
-                    <InfoRow label="Advanced Payment" value={formatPrice(invoiceRecord.advancedPayment)} />
-                    <InfoRow label="Post Payment" value={formatPrice(invoiceRecord.remainingPayment)} />
-                  </SimpleGrid>
-                  <Divider />
-                  <Group justify="flex-end">
-                    <Stack gap={0} align="flex-end" style={{ minWidth: 200 }}>
-                      <Group justify="space-between" w="100%">
-                        <Text size="sm" c="dimmed">Post Payment</Text>
-                        <Text size="sm">{formatPrice(invoiceRecord.remainingPayment)}</Text>
-                      </Group>
-                      <Group justify="space-between" w="100%">
-                        <Text size="sm" c="dimmed">Advanced Payment</Text>
-                        <Text size="sm">{formatPrice(invoiceRecord.advancedPayment)}</Text>
-                      </Group>
-                      <Divider my="xs" />
-                      {(() => {
-                        const postPayment = parseFloat(String(invoiceRecord.remainingPayment));
-                        const advancedPayment = parseFloat(String(invoiceRecord.advancedPayment));
-                        const difference = postPayment - advancedPayment;
-
-                        if (difference > 0) {
-                          return (
-                            <Group justify="space-between" w="100%">
-                              <Text size="sm" fw={600}>Remaining to Pay</Text>
-                              <Text fw={700} c="orange">{formatPrice(difference)}</Text>
-                            </Group>
-                          );
-                        } else if (difference < 0) {
-                          return (
-                            <Group justify="space-between" w="100%">
-                              <Text size="sm" fw={600}>Refund</Text>
-                              <Text fw={700} c="green">{formatPrice(Math.abs(difference))}</Text>
-                            </Group>
-                          );
-                        } else {
-                          return (
-                            <Group justify="space-between" w="100%">
-                              <Text size="sm" fw={600}>Status</Text>
-                              <Text fw={700} c="blue">Settled</Text>
-                            </Group>
-                          );
-                        }
-                      })()}
-                    </Stack>
-                  </Group>
-                </Stack>
-              </Card>
-            </>
-          )}
-          <Group justify="flex-end" gap="sm">
-            <Button variant="default" onClick={closeInvoice}>Close</Button>
-          </Group>
-        </Stack>
-      </Modal>
-
-      {/* Container Allocation modal */}
-      <Modal
-        opened={allocationOpen}
-        onClose={closeAllocation}
-        title={<Text fw={600}>Allocate Containers to Vehicles</Text>}
-        size="xl"
-        radius="lg"
-        centered
-      >
-        <Stack gap="md">
-          {activeRecord && (
-            <>
-              <Card withBorder padding="md" radius="md" bg="var(--mantine-color-gray-0)">
-                <Stack gap="sm">
-                  <Group justify="space-between">
-                    <Stack gap={0}>
-                      <Text fw={600} size="sm">{bookingRef(activeRecord)}</Text>
-                      <Text size="xs" c="dimmed">{customerName(activeRecord)}</Text>
-                    </Stack>
-                    <Stack gap={0} align="flex-end">
-                      <Text size="xs" c="dimmed" tt="uppercase">Cargo Type</Text>
-                      <Text size="sm" fw={600}>{activeRecord.booking?.cargoType?.label ?? activeRecord.booking?.cargoType?.name ?? "—"}</Text>
-                    </Stack>
-                  </Group>
-                </Stack>
-              </Card>
-
-              {/* Capacity logic based on cargo type */}
-              {activeRecord.booking?.cargoType?.name === "BULK" ? (
-                <Card withBorder padding="md" radius="md" bg="var(--mantine-color-blue-0)" style={{ borderColor: "var(--mantine-color-blue-3)" }}>
-                  <Stack gap="sm">
-                    <Group gap="xs">
-                      <Text fw={600} size="sm">Smart Capacity Allocation</Text>
+        {invoiceConfirm && (
+          <Stack gap="md">
+            <Group justify="space-between">
+              <Text fw={600} size="sm">{bookingRef(invoiceConfirm)}</Text>
+              <Text size="sm" c="dimmed">{customerName(invoiceConfirm)}</Text>
+            </Group>
+            <Card withBorder padding="sm" radius="md" bg="var(--mantine-color-gray-0)">
+              <Stack gap={6}>
+                {(invoiceConfirm.vehicleAssignments ?? []).map((a) => {
+                  const v = a.vehicle;
+                  const label = v ? [v.code, v.plateNumber].filter(Boolean).join(" · ") : a.vehicleId;
+                  return (
+                    <Group key={a.id} justify="space-between" wrap="nowrap">
+                      <Text size="sm">
+                        {label}
+                        {a.containerNumber ? ` · ${a.containerNumber}` : ""}
+                      </Text>
+                      <Text size="sm">{a.distanceKm != null ? `${a.distanceKm} km` : "—"}</Text>
                     </Group>
-                    <Stack gap={2}>
-                      <Text size="sm">Capacity: TBD</Text>
-                      <Text size="xs" c="dimmed">
-                        TODO: add vehicle capacity_tons to vehicle API if missing
-                      </Text>
-                      <Text size="xs" c="dimmed">
-                        TODO: add container weight to booking if missing
-                      </Text>
-                    </Stack>
-                    <Text size="sm" fw={500} mt="xs">
-                      Select multiple containers per vehicle based on capacity
-                    </Text>
-                  </Stack>
-                </Card>
-              ) : (
-                <Card withBorder padding="md" radius="md" bg="var(--mantine-color-gray-0)">
-                  <Text size="sm" fw={500}>One vehicle per container</Text>
-                </Card>
-              )}
-            </>
-          )}
-
-          <LastMileContainerAllocationTable
-            lastMileId={activeId ?? ""}
-            containers={allocationContainers}
-            onSave={async (mappings) => {
-              await allocateMutation.mutateAsync(mappings);
-            }}
-          />
-
-          <Group justify="flex-end" gap="sm">
-            <Button variant="default" onClick={closeAllocation}>Close</Button>
-          </Group>
-        </Stack>
+                  );
+                })}
+              </Stack>
+            </Card>
+            <Group justify="space-between">
+              <Text size="sm" c="dimmed">Total distance</Text>
+              <Text size="sm" fw={500}>{invoiceConfirm.exactKm ?? 0} km</Text>
+            </Group>
+            <Group justify="space-between">
+              <Text fw={600}>Invoice amount</Text>
+              <Text fw={700}>{formatPrice(invoiceConfirm.remainingPayment, currencyOf(invoiceConfirm))}</Text>
+            </Group>
+            <Text size="xs" c="dimmed">
+              This creates the delivery-fee invoice. Confirm the distances and amount are correct.
+            </Text>
+            <Group justify="flex-end" gap="sm">
+              <Button variant="default" onClick={() => setInvoiceConfirm(null)}>Cancel</Button>
+              <Button
+                loading={generateInvoiceMutation.isPending}
+                onClick={() =>
+                  generateInvoiceMutation.mutate(invoiceConfirm.id, {
+                    onSuccess: () => setInvoiceConfirm(null),
+                  })
+                }
+              >
+                Generate Invoice
+              </Button>
+            </Group>
+          </Stack>
+        )}
       </Modal>
 
       <ReleaseOrderModal
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 2568c76f7..421885310 100644
--- a/apps/edr-freight-web/backoffice/src/pages/ruleEngine/CargoTypesPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/ruleEngine/CargoTypesPage.tsx
@@ -19,7 +19,6 @@ import {
 import {
   Boxes,
   ChevronRight,
-  FileText,
   Home,
   Layers,
   Package,
@@ -41,6 +40,7 @@ import {
 import {
   useRuleEngineList,
   useRuleEngineMutations,
+  useWagonTypeOptions,
 } from "@/hooks/rule-engine/useRuleEngine";
 import type { RuleEngineRecord } from "@/types/rule-engine";
 
@@ -54,6 +54,8 @@ interface CargoNode extends RuleEngineRecord {
   requiresDirectorApproval?: boolean;
   /** How this cargo is measured (PER_TON / PER_ITEM); null for groups/unset. */
   unitOfMeasure?: string | null;
+  /** Wagon type FK used to carry this bulk cargo during scheduling; null if unset. */
+  wagonTypeId?: string | null;
   isActive?: boolean;
   displayOrder?: number;
 }
@@ -79,6 +81,18 @@ const FORM_FIELDS: FormFieldDef[] = [
       { label: "Per item (break-bulk)", value: "PER_ITEM" },
     ],
   },
+  {
+    // Wagon type that carries this (bulk) commodity — drives train-scheduling
+    // wagon resolution. Optional: leave "None" for grouping categories and
+    // container/legacy cargo; set it on scheduled bulk commodities.
+    // Options injected at render from useWagonTypeOptions.
+    name: "wagonTypeId",
+    label: "Wagon type",
+    type: "select",
+    optional: true,
+    placeholder: "Select wagon type (bulk cargo)",
+    options: [{ label: "None", value: RULE_ENGINE_SELECT_NONE }],
+  },
   { name: "requiresDirectorApproval", label: "Requires director approval", type: "boolean" },
   { name: "isActive", label: "Active", type: "boolean" },
 ];
@@ -105,6 +119,24 @@ const CargoTypesPage = () => {
 
   const { create, update, remove } = useRuleEngineMutations(CARGO_SLUG);
 
+  // Wagon-type options for the "Wagon type" picker (bulk cargo → wagon FK).
+  const { data: wagonTypeOptions } = useWagonTypeOptions(canManage);
+  const formFields = useMemo<FormFieldDef[]>(
+    () =>
+      FORM_FIELDS.map((field) =>
+        field.name === "wagonTypeId"
+          ? {
+              ...field,
+              options: [
+                { label: "None", value: RULE_ENGINE_SELECT_NONE },
+                ...(wagonTypeOptions ?? []),
+              ],
+            }
+          : field,
+      ),
+    [wagonTypeOptions],
+  );
+
   const [search, setSearch] = useState("");
   const [formMode, setFormMode] = useState<FormMode | null>(null);
   const [deleteTarget, setDeleteTarget] = useState<CargoNode | null>(null);
@@ -350,7 +382,7 @@ const CargoTypesPage = () => {
               ? "Create a top-level cargo category."
               : "Create a cargo type inside this category. It's attached here automatically."
         }
-        fields={FORM_FIELDS}
+        fields={formFields}
         initialRecord={formMode?.kind === "edit" ? formMode.record : null}
         isSubmitting={create.isPending || update.isPending}
         onSubmit={handleSubmit}
diff --git a/apps/edr-freight-web/backoffice/src/pages/ruleEngine/RuleEngineResourcePage.tsx b/apps/edr-freight-web/backoffice/src/pages/ruleEngine/RuleEngineResourcePage.tsx
index 99260946f..253cdffcc 100644
--- a/apps/edr-freight-web/backoffice/src/pages/ruleEngine/RuleEngineResourcePage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/ruleEngine/RuleEngineResourcePage.tsx
@@ -33,6 +33,7 @@ import {
     useCargoTypeParentOptions,
     useContainerTypeOptions,
     useLiveRateOptions,
+    useWagonTypeOptions,
     useRateWorkflow,
     useRuleEngineList,
     useRuleEngineMutations,
@@ -151,6 +152,9 @@ const RuleEngineResourcePage = () => {
   const usesLiveRateField = Boolean(
     config?.formFields.some((f) => f.name === "rateId"),
   );
+  const usesWagonTypeField = Boolean(
+    config?.formFields.some((f) => f.name === "wagonTypeId"),
+  );
 
   const { data: cargoParentOptions, isLoading: cargoParentOptionsLoading } =
     useCargoTypeParentOptions(editingId, config?.slug === "cargo-types");
@@ -160,6 +164,8 @@ const RuleEngineResourcePage = () => {
     useContainerTypeOptions(config?.slug === "rates", usesContainerTypeField);
   const { data: liveRateOptions, isLoading: liveRateOptionsLoading } =
     useLiveRateOptions(usesLiveRateField);
+  const { data: wagonTypeOptions, isLoading: wagonTypeOptionsLoading } =
+    useWagonTypeOptions(usesWagonTypeField);
 
   const formFields = useMemo(() => {
     if (!config) return [];
@@ -193,9 +199,16 @@ const RuleEngineResourcePage = () => {
           options: liveRateOptions ?? [],
         };
       }
+      if (field.name === "wagonTypeId") {
+        return {
+          ...field,
+          type: "select" as const,
+          options: wagonTypeOptions ?? [],
+        };
+      }
       return field;
     });
-  }, [config, cargoParentOptions, cargoLeafOptions, containerTypeOptions, liveRateOptions]);
+  }, [config, cargoParentOptions, cargoLeafOptions, containerTypeOptions, liveRateOptions, wagonTypeOptions]);
 
   const rows = data?.data ?? [];
   const meta = data?.meta;
@@ -341,6 +354,10 @@ const RuleEngineResourcePage = () => {
     } else if (config.slug === "priority-configs") {
       // Label is required by the backend but hidden in the UI for now.
       payload = { ...values, label: String(Date.now()) };
+    } else if (config.slug === "weight-limit-rules") {
+      // Empty max capacity means "no ceiling" — send null explicitly so an
+      // edit can clear a previously-set ceiling (omitting the key keeps it).
+      payload = { ...values, maxCapacityTons: values.maxCapacityTons ?? null };
     }
 
     if (editing?.id) {
@@ -498,7 +515,8 @@ const RuleEngineResourcePage = () => {
           (config.slug === "cargo-types" && cargoParentOptionsLoading) ||
           (usesContainerTypeField && containerTypeOptionsLoading) ||
           (usesCargoTypeField && cargoLeafOptionsLoading) ||
-          (usesLiveRateField && liveRateOptionsLoading)
+          (usesLiveRateField && liveRateOptionsLoading) ||
+          (usesWagonTypeField && wagonTypeOptionsLoading)
         }
         positionOptions={!editing ? createPositionOptions : undefined}
         positionLoading={createPositionLoading}
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 8016dfcc9..2014f9c65 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
@@ -47,6 +47,14 @@ export interface FormFieldDef {
    * showWhen and not match hideWhen.
    */
   showWhen?: { field: string; equals: string[] };
+  /**
+   * Select options computed from other fields' current values. When set, the
+   * form resolves the option list at render time from the live form state
+   * instead of the static `options` list. Used for the rate unit selector,
+   * whose valid choices depend on `appliesTo` + `trigger`. (Named distinctly
+   * from the fleet config's string-based `dynamicOptions` to avoid a clash.)
+   */
+  optionsFromValues?: (values: Record<string, unknown>) => { label: string; value: string }[];
 }
 
 export interface RuleEngineOrderConfig {
@@ -116,12 +124,54 @@ const RATE_TRIGGERS = [
   { label: "Shipping line extra fee (PIL)", value: "PIL_EXTRA_FEE" },
 ];
 
-const RATE_UNITS =["PER_WAGON", "PER_TON", "PER_CONTAINER", "PER_KM", "PER_INVOICE", "FLAT"].map(
-  (v) => ({
-    label: v.replace(/_/g, " "),
-    value: v,
-  }),
-);
+const unitOption = (value: string) => ({ label: value.replace(/_/g, " "), value });
+
+/**
+ * Valid weighting units for a rate shape — mirrors the API's
+ * `allowedRateUnits`. The unit is driven by the *type* being billed: containers
+ * bill per container, bulk per ton, overweight always per excess ton, etc. Kept
+ * in sync with apps/edr-freight-api/.../entities/rate-unit.util.ts.
+ */
+const allowedRateUnits = (appliesTo: string, trigger: string): string[] => {
+  if (appliesTo === "OTHER") {
+    switch (trigger) {
+      case "OVERWEIGHT":
+        return ["PER_TON"];
+      case "REEFER":
+      case "HAZARDOUS":
+      case "DEMURRAGE":
+        return ["PER_CONTAINER", "PER_TON"];
+      case "CANCELLATION":
+        return ["FLAT", "PER_INVOICE"];
+      case "CONSOLIDATION":
+      case "SHIPPING_LINE":
+      case "PIL_EXTRA_FEE":
+        return ["PER_CONTAINER", "FLAT"];
+      default:
+        return ["FLAT", "PER_TON", "PER_CONTAINER"];
+    }
+  }
+  switch (appliesTo) {
+    case "CONTAINER":
+      return ["PER_CONTAINER", "PER_WAGON"];
+    case "BULK":
+      return ["PER_TON", "PER_WAGON"];
+    case "INTERCITY":
+      return ["PER_CONTAINER", "PER_TON", "PER_WAGON", "PER_KM"];
+    case "FIRST_MILE":
+    case "LAST_MILE":
+      return ["PER_CONTAINER", "PER_TON", "PER_KM", "FLAT"];
+    default:
+      return ["FLAT"];
+  }
+};
+
+const rateUnitOptions = (values: Record<string, unknown>) => {
+  const appliesTo = String(values.appliesTo ?? "");
+  const trigger = appliesTo === "OTHER" ? String(values.trigger ?? "") : "ALWAYS";
+  if (!appliesTo) return [];
+  return allowedRateUnits(appliesTo, trigger).map(unitOption);
+};
 
 const CURRENCIES = [
   { label: "USD", value: "USD" },
@@ -198,6 +248,14 @@ export const RULE_ENGINE_RESOURCES: RuleEngineResourceConfig[] = [
     formFields: [
       { name: "label", label: "Label", type: "text", required: true },
       { name: "sizeFt", label: "Size (ft)", type: "number", required: true },
+      // Options injected at render from useWagonTypeOptions (RuleEngineResourcePage).
+      {
+        name: "wagonTypeId",
+        label: "Wagon type",
+        type: "select",
+        required: true,
+        description: "Wagon type used to carry this container during train scheduling.",
+      },
       { name: "isOpenTop", label: "Open top", type: "boolean" },
       { name: "isActive", label: "Active", type: "boolean" },
     ],
@@ -324,8 +382,12 @@ export const RULE_ENGINE_RESOURCES: RuleEngineResourceConfig[] = [
       },
       { id: "tradeDirection", header: "Direction", accessorKey: "tradeDirection" },
       { id: "maxVgmTons", header: "Max VGM (t)", accessorKey: "maxVgmTons", format: "number" },
-      { id: "effectiveFrom", header: "From", accessorKey: "effectiveFrom", format: "date" },
-      { id: "effectiveTo", header: "To", accessorKey: "effectiveTo", format: "date" },
+      {
+        id: "maxCapacityTons",
+        header: "Max capacity (t)",
+        accessorKey: "maxCapacityTons",
+        format: "number",
+      },
     ],
     formFields: [
       {
@@ -343,8 +405,14 @@ export const RULE_ENGINE_RESOURCES: RuleEngineResourceConfig[] = [
         options: TRADE_DIRECTIONS,
       },
       { name: "maxVgmTons", label: "Max VGM (tons)", type: "number", required: true },
-      { name: "effectiveFrom", label: "Effective from", type: "date", required: true },
-      { name: "effectiveTo", label: "Effective to", type: "date" },
+      {
+        name: "maxCapacityTons",
+        label: "Max capacity (tons)",
+        type: "number",
+        optional: true,
+        description:
+          "Hard ceiling — a booking whose line weight exceeds this cannot be created at all. Leave empty for no ceiling (overweight surcharge only).",
+      },
     ],
   },
   {
@@ -407,7 +475,6 @@ export const RULE_ENGINE_RESOURCES: RuleEngineResourceConfig[] = [
       { id: "rateValue", header: "Value", accessorKey: "rateValue", format: "currency" },
       { id: "rateUnit", header: "Unit", accessorKey: "rateUnit" },
       { id: "status", header: "Status", accessorKey: "status", format: "rateStatus" },
-      { id: "effectiveFrom", header: "From", accessorKey: "effectiveFrom", format: "date" },
     ],
     formFields: [
       {
@@ -457,9 +524,18 @@ export const RULE_ENGINE_RESOURCES: RuleEngineResourceConfig[] = [
         showWhen: { field: "appliesTo", equals: ["BULK", "INTERCITY"] },
       },
       { name: "rateValue", label: "Rate value", type: "number", required: true, suffix: "USD" },
-      { name: "rateUnit", label: "Rate unit", type: "select", required: true, options: RATE_UNITS },
-      { name: "effectiveFrom", label: "Effective from", type: "date", required: true },
-      { name: "effectiveTo", label: "Effective to", type: "date" },
+      // Unit choices are driven by the rate shape (appliesTo + trigger). Overweight
+      // is always per excess ton, so the unit field is hidden for it — the API
+      // forces PER_TON regardless.
+      {
+        name: "rateUnit",
+        label: "Rate unit",
+        type: "select",
+        required: true,
+        optionsFromValues: rateUnitOptions,
+        description: "Weighting basis — options depend on what the rate applies to.",
+        hideWhen: { field: "trigger", equals: ["OVERWEIGHT"] },
+      },
     ],
   },
   {
diff --git a/apps/edr-freight-web/backoffice/src/pages/trainScheduling/BatchScheduleDetailPage.tsx b/apps/edr-freight-web/backoffice/src/pages/trainScheduling/BatchScheduleDetailPage.tsx
index a4ebd531e..de6ecfa9b 100644
--- a/apps/edr-freight-web/backoffice/src/pages/trainScheduling/BatchScheduleDetailPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/trainScheduling/BatchScheduleDetailPage.tsx
@@ -1,8 +1,7 @@
-import { useEffect, useMemo, useState } from "react";
+import { useMemo, useState } from "react";
 import { useNavigate, useParams } from "react-router-dom";
 import {
   Accordion,
-  ActionIcon,
   Alert,
   Badge,
   Box,
@@ -24,9 +23,7 @@ import {
   Boxes,
   CalendarDays,
   CheckCircle2,
-  ChevronLeft,
   ClipboardCheck,
-  ChevronRight,
   Clock,
   FileSignature,
   Hourglass,
@@ -40,7 +37,7 @@ import {
   XCircle,
 } from "lucide-react";
 
-import { DataTable, type ColumnDef } from "@edr/ui-common";
+import { CountdownTimer, DataTable, type ColumnDef } from "@edr/ui-common";
 
 import { KpiStrip, PageContainer } from "@/components/page";
 import { ruleEngineTable } from "@/components/ruleEngine/ruleEngineStyles";
@@ -431,101 +428,148 @@ function WindowCountChips({ counts }: { counts: BatchWindowGroup["counts"] }) {
 }
 
 /** "05 Jun 2026 · 06:00 – 09:00 EAT" → "06:00 – 09:00 EAT" (date lives in the day header). */
-function timeLabelOf(label: string): string {
-  const idx = label.indexOf("·");
-  return idx >= 0 ? label.slice(idx + 1).trim() : label;
-}
-
 const EAT_TZ = "Africa/Addis_Ababa";
-const dateKeyFmt = new Intl.DateTimeFormat("en-CA", {
-  timeZone: EAT_TZ,
-  year: "numeric",
-  month: "2-digit",
-  day: "2-digit",
-});
 const dateLabelFmt = new Intl.DateTimeFormat("en-GB", {
   timeZone: EAT_TZ,
   weekday: "short",
   day: "2-digit",
   month: "short",
 });
+const timeFmt = new Intl.DateTimeFormat("en-GB", {
+  timeZone: EAT_TZ,
+  hour: "2-digit",
+  minute: "2-digit",
+  hour12: false,
+});
 
-/** EAT calendar date key for a window — prefers the API field, falls back to `start`. */
-function windowDateKey(w: BatchWindowGroup): string {
-  if (w.date) return w.date;
-  if (w.start) return dateKeyFmt.format(new Date(w.start));
-  return "undated";
+interface ScheduleWindow {
+  windowPhase: BatchBoardScheduleDetail["windowPhase"];
+  bookingWindowStatus: string;
+  windowOpensAt: string | null;
+  windowClosesAt: string | null;
+  docReviewEndsAt: string | null;
+  paymentPhaseEndsAt: string | null;
+  bookingCycleNo?: number;
 }
 
-/** Human day label for a window — prefers the API field, falls back to `start`. */
-function windowDateLabel(w: BatchWindowGroup): string {
-  if (w.dateLabel) return w.dateLabel;
-  if (w.start) return dateLabelFmt.format(new Date(w.start));
-  return "Undated";
+/**
+ * Deadline + label for the phase the schedule's booking window is currently in —
+ * the SAME phases the customer sees on the portal: pre-window (opens) → open
+ * (closes) → document review → payment. `expiredText` names the next step so a
+ * lapsed deadline reads as a handover, not a bare "Expired".
+ */
+function windowPhaseCountdown(
+  w: ScheduleWindow,
+): { label: string; deadline: string; expiredText: string } | null {
+  switch (w.windowPhase) {
+    case "PRE_WINDOW":
+      return w.windowOpensAt
+        ? { label: "Booking opens in", deadline: w.windowOpensAt, expiredText: "Booking opening now…" }
+        : null;
+    case "OPEN":
+      return w.windowClosesAt
+        ? { label: "Window closes in", deadline: w.windowClosesAt, expiredText: "Document review starting…" }
+        : null;
+    case "DOC_REVIEW":
+      return w.docReviewEndsAt
+        ? { label: "Document review ends in", deadline: w.docReviewEndsAt, expiredText: "Payment starting…" }
+        : null;
+    case "PAYMENT":
+      return w.paymentPhaseEndsAt
+        ? { label: "Payment window ends in", deadline: w.paymentPhaseEndsAt, expiredText: "Payment window closing…" }
+        : null;
+    default:
+      return null;
+  }
 }
 
-function WindowAccordionItem({ window }: { window: BatchWindowGroup }) {
-  const total = window.bookings.length;
-  const hasIssues = window.bookings.some(
-    (b) => b.allocationStatus === "FAILED" || b.allocationStatus === "DEFERRED",
+/** One phase row: label + its clock time (or "—" when unset). */
+function PhaseTimeRow({
+  label,
+  iso,
+  active,
+}: {
+  label: string;
+  iso: string | null;
+  active: boolean;
+}) {
+  return (
+    <Group justify="space-between" gap="sm" wrap="nowrap">
+      <Text size="sm" fw={active ? 700 : 500} c={active ? "edr-green.7" : "dimmed"}>
+        {label}
+      </Text>
+      <Text size="sm" fw={active ? 700 : 500} c={active ? "dark" : "dimmed"}>
+        {iso ? `${timeFmt.format(new Date(iso))} EAT` : "—"}
+      </Text>
+    </Group>
   );
+}
+
+/**
+ * The schedule's REAL booking window — the exact same window the customer sees on
+ * the portal (frozen open/close from the schedule's own snapshot + the post-close
+ * document-review and payment phases), with a live countdown to the current phase.
+ * Replaces the old theoretical "3-hour windows across every day" projection.
+ */
+function ScheduleWindowPanel({ window: w }: { window: ScheduleWindow }) {
+  const phase = w.windowPhase;
+  const cd = windowPhaseCountdown(w);
+  const open = phase === "OPEN" && w.bookingWindowStatus === "OPEN";
+
+  const openDay = w.windowOpensAt
+    ? dateLabelFmt.format(new Date(w.windowOpensAt))
+    : null;
 
   return (
-    <Accordion.Item value={window.key}>
-      <Accordion.Control>
-        <Group justify="space-between" wrap="nowrap" pr="md" gap="sm">
-          <Group gap="sm" wrap="nowrap" style={{ minWidth: 0 }}>
-            <Box
-              style={{
-                display: "flex",
-                alignItems: "center",
-                justifyContent: "center",
-                width: 34,
-                height: 34,
-                borderRadius: 10,
-                flexShrink: 0,
-                background: total ? "#FEF1D5" : "var(--mantine-color-gray-0)",
-                border: total
-                  ? "1px solid #FBD171"
-                  : "1px solid var(--mantine-color-gray-2)",
-                color: total ? "#B26C09" : "var(--mantine-color-gray-5)",
-              }}
-            >
-              <Clock size={16} />
-            </Box>
-            <Box style={{ minWidth: 0 }}>
-              <Text fw={700} size="sm" truncate>
-                {timeLabelOf(window.label)}
-              </Text>
-              <Text size="xs" c="dimmed">
-                {total
-                  ? `${total} booking${total === 1 ? "" : "s"}`
-                  : "Empty window"}
-              </Text>
-            </Box>
-          </Group>
-          <Group gap={6} wrap="nowrap">
-            {hasIssues ? (
-              <Badge
-                variant="light"
-                color="red"
-                size="sm"
-                leftSection={<AlertTriangle size={10} />}
-              >
-                Issues
-              </Badge>
-            ) : null}
-            <WindowCountChips counts={window.counts} />
-          </Group>
+    <Paper
+      withBorder
+      radius="lg"
+      p="md"
+      mt="md"
+      style={{
+        borderColor: open
+          ? "var(--mantine-color-edr-green-2)"
+          : "var(--mantine-color-gray-2)",
+        background: open ? "var(--mantine-color-edr-green-0)" : undefined,
+      }}
+    >
+      <Group justify="space-between" wrap="nowrap" mb="sm">
+        <Group gap="sm" wrap="nowrap">
+          {phase ? (
+            <WindowPhasePill phase={phase} cycleNo={w.bookingCycleNo} />
+          ) : null}
+          <WindowStatusPill status={w.bookingWindowStatus} />
         </Group>
-      </Accordion.Control>
-      <Accordion.Panel>
-        <BookingTable bookings={window.bookings} />
-      </Accordion.Panel>
-    </Accordion.Item>
+        {openDay ? (
+          <Text size="xs" c="dimmed">
+            Booking day · {openDay}
+          </Text>
+        ) : null}
+      </Group>
+
+      {cd ? (
+        <Box mb="sm">
+          <CountdownTimer
+            deadline={cd.deadline}
+            label={cd.label}
+            expiredText={cd.expiredText}
+            size="md"
+          />
+        </Box>
+      ) : null}
+
+      <Stack gap={6}>
+        <PhaseTimeRow label="Window opens" iso={w.windowOpensAt} active={phase === "PRE_WINDOW"} />
+        <PhaseTimeRow label="Window closes" iso={w.windowClosesAt} active={phase === "OPEN"} />
+        <PhaseTimeRow label="Document review ends" iso={w.docReviewEndsAt} active={phase === "DOC_REVIEW"} />
+        <PhaseTimeRow label="Payment window ends" iso={w.paymentPhaseEndsAt} active={phase === "PAYMENT"} />
+      </Stack>
+    </Paper>
   );
 }
 
+/** EAT calendar date key for a window — prefers the API field, falls back to `start`. */
+
 export default function BatchScheduleDetailPage() {
   const { scheduleId } = useParams<{ scheduleId: string }>();
   const navigate = useNavigate();
@@ -577,6 +621,34 @@ export default function BatchScheduleDetailPage() {
     return [...byId.values()];
   }, [data]);
 
+  // All bookings that fall inside the schedule's booking window (every window
+  // cycle, flattened) — the window is one booking day, so these belong to the
+  // single window panel above.
+  const windowBookings = useMemo(
+    () => (data?.windows ?? []).flatMap((w) => w.bookings),
+    [data?.windows],
+  );
+
+  const windowCounts = useMemo(() => {
+    const counts = {
+      allocated: 0,
+      selectedForBatch: 0,
+      ready: 0,
+      waiting: 0,
+      expired: 0,
+      pendingContract: 0,
+    };
+    for (const b of windowBookings) {
+      if (b.state === "ALLOCATED") counts.allocated += 1;
+      else if (b.state === "SELECTED_FOR_BATCH") counts.selectedForBatch += 1;
+      else if (b.state === "READY") counts.ready += 1;
+      else if (b.state === "WAITING") counts.waiting += 1;
+      else if (b.state === "EXPIRED") counts.expired += 1;
+      else counts.pendingContract += 1;
+    }
+    return counts;
+  }, [windowBookings]);
+
   // Batch bookings by state for the composition side panel (payment / expired lists).
   const batchBookings = useMemo(() => {
     const all = allBookings;
@@ -591,102 +663,10 @@ export default function BatchScheduleDetailPage() {
     [data?.status],
   );
 
-  // Group the flat window list into per-day sections (one per EAT calendar date).
-  const dayGroups = useMemo(() => {
-    if (!data) return [];
-    const byDate = new Map<
-      string,
-      {
-        date: string;
-        dateLabel: string;
-        windows: BatchWindowGroup[];
-        totalBookings: number;
-        counts: BatchWindowGroup["counts"];
-        hasIssues: boolean;
-      }
-    >();
-    for (const w of data.windows) {
-      const dateKey = windowDateKey(w);
-      let group = byDate.get(dateKey);
-      if (!group) {
-        group = {
-          date: dateKey,
-          dateLabel: windowDateLabel(w),
-          windows: [],
-          totalBookings: 0,
-          counts: {
-            allocated: 0,
-            selectedForBatch: 0,
-            ready: 0,
-            waiting: 0,
-            expired: 0,
-            pendingContract: 0,
-          },
-          hasIssues: false,
-        };
-        byDate.set(dateKey, group);
-      }
-      group.windows.push(w);
-      group.totalBookings += w.bookings.length;
-      group.counts.allocated += w.counts.allocated;
-      group.counts.selectedForBatch += w.counts.selectedForBatch;
-      group.counts.ready += w.counts.ready;
-      group.counts.waiting += w.counts.waiting;
-      group.counts.expired += w.counts.expired;
-      group.counts.pendingContract += w.counts.pendingContract;
-      group.hasIssues =
-        group.hasIssues ||
-        w.bookings.some(
-          (b) =>
-            b.allocationStatus === "FAILED" ||
-            b.allocationStatus === "DEFERRED",
-        );
-    }
-    return [...byDate.values()];
-  }, [data]);
-
-  // Windows with bookings open by default (inside an expanded day).
-  const openWindowKeys = useMemo(
-    () =>
-      data
-        ? data.windows.filter((w) => w.bookings.length > 0).map((w) => w.key)
-        : [],
-    [data],
-  );
-
-  const todayEat = useMemo(
-    () =>
-      new Intl.DateTimeFormat("en-CA", {
-        timeZone: "Africa/Addis_Ababa",
-        year: "numeric",
-        month: "2-digit",
-        day: "2-digit",
-      }).format(new Date()),
-    [],
-  );
-
-  // Date-stepper: which day is currently shown. Default to today, else the first
-  // day with bookings, else the first day. Keep the selection if still valid.
-  const [selectedDate, setSelectedDate] = useState<string | null>(null);
   const [activeTab, setActiveTab] = useState<string | null>("overview");
   const [selectedBookingId, setSelectedBookingId] = useState<string | null>(
     null,
   );
-  useEffect(() => {
-    if (!dayGroups.length) return;
-    if (selectedDate && dayGroups.some((d) => d.date === selectedDate)) return;
-    const preferred =
-      dayGroups.find((d) => d.date === todayEat) ??
-      dayGroups.find((d) => d.totalBookings > 0) ??
-      dayGroups[0];
-    setSelectedDate(preferred.date);
-  }, [dayGroups, selectedDate, todayEat]);
-
-  const selectedIndex = Math.max(
-    0,
-    dayGroups.findIndex((d) => d.date === selectedDate),
-  );
-  const selectedDay = dayGroups[selectedIndex];
 
   const handleCompleteDocReview = () => {
     completeDocReview
@@ -1012,137 +992,30 @@ export default function BatchScheduleDetailPage() {
                   <Clock size={19} />
                 </ThemeIcon>
                 <Box>
-                  <Title order={4}>Batch windows (EAT)</Title>
+                  <Title order={4}>Booking window (EAT)</Title>
                   <Text size="sm" c="dimmed">
-                    3-hour windows for every day from when the booking window
-                    opened through the departure date. Bookings appear under the
-                    date their contract was signed — open a day to see its
-                    windows.
+                    The schedule's real booking window — the same window and
+                    phase timings the customer sees on the portal. Bookings in
+                    the window are listed below.
                   </Text>
                 </Box>
               </Group>
 
-              {dayGroups.length && selectedDay ? (
-                <>
-                  {/* Date stepper — page back/forward through each day in the range */}
-                  <Group
-                    justify="center"
-                    align="center"
-                    wrap="nowrap"
-                    gap="md"
-                    mt="md"
-                  >
-                    <ActionIcon
-                      variant="light"
-                      color="#F2A516"
-                      size="xl"
-                      radius="xl"
-                      aria-label="Previous day"
-                      disabled={selectedIndex <= 0}
-                      onClick={() =>
-                        setSelectedDate(
-                          dayGroups[selectedIndex - 1]?.date ?? null,
-                        )
-                      }
-                    >
-                      <ChevronLeft size={20} />
-                    </ActionIcon>
+              <ScheduleWindowPanel window={data} />
 
-                    <Paper
-                      withBorder
-                      radius="xl"
-                      px="xl"
-                      py="xs"
-                      style={{
-                        flex: 1,
-                        maxWidth: 360,
-                        textAlign: "center",
-                        background: selectedDay.totalBookings
-                          ? "#FEF1D5"
-                          : "white",
-                        borderColor: selectedDay.totalBookings
-                          ? "#FBD171"
-                          : "var(--mantine-color-gray-2)",
-                      }}
-                    >
-                      <Group justify="center" gap={8} wrap="nowrap">
-                        <CalendarDays size={15} color="#B26C09" />
-                        <Text
-                          fw={800}
-                          style={{
-                            color: selectedDay.totalBookings
-                              ? "#8A5304"
-                              : "#0f172a",
-                          }}
-                        >
-                          {selectedDay.dateLabel}
-                        </Text>
-                        {selectedDay.date === todayEat ? (
-                          <Badge size="xs" variant="light" color="#F2A516">
-                            Today
-                          </Badge>
-                        ) : null}
-                      </Group>
-                      <Text size="xs" c="dimmed" mt={2}>
-                        {selectedDay.totalBookings
-                          ? `${selectedDay.totalBookings} booking${selectedDay.totalBookings === 1 ? "" : "s"} · ${selectedDay.windows.length} windows`
-                          : `${selectedDay.windows.length} windows · no bookings`}
-                      </Text>
-                    </Paper>
-
-                    <ActionIcon
-                      variant="light"
-                      color="#F2A516"
-                      size="xl"
-                      radius="xl"
-                      aria-label="Next day"
-                      disabled={selectedIndex >= dayGroups.length - 1}
-                      onClick={() =>
-                        setSelectedDate(
-                          dayGroups[selectedIndex + 1]?.date ?? null,
-                        )
-                      }
-                    >
-                      <ChevronRight size={20} />
-                    </ActionIcon>
-                  </Group>
-
-                  <Group justify="space-between" align="center" mt="sm">
-                    <Text size="xs" c="dimmed">
-                      Day {selectedIndex + 1} of {dayGroups.length}
+              {windowBookings.length ? (
+                <Box mt="lg">
+                  <Group justify="space-between" align="center" mb="sm">
+                    <Text fw={700} size="sm">
+                      Bookings in this window
                     </Text>
-                    <Group gap={6} wrap="nowrap">
-                      {selectedDay.hasIssues ? (
-                        <Badge
-                          variant="light"
-                          color="red"
-                          size="sm"
-                          leftSection={<AlertTriangle size={10} />}
-                        >
-                          Issues
-                        </Badge>
-                      ) : null}
-                      <WindowCountChips counts={selectedDay.counts} />
-                    </Group>
+                    <WindowCountChips counts={windowCounts} />
                   </Group>
-
-                  <Accordion
-                    key={selectedDay.date}
-                    multiple
-                    defaultValue={openWindowKeys}
-                    variant="separated"
-                    radius="md"
-                    mt="md"
-                    className="bb-window-accordion"
-                  >
-                    {selectedDay.windows.map((window) => (
-                      <WindowAccordionItem key={window.key} window={window} />
-                    ))}
-                  </Accordion>
-                </>
+                  <BookingTable bookings={windowBookings} />
+                </Box>
               ) : (
                 <Text size="sm" c="dimmed" ta="center" py="lg">
-                  No batch windows for this schedule.
+                  No bookings in this window yet.
                 </Text>
               )}
 
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 9319e6a01..958049a63 100644
--- a/apps/edr-freight-web/backoffice/src/pages/trainScheduling/TrainScheduleV2DetailPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/trainScheduling/TrainScheduleV2DetailPage.tsx
@@ -8,6 +8,7 @@ import {
   Paper,
   RingProgress,
   Stack,
+  Tabs,
   Text,
   Textarea,
   TextInput,
@@ -25,10 +26,12 @@ import {
   LayoutGrid,
   Navigation,
   Package,
+  PackageCheck,
   Route as RouteIcon,
   Send,
   Train,
   Weight,
+  Workflow as WorkflowIcon,
 } from "lucide-react";
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { Link, useParams } from "react-router-dom";
@@ -42,9 +45,11 @@ import {
 } from "@/components/trainScheduling/containerPlacement.util";
 import { ContainerPlacementGrid } from "@/components/trainScheduling/ContainerPlacementGrid";
 import { FleetAvailabilitySummary } from "@/components/trainScheduling/FleetAvailabilitySummary";
+import { ImportLoadingConfirmationPanel } from "@/components/trainScheduling/ImportLoadingConfirmationPanel";
 import { RescheduleTrainDialog } from "@/components/trainScheduling/RescheduleTrainDialog";
 import { ScheduleBatchPanel } from "@/components/trainScheduling/ScheduleBatchPanel";
 import { ScheduleBookingsStep } from "@/components/trainScheduling/ScheduleBookingsStep";
+import { ScheduleWorkspacePanel } from "@/components/trainScheduling/ScheduleWorkspacePanel";
 import { FreightTypeBadge } from "@/components/trainScheduling/ScheduleStatusBadge";
 import {
   RouteCorridor,
@@ -141,6 +146,13 @@ export default function TrainScheduleV2DetailPage() {
     },
   });
 
+  const importLoadingQuery = useQuery(
+    api.trainScheduling.importLoadingBookings.queryOptions({
+      input: { id: scheduleId ?? "" },
+      enabled: Boolean(scheduleId && schedule?.direction === "IMPORT"),
+    }),
+  );
+
   const eligibleFilters = useMemo(
     () =>
       schedule
@@ -951,6 +963,23 @@ export default function TrainScheduleV2DetailPage() {
         ]}
       />
 
+      {schedule?.direction === "IMPORT" ? (
+        <Paper radius="xl" p="lg" withBorder>
+          <Stack gap="md">
+            <Text fw={600}>Import loading confirmation</Text>
+            <Text size="sm" c="dimmed">
+              Paid import bookings with a wagon allocated on this schedule. Marking loaded/unloaded
+              is tracking only — it does not block dispatch.
+            </Text>
+            <ImportLoadingConfirmationPanel
+              scheduleId={scheduleId as string}
+              items={importLoadingQuery.data?.items ?? []}
+              isLoading={importLoadingQuery.isLoading}
+            />
+          </Stack>
+        </Paper>
+      ) : null}
+
       {gatepassApplies ? (
         <Paper radius="xl" p="lg" withBorder>
           <Stack gap="md">
@@ -1028,6 +1057,18 @@ export default function TrainScheduleV2DetailPage() {
         </Paper>
       ) : null}
 
+      <Tabs defaultValue="workflow" radius="md" color="edr-green" keepMounted={false}>
+        <Tabs.List mb="md">
+          <Tabs.Tab value="workflow" leftSection={<WorkflowIcon size={16} />}>
+            Workflow
+          </Tabs.Tab>
+          <Tabs.Tab value="workspace" leftSection={<PackageCheck size={16} />}>
+            Workspace
+          </Tabs.Tab>
+        </Tabs.List>
+
+        <Tabs.Panel value="workflow">
+          <Stack gap="lg">
       <Paper radius="xl" p="lg">
         <Stack gap="lg">
           {/* Workflow header with ring progress */}
@@ -1085,7 +1126,20 @@ export default function TrainScheduleV2DetailPage() {
         </Stack>
       </Paper>
 
-      <ScheduleBatchPanel schedule={schedule} />
+            <ScheduleBatchPanel schedule={schedule} />
+          </Stack>
+        </Tabs.Panel>
+
+        <Tabs.Panel value="workspace">
+          <ScheduleWorkspacePanel
+            schedule={schedule}
+            onChanged={() => {
+              autoPreviewedRef.current = false;
+              void detailQuery.refetch();
+            }}
+          />
+        </Tabs.Panel>
+      </Tabs>
 
       {scheduleId ? (
         <RescheduleTrainDialog
diff --git a/apps/edr-freight-web/backoffice/src/pages/trainScheduling/TrainSchedulingGlobalRulesPage.tsx b/apps/edr-freight-web/backoffice/src/pages/trainScheduling/TrainSchedulingGlobalRulesPage.tsx
index 97e35de23..4cccd35b4 100644
--- a/apps/edr-freight-web/backoffice/src/pages/trainScheduling/TrainSchedulingGlobalRulesPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/trainScheduling/TrainSchedulingGlobalRulesPage.tsx
@@ -2,6 +2,7 @@ import { useEffect, useState } from "react";
 import { Button, Card, Group, NumberInput, Stack } from "@mantine/core";
 
 import { PageContainer, PageHeader } from "@/components/page";
+import DurationField from "@/components/trainScheduling/DurationField";
 import { trainSchedulingService } from "@/services/trainScheduling.service";
 import { useToast } from "@/hooks/use-toast";
 import type { TrainSchedulingGlobalRules } from "@/types/trainScheduling";
@@ -10,38 +11,75 @@ export default function TrainSchedulingGlobalRulesPage() {
   const { toast } = useToast();
   const [loading, setLoading] = useState(true);
   const [saving, setSaving] = useState(false);
-  const [form, setForm] = useState<Partial<TrainSchedulingGlobalRules>>({});
+  // Fields hold raw NumberInput values (number | string) while editing; coerced to Number on save.
+  const [form, setForm] = useState<
+    Partial<Record<keyof TrainSchedulingGlobalRules, number | string>>
+  >({});
 
   useEffect(() => {
     void (async () => {
       try {
         const rules = await trainSchedulingService.getGlobalRules();
-        setForm(rules);
+        // `numeric` columns come back from the API as strings (e.g. "250.00").
+        // Coerce every field to a real number so Mantine's controlled
+        // NumberInput edits cleanly (a string value fights the caret) and the
+        // default can be cleared and replaced.
+        const numeric: Partial<Record<keyof TrainSchedulingGlobalRules, number | string>> = {};
+        for (const [key, value] of Object.entries(rules)) {
+          if (key === "id") continue;
+          const num = value === "" || value == null ? "" : Number(value);
+          numeric[key as keyof TrainSchedulingGlobalRules] =
+            typeof num === "number" && Number.isNaN(num) ? "" : num;
+        }
+        setForm(numeric);
       } catch {
         toast({ title: "Failed to load train scheduling rules", variant: "destructive" });
       } finally {
         setLoading(false);
       }
     })();
-  }, [toast]);
+    // Run once on mount only. `toast` from useToast is a fresh function every
+    // render — listing it here re-fired the effect on every render, refetching
+    // the rules and overwriting whatever the user was typing (values snapped
+    // back to the saved defaults).
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
 
   const handleSave = async () => {
+    // Every field must hold a real number — an empty box (cleared but not
+    // refilled) must not silently save as 0. Collect the numeric payload and
+    // reject if any value is blank or NaN.
+    const fields: (keyof TrainSchedulingGlobalRules)[] = [
+      "maxTrainLengthMeters",
+      "maxTrainWeightTons",
+      "maxWagonsPerTrain",
+      "max20ftContainerWeightTons",
+      "max20ftPairWeightDiffTons",
+      "importWindowLeadDays",
+      "exportBookingLeadHours",
+      "windowOpenHour",
+      "windowDurationHours",
+      "docReviewMinutes",
+      "paymentWindowMinutes",
+      "reopenDelayMinutes",
+    ];
+    const payload: Partial<Record<keyof TrainSchedulingGlobalRules, number>> = {};
+    for (const key of fields) {
+      const raw = form[key];
+      const num = raw === "" || raw == null ? NaN : Number(raw);
+      if (!Number.isFinite(num)) {
+        toast({
+          title: "All fields are required — fill every value before saving.",
+          variant: "destructive",
+        });
+        return;
+      }
+      payload[key] = num;
+    }
+
     setSaving(true);
     try {
-      const updated = await trainSchedulingService.updateGlobalRules({
-        maxTrainLengthMeters: Number(form.maxTrainLengthMeters),
-        maxTrainWeightTons: Number(form.maxTrainWeightTons),
-        maxWagonsPerTrain: Number(form.maxWagonsPerTrain),
-        max20ftContainerWeightTons: Number(form.max20ftContainerWeightTons),
-        max20ftPairWeightDiffTons: Number(form.max20ftPairWeightDiffTons),
-        importWindowLeadDays: Number(form.importWindowLeadDays),
-        exportBookingLeadHours: Number(form.exportBookingLeadHours),
-        windowOpenHour: Number(form.windowOpenHour),
-        windowDurationHours: Number(form.windowDurationHours),
-        docReviewMinutes: Number(form.docReviewMinutes),
-        paymentWindowMinutes: Number(form.paymentWindowMinutes),
-        reopenDelayMinutes: Number(form.reopenDelayMinutes),
-      });
+      const updated = await trainSchedulingService.updateGlobalRules(payload);
       setForm(updated);
       toast({ title: "Train scheduling rules saved" });
     } catch {
@@ -65,8 +103,10 @@ export default function TrainSchedulingGlobalRulesPage() {
             description="Sum of all wagon lengths must not exceed this"
             value={form.maxTrainLengthMeters ?? ""}
             onChange={(value) =>
-              setForm((current) => ({ ...current, maxTrainLengthMeters: Number(value) }))
+              setForm((current) => ({ ...current, maxTrainLengthMeters: value }))
             }
+            clampBehavior="none"
+            allowDecimal
             min={1}
             disabled={loading}
           />
@@ -75,8 +115,10 @@ export default function TrainSchedulingGlobalRulesPage() {
             description="Total container and bulk cargo weight must not exceed this"
             value={form.maxTrainWeightTons ?? ""}
             onChange={(value) =>
-              setForm((current) => ({ ...current, maxTrainWeightTons: Number(value) }))
+              setForm((current) => ({ ...current, maxTrainWeightTons: value }))
             }
+            clampBehavior="none"
+            allowDecimal
             min={1}
             disabled={loading}
           />
@@ -84,8 +126,10 @@ export default function TrainSchedulingGlobalRulesPage() {
             label="Max wagons per train"
             value={form.maxWagonsPerTrain ?? ""}
             onChange={(value) =>
-              setForm((current) => ({ ...current, maxWagonsPerTrain: Number(value) }))
+              setForm((current) => ({ ...current, maxWagonsPerTrain: value }))
             }
+            clampBehavior="none"
+            allowDecimal
             min={1}
             disabled={loading}
           />
@@ -96,9 +140,11 @@ export default function TrainSchedulingGlobalRulesPage() {
             onChange={(value) =>
               setForm((current) => ({
                 ...current,
-                max20ftContainerWeightTons: Number(value),
+                max20ftContainerWeightTons: value,
               }))
             }
+            clampBehavior="none"
+            allowDecimal
             min={0.001}
             disabled={loading}
           />
@@ -109,9 +155,11 @@ export default function TrainSchedulingGlobalRulesPage() {
             onChange={(value) =>
               setForm((current) => ({
                 ...current,
-                max20ftPairWeightDiffTons: Number(value),
+                max20ftPairWeightDiffTons: value,
               }))
             }
+            clampBehavior="none"
+            allowDecimal
             min={0}
             disabled={loading}
           />
@@ -124,22 +172,24 @@ export default function TrainSchedulingGlobalRulesPage() {
             title="Booking windows"
             subtitle="Import booking-day cycle and export lead time. All times in Addis Ababa (EAT)."
           />
-          <NumberInput
-            label="Import window lead (days)"
-            description="The single booking day opens this many days before departure"
+          <DurationField
+            label="Import window lead"
+            description="The single booking day opens this long before departure"
             value={form.importWindowLeadDays ?? ""}
+            nativeUnit="days"
             onChange={(value) =>
-              setForm((current) => ({ ...current, importWindowLeadDays: Number(value) }))
+              setForm((current) => ({ ...current, importWindowLeadDays: value }))
             }
             min={0}
             disabled={loading}
           />
-          <NumberInput
-            label="Export booking lead (hours)"
-            description="Export bookings are accepted first-come-first-serve starting this many hours before departure"
+          <DurationField
+            label="Export booking lead"
+            description="Export bookings are accepted first-come-first-serve starting this long before departure"
             value={form.exportBookingLeadHours ?? ""}
+            nativeUnit="hours"
             onChange={(value) =>
-              setForm((current) => ({ ...current, exportBookingLeadHours: Number(value) }))
+              setForm((current) => ({ ...current, exportBookingLeadHours: value }))
             }
             min={1}
             disabled={loading}
@@ -149,49 +199,54 @@ export default function TrainSchedulingGlobalRulesPage() {
             description="Local hour the import window opens on its booking day (e.g. 8 = 08:00)"
             value={form.windowOpenHour ?? ""}
             onChange={(value) =>
-              setForm((current) => ({ ...current, windowOpenHour: Number(value) }))
+              setForm((current) => ({ ...current, windowOpenHour: value }))
             }
+            clampBehavior="none"
+            allowDecimal
             min={0}
             max={23}
             disabled={loading}
           />
-          <NumberInput
-            label="Window duration (hours)"
+          <DurationField
+            label="Window duration"
+            description="How long the import booking window stays open"
             value={form.windowDurationHours ?? ""}
+            nativeUnit="hours"
             onChange={(value) =>
-              setForm((current) => ({ ...current, windowDurationHours: Number(value) }))
-            }
-            min={0.25}
-            max={12}
-            step={0.25}
-            disabled={loading}
-          />
-          <NumberInput
-            label="Document review (minutes)"
-            description="Max staff time to accept booking documents after the window closes"
-            value={form.docReviewMinutes ?? ""}
-            onChange={(value) =>
-              setForm((current) => ({ ...current, docReviewMinutes: Number(value) }))
-            }
-            min={0}
-            disabled={loading}
-          />
-          <NumberInput
-            label="Payment window (minutes)"
-            description="Time a selected customer has to pay before the slot expires"
-            value={form.paymentWindowMinutes ?? ""}
-            onChange={(value) =>
-              setForm((current) => ({ ...current, paymentWindowMinutes: Number(value) }))
+              setForm((current) => ({ ...current, windowDurationHours: value }))
             }
             min={1}
             disabled={loading}
           />
-          <NumberInput
-            label="Reopen delay (minutes)"
-            description="Delay after window close before reopening when the train is not full (90 = 11:00 close → 12:30 reopen)"
-            value={form.reopenDelayMinutes ?? ""}
+          <DurationField
+            label="Document review"
+            description="Max staff time to accept booking documents after the window closes"
+            value={form.docReviewMinutes ?? ""}
+            nativeUnit="minutes"
             onChange={(value) =>
-              setForm((current) => ({ ...current, reopenDelayMinutes: Number(value) }))
+              setForm((current) => ({ ...current, docReviewMinutes: value }))
+            }
+            min={0}
+            disabled={loading}
+          />
+          <DurationField
+            label="Payment window"
+            description="Time a selected customer has to pay before the slot expires"
+            value={form.paymentWindowMinutes ?? ""}
+            nativeUnit="minutes"
+            onChange={(value) =>
+              setForm((current) => ({ ...current, paymentWindowMinutes: value }))
+            }
+            min={1}
+            disabled={loading}
+          />
+          <DurationField
+            label="Reopen delay"
+            description="Delay after window close before reopening when the train is not full (90 min = 11:00 close → 12:30 reopen)"
+            value={form.reopenDelayMinutes ?? ""}
+            nativeUnit="minutes"
+            onChange={(value) =>
+              setForm((current) => ({ ...current, reopenDelayMinutes: value }))
             }
             min={1}
             disabled={loading}
diff --git a/apps/edr-freight-web/backoffice/src/pages/warehouses/ExportDjiboutiUnloadingQueuePage.tsx b/apps/edr-freight-web/backoffice/src/pages/warehouses/ExportDjiboutiUnloadingQueuePage.tsx
index 31ee5ea36..609995e3e 100644
--- a/apps/edr-freight-web/backoffice/src/pages/warehouses/ExportDjiboutiUnloadingQueuePage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/warehouses/ExportDjiboutiUnloadingQueuePage.tsx
@@ -14,7 +14,17 @@ import {
   Text,
 } from '@mantine/core';
 import { useNavigate } from 'react-router-dom';
-import { ChevronDown, ChevronRight, Eye, FileText, History, PackageOpen, Truck } from 'lucide-react';
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import {
+  ChevronDown,
+  ChevronRight,
+  Eye,
+  FileText,
+  History,
+  PackageOpen,
+  ShieldCheck,
+  Truck,
+} from 'lucide-react';
 
 import { PageHeader } from '@/components/page';
 import Breadcrumbs from '@/components/ui/Breadcrumbs';
@@ -36,6 +46,7 @@ import {
   useInterchangeDocuments,
 } from '@/hooks/useInterchangeDocuments';
 import { useToast } from '@/hooks/use-toast';
+import { trainSchedulingService } from '@/services/trainScheduling.service';
 import type {
   AutoUnloadExportDjiboutiResult,
   ExportTrain,
@@ -179,6 +190,14 @@ export default function ExportDjiboutiUnloadingQueuePage() {
   const { data: interchangeDocuments = [] } = useInterchangeDocuments({ direction: 'EXPORT' });
   const autoUnload = useAutoUnloadExportAtDjibouti();
   const generateInterchange = useGenerateInterchangeDocument();
+  const qc = useQueryClient();
+  const secureGatePass = useMutation({
+    mutationFn: (scheduleId: string) => trainSchedulingService.grantImportDjiboutiGatepass(scheduleId),
+    onSuccess: () =>
+      qc.invalidateQueries({
+        queryKey: ['warehouse-inventory', 'export-djibouti-arrival-queue'],
+      }),
+  });
   const [openScheduleId, setOpenScheduleId] = useState<string | null>(null);
   const [busyScheduleId, setBusyScheduleId] = useState<string | null>(null);
   const [historyInventoryId, setHistoryInventoryId] = useState<string | null>(null);
@@ -189,6 +208,25 @@ export default function ExportDjiboutiUnloadingQueuePage() {
       .map((doc) => [doc.scheduleId as string, doc]),
   );
 
+  const secureGate = async (train: ExportTrain) => {
+    setBusyScheduleId(train.scheduleId);
+    try {
+      await secureGatePass.mutateAsync(train.scheduleId);
+      toast({
+        title: 'Gate pass secured',
+        description: `Djibouti Port entry allowed for ${train.trainNumber ?? 'the train'}. You can now auto unload.`,
+      });
+    } catch (error) {
+      toast({
+        variant: 'destructive',
+        title: 'Could not secure gate pass',
+        description: getErrorMessage(error),
+      });
+    } finally {
+      setBusyScheduleId(null);
+    }
+  };
+
   const unloadTrain = async (train: ExportTrain) => {
     setBusyScheduleId(train.scheduleId);
     try {
@@ -346,6 +384,16 @@ export default function ExportDjiboutiUnloadingQueuePage() {
                               >
                                 Open
                               </Button>
+                              <Button
+                                size="compact-xs"
+                                variant="light"
+                                color="teal"
+                                leftSection={<ShieldCheck size={14} />}
+                                loading={busyScheduleId === train.scheduleId && secureGatePass.isPending}
+                                onClick={() => secureGate(train)}
+                              >
+                                Secure Gate Pass
+                              </Button>
                               <Button
                                 size="compact-xs"
                                 color="green"
@@ -356,7 +404,7 @@ export default function ExportDjiboutiUnloadingQueuePage() {
                                     <Truck size={14} />
                                   )
                                 }
-                                loading={busyScheduleId === train.scheduleId}
+                                loading={busyScheduleId === train.scheduleId && autoUnload.isPending}
                                 onClick={() => unloadTrain(train)}
                               >
                                 Auto Unload Export Items
diff --git a/apps/edr-freight-web/backoffice/src/pages/warehouses/WarehouseInventoryPage.tsx b/apps/edr-freight-web/backoffice/src/pages/warehouses/WarehouseInventoryPage.tsx
index 7133c47ab..6f0d27580 100644
--- a/apps/edr-freight-web/backoffice/src/pages/warehouses/WarehouseInventoryPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/warehouses/WarehouseInventoryPage.tsx
@@ -21,6 +21,7 @@ export default function WarehouseInventoryPage() {
   const navigate = useNavigate();
   const [searchParams] = useSearchParams();
   const initialStatus = (searchParams.get('status') as InventoryStatus | null) ?? undefined;
+  const direction = (searchParams.get('direction') as 'IMPORT' | 'EXPORT' | null) ?? undefined;
   const [filter, setFilter] = useState<InventoryFilter>(
     initialStatus ? { status: initialStatus } : {},
   );
@@ -28,8 +29,8 @@ export default function WarehouseInventoryPage() {
 
   const [debouncedSearch] = useDebouncedValue(search, 300);
   const queryFilter = useMemo<InventoryFilter>(
-    () => ({ ...filter, search: debouncedSearch || undefined }),
-    [filter, debouncedSearch],
+    () => ({ ...filter, direction, search: debouncedSearch || undefined }),
+    [filter, direction, debouncedSearch],
   );
 
   const warehousesQuery = useWarehouses();
@@ -53,7 +54,13 @@ export default function WarehouseInventoryPage() {
   return (
     <PageContainer>
       <PageHeader
-        title="Warehouse Inventory"
+        title={
+          direction === 'IMPORT'
+            ? 'Import Terminal Inventory'
+            : direction === 'EXPORT'
+              ? 'Export Terminal Inventory'
+              : 'Warehouse Inventory'
+        }
         subtitle="Track received items through the storage, reservation, loading and dispatch lifecycle."
         action={
           <Group gap="xs">
diff --git a/apps/edr-freight-web/backoffice/src/pages/warehouses/WarehouseRulesPage.tsx b/apps/edr-freight-web/backoffice/src/pages/warehouses/WarehouseRulesPage.tsx
index 7d1dbc555..b5c44e4d4 100644
--- a/apps/edr-freight-web/backoffice/src/pages/warehouses/WarehouseRulesPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/warehouses/WarehouseRulesPage.tsx
@@ -33,7 +33,7 @@ import {
 } from '@/hooks/useWarehouses';
 import { api } from '@/services/api';
 import { FEE_RULE_TYPES, type FeeRuleType } from '@/types/warehouse';
-import { extractErrorMessage } from '@/components/warehouses/options';
+import { extractErrorMessage, lettersOnly } from '@/components/warehouses/options';
 
 const FREIGHT = [
   { value: 'CONTAINER', label: 'Container' },
@@ -253,7 +253,7 @@ function AllocationRules() {
               required
               value={form.name}
               onChange={(e) => {
-                const value = e.currentTarget.value;
+                const value = lettersOnly(e.currentTarget.value);
                 setForm((f) => ({ ...f, name: value }));
               }}
             />
@@ -569,7 +569,7 @@ function FeeRules() {
               required
               value={form.name}
               onChange={(e) => {
-                const value = e.currentTarget.value;
+                const value = lettersOnly(e.currentTarget.value);
                 setForm((f) => ({ ...f, name: value }));
               }}
             />
diff --git a/apps/edr-freight-web/backoffice/src/services/api.ts b/apps/edr-freight-web/backoffice/src/services/api.ts
index 0edb591ac..7c6746ec7 100644
--- a/apps/edr-freight-web/backoffice/src/services/api.ts
+++ b/apps/edr-freight-web/backoffice/src/services/api.ts
@@ -44,13 +44,17 @@ import type {
   BatchBoardSchedule,
   BatchBoardScheduleDetail,
   BookableSchedule,
+  BookingWindow,
   CompositionRemovalEntry,
   CreateTrainSchedulePayload,
   EligibleContainerBookingsResponse,
   FreightType,
+  ImportLoadingBookingsResponse,
+  LoadingStatus,
   LocomotiveRecord,
   PinWagonsPayload,
   RecordCheckpointPayload,
+  StaffBookingWindow,
   TrainScheduleDetail,
   TrainScheduleFilters,
   TrainScheduleListItem,
@@ -220,6 +224,13 @@ export const api = {
       () => QUERY_KEYS.TRAIN_SCHEDULING.batchBoard(),
     ),
 
+    allBookingWindows: endpoint<void, StaffBookingWindow[]>(
+      "train-scheduling",
+      "all-booking-windows",
+      () => trainSchedulingService.getAllBookingWindows(),
+      () => ["train-scheduling", "all-booking-windows"],
+    ),
+
     batchBoardDetail: endpoint<
       { scheduleId: string },
       BatchBoardScheduleDetail
@@ -281,6 +292,18 @@ export const api = {
       ],
     ),
 
+    contractBookingWindows: endpoint<{ contractId: string }, BookingWindow[]>(
+      "train-scheduling",
+      "contract-booking-windows",
+      ({ contractId }) =>
+        trainSchedulingService.getContractBookingWindows(contractId),
+      ({ contractId }) => [
+        ...QUERY_KEYS.TRAIN_SCHEDULING.ROOT,
+        "contract-booking-windows",
+        contractId,
+      ],
+    ),
+
     availableDays: endpoint<
       { originYardId?: string | null; destinationYardId?: string | null },
       string[]
@@ -357,6 +380,25 @@ export const api = {
         QUERY_KEYS.TRAIN_SCHEDULING.compositionRemovals(scheduleId),
     ),
 
+    importLoadingBookings: endpoint<{ id: string }, ImportLoadingBookingsResponse>(
+      "train-scheduling",
+      "import-loading-bookings",
+      ({ id }) => trainSchedulingService.getImportLoadingBookings(id),
+      ({ id }) => QUERY_KEYS.TRAIN_SCHEDULING.importLoadingBookings(id),
+    ),
+
+    updateImportLoadingStatus: endpoint<
+      { id: string; bookingIds: string[]; loadingStatus: LoadingStatus },
+      ImportLoadingBookingsResponse
+    >(
+      "train-scheduling",
+      "update-import-loading-status",
+      ({ id, bookingIds, loadingStatus }) =>
+        trainSchedulingService.updateImportLoadingStatus(id, { bookingIds, loadingStatus }),
+      undefined,
+      ({ id }) => [QUERY_KEYS.TRAIN_SCHEDULING.importLoadingBookings(id)],
+    ),
+
     // ── Mutations ──────────────────────────────────────────────────────────
     runAllocation: endpoint<
       { scheduleId: string },
diff --git a/apps/edr-freight-web/backoffice/src/services/bookings.service.ts b/apps/edr-freight-web/backoffice/src/services/bookings.service.ts
index bcc30a1fc..6a4c0cb1c 100644
--- a/apps/edr-freight-web/backoffice/src/services/bookings.service.ts
+++ b/apps/edr-freight-web/backoffice/src/services/bookings.service.ts
@@ -17,6 +17,8 @@ export interface BookingListFilter {
   // customerId?: string;
   companyId?: string;
   freightType?: string;
+  /** ONE_TIME | GENERAL_CONTRACT — the booking-kind tab filter. */
+  bookingType?: string;
   tradeDirection?: string;
   paymentCurrency?: string;
   page?: number;
@@ -125,6 +127,7 @@ export const bookingsService = {
       if (filter.pageSize != null) params.pageSize = filter.pageSize;
       if (filter.companyId) params.companyId = filter.companyId;
       if (filter.freightType) params.freightType = filter.freightType;
+      if (filter.bookingType) params.bookingType = filter.bookingType;
       if (filter.tradeDirection) params.tradeDirection = filter.tradeDirection;
       if (filter.paymentCurrency) params.paymentCurrency = filter.paymentCurrency;
     }
@@ -148,6 +151,7 @@ export const bookingsService = {
       if (filter.assignedToSchedule) params.assignedToSchedule = filter.assignedToSchedule;
       if (filter.companyId) params.companyId = filter.companyId;
       if (filter.freightType) params.freightType = filter.freightType;
+      if (filter.bookingType) params.bookingType = filter.bookingType;
       if (filter.tradeDirection) params.tradeDirection = filter.tradeDirection;
       if (filter.paymentCurrency) params.paymentCurrency = filter.paymentCurrency;
     }
@@ -171,11 +175,6 @@ export const bookingsService = {
   },
 
   // ── Document clearance (GL workflow) ──
-  getClearance: async (id: string): Promise<Freight.ClearanceView> => {
-    const response = await client.get(`/bookings/${id}/clearance`);
-    return unwrap(response.data) as Freight.ClearanceView;
-  },
-
   reviewClearanceDocument: (
     id: string,
     payload: { fileKey: string; status: "APPROVED" | "QUERIED"; note?: string },
diff --git a/apps/edr-freight-web/backoffice/src/services/contracts.service.ts b/apps/edr-freight-web/backoffice/src/services/contracts.service.ts
index 369e53ea8..7ad051ce7 100644
--- a/apps/edr-freight-web/backoffice/src/services/contracts.service.ts
+++ b/apps/edr-freight-web/backoffice/src/services/contracts.service.ts
@@ -27,6 +27,41 @@ export interface PaginatedContracts {
   total: number;
 }
 
+/** One line of the server-priced booking breakdown (mirrors PriceLineItemDto). */
+export interface ShipmentPriceLine {
+  code: string;
+  description: string;
+  amount: number;
+  unitAmount: number;
+  /** Rate unit as stored: PER_CONTAINER | PER_WAGON | PER_TON | PER_KM | FLAT | … */
+  unit: string;
+  quantity: number;
+  currency: string;
+}
+
+/**
+ * Pre-create validation + authoritative price preview for a booking under a
+ * contract. `lineItems`/`totalAmount` are the full server-computed breakdown —
+ * the same pricing pass the booking persists at create (rail freight,
+ * first/last mile, overweight and every other surcharge). `pairingErrors` and
+ * `capacityErrors` are HARD BLOCKS; `overweightLines` are warnings.
+ */
+export interface ShipmentValidation {
+  overweightLines: Array<{
+    containerTypeCode: string;
+    totalVgmTons: number;
+    maxAllowedTons: number;
+    excessTons: number;
+  }>;
+  overweightSurchargeAmount: number;
+  currency: string | null;
+  pairingErrors: string[];
+  /** Lines above the container type's hard max capacity — booking cannot be created. */
+  capacityErrors?: string[];
+  lineItems?: ShipmentPriceLine[];
+  totalAmount?: number;
+}
+
 export interface ContractListSummaryMetrics {
   inQueue: number;
   needsAction: number;
@@ -356,35 +391,6 @@ export const contractsService = {
     return unwrap(response.data) as Freight.ClearanceT1State;
   },
 
-  /** Train schedules carrying customs bookings — GL DJ gate-pass table. */
-  getDjClearanceSchedules: async (): Promise<Freight.DjClearanceSchedule[]> => {
-    const response = await client.get(C.CLEARANCE_DJ_SCHEDULES);
-    return unwrap(response.data) as Freight.DjClearanceSchedule[];
-  },
-
-  /** Gate pass for every customs booking on a train schedule (captures time). */
-  grantScheduleGatepass: async (
-    scheduleId: string,
-    gatepassAt?: string,
-  ): Promise<{ granted: number; skipped: Array<{ bookingId: string; error: string }> }> => {
-    const response = await client.post(C.CLEARANCE_SCHEDULE_GATEPASS(scheduleId), {
-      gatepassAt,
-    });
-    return unwrap(response.data) as {
-      granted: number;
-      skipped: Array<{ bookingId: string; error: string }>;
-    };
-  },
-
-  /** Gate pass for a single customs booking (captures time). */
-  grantGatepass: async (
-    bookingId: string,
-    gatepassAt?: string,
-  ): Promise<{ bookingId: string; gatepassAt: string }> => {
-    const response = await client.post(C.BOOKING_GATEPASS(bookingId), { gatepassAt });
-    return unwrap(response.data) as { bookingId: string; gatepassAt: string };
-  },
-
   /** GL DJ raises the post-offload final invoice (amount + invoice document). */
   sendFinalInvoice: async (
     bookingId: string,
@@ -471,6 +477,18 @@ export const contractsService = {
     payload: Freight.CreateBookingUnderContractDto,
   ) => postContract<{ id: string; reference: string }>(C.BOOKINGS(id), payload),
 
+  /**
+   * Pre-create validation + authoritative price preview: the same
+   * BookingPricingService pass that prices the booking on create (rail +
+   * first/last mile + every surcharge), plus overweight warnings and 20ft
+   * pairing hard-blocks. Shown in the GL price-confirm modal.
+   */
+  validateShipment: (
+    id: string,
+    payload: Freight.CreateBookingUnderContractDto,
+  ) =>
+    postContract<ShipmentValidation>(C.VALIDATE_SHIPMENT(id), payload),
+
   /** Remaining bookable quantity per cargo line (GENERAL draw-down cap). */
   getCapacity: async (id: string): Promise<Freight.ContractCapacityLine[]> => {
     const response = await client.get(C.CAPACITY(id));
diff --git a/apps/edr-freight-web/backoffice/src/services/drivers.service.ts b/apps/edr-freight-web/backoffice/src/services/drivers.service.ts
index d288975c2..79b0f88ef 100644
--- a/apps/edr-freight-web/backoffice/src/services/drivers.service.ts
+++ b/apps/edr-freight-web/backoffice/src/services/drivers.service.ts
@@ -26,6 +26,8 @@ export interface Driver {
   address?: string | null;
   emergencyContact?: string | null;
   notes?: string | null;
+  faydaVerified?: boolean;
+  faydaSub?: string | null;
   totalTrips: number;
   rating: number;
   createdAt: string;
diff --git a/apps/edr-freight-web/backoffice/src/services/first-mile.service.ts b/apps/edr-freight-web/backoffice/src/services/first-mile.service.ts
index 1c81f5dc5..6fc80a282 100644
--- a/apps/edr-freight-web/backoffice/src/services/first-mile.service.ts
+++ b/apps/edr-freight-web/backoffice/src/services/first-mile.service.ts
@@ -16,12 +16,24 @@ export interface FirstMileBooking {
   cargoFreeText?: string | null;
   cargoTotalWeightVgm: number;
   totalAmount: number;
+  paymentCurrency?: string | null;
   scheduledDate?: string | null;
   company?: { id: string; name?: string; phone?: string | null; contactPersonName?: string | null; contactPersonPhone?: string | null } | null;
   serviceType?: { id: string; label?: string } | null;
   originYard?: { id: string; label?: string } | null;
   destinationYard?: { id: string; label?: string } | null;
   cargoType?: { id: string; label?: string } | null;
+  /** Container lines — total container count drives how many trucks are needed. */
+  bookingContainers?: Array<{
+    id: string;
+    quantity: number;
+    containerNumber?: string | null;
+    containerSize?: string | null;
+    containerType?: { id: string; name?: string; label?: string; code?: string } | null;
+    /** Physical containers under this line — their real numbers (line-level
+     *  containerNumber is often a TBD placeholder). */
+    units?: Array<{ id: string; containerNumber?: string | null; sortOrder?: number }>;
+  }>;
 }
 
 export interface FirstMileVehicle {
@@ -29,9 +41,12 @@ export interface FirstMileVehicle {
   plateNumber: string;
   manufacturer: string;
   model: string;
+  vehicleType?: string | null;
   code?: string | null;
   powerPlateNo?: string | null;
   trailerPlateNo?: string | null;
+  assignedDriverId?: string | null;
+  assignedDriverName?: string | null;
 }
 
 export interface FirstMileRecord {
@@ -45,6 +60,16 @@ export interface FirstMileRecord {
   vehicleId?: string | null;
   booking?: FirstMileBooking | null;
   vehicle?: FirstMileVehicle | null;
+  /** Full set of vehicles serving this pickup (multi-truck). */
+  vehicleAssignments?: Array<{
+    id: string;
+    vehicleId: string;
+    containerNumber?: string | null;
+    distanceKm?: number | null;
+    vehicle?: FirstMileVehicle | null;
+  }>;
+  /** Present only when an invoice has actually been generated (not on distance). */
+  invoice?: { id: string; number: string; status: string } | null;
   createdAt: string;
   updatedAt: string;
 }
@@ -66,4 +91,15 @@ export const firstMileService = {
     api.post<FirstMileRecord>(FM.ACCEPT(bookingReference)),
   remove: (id: string) =>
     api.delete<void>(FM.BY_ID(id)),
+  setVehicles: (
+    id: string,
+    vehicles: Array<{ vehicleId: string; containerNumber?: string | null }>,
+  ) => api.post<FirstMileRecord>(`${FM.BASE}/${id}/vehicles`, { vehicles }),
+  setDistances: (
+    id: string,
+    distances: Array<{ vehicleId: string; distanceKm: number }>,
+    remainingPayment?: number,
+  ) => api.post<FirstMileRecord>(`${FM.BASE}/${id}/distances`, { distances, remainingPayment }),
+  generateInvoice: (id: string) =>
+    api.post<{ id: string; invoiceNumber?: string } | null>(`${FM.BASE}/${id}/invoice`),
 };
diff --git a/apps/edr-freight-web/backoffice/src/services/fleet-history.service.ts b/apps/edr-freight-web/backoffice/src/services/fleet-history.service.ts
new file mode 100644
index 000000000..5ffbe4a26
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/services/fleet-history.service.ts
@@ -0,0 +1,38 @@
+import { api as apiClient } from "../auth/http";
+
+export type FleetEventType =
+  | "DRIVER_REGISTERED"
+  | "VEHICLE_REGISTERED"
+  | "DRIVER_ASSIGNED"
+  | "DRIVER_UNASSIGNED"
+  | "VEHICLE_STATUS_CHANGED"
+  | "VEHICLE_AVAILABILITY_CHANGED"
+  | "MILE_VEHICLE_ASSIGNED"
+  | "MILE_VEHICLE_RELEASED"
+  | "MILE_STATUS_CHANGED";
+
+export interface FleetHistoryEvent {
+  id: string;
+  eventType: FleetEventType;
+  vehicleId?: string | null;
+  driverId?: string | null;
+  firstMileId?: string | null;
+  lastMileId?: string | null;
+  fromValue?: string | null;
+  toValue?: string | null;
+  label?: string | null;
+  metadata?: Record<string, unknown> | null;
+  createdAt: string;
+}
+
+/** Timeline of fleet events for a driver or a vehicle (newest first). */
+export const fleetHistoryService = {
+  driver: (id: string) =>
+    apiClient
+      .get<FleetHistoryEvent[]>(`/drivers/${id}/history`)
+      .then((r) => r.data),
+  vehicle: (id: string) =>
+    apiClient
+      .get<FleetHistoryEvent[]>(`/vehicles/${id}/history`)
+      .then((r) => r.data),
+};
diff --git a/apps/edr-freight-web/backoffice/src/services/last-mile.service.ts b/apps/edr-freight-web/backoffice/src/services/last-mile.service.ts
index 27f47cc7a..88e4bb9c0 100644
--- a/apps/edr-freight-web/backoffice/src/services/last-mile.service.ts
+++ b/apps/edr-freight-web/backoffice/src/services/last-mile.service.ts
@@ -16,12 +16,24 @@ export interface LastMileBooking {
   cargoFreeText?: string | null;
   cargoTotalWeightVgm: number;
   totalAmount: number;
+  paymentCurrency?: string | null;
   scheduledDate?: string | null;
   company?: { id: string; name?: string; phone?: string | null; contactPersonName?: string | null; contactPersonPhone?: string | null } | null;
   serviceType?: { id: string; name?: string; label?: string } | null;
   originYard?: { id: string; name?: string; label?: string } | null;
   destinationYard?: { id: string; name?: string; label?: string } | null;
   cargoType?: { id: string; name?: string; label?: string; cargoTypeName?: string } | null;
+  /** Container lines — total container count drives how many trucks are needed. */
+  bookingContainers?: Array<{
+    id: string;
+    quantity: number;
+    containerNumber?: string | null;
+    containerSize?: string | null;
+    containerType?: { id: string; name?: string; label?: string; code?: string } | null;
+    /** Physical containers under this line — their real numbers (line-level
+     *  containerNumber is often a TBD placeholder). */
+    units?: Array<{ id: string; containerNumber?: string | null; sortOrder?: number }>;
+  }>;
 }
 
 export interface LastMileVehicle {
@@ -48,6 +60,16 @@ export interface LastMileRecord {
   vehicleId?: string | null;
   booking?: LastMileBooking | null;
   vehicle?: LastMileVehicle | null;
+  /** Full set of vehicles serving this delivery (multi-truck). */
+  vehicleAssignments?: Array<{
+    id: string;
+    vehicleId: string;
+    containerNumber?: string | null;
+    distanceKm?: number | null;
+    vehicle?: LastMileVehicle | null;
+  }>;
+  /** Present only when an invoice has actually been generated (not on distance). */
+  invoice?: { id: string; number: string; status: string } | null;
   createdAt: string;
   updatedAt: string;
 }
@@ -69,4 +91,15 @@ export const lastMileService = {
     api.post<LastMileRecord>(LM.ACCEPT(encodeURIComponent(bookingReference))),
   remove: (id: string) =>
     api.delete<void>(LM.BY_ID(id)),
+  setVehicles: (
+    id: string,
+    vehicles: Array<{ vehicleId: string; containerNumber?: string | null }>,
+  ) => api.post<LastMileRecord>(`${LM.BASE}/${id}/vehicles`, { vehicles }),
+  setDistances: (
+    id: string,
+    distances: Array<{ vehicleId: string; distanceKm: number }>,
+    remainingPayment?: number,
+  ) => api.post<LastMileRecord>(`${LM.BASE}/${id}/distances`, { distances, remainingPayment }),
+  generateInvoice: (id: string) =>
+    api.post<{ id: string; invoiceNumber?: string } | null>(`${LM.BASE}/${id}/invoice`),
 };
diff --git a/apps/edr-freight-web/backoffice/src/services/rates.service.ts b/apps/edr-freight-web/backoffice/src/services/rates.service.ts
index 589f3ea13..b7e3dd377 100644
--- a/apps/edr-freight-web/backoffice/src/services/rates.service.ts
+++ b/apps/edr-freight-web/backoffice/src/services/rates.service.ts
@@ -15,8 +15,6 @@ export interface Rate {
   proposedByStaffId: string;
   approvedByCeoId: string | null;
   approvedAt: string | null;
-  effectiveFrom: string;
-  effectiveTo: string | null;
   createdAt: string;
   updatedAt: string;
   deletedAt: string | null;
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 0d6ef6cc9..aa178d4b7 100644
--- a/apps/edr-freight-web/backoffice/src/services/trainScheduling.service.ts
+++ b/apps/edr-freight-web/backoffice/src/services/trainScheduling.service.ts
@@ -6,6 +6,7 @@ import type {
   BatchBoardSchedule,
   BatchBoardScheduleDetail,
   BookableSchedule,
+  BookingWindow,
   AssignBookingsPayload,
   CompositionRemovalEntry,
   UnassignedBookingsResponse,
@@ -15,9 +16,12 @@ import type {
   ImportDjiboutiActionPayload,
   ImportDjiboutiLoadList,
   ImportDjiboutiOperation,
+  ImportLoadingBookingsResponse,
+  LoadingStatus,
   LocomotiveRecord,
   PinWagonsPayload,
   RecordCheckpointPayload,
+  StaffBookingWindow,
   TrainScheduleDetail,
   TrainScheduleFilters,
   TrainScheduleListItem,
@@ -106,6 +110,19 @@ export const trainSchedulingService = {
     return unwrap(response.data);
   },
 
+  /**
+   * Booking windows for every route/schedule of a contract. A window with
+   * `isOpenNow === true` means GL may create a booking right now for that route.
+   */
+  getContractBookingWindows: async (
+    contractId: string,
+  ): Promise<BookingWindow[]> => {
+    const response = await client.get<BookingWindow[]>(
+      URL_CONSTANTS.TRAIN_SCHEDULING.CONTRACT_BOOKING_WINDOWS(contractId),
+    );
+    return unwrap(response.data);
+  },
+
   getBookableSchedules: async (
     originYardId?: string,
     destinationYardId?: string,
@@ -298,6 +315,26 @@ export const trainSchedulingService = {
     return unwrap(response.data);
   },
 
+  getImportLoadingBookings: async (
+    scheduleId: string,
+  ): Promise<ImportLoadingBookingsResponse> => {
+    const response = await client.get<ImportLoadingBookingsResponse>(
+      URL_CONSTANTS.TRAIN_SCHEDULING.IMPORT_LOADING_BOOKINGS(scheduleId),
+    );
+    return unwrap(response.data);
+  },
+
+  updateImportLoadingStatus: async (
+    scheduleId: string,
+    payload: { bookingIds: string[]; loadingStatus: LoadingStatus },
+  ): Promise<ImportLoadingBookingsResponse> => {
+    const response = await client.patch<ImportLoadingBookingsResponse>(
+      URL_CONSTANTS.TRAIN_SCHEDULING.IMPORT_LOADING_STATUS(scheduleId),
+      payload,
+    );
+    return unwrap(response.data);
+  },
+
   getImportDjiboutiOperation: async (
     scheduleId: string,
   ): Promise<ImportDjiboutiOperation> => {
@@ -507,6 +544,13 @@ export const trainSchedulingService = {
     return unwrap(response.data);
   },
 
+  getAllBookingWindows: async (): Promise<StaffBookingWindow[]> => {
+    const response = await client.get<StaffBookingWindow[]>(
+      URL_CONSTANTS.TRAIN_SCHEDULING.BOOKING_WINDOWS,
+    );
+    return unwrap(response.data);
+  },
+
   updateGlobalRules: async (
     payload: Partial<Omit<TrainSchedulingGlobalRules, "id">>,
   ): Promise<TrainSchedulingGlobalRules> => {
diff --git a/apps/edr-freight-web/backoffice/src/services/vehicles.service.ts b/apps/edr-freight-web/backoffice/src/services/vehicles.service.ts
index fd34b5e62..6b48ed801 100644
--- a/apps/edr-freight-web/backoffice/src/services/vehicles.service.ts
+++ b/apps/edr-freight-web/backoffice/src/services/vehicles.service.ts
@@ -35,6 +35,9 @@ export interface Vehicle {
   powerPlateNo?: string | null;
   trailerPlateNo?: string | null;
   locationId?: string | null;
+  /** Odometer-derived distances (API sends numeric strings; coerce with Number). */
+  estimatedDistanceKm?: number | null;
+  actualDistanceKm?: number | null;
   createdAt: string;
   updatedAt: string;
 }
diff --git a/apps/edr-freight-web/backoffice/src/services/verifayda.service.ts b/apps/edr-freight-web/backoffice/src/services/verifayda.service.ts
new file mode 100644
index 000000000..d02394278
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/services/verifayda.service.ts
@@ -0,0 +1,46 @@
+import { api as apiClient } from '../auth/http';
+
+export interface FaydaStartResponse {
+  authorizationUrl: string;
+}
+
+export interface FaydaCompleteResult {
+  purpose: 'LOGIN' | 'VERIFY';
+  verified: boolean;
+  fullName?: string;
+  email?: string;
+  phoneNumber?: string;
+  /** ISO yyyy-MM-dd */
+  birthdate?: string;
+  gender?: string;
+  iamUserId?: string;
+  userDataSaved?: boolean;
+}
+
+/** Message posted from the /callback popup back to the opener window. */
+export interface FaydaCallbackMessage {
+  type: 'fayda-callback';
+  code?: string;
+  state?: string;
+  error?: string;
+  errorDescription?: string;
+}
+
+export const verifaydaService = {
+  /** Returns the eSignet authorize URL to open in a popup. */
+  start: () =>
+    apiClient
+      .post<FaydaStartResponse>('/fayda/verification/start', {
+        purpose: 'VERIFY',
+        platform: 'WEB',
+      })
+      .then((r) => r.data),
+
+  /** Exchange the callback code+state for the verified identity attributes. */
+  complete: (code: string, state: string) =>
+    apiClient
+      .get<FaydaCompleteResult>(
+        `/fayda/verification/complete?code=${encodeURIComponent(code)}&state=${encodeURIComponent(state)}`,
+      )
+      .then((r) => r.data),
+};
diff --git a/apps/edr-freight-web/backoffice/src/types/booking.ts b/apps/edr-freight-web/backoffice/src/types/booking.ts
index 298e749c7..2c0be4726 100644
--- a/apps/edr-freight-web/backoffice/src/types/booking.ts
+++ b/apps/edr-freight-web/backoffice/src/types/booking.ts
@@ -69,9 +69,22 @@ export interface BookingCompany {
   website?: string | null;
 }
 
+/** One physical container under a line — its own number + verified gross mass. */
+export interface BookingContainerUnit {
+  id: string;
+  containerNumber: string;
+  sealNumber?: string | null;
+  vgmTons: number;
+  isHazardous?: boolean;
+  isReefer?: boolean;
+  sortOrder?: number;
+}
+
 export interface BookingContainerLine {
   id: string;
   containerTypeId: string;
+  /** Line-level number — often a "TBD-…" placeholder; real numbers live in units. */
+  containerNumber?: string | null;
   quantity: number;
   vgmPerUnitTons: number;
   containerType?: {
@@ -80,6 +93,8 @@ export interface BookingContainerLine {
     label?: string;
     sizeFt?: number;
   };
+  /** Per-physical-container rows (number + weight). Empty when not captured. */
+  units?: BookingContainerUnit[];
 }
 
 export interface BookingApprovalStep {
@@ -178,6 +193,9 @@ export interface BookingDetail {
   customsClearingEnabled?: boolean;
   customsClearingAgent?: string | null;
   contractKind?: "ONE_TIME" | "GENERAL" | null;
+  contractId?: string | null;
+  /** Reference of the contract this booking was created under (list column + search). */
+  contractReference?: string | null;
   contractSummary?: string | null;
   latestChangeRequestNote?: string | null;
   nextStep?: BookingNextStep | null;
@@ -188,7 +206,7 @@ export interface BookingDetail {
   company?: BookingNamedRef & Partial<BookingCompany>;
   originYard?: BookingNamedRef;
   destinationYard?: BookingNamedRef;
-  serviceType?: BookingNamedRef & { code?: string; priorityBonusPoints?: number; includesCustoms?: boolean };
+  serviceType?: BookingNamedRef & { code?: string; priorityBonusPoints?: number; includesCustoms?: boolean; includesFirstMile?: boolean; includesLastMile?: boolean };
   cargoType?: BookingNamedRef;
   shippingLine?: BookingNamedRef;
   bookingContainers?: BookingContainerLine[];
@@ -205,6 +223,7 @@ export interface BookingDetail {
 export interface BookingListRow {
   id: string;
   reference: string;
+  contractReference?: string | null;
   customerLabel: string;
   approvalSteps?: BookingApprovalStep[];
   status: BookingStatus;
diff --git a/apps/edr-freight-web/backoffice/src/types/trainScheduling.ts b/apps/edr-freight-web/backoffice/src/types/trainScheduling.ts
index 2e8ec2b21..d629311ee 100644
--- a/apps/edr-freight-web/backoffice/src/types/trainScheduling.ts
+++ b/apps/edr-freight-web/backoffice/src/types/trainScheduling.ts
@@ -226,6 +226,27 @@ export interface BatchBoardBooking {
   state: BatchBoardBookingState;
 }
 
+/**
+ * An announced booking window on any lane (import cycle or export FCFS), for
+ * staff dashboards. Mirrors the customer portal's MyBookingWindow.
+ */
+export interface StaffBookingWindow {
+  scheduleId: string;
+  trainNumber: string | null;
+  direction: "IMPORT" | "EXPORT" | null;
+  windowPhase: BookingWindowPhase | string | null;
+  isOpenNow: boolean;
+  windowOpensAt: string | null;
+  windowClosesAt: string | null;
+  docReviewEndsAt: string | null;
+  paymentPhaseEndsAt: string | null;
+  bookingWindowStatus: string;
+  bookingCycleNo: number;
+  departureDate: string;
+  origin: string | null;
+  destination: string | null;
+}
+
 export interface BatchBoardSchedule {
   scheduleId: string;
   trainNumber: string | null;
@@ -325,6 +346,25 @@ export interface BatchBoardScheduleDetail {
   allocationViolations: string[];
 }
 
+/**
+ * A booking window for one of a contract's routes/schedules. `isOpenNow === true`
+ * means a booking may be created right now for that route. Times are ISO strings;
+ * render them in EAT (Africa/Addis_Ababa).
+ */
+export interface BookingWindow {
+  scheduleId: string;
+  direction: string | null;
+  windowPhase: BookingWindowPhase | null;
+  isOpenNow: boolean;
+  windowOpensAt: string | null;
+  windowClosesAt: string | null;
+  bookingWindowStatus: string;
+  bookingCycleNo: number;
+  departureDate: string;
+  origin: string | null;
+  destination: string | null;
+}
+
 export interface WagonAllocationAttemptResult {
   assignedBookingIds: string[];
   deferred: Array<{ id: string; reference: string; reason: string }>;
@@ -366,6 +406,11 @@ export interface TrainScheduleDetail {
   freightType?: FreightType | null;
   trainNumber?: string | null;
   direction?: string | null;
+  windowPhase?: BookingWindowPhase | string | null;
+  windowOpensAt?: string | null;
+  windowClosesAt?: string | null;
+  docReviewEndsAt?: string | null;
+  paymentPhaseEndsAt?: string | null;
   route?: {
     id: string;
     name: string;
@@ -455,6 +500,21 @@ export interface ImportDjiboutiDocumentRecord {
   notes?: string | null;
 }
 
+export type LoadingStatus = "LOADED" | "UNLOADED";
+
+export interface ImportLoadingBooking {
+  id: string;
+  reference: string | null;
+  customer: string | null;
+  weightTons: number;
+  loadingStatus: LoadingStatus;
+}
+
+export interface ImportLoadingBookingsResponse {
+  count: number;
+  items: ImportLoadingBooking[];
+}
+
 export interface ImportDjiboutiOperation {
   trainScheduleId: string;
   trainNumber: string | null;
diff --git a/apps/edr-freight-web/backoffice/src/types/warehouse.ts b/apps/edr-freight-web/backoffice/src/types/warehouse.ts
index fdaeee556..5e116d1ca 100644
--- a/apps/edr-freight-web/backoffice/src/types/warehouse.ts
+++ b/apps/edr-freight-web/backoffice/src/types/warehouse.ts
@@ -1013,6 +1013,7 @@ export interface InventoryFilter {
   containerId?: string;
   goodsId?: string;
   status?: InventoryStatus;
+  direction?: 'IMPORT' | 'EXPORT';
   search?: string;
   dateFrom?: string;
   dateTo?: string;
diff --git a/apps/edr-freight-web/backoffice/user-management b/apps/edr-freight-web/backoffice/user-management
deleted file mode 160000
index e3a50a7c9..000000000
--- a/apps/edr-freight-web/backoffice/user-management
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit e3a50a7c91bc219e20c7068d8344ae25cbc72baf
diff --git a/apps/edr-freight-web/portal/public/assets/edr_image.jpg b/apps/edr-freight-web/portal/public/assets/edr_image.jpg
new file mode 100644
index 000000000..b89941eea
Binary files /dev/null and b/apps/edr-freight-web/portal/public/assets/edr_image.jpg differ
diff --git a/apps/edr-freight-web/portal/public/assets/edr_image.png b/apps/edr-freight-web/portal/public/assets/edr_image.png
new file mode 100644
index 000000000..1654c747c
Binary files /dev/null and b/apps/edr-freight-web/portal/public/assets/edr_image.png differ
diff --git a/apps/edr-freight-web/portal/src/components/auth/AuthShell.tsx b/apps/edr-freight-web/portal/src/components/auth/AuthShell.tsx
index 5a4adf587..439f41d19 100644
--- a/apps/edr-freight-web/portal/src/components/auth/AuthShell.tsx
+++ b/apps/edr-freight-web/portal/src/components/auth/AuthShell.tsx
@@ -1,40 +1,25 @@
 import type { ReactNode } from "react";
-import { ArrowUpRight, ChevronDown, Globe } from "lucide-react";
+import { Box, Image, Stack, Text, Title } from "@mantine/core";
+import { ChevronDown, Globe } from "lucide-react";
+import { Link } from "react-router-dom";
 
-const LOGIN_IMAGE = "/assets/login.png";
+const EDR_IMAGE = "/assets/edr_image.png";
 const EDR_LOGO = "/assets/logo.svg";
 
+/** Muted deep-green brand wash for the left panel. */
+const LEFT_PANEL_BG =
+  "linear-gradient(158deg, #2E6B55 0%, #21503F 46%, #16352A 100%)";
+
+/** Radial opacity mask: image fully opaque at its center, fading to nothing at the edges. */
+const IMAGE_FADE_MASK =
+  "linear-gradient(-90deg, #000 95%, #0009 97%, #0000 100%), linear-gradient(0deg, #000 80%, #0001 100%)";
+
 export const fieldClass =
   "h-11 w-full rounded-xl border border-gray-200/90 bg-white px-4 text-sm text-gray-900 shadow-sm placeholder:text-gray-400 outline-none transition-all duration-200 hover:border-gray-300 focus:border-primary focus:bg-white focus:ring-4 focus:ring-primary/10";
 
 export const primaryButtonClass =
   "h-11 w-full rounded-full bg-primary text-sm font-semibold text-primary-foreground shadow-[0_8px_20px_-6px_rgba(16,94,52,0.5)] transition-all duration-200 hover:bg-primary/90 hover:shadow-[0_10px_24px_-6px_rgba(16,94,52,0.55)] active:scale-[0.99] disabled:cursor-not-allowed disabled:opacity-60 disabled:shadow-none";
 
-const LeftPanelDecor = () => (
-  <div
-    className="pointer-events-none absolute inset-0 overflow-hidden"
-    aria-hidden
-  >
-    <svg
-      className="absolute -bottom-24 -left-24 h-[420px] w-[420px] text-white/[0.07]"
-      viewBox="0 0 400 400"
-      fill="none"
-    >
-      {[0, 1, 2, 3, 4, 5].map((ring) => (
-        <circle
-          key={ring}
-          cx="200"
-          cy="200"
-          r={60 + ring * 36}
-          stroke="currentColor"
-          strokeWidth="1"
-        />
-      ))}
-    </svg>
-    <div className="absolute right-0 top-0 h-40 w-40 rounded-full bg-white/[0.06] blur-2xl" />
-  </div>
-);
-
 const RightPanelDecor = () => (
   <div
     className="pointer-events-none absolute inset-0 overflow-hidden"
@@ -63,7 +48,7 @@ const RightPanelDecor = () => (
 
 export interface AuthShellProps {
   children: ReactNode;
-  /** Tagline shown in the highlighted card over the left image panel. */
+  /** Headline shown in the top-left of the green panel. */
   tagline?: string;
   taglineBody?: string;
 }
@@ -72,45 +57,63 @@ const LeftPanel = ({
   tagline,
   taglineBody,
 }: Pick<AuthShellProps, "tagline" | "taglineBody">) => (
-  <div className="relative hidden shrink-0 flex-col overflow-hidden rounded-2xl bg-[#011F12] shadow-[0_8px_32px_rgba(15,23,42,0.1)] lg:flex lg:h-auto lg:min-h-0 lg:flex-1 lg:basis-1/2 lg:rounded-[28px]">
-    <img
-      src={LOGIN_IMAGE}
-      alt="Ethio Djibouti Railway"
-      className="absolute inset-0 h-auto w-full object-cover object-center"
-    />
-    <div className="absolute inset-0 bg-gradient-to-br from-[#0a2e1a]/92 via-[#0f4a2a]/15 to-[#1a5c34]/45" />
-    <LeftPanelDecor />
-
-    <div className="relative z-10 flex shrink-0 items-center justify-between px-4 pt-4 sm:px-6 sm:pt-6 lg:px-8 lg:pt-8">
-      <img
+  <Box
+    className="relative hidden shrink-0 overflow-hidden rounded-2xl shadow-[0_8px_32px_rgba(15,23,42,0.12)] lg:flex lg:h-auto lg:min-h-0 lg:flex-1 lg:basis-1/2 lg:rounded-[28px]"
+    style={{ background: LEFT_PANEL_BG }}
+  >
+    {/* Top-left: logo, title, description — stacked, left aligned. */}
+    <Stack
+      gap="xl"
+      className="relative z-10 p-8 lg:p-10"
+      style={{ maxWidth: 520 }}
+    >
+      <Image
         src={EDR_LOGO}
         alt="EDR Freight"
-        className="h-7 w-auto brightness-0 invert sm:h-9"
+        h={40}
+        w="auto"
+        fit="contain"
+        style={{ filter: "brightness(0) invert(1)", alignSelf: "flex-start" }}
       />
-      <a
-        href="#"
-        className="flex items-center gap-1.5 rounded-full border border-white/70 bg-white/10 px-3 py-1.5 text-xs font-medium text-white backdrop-blur-sm transition-colors hover:bg-white/20 sm:px-4 sm:py-2 sm:text-sm"
-      >
-        Support
-        <ArrowUpRight className="h-3.5 w-3.5 sm:h-4 sm:w-4" />
-      </a>
-    </div>
 
-    <div className="relative z-10 mt-auto hidden px-8 pb-8 lg:block">
-      <div className="max-w-md rounded-2xl border border-white/15 bg-black/30 p-5 backdrop-blur-md">
-        <div className="mb-2 flex items-center gap-2">
-          <div className="h-2 w-2 shrink-0 rounded-full bg-primary" />
-          <span className="text-sm font-semibold text-white">
-            {tagline ?? "Empower Your Freight Operations"}
-          </span>
-        </div>
-        <p className="text-sm leading-relaxed text-white/85">
+      <Stack gap="sm">
+        <Title
+          order={1}
+          c="white"
+          fz={38}
+          fw={800}
+          lh={1.08}
+          style={{ letterSpacing: "-0.02em" }}
+        >
+          {tagline ?? "Ethiopian Djibouti Railway"}
+        </Title>
+        <Text fz="md" lh={1.6} c="rgba(255,255,255,0.82)" maw={440}>
           {taglineBody ??
-            "Sign in to manage shipments, track cargo, and run logistics operations on the Ethio Djibouti Railway freight platform."}
-        </p>
-      </div>
-    </div>
-  </div>
+            "Sign in to book shipments, track cargo, and manage your freight on the Ethio–Djibouti Railway platform."}
+        </Text>
+      </Stack>
+    </Stack>
+
+    {/* Bottom-right: brand image with a center-to-edge opacity fade, no color tint. */}
+    <Image
+      src={EDR_IMAGE}
+      alt=""
+      aria-hidden
+      fit="cover"
+      pos="absolute"
+      right={0}
+      bottom={0}
+      w="80%"
+      h="60%"
+      style={{
+        WebkitMaskImage: IMAGE_FADE_MASK,
+        maskImage: IMAGE_FADE_MASK,
+        opacity: 0.9,
+        pointerEvents: "none",
+        maskComposite: "intersect",
+      }}
+    />
+  </Box>
 );
 
 const LanguageSelector = () => (
@@ -125,24 +128,24 @@ const FormFooter = () => (
   <div className="relative z-10 flex shrink-0 flex-col items-center justify-between gap-3 border-t border-gray-100 px-4 py-4 text-xs text-gray-400 sm:flex-row sm:gap-4 sm:px-6 sm:py-4 lg:px-8 lg:pb-6">
     <span className="shrink-0">© 2026 EDR Freight</span>
     <div className="flex flex-wrap items-center justify-center gap-3 sm:justify-end sm:gap-6">
-      <a
-        href="#"
+      <Link
+        to="#"
         className="font-semibold text-gray-700 transition-colors hover:text-primary"
       >
         Terms &amp; Conditions
-      </a>
-      <a
-        href="#"
+      </Link>
+      <Link
+        to="#"
         className="font-semibold text-gray-700 transition-colors hover:text-primary"
       >
         Privacy Policy
-      </a>
-      <a
-        href="#"
+      </Link>
+      <Link
+        to="#"
         className="font-semibold text-gray-700 transition-colors hover:text-primary"
       >
         Help &amp; Support
-      </a>
+      </Link>
     </div>
   </div>
 );
@@ -169,8 +172,8 @@ export default function AuthShell({
             </div>
 
             <div className="relative z-10 min-h-0 flex-1 overflow-y-auto overscroll-contain">
-              <div className="flex min-h-full justify-center px-4 py-4 sm:px-6 sm:py-6 lg:px-8 lg:py-8">
-                <div className="my-auto w-full max-w-xl rounded-3xl px-5 py-6 sm:px-7 sm:py-8 lg:px-9 lg:py-9">
+              <div className="flex min-h-full justify-center">
+                <div className="my-auto w-full max-w-xl rounded-3xl px-5 py-6 sm:px-7 sm:py-8 lg:px-9">
                   {children}
                 </div>
               </div>
diff --git a/apps/edr-freight-web/portal/src/components/customer-actions/ContractClearanceAction.tsx b/apps/edr-freight-web/portal/src/components/customer-actions/ContractClearanceAction.tsx
index 58fef65e3..4aa131c23 100644
--- a/apps/edr-freight-web/portal/src/components/customer-actions/ContractClearanceAction.tsx
+++ b/apps/edr-freight-web/portal/src/components/customer-actions/ContractClearanceAction.tsx
@@ -1,7 +1,7 @@
 import { useMemo } from "react";
 import { useQuery } from "@tanstack/react-query";
 import { Button, Modal, Text, type ButtonProps } from "@mantine/core";
-import { AlertCircle, Upload } from "lucide-react";
+import { AlertCircle, Upload, type LucideIcon } from "lucide-react";
 
 import { api } from "@/services/api";
 import { ContractClearancePanel } from "@/pages/contracts/ContractClearancePanel";
@@ -13,6 +13,10 @@ interface ContractClearanceActionProps {
   label?: string;
   size?: ButtonProps["size"];
   urgent?: boolean;
+  /** GL's turn — render as a calm status button, not a call to action. */
+  waiting?: boolean;
+  /** Icon override from the phase-aware action derivation. */
+  icon?: LucideIcon;
 }
 
 export function ContractClearanceAction({
@@ -20,6 +24,8 @@ export function ContractClearanceAction({
   label: labelProp,
   size = "xs",
   urgent = false,
+  waiting = false,
+  icon: iconProp,
 }: ContractClearanceActionProps) {
   const [opened, { open, close }] = useDisclosure(false);
 
@@ -38,7 +44,13 @@ export function ContractClearanceAction({
     return urgent ? "Upload clearance" : "Manage clearance";
   }, [labelProp, clearance, urgent]);
 
-  const Icon = urgent || label.includes("Update") ? AlertCircle : Upload;
+  const Icon =
+    iconProp ?? (urgent || label.includes("Update") ? AlertCircle : Upload);
+
+  // Urgent (customer's turn) = filled orange so it stands out among the green
+  // actions; waiting (GL's turn) = calm subtle gray; default = brand green.
+  const color = urgent ? "orange" : waiting ? "gray" : "edr-green";
+  const variant = waiting ? "light" : "filled";
 
   return (
     <ModalSafeWrapper>
@@ -47,7 +59,8 @@ export function ContractClearanceAction({
         radius="md"
         fw={700}
         fz={13}
-        color="edr-green"
+        color={color}
+        variant={variant}
         leftSection={<Icon size={14} />}
         onClick={(e) => {
           e.stopPropagation();
diff --git a/apps/edr-freight-web/portal/src/components/customer-actions/ContractCustomerAction.tsx b/apps/edr-freight-web/portal/src/components/customer-actions/ContractCustomerAction.tsx
index e91f897b4..9d1b6718e 100644
--- a/apps/edr-freight-web/portal/src/components/customer-actions/ContractCustomerAction.tsx
+++ b/apps/edr-freight-web/portal/src/components/customer-actions/ContractCustomerAction.tsx
@@ -46,6 +46,8 @@ export function ContractCustomerAction({
         label={action.label}
         size={size}
         urgent={action.urgent}
+        waiting={action.waiting}
+        icon={action.icon}
       />
     );
   }
diff --git a/apps/edr-freight-web/portal/src/components/customer-actions/deriveContractCustomerAction.ts b/apps/edr-freight-web/portal/src/components/customer-actions/deriveContractCustomerAction.ts
index 48fb19943..4de7d2545 100644
--- a/apps/edr-freight-web/portal/src/components/customer-actions/deriveContractCustomerAction.ts
+++ b/apps/edr-freight-web/portal/src/components/customer-actions/deriveContractCustomerAction.ts
@@ -4,8 +4,10 @@ import {
   CreditCard,
   Eye,
   FileSignature,
+  Hourglass,
   PackagePlus,
   PencilLine,
+  Receipt,
   RotateCcw,
   Upload,
 } from "lucide-react";
@@ -61,6 +63,8 @@ export type ContractCustomerAction =
       primary: boolean;
       icon: LucideIcon;
       urgent: boolean;
+      /** True when it's GL's turn — render calm/informational, not a call to action. */
+      waiting?: boolean;
     }
   | {
       type: "pay";
@@ -126,14 +130,56 @@ export function deriveContractCustomerAction(
 
   const clr = contractNeedsClearanceAction(contract);
   if (clr.show) {
-    return {
-      type: "clearance",
-      contractId: id,
-      label: clr.urgent ? "Upload clearance" : "Update clearance",
-      primary: true,
-      icon: Upload,
-      urgent: clr.urgent,
-    };
+    // Refine the generic clearance action by the persisted clearance phase so
+    // the button says what the customer actually has to do right now (e.g.
+    // "Pay duty & upload slip" during CUSTOMER_DUTY, not "Update clearance").
+    const phase = contract.clearancePhase ?? null;
+    switch (phase) {
+      case "CUSTOMER_INTAKE":
+        return {
+          type: "clearance",
+          contractId: id,
+          label: "Upload clearance documents",
+          primary: true,
+          icon: Upload,
+          urgent: true,
+        };
+      case "CUSTOMER_DUTY":
+        return {
+          type: "clearance",
+          contractId: id,
+          label: "Pay duty & upload slip",
+          primary: true,
+          icon: Receipt,
+          urgent: true,
+        };
+      case "GL_ET_REVIEW":
+      case "GL_DJ_COLLECTION":
+      case "GL_ET_OUTPUT":
+      case "GL_ET_POST_CLEARANCE":
+      case "GL_DJ_LOADING":
+      case "POST_TRANSIT":
+        // GL's turn — nothing for the customer to do; show a calm status.
+        return {
+          type: "clearance",
+          contractId: id,
+          label: "Clearance in progress",
+          primary: false,
+          icon: Hourglass,
+          urgent: false,
+          waiting: true,
+        };
+      default:
+        // No persisted phase (legacy / early cycles) — keep the status-derived label.
+        return {
+          type: "clearance",
+          contractId: id,
+          label: clr.urgent ? "Upload clearance" : "Update clearance",
+          primary: true,
+          icon: Upload,
+          urgent: clr.urgent,
+        };
+    }
   }
 
   if (
diff --git a/apps/edr-freight-web/portal/src/components/onboarding/ETradeInfo.tsx b/apps/edr-freight-web/portal/src/components/onboarding/ETradeInfo.tsx
index 98efc2613..6c38bba46 100644
--- a/apps/edr-freight-web/portal/src/components/onboarding/ETradeInfo.tsx
+++ b/apps/edr-freight-web/portal/src/components/onboarding/ETradeInfo.tsx
@@ -7,9 +7,11 @@ import {
   Text,
   TextInput,
 } from "@mantine/core";
+import { useEffect, useRef } from "react";
 import type { UseFormRegisterReturn } from "react-hook-form";
-import { AlertCircle, CheckCircle2, Download } from "lucide-react";
+import { AlertCircle, CheckCircle2, Download, Info } from "lucide-react";
 import { useETradeData } from "@/hooks/useETradeData";
+import { extractApiError } from "@/utils/result";
 import type { CompanyRegistrationData } from "@edr/types";
 
 interface ETradeInfoProps {
@@ -22,6 +24,8 @@ interface ETradeInfoProps {
   onDataLoaded: (data: CompanyRegistrationData) => void;
 }
 
+const isValidTin = (tin: string) => tin.length === 10;
+
 export default function ETradeInfo({
   tin,
   register,
@@ -30,53 +34,100 @@ export default function ETradeInfo({
 }: ETradeInfoProps) {
   const mutation = useETradeData();
   const isLoading = mutation.isPending;
-  const hasData = mutation.data;
+  const tinTaken = mutation.data?.tinTaken;
+  const hasData =
+    mutation.data && !mutation.data.tinTaken ? mutation.data : null;
 
   const handleFetch = async () => {
-    if (!tin || tin.length !== 10 || !tin.startsWith("00")) return;
+    if (!isValidTin(tin)) return;
     const result = await mutation.mutateAsync(tin);
-    if (result) {
+    if (result && !result.tinTaken) {
       onDataLoaded(result);
     }
   };
 
-  const errorMessage =
+  // Auto-fetch as soon as the TIN reaches its full 10-digit length — only
+  // once per distinct value, so retyping the same TIN doesn't refetch.
+  const lastFetchedTin = useRef<string | null>(null);
+  useEffect(() => {
+    if (isValidTin(tin) && lastFetchedTin.current !== tin) {
+      lastFetchedTin.current = tin;
+      handleFetch();
+    }
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [tin]);
+
+  const apiError =
     mutation.isError && mutation.error
-      ? (mutation.error as any).message ||
-        "Failed to fetch company information. Please try again."
+      ? extractApiError(mutation.error)
+      : null;
+  // A 400 here means eTrade simply has no record for this TIN — not a
+  // failure. Soft-pedal it as an FYI, not a red error, so filling in
+  // manually doesn't feel like something went wrong.
+  const notFound = apiError?.statusCode === 400;
+  const errorMessage =
+    apiError && !notFound
+      ? apiError.message ||
+        "We couldn't reach eTrade to fetch your company information. Please try again, or fill in the details manually below."
       : null;
 
   return (
     <Stack gap="md">
       <Group align="flex-start" grow>
         <TextInput
-          label={<>TIN Number (10 digits) <span style={{ color: "var(--mantine-color-red-6)" }}>*</span></>}
+          label={
+            <>
+              TIN Number (10 digits){" "}
+              <span style={{ color: "var(--mantine-color-red-6)" }}>*</span>
+            </>
+          }
           placeholder="0012345678"
           maxLength={10}
           error={error}
           {...register}
         />
-        <Button
-          variant="filled"
-          color="edr-green"
-          onClick={handleFetch}
-          disabled={!tin || tin.length !== 10 || !tin.startsWith("00") || isLoading}
-          leftSection={
-            isLoading ? <Loader size={16} /> : <Download size={16} />
-          }
-          mt="24px"
-        >
-          {isLoading ? "Getting..." : "Get Data"}
-        </Button>
+        {errorMessage && (
+          <Button
+            variant="filled"
+            color="edr-green"
+            onClick={handleFetch}
+            disabled={!isValidTin(tin) || isLoading}
+            leftSection={
+              isLoading ? <Loader size={16} /> : <Download size={16} />
+            }
+            mt="24px"
+          >
+            {isLoading ? "Getting..." : "Get Data"}
+          </Button>
+        )}
       </Group>
 
+      {notFound && (
+        <Alert icon={<Info size={16} />} color="gray">
+          We couldn't find a matching business record for this TIN — no
+          problem, just fill in the details below.
+        </Alert>
+      )}
+
       {errorMessage && (
         <Alert
           icon={<AlertCircle size={16} />}
           color="red"
-          title="Failed to fetch data"
+          title="Couldn't fetch eTrade data"
         >
-          {errorMessage} You can still fill in the details manually below.
+          {errorMessage}
+        </Alert>
+      )}
+
+      {tinTaken && (
+        <Alert
+          icon={<AlertCircle size={16} />}
+          color="red"
+          title="TIN already registered"
+        >
+          This TIN is already registered to another company account. Please
+          double-check the number, or contact support if you believe this is a
+          mistake.
         </Alert>
       )}
 
diff --git a/apps/edr-freight-web/portal/src/components/onboarding/RoleLicenseStep.tsx b/apps/edr-freight-web/portal/src/components/onboarding/RoleLicenseStep.tsx
index 451222841..fa1061622 100644
--- a/apps/edr-freight-web/portal/src/components/onboarding/RoleLicenseStep.tsx
+++ b/apps/edr-freight-web/portal/src/components/onboarding/RoleLicenseStep.tsx
@@ -70,6 +70,8 @@ interface RoleLicenseStepProps {
   /** Newly-selected files per profile id (not yet uploaded). */
   value: Record<string, File[]>;
   onChange: (value: Record<string, File[]>) => void;
+  /** "Business license is required" style error, keyed by profile id. */
+  errors?: Record<string, string>;
 }
 
 /**
@@ -82,6 +84,7 @@ export default function RoleLicenseStep({
   profiles,
   value,
   onChange,
+  errors,
 }: RoleLicenseStepProps) {
   const setFiles = (profileId: string, files: File[]) => {
     onChange({ ...value, [profileId]: files });
@@ -123,6 +126,11 @@ export default function RoleLicenseStep({
               file={buildLicenseSetting(profile.id, label)}
               value={{ [LICENSE_FILE_KEY]: selected }}
               uploadedKeys={hasExisting ? [LICENSE_FILE_KEY] : undefined}
+              errors={
+                errors?.[profile.id]
+                  ? { [LICENSE_FILE_KEY]: errors[profile.id] }
+                  : undefined
+              }
               onChange={(v) => {
                 const next = v[LICENSE_FILE_KEY];
                 const files = Array.isArray(next) ? next : next ? [next] : [];
diff --git a/apps/edr-freight-web/portal/src/constants/URLS.ts b/apps/edr-freight-web/portal/src/constants/URLS.ts
index ce2c35c1a..ac00e71a0 100644
--- a/apps/edr-freight-web/portal/src/constants/URLS.ts
+++ b/apps/edr-freight-web/portal/src/constants/URLS.ts
@@ -14,6 +14,7 @@ export const URL_CONSTANTS = {
     SET_PASSWORD: "/api/auth/set-password",
     ME: "/api/auth/me",
     GENERATE_VERIFICATION_CODE: "/users/generate-verification-code",
+    CHECK_AVAILABILITY: "/api/auth/check-availability",
   },
 
   OTP: {
@@ -106,6 +107,9 @@ export const URL_CONSTANTS = {
     CONTRACT_DOWNLOAD: (id: string) => `/api/bookings/${id}/contract`,
     CANCEL: (id: string | number) => `/api/bookings/${id}/cancel`,
     CONFIRM: (id: string | number) => `/api/bookings/${id}/confirm`,
+    CUSTOMER_TRUCKS: (id: string) => `/api/bookings/${id}/customer-trucks`,
+    CUSTOMER_TRUCK: (id: string, assignmentId: string) =>
+      `/api/bookings/${id}/customer-trucks/${assignmentId}`,
   },
 
   CONTRACTS: {
@@ -148,6 +152,8 @@ export const URL_CONSTANTS = {
     AVAILABLE_DAYS: "/api/train-scheduling/available-days",
     AVAILABLE_DAYS_FOR_CARGO: "/api/train-scheduling/available-days-for-cargo",
     MY_BOOKING_WINDOWS: "/api/train-scheduling/my-booking-windows",
+    CONTRACT_BOOKING_WINDOWS: (contractId: string) =>
+      `/api/train-scheduling/contracts/${contractId}/booking-windows`,
   },
 
   PAYMENTS: {
@@ -170,5 +176,6 @@ export const URL_CONSTANTS = {
     BY_ID: (id: string) => `/api/warehouse-fee-invoices/${id}`,
     DOCUMENT: (id: string) => `/api/warehouse-fee-invoices/${id}/document`,
     RECEIPT: (id: string) => `/api/warehouse-fee-invoices/${id}/receipt`,
+    PAY_ONLINE: (id: string) => `/api/warehouse-fee-invoices/${id}/pay-online`,
   },
 };
diff --git a/apps/edr-freight-web/portal/src/pages/MyPortalPage/actions.ts b/apps/edr-freight-web/portal/src/pages/MyPortalPage/actions.ts
index 833aa6ce7..de4b387b1 100644
--- a/apps/edr-freight-web/portal/src/pages/MyPortalPage/actions.ts
+++ b/apps/edr-freight-web/portal/src/pages/MyPortalPage/actions.ts
@@ -6,7 +6,7 @@ import { contractNeedsClearanceAction } from "@/components/customer-actions/deri
 export interface ActionItem {
   id: string;
   /** What the customer must do — drives the icon, label and modal. */
-  kind: "clearance" | "sign" | "book" | "pay";
+  kind: "clearance" | "duty" | "sign" | "book" | "pay";
   /** The contract/booking reference for display. */
   reference: string;
   /** Short human description of the action. */
diff --git a/apps/edr-freight-web/portal/src/pages/MyPortalPage/components/ActionNeededSection.tsx b/apps/edr-freight-web/portal/src/pages/MyPortalPage/components/ActionNeededSection.tsx
index a68a72280..64f320602 100644
--- a/apps/edr-freight-web/portal/src/pages/MyPortalPage/components/ActionNeededSection.tsx
+++ b/apps/edr-freight-web/portal/src/pages/MyPortalPage/components/ActionNeededSection.tsx
@@ -8,6 +8,7 @@ import {
   FilePlus2,
   FileSignature,
   PackagePlus,
+  Receipt,
   Upload,
 } from "lucide-react";
 import type { Freight } from "@edr/types";
@@ -34,6 +35,7 @@ const KIND_META: Record<
   { icon: typeof Upload; label: string; color: string }
 > = {
   clearance: { icon: Upload, label: "Clearance", color: "edr-green" },
+  duty: { icon: Receipt, label: "Duty / tax", color: "orange" },
   sign: { icon: FileSignature, label: "Sign", color: "blue" },
   book: { icon: PackagePlus, label: "Book", color: "violet" },
   pay: { icon: CreditCard, label: "Payment", color: "orange" },
@@ -96,6 +98,19 @@ export function ActionNeededSection({
       const awaiting =
         c.status === "AWAITING_CLEARANCE_DOCUMENTS" ||
         view?.clearanceStatus === "AWAITING_DOCUMENTS";
+      // Duty phase: the customer's task is paying duty/tax and uploading the
+      // slip — a distinct, money action, not a generic document upload.
+      if (view?.phase === "CUSTOMER_DUTY") {
+        out.push({
+          id: `duty-${c.id}`,
+          kind: "duty",
+          reference: c.reference,
+          description: "Duty / tax payment due — pay and upload the slip",
+          targetId: c.id,
+          urgent: true,
+        });
+        return;
+      }
       // Only surface when there's something the customer can do: a query, or the
       // contract is awaiting their (re)upload.
       if (queried === 0 && !awaiting) return;
@@ -162,6 +177,10 @@ export function ActionNeededSection({
       case "clearance":
         setClearanceId(item.targetId);
         break;
+      case "duty":
+        // Duty advice + payment-slip upload live on the contract detail page.
+        navigate(`/contracts/${item.targetId}`);
+        break;
       case "pay":
         setPayItem(item);
         break;
@@ -249,6 +268,8 @@ export function ActionNeededSection({
                 leftSection={
                   item.kind === "clearance" ? (
                     <Upload size={14} />
+                  ) : item.kind === "duty" ? (
+                    <Receipt size={14} />
                   ) : (
                     <FilePlus2 size={14} />
                   )
@@ -256,13 +277,15 @@ export function ActionNeededSection({
               >
                 {item.kind === "pay"
                   ? "Pay now"
-                  : item.kind === "sign"
-                    ? "Sign"
-                    : item.kind === "book"
-                      ? "Book"
-                      : item.urgent
-                        ? "Upload documents"
-                        : "Upload"}
+                  : item.kind === "duty"
+                    ? "Pay duty & upload slip"
+                    : item.kind === "sign"
+                      ? "Sign"
+                      : item.kind === "book"
+                        ? "Book"
+                        : item.urgent
+                          ? "Upload documents"
+                          : "Upload"}
               </Button>
             </Group>
           );
diff --git a/apps/edr-freight-web/portal/src/pages/MyPortalPage/components/UpcomingWindowsSection.tsx b/apps/edr-freight-web/portal/src/pages/MyPortalPage/components/UpcomingWindowsSection.tsx
index fbb704292..6dcece7ef 100644
--- a/apps/edr-freight-web/portal/src/pages/MyPortalPage/components/UpcomingWindowsSection.tsx
+++ b/apps/edr-freight-web/portal/src/pages/MyPortalPage/components/UpcomingWindowsSection.tsx
@@ -1,7 +1,12 @@
-import { Box, Group, Skeleton, Stack, Text } from "@mantine/core";
-import { memo } from "react";
-import { useNavigate } from "react-router-dom";
-import { ArrowRight, CalendarClock } from "lucide-react";
+import { ActionIcon, Box, Group, Skeleton, Stack, Text } from "@mantine/core";
+import { memo, useMemo, useState } from "react";
+import {
+  ArrowRight,
+  CalendarClock,
+  ChevronLeft,
+  ChevronRight,
+} from "lucide-react";
+import { CountdownTimer } from "@edr/ui-common";
 import type { MyBookingWindow } from "@/services/bookings.service";
 import { Card } from "./Card";
 
@@ -43,6 +48,57 @@ function windowLabel(w: MyBookingWindow): string {
   return (w.windowPhase ?? w.bookingWindowStatus).replace(/_/g, " ");
 }
 
+/**
+ * The countdown for whichever phase the window is currently in. Phases run:
+ * pre-window (opens at windowOpensAt) → open (closes at windowClosesAt) →
+ * document review (docReviewEndsAt) → payment (paymentPhaseEndsAt).
+ *
+ * `label` describes the deadline being counted down to; `expiredText` names the
+ * NEXT step so that when a deadline lapses between the 60s refetches the row
+ * announces what comes next ("Booking opening now…", "Review starting…") rather
+ * than the bare word "Expired". Returns null when no phase is timing down.
+ */
+function phaseCountdown(
+  w: MyBookingWindow,
+): { label: string; deadline: string; expiredText: string } | null {
+  switch (w.windowPhase) {
+    case "PRE_WINDOW":
+      if (w.windowOpensAt)
+        return {
+          label: "Booking opens in",
+          deadline: w.windowOpensAt,
+          expiredText: "Booking opening now…",
+        };
+      return null;
+    case "OPEN":
+      if (w.windowClosesAt)
+        return {
+          label: "Window closes in",
+          deadline: w.windowClosesAt,
+          expiredText: "Document review starting…",
+        };
+      return null;
+    case "DOC_REVIEW":
+      if (w.docReviewEndsAt)
+        return {
+          label: "Document review ends in",
+          deadline: w.docReviewEndsAt,
+          expiredText: "Payment starting…",
+        };
+      return null;
+    case "PAYMENT":
+      if (w.paymentPhaseEndsAt)
+        return {
+          label: "Payment due in",
+          deadline: w.paymentPhaseEndsAt,
+          expiredText: "Payment window closing…",
+        };
+      return null;
+    default:
+      return null;
+  }
+}
+
 function Pill({
   children,
   bg,
@@ -117,15 +173,38 @@ interface UpcomingWindowsSectionProps {
 }
 
 /**
- * The customer's upcoming/open booking windows on their active-contract
- * lanes. Import trains open a window on one booking day; export trains open
- * 24h before departure. Hidden entirely when there is nothing to show.
+ * All announced upcoming/open booking windows, shown to every customer
+ * regardless of whether they hold a contract on the lane. Import trains open a
+ * window on one booking day; export trains open 24h before departure. Rows on a
+ * lane the customer has an active contract for carry a "Book now" action;
+ * others route to the contract list. Hidden entirely when nothing is announced.
  */
+/** Rows shown per carousel page. */
+const PER_PAGE = 3;
+
 export const UpcomingWindowsSection = memo(function UpcomingWindowsSection({
   windows,
   isLoading,
 }: UpcomingWindowsSectionProps) {
-  const navigate = useNavigate();
+  const [page, setPage] = useState(0);
+
+  // Open lanes first, then by opening time — the ones the customer can act on
+  // lead the carousel.
+  const sorted = useMemo(
+    () =>
+      [...windows].sort((a, b) => {
+        const openDiff = Number(b.isOpenNow) - Number(a.isOpenNow);
+        if (openDiff !== 0) return openDiff;
+        const at = a.windowOpensAt ? new Date(a.windowOpensAt).getTime() : Infinity;
+        const bt = b.windowOpensAt ? new Date(b.windowOpensAt).getTime() : Infinity;
+        return at - bt;
+      }),
+    [windows],
+  );
+
+  const pageCount = Math.max(1, Math.ceil(sorted.length / PER_PAGE));
+  const safePage = Math.min(page, pageCount - 1);
+  const visible = sorted.slice(safePage * PER_PAGE, safePage * PER_PAGE + PER_PAGE);
 
   // Nothing upcoming — keep the dashboard uncluttered.
   if (!isLoading && windows.length === 0) return null;
@@ -138,20 +217,61 @@ export const UpcomingWindowsSection = memo(function UpcomingWindowsSection({
             Booking Windows
           </Text>
           <Text fz={13} c="edr-muted">
-            Upcoming and open booking windows on your contract lanes
+            Upcoming and open booking windows across all lanes
           </Text>
         </Box>
+
+        {pageCount > 1 ? (
+          <Group gap={8} wrap="nowrap">
+            <ActionIcon
+              variant="default"
+              radius="xl"
+              size="lg"
+              aria-label="Previous windows"
+              disabled={safePage <= 0}
+              onClick={() => setPage((p) => Math.max(0, p - 1))}
+            >
+              <ChevronLeft size={18} />
+            </ActionIcon>
+            <Group gap={5} wrap="nowrap">
+              {Array.from({ length: pageCount }, (_, i) => (
+                <Box
+                  key={i}
+                  onClick={() => setPage(i)}
+                  style={{
+                    width: i === safePage ? 18 : 7,
+                    height: 7,
+                    borderRadius: 999,
+                    cursor: "pointer",
+                    background: i === safePage ? "#0A6F4D" : "#D8E2EB",
+                    transition: "width 200ms ease, background 200ms ease",
+                  }}
+                />
+              ))}
+            </Group>
+            <ActionIcon
+              variant="default"
+              radius="xl"
+              size="lg"
+              aria-label="Next windows"
+              disabled={safePage >= pageCount - 1}
+              onClick={() => setPage((p) => Math.min(pageCount - 1, p + 1))}
+            >
+              <ChevronRight size={18} />
+            </ActionIcon>
+          </Group>
+        ) : null}
       </Group>
 
       {isLoading ? (
         <Stack gap={6}>
-          {[1, 2].map((i) => (
+          {[1, 2, 3].map((i) => (
             <Skeleton key={i} height={60} radius="md" />
           ))}
         </Stack>
       ) : (
-        <Stack gap={10}>
-          {windows.map((w) => (
+        <Stack gap={10} key={safePage}>
+          {visible.map((w) => (
             <Group
               key={`${w.scheduleId}-${w.bookingCycleNo}`}
               justify="space-between"
@@ -162,11 +282,7 @@ export const UpcomingWindowsSection = memo(function UpcomingWindowsSection({
                 borderRadius: 12,
                 border: `1px solid ${w.isOpenNow ? "#CDEBDD" : BORDER}`,
                 backgroundColor: w.isOpenNow ? "#F4FBF7" : undefined,
-                cursor: w.isOpenNow ? "pointer" : "default",
               }}
-              onClick={
-                w.isOpenNow ? () => navigate("/contracts") : undefined
-              }
             >
               <Box style={{ minWidth: 0 }}>
                 <Group gap={6} wrap="nowrap">
@@ -184,8 +300,23 @@ export const UpcomingWindowsSection = memo(function UpcomingWindowsSection({
                     {windowLabel(w)} · Departs {fmtDay(w.departureDate)}
                   </Text>
                 </Group>
+                {(() => {
+                  const cd = phaseCountdown(w);
+                  return cd ? (
+                    <Box mt={4}>
+                      <CountdownTimer
+                        deadline={cd.deadline}
+                        label={cd.label}
+                        expiredText={cd.expiredText}
+                        size="xs"
+                      />
+                    </Box>
+                  ) : null;
+                })()}
               </Box>
 
+              {/* Windows are informational here — booking is done from the
+                  contract page while a window is open, not via a home CTA. */}
               <Group gap={8} wrap="nowrap" style={{ flexShrink: 0 }}>
                 <DirectionBadge direction={w.direction} />
                 <StatusBadge window={w} />
diff --git a/apps/edr-freight-web/portal/src/pages/accounts/CompanyProfileForm.tsx b/apps/edr-freight-web/portal/src/pages/accounts/CompanyProfileForm.tsx
index 85af9bfdd..cc9f81a29 100644
--- a/apps/edr-freight-web/portal/src/pages/accounts/CompanyProfileForm.tsx
+++ b/apps/edr-freight-web/portal/src/pages/accounts/CompanyProfileForm.tsx
@@ -11,7 +11,7 @@ import {
 } from "@mantine/core";
 import { zodResolver } from "@hookform/resolvers/zod";
 import { useQuery } from "@tanstack/react-query";
-import { AlertCircle, ArrowLeft, ArrowRight, UserCheck } from "lucide-react";
+import { AlertCircle, ArrowLeft, ArrowRight } from "lucide-react";
 import { useEffect, useRef, useState } from "react";
 import { useForm } from "react-hook-form";
 
@@ -21,6 +21,7 @@ import type { ProfileResponse, UpdateProfilePayload } from "@/types/profile";
 import type { CompanyRegistrationData } from "@edr/types";
 import { ControlledPhoneField, toEthiopianE164 } from "@/components/PhoneField";
 import { SmartFileInput } from "@edr/ui-common";
+import { getMinFiles } from "@/types/fileUploadSettings";
 import { api } from "@/services/api";
 import RoleLicenseStep, {
   type RoleLicenseProfile,
@@ -279,22 +280,39 @@ export default function CompanyProfileForm({
     });
   };
 
-  /** Fill the General Manager from the eTrade business owner. */
-  const useOwnerAsManager = () => {
-    if (!etradeOwner) return;
-    setValue("generalManagerName", etradeOwner.name);
-    setValue("generalManagerEmail", user.email);
-    setValue("generalManagerPhone", etradeOwner.phone ?? "", {
-      shouldValidate: true,
-    });
-  };
-
   // "Same as …" links. A checked card prefills the target step's fields from the
   // source step and disables them (kept mirrored while linked); unchecking clears
   // them and re-enables editing.
+  const [gmSameAsOwner, setGmSameAsOwner] = useState(false);
   const [contactSameAsGm, setContactSameAsGm] = useState(false);
   const [poaSameAsContact, setPoaSameAsContact] = useState(false);
 
+  // General Manager source: the eTrade-registered business owner when a TIN
+  // lookup found one, otherwise the registering user's own account details.
+  const gmSourceName = etradeOwner?.name ?? user.name?.en ?? "";
+  const gmSourcePhone = etradeOwner
+    ? etradeOwner.phone
+    : toEthiopianE164(user.phoneNumber);
+
+  useEffect(() => {
+    if (!gmSameAsOwner) return;
+    setValue("generalManagerName", gmSourceName, { shouldValidate: true });
+    setValue("generalManagerEmail", user.email ?? "", { shouldValidate: true });
+    setValue("generalManagerPhone", gmSourcePhone ?? "", {
+      shouldValidate: true,
+    });
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [gmSameAsOwner, gmSourceName, gmSourcePhone, user.email]);
+
+  const toggleGmSameAsOwner = (checked: boolean) => {
+    setGmSameAsOwner(checked);
+    if (!checked) {
+      setValue("generalManagerName", "");
+      setValue("generalManagerEmail", "");
+      setValue("generalManagerPhone", "");
+    }
+  };
+
   const gmName = watch("generalManagerName");
   const gmEmail = watch("generalManagerEmail");
   const gmPhone = watch("generalManagerPhone");
@@ -341,6 +359,72 @@ export default function CompanyProfileForm({
 
   const hasDocuments = Boolean(uploadSetting?.fields?.length);
 
+  // Hard verification for the documents step: required company-level
+  // documents and a business license per operational profile must both be
+  // present before the user can continue.
+  const [documentFieldErrors, setDocumentFieldErrors] = useState<
+    Record<string, string>
+  >({});
+  const [licenseFieldErrors, setLicenseFieldErrors] = useState<
+    Record<string, string>
+  >({});
+
+  const validateRequiredDocuments = (): Record<string, string> => {
+    const errs: Record<string, string> = {};
+    for (const field of uploadSetting?.fields ?? []) {
+      const min = getMinFiles(field);
+      if (min <= 0) continue;
+      if ((uploadedDocumentKeys ?? []).includes(field.fileKey)) continue;
+      const v = documentFiles[field.fileKey];
+      const count = Array.isArray(v) ? v.length : v ? 1 : 0;
+      if (count < min) {
+        errs[field.fileKey] = `${field.fileLabel} is required`;
+      }
+    }
+    return errs;
+  };
+
+  // Every role needs at least one license file (existing or newly selected).
+  const validateLicenses = (): Record<string, string> => {
+    const errs: Record<string, string> = {};
+    for (const p of roleProfiles ?? []) {
+      const hasNew = (licenseFiles?.[p.id]?.length ?? 0) > 0;
+      const hasExisting = p.existingFiles.length > 0;
+      if (!hasNew && !hasExisting) {
+        errs[p.id] = "Business license is required";
+      }
+    }
+    return errs;
+  };
+
+  const handleDocumentFilesChange = (
+    next: Record<string, File | File[] | null>,
+  ) => {
+    setDocumentFiles(next);
+    setDocumentFieldErrors((prev) => {
+      if (Object.keys(prev).length === 0) return prev;
+      const updated = { ...prev };
+      for (const key of Object.keys(updated)) {
+        const v = next[key];
+        const hasValue = Array.isArray(v) ? v.length > 0 : v != null;
+        if (hasValue) delete updated[key];
+      }
+      return updated;
+    });
+  };
+
+  const handleLicenseFilesChange = (next: Record<string, File[]>) => {
+    onLicenseChange?.(next);
+    setLicenseFieldErrors((prev) => {
+      if (Object.keys(prev).length === 0) return prev;
+      const updated = { ...prev };
+      for (const id of Object.keys(updated)) {
+        if ((next[id]?.length ?? 0) > 0) delete updated[id];
+      }
+      return updated;
+    });
+  };
+
   // The registration/license details come straight from the eTrade lookup and
   // are not user-editable — shown as a read-only confirmation once a TIN lookup
   // (or rehydration) has filled them in. The address fields below are separate:
@@ -385,18 +469,21 @@ export default function CompanyProfileForm({
     }
   };
 
-  // Every role needs at least one license file (existing or newly selected).
-  const licenseComplete = (roleProfiles ?? []).every(
-    (p) =>
-      (licenseFiles?.[p.id]?.length ?? 0) > 0 || p.existingFiles.length > 0,
-  );
-
   const nextStep = async () => {
     userNavigatedRef.current = true;
-    // The documents step auto-uploads whatever the user selected as they
-    // continue (partial uploads are allowed — required-doc completeness is
-    // re-checked on resume). A failed upload holds them on the step.
+    // The documents step hard-blocks on required company documents and a
+    // business license per operational profile before it auto-uploads and
+    // submits — no partial-completion path forward.
     if (step === "documents") {
+      const docErrors = validateRequiredDocuments();
+      const licenseErrors = validateLicenses();
+      if (Object.keys(docErrors).length > 0 || Object.keys(licenseErrors).length > 0) {
+        setDocumentFieldErrors(docErrors);
+        setLicenseFieldErrors(licenseErrors);
+        setSaveError("Please upload all required documents before continuing.");
+        return;
+      }
+
       if (onUploadDocuments) {
         setSaving(true);
         try {
@@ -410,12 +497,6 @@ export default function CompanyProfileForm({
         }
       }
 
-      if (!licenseComplete) {
-        setSaveError(
-          "Please upload a business license for each of your operational profiles.",
-        );
-        return;
-      }
       setSaveError(null);
       handleSubmit((data) => onSubmit(buildPayload(data, user)))();
       return;
@@ -450,8 +531,6 @@ export default function CompanyProfileForm({
                 onDataLoaded={handleETradeDataLoaded}
               />
 
-              <Divider my="sm" />
-
               <TextInput
                 label="Company Name"
                 placeholder="Global Logistics Ltd"
@@ -507,7 +586,7 @@ export default function CompanyProfileForm({
                       from eTrade · read-only
                     </Text>
                   </Group>
-                  <SimpleGrid cols={2} spacing="md">
+                  <SimpleGrid cols={2} spacing="sm">
                     <ReadOnlyField
                       label="License Number"
                       value={watch("licenceNumber")}
@@ -586,22 +665,19 @@ export default function CompanyProfileForm({
 
           {step === "personnel" && (
             <>
-              <Group justify="space-between" align="center">
-                <Text fw={600} size="sm" c="edr-text">
-                  General Manager
-                </Text>
-                {etradeOwner && (
-                  <Button
-                    variant="light"
-                    color="edr-green"
-                    size="xs"
-                    leftSection={<UserCheck size={14} />}
-                    onClick={useOwnerAsManager}
-                  >
-                    Use owner as manager
-                  </Button>
-                )}
-              </Group>
+              <Text fw={600} size="sm" c="edr-text">
+                General Manager
+              </Text>
+              <LinkCheckboxCard
+                checked={gmSameAsOwner}
+                onToggle={toggleGmSameAsOwner}
+                title="Same as business owner"
+                description={
+                  etradeOwner
+                    ? "Reuse the eTrade-registered owner's name and phone (email from your account). Uncheck to enter different details."
+                    : "Reuse your account's name, email and phone. Uncheck to enter different details."
+                }
+              />
               <TextInput
                 label="Name"
                 placeholder="Abebe Bikila"
@@ -737,15 +813,17 @@ export default function CompanyProfileForm({
                   file={uploadSetting}
                   value={documentFiles}
                   uploadedKeys={uploadedDocumentKeys}
+                  errors={documentFieldErrors}
                   containerClassName="lg:grid grid-cols-2 items-stretch"
-                  onChange={setDocumentFiles}
+                  onChange={handleDocumentFilesChange}
                 />
               )}
 
               <RoleLicenseStep
                 profiles={roleProfiles ?? []}
                 value={licenseFiles ?? {}}
-                onChange={onLicenseChange ?? (() => { })}
+                onChange={handleLicenseFilesChange}
+                errors={licenseFieldErrors}
               />
             </>
           )}
diff --git a/apps/edr-freight-web/portal/src/pages/accounts/LoginPage.tsx b/apps/edr-freight-web/portal/src/pages/accounts/LoginPage.tsx
index bdd10871b..885888a05 100644
--- a/apps/edr-freight-web/portal/src/pages/accounts/LoginPage.tsx
+++ b/apps/edr-freight-web/portal/src/pages/accounts/LoginPage.tsx
@@ -1,9 +1,11 @@
 import { type FormEvent, useState } from "react";
-import { Eye, EyeOff } from "lucide-react";
-import { useLocation, useNavigate } from "react-router-dom";
+import { Alert, Button, PasswordInput, Stack, TextInput } from "@mantine/core";
+import { AlertCircle } from "lucide-react";
+import { Link, useLocation, useNavigate } from "react-router-dom";
 
 import useAuth from "@/hooks/useAuth";
-import AuthShell, { fieldClass, primaryButtonClass } from "@/components/auth/AuthShell";
+import AuthShell from "@/components/auth/AuthShell";
+import { extractApiError } from "@/utils/result";
 
 const EDR_LOGO = "/assets/edr-logo.png";
 
@@ -24,7 +26,6 @@ export default function LoginPage() {
   const { login } = useAuth();
   const [identifier, setIdentifier] = useState("");
   const [password, setPassword] = useState("");
-  const [showPassword, setShowPassword] = useState(false);
   const [error, setError] = useState<string | null>(null);
   const [loading, setLoading] = useState(false);
 
@@ -41,8 +42,8 @@ export default function LoginPage() {
       } else {
         setError(result.error.message);
       }
-    } catch {
-      setError("An unexpected error occurred");
+    } catch (err) {
+      setError(extractApiError(err).message);
     } finally {
       setLoading(false);
     }
@@ -64,60 +65,45 @@ export default function LoginPage() {
           </p>
         </div>
 
-        <div className="flex w-full flex-col gap-4">
-          <div className="space-y-1.5">
-            <label className="text-sm font-medium text-gray-800">
-              Email or Phone <span className="text-red-500">*</span>
-            </label>
-            <input
-              type="text"
-              value={identifier}
-              onChange={(event) => setIdentifier(event.target.value)}
-              placeholder="name@company.com or 09XXXXXXXX"
+        <Stack gap="md">
+          <TextInput
+            label="Email or Phone"
+            placeholder="name@company.com or 09XXXXXXXX"
+            autoComplete="username"
+            required
+            disabled={loading}
+            value={identifier}
+            onChange={(event) => setIdentifier(event.target.value)}
+          />
+
+          <div>
+            <div className="mb-1.5 flex items-center justify-between">
+              <span className="text-sm font-medium text-gray-800">Password</span>
+              <Link
+                to="#"
+                className="text-xs font-semibold text-primary hover:underline"
+              >
+                Forgot password?
+              </Link>
+            </div>
+            <PasswordInput
+              placeholder="Enter your password"
+              required
               disabled={loading}
-              autoComplete="username"
-              className={fieldClass}
+              value={password}
+              onChange={(event) => setPassword(event.target.value)}
             />
           </div>
 
-          <div className="space-y-1.5">
-            <div className="flex items-center justify-between">
-              <label className="text-sm font-medium text-gray-800">
-                Password <span className="text-red-500">*</span>
-              </label>
-              <a href="#" className="text-xs font-semibold text-primary hover:underline">
-                Forgot password?
-              </a>
-            </div>
-            <div className="relative">
-              <input
-                type={showPassword ? "text" : "password"}
-                value={password}
-                onChange={(event) => setPassword(event.target.value)}
-                placeholder="Enter your password"
-                disabled={loading}
-                className={`${fieldClass} pr-11`}
-              />
-              <button
-                type="button"
-                onClick={() => setShowPassword((current) => !current)}
-                className="absolute right-3 top-1/2 -translate-y-1/2 text-gray-400 transition-colors hover:text-gray-600"
-                aria-label={showPassword ? "Hide password" : "Show password"}
-              >
-                {showPassword ? <EyeOff className="h-5 w-5" /> : <Eye className="h-5 w-5" />}
-              </button>
-            </div>
-          </div>
-
           {error ? (
-            <div className="rounded-lg border border-red-200 bg-red-50 px-3 py-2.5 text-sm text-red-700">
+            <Alert color="red" variant="light" icon={<AlertCircle size={18} />}>
               {error}
-            </div>
+            </Alert>
           ) : null}
 
-          <button type="submit" disabled={loading} className={primaryButtonClass}>
-            {loading ? "Signing in..." : "Sign In"}
-          </button>
+          <Button type="submit" color="edr-green" fullWidth loading={loading}>
+            Sign In
+          </Button>
 
           <p className="text-center text-sm text-gray-500">
             Don&apos;t have an account?{" "}
@@ -129,7 +115,7 @@ export default function LoginPage() {
               Create an account
             </button>
           </p>
-        </div>
+        </Stack>
       </form>
     </AuthShell>
   );
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 50320f699..1b13f7cfc 100644
--- a/apps/edr-freight-web/portal/src/pages/accounts/SignupPage.tsx
+++ b/apps/edr-freight-web/portal/src/pages/accounts/SignupPage.tsx
@@ -34,14 +34,15 @@ import { ControlledPhoneField, isValidPhone } from "@/components/PhoneField";
 import { api } from "@/services/api";
 import { extractApiError } from "@/utils/result";
 
-const EDR_LOGO = "/assets/edr-logo.png";
-
 const passwordRequirements = [
   { label: "At least 8 characters", test: (v: string) => v.length >= 8 },
   { label: "One uppercase letter", test: (v: string) => /[A-Z]/.test(v) },
   { label: "One lowercase letter", test: (v: string) => /[a-z]/.test(v) },
   { label: "One number", test: (v: string) => /\d/.test(v) },
-  { label: "One special character", test: (v: string) => /[^A-Za-z0-9]/.test(v) },
+  {
+    label: "One special character",
+    test: (v: string) => /[^A-Za-z0-9]/.test(v),
+  },
 ] as const;
 
 const userSchema = z
@@ -52,8 +53,14 @@ const userSchema = z
       .min(1, "Phone number is required")
       .refine(isValidPhone, "Enter a valid phone number"),
     userType: z.string(),
-    firstName: z.object({ en: z.string().min(2, "Name is required"), am: z.string().nullable() }),
-    lastName: z.object({ en: z.string().min(2, "Name is required"), am: z.string().nullable() }),
+    firstName: z.object({
+      en: z.string().min(2, "Name is required"),
+      am: z.string().nullable(),
+    }),
+    lastName: z.object({
+      en: z.string().min(2, "Name is required"),
+      am: z.string().nullable(),
+    }),
     password: z
       .string()
       .min(8, "Password must be at least 8 characters")
@@ -132,12 +139,30 @@ export default function SignupPage() {
 
   const passwordValue = watch("password") ?? "";
 
-  // Step 1 — form is valid: send a fresh code to the chosen channel, then
-  // move to the OTP challenge.
+  // Step 1 — form is valid: make sure the email/phone aren't already
+  // registered, then send a fresh code to the chosen channel and move to
+  // the OTP challenge.
   const requestOtp = async (data: FormData) => {
     setError(null);
     setSending(true);
     try {
+      const availability = await api.auth.checkAvailability.call({
+        email: data.email,
+        phone: data.phone,
+      });
+      if (availability.emailTaken && availability.phoneTaken) {
+        setError("An account with this email and phone number already exists.");
+        return;
+      }
+      if (availability.emailTaken) {
+        setError("An account with this email already exists.");
+        return;
+      }
+      if (availability.phoneTaken) {
+        setError("An account with this phone number already exists.");
+        return;
+      }
+
       await api.auth.sendOTP.call(
         channel === "email" ? { email: data.email } : { phone: data.phone },
       );
@@ -217,242 +242,270 @@ export default function SignupPage() {
 
   return (
     <AuthShell
-      tagline="Smart Freight Operations"
-      taglineBody="Join EDR Freight to manage shipments, track consignments, and streamline logistics workflows across Ethiopia and Djibouti."
+      tagline= "Smart Freight Operations"
+  taglineBody = "Join EDR Freight to manage shipments, track consignments, and streamline logistics workflows across Ethiopia and Djibouti."
     >
-      <div className="flex w-full flex-col">
-        <div className="mb-4 flex justify-center sm:mb-6">
-          <img src={EDR_LOGO} alt="EDR Freight" className="h-9 w-auto sm:h-11" />
-        </div>
-
-        {stage === "form" ? (
-          <form onSubmit={handleSubmit(requestOtp)} className="flex w-full flex-col">
-            <div className="mb-4 space-y-1.5 text-center sm:mb-5">
-              <h1 className="text-xl font-bold tracking-tight text-gray-900 sm:text-2xl">
-                Create account
-              </h1>
-              <p className="text-sm leading-relaxed text-gray-500">
-                Register to access EDR Freight services.
+    <div className="flex w-full flex-col" >
+      { stage === "form" ? (
+        <form
+            onSubmit= { handleSubmit(requestOtp) }
+            className = "flex w-full flex-col"
+    >
+    <div className="mb-4 space-y-1.5 text-center sm:mb-5" >
+      <h1 className="text-xl font-bold tracking-tight text-gray-900 sm:text-2xl" >
+        Create account
+          </h1>
+          < p className = "text-sm leading-relaxed text-gray-500" >
+            Register to access EDR Freight services.
               </p>
-            </div>
+              </div>
 
-            <Stack gap="md">
-              <SimpleGrid cols={{ base: 1, sm: 2 }} spacing="md">
-                <TextInput
+              < Stack gap = "sm" >
+                <SimpleGrid cols={ { base: 1, sm: 2 } } spacing = "md" >
+                  <TextInput
                   label="First name"
-                  placeholder="John"
-                  required
-                  disabled={sending}
-                  error={errors.firstName?.en?.message}
-                  {...register("firstName.en")}
+  placeholder = "John"
+  required
+  disabled = { sending }
+  error = { errors.firstName?.en?.message }
+  {...register("firstName.en") }
                 />
-                <TextInput
-                  label="Last name"
-                  placeholder="Doe"
-                  required
-                  disabled={sending}
-                  error={errors.lastName?.en?.message}
-                  {...register("lastName.en")}
+    < TextInput
+  label = "Last name"
+  placeholder = "Doe"
+  required
+  disabled = { sending }
+  error = { errors.lastName?.en?.message }
+  {...register("lastName.en") }
                 />
-              </SimpleGrid>
+    </SimpleGrid>
 
-              <TextInput
-                label="Email"
-                type="email"
-                placeholder="john@example.com"
-                required
-                disabled={sending}
-                error={errors.email?.message}
-                {...register("email")}
+    < TextInput
+  label = "Email"
+  type = "email"
+  placeholder = "john@example.com"
+  required
+  disabled = { sending }
+  error = { errors.email?.message }
+  {...register("email") }
               />
 
-              <ControlledPhoneField
-                control={control}
-                name="phone"
-                label="Phone"
-                required
-                disabled={sending}
-              />
+    < ControlledPhoneField
+  control = { control }
+  name = "phone"
+  label = "Phone"
+  required
+  disabled = { sending }
+    />
 
-              <div className="space-y-1.5">
-                <Text size="sm" fw={500} c="edr-text">
-                  Send verification code via
-                </Text>
-                <SegmentedControl
-                  fullWidth
-                  disabled={sending}
-                  value={channel}
-                  onChange={(v) => setChannel(v as OtpChannel)}
-                  data={[
-                    {
-                      value: "phone",
-                      label: (
-                        <span className="flex items-center justify-center gap-1.5">
-                          <Smartphone size={14} /> Phone
-                        </span>
+    <div className="space-y-1.5" >
+      <Text size="sm" fw = { 500} c = "edr-text" >
+        Send verification code via
+          </Text>
+          < SegmentedControl
+  fullWidth
+  disabled = { sending }
+  value = { channel }
+  onChange = {(v) => setChannel(v as OtpChannel)
+}
+data = {
+  [
+  {
+    value: "phone",
+    label: (
+      <span className= "flex items-center justify-center gap-1.5" >
+      <Smartphone size={ 14} /> Phone
+  </span>
                       ),
-                    },
-                    {
-                      value: "email",
-                      label: (
-                        <span className="flex items-center justify-center gap-1.5">
-                          <Mail size={14} /> Email
-                        </span>
+},
+{
+  value: "email",
+  label: (
+    <span className= "flex items-center justify-center gap-1.5" >
+    <Mail size={ 14 } /> Email
+      </span>
                       ),
                     },
                   ]}
                 />
-              </div>
+  </div>
 
-              <div>
-                <PasswordInput
+  < div >
+  <PasswordInput
                   label="Password"
-                  placeholder="Create a strong password"
-                  required
-                  disabled={sending}
-                  error={errors.password?.message}
-                  {...register("password")}
+placeholder = "Create a strong password"
+required
+disabled = { sending }
+error = { errors.password?.message }
+{...register("password") }
                 />
-                {passwordValue.length > 0 ? (
-                  <div className="mt-2 space-y-1">
-                    {passwordRequirements.map((req) => {
-                      const met = req.test(passwordValue);
-                      return (
-                        <div key={req.label} className="flex items-center gap-2">
-                          <span
-                            className={`flex h-4 w-4 shrink-0 items-center justify-center rounded-full ${
-                              met ? "bg-primary text-primary-foreground" : "bg-gray-200 text-gray-500"
-                            }`}
+{
+  passwordValue.length > 0 ? (
+    <div className= "mt-2 space-y-1" >
+    {
+      passwordRequirements.map((req) => {
+        const met = req.test(passwordValue);
+        return (
+          <div
+                          key= { req.label }
+        className = "flex items-center gap-2"
+          >
+          <span
+                            className={
+          `flex h-4 w-4 shrink-0 items-center justify-center rounded-full ${met
+            ? "bg-primary text-primary-foreground"
+            : "bg-gray-200 text-gray-500"
+          }`
+        }
                           >
-                            {met ? <Check className="h-2.5 w-2.5" /> : <X className="h-2.5 w-2.5" />}
-                          </span>
-                          <span className={`text-xs ${met ? "text-primary" : "text-gray-500"}`}>
-                            {req.label}
-                          </span>
-                        </div>
+          {
+            met?(
+                              <Check className = "h-2.5 w-2.5" />
+                            ): (
+                <X className = "h-2.5 w-2.5" />
+                            )
+    }
+    </span>
+    < span
+                            className = {`text-xs ${met ? "text-primary" : "text-gray-500"}`
+}
+                          >
+  { req.label }
+  </span>
+  </div>
                       );
                     })}
-                  </div>
+</div>
                 ) : null}
-              </div>
+</div>
 
-              <PasswordInput
-                label="Confirm password"
-                placeholder="Re-enter your password"
-                required
-                disabled={sending}
-                error={errors.confirmPassword?.message}
-                {...register("confirmPassword")}
+  < PasswordInput
+label = "Confirm password"
+placeholder = "Re-enter your password"
+required
+disabled = { sending }
+error = { errors.confirmPassword?.message }
+{...register("confirmPassword") }
               />
 
-              {error ? (
-                <Alert color="red" variant="light" icon={<AlertCircle size={18} />}>
-                  {error}
-                </Alert>
+{
+  error ? (
+    <Alert
+                  color= "red"
+                  variant = "light"
+  icon = {< AlertCircle size = { 18} />}
+                >
+  { error }
+  </Alert>
               ) : null}
 
-              <Button
+<Button
                 type="submit"
-                color="edr-green"
-                fullWidth
-                loading={sending}
-                rightSection={!sending ? <ArrowRight size={16} /> : undefined}
+color = "edr-green"
+fullWidth
+loading = { sending }
+rightSection = {!sending ? <ArrowRight size={ 16 } /> : undefined}
               >
-                Continue
-              </Button>
+  Continue
+  </Button>
 
-              <p className="text-center text-sm text-gray-500">
-                Already have an account?{" "}
-                <button
-                  type="button"
-                  onClick={() => navigate("/login")}
-                  className="font-semibold text-primary hover:underline"
-                >
-                  Sign In
-                </button>
-              </p>
-            </Stack>
-          </form>
+  < p className = "text-center text-sm text-gray-500" >
+    Already have an account ? { " "}
+      < button
+                  type = "button"
+onClick = {() => navigate("/login")}
+className = "font-semibold text-primary hover:underline"
+  >
+  Sign In
+    </button>
+    </p>
+    </Stack>
+    </form>
         ) : (
-          <Stack gap="md">
-            <div className="mb-1 flex justify-center">
-              <span className="flex h-12 w-12 items-center justify-center rounded-full bg-primary/10 text-primary">
-                <ShieldCheck size={22} />
-              </span>
-            </div>
-            <div className="space-y-1.5 text-center">
-              <h1 className="text-xl font-bold tracking-tight text-gray-900 sm:text-2xl">
-                Verify your {otpChannel === "email" ? "email" : "phone"}
-              </h1>
-              <p className="text-sm leading-relaxed text-gray-500">
-                We sent a 6-digit code to{" "}
-                <span className="font-medium text-gray-700">
-                  {otpChannel === "email"
-                    ? maskEmail(pendingData?.email ?? "")
-                    : maskPhone(pendingData?.phone ?? "")}
-                </span>
-                . Enter it to finish creating your account.
+  <Stack gap= "md" >
+  <div className="mb-1 flex justify-center" >
+    <span className="flex h-12 w-12 items-center justify-center rounded-full bg-primary/10 text-primary" >
+      <ShieldCheck size={ 22 } />
+        </span>
+        </div>
+        < div className = "space-y-1.5 text-center" >
+          <h1 className="text-xl font-bold tracking-tight text-gray-900 sm:text-2xl" >
+            Verify your { otpChannel === "email" ? "email" : "phone" }
+</h1>
+  < p className = "text-sm leading-relaxed text-gray-500" >
+    We sent a 6 - digit code to{ " " }
+<span className="font-medium text-gray-700" >
+  { otpChannel === "email"
+  ? maskEmail(pendingData?.email ?? "")
+  : maskPhone(pendingData?.phone ?? "")}
+</span>
+  .Enter it to finish creating your account.
               </p>
-            </div>
+    </div>
 
-            {otpError ? (
-              <Alert color="red" variant="light" icon={<AlertCircle size={18} />}>
-                {otpError}
-              </Alert>
+{
+  otpError ? (
+    <Alert
+                color= "red"
+                variant = "light"
+  icon = {< AlertCircle size = { 18} />}
+              >
+  { otpError }
+  </Alert>
             ) : null}
 
-            <Stack gap={6} align="center">
-              <Text size="sm" fw={500} c="edr-text">
-                Verification code
-              </Text>
-              <PinInput
-                length={6}
-                type="number"
-                oneTimeCode
-                value={otpCode}
-                placeholder="0"
-                disabled={verifying}
-                styles={{ input: { textAlign: "center" } }}
-                onChange={setOtpCode}
-              />
-            </Stack>
+<Stack gap={ 6 } align = "center" >
+  <Text size="sm" fw = { 500} c = "edr-text" >
+    Verification code
+      </Text>
+      < PinInput
+length = { 6}
+type = "number"
+oneTimeCode
+value = { otpCode }
+placeholder = "0"
+disabled = { verifying }
+styles = {{ input: { textAlign: "center" } }}
+onChange = { setOtpCode }
+  />
+  </Stack>
 
-            <Button
-              color="edr-green"
-              fullWidth
-              loading={verifying}
-              disabled={verifying || otpCode.trim().length !== 6}
-              onClick={confirmOtp}
-            >
-              Verify &amp; create account
-            </Button>
+  < Button
+color = "edr-green"
+fullWidth
+loading = { verifying }
+disabled = { verifying || otpCode.trim().length !== 6}
+onClick = { confirmOtp }
+  >
+  Verify & amp; create account
+    </Button>
 
-            <div className="flex items-center justify-between">
-              <Button
+    < div className = "flex items-center justify-between" >
+      <Button
                 variant="subtle"
-                color="gray"
-                leftSection={<ArrowLeft size={14} />}
-                disabled={sending || verifying}
-                onClick={() => {
-                  setStage("form");
-                  setOtpError(null);
-                }}
+color = "gray"
+leftSection = {< ArrowLeft size = { 14} />}
+disabled = { sending || verifying}
+onClick = {() => {
+  setStage("form");
+  setOtpError(null);
+}}
               >
-                Back
-              </Button>
-              <Button
-                variant="subtle"
-                color="edr-green"
-                leftSection={<RotateCw size={14} />}
-                disabled={resendIn > 0 || sending || verifying}
-                onClick={resendOtp}
-              >
-                {resendIn > 0 ? `Resend in ${resendIn}s` : "Resend code"}
-              </Button>
-            </div>
-          </Stack>
+  Back
+  </Button>
+  < Button
+variant = "subtle"
+color = "edr-green"
+leftSection = {< RotateCw size = { 14} />}
+disabled = { resendIn > 0 || sending || verifying}
+onClick = { resendOtp }
+  >
+  { resendIn > 0 ? `Resend in ${resendIn}s` : "Resend code"}
+</Button>
+  </div>
+  </Stack>
         )}
-      </div>
-    </AuthShell>
+</div>
+  </AuthShell>
   );
 }
diff --git a/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/ReadonlyBookingView.tsx b/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/ReadonlyBookingView.tsx
index f0f75f537..6d274f22f 100644
--- a/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/ReadonlyBookingView.tsx
+++ b/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/ReadonlyBookingView.tsx
@@ -1,12 +1,10 @@
-import { Box, Group, Text } from "@mantine/core";
+import { Group } from "@mantine/core";
 import { useMutation, useQuery } from "@tanstack/react-query";
-import { CreditCard, Download, Eye } from "lucide-react";
+import { CreditCard } from "lucide-react";
 import { useState } from "react";
 import { useNavigate } from "react-router-dom";
-import { isViewable } from "@edr/ui-common";
 
 import { api } from "@/services/api";
-import { fileViewUrl } from "@/constants/apiConfig";
 import { useFileViewer } from "@/hooks/useFileViewer";
 import { invoicesService } from "@/services/invoices.service";
 import { paymentsService, type PaymentMethod } from "@/services/payments.service";
@@ -19,9 +17,8 @@ import { ClearanceCard } from "./components/ClearanceCard";
 import { ContainersCard } from "./components/ContainersCard";
 import { ContractCard } from "./components/ContractCard";
 import { CustomerTruckAssignmentCard } from "./components/CustomerTruckAssignmentCard";
-import { DocRow, IconSquare } from "./components/Documents";
 import { KeyFactsStrip } from "./components/KeyFactsStrip";
-import { BodyGrid, CardTitle, PageShell, SectionCard } from "./components/layout";
+import { BodyGrid, PageShell } from "./components/layout";
 import {
   CancelledBanner,
   ConsolidationPairedNotice,
@@ -51,7 +48,7 @@ export function ReadonlyBookingView({
   useScrollToHash();
   const status = booking.status as string;
   const [payModalOpen, setPayModalOpen] = useState(false);
-  const { view, viewer } = useFileViewer();
+  const { viewer } = useFileViewer();
 
   // Re-book opens the New Shipment Booking form for the same contract, not the
   // New Contract page. Fall back to /contracts/new only if the link is missing.
@@ -160,7 +157,6 @@ export function ReadonlyBookingView({
           )
         }
         menuActions={{
-          onViewContract: booking.signedByCeoAt ? () => {} : undefined,
           onRebook,
           onSupport: () => navigate("/support"),
         }}
@@ -199,7 +195,7 @@ export function ReadonlyBookingView({
 
       <KeyFactsStrip booking={booking} />
 
-      <ContractCard booking={booking} navigate={navigate} />
+      <ContractCard booking={booking} />
 
       {isClearance && <ClearanceCard booking={booking} />}
 
@@ -220,52 +216,6 @@ export function ReadonlyBookingView({
             )}
             <WarehousePaymentsSection bookingId={booking.id} />
 
-            {booking.files && booking.files.length > 0 && (
-              <SectionCard>
-                <Group justify="space-between" align="center" mb="md">
-                  <CardTitle>Documents</CardTitle>
-                  <Text fz="12.5px" fw={600} c="#9AA8B5">
-                    {booking.files.length} files
-                  </Text>
-                </Group>
-                <Box>
-                  {booking.files.map((file, i) => (
-                    <DocRow
-                      key={file.id}
-                      last={i === booking.files!.length - 1}
-                      title={file.name}
-                      meta={file.code.replace(/_/g, " ")}
-                      status="verified"
-                      action={
-                        <Group gap={6} wrap="nowrap">
-                          {isViewable({
-                            name: file.name,
-                            url: fileViewUrl(file.id),
-                            mimeType: file.mimeType,
-                          }) && (
-                            <IconSquare
-                              icon={<Eye size={16} />}
-                              onClick={() =>
-                                view({
-                                  name: file.name,
-                                  url: fileViewUrl(file.id),
-                                  mimeType: file.mimeType,
-                                })
-                              }
-                            />
-                          )}
-                          <IconSquare
-                            href={fileViewUrl(file.id, true)}
-                            icon={<Download size={16} />}
-                          />
-                        </Group>
-                      }
-                    />
-                  ))}
-                </Box>
-              </SectionCard>
-            )}
-
             <ActivityCard booking={booking} />
           </>
         }
diff --git a/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/components/ContractCard.tsx b/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/components/ContractCard.tsx
index f56e07349..083e4de26 100644
--- a/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/components/ContractCard.tsx
+++ b/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/components/ContractCard.tsx
@@ -1,6 +1,4 @@
-import { Box, Button, Group, Paper, Text } from "@mantine/core";
-import { FileSignature } from "lucide-react";
-import type { useNavigate } from "react-router-dom";
+import { Box, Group, Paper, Text } from "@mantine/core";
 
 import type { Freight } from "@edr/types";
 
@@ -37,13 +35,7 @@ const CONTRACT_CONFIG: Record<
   },
 };
 
-export function ContractCard({
-  booking,
-  navigate,
-}: {
-  booking: Freight.IBooking;
-  navigate: ReturnType<typeof useNavigate>;
-}) {
+export function ContractCard({ booking }: { booking: Freight.IBooking }) {
   const c = CONTRACT_CONFIG[booking.status as string];
   if (!c) return null;
 
@@ -76,20 +68,6 @@ export function ContractCard({
             {c.description}
           </Text>
         </Box>
-        {c.buttonLabel && (
-          <Button
-            onClick={() => navigate(`/bookings/${booking.id}/contract`)}
-            radius={10}
-            color="edr-green"
-            leftSection={<FileSignature size={18} />}
-            styles={{
-              root: { height: 42, paddingInline: 18 },
-              label: { fontSize: 13, fontWeight: 700 },
-            }}
-          >
-            {c.buttonLabel}
-          </Button>
-        )}
       </Group>
     </Paper>
   );
diff --git a/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/components/CustomerTruckAssignmentCard.tsx b/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/components/CustomerTruckAssignmentCard.tsx
index 37e65ab2b..65af584d3 100644
--- a/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/components/CustomerTruckAssignmentCard.tsx
+++ b/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/components/CustomerTruckAssignmentCard.tsx
@@ -1,15 +1,30 @@
-import { Alert, Button, Group, Select, SimpleGrid, Stack, Text, TextInput } from "@mantine/core";
-import { useMutation } from "@tanstack/react-query";
+import {
+  ActionIcon,
+  Alert,
+  Badge,
+  Button,
+  Divider,
+  Group,
+  Loader,
+  MultiSelect,
+  Select,
+  SimpleGrid,
+  Stack,
+  Text,
+  TextInput,
+} from "@mantine/core";
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
 import type { Freight } from "@edr/types";
-import { Download, Lock, Truck } from "lucide-react";
+import { CheckCircle2, Clock, Download, Plus, Trash2, Truck } from "lucide-react";
 import { useState } from "react";
+import toast from "react-hot-toast";
 
 import { api } from "@/services/api";
+import { customerTrucksService } from "@/services/customer-trucks.service";
 
 import { CardTitle, SectionCard } from "./layout";
 
 const TRUCK_TYPES = ["Flatbed", "Container Chassis", "Lowboy", "Box Truck", "Tipper"];
-const ISO_CONTAINER_PATTERN = /^[A-Z]{4}\d{7}$/;
 
 const downloadBlob = (blob: Blob, filename: string) => {
   const url = URL.createObjectURL(blob);
@@ -22,6 +37,13 @@ const downloadBlob = (blob: Blob, filename: string) => {
   URL.revokeObjectURL(url);
 };
 
+const errorMessage = (error: unknown, fallback: string) => {
+  const data = (error as { response?: { data?: { message?: string | string[] } } })?.response?.data;
+  if (Array.isArray(data?.message)) return data.message.join(", ");
+  if (data?.message) return data.message;
+  return error instanceof Error ? error.message : fallback;
+};
+
 export function CustomerTruckAssignmentCard({
   booking,
   onAssigned,
@@ -29,43 +51,86 @@ export function CustomerTruckAssignmentCard({
   booking: Freight.IBooking;
   onAssigned: () => void;
 }) {
-  const assigned = Boolean(booking.customerTruckAssignedAt);
-  const [truckPlateNumber, setTruckPlateNumber] = useState(booking.customerTruckPlateNumber ?? "");
-  const [driverName, setDriverName] = useState(booking.customerTruckDriverName ?? "");
-  const [truckType, setTruckType] = useState(booking.customerTruckType ?? "");
-  const [containerNumberToLoad, setContainerNumberToLoad] = useState(
-    booking.customerTruckContainerNumber ?? "",
-  );
+  const queryClient = useQueryClient();
+  const trucksKey = ["customer-trucks", booking.id];
+
+  const { data: trucks = [], isLoading } = useQuery({
+    queryKey: trucksKey,
+    queryFn: () => customerTrucksService.list(booking.id),
+  });
+
+  const [plateNumber, setPlateNumber] = useState("");
+  const [driverName, setDriverName] = useState("");
+  const [truckType, setTruckType] = useState("");
+  const [containers, setContainers] = useState<string[]>([]);
   const [error, setError] = useState<string | null>(null);
 
-  const assignMutation = useMutation(api.bookings.assignCustomerTruck.mutationOptions());
-  const downloadMutation = useMutation(api.bookings.downloadCustomerTruckFreightOrder.mutationOptions());
+  // Container numbers on the booking that aren't already loaded onto a truck.
+  const assignedNumbers = new Set(
+    trucks.flatMap((t) => (t.containers ?? []).map((c) => c.containerNumber)),
+  );
+  const availableContainers = (booking.containerNumbers ?? []).filter(
+    (n) => !assignedNumbers.has(n),
+  );
 
-  const submit = async () => {
-    const payload = {
-      truckPlateNumber: truckPlateNumber.trim().toUpperCase(),
-      driverName: driverName.trim(),
-      truckType: truckType.trim(),
-      containerNumberToLoad: containerNumberToLoad.trim().toUpperCase(),
-    };
-    if (!payload.truckPlateNumber || !payload.driverName || !payload.truckType || !payload.containerNumberToLoad) {
-      setError("All truck assignment fields are required.");
-      return;
-    }
-    if (!ISO_CONTAINER_PATTERN.test(payload.containerNumberToLoad)) {
-      setError("Container number must match ISO format, e.g. ABCD1234567.");
-      return;
-    }
+  // EXPORT trucks deliver known containers (pre-selected). IMPORT trucks don't —
+  // staff register + weigh what was loaded when the truck leaves.
+  const isExport = booking.tradeDirection === "EXPORT";
+
+  const resetForm = () => {
+    setPlateNumber("");
+    setDriverName("");
+    setTruckType("");
+    setContainers([]);
     setError(null);
-    await assignMutation.mutateAsync({ id: booking.id, payload });
-    onAssigned();
   };
 
+  const addMutation = useMutation({
+    mutationFn: () =>
+      customerTrucksService.add(booking.id, {
+        truckPlateNumber: plateNumber.trim().toUpperCase(),
+        driverName: driverName.trim(),
+        truckType: truckType.trim(),
+        // Import: containers are registered + weighed on departure, not here.
+        containerNumbers: isExport ? containers : [],
+      }),
+    onSuccess: (list) => {
+      queryClient.setQueryData(trucksKey, list);
+      resetForm();
+      onAssigned();
+      toast.success("Truck added");
+    },
+    onError: (e) => setError(errorMessage(e, "Could not add truck")),
+  });
+
+  const removeMutation = useMutation({
+    mutationFn: (assignmentId: string) => customerTrucksService.remove(booking.id, assignmentId),
+    onSuccess: (list) => {
+      queryClient.setQueryData(trucksKey, list);
+      onAssigned();
+    },
+    onError: (e) => toast.error(errorMessage(e, "Could not remove truck")),
+  });
+
+  const downloadMutation = useMutation(api.bookings.downloadCustomerTruckFreightOrder.mutationOptions());
   const downloadFreightOrder = async () => {
     const blob = await downloadMutation.mutateAsync({ id: booking.id });
     downloadBlob(blob, `freight-order-${booking.reference}.pdf`);
   };
 
+  const submitAdd = () => {
+    if (!plateNumber.trim() || !driverName.trim() || !truckType.trim()) {
+      setError("Plate number, driver name and truck type are required.");
+      return;
+    }
+    if (isExport && (containers.length < 1 || containers.length > 2)) {
+      setError("Select 1 or 2 container numbers for this truck.");
+      return;
+    }
+    setError(null);
+    addMutation.mutate();
+  };
+
   return (
     <SectionCard>
       <Stack gap="md">
@@ -74,64 +139,135 @@ export function CustomerTruckAssignmentCard({
             <Truck size={18} color="#0a9f6a" />
             <CardTitle>External Truck Assignment</CardTitle>
           </Group>
-          {assigned && (
-            <Group gap={6} c="#0a9f6a">
-              <Lock size={14} />
-              <Text size="sm" fw={700}>
-                Truck Assigned
-              </Text>
-            </Group>
+          {trucks.length > 0 && (
+            <Text size="sm" fw={700} c="#0a9f6a">
+              {trucks.length} truck{trucks.length !== 1 ? "s" : ""}
+            </Text>
           )}
         </Group>
 
+        {/* Assigned trucks */}
+        {isLoading ? (
+          <Group justify="center" py="sm">
+            <Loader size="sm" />
+          </Group>
+        ) : (
+          trucks.map((t) => (
+            <Group
+              key={t.id}
+              justify="space-between"
+              align="flex-start"
+              wrap="nowrap"
+              style={{ border: "1px solid #EEF2F6", borderRadius: 12, padding: "12px 14px" }}
+            >
+              <Stack gap={4} style={{ minWidth: 0 }}>
+                <Group gap={8} wrap="nowrap">
+                  <Text fz="14px" fw={700} c="#10202F">
+                    {t.plateNumber}
+                  </Text>
+                  {t.arrivedAt ? (
+                    <Badge color="green" variant="light" leftSection={<CheckCircle2 size={12} />}>
+                      Arrived
+                    </Badge>
+                  ) : (
+                    <Badge color="orange" variant="light" leftSection={<Clock size={12} />}>
+                      Awaiting arrival
+                    </Badge>
+                  )}
+                </Group>
+                <Text fz="12.5px" c="#6B7C8E">
+                  {t.driverName} · {t.truckType}
+                </Text>
+                <Group gap={6}>
+                  {(t.containers ?? []).map((c) => (
+                    <Badge key={c.id} variant="outline" color="gray">
+                      {c.containerNumber}
+                    </Badge>
+                  ))}
+                </Group>
+              </Stack>
+              {!t.arrivedAt && (
+                <ActionIcon
+                  variant="subtle"
+                  color="red"
+                  aria-label="Remove truck"
+                  onClick={() => removeMutation.mutate(t.id)}
+                  loading={removeMutation.isPending}
+                >
+                  <Trash2 size={16} />
+                </ActionIcon>
+              )}
+            </Group>
+          ))
+        )}
+
         {error && (
           <Alert color="red" variant="light">
             {error}
           </Alert>
         )}
-        {assignMutation.isError && (
-          <Alert color="red" variant="light">
-            {assignMutation.error instanceof Error
-              ? assignMutation.error.message
-              : "Truck assignment failed."}
-          </Alert>
+
+        {/* Add-truck form. Export needs unassigned containers; import always allows another truck. */}
+        {(isExport ? availableContainers.length > 0 : true) ? (
+          <>
+            <Divider label="Add a truck" labelPosition="center" />
+            <SimpleGrid cols={{ base: 1, sm: 2 }} spacing="sm">
+              <TextInput
+                label="Truck Plate Number"
+                required
+                value={plateNumber}
+                onChange={(e) => setPlateNumber(e.currentTarget.value.toUpperCase())}
+              />
+              <TextInput
+                label="Driver Name"
+                required
+                value={driverName}
+                onChange={(e) => setDriverName(e.currentTarget.value)}
+              />
+              <Select
+                label="Truck Type"
+                required
+                data={TRUCK_TYPES}
+                value={truckType || null}
+                onChange={(value) => setTruckType(value ?? "")}
+              />
+              {isExport && (
+                <MultiSelect
+                  label="Containers to load (1–2)"
+                  required
+                  placeholder="Select container numbers"
+                  data={availableContainers}
+                  value={containers}
+                  onChange={setContainers}
+                  maxValues={2}
+                  searchable
+                  nothingFoundMessage="No unassigned containers"
+                />
+              )}
+            </SimpleGrid>
+            <Group justify="flex-end">
+              <Button
+                leftSection={<Plus size={16} />}
+                color="edr-green"
+                onClick={submitAdd}
+                loading={addMutation.isPending}
+              >
+                Add truck
+              </Button>
+            </Group>
+          </>
+        ) : (
+          trucks.length > 0 && (
+            <Text fz="12.5px" c="#9AA8B5">
+              All containers on this booking have been assigned to a truck.
+            </Text>
+          )
         )}
 
-        <SimpleGrid cols={{ base: 1, sm: 2 }} spacing="sm">
-          <TextInput
-            label="Truck Plate Number"
-            required
-            value={truckPlateNumber}
-            onChange={(e) => setTruckPlateNumber(e.currentTarget.value)}
-            readOnly={assigned}
-          />
-          <TextInput
-            label="Driver Name"
-            required
-            value={driverName}
-            onChange={(e) => setDriverName(e.currentTarget.value)}
-            readOnly={assigned}
-          />
-          <Select
-            label="Truck Type"
-            required
-            data={TRUCK_TYPES}
-            value={truckType || null}
-            onChange={(value) => setTruckType(value ?? "")}
-            disabled={assigned}
-          />
-          <TextInput
-            label="Container Number to Load"
-            required
-            value={containerNumberToLoad}
-            onChange={(e) => setContainerNumberToLoad(e.currentTarget.value.toUpperCase())}
-            readOnly={assigned}
-          />
-        </SimpleGrid>
-
-        <Group justify="flex-end">
-          {assigned ? (
+        {trucks.length > 0 && (
+          <Group justify="flex-end">
             <Button
+              variant="light"
               leftSection={<Download size={16} />}
               color="edr-green"
               onClick={downloadFreightOrder}
@@ -139,12 +275,8 @@ export function CustomerTruckAssignmentCard({
             >
               Generate Freight Order Copies
             </Button>
-          ) : (
-            <Button color="edr-green" onClick={submit} loading={assignMutation.isPending}>
-              Verify & Submit Assignment
-            </Button>
-          )}
-        </Group>
+          </Group>
+        )}
       </Stack>
     </SectionCard>
   );
diff --git a/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/components/WarehousePaymentsSection.tsx b/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/components/WarehousePaymentsSection.tsx
index 146e31c1e..acd4dbb25 100644
--- a/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/components/WarehousePaymentsSection.tsx
+++ b/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/components/WarehousePaymentsSection.tsx
@@ -1,16 +1,24 @@
-import { ActionIcon, Box, Group, Stack, Text } from "@mantine/core";
-import { useQuery } from "@tanstack/react-query";
-import { Download, Receipt } from "lucide-react";
+import { ActionIcon, Box, Button, Group, Stack, Text } from "@mantine/core";
+import { useMutation, useQuery } from "@tanstack/react-query";
+import { CreditCard, Download, Receipt } from "lucide-react";
+import { useState } from "react";
 import toast from "react-hot-toast";
 
+import { paymentsService, type PaymentMethod } from "@/services/payments.service";
 import {
   warehouseInvoicesService,
   type PortalWarehouseInvoice,
 } from "@/services/warehouse-invoices.service";
 import { saveBlob } from "@/utils/download";
 
+import { PaymentMethodModal } from "./PaymentMethodModal";
 import { CardTitle, SectionCard } from "./layout";
 
+/** Warehouse fee invoices the customer can still settle online. */
+const PAYABLE_STATUSES = new Set(["ISSUED", "PARTIALLY_PAID"]);
+const isPayable = (inv: PortalWarehouseInvoice) =>
+  PAYABLE_STATUSES.has(inv.status) && Number(inv.balanceAmount ?? 0) > 0;
+
 const money = (amount: number | string | null | undefined, currency: string) =>
   `${Number(amount ?? 0).toLocaleString()} ${currency}`;
 
@@ -44,10 +52,12 @@ function StatusPill({ status }: { status: string }) {
 }
 
 /**
- * Warehouse fee invoices linked to this booking — display + PDF download only.
- * Paying them online is tracked separately (in-system demurrage/storage
- * payment). Renders nothing when the booking has no warehouse fees. Carries
- * `id="warehouse-payments"` so the invoice detail page can deep-link here.
+ * Warehouse fee invoices linked to this booking. Customers can pay outstanding
+ * demurrage/storage invoices online (Telebirr/Waafi) so they can then sign the
+ * delivery handover; paid invoices expose the receipt PDF. The backoffice cash
+ * `/pay` (record-a-payment) path is unaffected. Renders nothing when the booking
+ * has no warehouse fees. Carries `id="warehouse-payments"` so the invoice detail
+ * page can deep-link here.
  */
 export function WarehousePaymentsSection({ bookingId }: { bookingId: string }) {
   const { data: invoices = [] } = useQuery({
@@ -55,6 +65,41 @@ export function WarehousePaymentsSection({ bookingId }: { bookingId: string }) {
     queryFn: () => warehouseInvoicesService.listForBooking(bookingId),
   });
 
+  const [payInvoice, setPayInvoice] = useState<PortalWarehouseInvoice | null>(null);
+
+  const payMutation = useMutation({
+    mutationFn: (method: PaymentMethod) => {
+      if (!payInvoice) throw new Error("No invoice selected for payment.");
+      return warehouseInvoicesService.payOnline(payInvoice.id, {
+        method,
+        platform: "web",
+      });
+    },
+    onSuccess: (data, method) => {
+      if (!payInvoice) return;
+      // Redirect to the provider (or the fallback checkout page) — same as the
+      // booking "Pay now" flow, so behaviour is identical everywhere.
+      const redirectUrl =
+        data?.clientAction?.type === "REDIRECT" && data.clientAction.url
+          ? data.clientAction.url
+          : paymentsService.checkoutUrlForInvoice({ invoiceId: payInvoice.id, method });
+      window.location.href = redirectUrl;
+    },
+  });
+
+  const payError = payMutation.isError
+    ? payMutation.error instanceof Error
+      ? payMutation.error.message
+      : "Could not start payment. Please try again."
+    : null;
+
+  const closePayModal = () => {
+    if (!payMutation.isPending) {
+      setPayInvoice(null);
+      payMutation.reset();
+    }
+  };
+
   if (invoices.length === 0) return null;
 
   const download = async (inv: PortalWarehouseInvoice) => {
@@ -128,6 +173,17 @@ export function WarehousePaymentsSection({ bookingId }: { bookingId: string }) {
                 </Text>
               </Box>
               <Group gap={6} wrap="nowrap">
+                {isPayable(inv) && (
+                  <Button
+                    size="xs"
+                    radius={10}
+                    color="edr-green"
+                    leftSection={<CreditCard size={14} />}
+                    onClick={() => setPayInvoice(inv)}
+                  >
+                    Pay
+                  </Button>
+                )}
                 <ActionIcon
                   variant="subtle"
                   color="gray"
@@ -151,6 +207,18 @@ export function WarehousePaymentsSection({ bookingId }: { bookingId: string }) {
           );
         })}
       </Stack>
+
+      <PaymentMethodModal
+        opened={payInvoice !== null}
+        onClose={closePayModal}
+        amountLabel={
+          payInvoice ? money(payInvoice.balanceAmount, payInvoice.currency) : undefined
+        }
+        currency={payInvoice?.currency}
+        onConfirm={(method) => payMutation.mutate(method)}
+        processing={payMutation.isPending}
+        error={payError}
+      />
     </SectionCard>
   );
 }
diff --git a/apps/edr-freight-web/portal/src/pages/bookings/NewBookingPage.tsx b/apps/edr-freight-web/portal/src/pages/bookings/NewBookingPage.tsx
index 80ed05eb0..afcd2f777 100644
--- a/apps/edr-freight-web/portal/src/pages/bookings/NewBookingPage.tsx
+++ b/apps/edr-freight-web/portal/src/pages/bookings/NewBookingPage.tsx
@@ -524,11 +524,10 @@ export default function NewBookingPage() {
           }
         : { customsClearingEnabled: false }),
       ...(cargoFreeText ? { cargoFreeText } : {}),
-      // Multi-route general contracts: routes are pure origin→destination lanes
-      // the contract covers — they carry NO quantity. Route #1 is the primary
-      // origin/destination; the rest come from the extra-routes step. The
-      // contracted quantity lives in a single shared pool (the container
-      // quantities / bulk total), drawn down per order against a chosen lane.
+      // A general contract covers exactly ONE route — the same single
+      // origin→destination pair as a one-time booking (multi-route on bookings
+      // was dropped). The contracted quantity lives in a single shared pool
+      // (container quantities / bulk total), drawn down per order.
       ...(isContract
         ? {
             routes: [
@@ -536,12 +535,6 @@ export default function NewBookingPage() {
                 originYardId: data.originYard,
                 destinationYardId: data.destinationYard,
               },
-              ...(data.extraRoutes ?? [])
-                .filter((r) => r.originYard && r.destinationYard)
-                .map((r) => ({
-                  originYardId: r.originYard,
-                  destinationYardId: r.destinationYard,
-                })),
             ],
           }
         : {}),
diff --git a/apps/edr-freight-web/portal/src/pages/bookings/new-booking-form/LocationPicker.tsx b/apps/edr-freight-web/portal/src/pages/bookings/new-booking-form/LocationPicker.tsx
index 1b75ab65c..b2f14b16f 100644
--- a/apps/edr-freight-web/portal/src/pages/bookings/new-booking-form/LocationPicker.tsx
+++ b/apps/edr-freight-web/portal/src/pages/bookings/new-booking-form/LocationPicker.tsx
@@ -147,6 +147,31 @@ async function searchPlaces(
   return found;
 }
 
+/**
+ * Build the address label for a picked place.
+ *
+ * For an establishment / POI (e.g. "Bole Medhanialem") Google's
+ * `formatted_address` is the *postal* address, which for many Ethiopian places
+ * collapses to just the city ("Addis Ababa, Ethiopia") — so taking it verbatim
+ * silently replaces the specific place the user picked with a broad city. The
+ * place `name` carries the specific label, so we lead with it and only append
+ * the formatted address for context when it doesn't already contain the name.
+ * Falls back to the prediction's own description (what the user saw and clicked).
+ */
+function placeDisplayName(
+  place: google.maps.places.PlaceResult | null,
+  prediction: PlacePrediction,
+): string {
+  const name = place?.name?.trim();
+  const formatted = place?.formatted_address?.trim();
+  if (name && formatted) {
+    return formatted.toLowerCase().includes(name.toLowerCase())
+      ? formatted
+      : `${name}, ${formatted}`;
+  }
+  return name || formatted || prediction.displayName;
+}
+
 /**
  * Resolve a picked prediction to its coordinates via Place Details. Runs once
  * per selection (closes the Autocomplete session), so billing stays on the
@@ -174,10 +199,7 @@ async function resolvePrediction(
           return;
         }
         resolve({
-          displayName:
-            place?.formatted_address ||
-            place?.name ||
-            prediction.displayName,
+          displayName: placeDisplayName(place, prediction),
           lat: loc.lat(),
           lng: loc.lng(),
         });
diff --git a/apps/edr-freight-web/portal/src/pages/bookings/new-booking-form/schema.ts b/apps/edr-freight-web/portal/src/pages/bookings/new-booking-form/schema.ts
index 2b902bdc8..b137635ae 100644
--- a/apps/edr-freight-web/portal/src/pages/bookings/new-booking-form/schema.ts
+++ b/apps/edr-freight-web/portal/src/pages/bookings/new-booking-form/schema.ts
@@ -144,10 +144,9 @@ export const bookingFormSchema = z
     // The contracted quantity now comes from the cargo step (cargoWeight), the
     // same as a one-time booking, so per-route quantity is no longer entered.
     primaryRouteQuantity: z.string().default(""),
-    // Additional routes for a GENERAL contract (the primary origin/destination
-    // above is route #1). Each route is just an (origin, destination) pair —
-    // identical to the one-time route — so a contract can cover several routes.
-    // Ignored for one-time bookings. quantity/km kept for payload back-compat.
+    // LEGACY — multi-route general contracts were dropped; a contract booking
+    // now covers exactly one route, like a one-time booking. Field retained only
+    // so previously saved drafts still hydrate; never collected or sent anymore.
     extraRoutes: z
       .array(
         z.object({
@@ -434,7 +433,6 @@ export const stepFields: Record<number, Array<Path<BookingFormValues>>> = {
     "originYard",
     "destinationYard",
     "primaryRouteQuantity",
-    "extraRoutes",
     // Estimated shipment date now lives in the Route step (one-time bookings only).
     "scheduledDate",
   ],
diff --git a/apps/edr-freight-web/portal/src/pages/bookings/new-booking-form/step4-route.tsx b/apps/edr-freight-web/portal/src/pages/bookings/new-booking-form/step4-route.tsx
index 783162a35..15b2c5a8e 100644
--- a/apps/edr-freight-web/portal/src/pages/bookings/new-booking-form/step4-route.tsx
+++ b/apps/edr-freight-web/portal/src/pages/bookings/new-booking-form/step4-route.tsx
@@ -1,26 +1,9 @@
 import type { Freight } from "@edr/types";
-import {
-  Box,
-  Button,
-  Group,
-  Skeleton,
-  Stack,
-  Text,
-} from "@mantine/core";
+import { Box, Skeleton, Stack } from "@mantine/core";
 import { DatePickerInput } from "@mantine/dates";
-import {
-  CalendarDays,
-  MapPin,
-  Plus,
-  Route as RouteIcon,
-  Trash2,
-} from "lucide-react";
+import { CalendarDays, MapPin, Route as RouteIcon } from "lucide-react";
 import { useCallback, useEffect, useMemo } from "react";
-import {
-  Controller,
-  useFieldArray,
-  type UseFormReturn,
-} from "react-hook-form";
+import { Controller, type UseFormReturn } from "react-hook-form";
 import {
   BookingFormInputValues,
   type BookingFormValues,
@@ -70,16 +53,6 @@ export function Step4Route({
     }
   }, [operationType]);
 
-  const {
-    fields: extraRoutes,
-    append: appendRoute,
-    remove: removeRoute,
-  } = useFieldArray({ control: form.control, name: "extraRoutes" });
-
-  // useFieldArray's `fields` don't re-render on value change, so watch the live
-  // route values to filter each row's yard options by what it has selected.
-  const watchedExtraRoutes = form.watch("extraRoutes") ?? [];
-
   const yardOptions = useMemo(() => {
     if (!referenceData?.yard) return [];
     return referenceData.yard.map((y) => ({ value: y.id, label: y.name }));
@@ -129,25 +102,6 @@ export function Step4Route({
     }
   }, [destinationCountry, dest, form]);
 
-  // Same cleanup for the extra contract routes: when the operation type changes,
-  // clear any extra-route yard whose country no longer matches the required side
-  // so an added route can't contradict the operation either.
-  useEffect(() => {
-    watchedExtraRoutes.forEach((route, i) => {
-      const ro = referenceData?.yard.find((y) => y.id === route?.originYard);
-      if (originCountry && ro && ro.country !== originCountry) {
-        form.setValue(`extraRoutes.${i}.originYard`, "");
-      }
-      const rd = referenceData?.yard.find(
-        (y) => y.id === route?.destinationYard,
-      );
-      if (destinationCountry && rd && rd.country !== destinationCountry) {
-        form.setValue(`extraRoutes.${i}.destinationYard`, "");
-      }
-    });
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [originCountry, destinationCountry, referenceData, 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",
@@ -161,11 +115,10 @@ export function Step4Route({
 
   const stationSelectDisabled = yardOptions.length === 0;
 
-  // A general contract can cover several routes, but each route is just an
-  // (origin, destination) pair — the same shape as the one-time route. The
-  // contracted quantity comes from the cargo step, so no per-route quantity or
-  // distance is collected here. Cargo handling (hazardous / refrigerated) also
-  // lives in the Cargo step now, not here.
+  // A general contract covers exactly ONE route — the same single
+  // origin/destination pair as a one-time booking. (Multi-route contracts were
+  // dropped; the multi-lane concept lives on the contracts module, not on
+  // bookings.) The contracted quantity comes from the cargo step.
 
   // Earliest selectable shipment date (today, local) for the date input's `min`.
   const todayISODate = useMemo(() => {
@@ -256,103 +209,6 @@ export function Step4Route({
         </div>
       )}
 
-      {isGeneralContract && !isLoading && (
-        <Box mt={18}>
-          <Group justify="space-between" align="center" mb={8}>
-            <StepLabel>Additional contract routes</StepLabel>
-            <Button
-              variant="light"
-              color="edr-green"
-              size="xs"
-              radius="md"
-              leftSection={<Plus size={14} />}
-              disabled={stationSelectDisabled}
-              onClick={() =>
-                appendRoute({
-                  originYard: "",
-                  destinationYard: "",
-                  quantity: "",
-                  km: "",
-                })
-              }
-            >
-              Add route
-            </Button>
-          </Group>
-          <Text fz={12} c="#6B7C8E" mb={12}>
-            A general contract can cover several routes. The route above is your
-            primary route; add more origin–destination routes the contract should
-            cover.
-          </Text>
-          <Stack gap={12}>
-            {extraRoutes.map((rf, i) => {
-              // Each extra route is constrained by the SAME operation type as the
-              // primary route: its origin must sit in originCountry and its
-              // destination in destinationCountry. Watch this row's current values
-              // so each side also excludes the yard picked on the other side.
-              const rowOrigin = watchedExtraRoutes[i]?.originYard ?? "";
-              const rowDestination =
-                watchedExtraRoutes[i]?.destinationYard ?? "";
-              const rowOriginData = yardsForSide(originCountry, rowDestination);
-              const rowDestData = yardsForSide(destinationCountry, rowOrigin);
-              return (
-                <Group
-                  key={rf.id}
-                  gap={10}
-                  align="flex-start"
-                  wrap="nowrap"
-                  className="rounded-xl"
-                  style={{ border: "1px solid #E6ECF2", padding: 12 }}
-                >
-                  <Box style={{ flex: 1 }}>
-                    <Controller
-                      name={`extraRoutes.${i}.originYard`}
-                      control={form.control}
-                      render={({ field, fieldState }) => (
-                        <SelectField
-                          field={field}
-                          error={fieldState.error}
-                          label="Origin"
-                          placeholder="Origin..."
-                          disabled={stationSelectDisabled}
-                          data={rowOriginData}
-                        />
-                      )}
-                    />
-                  </Box>
-                  <Box style={{ flex: 1 }}>
-                    <Controller
-                      name={`extraRoutes.${i}.destinationYard`}
-                      control={form.control}
-                      render={({ field, fieldState }) => (
-                        <SelectField
-                          field={field}
-                          error={fieldState.error}
-                          label="Destination"
-                          placeholder="Destination..."
-                          disabled={stationSelectDisabled}
-                          data={rowDestData}
-                        />
-                      )}
-                    />
-                  </Box>
-                  <Button
-                    variant="subtle"
-                    color="red"
-                    size="xs"
-                    mt={24}
-                    px={6}
-                    onClick={() => removeRoute(i)}
-                  >
-                    <Trash2 size={16} />
-                  </Button>
-                </Group>
-              );
-            })}
-          </Stack>
-        </Box>
-      )}
-
     </StepCard>
   );
 }
diff --git a/apps/edr-freight-web/portal/src/pages/bookings/new-booking-form/step5-cargo-details.tsx b/apps/edr-freight-web/portal/src/pages/bookings/new-booking-form/step5-cargo-details.tsx
index a02138373..ac336c47c 100644
--- a/apps/edr-freight-web/portal/src/pages/bookings/new-booking-form/step5-cargo-details.tsx
+++ b/apps/edr-freight-web/portal/src/pages/bookings/new-booking-form/step5-cargo-details.tsx
@@ -26,6 +26,70 @@ type BookingForm = UseFormReturn<
   BookingFormValues
 >;
 
+/**
+ * One numbered toggle per container unit in the line — tap units to mark how
+ * many are hazardous/refrigerated (2 hazardous → toggle 2 units on). Selection
+ * fills from unit 1: tapping unit N selects 1..N, tapping a selected unit N
+ * keeps 1..N-1 — the count is always derived, never free-typed, so it can't
+ * exceed the line quantity.
+ */
+function UnitCountToggles({
+  total,
+  value,
+  onChange,
+  label,
+  activeBg,
+  activeBorder,
+  activeColor,
+}: {
+  total: number;
+  value: string;
+  onChange: (v: string) => void;
+  label: string;
+  activeBg: string;
+  activeBorder: string;
+  activeColor: string;
+}) {
+  const count = Math.min(total, Math.max(0, Math.floor(Number(value) || 0)));
+
+  return (
+    <div>
+      <Text fz={12} fw={600} c="#4A5A68" mb={6}>
+        {label} · {count}/{total} selected
+      </Text>
+      <div className="flex flex-wrap gap-2">
+        {Array.from({ length: total }, (_, i) => {
+          const selected = i < count;
+          return (
+            <button
+              key={i}
+              type="button"
+              aria-pressed={selected}
+              aria-label={`Container ${i + 1}`}
+              onClick={() => onChange(String(selected ? i : i + 1))}
+              className="rounded-lg"
+              style={{
+                minWidth: 40,
+                padding: "6px 10px",
+                fontSize: 12,
+                fontWeight: 700,
+                cursor: "pointer",
+                border: `1.5px solid ${selected ? activeBorder : "#E6ECF2"}`,
+                background: selected ? activeBg : "#fff",
+                color: selected ? activeColor : "#6B7C8E",
+                transition:
+                  "background 120ms ease, border-color 120ms ease, color 120ms ease",
+              }}
+            >
+              #{i + 1}
+            </button>
+          );
+        })}
+      </div>
+    </div>
+  );
+}
+
 export function Step5CargoDetails({
   form,
   referenceData,
@@ -144,16 +208,6 @@ export function Step5CargoDetails({
   const lineQtyOf = (index: number) =>
     Math.max(1, Number(form.getValues(`containers.${index}.qty`) ?? 1) || 1);
   const lineMax = (index: number) => lineQtyOf(index);
-  // When a flag is switched on, default its count to the whole line.
-  const defaultLineQty = (index: number) => lineQtyOf(index).toString();
-  // Clamp a typed value into 1..lineQty (empty stays empty so the field can be
-  // cleared; the schema flags an empty value as required while the switch is on).
-  const clampToLine = (raw: string, index: number) => {
-    if (raw === "") return "";
-    const n = Number(raw);
-    if (Number.isNaN(n)) return raw;
-    return Math.min(lineQtyOf(index), Math.max(1, Math.floor(n))).toString();
-  };
   // After the line quantity changes, pull any active count back within bounds.
   const clampDependentQty = (index: number, newLineQty: number) => {
     const max = Math.max(1, newLineQty);
@@ -636,7 +690,7 @@ export function Step5CargoDetails({
                           hazField.onChange(v);
                           form.setValue(
                             `containers.${index}.hazardousQty`,
-                            v ? defaultLineQty(index) : "0",
+                            v ? "1" : "0",
                             { shouldDirty: true, shouldValidate: true },
                           );
                         }}
@@ -645,22 +699,22 @@ export function Step5CargoDetails({
                           name={`containers.${index}.hazardousQty`}
                           control={form.control}
                           render={({ field: hq, fieldState }) => (
-                            <TextInput
-                              type="number"
-                              size="sm"
-                              label="How many hazardous?"
-                              min={1}
-                              max={lineMax(index)}
-                              value={hq.value ?? ""}
-                              onChange={(e) =>
-                                hq.onChange(
-                                  clampToLine(e.currentTarget.value, index),
-                                )
-                              }
-                              onBlur={hq.onBlur}
-                              error={fieldState.error?.message}
-                              radius="md"
-                            />
+                            <div>
+                              <UnitCountToggles
+                                total={lineMax(index)}
+                                value={hq.value ?? "0"}
+                                onChange={hq.onChange}
+                                label="Tap the hazardous containers"
+                                activeBg="#FBEAE7"
+                                activeBorder="#E4A69B"
+                                activeColor="#C0392B"
+                              />
+                              {fieldState.error?.message ? (
+                                <Text fz={11} c="red.7" mt={4}>
+                                  {fieldState.error.message}
+                                </Text>
+                              ) : null}
+                            </div>
                           )}
                         />
                       </ToggleRow>
@@ -681,7 +735,7 @@ export function Step5CargoDetails({
                           reeField.onChange(v);
                           form.setValue(
                             `containers.${index}.reeferQty`,
-                            v ? defaultLineQty(index) : "0",
+                            v ? "1" : "0",
                             { shouldDirty: true, shouldValidate: true },
                           );
                         }}
@@ -690,22 +744,22 @@ export function Step5CargoDetails({
                           name={`containers.${index}.reeferQty`}
                           control={form.control}
                           render={({ field: rq, fieldState }) => (
-                            <TextInput
-                              type="number"
-                              size="sm"
-                              label="How many refrigerated?"
-                              min={1}
-                              max={lineMax(index)}
-                              value={rq.value ?? ""}
-                              onChange={(e) =>
-                                rq.onChange(
-                                  clampToLine(e.currentTarget.value, index),
-                                )
-                              }
-                              onBlur={rq.onBlur}
-                              error={fieldState.error?.message}
-                              radius="md"
-                            />
+                            <div>
+                              <UnitCountToggles
+                                total={lineMax(index)}
+                                value={rq.value ?? "0"}
+                                onChange={rq.onChange}
+                                label="Tap the refrigerated containers"
+                                activeBg="#E9F0F8"
+                                activeBorder="#A9C2E0"
+                                activeColor="#2E5B96"
+                              />
+                              {fieldState.error?.message ? (
+                                <Text fz={11} c="red.7" mt={4}>
+                                  {fieldState.error.message}
+                                </Text>
+                              ) : null}
+                            </div>
                           )}
                         />
                       </ToggleRow>
diff --git a/apps/edr-freight-web/portal/src/pages/contracts/ClearancePhaseStepper.tsx b/apps/edr-freight-web/portal/src/pages/contracts/ClearancePhaseStepper.tsx
index f9429a3e6..10b64c79a 100644
--- a/apps/edr-freight-web/portal/src/pages/contracts/ClearancePhaseStepper.tsx
+++ b/apps/edr-freight-web/portal/src/pages/contracts/ClearancePhaseStepper.tsx
@@ -15,6 +15,18 @@ const PHASE_LABELS: Record<string, string> = {
   POST_TRANSIT: "Transit",
 };
 
+/** One-line hint under each phase label, for the vertical layout. */
+const PHASE_HINTS: Record<string, string> = {
+  CUSTOMER_INTAKE: "You upload the required clearance documents",
+  GL_ET_REVIEW: "Global Logistics reviews your documents in Ethiopia",
+  GL_DJ_COLLECTION: "Delivery order collected in Djibouti",
+  GL_ET_OUTPUT: "Customs declaration prepared",
+  CUSTOMER_DUTY: "You pay the assessed duty / tax",
+  GL_ET_POST_CLEARANCE: "Transit cleared and paperwork finalised",
+  GL_DJ_LOADING: "Cargo loaded for departure",
+  POST_TRANSIT: "In transit",
+};
+
 const IMPORT_PHASES = [
   "CUSTOMER_INTAKE",
   "GL_ET_REVIEW",
@@ -51,62 +63,92 @@ export function ClearancePhaseStepper({
   const current = clearance?.phase ?? phases[0];
   const activeIdx = phaseIndex(phases, current);
 
+  const dot = compact ? 26 : 30;
+  const rowGap = compact ? 18 : 24;
+
+  // Vertical timeline: every phase is a row, so all steps stay visible on any
+  // width without horizontal scrolling. The connector runs down between dots.
   return (
-    <Group gap={0} wrap="nowrap" align="flex-start" style={{ overflowX: "auto" }}>
+    <Stack gap={0}>
       {phases.map((phase, index) => {
         const isComplete = index < activeIdx;
         const isActive = index === activeIdx;
         const isLast = index === phases.length - 1;
+        // const doneOrActive = isComplete || isActive;
 
         return (
-          <Box key={phase} style={{ flex: isLast ? "0 0 auto" : 1, minWidth: compact ? 72 : 88 }}>
-            <Group gap={0} wrap="nowrap" align="center">
-              <Stack gap={4} align="center" style={{ flexShrink: 0 }}>
-                <Box
-                  style={{
-                    display: "flex",
-                    alignItems: "center",
-                    justifyContent: "center",
-                    width: compact ? 28 : 34,
-                    height: compact ? 28 : 34,
-                    borderRadius: "50%",
-                    background: isComplete ? BRAND_GREEN : isActive ? "white" : "var(--mantine-color-gray-1)",
-                    border: isActive
-                      ? `2px solid ${BRAND_GREEN}`
-                      : isComplete
-                        ? "2px solid transparent"
-                        : "2px solid var(--mantine-color-gray-3)",
-                    color: isComplete ? "white" : isActive ? BRAND_GREEN : "var(--mantine-color-gray-5)",
-                  }}
-                >
-                  {isComplete ? <Check size={compact ? 14 : 16} strokeWidth={3} /> : null}
-                </Box>
-                <Text
-                  size={compact ? "10px" : "xs"}
-                  fw={isActive ? 600 : 500}
-                  c={isActive ? "edr-green.7" : isComplete ? "dark" : "dimmed"}
-                  ta="center"
-                  style={{ whiteSpace: "nowrap" }}
-                >
-                  {PHASE_LABELS[phase] ?? phase}
-                </Text>
-              </Stack>
+          <Group key={phase} gap={12} wrap="nowrap" align="flex-start">
+            {/* Dot + connector column */}
+            <Stack gap={0} align="center" style={{ flexShrink: 0, alignSelf: "stretch" }}>
+              <Box
+                style={{
+                  display: "flex",
+                  alignItems: "center",
+                  justifyContent: "center",
+                  width: dot,
+                  height: dot,
+                  borderRadius: "50%",
+                  flexShrink: 0,
+                  background: isComplete
+                    ? BRAND_GREEN
+                    : isActive
+                      ? "white"
+                      : "var(--mantine-color-gray-1)",
+                  border: isActive
+                    ? `2px solid ${BRAND_GREEN}`
+                    : isComplete
+                      ? "2px solid transparent"
+                      : "2px solid var(--mantine-color-gray-3)",
+                  color: isComplete
+                    ? "white"
+                    : isActive
+                      ? BRAND_GREEN
+                      : "var(--mantine-color-gray-5)",
+                }}
+              >
+                {isComplete ? (
+                  <Check size={compact ? 14 : 16} strokeWidth={3} />
+                ) : (
+                  <Text size="xs" fw={700}>
+                    {index + 1}
+                  </Text>
+                )}
+              </Box>
               {!isLast && (
                 <Box
                   style={{
+                    width: 2,
                     flex: 1,
-                    height: 2,
-                    marginInline: 6,
-                    marginBottom: compact ? 16 : 20,
+                    minHeight: rowGap,
+                    marginBlock: 4,
                     borderRadius: 2,
-                    background: isComplete ? BRAND_GREEN : "var(--mantine-color-gray-2)",
+                    background: isComplete
+                      ? BRAND_GREEN
+                      : "var(--mantine-color-gray-2)",
                   }}
                 />
               )}
-            </Group>
-          </Box>
+            </Stack>
+
+            {/* Label + hint */}
+            <Box pb={isLast ? 0 : rowGap} style={{ minWidth: 0, paddingTop: 3 }}>
+              <Text
+                size="sm"
+                fw={isActive ? 700 : 500}
+                c={isActive ? "edr-green.7" : isComplete ? "dark" : "dimmed"}
+                lh={1.2}
+              >
+                {PHASE_LABELS[phase] ?? phase}
+              </Text>
+              {PHASE_HINTS[phase] && (
+                <Text size="xs" c="dimmed" mt={2} lh={1.3}>
+                  {PHASE_HINTS[phase]}
+                </Text>
+              )}
+            </Box>
+          </Group>
         );
       })}
-    </Group>
+    </Stack>
   );
 }
diff --git a/apps/edr-freight-web/portal/src/pages/contracts/ContractClearanceWorkflowBanner.tsx b/apps/edr-freight-web/portal/src/pages/contracts/ContractClearanceWorkflowBanner.tsx
index 736cc67e4..cc5318cf9 100644
--- a/apps/edr-freight-web/portal/src/pages/contracts/ContractClearanceWorkflowBanner.tsx
+++ b/apps/edr-freight-web/portal/src/pages/contracts/ContractClearanceWorkflowBanner.tsx
@@ -1,6 +1,6 @@
 import { useState } from "react";
 import { Alert, Box, Button, Group, Paper, Stack, Text } from "@mantine/core";
-import { AlertTriangle, Download, Receipt, Upload } from "lucide-react";
+import { AlertTriangle, ArrowRight, Download, PackageCheck, Receipt, Upload } from "lucide-react";
 import { useQuery } from "@tanstack/react-query";
 import toast from "react-hot-toast";
 import type { Freight } from "@edr/types";
@@ -87,7 +87,36 @@ export function ContractClearanceWorkflowBanner({
             onDownload={downloadWorkflowFile}
           />
 
-          {clearance.bookingReady ? (
+          {clearance.linkedBookingId ? (
+            <Alert color="green" variant="light" icon={<PackageCheck size={16} />}>
+              <Stack gap={6}>
+                <Text fz={13} fw={600} style={{ color: INK }}>
+                  Shipment booking created
+                  {clearance.linkedBookingReference
+                    ? ` · ${clearance.linkedBookingReference}`
+                    : ""}
+                </Text>
+                <Text fz={12} c="dimmed">
+                  Global Logistics has created your shipment booking
+                  {clearance.linkedBookingStatus
+                    ? ` (${clearance.linkedBookingStatus.replace(/_/g, " ").toLowerCase()})`
+                    : ""}
+                  . Track its progress from the booking.
+                </Text>
+                <Button
+                  size="compact-sm"
+                  variant="light"
+                  color="green"
+                  leftSection={<ArrowRight size={14} />}
+                  component="a"
+                  href={`/bookings/${clearance.linkedBookingId}`}
+                  style={{ alignSelf: "flex-start" }}
+                >
+                  View shipment booking
+                </Button>
+              </Stack>
+            </Alert>
+          ) : clearance.bookingReady ? (
             <Alert color="green" variant="light">
               Clearance is complete. Global Logistics will create your shipment booking shortly.
             </Alert>
diff --git a/apps/edr-freight-web/portal/src/pages/contracts/ContractDetailPage.tsx b/apps/edr-freight-web/portal/src/pages/contracts/ContractDetailPage.tsx
index f15200d49..268e8627a 100644
--- a/apps/edr-freight-web/portal/src/pages/contracts/ContractDetailPage.tsx
+++ b/apps/edr-freight-web/portal/src/pages/contracts/ContractDetailPage.tsx
@@ -16,6 +16,8 @@ import {
   Group,
   Loader,
   Paper,
+  Progress,
+  RingProgress,
   SimpleGrid,
   Stack,
   Tabs,
@@ -61,6 +63,7 @@ import { ContractClearanceWorkflowBanner } from "./ContractClearanceWorkflowBann
 import { ClearanceUploadedDocumentsPanel } from "@/components/contracts/ClearanceUploadedDocumentsPanel";
 import { formatRateUnit } from "./new-contract-form/unit-rates";
 import { getContractBookingAction } from "./contract-booking-action";
+import { closedWindowMessage, hasOpenWindow } from "./booking-window";
 import {
   BORDER,
   ContractStatusBadge,
@@ -198,6 +201,29 @@ export default function ContractDetailPage() {
     (r) => r.status === "PENDING" || r.status === "ACCEPTED",
   );
 
+  // Booking windows for this contract's routes — gates the direct "New shipment
+  // booking" entry so the customer only sees it while a window is open.
+  // Refetched every minute so "Open now" flips without a manual reload.
+  const { data: bookingWindows = [] } = useQuery({
+    ...api.bookings.getContractBookingWindows.queryOptions({
+      input: { contractId: id! },
+      refetchInterval: 60_000,
+    }),
+    enabled: !!id,
+  });
+  const bookingWindowOpen = hasOpenWindow(bookingWindows);
+
+  // Draw-down capacity per cargo line (GENERAL contracts only). The backend
+  // excludes CANCELLED/REJECTED/EXPIRED bookings, so a shipment that never ships
+  // releases its share and the tracker fills back up. Refetched on window focus so
+  // it reflects newly created / cancelled shipments.
+  const { data: capacityLines = [] } = useQuery({
+    queryKey: ["contract-capacity", id],
+    queryFn: () => contractsService.getCapacity(id!),
+    enabled: !!id && contract?.contractKind === "GENERAL",
+    refetchOnWindowFocus: true,
+  });
+
   const contractBookings = useMemo(
     () =>
       (bookingsPage?.items ?? []).filter(
@@ -370,17 +396,40 @@ export default function ContractDetailPage() {
                 Request shipment
               </Button>
             )}
-            {canBookShipment && (
-              <Button
-                color="edr-green"
-                radius="md"
-                size="md"
-                leftSection={<PackagePlus size={16} />}
-                onClick={() => navigate(`/contracts/${contract.id}/bookings/new`)}
-              >
-                New shipment booking
-              </Button>
-            )}
+            {canBookShipment &&
+              (bookingWindowOpen ? (
+                <Button
+                  color="edr-green"
+                  radius="md"
+                  size="md"
+                  leftSection={<PackagePlus size={16} />}
+                  onClick={() =>
+                    navigate(`/contracts/${contract.id}/bookings/new`)
+                  }
+                >
+                  New shipment booking
+                </Button>
+              ) : (
+                <Paper
+                  withBorder
+                  radius="md"
+                  px="md"
+                  py={10}
+                  maw={420}
+                  style={{ borderColor: BORDER, background: "#F8FAFC" }}
+                >
+                  <Group gap={10} align="flex-start" wrap="nowrap">
+                    <CalendarClock
+                      size={16}
+                      color={MUTED}
+                      style={{ flexShrink: 0, marginTop: 2 }}
+                    />
+                    <Text fz={13} c="dimmed">
+                      {closedWindowMessage(bookingWindows)}
+                    </Text>
+                  </Group>
+                </Paper>
+              ))}
             {glPreparingBooking && (
               <Badge
                 size="lg"
@@ -846,6 +895,88 @@ export default function ContractDetailPage() {
           </Card>
         </SimpleGrid>
 
+        {/* Draw-down capacity — GENERAL contracts with a per-line quantity cap.
+            Fills as shipments consume capacity; empties again when a shipment is
+            cancelled/rejected/expired (backend releases it). */}
+        {isGeneral && capacityLines.length > 0 && (
+          <Card
+            withBorder
+            radius="lg"
+            p="lg"
+            style={{ borderColor: BORDER, boxShadow: CARD_SHADOW }}
+          >
+            <SectionLabel mb="md">Contract capacity</SectionLabel>
+            <Stack gap="lg">
+              {capacityLines.map((line, i) => {
+                const cap = line.cap ?? 0;
+                const booked = line.booked ?? 0;
+                const remaining = line.remaining ?? Math.max(0, cap - booked);
+                const usedPct = cap > 0 ? Math.min(100, (booked / cap) * 100) : 0;
+                const remainingPct = cap > 0 ? Math.round((remaining / cap) * 100) : 0;
+                const unit = capacityUnitLabel(contract, line);
+                const label = isContainer
+                  ? `${line.containerSize ?? "Containers"}`
+                  : (contract.cargoScope ?? []).find(
+                        (s) => s.cargoTypeId === line.cargoTypeId,
+                      )?.cargoType?.cargoTypeName ??
+                    (contract.cargoScope ?? [])[0]?.cargoFreeText ??
+                    "Bulk commodity";
+                return (
+                  <Group
+                    key={line.containerSize ?? line.cargoTypeId ?? i}
+                    align="center"
+                    wrap="nowrap"
+                    gap="lg"
+                  >
+                    <RingProgress
+                      size={72}
+                      thickness={8}
+                      roundCaps
+                      sections={[
+                        {
+                          value: remainingPct,
+                          color: remaining === 0 ? "red" : GREEN,
+                        },
+                      ]}
+                      label={
+                        <Text ta="center" fz={13} fw={700} style={{ color: INK }}>
+                          {remainingPct}%
+                        </Text>
+                      }
+                    />
+                    <Box style={{ flex: 1, minWidth: 0 }}>
+                      <Group justify="space-between" mb={6} wrap="nowrap">
+                        <Group gap={8} wrap="nowrap">
+                          {isContainer ? (
+                            <Package size={16} color={MUTED} />
+                          ) : (
+                            <Weight size={16} color={MUTED} />
+                          )}
+                          <Text fz={14} fw={600} style={{ color: INK }}>
+                            {label}
+                          </Text>
+                        </Group>
+                        <Text fz={13} c="dimmed">
+                          {booked} / {cap} {unit} booked
+                        </Text>
+                      </Group>
+                      <Progress
+                        value={usedPct}
+                        size="md"
+                        radius="xl"
+                        color={remaining === 0 ? "red" : GREEN}
+                      />
+                      <Text fz={12} c="dimmed" mt={6}>
+                        {remaining} {unit} remaining
+                      </Text>
+                    </Box>
+                  </Group>
+                );
+              })}
+            </Stack>
+          </Card>
+        )}
+
         {/* Signatures */}
         {(contract.signatures ?? []).length > 0 && (
           <Card
@@ -1102,7 +1233,7 @@ export default function ContractDetailPage() {
             >
               <Group justify="space-between" align="center" mb="md">
                 <SectionLabel>Bookings under this contract</SectionLabel>
-                {canBookShipment && (
+                {canBookShipment && bookingWindowOpen && (
                   <Button
                     color="edr-green"
                     radius="md"
@@ -1116,6 +1247,18 @@ export default function ContractDetailPage() {
                   </Button>
                 )}
               </Group>
+              {canBookShipment && !bookingWindowOpen && (
+                <Group gap={8} align="flex-start" wrap="nowrap" mb="md">
+                  <CalendarClock
+                    size={15}
+                    color={MUTED}
+                    style={{ flexShrink: 0, marginTop: 2 }}
+                  />
+                  <Text fz={13} c="dimmed">
+                    {closedWindowMessage(bookingWindows)}
+                  </Text>
+                </Group>
+              )}
               {contractBookings.length === 0 ? (
                 <Stack align="center" gap={10} py="xl">
                   <Inbox size={26} color={MUTED} style={{ opacity: 0.5 }} />
@@ -1303,6 +1446,22 @@ function SectionLabel({
   );
 }
 
+/**
+ * Unit noun for a capacity line: "containers" for CONTAINER freight, else the
+ * bulk cargo's unit of measure ("tons" for PER_TON, "items" for PER_ITEM).
+ */
+function capacityUnitLabel(
+  contract: Freight.IContract,
+  line: Freight.ContractCapacityLine,
+): string {
+  if (contract.freightType === "CONTAINER") return "containers";
+  const scope =
+    (contract.cargoScope ?? []).find(
+      (s) => s.cargoTypeId === line.cargoTypeId,
+    ) ?? (contract.cargoScope ?? [])[0];
+  return scope?.cargoType?.unitOfMeasure === "PER_ITEM" ? "items" : "tons";
+}
+
 /**
  * One document row in the Documents tab: the file's kind (passport, business
  * license, contract, …) derived from its `code` as the primary label, the
diff --git a/apps/edr-freight-web/portal/src/pages/contracts/ContractStepBanner.tsx b/apps/edr-freight-web/portal/src/pages/contracts/ContractStepBanner.tsx
new file mode 100644
index 000000000..a339c214a
--- /dev/null
+++ b/apps/edr-freight-web/portal/src/pages/contracts/ContractStepBanner.tsx
@@ -0,0 +1,271 @@
+import { Box, Group, Stack, Text } from "@mantine/core";
+import {
+  AlertTriangle,
+  Check,
+  CircleDot,
+  FileEdit,
+  FilePlus2,
+  Gavel,
+  PenLine,
+  Send,
+  ShieldCheck,
+  Truck,
+  XCircle,
+} from "lucide-react";
+import type { LucideIcon } from "lucide-react";
+import type { Freight } from "@edr/types";
+
+import { BORDER, GREEN, GREEN_DARK, INK, MUTED } from "./contract-ui";
+
+/**
+ * The customer-facing contract journey, in order. This is the *contract track*
+ * (establishing the agreement) — the per-shipment booking/clearance journey is a
+ * separate stepper (`ClearancePhaseStepper`) shown on a booking, not here.
+ */
+interface Stage {
+  key: string;
+  label: string;
+  icon: LucideIcon;
+}
+
+const STAGES: Stage[] = [
+  { key: "draft", label: "Draft", icon: FileEdit },
+  { key: "submitted", label: "Submitted", icon: Send },
+  { key: "accepted", label: "Accepted", icon: ShieldCheck },
+  { key: "approval", label: "Approval", icon: Gavel },
+  { key: "sign", label: "Signature", icon: PenLine },
+  { key: "active", label: "Active", icon: FilePlus2 },
+  { key: "shipping", label: "Shipping", icon: Truck },
+];
+
+const STAGE_INDEX: Record<string, number> = STAGES.reduce(
+  (acc, s, i) => ({ ...acc, [s.key]: i }),
+  {},
+);
+
+type Terminal = "REJECTED" | "CANCELLED" | "EXPIRED" | "CLOSED" | null;
+
+interface StepState {
+  /** Index into STAGES of the stage the contract is currently working on. */
+  activeIdx: number;
+  /** Terminal state, if the contract ended off the happy path. */
+  terminal: Terminal;
+  /** One-line "what happens next" helper for the customer. */
+  next: string;
+}
+
+/**
+ * Map any contract status onto the journey. Statuses that share a stage (e.g.
+ * every approval/signature sub-state) collapse onto that stage; the helper line
+ * is what disambiguates them for the customer.
+ */
+function resolveStep(status: string): StepState {
+  const at = (key: string): number => STAGE_INDEX[key] ?? 0;
+
+  switch (status) {
+    case "DRAFT":
+    case "RENEWAL_DRAFT":
+      return { activeIdx: at("draft"), terminal: null, next: "Finish and submit this contract for review." };
+
+    case "SUBMITTED":
+    case "RENEWAL_SUBMITTED":
+      return { activeIdx: at("submitted"), terminal: null, next: "Waiting for staff to accept your submission." };
+
+    case "PRICE_CHANGED_PENDING_CONFIRM":
+      return { activeIdx: at("submitted"), terminal: null, next: "Price changed since preview — confirm to resubmit." };
+
+    case "CHANGES_REQUESTED":
+      return { activeIdx: at("submitted"), terminal: null, next: "Staff requested changes — update and resubmit." };
+
+    case "AMENDMENTS_PROPOSED":
+      return { activeIdx: at("submitted"), terminal: null, next: "Amendments proposed — review the proposed changes." };
+
+    case "PENDING_APPROVAL":
+    case "RENEWAL_PENDING_APPROVAL":
+      return { activeIdx: at("approval"), terminal: null, next: "Under internal approval (staff → director → CEO)." };
+
+    case "APPROVED":
+      return { activeIdx: at("approval"), terminal: null, next: "Approved — the contract document is being prepared." };
+
+    case "APPROVED_PENDING_SIGNATURE":
+    case "CONTRACT_READY":
+      return { activeIdx: at("sign"), terminal: null, next: "Contract is ready — review and sign it." };
+
+    case "SIGNED_CUSTOMER":
+      return { activeIdx: at("sign"), terminal: null, next: "You've signed — waiting for staff to counter-sign." };
+
+    case "CONTRACT_ACTIVE":
+    case "FULLY_EXECUTED":
+    case "CLEARANCE_READY_FOR_BOOKING":
+      return { activeIdx: at("active"), terminal: null, next: "Active — submit a shipment request to start shipping." };
+
+    case "AWAITING_CLEARANCE_DOCUMENTS":
+      return { activeIdx: at("active"), terminal: null, next: "Upload the pre-booking clearance documents." };
+
+    case "CLEARANCE_UNDER_REVIEW":
+      return { activeIdx: at("active"), terminal: null, next: "Global Logistics is reviewing your clearance documents." };
+
+    case "ACTIVE_SHIPMENT_IN_PROGRESS":
+      return { activeIdx: at("shipping"), terminal: null, next: "A shipment is in progress under this contract." };
+
+    // ── Terminal ──
+    case "REJECTED":
+      return { activeIdx: at("approval"), terminal: "REJECTED", next: "This contract was rejected." };
+    case "CANCELLED":
+      return { activeIdx: at("draft"), terminal: "CANCELLED", next: "This contract was cancelled." };
+    case "EXPIRED":
+      return { activeIdx: at("active"), terminal: "EXPIRED", next: "This contract's validity has expired." };
+    case "CONTRACT_CLOSED":
+    case "ARCHIVED":
+      return { activeIdx: STAGES.length - 1, terminal: "CLOSED", next: "This contract is closed." };
+
+    default:
+      return { activeIdx: at("draft"), terminal: null, next: "" };
+  }
+}
+
+/** Days until the contract validity lapses, if any (negative = already lapsed). */
+function daysUntil(dateIso?: string | null): number | null {
+  if (!dateIso) return null;
+  const end = new Date(dateIso).getTime();
+  if (Number.isNaN(end)) return null;
+  const ms = end - Date.now();
+  return Math.ceil(ms / 86_400_000);
+}
+
+export interface ContractStepBannerProps {
+  contract: Freight.IContract;
+}
+
+/**
+ * A polished, branded step banner that shows where a contract sits in its
+ * lifecycle. Rendered inside the expanded region of a contract row.
+ */
+export function ContractStepBanner({ contract }: ContractStepBannerProps) {
+  const { activeIdx, terminal, next } = resolveStep(contract.status);
+  const isTerminalBad = terminal === "REJECTED" || terminal === "CANCELLED" || terminal === "EXPIRED";
+
+  const expiryDays = daysUntil(contract.contractValidUntil);
+  const expirySoon =
+    !terminal && expiryDays !== null && expiryDays >= 0 && expiryDays <= 14;
+
+  return (
+    <Box
+      style={{
+        borderRadius: 14,
+        padding: "18px 20px",
+        border: `1px solid ${isTerminalBad ? "#F3C6C1" : BORDER}`,
+        background: isTerminalBad
+          ? "linear-gradient(135deg, #FEF3F2 0%, #FFFFFF 60%)"
+          : `linear-gradient(135deg, ${GREEN}12 0%, ${GREEN}06 26%, #FFFFFF 68%)`,
+      }}
+    >
+      {/* Stepper row */}
+      <Group gap={0} wrap="nowrap" align="flex-start" style={{ overflowX: "auto" }}>
+        {STAGES.map((stage, index) => {
+          const isComplete = !isTerminalBad && index < activeIdx;
+          const isActive = !isTerminalBad && index === activeIdx;
+          const isFailedHere = isTerminalBad && index === activeIdx;
+          const isLast = index === STAGES.length - 1;
+          const Icon = isFailedHere ? XCircle : stage.icon;
+
+          return (
+            <Box key={stage.key} style={{ flex: isLast ? "0 0 auto" : 1, minWidth: 78 }}>
+              <Group gap={0} wrap="nowrap" align="center">
+                <Stack gap={5} align="center" style={{ flexShrink: 0 }}>
+                  <Box
+                    style={{
+                      display: "flex",
+                      alignItems: "center",
+                      justifyContent: "center",
+                      width: 36,
+                      height: 36,
+                      borderRadius: "50%",
+                      background: isComplete
+                        ? GREEN_DARK
+                        : isFailedHere
+                          ? "#D92D20"
+                          : isActive
+                            ? "#FFFFFF"
+                            : "#F1F5F8",
+                      border: isActive
+                        ? `2px solid ${GREEN}`
+                        : isComplete || isFailedHere
+                          ? "2px solid transparent"
+                          : `2px solid ${BORDER}`,
+                      color: isComplete || isFailedHere
+                        ? "#FFFFFF"
+                        : isActive
+                          ? GREEN_DARK
+                          : "#9AA9B7",
+                      boxShadow: isActive ? `0 0 0 4px ${GREEN}22` : "none",
+                      transition: "all 160ms ease",
+                    }}
+                  >
+                    {isComplete ? (
+                      <Check size={17} strokeWidth={3} />
+                    ) : (
+                      <Icon size={17} strokeWidth={isActive ? 2.4 : 2} />
+                    )}
+                  </Box>
+                  <Text
+                    fz={11}
+                    fw={isActive ? 700 : 600}
+                    ta="center"
+                    style={{
+                      whiteSpace: "nowrap",
+                      color: isActive ? GREEN_DARK : isComplete ? INK : MUTED,
+                    }}
+                  >
+                    {stage.label}
+                  </Text>
+                </Stack>
+                {!isLast && (
+                  <Box
+                    style={{
+                      flex: 1,
+                      height: 2.5,
+                      marginInline: 6,
+                      marginBottom: 20,
+                      borderRadius: 2,
+                      background: isComplete ? GREEN_DARK : BORDER,
+                      transition: "background 160ms ease",
+                    }}
+                  />
+                )}
+              </Group>
+            </Box>
+          );
+        })}
+      </Group>
+
+      {/* Helper line + expiry hint */}
+      {(next || expirySoon) && (
+        <Group gap={16} wrap="wrap" mt={14} align="center">
+          {next && (
+            <Group gap={7} wrap="nowrap" align="center">
+              {isTerminalBad ? (
+                <XCircle size={15} color="#D92D20" />
+              ) : (
+                <CircleDot size={15} color={GREEN_DARK} />
+              )}
+              <Text fz={12.5} fw={600} style={{ color: isTerminalBad ? "#B42318" : INK }}>
+                {next}
+              </Text>
+            </Group>
+          )}
+          {expirySoon && (
+            <Group gap={6} wrap="nowrap" align="center">
+              <AlertTriangle size={14} color="#9A6700" />
+              <Text fz={12} fw={600} c="#9A6700">
+                {expiryDays === 0
+                  ? "Validity ends today"
+                  : `Validity ends in ${expiryDays} day${expiryDays === 1 ? "" : "s"}`}
+              </Text>
+            </Group>
+          )}
+        </Group>
+      )}
+    </Box>
+  );
+}
diff --git a/apps/edr-freight-web/portal/src/pages/contracts/ContractsList.tsx b/apps/edr-freight-web/portal/src/pages/contracts/ContractsList.tsx
index fbb8ac0ce..41e77625b 100644
--- a/apps/edr-freight-web/portal/src/pages/contracts/ContractsList.tsx
+++ b/apps/edr-freight-web/portal/src/pages/contracts/ContractsList.tsx
@@ -1,4 +1,4 @@
-import { useMemo, useState } from "react";
+import { Fragment, useMemo, useState } from "react";
 import { useNavigate } from "react-router-dom";
 import { useQuery } from "@tanstack/react-query";
 import {
@@ -17,6 +17,7 @@ import {
 } from "@mantine/core";
 import {
   CheckCircle2,
+  ChevronDown,
   ChevronLeft,
   ChevronRight,
   FileStack,
@@ -43,6 +44,7 @@ import {
   MUTED,
   StatCard,
 } from "./contract-ui";
+import { ContractStepBanner } from "./ContractStepBanner";
 
 function primaryRoute(contract: Freight.IContract) {
   const route = contract.routes?.[0];
@@ -61,6 +63,15 @@ export default function ContractsList() {
   const [kindFilter, setKindFilter] = useState<string | null>(null);
   const [createdFrom, setCreatedFrom] = useState<string>("");
   const [createdTo, setCreatedTo] = useState<string>("");
+  const [expanded, setExpanded] = useState<Set<string>>(new Set());
+
+  const toggleExpanded = (id: string) =>
+    setExpanded((prev) => {
+      const nextSet = new Set(prev);
+      if (nextSet.has(id)) nextSet.delete(id);
+      else nextSet.add(id);
+      return nextSet;
+    });
 
   const resetPage = () =>
     setPagination({ pageIndex: 0, pageSize: pagination.pageSize });
@@ -326,6 +337,7 @@ export default function ContractsList() {
             >
               <Table.Thead>
                 <Table.Tr>
+                  <Table.Th style={{ width: 44 }} aria-label="Expand" />
                   <Table.Th>Contract</Table.Th>
                   <Table.Th>Cargo</Table.Th>
                   <Table.Th>Route</Table.Th>
@@ -340,7 +352,7 @@ export default function ContractsList() {
               <Table.Tbody>
                 {isLoading && (
                   <Table.Tr>
-                    <Table.Td colSpan={9}>
+                    <Table.Td colSpan={10}>
                       <Center py={48}>
                         <Loader color="edr-green" size="sm" />
                       </Center>
@@ -350,7 +362,7 @@ export default function ContractsList() {
 
                 {!isLoading && isError && (
                   <Table.Tr>
-                    <Table.Td colSpan={9}>
+                    <Table.Td colSpan={10}>
                       <Center py={48}>
                         <Text fz={13} c="red">
                           Failed to load contracts. Please try again.
@@ -362,7 +374,7 @@ export default function ContractsList() {
 
                 {!isLoading && !isError && rows.length === 0 && (
                   <Table.Tr>
-                    <Table.Td colSpan={9}>
+                    <Table.Td colSpan={10}>
                       <Stack align="center" gap={8} py={48}>
                         <Inbox size={26} color={MUTED} style={{ opacity: 0.5 }} />
                         <Text fz={13} c="dimmed">
@@ -383,12 +395,48 @@ export default function ContractsList() {
                     const tradeLabel = dir
                       ? dir.charAt(0) + dir.slice(1).toLowerCase()
                       : "—";
+                    const isOpen = expanded.has(c.id);
                     return (
+                      <Fragment key={c.id}>
                       <Table.Tr
-                        key={c.id}
-                        style={{ cursor: "pointer" }}
+                        style={{
+                          cursor: "pointer",
+                          background: isOpen ? "#F4FBF8" : undefined,
+                        }}
                         onClick={() => navigate(`/contracts/${c.id}`)}
                       >
+                        <Table.Td>
+                          <Box
+                            component="button"
+                            aria-label={isOpen ? "Hide progress" : "Show progress"}
+                            aria-expanded={isOpen}
+                            onClick={(e) => {
+                              e.stopPropagation();
+                              toggleExpanded(c.id);
+                            }}
+                            style={{
+                              display: "flex",
+                              alignItems: "center",
+                              justifyContent: "center",
+                              width: 28,
+                              height: 28,
+                              borderRadius: 8,
+                              border: `1px solid ${BORDER}`,
+                              background: isOpen ? GREEN : "#FFFFFF",
+                              color: isOpen ? "#FFFFFF" : MUTED,
+                              cursor: "pointer",
+                              transition: "all 140ms ease",
+                            }}
+                          >
+                            <ChevronDown
+                              size={16}
+                              style={{
+                                transform: isOpen ? "rotate(180deg)" : "none",
+                                transition: "transform 160ms ease",
+                              }}
+                            />
+                          </Box>
+                        </Table.Td>
                         <Table.Td>
                           <Text fz={14} fw={700} style={{ color: INK }}>
                             {c.reference}
@@ -483,6 +531,14 @@ export default function ContractsList() {
                           </Group>
                         </Table.Td>
                       </Table.Tr>
+                      {isOpen && (
+                        <Table.Tr style={{ background: "#F4FBF8" }}>
+                          <Table.Td colSpan={10} style={{ padding: "6px 20px 18px" }}>
+                            <ContractStepBanner contract={c} />
+                          </Table.Td>
+                        </Table.Tr>
+                      )}
+                      </Fragment>
                     );
                   })}
               </Table.Tbody>
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 d245cd20c..a2bc985c0 100644
--- a/apps/edr-freight-web/portal/src/pages/contracts/NewShipmentPage.tsx
+++ b/apps/edr-freight-web/portal/src/pages/contracts/NewShipmentPage.tsx
@@ -52,6 +52,7 @@ import {
 } from "./new-shipment-form/schema";
 import { computeShipmentTotal } from "./new-shipment-form/total";
 import { ContractCapacityNotice } from "./new-shipment-form/ContractCapacityNotice";
+import { closedWindowMessage, hasOpenWindow } from "./booking-window";
 
 type ShipmentForm = ReturnType<
   typeof useForm<ShipmentFormInputValues, any, ShipmentFormValues>
@@ -65,7 +66,19 @@ export default function NewShipmentPage() {
     api.contracts.get.queryOptions({ input: { id: id! }, enabled: !!id }),
   );
 
-  if (isLoading) {
+  // Coarse booking-window gate: block the form entirely when no window is
+  // currently open for the contract's routes. The day-picker inside the form
+  // still narrows to bookable days; this is the outer "is booking open at all"
+  // check that mirrors the contract detail page.
+  const { data: bookingWindows = [], isLoading: windowsLoading } = useQuery({
+    ...api.bookings.getContractBookingWindows.queryOptions({
+      input: { contractId: id! },
+      refetchInterval: 60_000,
+    }),
+    enabled: !!id,
+  });
+
+  if (isLoading || windowsLoading) {
     return (
       <Center mih={400} p="xl">
         <Loader color="edr-green" />
@@ -113,6 +126,60 @@ export default function NewShipmentPage() {
     );
   }
 
+  // Coarse gate: if the customer deep-links here while no booking window is
+  // open, show the same closed-state notice as the contract page instead of the
+  // form. Still allowed the moment any window isOpenNow.
+  if (!hasOpenWindow(bookingWindows)) {
+    return (
+      <Box style={{ padding: "28px 0 0" }}>
+        <Group
+          justify="space-between"
+          px="24px"
+          align="flex-end"
+          wrap="wrap"
+          gap="md"
+          mb="lg"
+        >
+          <Box>
+            <Title
+              order={1}
+              fw={800}
+              fz={26}
+              style={{ letterSpacing: "-0.01em" }}
+            >
+              New Shipment Booking
+            </Title>
+            <Text size="sm" c="edr-muted" mt={4}>
+              Book a shipment against contract {contract.reference}.
+            </Text>
+          </Box>
+          <Button
+            variant="default"
+            radius="md"
+            leftSection={<ChevronLeft size={16} />}
+            onClick={() => navigate(`/contracts/${contract.id}`)}
+          >
+            Back to contract
+          </Button>
+        </Group>
+        <Box px="24px">
+          <Alert
+            color="yellow"
+            variant="light"
+            radius="md"
+            icon={<CalendarDays size={18} />}
+            title="Booking is not open right now"
+          >
+            <Text size="sm">{closedWindowMessage(bookingWindows)}</Text>
+            <Text size="sm" mt="xs">
+              Come back when the booking window opens to book your shipment.
+            </Text>
+          </Alert>
+        </Box>
+      </Box>
+    );
+  }
+
   return <NewShipmentBookingForm contract={contract} contractId={id!} />;
 }
 
@@ -151,8 +218,6 @@ function NewShipmentBookingForm({
     mode: "onChange",
   });
 
-  const isContainerContract = contract.freightType === "CONTAINER";
-
   const submitMutation = useMutation({
     mutationFn: (dto: Freight.CreateBookingUnderContractDto) =>
       api.contracts.createBookingUnderContract.call({ id: contractId, dto }),
@@ -220,21 +285,22 @@ function NewShipmentBookingForm({
   }
 
   // Submit validates the whole form, then opens the price modal for
-  // confirmation. For container contracts we also run the server-side shipment
-  // validation (overweight warnings + 20ft pairing hard-blocks) so the modal
-  // can surface them before the booking is created.
+  // confirmation. The server-side shipment validation also returns the
+  // authoritative price breakdown (rail + first/last mile + every surcharge) —
+  // run it for every freight type; container contracts additionally get
+  // overweight warnings + 20ft pairing hard-blocks surfaced in the modal.
   const handleReview = form.handleSubmit((values) => {
     setPendingValues(values);
-    if (isContainerContract) {
-      validateMutation.reset();
-      validateMutation.mutate(buildDto(values));
-    }
+    validateMutation.reset();
+    validateMutation.mutate(buildDto(values));
   });
 
   const handleConfirm = () => {
     if (!pendingValues) return;
     // Guard: never let a booking with unresolved 20ft pairing errors submit.
     if ((validateMutation.data?.pairingErrors.length ?? 0) > 0) return;
+    // Guard: a line above the container type's max capacity can never book.
+    if ((validateMutation.data?.capacityErrors?.length ?? 0) > 0) return;
     submitMutation.mutate(buildDto(pendingValues));
   };
 
@@ -371,15 +437,63 @@ function PriceConfirmModal({
   onConfirm: () => void;
   onReject: () => void;
 }) {
-  const total = useMemo(
+  const baseTotal = useMemo(
     () => (values ? computeShipmentTotal(contract, values) : null),
     [contract, values],
   );
 
   const overweightLines = validation?.overweightLines ?? [];
+  const overweightSurchargeAmount = validation?.overweightSurchargeAmount ?? 0;
   const pairingErrors = validation?.pairingErrors ?? [];
   const hasPairingBlock = pairingErrors.length > 0;
-  const confirmDisabled = loading || validationLoading || hasPairingBlock;
+  const capacityErrors = validation?.capacityErrors ?? [];
+  const hasCapacityBlock = capacityErrors.length > 0;
+  const confirmDisabled =
+    loading || validationLoading || hasPairingBlock || hasCapacityBlock;
+
+  // Authoritative server breakdown — the SAME BookingPricingService pass that
+  // prices the booking on create, so it carries every line the booking will be
+  // charged: rail freight, first/last mile trucking, overweight, hazard/reefer
+  // and any other rule-engine surcharge.
+  const serverTotal = useMemo(() => {
+    const items = validation?.lineItems;
+    if (!items?.length) return null;
+    return {
+      currency: validation?.currency ?? baseTotal?.currency ?? "ETB",
+      lines: items.map((li) => ({
+        label: li.description,
+        unitPrice: li.unitAmount,
+        unit: li.unit.toLowerCase(),
+        quantity: li.quantity,
+        amount: li.amount,
+      })),
+      total:
+        validation?.totalAmount ?? items.reduce((s, l) => s + l.amount, 0),
+    };
+  }, [validation, baseTotal]);
+
+  // Fallback while the server preview loads: the contract's frozen unit rates
+  // (container/bulk + hazard/reefer only) with the overweight surcharge folded
+  // in. Replaced by the full server breakdown the moment it arrives.
+  const total = useMemo(() => {
+    if (serverTotal) return serverTotal;
+    if (!baseTotal) return null;
+    if (!(overweightSurchargeAmount > 0)) return baseTotal;
+    return {
+      ...baseTotal,
+      lines: [
+        ...baseTotal.lines,
+        {
+          label: "Overweight surcharge",
+          unitPrice: overweightSurchargeAmount,
+          unit: "flat" as const,
+          quantity: 1,
+          amount: overweightSurchargeAmount,
+        },
+      ],
+      total: baseTotal.total + overweightSurchargeAmount,
+    };
+  }, [serverTotal, baseTotal, overweightSurchargeAmount]);
 
   return (
     <Modal
@@ -413,7 +527,8 @@ function PriceConfirmModal({
             <Group gap={8} c="dimmed">
               <Loader size="xs" color="edr-green" />
               <Text fz="sm" c="dimmed">
-                Checking container weights and wagon pairing…
+                Computing the final price breakdown and checking container
+                weights…
               </Text>
             </Group>
           )}
@@ -440,6 +555,28 @@ function PriceConfirmModal({
             </Alert>
           )}
 
+          {hasCapacityBlock && (
+            <Alert
+              color="red"
+              variant="light"
+              radius="md"
+              icon={<AlertCircle size={16} />}
+              title="Cannot create booking — over maximum capacity"
+            >
+              <Stack gap={6}>
+                {capacityErrors.map((msg, i) => (
+                  <Text key={i} fz="sm" c="red.8">
+                    {msg}
+                  </Text>
+                ))}
+                <Text fz="xs" c="red.7" mt={2}>
+                  Reduce the cargo weight or split it across more containers to
+                  book this shipment.
+                </Text>
+              </Stack>
+            </Alert>
+          )}
+
           {overweightLines.length > 0 && (
             <Alert
               color="yellow"
@@ -456,8 +593,11 @@ function PriceConfirmModal({
                   </Text>
                 ))}
                 <Text fz="xs" c="#9A5B00" mt={2}>
-                  An overweight surcharge applies. You can still submit, or go
-                  back and adjust weights.
+                  {overweightSurchargeAmount > 0
+                    ? `An overweight surcharge of ${overweightSurchargeAmount.toLocaleString()} ${
+                        validation?.currency ?? total?.currency ?? ""
+                      } applies (included in the total below). You can still submit, or go back and adjust weights.`
+                    : "An overweight surcharge applies. You can still submit, or go back and adjust weights."}
                 </Text>
               </Stack>
             </Alert>
diff --git a/apps/edr-freight-web/portal/src/pages/contracts/booking-window.ts b/apps/edr-freight-web/portal/src/pages/contracts/booking-window.ts
new file mode 100644
index 000000000..44b97c741
--- /dev/null
+++ b/apps/edr-freight-web/portal/src/pages/contracts/booking-window.ts
@@ -0,0 +1,63 @@
+import type { MyBookingWindow } from "@/services/bookings.service";
+
+/** All booking-window times are communicated in East Africa Time. */
+const TZ = "Africa/Addis_Ababa";
+
+/** "Thu, 10 Jul, 08:00 EAT" — a full opening date/time in Addis Ababa time. */
+export function formatWindowOpensAt(iso: string): string {
+  const day = new Date(iso).toLocaleDateString("en-GB", {
+    weekday: "short",
+    day: "numeric",
+    month: "short",
+    timeZone: TZ,
+  });
+  const time = new Date(iso).toLocaleTimeString("en-GB", {
+    hour: "2-digit",
+    minute: "2-digit",
+    hour12: false,
+    timeZone: TZ,
+  });
+  return `${day}, ${time}`;
+}
+
+/** True when at least one of the contract's windows is bookable right now. */
+export function hasOpenWindow(windows: MyBookingWindow[]): boolean {
+  return windows.some((w) => w.isOpenNow);
+}
+
+/**
+ * The soonest upcoming (not-yet-open) window with a known opening time, so the
+ * customer can be told when to come back. Returns `null` when nothing upcoming
+ * carries an opening time.
+ */
+export function soonestUpcomingWindow(
+  windows: MyBookingWindow[],
+): MyBookingWindow | null {
+  const upcoming = windows
+    .filter((w) => !w.isOpenNow && w.windowOpensAt)
+    .sort(
+      (a, b) =>
+        new Date(a.windowOpensAt!).getTime() -
+        new Date(b.windowOpensAt!).getTime(),
+    );
+  return upcoming[0] ?? null;
+}
+
+/**
+ * The closed-state message shown when no booking window is open: the soonest
+ * upcoming window's opening time + lane, or a generic notice when nothing is
+ * scheduled.
+ */
+export function closedWindowMessage(windows: MyBookingWindow[]): string {
+  const next = soonestUpcomingWindow(windows);
+  if (!next || !next.windowOpensAt) {
+    return "No upcoming booking window scheduled.";
+  }
+  const lane =
+    next.origin && next.destination
+      ? ` for ${next.origin}→${next.destination}`
+      : "";
+  return `Booking is not open right now. Next window: ${formatWindowOpensAt(
+    next.windowOpensAt,
+  )} EAT${lane}.`;
+}
diff --git a/apps/edr-freight-web/portal/src/pages/contracts/new-contract-form/step1-contract-type.tsx b/apps/edr-freight-web/portal/src/pages/contracts/new-contract-form/step1-contract-type.tsx
index c86e17fc5..eec7e896b 100644
--- a/apps/edr-freight-web/portal/src/pages/contracts/new-contract-form/step1-contract-type.tsx
+++ b/apps/edr-freight-web/portal/src/pages/contracts/new-contract-form/step1-contract-type.tsx
@@ -15,7 +15,8 @@ import { AlertBox, AsyncComboboxField, fieldStyles } from "./shared";
 
 const CONTRACT_TYPE_OPTIONS = [
   { value: "new", label: "New Contract" },
-  { value: "renewal", label: "Contract Renewal" },
+  // Renewal is disabled for now — not yet available to customers.
+  { value: "renewal", label: "Contract Renewal (coming soon)", disabled: true },
 ];
 
 type ContractForm = UseFormReturn<
diff --git a/apps/edr-freight-web/portal/src/services/api.ts b/apps/edr-freight-web/portal/src/services/api.ts
index ed359d998..932f6fc46 100644
--- a/apps/edr-freight-web/portal/src/services/api.ts
+++ b/apps/edr-freight-web/portal/src/services/api.ts
@@ -66,6 +66,8 @@ import type {
 import type { ProfileResponse, UpdateProfilePayload } from "@/types/profile";
 import type {
   AuthUser,
+  CheckAvailabilityPayload,
+  CheckAvailabilityResponse,
   GenerateVerificationCodePayload,
   LoginPayload,
   LoginResponse,
@@ -107,6 +109,11 @@ export const api = {
       "setPassword",
       authService.setPassword,
     ),
+    checkAvailability: endpoint<CheckAvailabilityPayload, CheckAvailabilityResponse>(
+      "auth",
+      "checkAvailability",
+      authService.checkAvailability,
+    ),
     sendOTP: endpoint<OtpPayload, OtpResponse>(
       "auth",
       "sendOTP",
@@ -376,6 +383,12 @@ export const api = {
       "myBookingWindows",
       () => bookingsService.getMyBookingWindows(),
     ),
+
+    getContractBookingWindows: endpoint<{ contractId: string }, MyBookingWindow[]>(
+      "train-scheduling",
+      "contractBookingWindows",
+      ({ contractId }) => bookingsService.getContractBookingWindows(contractId),
+    ),
   },
 
   contracts: {
diff --git a/apps/edr-freight-web/portal/src/services/auth.service.ts b/apps/edr-freight-web/portal/src/services/auth.service.ts
index e1de1889a..3f9ef4e53 100644
--- a/apps/edr-freight-web/portal/src/services/auth.service.ts
+++ b/apps/edr-freight-web/portal/src/services/auth.service.ts
@@ -1,14 +1,16 @@
 import { URL_CONSTANTS } from "@/constants/URLS";
 import type {
-    AuthUser,
-    GenerateVerificationCodePayload,
-    LoginPayload,
-    LoginResponse,
-    OtpPayload,
-    OtpResponse,
-    SetPasswordPayload,
-    SignupPayload,
-    SignupResponse,
+  AuthUser,
+  CheckAvailabilityPayload,
+  CheckAvailabilityResponse,
+  GenerateVerificationCodePayload,
+  LoginPayload,
+  LoginResponse,
+  OtpPayload,
+  OtpResponse,
+  SetPasswordPayload,
+  SignupPayload,
+  SignupResponse,
 } from "@/types/auth";
 import { client } from "@/utils/api";
 import { ApiResponse } from "@edr/types";
@@ -23,7 +25,7 @@ export const authService = {
   },
 
   createUser: async (body: SignupPayload) => {
-    const res = await client.post<SignupResponse & ApiResponse<void>> (
+    const res = await client.post<SignupResponse & ApiResponse<void>>(
       URL_CONSTANTS.USERS.SIGN_UP,
       body,
     );
@@ -31,9 +33,7 @@ export const authService = {
   },
 
   getMyInfo: async () => {
-    const res = await client.get<AuthUser>(
-      URL_CONSTANTS.USERS.ME,
-    );
+    const res = await client.get<AuthUser>(URL_CONSTANTS.USERS.ME);
     return res.data;
   },
 
@@ -53,6 +53,14 @@ export const authService = {
     return res.data.data;
   },
 
+  checkAvailability: async (params: CheckAvailabilityPayload) => {
+    const res = await client.get<CheckAvailabilityResponse>(
+      URL_CONSTANTS.USERS.CHECK_AVAILABILITY,
+      { params },
+    );
+    return res.data;
+  },
+
   sendOTP: async (body: OtpPayload) => {
     const res = await client.post<ApiResponse<OtpResponse>>(
       URL_CONSTANTS.OTP.SEND,
diff --git a/apps/edr-freight-web/portal/src/services/bookings.service.ts b/apps/edr-freight-web/portal/src/services/bookings.service.ts
index a4ce87131..c2729bebb 100644
--- a/apps/edr-freight-web/portal/src/services/bookings.service.ts
+++ b/apps/edr-freight-web/portal/src/services/bookings.service.ts
@@ -47,17 +47,26 @@ export interface PriceLineItem {
 }
 
 /**
- * An upcoming/open booking window on one of the signed-in customer's
- * active-contract lanes. Import trains open a window on one booking day;
+ * An announced upcoming/open booking window, shown to every signed-in customer
+ * regardless of contract. Import trains open a window on one booking day;
  * export trains open 24h before departure (first come, first served).
  */
 export interface MyBookingWindow {
   scheduleId: string;
+  /**
+   * The customer's active contract on this lane, when they hold one — enables
+   * "Book now" to target it. Null for lanes they have no contract on.
+   */
+  contractId: string | null;
+  /** ONE_TIME contracts can't draw down against a window — button is hidden. */
+  contractKind: "ONE_TIME" | "GENERAL" | null;
   direction: "IMPORT" | "EXPORT" | null;
   windowPhase: string | null;
   isOpenNow: boolean;
   windowOpensAt: string | null;
   windowClosesAt: string | null;
+  docReviewEndsAt: string | null;
+  paymentPhaseEndsAt: string | null;
   bookingWindowStatus: string;
   bookingCycleNo: number;
   departureDate: string;
@@ -375,4 +384,18 @@ export const bookingsService = {
     );
     return data.data ?? data;
   },
+
+  /**
+   * Booking windows for a single contract's routes (same row shape as
+   * `getMyBookingWindows`). Used to gate the direct "New shipment booking"
+   * entry on the contract detail page and the new-shipment form.
+   */
+  getContractBookingWindows: async (
+    contractId: string,
+  ): Promise<MyBookingWindow[]> => {
+    const { data } = await client.get(
+      URL_CONSTANTS.TRAIN_SCHEDULING.CONTRACT_BOOKING_WINDOWS(contractId),
+    );
+    return data.data ?? data;
+  },
 };
diff --git a/apps/edr-freight-web/portal/src/services/contracts.service.ts b/apps/edr-freight-web/portal/src/services/contracts.service.ts
index 3af87ee42..10ef9716f 100644
--- a/apps/edr-freight-web/portal/src/services/contracts.service.ts
+++ b/apps/edr-freight-web/portal/src/services/contracts.service.ts
@@ -42,14 +42,39 @@ export interface OverweightLine {
 }
 
 /**
- * Pre-submit validation for a shipment booking under a CONTAINER contract.
+ * One line of the server-priced booking breakdown — the exact line the booking
+ * will persist at create time (rail freight, first/last mile, surcharges…).
+ */
+export interface ShipmentPriceLine {
+  code: string;
+  description: string;
+  amount: number;
+  unitAmount: number;
+  /** Rate unit as stored: PER_CONTAINER | PER_WAGON | PER_TON | PER_KM | FLAT | … */
+  unit: string;
+  quantity: number;
+  currency: string;
+}
+
+/**
+ * Pre-submit validation + authoritative price preview for a shipment booking.
  * `overweightLines` are WARNINGS only (an overweight surcharge applies — the
  * customer may still submit); `pairingErrors` are HARD BLOCKS (20ft containers
  * that cannot be balanced onto wagons) and must prevent booking.
+ * `lineItems`/`totalAmount` are the full server-computed breakdown — the same
+ * BookingPricingService pass that prices the booking on create, so the confirm
+ * modal shows first/last mile, overweight, and every surcharge, not just the
+ * container estimate.
  */
 export interface ShipmentValidation {
   overweightLines: OverweightLine[];
+  overweightSurchargeAmount: number;
+  currency: string | null;
   pairingErrors: string[];
+  /** Lines above the container type's hard max capacity — booking cannot be created. */
+  capacityErrors?: string[];
+  lineItems?: ShipmentPriceLine[];
+  totalAmount?: number;
 }
 
 export interface ContractListFilter {
diff --git a/apps/edr-freight-web/portal/src/services/customer-trucks.service.ts b/apps/edr-freight-web/portal/src/services/customer-trucks.service.ts
new file mode 100644
index 000000000..ee317e204
--- /dev/null
+++ b/apps/edr-freight-web/portal/src/services/customer-trucks.service.ts
@@ -0,0 +1,33 @@
+import type { Freight } from "@edr/types";
+
+import { URL_CONSTANTS } from "@/constants/URLS";
+import { client } from "../utils/api";
+
+const B = URL_CONSTANTS.BOOKINGS;
+
+/**
+ * Multi-truck self-haul assignment for a booking (no EDR first/last mile).
+ * Each truck carries 1–2 of the booking's containers and tracks its own arrival.
+ */
+export const customerTrucksService = {
+  list: async (bookingId: string): Promise<Freight.ICustomerTruck[]> => {
+    const { data } = await client.get(B.CUSTOMER_TRUCKS(bookingId));
+    return data.data ?? data;
+  },
+
+  add: async (
+    bookingId: string,
+    payload: Freight.AddCustomerTruckPayload,
+  ): Promise<Freight.ICustomerTruck[]> => {
+    const { data } = await client.post(B.CUSTOMER_TRUCKS(bookingId), payload);
+    return data.data ?? data;
+  },
+
+  remove: async (
+    bookingId: string,
+    assignmentId: string,
+  ): Promise<Freight.ICustomerTruck[]> => {
+    const { data } = await client.delete(B.CUSTOMER_TRUCK(bookingId, assignmentId));
+    return data.data ?? data;
+  },
+};
diff --git a/apps/edr-freight-web/portal/src/services/warehouse-invoices.service.ts b/apps/edr-freight-web/portal/src/services/warehouse-invoices.service.ts
index f1fa4e841..91cd6a0d2 100644
--- a/apps/edr-freight-web/portal/src/services/warehouse-invoices.service.ts
+++ b/apps/edr-freight-web/portal/src/services/warehouse-invoices.service.ts
@@ -1,5 +1,10 @@
 import { URL_CONSTANTS } from "@/constants/URLS";
 import { client } from "../utils/api";
+import type {
+  InitiateResponse,
+  PaymentMethod,
+  PaymentPlatform,
+} from "./payments.service";
 
 const W = URL_CONSTANTS.WAREHOUSE_INVOICES;
 
@@ -51,4 +56,27 @@ export const warehouseInvoicesService = {
     const { data } = await client.get(W.RECEIPT(id), { responseType: "blob" });
     return data;
   },
+
+  /**
+   * Initiate a Telebirr/Waafi online payment for a warehouse demurrage/storage
+   * invoice. Returns the payment intent + `clientAction` to redirect the browser
+   * to the provider (mirrors the booking `/pay` flow). The backoffice cash
+   * `/pay` (record-a-payment) path is unaffected.
+   */
+  payOnline: async (
+    id: string,
+    payload: {
+      method: PaymentMethod;
+      platform?: PaymentPlatform;
+      payerAccount?: string;
+      returnUrl?: string;
+      failureUrl?: string;
+    },
+  ): Promise<InitiateResponse> => {
+    const { data } = await client.post(W.PAY_ONLINE(id), {
+      platform: "web",
+      ...payload,
+    });
+    return data.data ?? data;
+  },
 };
diff --git a/apps/edr-freight-web/portal/src/types/auth.ts b/apps/edr-freight-web/portal/src/types/auth.ts
index 7b58f573b..04357a9ca 100644
--- a/apps/edr-freight-web/portal/src/types/auth.ts
+++ b/apps/edr-freight-web/portal/src/types/auth.ts
@@ -45,6 +45,16 @@ export interface OtpResponse {
   message: string;
 }
 
+export interface CheckAvailabilityPayload {
+  email?: string;
+  phone?: string;
+}
+
+export interface CheckAvailabilityResponse {
+  emailTaken: boolean;
+  phoneTaken: boolean;
+}
+
 export interface SetPasswordPayload {
   newPassword: string;
   confirmPassword: string;
diff --git a/apps/edr-passenger-api/prisma/migrations/20260704132103_add_package_fields_to_booking/migration.sql b/apps/edr-passenger-api/prisma/migrations/20260704132103_add_package_fields_to_booking/migration.sql
new file mode 100644
index 000000000..365c15559
--- /dev/null
+++ b/apps/edr-passenger-api/prisma/migrations/20260704132103_add_package_fields_to_booking/migration.sql
@@ -0,0 +1,9 @@
+-- AlterTable
+ALTER TABLE "Booking" ADD COLUMN     "packageId" TEXT,
+ADD COLUMN     "priceTierId" TEXT;
+
+-- AddForeignKey
+ALTER TABLE "Booking" ADD CONSTRAINT "Booking_packageId_fkey" FOREIGN KEY ("packageId") REFERENCES "TravelPackage"("id") ON DELETE SET NULL ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "Booking" ADD CONSTRAINT "Booking_priceTierId_fkey" FOREIGN KEY ("priceTierId") REFERENCES "PackagePriceTier"("id") ON DELETE SET NULL ON UPDATE CASCADE;
diff --git a/apps/edr-passenger-api/prisma/migrations/20260704212551_add_fraud_alert_acknowledged_at/migration.sql b/apps/edr-passenger-api/prisma/migrations/20260704212551_add_fraud_alert_acknowledged_at/migration.sql
new file mode 100644
index 000000000..51e09889a
--- /dev/null
+++ b/apps/edr-passenger-api/prisma/migrations/20260704212551_add_fraud_alert_acknowledged_at/migration.sql
@@ -0,0 +1,2 @@
+-- AlterTable
+ALTER TABLE "FraudAlert" ADD COLUMN     "acknowledgedAt" TIMESTAMP(3);
diff --git a/apps/edr-passenger-api/prisma/migrations/20260705000000_add_app_releases/migration.sql b/apps/edr-passenger-api/prisma/migrations/20260705000000_add_app_releases/migration.sql
new file mode 100644
index 000000000..0ce87d7de
--- /dev/null
+++ b/apps/edr-passenger-api/prisma/migrations/20260705000000_add_app_releases/migration.sql
@@ -0,0 +1,13 @@
+CREATE TABLE "passenger"."AppRelease" (
+  "id"          TEXT NOT NULL,
+  "os"          TEXT NOT NULL,
+  "version"     TEXT NOT NULL,
+  "forceUpdate" BOOLEAN NOT NULL DEFAULT false,
+  "storeLink"   TEXT,
+  "notes"       TEXT,
+  "createdAt"   TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  "updatedAt"   TIMESTAMP(3) NOT NULL,
+  CONSTRAINT "AppRelease_pkey" PRIMARY KEY ("id")
+);
+
+CREATE UNIQUE INDEX "AppRelease_os_version_key" ON "passenger"."AppRelease"("os", "version");
diff --git a/apps/edr-passenger-api/prisma/migrations/20260706000000_add_departure_station_to_bookings/migration.sql b/apps/edr-passenger-api/prisma/migrations/20260706000000_add_departure_station_to_bookings/migration.sql
new file mode 100644
index 000000000..f782c3c64
--- /dev/null
+++ b/apps/edr-passenger-api/prisma/migrations/20260706000000_add_departure_station_to_bookings/migration.sql
@@ -0,0 +1,21 @@
+-- AlterTable: add package_departure_station_id to Booking
+ALTER TABLE "passenger"."Booking"
+  ADD COLUMN "packageDepartureStationId" TEXT;
+
+-- AlterTable: add package_departure_station_id to PackageBooking
+ALTER TABLE "passenger"."PackageBooking"
+  ADD COLUMN "packageDepartureStationId" TEXT;
+
+-- AddForeignKey: Booking -> Station
+ALTER TABLE "passenger"."Booking"
+  ADD CONSTRAINT "Booking_packageDepartureStationId_fkey"
+  FOREIGN KEY ("packageDepartureStationId")
+  REFERENCES "passenger"."Station"("id")
+  ON DELETE SET NULL ON UPDATE CASCADE;
+
+-- AddForeignKey: PackageBooking -> Station
+ALTER TABLE "passenger"."PackageBooking"
+  ADD CONSTRAINT "PackageBooking_packageDepartureStationId_fkey"
+  FOREIGN KEY ("packageDepartureStationId")
+  REFERENCES "passenger"."Station"("id")
+  ON DELETE SET NULL ON UPDATE CASCADE;
diff --git a/apps/edr-passenger-api/prisma/schema.prisma b/apps/edr-passenger-api/prisma/schema.prisma
index 68b3ac234..83c2b884e 100644
--- a/apps/edr-passenger-api/prisma/schema.prisma
+++ b/apps/edr-passenger-api/prisma/schema.prisma
@@ -330,7 +330,9 @@ model Station {
   originSchedules      TrainSchedule[] @relation("OriginTrips")
   destinationSchedules TrainSchedule[] @relation("DestinationTrips")
   stopTimes            TripStopTime[]
-  crowdSignals         StationCrowdSignal[]
+  crowdSignals             StationCrowdSignal[]
+  bookingDepartures        Booking[]        @relation("BookingPackageDepartureStation")
+  packageBookingDepartures PackageBooking[] @relation("PackageBookingDepartureStation")
   @@index([city, countryCode])
   @@index([sequence])
   @@schema("passenger")
@@ -506,6 +508,8 @@ model Booking {
   bookingRef                String                @unique
   passengerId               String
   scheduleId                String
+  packageId                 String?
+  priceTierId               String?
   bookingType               String                @default("ONE_WAY")
   status                    BookingStatus         @default(DRAFT)
   currency                  String                @default("ETB")
@@ -539,11 +543,15 @@ model Booking {
   promoCode                 String?
   paidAt                    DateTime?
   paymentReminderSentAt     DateTime?
+  packageDepartureStationId String?
   createdAt                 DateTime              @default(now())
   updatedAt                 DateTime              @updatedAt
   passenger                 Passenger             @relation(fields: [passengerId], references: [id])
   schedule                  TrainSchedule         @relation("OutboundSchedule", fields: [scheduleId], references: [id])
   returnSchedule            TrainSchedule?        @relation("ReturnSchedule", fields: [returnScheduleId], references: [id])
+  package                   TravelPackage?        @relation(fields: [packageId], references: [id])
+  priceTier                 PackagePriceTier?     @relation(fields: [priceTierId], references: [id])
+  departureStation          Station?              @relation("BookingPackageDepartureStation", fields: [packageDepartureStationId], references: [id])
   seats                     BookingSeat[]
   paymentIntent             PaymentIntent?
   tickets                   Ticket[]
@@ -1301,6 +1309,7 @@ model FraudAlert {
   context        Json
   severity       String   @default("MEDIUM")
   acknowledged   Boolean  @default(false)
+  acknowledgedAt DateTime?
   createdAt      DateTime @default(now())
   @@index([iamUserId, createdAt])
   @@index([acknowledged])
@@ -1428,7 +1437,8 @@ model TravelPackage {
   outboundSchedule     TrainSchedule      @relation("PackageOutbound", fields: [outboundScheduleId], references: [id])
   returnSchedule       TrainSchedule      @relation("PackageReturn",   fields: [returnScheduleId],   references: [id])
   priceTiers           PackagePriceTier[]
-  bookings             PackageBooking[]
+  bookings             Booking[]
+  packageBookings      PackageBooking[]
   inquiries            PackageInquiry[]
 
   @@index([status, validFrom])
@@ -1446,7 +1456,8 @@ model PackagePriceTier {
   bookedSeats    Int            @default(0)
 
   package        TravelPackage   @relation(fields: [packageId], references: [id])
-  bookings       PackageBooking[]
+  bookings       Booking[]
+  packageBookings PackageBooking[]
   inquiries      PackageInquiry[]
 
   @@unique([packageId, seatType])
@@ -1472,10 +1483,12 @@ model PackageBooking {
   paidAt            DateTime?
   createdAt         DateTime      @default(now())
   updatedAt         DateTime      @updatedAt
+  packageDepartureStationId String?
 
   package           TravelPackage             @relation(fields: [packageId], references: [id])
   priceTier         PackagePriceTier          @relation(fields: [priceTierId], references: [id])
   passenger         Passenger?                @relation(fields: [passengerId], references: [id])
+  departureStation  Station?                  @relation("PackageBookingDepartureStation", fields: [packageDepartureStationId], references: [id])
   passengers        PackageBookingPassenger[]
   paymentIntent     PackagePaymentIntent?
 
@@ -1536,3 +1549,17 @@ model PackageInquiry {
   @@index([packageId])
   @@schema("passenger")
 }
+
+model AppRelease {
+  id          String   @id @default(uuid())
+  os          String   // "android" | "ios"
+  version     String
+  forceUpdate Boolean  @default(false)
+  storeLink   String?
+  notes       String?
+  createdAt   DateTime @default(now())
+  updatedAt   DateTime @updatedAt
+
+  @@unique([os, version])
+  @@schema("passenger")
+}
diff --git a/apps/edr-passenger-api/prisma/seed.ts b/apps/edr-passenger-api/prisma/seed.ts
index 0e9f85079..313ce34b0 100644
--- a/apps/edr-passenger-api/prisma/seed.ts
+++ b/apps/edr-passenger-api/prisma/seed.ts
@@ -854,26 +854,64 @@ async function runStep(name: string, step: () => Promise<unknown>): Promise<bool
   }
 }
 
+async function seedPackageBookings() {
+  const pkg = await prisma.travelPackage.findFirst({ where: { code: 'KULUBBI-2025' }, include: { priceTiers: true } });
+  if (!pkg || !pkg.priceTiers.length) {
+    console.log('  ⚠️  Kulubbi package not found, skipping package booking seed');
+    return;
+  }
+  const tier = pkg.priceTiers[0];
+  const passenger = await prisma.passenger.findFirst();
+
+  const existing = await prisma.packageBooking.findFirst({ where: { bookingRef: 'PKG-SEED01' } });
+  if (existing) { console.log('  ℹ️  Package booking seed already exists'); return; }
+
+  await prisma.packageBooking.create({
+    data: {
+      bookingRef: 'PKG-SEED01',
+      packageId: pkg.id,
+      priceTierId: tier.id,
+      passengerId: passenger?.id ?? null,
+      contactEmail: 'kelemu@email.com',
+      contactPhone: '+251911234567',
+      passengerCount: 2,
+      totalMinor: tier.priceMinor * 2,
+      currency: 'ETB',
+      displayCurrency: 'ETB',
+      displayTotalMinor: tier.priceMinor * 2,
+      status: 'PENDING_PAYMENT',
+      passengers: {
+        create: [
+          { passengerName: 'Abebe Kebede', idDocumentType: 'NATIONAL_ID' },
+          { passengerName: 'Tigist Alemu', idDocumentType: 'NATIONAL_ID' },
+        ],
+      },
+    },
+  });
+  console.log('  ✅ Sample package booking created (PKG-SEED01)');
+}
+
 async function main() {
   console.log('🌱 Comprehensive EDR Seed Starting...\n');
 
   const steps: Array<[string, () => Promise<unknown>]> = [
-    ['System Users', seedSystemUsers],
-    ['Stations', seedStations],
-    ['Coach Types & Classes', seedCoachTypesAndClasses],
-    ['Route', seedRoute],
-    ['Coaches', seedCoaches],
-    ['Trips', seedTrips],
-    ['Fare Rules', seedFareRules],
-    ['Currency', seedCurrency],
-    ['Payment Methods', seedPaymentMethods],
-    ['Segment Fares', seedSegmentFares],
-    ['Notification Templates', seedNotificationTemplates],
-    ['Menu & Food', seedMenuAndFood],
-    ['Promotions', seedPromotions],
-    ['FAQ', seedFAQ],
-    ['Fraud Rules', seedFraudRules],
-    ['Kulubbi Package', seedKulubbiPackage],
+    // ['System Users', seedSystemUsers],
+    // ['Stations', seedStations],
+    // ['Coach Types & Classes', seedCoachTypesAndClasses],
+    // ['Route', seedRoute],
+    // ['Coaches', seedCoaches],
+    // ['Trips', seedTrips],
+    // ['Fare Rules', seedFareRules],
+    // ['Currency', seedCurrency],
+    // ['Payment Methods', seedPaymentMethods],
+    // ['Segment Fares', seedSegmentFares],
+    // ['Notification Templates', seedNotificationTemplates],
+    // ['Menu & Food', seedMenuAndFood],
+    // ['Promotions', seedPromotions],
+    // ['FAQ', seedFAQ],
+    // ['Fraud Rules', seedFraudRules],
+    // ['Kulubbi Package', seedKulubbiPackage],
+    // ['Package Bookings', seedPackageBookings],
   ];
 
   let failed = 0;
diff --git a/apps/edr-passenger-api/src/app.module.ts b/apps/edr-passenger-api/src/app.module.ts
index ba7a18086..1e41076e7 100644
--- a/apps/edr-passenger-api/src/app.module.ts
+++ b/apps/edr-passenger-api/src/app.module.ts
@@ -61,6 +61,9 @@ import { PackagesModule } from './modules/packages/packages.module';
 import { ExcessBaggageModule } from './modules/excess-baggage/excess-baggage.module';
 import { HealthModule } from './modules/health/health.module';
 import { TasksModule } from './modules/tasks/tasks.module';
+import { AppReleasesModule } from './modules/app-releases/app-releases.module';
+import { ConfigurableFareModule } from './modules/configurable-fare/configurable-fare.module';
+import { SegmentFareSeeder } from './seed/segment-fare.seeder';
 
 @Module({
   imports: [
@@ -130,6 +133,8 @@ import { TasksModule } from './modules/tasks/tasks.module';
     ExcessBaggageModule,
     HealthModule,
     TasksModule,
+    AppReleasesModule,
+    ConfigurableFareModule,
   ],
   providers: [
     { provide: APP_GUARD, useClass: DynamicThrottlerGuard },
@@ -137,6 +142,7 @@ import { TasksModule } from './modules/tasks/tasks.module';
     DynamicThrottlerGuard,
     EdrPassengerOrgSeeder,
     PassengerStaffUsersSeeder,
+    SegmentFareSeeder,
   ],
 })
 export class AppModule implements OnApplicationBootstrap {
@@ -145,6 +151,7 @@ export class AppModule implements OnApplicationBootstrap {
     private readonly seeder: DataSeeder,
     private readonly edrPassengerOrgSeeder: EdrPassengerOrgSeeder,
     private readonly passengerStaffUsersSeeder: PassengerStaffUsersSeeder,
+    private readonly segmentFareSeeder: SegmentFareSeeder,
   ) {}
 
   async onApplicationBootstrap() {
@@ -163,5 +170,10 @@ export class AppModule implements OnApplicationBootstrap {
     } catch (err) {
       this.logger.error('[PassengerStaffUsersSeeder] Seed failed (non-fatal):', (err as Error).message);
     }
+    try {
+      await this.segmentFareSeeder.run();
+    } catch (err) {
+      this.logger.error('[SegmentFareSeeder] Seed failed (non-fatal):', (err as Error).message);
+    }
   }
 }
diff --git a/apps/edr-passenger-api/src/common/filters/http-exception.filter.ts b/apps/edr-passenger-api/src/common/filters/http-exception.filter.ts
index 39d492b2c..0cc8d93b6 100644
--- a/apps/edr-passenger-api/src/common/filters/http-exception.filter.ts
+++ b/apps/edr-passenger-api/src/common/filters/http-exception.filter.ts
@@ -6,6 +6,7 @@ import {
   HttpStatus,
   Logger,
 } from '@nestjs/common';
+import { PrismaClientKnownRequestError } from '@prisma/client/runtime/library';
 
 @Catch()
 export class HttpExceptionFilter implements ExceptionFilter {
@@ -22,15 +23,27 @@ export class HttpExceptionFilter implements ExceptionFilter {
     const response = ctx.getResponse();
     const request = ctx.getRequest();
 
+    let prismaMessage: string | null = null;
+    if (exception instanceof PrismaClientKnownRequestError) {
+      if (exception.code === 'P2003') {
+        const field = (exception.meta?.field_name as string | undefined) ?? 'a related record';
+        prismaMessage = `Cannot delete this record because it is still referenced by ${field}. Remove the related records first.`;
+      } else if (exception.code === 'P2025') {
+        prismaMessage = 'Record not found.';
+      }
+    }
+
     const status =
       exception instanceof HttpException
         ? exception.getStatus()
-        : HttpStatus.INTERNAL_SERVER_ERROR;
+        : prismaMessage
+          ? HttpStatus.BAD_REQUEST
+          : HttpStatus.INTERNAL_SERVER_ERROR;
 
     const messageRaw =
       exception instanceof HttpException
         ? exception.getResponse()
-        : 'Internal server error';
+        : prismaMessage ?? 'Internal server error';
 
     const message =
       typeof messageRaw === 'string'
diff --git a/apps/edr-passenger-api/src/modules/app-releases/app-releases.controller.ts b/apps/edr-passenger-api/src/modules/app-releases/app-releases.controller.ts
new file mode 100644
index 000000000..7fbfa7de0
--- /dev/null
+++ b/apps/edr-passenger-api/src/modules/app-releases/app-releases.controller.ts
@@ -0,0 +1,50 @@
+import { Body, Controller, Delete, Get, Param, Patch, Post, SetMetadata } from '@nestjs/common';
+import { ApiTags, ApiBearerAuth, ApiOperation, ApiParam } from '@nestjs/swagger';
+import { AppReleasesService, AppReleaseDto } from './app-releases.service';
+import { PassengerStaff } from '../../common/passenger-guards';
+import { PASSENGER_PERMS } from '../../seed/passenger-permissions.registry';
+
+@ApiTags('App Releases')
+@Controller('app-releases')
+export class AppReleasesController {
+  constructor(private service: AppReleasesService) {}
+
+  @Get()
+  @SetMetadata('isPublic', true)
+  @ApiOperation({ summary: 'List all app releases (public)' })
+  getAll() {
+    return this.service.getAll();
+  }
+
+  @Get('latest/:os')
+  @SetMetadata('isPublic', true)
+  @ApiOperation({ summary: 'Get latest release for a given OS (public)' })
+  @ApiParam({ name: 'os', enum: ['android', 'ios'] })
+  getLatest(@Param('os') os: string) {
+    return this.service.getLatest(os);
+  }
+
+  @Post()
+  @PassengerStaff(PASSENGER_PERMS.admin)
+  @ApiBearerAuth('IAM-auth')
+  @ApiOperation({ summary: 'Create an app release (admin)' })
+  create(@Body() dto: AppReleaseDto) {
+    return this.service.create(dto);
+  }
+
+  @Patch(':id')
+  @PassengerStaff(PASSENGER_PERMS.admin)
+  @ApiBearerAuth('IAM-auth')
+  @ApiOperation({ summary: 'Update an app release (admin)' })
+  update(@Param('id') id: string, @Body() dto: Partial<AppReleaseDto>) {
+    return this.service.update(id, dto);
+  }
+
+  @Delete(':id')
+  @PassengerStaff(PASSENGER_PERMS.admin)
+  @ApiBearerAuth('IAM-auth')
+  @ApiOperation({ summary: 'Delete an app release (admin)' })
+  remove(@Param('id') id: string) {
+    return this.service.remove(id);
+  }
+}
diff --git a/apps/edr-passenger-api/src/modules/app-releases/app-releases.module.ts b/apps/edr-passenger-api/src/modules/app-releases/app-releases.module.ts
new file mode 100644
index 000000000..89e1f733a
--- /dev/null
+++ b/apps/edr-passenger-api/src/modules/app-releases/app-releases.module.ts
@@ -0,0 +1,11 @@
+import { Module } from '@nestjs/common';
+import { AppReleasesController } from './app-releases.controller';
+import { AppReleasesService } from './app-releases.service';
+import { PrismaModule } from '../../common/prisma.module';
+
+@Module({
+  imports: [PrismaModule],
+  controllers: [AppReleasesController],
+  providers: [AppReleasesService],
+})
+export class AppReleasesModule {}
diff --git a/apps/edr-passenger-api/src/modules/app-releases/app-releases.service.ts b/apps/edr-passenger-api/src/modules/app-releases/app-releases.service.ts
new file mode 100644
index 000000000..16b221ecc
--- /dev/null
+++ b/apps/edr-passenger-api/src/modules/app-releases/app-releases.service.ts
@@ -0,0 +1,71 @@
+import { Injectable, NotFoundException, ConflictException } from '@nestjs/common';
+import { IsBoolean, IsIn, IsOptional, IsString } from 'class-validator';
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+import { PrismaService } from '../../common/prisma.service';
+
+export class AppReleaseDto {
+  @ApiProperty({ enum: ['android', 'ios'] })
+  @IsIn(['android', 'ios'])
+  os: string;
+
+  @ApiProperty({ example: '1.2.3' })
+  @IsString()
+  version: string;
+
+  @ApiProperty({ default: false })
+  @IsBoolean()
+  forceUpdate: boolean;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsString()
+  storeLink?: string;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsString()
+  notes?: string;
+}
+
+@Injectable()
+export class AppReleasesService {
+  constructor(private prisma: PrismaService) {}
+
+  private get db() {
+    return (this.prisma as any);
+  }
+
+  getAll() {
+    return this.db.appRelease.findMany({ orderBy: [{ os: 'asc' }, { createdAt: 'desc' }] });
+  }
+
+  async getLatest(os: string) {
+    const release = await this.db.appRelease.findFirst({
+      where: { os },
+      orderBy: { createdAt: 'desc' },
+    });
+    if (!release) throw new NotFoundException(`No release found for ${os}`);
+    return release;
+  }
+
+  async create(dto: AppReleaseDto) {
+    const existing = await this.db.appRelease.findUnique({
+      where: { os_version: { os: dto.os, version: dto.version } },
+    });
+    if (existing) throw new ConflictException(`Release ${dto.os} ${dto.version} already exists`);
+    return this.db.appRelease.create({ data: dto });
+  }
+
+  async update(id: string, dto: Partial<AppReleaseDto>) {
+    const release = await this.db.appRelease.findUnique({ where: { id } });
+    if (!release) throw new NotFoundException('App release not found');
+    return this.db.appRelease.update({ where: { id }, data: dto });
+  }
+
+  async remove(id: string) {
+    const release = await this.db.appRelease.findUnique({ where: { id } });
+    if (!release) throw new NotFoundException('App release not found');
+    await this.db.appRelease.delete({ where: { id } });
+    return { deleted: true, id };
+  }
+}
diff --git a/apps/edr-passenger-api/src/modules/audit/audit.controller.ts b/apps/edr-passenger-api/src/modules/audit/audit.controller.ts
index 1202e4d45..3a1e94760 100644
--- a/apps/edr-passenger-api/src/modules/audit/audit.controller.ts
+++ b/apps/edr-passenger-api/src/modules/audit/audit.controller.ts
@@ -30,8 +30,8 @@ export class AuditController {
       entityType: entityType || undefined,
     };
 
-    const items = await this.auditService.getLogs(filters);
-    return { items };
+    const result = await this.auditService.getLogs(filters);
+    return { items: result.data, total: result.total, limit: result.limit, offset: result.offset };
   }
 
   @Get('logs/:id')
diff --git a/apps/edr-passenger-api/src/modules/auth/auth.controller.ts b/apps/edr-passenger-api/src/modules/auth/auth.controller.ts
index d53ef40d7..a6f596bf6 100644
--- a/apps/edr-passenger-api/src/modules/auth/auth.controller.ts
+++ b/apps/edr-passenger-api/src/modules/auth/auth.controller.ts
@@ -3,7 +3,7 @@ import { ApiTags, ApiOperation, ApiResponse, ApiBody, ApiBearerAuth } from '@nes
 import { Throttle, SkipThrottle } from '@nestjs/throttler';
 import { IsPublic } from '@tria-plc/api-common/modules/auth/decorators/public.decorator';
 import { PassengerAuthService } from './passenger-auth.service';
-import { RegisterDto, LoginDto, FaydaRequestPasswordSetupDto, FaydaVerifyAndLoginDto } from './auth.dto';
+import { RegisterDto, LoginDto, ResendRegistrationCodeDto, FaydaRequestPasswordSetupDto, FaydaVerifyAndLoginDto } from './auth.dto';
 import { JwtGuard } from '../../common/jwt.guard';
 
 @ApiTags('Passenger Auth')
@@ -14,14 +14,28 @@ export class AuthController {
 
   @Post('register')
   @IsPublic()
-  @ApiOperation({ summary: 'Register new passenger account' })
-  @ApiResponse({ status: 201, description: 'Account created. Returns token + user.' })
+  @ApiOperation({ summary: 'Register new passenger account (sends SMS verification code)' })
+  @ApiResponse({
+    status: 201,
+    description:
+      'Account created as pending. A verification code is sent via SMS — complete signup via PATCH /v1/auth/set-password.',
+  })
   @ApiResponse({ status: 409, description: 'Email or phone already registered' })
   @ApiBody({ type: RegisterDto })
   register(@Request() req: any, @Body() dto: RegisterDto) {
     return this.passengerAuthService.register(dto, req);
   }
 
+  @Post('register/resend-code')
+  @IsPublic()
+  @HttpCode(HttpStatus.OK)
+  @ApiOperation({ summary: 'Resend the registration verification code for a pending account' })
+  @ApiResponse({ status: 200, description: 'Verification code re-sent if the account is pending.' })
+  @ApiBody({ type: ResendRegistrationCodeDto })
+  resendRegistrationCode(@Request() req: any, @Body() dto: ResendRegistrationCodeDto) {
+    return this.passengerAuthService.resendRegistrationCode(dto, req);
+  }
+
   @Post('login')
   @IsPublic()
   @HttpCode(HttpStatus.OK)
diff --git a/apps/edr-passenger-api/src/modules/auth/auth.dto.ts b/apps/edr-passenger-api/src/modules/auth/auth.dto.ts
index 6f43e7212..d0a691b0f 100644
--- a/apps/edr-passenger-api/src/modules/auth/auth.dto.ts
+++ b/apps/edr-passenger-api/src/modules/auth/auth.dto.ts
@@ -1,6 +1,6 @@
-import { IsEmail, IsString, MinLength, ValidateNested } from 'class-validator';
+import { IsEmail, IsString, ValidateNested } from 'class-validator';
 import { Type } from 'class-transformer';
-import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+import { ApiProperty } from '@nestjs/swagger';
 
 export class NameDto {
   @ApiProperty({ example: 'ቀለሙ ቀጸላ' })
@@ -29,15 +29,16 @@ export class RegisterDto {
   @ValidateNested()
   @Type(() => NameDto)
   name: NameDto;
+}
 
-  @ApiProperty({ example: 'SecurePass123', minLength: 8, format: 'password' })
-  @IsString()
-  @MinLength(8)
-  password: string;
+export class ResendRegistrationCodeDto {
+  @ApiProperty({ example: 'kelemu@email.com' })
+  @IsEmail()
+  email: string;
 
-  @ApiProperty({ example: 'SecurePass123', format: 'password' })
+  @ApiProperty({ example: '+251912345678' })
   @IsString()
-  confirmPassword: string;
+  phoneNumber: string;
 }
 
 export class LoginDto {
diff --git a/apps/edr-passenger-api/src/modules/auth/passenger-auth.service.ts b/apps/edr-passenger-api/src/modules/auth/passenger-auth.service.ts
index 0213bb8f6..1784261e5 100644
--- a/apps/edr-passenger-api/src/modules/auth/passenger-auth.service.ts
+++ b/apps/edr-passenger-api/src/modules/auth/passenger-auth.service.ts
@@ -50,14 +50,17 @@ export class PassengerAuthService {
 
     const iamAuthService = await this.resolveIamAuthService(req);
 
-    const { token, refreshToken } = await iamAuthService.signupWithPassword({
+    // IAM `signup` creates the user as PENDING/isActive=false with NO credential and
+    // SMS-sends a 6-digit verification code. The account cannot log in until the code is
+    // redeemed via PATCH /v1/auth/set-password. We intentionally discard the session
+    // token `signup` returns — the account is not verified yet, so it must never reach
+    // the client.
+    await iamAuthService.signup({
       email: dto.email,
       username: dto.username,
       phoneNumber: dto.phoneNumber,
       userType: EUserType.INDIVIDUAL,
       name: dto.name,
-      password: dto.password,
-      confirmPassword: dto.confirmPassword,
     });
 
     const iamRows = await this.dataSource.query<IamUserRow[]>(
@@ -70,20 +73,98 @@ export class PassengerAuthService {
     }
     const iamUserId = iamRows[0].id;
 
-    let passengerId: string;
+    // The Prisma "passenger satellite" (Passenger + wallet + loyalty) is NOT provisioned
+    // here — `login()` lazy-provisions it on first successful login, so satellites exist
+    // only for verified users who complete set-password and sign in.
+    return {
+      iamUserId,
+      email: dto.email,
+      phoneNumber: dto.phoneNumber,
+      requiresPasswordSetup: true,
+    };
+  }
+
+  /**
+   * Immediate-activation account creation used by the payment-gated guest-checkout
+   * "create account" path only. Unlike the public `register()` (OTP-gated), this creates a
+   * ready-to-use account from the password entered at checkout and provisions the passenger
+   * satellite synchronously so the booking can attach to it. Do NOT wire this to the public
+   * registration form — that flow must stay behind SMS verification.
+   */
+  async registerWithPassword(
+    dto: {
+      email: string;
+      username: string;
+      phoneNumber: string;
+      name: { en: string; am: string };
+      password: string;
+    },
+    req: any,
+  ): Promise<{ iamUserId: string; passengerId: string }> {
+    const existing = await this.dataSource.query<{ id: string }[]>(
+      `SELECT id FROM iam.users WHERE email = $1 OR phone_number = $2 LIMIT 1`,
+      [dto.email, dto.phoneNumber],
+    );
+    if (existing.length) throw new ConflictException('Email or phone already registered');
+
+    const iamAuthService = await this.resolveIamAuthService(req);
+    await iamAuthService.signupWithPassword({
+      email: dto.email,
+      username: dto.username,
+      phoneNumber: dto.phoneNumber,
+      userType: EUserType.INDIVIDUAL,
+      name: dto.name,
+      password: dto.password,
+      confirmPassword: dto.password,
+    });
+
+    const iamRows = await this.dataSource.query<IamUserRow[]>(
+      `SELECT id, email, name, phone_number, metadata FROM iam.users WHERE email = $1 LIMIT 1`,
+      [dto.email],
+    );
+    if (!iamRows.length) {
+      await this.compensateIamSignup(dto.email);
+      throw new InternalServerErrorException('Account creation failed. Please try again.');
+    }
+    const iamUserId = iamRows[0].id;
+
     try {
       const result = await this.provisionPassengerSatellite({ iamUserId, auditAction: 'USER_REGISTERED' });
-      passengerId = result.passengerId;
+      return { iamUserId, passengerId: result.passengerId };
     } catch {
       await this.compensateIamSignup(dto.email);
       throw new InternalServerErrorException('Account creation failed. Please try again.');
     }
+  }
 
-    return {
-      token,
-      refreshToken,
-      user: { id: iamUserId, iamUserId, email: dto.email, fullName: dto.name.en, passengerId },
-    };
+  async resendRegistrationCode(
+    dto: { email: string; phoneNumber: string },
+    req: any,
+  ): Promise<{ sent: boolean }> {
+    // Only regenerate for accounts still pending password setup. A fully-registered user
+    // should use forgot-password instead. Always return { sent: true } to avoid leaking
+    // whether the email/phone maps to a pending account (enumeration guard).
+    const users = await this.dataSource.query<{ email: string; phone_number: string }[]>(
+      `SELECT email, phone_number FROM iam.users
+        WHERE email = $1 AND phone_number = $2 AND has_set_password = false LIMIT 1`,
+      [dto.email, dto.phoneNumber],
+    );
+    if (!users.length) return { sent: true };
+
+    const iamAuthService = await this.resolveIamAuthService(req);
+    try {
+      await iamAuthService.generateVerificationCode({
+        email: users[0].email,
+        phoneNumber: users[0].phone_number,
+        type: EOtpType.VERIFY_PHONE_NUMBER,
+      });
+    } catch (err) {
+      this.logger.error(
+        `[PassengerAuthService] resend registration code failed for ${dto.email}`,
+        (err as Error).message,
+      );
+    }
+    return { sent: true };
   }
 
   async login(dto: LoginDto, req: any) {
diff --git a/apps/edr-passenger-api/src/modules/bookings/bookings.dto.ts b/apps/edr-passenger-api/src/modules/bookings/bookings.dto.ts
index 5df5f7107..6e45aeab4 100644
--- a/apps/edr-passenger-api/src/modules/bookings/bookings.dto.ts
+++ b/apps/edr-passenger-api/src/modules/bookings/bookings.dto.ts
@@ -137,6 +137,12 @@ export class CreateBookingDto {
   @IsArray() @ValidateNested({ each: true }) @Type(() => PassengerInputDto) 
   passengers: PassengerInputDto[];
 
+  @ApiPropertyOptional({ description: 'Package ID — when set, fare is taken from the package price tier instead of the fare engine' })
+  @IsOptional() @IsString() packageId?: string;
+
+  @ApiPropertyOptional({ description: 'Package price tier ID — required when packageId is provided' })
+  @IsOptional() @IsString() priceTierId?: string;
+
   @ApiPropertyOptional({ description: 'Promo code for discount (applies to combined fare for round-trip)' }) 
   @IsOptional() @IsString() promoCode?: string;
   
diff --git a/apps/edr-passenger-api/src/modules/bookings/bookings.service.ts b/apps/edr-passenger-api/src/modules/bookings/bookings.service.ts
index 2ca7d5ac4..9ed00249c 100644
--- a/apps/edr-passenger-api/src/modules/bookings/bookings.service.ts
+++ b/apps/edr-passenger-api/src/modules/bookings/bookings.service.ts
@@ -202,9 +202,12 @@ export class BookingsService {
   async findAll(filters: BookingFilters = {}) {
     const { search, status, returnLegStatus, bookingType, paymentStatus, dateFrom, dateTo, page = 1, pageSize = 20 } = filters;
     const skip = (page - 1) * pageSize;
-    
+
+    const onlyPackages = bookingType === 'PACKAGE';
+    const includePackageBookings = !returnLegStatus && bookingType !== 'ONE_WAY' && bookingType !== 'ROUND_TRIP' && bookingType !== 'TRANSIT' && bookingType !== 'ROUND_TRIP_TRANSIT';
+
     const where: any = {};
-    
+
     if (search) {
       const iamRows = await this.dataSource.query<{ id: string }[]>(
         `SELECT u.id FROM iam.users u
@@ -229,10 +232,10 @@ export class BookingsService {
         { seats: { some: { passengerName: { contains: search, mode: 'insensitive' } } } },
       ];
     }
-    
+
     if (status) where.status = status;
     if (returnLegStatus) (where as any).returnLegStatus = returnLegStatus;
-    if (bookingType) where.bookingType = bookingType;
+    if (bookingType && !onlyPackages) where.bookingType = bookingType;
     if (dateFrom || dateTo) {
       where.createdAt = {
         ...(dateFrom ? { gte: new Date(dateFrom) } : {}),
@@ -240,17 +243,126 @@ export class BookingsService {
       };
     }
     if (paymentStatus) {
-      const statusMap: Record<string, string> = {
-        PAID: 'SUCCEEDED',
-        PENDING: 'REQUIRES_ACTION',
-        FAILED: 'FAILED',
-        REFUNDED: 'REFUNDED',
-      };
+      const statusMap: Record<string, string> = { PAID: 'SUCCEEDED', PENDING: 'REQUIRES_ACTION', FAILED: 'FAILED', REFUNDED: 'REFUNDED' };
       const mapped = statusMap[paymentStatus] ?? paymentStatus;
       where.paymentIntent = { is: { status: mapped } };
     }
-    
-    const [items, total] = await Promise.all([
+
+    const pkgWhere: any = {};
+    if (search) {
+      pkgWhere.OR = [
+        { bookingRef: { contains: search, mode: 'insensitive' } },
+        { contactEmail: { contains: search, mode: 'insensitive' } },
+        { contactPhone: { contains: search, mode: 'insensitive' } },
+        { passengers: { some: { passengerName: { contains: search, mode: 'insensitive' } } } },
+      ];
+    }
+    if (status) pkgWhere.status = status;
+    if (dateFrom || dateTo) pkgWhere.createdAt = where.createdAt;
+    if (paymentStatus) pkgWhere.paymentIntent = { is: { status: (where.paymentIntent as any)?.is?.status } };
+
+    if (onlyPackages) {
+      // Package bookings live in two places:
+      // 1. PackageBooking table (dedicated package bookings)
+      // 2. Booking table with packageId != null (round-trip bookings linked to a package)
+      const bookingPkgWhere: any = { packageId: { not: null } };
+      if (status) bookingPkgWhere.status = status;
+      if (dateFrom || dateTo) bookingPkgWhere.createdAt = where.createdAt;
+      if (paymentStatus) bookingPkgWhere.paymentIntent = where.paymentIntent;
+      if (search) bookingPkgWhere.OR = where.OR;
+
+      const [pkgItems, pkgTotal, regPkgItems, regPkgTotal] = await Promise.all([
+        this.prisma.packageBooking.findMany({
+          where: pkgWhere,
+          skip,
+          take: pageSize,
+          orderBy: { createdAt: 'desc' },
+          include: {
+            package: { select: { id: true, name: true, code: true } },
+            priceTier: { select: { id: true, label: true, seatType: true } },
+            passengers: true,
+            paymentIntent: true,
+          },
+        }),
+        this.prisma.packageBooking.count({ where: pkgWhere }),
+        this.prisma.booking.findMany({
+          where: bookingPkgWhere,
+          skip,
+          take: pageSize,
+          orderBy: { createdAt: 'desc' },
+          include: {
+            passenger: { select: { id: true, iamUserId: true } },
+            schedule: { include: { originStation: true, destinationStation: true, train: true } },
+            paymentIntent: true,
+            seats: { include: { seat: true } },
+          },
+        }),
+        this.prisma.booking.count({ where: bookingPkgWhere }),
+      ]);
+
+      const iamUserIds = regPkgItems.map((b: any) => b.passenger?.iamUserId).filter(Boolean) as string[];
+      const iamRows = iamUserIds.length > 0
+        ? await this.dataSource.query<{ id: string; email: string; name: any; phone_number: string | null }[]>(
+            `SELECT id, email, name, phone_number FROM iam.users WHERE id = ANY($1)`,
+            [iamUserIds],
+          )
+        : [];
+      const iamMap = new Map(iamRows.map(r => [r.id, r]));
+
+      const mappedRegPkg = regPkgItems.map((booking: any) => {
+        const iam = booking.passenger?.iamUserId ? iamMap.get(booking.passenger.iamUserId) : undefined;
+        const passengerDetails = booking.seats.map((s: any) => ({ name: s.passengerName, category: s.passengerCategory }));
+        const uniquePassengers = Array.from(new Map(passengerDetails.map((p: any) => [p.name, p])).values());
+        return {
+          id: booking.id, bookingRef: booking.bookingRef, status: booking.status,
+          totalMinor: booking.totalMinor, currency: 'ETB',
+          displayCurrency: booking.displayCurrency, displayTotalMinor: booking.displayTotalMinor,
+          contactEmail: booking.contactEmail, contactPhone: booking.contactPhone,
+          bookingType: booking.bookingType, packageId: booking.packageId, isPackageBooking: true,
+          returnLegStatus: (booking as any).returnLegStatus ?? null,
+          adultCount: booking.adultCount, childCount: booking.childCount,
+          createdAt: booking.createdAt,
+          passenger: iam ? { fullName: iam.name?.en ?? iam.name?.am ?? null, email: iam.email, phone: iam.phone_number } : null,
+          passengerNames: [...new Set(booking.seats.map((s: any) => s.passengerName))],
+          passengers: uniquePassengers,
+          schedule: booking.schedule ? {
+            train: booking.schedule.train,
+            originStation: booking.schedule.originStation,
+            destinationStation: booking.schedule.destinationStation,
+            departureAt: booking.schedule.departureAt,
+          } : null,
+          paymentIntent: booking.paymentIntent,
+          seatCount: booking.seats.length,
+        };
+      });
+
+      const mappedPkg = pkgItems.map((b: any) => ({
+        id: b.id, bookingRef: b.bookingRef, status: b.status,
+        totalMinor: b.totalMinor, currency: b.currency || 'ETB',
+        displayCurrency: b.displayCurrency, displayTotalMinor: b.displayTotalMinor,
+        contactEmail: b.contactEmail, contactPhone: b.contactPhone,
+        bookingType: 'PACKAGE', packageId: b.packageId, priceTierId: b.priceTierId,
+        isPackageBooking: true, packageName: b.package?.name, packageCode: b.package?.code,
+        tierLabel: b.priceTier?.label ?? null,
+        returnLegStatus: null, adultCount: b.passengerCount, childCount: 0,
+        createdAt: b.createdAt, passenger: null,
+        passengerNames: b.passengers?.map((p: any) => p.passengerName) ?? [],
+        passengers: b.passengers?.map((p: any) => ({ name: p.passengerName, category: 'ADULT' })) ?? [],
+        schedule: null, paymentIntent: b.paymentIntent, seatCount: b.passengerCount,
+      }));
+
+      const total = pkgTotal + regPkgTotal;
+      const allItems = [...mappedPkg, ...mappedRegPkg]
+        .sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime())
+        .slice(0, pageSize);
+
+      return {
+        items: allItems,
+        meta: { page, pageSize, total, totalPages: Math.ceil(total / pageSize) },
+      };
+    }
+
+    const [regularItems, regularTotal, pkgItems, pkgTotal] = await Promise.all([
       this.prisma.booking.findMany({
         where,
         skip,
@@ -261,12 +373,27 @@ export class BookingsService {
           schedule: { include: { originStation: true, destinationStation: true, train: true } },
           paymentIntent: true,
           seats: { include: { seat: true } },
+          package: { select: { id: true, name: true, code: true } },
+          priceTier: { select: { id: true, label: true } },
         },
       }),
       this.prisma.booking.count({ where }),
+      includePackageBookings
+        ? this.prisma.packageBooking.findMany({
+            where: pkgWhere,
+            orderBy: { createdAt: 'desc' },
+            include: {
+              package: { select: { id: true, name: true, code: true } },
+              priceTier: { select: { id: true, label: true, seatType: true } },
+              passengers: true,
+              paymentIntent: true,
+            },
+          })
+        : Promise.resolve([] as any[]),
+      includePackageBookings ? this.prisma.packageBooking.count({ where: pkgWhere }) : Promise.resolve(0),
     ]);
 
-    const iamUserIds = items.map(b => b.passenger?.iamUserId).filter(Boolean) as string[];
+    const iamUserIds = regularItems.map((b: any) => b.passenger?.iamUserId).filter(Boolean) as string[];
     const iamRows = iamUserIds.length > 0
       ? await this.dataSource.query<{ id: string; email: string; name: any; phone_number: string | null }[]>(
           `SELECT id, email, name, phone_number FROM iam.users WHERE id = ANY($1)`,
@@ -275,59 +402,86 @@ export class BookingsService {
       : [];
     const iamMap = new Map(iamRows.map(r => [r.id, r]));
 
+    const mappedRegular = regularItems.map((booking: any) => {
+      const iam = booking.passenger?.iamUserId ? iamMap.get(booking.passenger.iamUserId) : undefined;
+      const passengerDetails = booking.seats.map((s: any) => ({ name: s.passengerName, category: s.passengerCategory }));
+      const uniquePassengers = Array.from(new Map(passengerDetails.map((p: any) => [p.name, p])).values());
+      return {
+        id: booking.id,
+        bookingRef: booking.bookingRef,
+        status: booking.status,
+        totalMinor: booking.totalMinor,
+        currency: 'ETB',
+        displayCurrency: booking.displayCurrency,
+        displayTotalMinor: booking.displayTotalMinor,
+        contactEmail: booking.contactEmail,
+        contactPhone: booking.contactPhone,
+        bookingType: booking.bookingType,
+        packageId: booking.packageId ?? null,
+        priceTierId: (booking as any).priceTierId ?? null,
+        packageName: (booking as any).package?.name ?? null,
+        packageCode: (booking as any).package?.code ?? null,
+        tierLabel: (booking as any).priceTier?.label ?? null,
+        isPackageBooking: !!booking.packageId,
+        returnLegStatus: (booking as any).returnLegStatus ?? null,
+        adultCount: booking.adultCount,
+        childCount: booking.childCount,
+        createdAt: booking.createdAt,
+        passenger: iam ? { fullName: iam.name?.en ?? iam.name?.am ?? null, email: iam.email, phone: iam.phone_number } : null,
+        passengerNames: [...new Set(booking.seats.map((s: any) => s.passengerName))],
+        passengers: uniquePassengers,
+        schedule: {
+          train: booking.schedule.train,
+          originStation: booking.schedule.originStation,
+          destinationStation: booking.schedule.destinationStation,
+          departureAt: booking.schedule.departureAt,
+        },
+        paymentIntent: booking.paymentIntent,
+        seatCount: booking.seats.length,
+      };
+    });
+
+    const mappedPkg = pkgItems.map((b: any) => ({
+      id: b.id,
+      bookingRef: b.bookingRef,
+      status: b.status,
+      totalMinor: b.totalMinor,
+      currency: b.currency || 'ETB',
+      displayCurrency: b.displayCurrency,
+      displayTotalMinor: b.displayTotalMinor,
+      contactEmail: b.contactEmail,
+      contactPhone: b.contactPhone,
+      bookingType: 'PACKAGE',
+      packageId: b.packageId,
+      priceTierId: b.priceTierId,
+      isPackageBooking: true,
+      packageName: b.package?.name,
+      packageCode: b.package?.code,
+      tierLabel: b.priceTier?.label ?? null,
+      returnLegStatus: null,
+      adultCount: b.passengerCount,
+      childCount: 0,
+      createdAt: b.createdAt,
+      passenger: null,
+      passengerNames: b.passengers?.map((p: any) => p.passengerName) ?? [],
+      passengers: b.passengers?.map((p: any) => ({ name: p.passengerName, category: 'ADULT' })) ?? [],
+      schedule: null,
+      paymentIntent: b.paymentIntent,
+      seatCount: b.passengerCount,
+    }));
+
+    const total = regularTotal + pkgTotal;
+    const allItems = [...mappedRegular, ...mappedPkg]
+      .sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime())
+      .slice(0, pageSize);
+
     return {
-      items: items.map(booking => {
-        const iam = booking.passenger?.iamUserId ? iamMap.get(booking.passenger.iamUserId) : undefined;
-        // Build passenger list with categories
-        const passengerDetails = booking.seats.map((s: any) => ({
-          name: s.passengerName,
-          category: s.passengerCategory // 'ADULT' or 'CHILD'
-        }));
-        // Get unique names with their categories
-        const uniquePassengers = Array.from(
-          new Map(passengerDetails.map(p => [p.name, p])).values()
-        );
-        
-        return {
-          id: booking.id,
-          bookingRef: booking.bookingRef,
-          status: booking.status,
-          totalMinor: booking.totalMinor,
-          currency: 'ETB',
-          displayCurrency: booking.displayCurrency,
-          displayTotalMinor: booking.displayTotalMinor,
-          contactEmail: booking.contactEmail,
-          contactPhone: booking.contactPhone,
-          bookingType: booking.bookingType,
-          returnLegStatus: (booking as any).returnLegStatus ?? null,
-          adultCount: booking.adultCount,
-          childCount: booking.childCount,
-          createdAt: booking.createdAt,
-          passenger: iam
-            ? { fullName: iam.name?.en ?? iam.name?.am ?? null, email: iam.email, phone: iam.phone_number }
-            : null,
-          passengerNames: [...new Set(booking.seats.map((s: any) => s.passengerName))],
-          passengers: uniquePassengers, // Include category info
-          schedule: {
-            train: booking.schedule.train,
-            originStation: booking.schedule.originStation,
-            destinationStation: booking.schedule.destinationStation,
-            departureAt: booking.schedule.departureAt,
-          },
-          paymentIntent: booking.paymentIntent,
-          seatCount: booking.seats.length,
-        };
-      }),
-      meta: {
-        page,
-        pageSize,
-        total,
-        totalPages: Math.ceil(total / pageSize),
-      },
+      items: allItems,
+      meta: { page, pageSize, total, totalPages: Math.ceil(total / pageSize) },
     };
   }
 
-  async create(dto: CreateBookingDto) {
+    async create(dto: CreateBookingDto) {
     if (dto.bookingType === 'ROUND_TRIP')         return this.createRoundTripBooking(dto);
     if (dto.bookingType === 'TRANSIT')            return this.createTransitBooking(dto);
     if (dto.bookingType === 'ROUND_TRIP_TRANSIT') return this.createRoundTripTransitBooking(dto);
@@ -363,7 +517,9 @@ export class BookingsService {
 
     const passengersData = await this.processPassengers(dto.passengers as any[]);
     const { adultCount, childCount } = this.countPassengers(passengersData);
-    const fareCalculation = await this.calculateFare(dto.scheduleId, dto.seatClassId, originStop, destStop, passengersData[0]?.nationality, adultCount, childCount, dto.promoCode, dto.loyaltyRedemptionPoints);
+    const fareCalculation = dto.packageId && dto.priceTierId
+      ? await this.calculatePackageFare(dto.priceTierId, adultCount, childCount)
+      : await this.calculateFare(dto.scheduleId, dto.seatClassId, originStop, destStop, passengersData[0]?.nationality, adultCount, childCount, dto.promoCode, dto.loyaltyRedemptionPoints);
     
     const displayCurrency = dto.displayCurrency || Currency.ETB;
     let displayTotalMinor = fareCalculation.totalMinor;
@@ -371,20 +527,18 @@ export class BookingsService {
       displayTotalMinor = await this.currencyService.convertAmount(fareCalculation.totalMinor, Currency.ETB, displayCurrency);
     }
 
-    // Track which child gets free fare (first child encountered)
+    // Track per-seat fare. For package bookings children pay 10% of adult fare;
+    // for regular bookings the first child is free.
     let freeChildUsed = false;
     const passengersWithFares = passengersData.map(p => {
       let fareMinor: number;
       if (p.category === PassengerCategory.ADULT) {
         fareMinor = fareCalculation.baseFareMinor;
+      } else if (dto.packageId) {
+        fareMinor = Math.round(fareCalculation.baseFareMinor * 0.1);
       } else {
-        // Child: first child is free, subsequent children pay full fare
-        if (!freeChildUsed) {
-          fareMinor = 0;
-          freeChildUsed = true;
-        } else {
-          fareMinor = fareCalculation.baseFareMinor;
-        }
+        if (!freeChildUsed) { fareMinor = 0; freeChildUsed = true; }
+        else fareMinor = fareCalculation.baseFareMinor;
       }
       return { ...p, fareMinor };
     });
@@ -401,6 +555,7 @@ export class BookingsService {
         childCount,
         displayCurrency,
         displayTotalMinor,
+        ...(dto.packageId ? { packageId: dto.packageId, priceTierId: dto.priceTierId } : {}),
         seats: {
           create: passengersWithFares.map(p => ({
             seat: { connect: { id: p.seatId } },
@@ -421,6 +576,12 @@ export class BookingsService {
     });
 
     await this.seatsService.confirmSeats(passengersData.map(p => p.seatId));
+    if (dto.packageId && dto.priceTierId) {
+      await this.prisma.packagePriceTier.update({
+        where: { id: dto.priceTierId },
+        data: { bookedSeats: { increment: passengersData.length } },
+      });
+    }
     this.eventEmitter.emit('booking.created', { booking });
     return { ...booking, fareBreakdown: fareCalculation };
   }
@@ -468,23 +629,38 @@ export class BookingsService {
     const passengersData = await this.processRoundTripPassengers(dto.passengers as any[]);
     const { adultCount, childCount } = this.countPassengers(passengersData);
 
-    const [outboundFare, returnFare] = await Promise.all([
-      this.calculateFare(dto.scheduleId, dto.seatClassId, outboundOriginStop, outboundDestStop, passengersData[0]?.nationality, adultCount, childCount),
-      this.calculateFare(dto.returnScheduleId, dto.returnSeatClassId || dto.seatClassId, returnOriginStop, returnDestStop, passengersData[0]?.nationality, adultCount, childCount)
-    ]);
-
-    const combinedBaseFareMinor = outboundFare.totalBaseFareMinor + returnFare.totalBaseFareMinor;
+    // Package bookings use fixed tier price split equally across both legs
+    let outboundFare: Awaited<ReturnType<typeof this.calculateFare>>;
+    let returnFare:   Awaited<ReturnType<typeof this.calculateFare>>;
+    let combinedBaseFareMinor: number;
     let discountMinor = 0;
-    if (dto.promoCode) {
-      const promo = await this.prisma.promotion.findUnique({ where: { code: dto.promoCode } });
-      if (promo?.active && promo.validUntil > new Date()) {
-        discountMinor = promo.percentOff ? Math.round(combinedBaseFareMinor * promo.percentOff / 100) : (promo.amountOffMinor ?? 0);
-      }
-    }
+    let loyaltyMinor = 0;
+    let totalMinor: number;
 
-    const loyaltyMinor = (dto.loyaltyRedemptionPoints ?? 0) * 10;
+    if (dto.packageId && dto.priceTierId) {
+      const pkgFare = await this.calculatePackageFare(dto.priceTierId, adultCount, childCount);
+      // Split evenly across both legs for per-seat fare recording
+      const halfMinor = Math.round(pkgFare.baseFareMinor / 2);
+      outboundFare = { ...pkgFare, baseFareMinor: halfMinor, totalBaseFareMinor: Math.round(pkgFare.totalBaseFareMinor / 2) };
+      returnFare   = { ...pkgFare, baseFareMinor: pkgFare.baseFareMinor - halfMinor, totalBaseFareMinor: pkgFare.totalBaseFareMinor - Math.round(pkgFare.totalBaseFareMinor / 2) };
+      combinedBaseFareMinor = pkgFare.totalBaseFareMinor;
+      totalMinor = pkgFare.totalMinor;
+    } else {
+      [outboundFare, returnFare] = await Promise.all([
+        this.calculateFare(dto.scheduleId, dto.seatClassId, outboundOriginStop, outboundDestStop, passengersData[0]?.nationality, adultCount, childCount),
+        this.calculateFare(dto.returnScheduleId, dto.returnSeatClassId || dto.seatClassId, returnOriginStop, returnDestStop, passengersData[0]?.nationality, adultCount, childCount)
+      ]);
+      combinedBaseFareMinor = outboundFare.totalBaseFareMinor + returnFare.totalBaseFareMinor;
+      if (dto.promoCode) {
+        const promo = await this.prisma.promotion.findUnique({ where: { code: dto.promoCode } });
+        if (promo?.active && promo.validUntil > new Date()) {
+          discountMinor = promo.percentOff ? Math.round(combinedBaseFareMinor * promo.percentOff / 100) : (promo.amountOffMinor ?? 0);
+        }
+      }
+      loyaltyMinor = (dto.loyaltyRedemptionPoints ?? 0) * 10;
+      totalMinor = Math.max(0, combinedBaseFareMinor - discountMinor - loyaltyMinor);
+    }
     const taxesMinor = 0;
-    const totalMinor = Math.max(0, combinedBaseFareMinor - discountMinor - loyaltyMinor);
 
     const displayCurrency = dto.displayCurrency || Currency.ETB;
     let displayTotalMinor = totalMinor;
@@ -492,34 +668,27 @@ export class BookingsService {
       displayTotalMinor = await this.currencyService.convertAmount(totalMinor, Currency.ETB, displayCurrency);
     }
 
-    // Track which child gets free fare for outbound and return legs
+    // Track per-seat fare. For package bookings children pay 10% of adult fare;
+    // for regular bookings the first child is free per leg.
     let outboundFreeChildUsed = false;
     let returnFreeChildUsed = false;
     const passengersWithFares = passengersData.map(p => {
       let outboundFareMinor: number;
       let returnFareMinor: number;
-      
+
       if (p.category === PassengerCategory.ADULT) {
         outboundFareMinor = outboundFare.baseFareMinor;
         returnFareMinor = returnFare.baseFareMinor;
+      } else if (dto.packageId) {
+        outboundFareMinor = Math.round(outboundFare.baseFareMinor * 0.1);
+        returnFareMinor   = Math.round(returnFare.baseFareMinor   * 0.1);
       } else {
-        // Child fare for outbound
-        if (!outboundFreeChildUsed) {
-          outboundFareMinor = 0;
-          outboundFreeChildUsed = true;
-        } else {
-          outboundFareMinor = outboundFare.baseFareMinor;
-        }
-        
-        // Child fare for return
-        if (!returnFreeChildUsed) {
-          returnFareMinor = 0;
-          returnFreeChildUsed = true;
-        } else {
-          returnFareMinor = returnFare.baseFareMinor;
-        }
+        if (!outboundFreeChildUsed) { outboundFareMinor = 0; outboundFreeChildUsed = true; }
+        else outboundFareMinor = outboundFare.baseFareMinor;
+        if (!returnFreeChildUsed)   { returnFareMinor   = 0; returnFreeChildUsed   = true; }
+        else returnFareMinor   = returnFare.baseFareMinor;
       }
-      
+
       return { ...p, outboundFareMinor, returnFareMinor };
     });
 
@@ -541,6 +710,7 @@ export class BookingsService {
         returnHoldId: dto.returnHoldId,
         returnSeatClassId: dto.returnSeatClassId,
         returnLegStatus: 'NEITHER_USED',
+        ...(dto.packageId ? { packageId: dto.packageId, priceTierId: dto.priceTierId } : {}),
         seats: {
           create: [
             ...passengersWithFares.map(p => ({
@@ -586,6 +756,13 @@ export class BookingsService {
       this.seatsService.confirmSeats(returnSeatIds)
     ]);
 
+    if (dto.packageId && dto.priceTierId) {
+      await this.prisma.packagePriceTier.update({
+        where: { id: dto.priceTierId },
+        data: { bookedSeats: { increment: passengersData.length } },
+      });
+    }
+
     this.eventEmitter.emit('booking.created', { booking });
 
     return {
@@ -1048,6 +1225,34 @@ export class BookingsService {
     return { adultCount, childCount };
   }
 
+  private async calculatePackageFare(
+    priceTierId: string,
+    adultCount: number,
+    childCount: number,
+  ) {
+    const tier = await this.prisma.packagePriceTier.findUniqueOrThrow({ where: { id: priceTierId } });
+    // For round-trip packages the caller splits the tier price across legs, so
+    // priceMinor here is already the per-leg amount. Children pay 10% of adult fare.
+    const childFareMinor = Math.round(tier.priceMinor * 0.1);
+    const adultFareMinor = tier.priceMinor * adultCount;
+    const childTotalMinor = childFareMinor * childCount;
+    const totalBaseFareMinor = adultFareMinor + childTotalMinor;
+    return {
+      baseFareMinor: tier.priceMinor,
+      adultCount,
+      adultFareMinor,
+      childCount,
+      freeChildrenCount: 0,
+      paidChildrenCount: childCount,
+      childFareMinor: childTotalMinor,
+      totalBaseFareMinor,
+      discountMinor: 0,
+      loyaltyRedemptionMinor: 0,
+      taxesFeesMinor: 0,
+      totalMinor: totalBaseFareMinor,
+    };
+  }
+
   private async calculateFare(
     scheduleId: string,
     seatClassId: string,
@@ -1182,7 +1387,64 @@ export class BookingsService {
         paymentIntent: true, tickets: { take: 1 },
       },
     });
-    if (!booking) throw new NotFoundException('Booking not found');
+
+    if (!booking) {
+      // Fall back to PackageBooking
+      const pkgBooking = await this.prisma.packageBooking.findUnique({
+        where: isUuid ? { id: bookingRefOrId } : { bookingRef: bookingRefOrId },
+        include: {
+          package: { include: { outboundSchedule: { include: { originStation: true, destinationStation: true, train: true } }, returnSchedule: { include: { originStation: true, destinationStation: true } } } },
+          priceTier: true,
+          passengers: true,
+          paymentIntent: true,
+        },
+      });
+      if (!pkgBooking) throw new NotFoundException('Booking not found');
+      return {
+        id: pkgBooking.id,
+        bookingRef: pkgBooking.bookingRef,
+        status: pkgBooking.status,
+        totalMinor: pkgBooking.totalMinor,
+        currency: pkgBooking.currency || 'ETB',
+        adultCount: pkgBooking.passengerCount,
+        childCount: 0,
+        displayCurrency: pkgBooking.displayCurrency,
+        displayTotalMinor: pkgBooking.displayTotalMinor ?? undefined,
+        bookingType: 'PACKAGE',
+        packageId: pkgBooking.packageId,
+        priceTierId: pkgBooking.priceTierId,
+        packageName: (pkgBooking as any).package?.name,
+        packageCode: (pkgBooking as any).package?.code,
+        tierLabel: (pkgBooking as any).priceTier?.label,
+        isPackageBooking: true,
+        returnLegStatus: null,
+        contactEmail: pkgBooking.contactEmail,
+        contactPhone: pkgBooking.contactPhone,
+        createdAt: pkgBooking.createdAt,
+        schedule: (pkgBooking as any).package?.outboundSchedule ? {
+          id: (pkgBooking as any).package.outboundSchedule.id,
+          trainNumber: (pkgBooking as any).package.outboundSchedule.train?.number,
+          trainName: (pkgBooking as any).package.outboundSchedule.train?.name,
+          origin: (pkgBooking as any).package.outboundSchedule.originStation,
+          destination: (pkgBooking as any).package.outboundSchedule.destinationStation,
+          departureAt: (pkgBooking as any).package.outboundSchedule.departureAt,
+          arrivalAt: (pkgBooking as any).package.outboundSchedule.arrivalAt,
+        } : null,
+        passengers: (pkgBooking as any).passengers?.map((p: any) => ({
+          fullName: p.passengerName,
+          category: 'ADULT',
+          leg: 1,
+          fareMinor: Math.round(pkgBooking.totalMinor / pkgBooking.passengerCount),
+          verifaydaVerified: false,
+          seat: null,
+        })),
+        payment: (pkgBooking as any).paymentIntent
+          ? { method: (pkgBooking as any).paymentIntent.method, status: (pkgBooking as any).paymentIntent.status }
+          : undefined,
+        ticket: undefined,
+      };
+    }
+
     return {
       id: booking.id, bookingRef: booking.bookingRef, status: booking.status,
       totalMinor: booking.totalMinor, currency: 'ETB',
diff --git a/apps/edr-passenger-api/src/modules/bookings/guest-booking.dto.ts b/apps/edr-passenger-api/src/modules/bookings/guest-booking.dto.ts
index d3d1e206d..c6f27d9c3 100644
--- a/apps/edr-passenger-api/src/modules/bookings/guest-booking.dto.ts
+++ b/apps/edr-passenger-api/src/modules/bookings/guest-booking.dto.ts
@@ -144,6 +144,12 @@ export class CreateGuestBookingDto {
 
   @ApiPropertyOptional({ example: 'device-uuid-12345', description: 'Device ID for local storage of passenger details' }) 
   @IsOptional() @IsString() deviceId?: string;
+
+  @ApiPropertyOptional({ description: 'Package ID — when set, fare is taken from the package price tier' })
+  @IsOptional() @IsString() packageId?: string;
+
+  @ApiPropertyOptional({ description: 'Package price tier ID — required when packageId is provided' })
+  @IsOptional() @IsString() priceTierId?: string;
 }
 
 export class SavedPassengerProfileDto {
diff --git a/apps/edr-passenger-api/src/modules/bookings/guest-booking.service.ts b/apps/edr-passenger-api/src/modules/bookings/guest-booking.service.ts
index 6907d14a3..f4139d842 100644
--- a/apps/edr-passenger-api/src/modules/bookings/guest-booking.service.ts
+++ b/apps/edr-passenger-api/src/modules/bookings/guest-booking.service.ts
@@ -81,8 +81,10 @@ export class GuestBookingService {
       throw new BadRequestException('Bookings are not accepted within 30 minutes of departure');
     }
 
-    const originStop = schedule.stopTimes.find(s => s.stationId === dto.originStationId);
-    const destStop = schedule.stopTimes.find(s => s.stationId === dto.destinationStationId);
+    const originStop = schedule.stopTimes.find(s => s.stationId === dto.originStationId)
+      ?? (schedule.stopTimes.length === 0 ? { stationId: schedule.originStationId, sequence: 0, station: schedule.originStation } : undefined);
+    const destStop = schedule.stopTimes.find(s => s.stationId === dto.destinationStationId)
+      ?? (schedule.stopTimes.length === 0 ? { stationId: schedule.destinationStationId, sequence: 1, station: schedule.destinationStation } : undefined);
     if (!originStop || !destStop) throw new NotFoundException('Origin or destination not found');
 
     const segmentRoute = `${originStop.station.code}-${destStop.station.code}`;
@@ -142,21 +144,34 @@ export class GuestBookingService {
       });
     }
 
-    // Calculate fare
-    const primaryNationality = passengersData[0]?.nationality;
-    const baseFareMinor = await this.getBaseFare(
-      dto.scheduleId,
-      dto.seatClassId,
-      segmentRoute,
-      fullRoute,
-      primaryNationality,
-      dto.originStationId,
-      dto.destinationStationId,
-    );
+    // Calculate fare — package bookings use the fixed tier price, bypassing the fare engine
+    const isPackageOneway = !!dto.packageId && !!dto.priceTierId;
+    let baseFareMinor: number;
+    let paidChildrenCount: number;
+    let childUnitFare: number;
+
+    if (isPackageOneway) {
+      const tier = await this.prisma.packagePriceTier.findUniqueOrThrow({ where: { id: dto.priceTierId! } });
+      baseFareMinor = tier.priceMinor;
+      paidChildrenCount = childCount;
+      childUnitFare = Math.round(baseFareMinor * 0.1);
+    } else {
+      const primaryNationality = passengersData[0]?.nationality;
+      baseFareMinor = await this.getBaseFare(
+        dto.scheduleId,
+        dto.seatClassId,
+        segmentRoute,
+        fullRoute,
+        primaryNationality,
+        dto.originStationId,
+        dto.destinationStationId,
+      );
+      paidChildrenCount = Math.max(0, childCount - 1);
+      childUnitFare = baseFareMinor;
+    }
 
     const adultFareMinor = baseFareMinor * adultCount;
-    const paidChildrenCount = Math.max(0, childCount - 1);
-    const childFareMinor = baseFareMinor * paidChildrenCount;
+    const childFareMinor = childUnitFare * paidChildrenCount;
     const totalBaseFareMinor = adultFareMinor + childFareMinor;
 
     let discountMinor = 0;
@@ -215,6 +230,7 @@ export class GuestBookingService {
         displayCurrency,
         displayTotalMinor,
         bookingType: 'ONE_WAY',
+        ...(dto.packageId ? { packageId: dto.packageId, priceTierId: dto.priceTierId } : {}),
         userAgent:    dto.deviceId,
         contactEmail: firstPassenger.email || null,
         contactPhone: firstPassenger.phone || null,
@@ -229,7 +245,7 @@ export class GuestBookingService {
             passportCountry: p.passportCountry,
             verifaydaVerified: p.verifaydaVerified,
             verifaydaData: p.verifaydaData || undefined,
-            fareMinor: p.category === PassengerCategory.ADULT ? baseFareMinor : (paidChildrenCount > 0 ? baseFareMinor : 0),
+            fareMinor: p.category === PassengerCategory.ADULT ? baseFareMinor : childUnitFare,
             displayCurrency,
           })),
         },
@@ -256,7 +272,7 @@ export class GuestBookingService {
         adultCount,
         adultFareMinor,
         childCount,
-        freeChildrenCount: Math.min(childCount, 1),
+        freeChildrenCount: isPackageOneway ? 0 : Math.min(childCount, 1),
         paidChildrenCount,
         childFareMinor,
         totalBaseFareMinor,
@@ -306,10 +322,16 @@ export class GuestBookingService {
       throw new BadRequestException('Bookings are not accepted within 30 minutes of departure');
     }
 
-    const outboundOriginStop = outboundSchedule.stopTimes.find(s => s.stationId === dto.originStationId);
-    const outboundDestStop   = outboundSchedule.stopTimes.find(s => s.stationId === dto.destinationStationId);
-    const returnOriginStop   = returnSchedule.stopTimes.find(s => s.stationId === dto.returnOriginStationId);
-    const returnDestStop     = returnSchedule.stopTimes.find(s => s.stationId === dto.returnDestinationStationId);
+    const synth = (sched: any, stationId: string, seq: number) => {
+      const station = sched.originStationId === stationId ? sched.originStation : sched.destinationStation;
+      return { stationId, sequence: seq, station };
+    };
+    const obStops  = outboundSchedule.stopTimes.length > 0 ? outboundSchedule.stopTimes : [synth(outboundSchedule, outboundSchedule.originStationId, 0), synth(outboundSchedule, outboundSchedule.destinationStationId, 1)];
+    const retStops = returnSchedule.stopTimes.length   > 0 ? returnSchedule.stopTimes   : [synth(returnSchedule,   returnSchedule.originStationId,   0), synth(returnSchedule,   returnSchedule.destinationStationId,   1)];
+    const outboundOriginStop = obStops.find((s: any)  => s.stationId === dto.originStationId)            ?? obStops[0];
+    const outboundDestStop   = obStops.find((s: any)  => s.stationId === dto.destinationStationId)       ?? obStops[obStops.length - 1];
+    const returnOriginStop   = retStops.find((s: any) => s.stationId === dto.returnOriginStationId)      ?? retStops[0];
+    const returnDestStop     = retStops.find((s: any) => s.stationId === dto.returnDestinationStationId) ?? retStops[retStops.length - 1];
     if (!outboundOriginStop || !outboundDestStop) throw new NotFoundException('Outbound origin or destination not found on schedule');
     if (!returnOriginStop   || !returnDestStop)   throw new NotFoundException('Return origin or destination not found on schedule');
 
@@ -358,18 +380,36 @@ export class GuestBookingService {
       passengersData.push({ ...passenger, passengerName, dateOfBirth, category, verifaydaVerified, verifaydaData, nationality });
     }
 
-    // Calculate fares for both legs
+    // Calculate fares for both legs — package bookings use the fixed tier price split across legs
     const returnSeatClassId = dto.returnSeatClassId || dto.seatClassId;
-    const primaryNationality = passengersData[0]?.nationality;
+    const isPackageRoundTrip = !!dto.packageId && !!dto.priceTierId;
+    let outboundBaseFare: number;
+    let returnBaseFare: number;
+    let paidChildrenCount: number;
+    let outboundChildUnitFare: number;
+    let returnChildUnitFare: number;
 
-    const [outboundBaseFare, returnBaseFare] = await Promise.all([
-      this.getBaseFare(dto.scheduleId, dto.seatClassId, outboundSegmentRoute, outboundFullRoute, primaryNationality, dto.originStationId, dto.destinationStationId),
-      this.getBaseFare(dto.returnScheduleId, returnSeatClassId, returnSegmentRoute, returnFullRoute, primaryNationality, dto.returnOriginStationId, dto.returnDestinationStationId),
-    ]);
-
-    const paidChildrenCount      = Math.max(0, childCount - 1);
-    const outboundTotalBase      = outboundBaseFare * adultCount + outboundBaseFare * paidChildrenCount;
-    const returnTotalBase        = returnBaseFare  * adultCount + returnBaseFare  * paidChildrenCount;
+    if (isPackageRoundTrip) {
+      const tier = await this.prisma.packagePriceTier.findUniqueOrThrow({ where: { id: dto.priceTierId! } });
+      // tier.priceMinor is the full round-trip price per adult; split evenly across legs
+      const halfMinor = Math.round(tier.priceMinor / 2);
+      outboundBaseFare = halfMinor;
+      returnBaseFare = tier.priceMinor - halfMinor;
+      paidChildrenCount = childCount;
+      outboundChildUnitFare = Math.round(outboundBaseFare * 0.1);
+      returnChildUnitFare   = Math.round(returnBaseFare   * 0.1);
+    } else {
+      const primaryNationality = passengersData[0]?.nationality;
+      [outboundBaseFare, returnBaseFare] = await Promise.all([
+        this.getBaseFare(dto.scheduleId, dto.seatClassId, outboundSegmentRoute, outboundFullRoute, primaryNationality, dto.originStationId, dto.destinationStationId),
+        this.getBaseFare(dto.returnScheduleId, returnSeatClassId, returnSegmentRoute, returnFullRoute, primaryNationality, dto.returnOriginStationId, dto.returnDestinationStationId),
+      ]);
+      paidChildrenCount = Math.max(0, childCount - 1);
+      outboundChildUnitFare = outboundBaseFare;
+      returnChildUnitFare   = returnBaseFare;
+    }
+    const outboundTotalBase      = outboundBaseFare * adultCount + outboundChildUnitFare * paidChildrenCount;
+    const returnTotalBase        = returnBaseFare  * adultCount + returnChildUnitFare  * paidChildrenCount;
     const combinedBaseFareMinor  = outboundTotalBase + returnTotalBase;
 
     let discountMinor = 0;
@@ -415,6 +455,7 @@ export class GuestBookingService {
         returnHoldId:                dto.returnHoldId,
         returnSeatClassId,
         returnLegStatus:             'NEITHER_USED',
+        ...(dto.packageId ? { packageId: dto.packageId, priceTierId: dto.priceTierId } : {}),
         userAgent:                   dto.deviceId,
         contactEmail:                passengersData[0]?.email || null,
         contactPhone:                passengersData[0]?.phone || null,
@@ -432,7 +473,7 @@ export class GuestBookingService {
               passportCountry:   p.passportCountry,
               verifaydaVerified: p.verifaydaVerified,
               verifaydaData:     p.verifaydaData || undefined,
-              fareMinor:         p.category === PassengerCategory.ADULT ? outboundBaseFare : (paidChildrenCount > 0 ? outboundBaseFare : 0),
+              fareMinor:         p.category === PassengerCategory.ADULT ? outboundBaseFare : outboundChildUnitFare,
               displayCurrency,
             })),
             ...passengersData.map((p) => ({
@@ -447,7 +488,7 @@ export class GuestBookingService {
               passportCountry:   p.passportCountry,
               verifaydaVerified: p.verifaydaVerified,
               verifaydaData:     p.verifaydaData || undefined,
-              fareMinor:         p.category === PassengerCategory.ADULT ? returnBaseFare : (paidChildrenCount > 0 ? returnBaseFare : 0),
+              fareMinor:         p.category === PassengerCategory.ADULT ? returnBaseFare : returnChildUnitFare,
               displayCurrency,
             })),
           ],
@@ -476,7 +517,7 @@ export class GuestBookingService {
         returnBaseFareMinor:   returnBaseFare,
         adultCount,
         childCount,
-        freeChildrenCount:     Math.min(childCount, 1),
+        freeChildrenCount:     isPackageRoundTrip ? 0 : Math.min(childCount, 1),
         paidChildrenCount,
         combinedBaseFareMinor,
         discountMinor,
@@ -886,18 +927,17 @@ export class GuestBookingService {
   ): Promise<{ guestPassengerId: string; iamUserId: string | null; createdAccount: boolean }> {
     if (dto.createAccount && firstPassenger.email && dto.password) {
       const guestName = firstPassenger.passengerName ?? 'Guest';
-      const result = await this.passengerAuthService.register(
+      const result = await this.passengerAuthService.registerWithPassword(
         {
           email: firstPassenger.email,
           username: firstPassenger.email,
           phoneNumber: firstPassenger.phone || `+251900000000`,
           name: { en: guestName, am: guestName },
           password: dto.password,
-          confirmPassword: dto.password,
         },
         req,
       );
-      return { guestPassengerId: result.user.passengerId, iamUserId: result.user.iamUserId, createdAccount: true };
+      return { guestPassengerId: result.passengerId, iamUserId: result.iamUserId, createdAccount: true };
     }
 
     // Create guest passenger with basic profile
diff --git a/apps/edr-passenger-api/src/modules/configurable-fare/configurable-fare.service.ts b/apps/edr-passenger-api/src/modules/configurable-fare/configurable-fare.service.ts
index 34b2be08f..06107c30e 100644
--- a/apps/edr-passenger-api/src/modules/configurable-fare/configurable-fare.service.ts
+++ b/apps/edr-passenger-api/src/modules/configurable-fare/configurable-fare.service.ts
@@ -329,7 +329,7 @@ export class ConfigurableFareService {
       );
       
       if (childRule) {
-        const freeChildren = Math.min(childCount, childRule.max_free_passengers);
+        const freeChildren = Math.min(childCount, adultCount);
         const paidChildren = Math.max(0, childCount - freeChildren);
         
         if (freeChildren > 0) {
diff --git a/apps/edr-passenger-api/src/modules/fare-engine/fare-engine.service.ts b/apps/edr-passenger-api/src/modules/fare-engine/fare-engine.service.ts
index 592aadacd..70f18564d 100644
--- a/apps/edr-passenger-api/src/modules/fare-engine/fare-engine.service.ts
+++ b/apps/edr-passenger-api/src/modules/fare-engine/fare-engine.service.ts
@@ -130,8 +130,8 @@ export class FareEngineService {
 
     const adultCount        = dto.adultCount ?? 1;
     const childCount        = dto.childCount ?? 0;
-    const freeChildrenCount = Math.min(childCount, 1);
-    const paidChildrenCount = Math.max(0, childCount - 1);
+    const freeChildrenCount = Math.min(childCount, adultCount);
+    const paidChildrenCount = Math.max(0, childCount - freeChildrenCount);
 
     // Subtotal includes: (distance-based fare + premium + insurance) × passengers
     // First child is free, but pays premium and insurance
@@ -169,7 +169,7 @@ export class FareEngineService {
       `Total fare/pax: ${farePerPassengerMinor} ETB minor`,
       ``,
       `Adults:         ${adultCount} × ${farePerPassengerMinor} = ${adultSubtotal} ETB minor`,
-      `Children:       ${childCount} (${freeChildrenCount} free + ${paidChildrenCount} paid)`,
+      `Children:       ${childCount} (${freeChildrenCount} free [1 per adult] + ${paidChildrenCount} paid)`,
       `  Free child:   ${freeChildrenCount} × ${premiumPerPassenger + insurancePerPassenger} = ${freeChildSubtotal} ETB minor`,
       `  Paid child:   ${paidChildrenCount} × ${farePerPassengerMinor} = ${paidChildSubtotal} ETB minor`,
       ``,
diff --git a/apps/edr-passenger-api/src/modules/fraud/fraud.controller.ts b/apps/edr-passenger-api/src/modules/fraud/fraud.controller.ts
index c53d3a5fb..87007f16a 100644
--- a/apps/edr-passenger-api/src/modules/fraud/fraud.controller.ts
+++ b/apps/edr-passenger-api/src/modules/fraud/fraud.controller.ts
@@ -1,4 +1,4 @@
-import { Controller, Get, Post, Body, Query, Logger } from '@nestjs/common';
+import { Controller, Get, Post, Patch, Param, Body, Query, Logger } from '@nestjs/common';
 import { ApiTags, ApiOperation, ApiBearerAuth } from '@nestjs/swagger';
 import { FraudService, FraudRuleConfig } from './fraud.service';
 import { PassengerStaff } from '../../common/passenger-guards';
@@ -48,6 +48,31 @@ export class FraudController {
     return { data: rule, message: 'Rule updated successfully' };
   }
 
+  /**
+   * Acknowledge a fraud alert
+   */
+  @Patch('alerts/:id/acknowledge')
+  @PassengerStaff([PASSENGER_PERMS.fraud.manage, PASSENGER_PERMS.admin])
+  @ApiOperation({ summary: 'Acknowledge a fraud alert' })
+  async acknowledgeAlert(@Param('id') id: string) {
+    const alert = await this.fraudService.acknowledgeAlert(id);
+    return { data: alert, message: 'Alert acknowledged' };
+  }
+
+  /**
+   * Block user via userId
+   */
+  @Post('users/:userId/block')
+  @PassengerStaff([PASSENGER_PERMS.fraud.manage, PASSENGER_PERMS.admin])
+  @ApiOperation({ summary: 'Block user by userId' })
+  async blockUserById(
+    @Param('userId') userId: string,
+    @Body() body: { reason?: string; durationMinutes?: number },
+  ) {
+    await this.fraudService.blockUserTemporarily(userId, body.durationMinutes ?? 60);
+    return { message: `User blocked for ${body.durationMinutes ?? 60} minutes` };
+  }
+
   /**
    * Block user temporarily
    */
diff --git a/apps/edr-passenger-api/src/modules/fraud/fraud.module.ts b/apps/edr-passenger-api/src/modules/fraud/fraud.module.ts
index a95078578..17b86705f 100644
--- a/apps/edr-passenger-api/src/modules/fraud/fraud.module.ts
+++ b/apps/edr-passenger-api/src/modules/fraud/fraud.module.ts
@@ -1,10 +1,11 @@
 import { Module } from '@nestjs/common';
 import { HttpModule } from '@nestjs/axios';
+import { TypeOrmModule } from '@nestjs/typeorm';
 import { FraudService } from './fraud.service';
 import { FraudController } from './fraud.controller';
 
 @Module({
-  imports: [HttpModule],
+  imports: [HttpModule, TypeOrmModule],
   providers: [FraudService],
   controllers: [FraudController],
   exports: [FraudService],
diff --git a/apps/edr-passenger-api/src/modules/fraud/fraud.service.ts b/apps/edr-passenger-api/src/modules/fraud/fraud.service.ts
index a75db4449..2f988fd31 100644
--- a/apps/edr-passenger-api/src/modules/fraud/fraud.service.ts
+++ b/apps/edr-passenger-api/src/modules/fraud/fraud.service.ts
@@ -164,6 +164,16 @@ export class FraudService {
     this.logger.log(`Passenger (iamUserId=${iamUserId}) unblocked`);
   }
 
+  /**
+   * Acknowledge a fraud alert
+   */
+  async acknowledgeAlert(id: string) {
+    return this.prisma.fraudAlert.update({
+      where: { id },
+      data: { acknowledged: true, acknowledgedAt: new Date() },
+    });
+  }
+
   /**
    * Get all fraud alerts
    */
diff --git a/apps/edr-passenger-api/src/modules/loyalty/loyalty.controller.ts b/apps/edr-passenger-api/src/modules/loyalty/loyalty.controller.ts
index 7095110e4..b4b1a63c6 100644
--- a/apps/edr-passenger-api/src/modules/loyalty/loyalty.controller.ts
+++ b/apps/edr-passenger-api/src/modules/loyalty/loyalty.controller.ts
@@ -1,4 +1,4 @@
-import { Controller, Get, Param, Post, UseGuards } from '@nestjs/common';
+import { Controller, Get, Param, Post, Delete, UseGuards, SetMetadata, Query } from '@nestjs/common';
 import { ApiTags, ApiOperation, ApiBearerAuth } from '@nestjs/swagger';
 import { LoyaltyService } from './loyalty.service';
 import { JwtGuard } from '../../common/jwt.guard';
@@ -9,7 +9,9 @@ import { JwtGuard } from '../../common/jwt.guard';
 @ApiBearerAuth('JWT-auth')
 export class LoyaltyController {
   constructor(private service: LoyaltyService) {}
+  @Get('accounts')                                        @SetMetadata('isPublic', true) @ApiOperation({ summary: 'List all loyalty accounts' })          getAccounts(@Query() q: any) { return this.service.getAccounts(q); }
   @Get(':passengerId')                                    @ApiOperation({ summary: 'Get loyalty account with tier progress' }) getAccount(@Param('passengerId') id: string) { return this.service.getAccount(id); }
   @Get(':passengerId/rewards')                            @ApiOperation({ summary: 'Get available rewards' })                  getRewards(@Param('passengerId') id: string) { return this.service.getRewards(id); }
   @Post(':passengerId/rewards/:rewardId/redeem')          @ApiOperation({ summary: 'Redeem a loyalty reward' })                redeemReward(@Param('passengerId') pid: string, @Param('rewardId') rid: string) { return this.service.redeemReward(pid, rid); }
+  @Delete('accounts/:id')                                 @SetMetadata('isPublic', true) @ApiOperation({ summary: 'Delete loyalty account' })             deleteAccount(@Param('id') id: string) { return this.service.deleteAccount(id); }
 }
diff --git a/apps/edr-passenger-api/src/modules/loyalty/loyalty.service.ts b/apps/edr-passenger-api/src/modules/loyalty/loyalty.service.ts
index 4cc69b214..22b919f6f 100644
--- a/apps/edr-passenger-api/src/modules/loyalty/loyalty.service.ts
+++ b/apps/edr-passenger-api/src/modules/loyalty/loyalty.service.ts
@@ -5,6 +5,42 @@ import { PrismaService } from '../../common/prisma.service';
 export class LoyaltyService {
   constructor(private prisma: PrismaService) {}
 
+  async getAccounts(params: { search?: string; tier?: string; page?: string; pageSize?: string } = {}) {
+    const { search, tier, page = '1', pageSize = '20' } = params;
+    const skip = (parseInt(page) - 1) * parseInt(pageSize);
+    const where: any = {};
+    if (tier) where.tier = tier;
+    if (search) {
+      where.passenger = {
+        OR: [
+          { user: { fullName: { contains: search, mode: 'insensitive' } } },
+          { user: { email: { contains: search, mode: 'insensitive' } } },
+        ],
+      };
+    }
+    const [items, total] = await Promise.all([
+      this.prisma.loyaltyAccount.findMany({
+        where,
+        skip,
+        take: parseInt(pageSize),
+        orderBy: { pointsBalance: 'desc' },
+        include: { passenger: { include: { user: true } } },
+      }),
+      this.prisma.loyaltyAccount.count({ where }),
+    ]);
+    return {
+      items: items.map(a => ({
+        ...a,
+        passenger: a.passenger ? {
+          id: a.passenger.id,
+          fullName: (a.passenger as any).user?.fullName ?? null,
+          email: (a.passenger as any).user?.email ?? null,
+          phone: (a.passenger as any).user?.phone ?? null,
+        } : null,
+      })),
+      meta: { page: parseInt(page), pageSize: parseInt(pageSize), total, totalPages: Math.ceil(total / parseInt(pageSize)) },
+    };
+  }
   async getAccount(passengerId: string) {
     const account = await this.prisma.loyaltyAccount.findUnique({ where: { passengerId }, include: { ledger: { orderBy: { createdAt: 'desc' }, take: 20 } } });
     if (!account) throw new NotFoundException('Loyalty account not found');
@@ -40,4 +76,15 @@ export class LoyaltyService {
     await this.prisma.loyaltyReward.update({ where: { id: rewardId }, data: { available: false } });
     return { redeemed: true, pointsUsed: reward.costPoints, balanceAfter: newBalance };
   }
+
+  async deleteAccount(id: string) {
+    const account = await this.prisma.loyaltyAccount.findUnique({ where: { id } });
+    if (!account) throw new NotFoundException('Loyalty account not found');
+    await this.prisma.$transaction([
+      this.prisma.loyaltyLedgerEntry.deleteMany({ where: { accountId: id } }),
+      this.prisma.loyaltyReward.deleteMany({ where: { accountId: id } }),
+      this.prisma.loyaltyAccount.delete({ where: { id } }),
+    ]);
+    return { deleted: true, accountId: id };
+  }
 }
diff --git a/apps/edr-passenger-api/src/modules/packages/packages.controller.ts b/apps/edr-passenger-api/src/modules/packages/packages.controller.ts
index c88bdc15d..de61f92ca 100644
--- a/apps/edr-passenger-api/src/modules/packages/packages.controller.ts
+++ b/apps/edr-passenger-api/src/modules/packages/packages.controller.ts
@@ -1,8 +1,8 @@
 import { Body, Controller, Get, Param, Post, Patch, Delete, UseGuards, Request, Query } from '@nestjs/common';
-import { ApiTags, ApiOperation, ApiBearerAuth } from '@nestjs/swagger';
+import { ApiTags, ApiOperation, ApiBearerAuth, ApiQuery } from '@nestjs/swagger';
 import { IsPublic } from '@tria-plc/api-common/modules/auth/decorators/public.decorator';
 import { PackagesService } from './packages.service';
-import { CreatePackageDto, BookPackageDto, CreatePriceTierDto, UpdatePriceTierDto, CreateInquiryDto, UpdateInquiryStatusDto } from './packages.dto';
+import { CreatePackageDto, BookPackageDto, CreatePriceTierDto, UpdatePriceTierDto, CreateInquiryDto, UpdateInquiryStatusDto, PackageBookingContextDto } from './packages.dto';
 import { IamGuard } from '../../common/iam-adapter';
 import { JwtGuard } from '../../common/jwt.guard';
 import { OptionalJwtGuard } from '../verifayda/optional-jwt.guard';
@@ -63,6 +63,19 @@ export class PackagesController {
     return this.service.listAll(page ? +page : 1, pageSize ? +pageSize : 20);
   }
 
+  @Get('bookings')
+  @UseGuards(IamGuard)
+  @ApiBearerAuth('IAM-auth')
+  @ApiOperation({ summary: 'List all package bookings (backoffice)' })
+  listBookings(
+    @Query('packageId') packageId?: string,
+    @Query('status') status?: string,
+    @Query('page') page?: string,
+    @Query('pageSize') pageSize?: string,
+  ) {
+    return this.service.listBookings({ packageId, status, page: page ? +page : 1, pageSize: pageSize ? +pageSize : 20 });
+  }
+
   @Get('my-bookings')
   @UseGuards(JwtGuard)
   @ApiBearerAuth('JWT-auth')
@@ -78,6 +91,30 @@ export class PackagesController {
     return this.service.getBookingByRef(ref);
   }
 
+  @Post('book')
+  @IsPublic()
+  @UseGuards(OptionalJwtGuard)
+  @ApiBearerAuth('JWT-auth')
+  @ApiOperation({ summary: 'Book a package (public or authenticated)' })
+  book(@Body() dto: BookPackageDto, @Request() req: any) {
+    return this.service.book(dto, req.user?.passengerId);
+  }
+
+  @Get(':id/booking-context')
+  @IsPublic()
+  @ApiOperation({ summary: 'Get booking context for self-service package booking' })
+  @ApiQuery({ name: 'tierId', required: true })
+  @ApiQuery({ name: 'adultCount', required: true })
+  @ApiQuery({ name: 'childCount', required: false })
+  getBookingContext(
+    @Param('id') id: string,
+    @Query('tierId') tierId: string,
+    @Query('adultCount') adultCount: string,
+    @Query('childCount') childCount?: string,
+  ) {
+    return this.service.getBookingContext(id, tierId, parseInt(adultCount), childCount ? parseInt(childCount) : 0);
+  }
+
   @Get(':id')
   @IsPublic()
   @ApiOperation({ summary: 'Get package details' })
@@ -149,12 +186,4 @@ export class PackagesController {
     return this.service.deleteTier(tierId);
   }
 
-  @Post('book')
-  @IsPublic()
-  @UseGuards(OptionalJwtGuard)
-  @ApiBearerAuth('JWT-auth')
-  @ApiOperation({ summary: 'Book a package (public or authenticated)' })
-  book(@Body() dto: BookPackageDto, @Request() req: any) {
-    return this.service.book(dto, req.user?.passengerId);
-  }
 }
diff --git a/apps/edr-passenger-api/src/modules/packages/packages.dto.ts b/apps/edr-passenger-api/src/modules/packages/packages.dto.ts
index b4dac126d..0b7a25bba 100644
--- a/apps/edr-passenger-api/src/modules/packages/packages.dto.ts
+++ b/apps/edr-passenger-api/src/modules/packages/packages.dto.ts
@@ -1,4 +1,4 @@
-import { IsString, IsOptional, IsInt, IsBoolean, IsArray, IsDateString, Min, ValidateNested, IsUUID } from 'class-validator';
+import { IsString, IsOptional, IsInt, IsBoolean, IsArray, IsDateString, Min, ValidateNested, IsUUID, IsPositive } from 'class-validator';
 import { Type } from 'class-transformer';
 import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
 
@@ -93,6 +93,12 @@ export class BookPackagePassengerDto {
   @ApiPropertyOptional() @IsOptional() @IsString() passportCountry?: string;
 }
 
+export class PackageBookingContextDto {
+  @ApiProperty() @IsUUID() tierId: string;
+  @ApiProperty({ example: 1 }) @IsInt() @IsPositive() adultCount: number;
+  @ApiPropertyOptional({ example: 0 }) @IsOptional() @IsInt() @Min(0) childCount?: number;
+}
+
 export class BookPackageDto {
   @ApiProperty() @IsUUID() packageId: string;
   @ApiProperty() @IsUUID() priceTierId: string;
@@ -112,4 +118,10 @@ export class BookPackageDto {
   @ApiProperty({ type: [BookPackagePassengerDto] })
   @IsArray() @ValidateNested({ each: true }) @Type(() => BookPackagePassengerDto)
   passengers: BookPackagePassengerDto[];
+
+  /** Number of adult passengers (≥5 years). Derived from passengers array if omitted. */
+  @ApiPropertyOptional({ example: 2 }) @IsOptional() @IsInt() @Min(1) adultCount?: number;
+
+  /** Number of child passengers (<5 years). Derived from passengers array if omitted. */
+  @ApiPropertyOptional({ example: 1 }) @IsOptional() @IsInt() @Min(0) childCount?: number;
 }
diff --git a/apps/edr-passenger-api/src/modules/packages/packages.module.ts b/apps/edr-passenger-api/src/modules/packages/packages.module.ts
index f84a23781..32aec44fc 100644
--- a/apps/edr-passenger-api/src/modules/packages/packages.module.ts
+++ b/apps/edr-passenger-api/src/modules/packages/packages.module.ts
@@ -3,9 +3,10 @@ import { PrismaModule } from '../../common/prisma.module';
 import { PackagesController } from './packages.controller';
 import { PackagesService } from './packages.service';
 import { CurrencyModule } from '../currency/currency.module';
+import { BookingsModule } from '../bookings/bookings.module';
 
 @Module({
-  imports: [PrismaModule, CurrencyModule],
+  imports: [PrismaModule, CurrencyModule, BookingsModule],
   controllers: [PackagesController],
   providers: [PackagesService],
   exports: [PackagesService],
diff --git a/apps/edr-passenger-api/src/modules/packages/packages.service.ts b/apps/edr-passenger-api/src/modules/packages/packages.service.ts
index f6c25611c..3b14af6dd 100644
--- a/apps/edr-passenger-api/src/modules/packages/packages.service.ts
+++ b/apps/edr-passenger-api/src/modules/packages/packages.service.ts
@@ -3,6 +3,34 @@ import { PrismaService } from '../../common/prisma.service';
 import { CurrencyService } from '../currency/currency.service';
 import { CreatePackageDto, BookPackageDto, UpdatePriceTierDto, CreatePriceTierDto, CreateInquiryDto } from './packages.dto';
 import { Currency } from '@prisma/client';
+import { BookingsService } from '../bookings/bookings.service';
+import { GuestBookingService } from '../bookings/guest-booking.service';
+
+/** Package-specific fare rules */
+const PKG_MAX_ADULTS = 5;
+const PKG_MAX_CHILDREN = 2;
+const PKG_CHILD_FARE_RATIO = 0.1;
+
+function calculatePackageFareBreakdown(
+  priceMinor: number,
+  isRoundTrip: boolean,
+  adultCount: number,
+  childCount: number,
+) {
+  const multiplier = isRoundTrip ? 2 : 1;
+  const adultFareMinor = priceMinor * multiplier;
+  const childFareMinor = Math.round(adultFareMinor * PKG_CHILD_FARE_RATIO);
+  const totalMinor = adultCount * adultFareMinor + childCount * childFareMinor;
+  return { adultFareMinor, childFareMinor, totalMinor, multiplier };
+}
+
+function deriveAge(dateOfBirth: string | Date): number {
+  const today = new Date();
+  const dob = new Date(dateOfBirth);
+  let age = today.getFullYear() - dob.getFullYear();
+  if (today < new Date(today.getFullYear(), dob.getMonth(), dob.getDate())) age--;
+  return age;
+}
 
 function generateRef(): string {
   return 'PKG-' + Array.from({ length: 6 }, () =>
@@ -15,8 +43,102 @@ export class PackagesService {
   constructor(
     private readonly prisma: PrismaService,
     private readonly currencyService: CurrencyService,
+    private readonly bookingsService: BookingsService,
+    private readonly guestBookingService: GuestBookingService,
   ) {}
 
+  async getBookingContext(packageId: string, tierId: string, adultCount: number, childCount = 0) {
+    const pkg = await this.prisma.travelPackage.findUnique({
+      where: { id: packageId },
+      include: {
+        priceTiers: true,
+        outboundSchedule: {
+          include: {
+            originStation: true,
+            destinationStation: true,
+            coachAssignments: { include: { coach: { include: { coachType: { include: { seatClasses: true } } } } } },
+          },
+        },
+        returnSchedule: { include: { originStation: true, destinationStation: true } },
+      },
+    });
+    if (!pkg || pkg.status !== 'ACTIVE') throw new NotFoundException('Package not available');
+    const tier = pkg.priceTiers.find((t) => t.id === tierId);
+    if (!tier) throw new NotFoundException('Price tier not found');
+
+    if (adultCount < 1) throw new BadRequestException('At least one adult passenger required');
+    if (adultCount > PKG_MAX_ADULTS) throw new BadRequestException(`Maximum ${PKG_MAX_ADULTS} adults allowed per package booking`);
+    if (childCount > PKG_MAX_CHILDREN) throw new BadRequestException(`Maximum ${PKG_MAX_CHILDREN} children allowed per package booking`);
+
+    const passengerCount = adultCount + childCount;
+    const remaining = tier.availableSeats - tier.bookedSeats;
+    if (passengerCount > remaining)
+      throw new BadRequestException(`Only ${remaining} seat(s) remaining in the ${tier.label} tier`);
+
+    const isRoundTrip = !!pkg.returnScheduleId;
+    const { adultFareMinor, childFareMinor, totalMinor } = calculatePackageFareBreakdown(
+      tier.priceMinor, isRoundTrip, adultCount, childCount,
+    );
+
+    // Resolve the seatClassId and coachTypeId that matches this tier's seatType from the outbound schedule coaches
+    let seatClassId: string | null = null;
+    let coachTypeId: string | null = null;
+    for (const a of pkg.outboundSchedule.coachAssignments) {
+      const sc = a.coach.coachType?.seatClasses?.find(
+        (s: any) => s.name.toLowerCase().includes(tier.seatType.toLowerCase()) ||
+                    tier.seatType.toLowerCase().includes(s.name.toLowerCase()),
+      );
+      if (sc) { seatClassId = sc.id; coachTypeId = a.coach.coachTypeId ?? a.coach.coachType?.id ?? null; break; }
+    }
+    if (!coachTypeId && pkg.outboundSchedule.coachAssignments.length > 0) {
+      const first = pkg.outboundSchedule.coachAssignments[0];
+      coachTypeId = first.coach.coachTypeId ?? first.coach.coachType?.id ?? null;
+    }
+
+    return {
+      packageId: pkg.id,
+      packageName: pkg.name,
+      priceTierId: tier.id,
+      tierLabel: tier.label,
+      seatType: tier.seatType,
+      seatClassId,
+      coachTypeId,
+      adultCount,
+      childCount,
+      passengerCount,
+      isRoundTrip,
+      pricePerAdultMinor: adultFareMinor,
+      pricePerChildMinor: childFareMinor,
+      childFareNote: `Children pay ${PKG_CHILD_FARE_RATIO * 100}% of adult fare`,
+      maxAdults: PKG_MAX_ADULTS,
+      maxChildren: PKG_MAX_CHILDREN,
+      totalMinor,
+      currency: tier.currency,
+      remainingSeats: remaining,
+      outboundSchedule: {
+        scheduleId: pkg.outboundScheduleId,
+        originStationId: pkg.outboundSchedule.originStationId,
+        destinationStationId: pkg.outboundSchedule.destinationStationId,
+        departureAt: pkg.outboundSchedule.departureAt,
+        arrivalAt: pkg.outboundSchedule.arrivalAt,
+        originStation: pkg.outboundSchedule.originStation,
+        destinationStation: pkg.outboundSchedule.destinationStation,
+      },
+      returnSchedule: pkg.returnSchedule ? {
+        scheduleId: pkg.returnScheduleId,
+        originStationId: pkg.returnSchedule.originStationId,
+        destinationStationId: pkg.returnSchedule.destinationStationId,
+        departureAt: pkg.returnSchedule.departureAt,
+        arrivalAt: pkg.returnSchedule.arrivalAt,
+        originStation: pkg.returnSchedule.originStation,
+        destinationStation: pkg.returnSchedule.destinationStation,
+      } : null,
+      includedServices: pkg.includedServices,
+      busTransferIncluded: pkg.busTransferIncluded,
+      busTransferRoute: pkg.busTransferRoute,
+    };
+  }
+
   async createInquiry(dto: CreateInquiryDto) {
     return this.prisma.packageInquiry.create({
       data: {
@@ -74,7 +196,7 @@ export class PackagesService {
         returnSchedule: { include: { originStation: true, destinationStation: true } },
       },
       orderBy: { validFrom: 'asc' },
-    });
+    }).then(pkgs => pkgs.map(p => ({ ...p, journeyType: p.returnScheduleId ? 'ROUND_TRIP' : 'ONE_WAY' })));
   }
 
   async getById(id: string) {
@@ -82,12 +204,19 @@ export class PackagesService {
       where: { id },
       include: {
         priceTiers: true,
-        outboundSchedule: { include: { originStation: true, destinationStation: true, train: true } },
+        outboundSchedule: {
+          include: {
+            originStation: true,
+            destinationStation: true,
+            train: true,
+            stopTimes: { include: { station: true }, orderBy: { sequence: 'asc' } },
+          },
+        },
         returnSchedule: { include: { originStation: true, destinationStation: true, train: true } },
       },
     });
     if (!pkg) throw new NotFoundException('Package not found');
-    return pkg;
+    return { ...pkg, journeyType: pkg.returnScheduleId ? 'ROUND_TRIP' : 'ONE_WAY' };
   }
 
   create(dto: CreatePackageDto) {
@@ -209,13 +338,30 @@ export class PackagesService {
     const tier = pkg.priceTiers.find((t) => t.id === dto.priceTierId);
     if (!tier) throw new NotFoundException('Price tier not found');
 
-    const passengerCount = dto.passengers.length;
+    // Derive adult/child counts from the passengers array (dateOfBirth-based)
+    let adultCount = 0, childCount = 0;
+    for (const p of dto.passengers) {
+      if (p.dateOfBirth && deriveAge(p.dateOfBirth) < 5) childCount++;
+      else adultCount++;
+    }
+    // Allow explicit override from mobile app (e.g. when dateOfBirth is not provided per passenger)
+    if (dto.adultCount !== undefined) adultCount = dto.adultCount;
+    if (dto.childCount !== undefined) childCount = dto.childCount;
+
+    if (adultCount < 1) throw new BadRequestException('At least one adult passenger required');
+    if (adultCount > PKG_MAX_ADULTS) throw new BadRequestException(`Maximum ${PKG_MAX_ADULTS} adults allowed per package booking`);
+    if (childCount > PKG_MAX_CHILDREN) throw new BadRequestException(`Maximum ${PKG_MAX_CHILDREN} children allowed per package booking`);
+
+    const passengerCount = adultCount + childCount;
     const remaining = tier.availableSeats - tier.bookedSeats;
     if (passengerCount > remaining) {
       throw new BadRequestException(`Only ${remaining} seats remaining in the ${tier.label} tier`);
     }
 
-    const totalMinor = tier.priceMinor * passengerCount;
+    const isRoundTrip = !!pkg.returnScheduleId;
+    const { adultFareMinor, childFareMinor, totalMinor } = calculatePackageFareBreakdown(
+      tier.priceMinor, isRoundTrip, adultCount, childCount,
+    );
     const displayCurrency = (dto.displayCurrency as Currency) ?? Currency.ETB;
     const displayTotalMinor =
       displayCurrency !== Currency.ETB
@@ -266,7 +412,21 @@ export class PackagesService {
       }),
     ]);
 
-    return booking;
+    return {
+      ...booking,
+      fareBreakdown: {
+        isRoundTrip,
+        adultCount,
+        adultFareMinor,
+        childCount,
+        childFareMinor,
+        childFareNote: `Children pay ${PKG_CHILD_FARE_RATIO * 100}% of adult fare`,
+        totalMinor,
+        currency: 'ETB',
+        displayCurrency,
+        displayTotalMinor,
+      },
+    };
   }
 
   getMyBookings(passengerId: string) {
@@ -296,6 +456,29 @@ export class PackagesService {
     return booking;
   }
 
+  async listBookings({ packageId, status, page = 1, pageSize = 20 }: { packageId?: string; status?: string; page?: number; pageSize?: number }) {
+    const where: any = {};
+    if (packageId) where.packageId = packageId;
+    if (status) where.status = status;
+    const skip = (page - 1) * pageSize;
+    const [items, total] = await Promise.all([
+      this.prisma.packageBooking.findMany({
+        where,
+        include: {
+          package: { select: { id: true, name: true, code: true } },
+          priceTier: { select: { id: true, label: true, seatType: true } },
+          passengers: true,
+          paymentIntent: true,
+        },
+        orderBy: { createdAt: 'desc' },
+        skip,
+        take: pageSize,
+      }),
+      this.prisma.packageBooking.count({ where }),
+    ]);
+    return { items, total, page, pageSize, totalPages: Math.ceil(total / pageSize) };
+  }
+
   async listAll(page = 1, pageSize = 20) {
     const skip = (page - 1) * pageSize;
     const [items, total] = await Promise.all([
diff --git a/apps/edr-passenger-api/src/modules/passengers/passengers.service.ts b/apps/edr-passenger-api/src/modules/passengers/passengers.service.ts
index ea952d98c..d41fcbfed 100644
--- a/apps/edr-passenger-api/src/modules/passengers/passengers.service.ts
+++ b/apps/edr-passenger-api/src/modules/passengers/passengers.service.ts
@@ -433,39 +433,49 @@ export class PassengersService {
   }
 
   async deletePassenger(id: string) {
-    const passenger = await this.prisma.passenger.findUnique({ 
+    // id may be a TravelerProfile.id (from the list endpoint) or a Passenger.id
+    let passenger = await this.prisma.passenger.findUnique({
       where: { id },
-      include: {
-        user: true
-      }
+      include: { user: true },
     });
-    if (!passenger) throw new NotFoundException('Passenger not found');
+
+    if (!passenger) {
+      const profile = await this.prisma.travelerProfile.findUnique({ where: { id } });
+      if (!profile?.passengerId) throw new NotFoundException('Passenger not found');
+      passenger = await this.prisma.passenger.findUnique({
+        where: { id: profile.passengerId },
+        include: { user: true },
+      });
+      if (!passenger) throw new NotFoundException('Passenger not found');
+    }
+
+    const passengerId = passenger.id;
 
     // Check usage before allowing deletion
-    const usage = await this.checkPassengerUsage(id);
+    const usage = await this.checkPassengerUsage(passengerId);
     if (usage.isInUse && usage.constraints) {
-      const passengerName = (passenger as any).user?.fullName || `Passenger ${id.slice(-8)}`;
+      const passengerName = (passenger as any).user?.fullName || `Passenger ${passengerId.slice(-8)}`;
       throw new DeleteOperationException('Passenger', passengerName, usage.constraints);
     }
 
     await this.prisma.$transaction([
-      this.prisma.loyaltyLedgerEntry.deleteMany({ where: { account: { passengerId: id } } }),
-      this.prisma.loyaltyAccount.deleteMany({ where: { passengerId: id } }),
-      this.prisma.walletLedgerEntry.deleteMany({ where: { wallet: { passengerId: id } } }),
-      this.prisma.walletAccount.deleteMany({ where: { passengerId: id } }),
-      this.prisma.notification.deleteMany({ where: { passengerId: id } }),
-      this.prisma.travelerProfile.deleteMany({ where: { passengerId: id } }),
-      this.prisma.savedRoute.deleteMany({ where: { passengerId: id } }),
-      this.prisma.packageBooking.deleteMany({ where: { passengerId: id } }),
-      this.prisma.ticket.deleteMany({ where: { booking: { passengerId: id } } }),
-      this.prisma.bookingSeat.deleteMany({ where: { booking: { passengerId: id } } }),
-      this.prisma.booking.deleteMany({ where: { passengerId: id } }),
-      this.prisma.journeySegment.deleteMany({ where: { journey: { passengerId: id } } }),
-      this.prisma.journey.deleteMany({ where: { passengerId: id } }),
-      this.prisma.passenger.delete({ where: { id } }),
+      this.prisma.loyaltyLedgerEntry.deleteMany({ where: { account: { passengerId } } }),
+      this.prisma.loyaltyAccount.deleteMany({ where: { passengerId } }),
+      this.prisma.walletLedgerEntry.deleteMany({ where: { wallet: { passengerId } } }),
+      this.prisma.walletAccount.deleteMany({ where: { passengerId } }),
+      this.prisma.notification.deleteMany({ where: { passengerId } }),
+      this.prisma.travelerProfile.deleteMany({ where: { passengerId } }),
+      this.prisma.savedRoute.deleteMany({ where: { passengerId } }),
+      this.prisma.packageBooking.deleteMany({ where: { passengerId } }),
+      this.prisma.ticket.deleteMany({ where: { booking: { passengerId } } }),
+      this.prisma.bookingSeat.deleteMany({ where: { booking: { passengerId } } }),
+      this.prisma.booking.deleteMany({ where: { passengerId } }),
+      this.prisma.journeySegment.deleteMany({ where: { journey: { passengerId } } }),
+      this.prisma.journey.deleteMany({ where: { passengerId } }),
+      this.prisma.passenger.delete({ where: { id: passengerId } }),
     ]);
 
-    return { deleted: true, passengerId: id };
+    return { deleted: true, passengerId };
   }
 
   async checkPassengerUsage(id: string) {
diff --git a/apps/edr-passenger-api/src/modules/payments/payments.controller.ts b/apps/edr-passenger-api/src/modules/payments/payments.controller.ts
index 280ef2752..5be11434a 100644
--- a/apps/edr-passenger-api/src/modules/payments/payments.controller.ts
+++ b/apps/edr-passenger-api/src/modules/payments/payments.controller.ts
@@ -1,6 +1,7 @@
 import {
   Body,
   Controller,
+  Delete,
   Get,
   HttpStatus,
   Param,
@@ -42,6 +43,14 @@ import { PASSENGER_PERMS } from "../../seed/passenger-permissions.registry";
 export class PaymentsController {
   constructor(private service: PaymentsService) {}
 
+  @Delete(":id")
+  @PassengerStaff([PASSENGER_PERMS.admin])
+  @ApiBearerAuth("IAM-auth")
+  @ApiOperation({ summary: "Delete a payment intent record (admin only)" })
+  deletePayment(@Param("id") id: string) {
+    return this.service.deletePayment(id);
+  }
+
   @Get("all")
   @PassengerStaff([PASSENGER_PERMS.payments.viewAll, PASSENGER_PERMS.admin])
   @ApiBearerAuth("IAM-auth")
diff --git a/apps/edr-passenger-api/src/modules/payments/payments.service.ts b/apps/edr-passenger-api/src/modules/payments/payments.service.ts
index af496a5a2..b79079c39 100644
--- a/apps/edr-passenger-api/src/modules/payments/payments.service.ts
+++ b/apps/edr-passenger-api/src/modules/payments/payments.service.ts
@@ -55,6 +55,13 @@ export class PaymentsService {
     private currencyService: CurrencyService,
   ) {}
 
+  async deletePayment(id: string) {
+    const intent = await this.prisma.paymentIntent.findUnique({ where: { id } });
+    if (!intent) throw new NotFoundException('Payment intent not found');
+    await this.prisma.paymentIntent.delete({ where: { id } });
+    return { deleted: true, id };
+  }
+
   async getAll(filters: {
     search?: string;
     status?: string;
diff --git a/apps/edr-passenger-api/src/modules/schedules/schedules.dto.ts b/apps/edr-passenger-api/src/modules/schedules/schedules.dto.ts
index 044768e90..80f3ad13b 100644
--- a/apps/edr-passenger-api/src/modules/schedules/schedules.dto.ts
+++ b/apps/edr-passenger-api/src/modules/schedules/schedules.dto.ts
@@ -50,8 +50,8 @@ export class CreateScheduleDto {
       { sequence: 6, plannedArrivalAt: '2026-06-15T20:00:00Z' },
     ],
   })
-  @IsArray() @ValidateNested({ each: true }) @Type(() => PlannedStopTimeDto)
-  plannedTimes: PlannedStopTimeDto[];
+  @IsOptional() @IsArray() @ValidateNested({ each: true }) @Type(() => PlannedStopTimeDto)
+  plannedTimes?: PlannedStopTimeDto[];
 }
 
 export class UpdateScheduleDto {
diff --git a/apps/edr-passenger-api/src/modules/schedules/schedules.service.ts b/apps/edr-passenger-api/src/modules/schedules/schedules.service.ts
index 2d194fd7b..19aa5ed0e 100644
--- a/apps/edr-passenger-api/src/modules/schedules/schedules.service.ts
+++ b/apps/edr-passenger-api/src/modules/schedules/schedules.service.ts
@@ -153,7 +153,7 @@ export class SchedulesService {
       });
     }
 
-    const providedSeqs = new Set(plannedTimes.map(t => t.sequence));
+    const providedSeqs = new Set((plannedTimes ?? []).map(t => t.sequence));
     const missingSeqs = route.stops.map(s => s.sequence).filter(seq => !providedSeqs.has(seq));
     if (missingSeqs.length > 0) {
       throw new BadRequestException(`Missing planned times for stop sequences: ${missingSeqs.join(', ')}`);
diff --git a/apps/edr-passenger-api/src/modules/search/search.controller.ts b/apps/edr-passenger-api/src/modules/search/search.controller.ts
index 6bb9d1960..384592dc9 100644
--- a/apps/edr-passenger-api/src/modules/search/search.controller.ts
+++ b/apps/edr-passenger-api/src/modules/search/search.controller.ts
@@ -1,8 +1,8 @@
-import { Body, Controller, Post } from '@nestjs/common';
-import { ApiTags, ApiOperation, ApiResponse } from '@nestjs/swagger';
+import { Body, Controller, Post, Get, Query } from '@nestjs/common';
+import { ApiTags, ApiOperation, ApiResponse, ApiQuery } from '@nestjs/swagger';
 import { IsPublic } from '@tria-plc/api-common/modules/auth/decorators/public.decorator';
 import { SearchService } from './search.service';
-import { SearchTripsDto, FareQuoteDto } from './search.dto';
+import { SearchTripsDto, FareQuoteDto, FareBreakdownRequestDto } from './search.dto';
 
 @ApiTags('Search')
 @Controller('search')
@@ -66,4 +66,29 @@ Nationality-Based:
   getFareQuote(@Body() dto: FareQuoteDto) {
     return this.service.getFareQuote(dto);
   }
+
+  @Get('fare-breakdown')
+  @ApiOperation({
+    summary: 'Per-passenger fare breakdown for booking review page',
+    description: `Calculates a line-item fare for each individual passenger based on their date of birth, nationality, and chosen seat class.
+
+- Age is derived from dateOfBirth at request time (ADULT ≥5 yrs, CHILD <5 yrs)
+- First CHILD in the list travels free (pays only premium + insurance fees)
+- Each passenger can have a different seat class and nationality
+- Returns per-passenger lines plus subtotal, discount, and grand total
+
+**passengers** must be a URL-encoded JSON array, e.g.:
+\`[{"passengerName":"Abebe","dateOfBirth":"1985-03-15","seatClassId":"uuid","nationality":"Ethiopian"}]\``,
+  })
+  @ApiQuery({ name: 'scheduleId', description: 'TrainSchedule UUID' })
+  @ApiQuery({ name: 'originStationId', description: 'Origin station UUID' })
+  @ApiQuery({ name: 'destinationStationId', description: 'Destination station UUID' })
+  @ApiQuery({ name: 'passengers', description: 'URL-encoded JSON array of passengers: [{passengerName, dateOfBirth, seatClassId, nationality?}]' })
+  @ApiQuery({ name: 'promoCode', required: false })
+  @ApiQuery({ name: 'displayCurrency', required: false, enum: ['ETB', 'DJF', 'USD'] })
+  @ApiResponse({ status: 200, description: 'Per-passenger fare lines with grand total' })
+  @ApiResponse({ status: 404, description: 'Schedule not found' })
+  getFareBreakdown(@Query() dto: FareBreakdownRequestDto) {
+    return this.service.getFareBreakdown(dto);
+  }
 }
diff --git a/apps/edr-passenger-api/src/modules/search/search.dto.ts b/apps/edr-passenger-api/src/modules/search/search.dto.ts
index 9eb035ef2..cfb1075ca 100644
--- a/apps/edr-passenger-api/src/modules/search/search.dto.ts
+++ b/apps/edr-passenger-api/src/modules/search/search.dto.ts
@@ -75,6 +75,43 @@ export class CoachTypeOptionClass {
   @ApiProperty({ example: 35000 }) baseFareMinor: number;
 }
 
+export class FareBreakdownPassengerDto {
+  @ApiProperty({ example: 'Abebe Kebede', description: 'Passenger name (for display only)' })
+  @IsString() passengerName: string;
+
+  @ApiProperty({ example: '1985-03-15', description: 'Date of birth — determines ADULT (≥5 yrs) or CHILD (<5 yrs)' })
+  @IsDateString() dateOfBirth: string;
+
+  @ApiProperty({ example: 'seat-class-uuid', description: 'SeatClass UUID for this passenger' })
+  @IsString() seatClassId: string;
+
+  @ApiPropertyOptional({ example: 'Ethiopian', description: 'Nationality — affects billing currency and seat class variant' })
+  @IsOptional() @IsString() nationality?: string;
+}
+
+export class FareBreakdownRequestDto {
+  @ApiProperty({ example: 'schedule-uuid' })
+  @IsString() scheduleId: string;
+
+  @ApiProperty({ example: 'station-uuid', description: 'Origin station UUID (must be a stop on the schedule)' })
+  @IsString() originStationId: string;
+
+  @ApiProperty({ example: 'station-uuid', description: 'Destination station UUID' })
+  @IsString() destinationStationId: string;
+
+  @ApiProperty({
+    example: '[{"passengerName":"Abebe","dateOfBirth":"1985-03-15","seatClassId":"uuid","nationality":"Ethiopian"}]',
+    description: 'URL-encoded JSON array of passengers. Each entry: { passengerName, dateOfBirth (YYYY-MM-DD), seatClassId, nationality? }',
+  })
+  @IsString() passengers: string;
+
+  @ApiPropertyOptional({ example: 'WEEKEND15' })
+  @IsOptional() @IsString() promoCode?: string;
+
+  @ApiPropertyOptional({ example: 'USD', enum: Currency })
+  @IsOptional() @IsEnum(Currency) displayCurrency?: Currency;
+}
+
 export class CoachTypeOption {
   @ApiProperty({ example: 'coach-type-uuid' }) coachTypeId: string;
   @ApiProperty({ example: 'Economy' }) coachTypeName: string;
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 6f3bc5a67..621e5487d 100644
--- a/apps/edr-passenger-api/src/modules/search/search.service.ts
+++ b/apps/edr-passenger-api/src/modules/search/search.service.ts
@@ -1,6 +1,6 @@
 import { Injectable, NotFoundException } from '@nestjs/common';
 import { PrismaService } from '../../common/prisma.service';
-import { SearchTripsDto, FareQuoteDto } from './search.dto';
+import { SearchTripsDto, FareQuoteDto, FareBreakdownRequestDto, FareBreakdownPassengerDto } from './search.dto';
 import { CurrencyService } from '../currency/currency.service';
 import { FareEngineService } from '../fare-engine/fare-engine.service';
 import { SegmentsService } from '../segments/segments.service';
@@ -477,6 +477,124 @@ export class SearchService {
     };
   }
 
+  async getFareBreakdown(dto: FareBreakdownRequestDto) {
+    const schedule = await this.prisma.trainSchedule.findUnique({
+      where: { id: dto.scheduleId },
+      select: { routeId: true, originStationId: true, destinationStationId: true },
+    });
+    if (!schedule) throw new NotFoundException('Schedule not found');
+    if (!schedule.routeId) throw new NotFoundException('Schedule has no route configured for fare calculation');
+
+    const now = new Date();
+    const displayCurrency = dto.displayCurrency ?? Currency.ETB;
+
+    let parsedPassengers: FareBreakdownPassengerDto[];
+    try {
+      parsedPassengers = JSON.parse(dto.passengers as unknown as string);
+    } catch {
+      throw new NotFoundException('passengers must be a valid JSON array');
+    }
+
+    // Categorise passengers by age
+    const categorised = parsedPassengers.map(p => {
+      const ageMs = now.getTime() - new Date(p.dateOfBirth).getTime();
+      const ageYears = ageMs / (1000 * 60 * 60 * 24 * 365.25);
+      return { ...p, category: (ageYears >= 5 ? 'ADULT' : 'CHILD') as 'ADULT' | 'CHILD', ageYears };
+    });
+
+    const adultCount = categorised.filter(p => p.category === 'ADULT').length;
+    const childCount = categorised.filter(p => p.category === 'CHILD').length;
+
+    // Ask the fare engine for the authoritative free-child count using the full group
+    // Use the first passenger's seatClassId as a representative — freeChildrenCount
+    // depends only on adultCount/childCount, not on seat class.
+    const groupFare = await this.fareEngine.calculate({
+      routeId: schedule.routeId!,
+      originStationId: dto.originStationId,
+      destinationStationId: dto.destinationStationId,
+      seatClassId: categorised[0].seatClassId,
+      nationality: categorised[0].nationality,
+      scheduleId: dto.scheduleId,
+      adultCount,
+      childCount,
+    });
+    const freeChildrenAllowed = groupFare.freeChildrenCount;
+
+    // Calculate per-passenger fare rate (engine called with 1 adult, 0 children — pure rate lookup)
+    let freeChildrenUsed = 0;
+    const passengerLines = await Promise.all(
+      categorised.map(async (p) => {
+        const fare = await this.fareEngine.calculate({
+          routeId: schedule.routeId!,
+          originStationId: dto.originStationId,
+          destinationStationId: dto.destinationStationId,
+          seatClassId: p.seatClassId,
+          nationality: p.nationality,
+          scheduleId: dto.scheduleId,
+          adultCount: 1,
+          childCount: 0,
+        });
+
+        const isFree = p.category === 'CHILD' && freeChildrenUsed < freeChildrenAllowed;
+        if (isFree) freeChildrenUsed++;
+
+        const fareMinor = isFree
+          ? fare.premiumPerPassenger + fare.insurancePerPassenger
+          : fare.farePerPassengerMinor;
+        const displayFareMinor = displayCurrency !== Currency.ETB
+          ? await this.currencyService.convertAmount(fareMinor, Currency.ETB, displayCurrency)
+          : fareMinor;
+
+        return {
+          passengerName: p.passengerName,
+          dateOfBirth: p.dateOfBirth,
+          category: p.category,
+          ageYears: Math.floor(p.ageYears),
+          seatClassId: fare.seatClassId,
+          seatClassName: fare.seatClassName,
+          nationality: p.nationality ?? null,
+          baseFareMinor: fare.baseFarePerPassengerMinor,
+          premiumMinor: fare.premiumPerPassenger,
+          insuranceFeeMinor: fare.insurancePerPassenger,
+          fareMinor,
+          isFree,
+          displayCurrency,
+          displayFareMinor,
+        };
+      }),
+    );
+
+    let subtotalMinor = passengerLines.reduce((sum, l) => sum + l.fareMinor, 0);
+
+    let discountMinor = 0;
+    if (dto.promoCode) {
+      const promo = await this.prisma.promotion.findUnique({ where: { code: dto.promoCode } });
+      if (promo?.active && promo.validUntil > now) {
+        discountMinor = promo.percentOff
+          ? Math.round(subtotalMinor * promo.percentOff / 100)
+          : (promo.amountOffMinor ?? 0);
+      }
+    }
+
+    const totalMinor = subtotalMinor - discountMinor;
+    const displayTotalMinor = displayCurrency !== Currency.ETB
+      ? await this.currencyService.convertAmount(totalMinor, Currency.ETB, displayCurrency)
+      : totalMinor;
+
+    return {
+      scheduleId: dto.scheduleId,
+      originStationId: dto.originStationId,
+      destinationStationId: dto.destinationStationId,
+      passengers: passengerLines,
+      subtotalMinor,
+      discountMinor,
+      totalMinor,
+      currency: 'ETB',
+      displayCurrency,
+      displayTotalMinor,
+    };
+  }
+
   private async calculateFaresForSegment(
     schedule: ScheduleWithIncludes,
     originStationId: string,
diff --git a/apps/edr-passenger-api/src/modules/seat-classes/seat-classes.service.ts b/apps/edr-passenger-api/src/modules/seat-classes/seat-classes.service.ts
index 79151bdc9..63f5e1f29 100644
--- a/apps/edr-passenger-api/src/modules/seat-classes/seat-classes.service.ts
+++ b/apps/edr-passenger-api/src/modules/seat-classes/seat-classes.service.ts
@@ -1,5 +1,6 @@
 import { Injectable, NotFoundException, ConflictException } from '@nestjs/common';
 import { PrismaService } from '../../common/prisma.service';
+import { DeleteOperationException } from '../../common/exceptions/delete-operation.exception';
 
 @Injectable()
 export class SeatClassesService {
@@ -45,8 +46,24 @@ export class SeatClassesService {
   }
 
   async deleteSeatClass(id: string) {
-    const sc = await this.prisma.seatClass.findUnique({ where: { id } });
+    const sc = await this.prisma.seatClass.findUnique({
+      where: { id },
+      include: {
+        _count: { select: { fareRules: true, routeFareRules: true, segmentFares: true } },
+      },
+    });
     if (!sc) throw new NotFoundException('SeatClass not found');
+
+    const totalFareRules =
+      (sc as any)._count.fareRules +
+      (sc as any)._count.routeFareRules +
+      (sc as any)._count.segmentFares;
+
+    if (totalFareRules > 0)
+      throw new DeleteOperationException('Seat Class', sc.name, [
+        { entityName: 'fare rule', count: totalFareRules, action: 'delete' },
+      ]);
+
     return this.prisma.seatClass.delete({ where: { id } });
   }
 }
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 a8d5d724c..4a9783101 100644
--- a/apps/edr-passenger-api/src/modules/seats/seats.controller.ts
+++ b/apps/edr-passenger-api/src/modules/seats/seats.controller.ts
@@ -28,6 +28,25 @@ import { IamGuard } from "../../common/iam-adapter";
 export class SeatsController {
   constructor(private service: SeatsService) {}
 
+  // ── Coach Availability ────────────────────────────────────────────────────
+  @Get('coaches/:scheduleId')
+  @SetMetadata('isPublic', true)
+  @ApiOperation({
+    summary: 'List coaches with remaining seat counts for a schedule',
+    description: 'Returns each coach assigned to the schedule with total, available, held, and booked seat counts. Optionally scoped to a specific origin→destination leg.',
+  })
+  @ApiParam({ name: 'scheduleId', description: 'TrainSchedule UUID' })
+  @ApiQuery({ name: 'originStationId', required: false, description: 'Scope availability to this origin station' })
+  @ApiQuery({ name: 'destinationStationId', required: false, description: 'Scope availability to this destination station' })
+  @ApiResponse({ status: 200, description: 'Coaches with seat availability counts' })
+  getCoachesWithAvailability(
+    @Param('scheduleId') scheduleId: string,
+    @Query('originStationId') originStationId?: string,
+    @Query('destinationStationId') destinationStationId?: string,
+  ) {
+    return this.service.getCoachesWithAvailability(scheduleId, originStationId, destinationStationId);
+  }
+
   // ── Seat Map ──────────────────────────────────────────────────────────────
   @Get("seatmap/:scheduleId")
   @SetMetadata('isPublic', true)
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 1562a600b..495c394ee 100644
--- a/apps/edr-passenger-api/src/modules/seats/seats.service.ts
+++ b/apps/edr-passenger-api/src/modules/seats/seats.service.ts
@@ -61,11 +61,12 @@ export class SeatsService {
           const resolvedBedPosition = isBedCoach
             ? this.resolveBedPosition(s.col, s.bedPosition)
             : s.bedPosition;
+          const effectiveStatus = effectiveStatuses.get(s.id) ?? (s.status === 'BLOCKED' || s.status === 'BOOKED' ? s.status : 'AVAILABLE');
           return {
             id:          s.id,
             seatNumber:  s.seatNumber,
             label:       s.seatNumber,
-            status:      effectiveStatuses.get(s.id) ?? s.status,
+            status:      effectiveStatus,
             kind:        s.kind,
             row:         s.row,
             col:         s.col,
@@ -245,11 +246,16 @@ export class SeatsService {
           holdFrom === undefined || holdTo === undefined ||
           (holdFrom < reqTo && reqFrom < holdTo);
         
-        if (!legsOverlap) continue;
-        
         // Check direction conflict
         const directionsConflict = this.checkDirectionConflict(reqDirection, holdDirection);
-        if (!directionsConflict) continue;
+
+        if (!legsOverlap || !directionsConflict) {
+          // This hold does not conflict with the requested leg/direction.
+          // Explicitly mark AVAILABLE so the DB's HELD status (set by the
+          // opposing-direction hold) does not bleed through via the fallback.
+          if (!statusMap.has(seatId)) statusMap.set(seatId, 'AVAILABLE');
+          continue;
+        }
         
         statusMap.set(seatId, 'HELD');
       }
@@ -367,7 +373,24 @@ export class SeatsService {
         where: { scheduleId: dto.scheduleId },
         select: { stationId: true, sequence: true },
       });
-      const seqOf = (stationId: string) => stopTimes.find(s => s.stationId === stationId)?.sequence;
+
+      // When no stop times exist, fall back to the schedule's own origin/destination
+      // with synthetic sequences so the hold can still be created.
+      let effectiveStopTimes = stopTimes;
+      if (stopTimes.length === 0) {
+        const sched = await tx.trainSchedule.findUnique({
+          where: { id: dto.scheduleId },
+          select: { originStationId: true, destinationStationId: true },
+        });
+        if (sched) {
+          effectiveStopTimes = [
+            { stationId: sched.originStationId, sequence: 0 },
+            { stationId: sched.destinationStationId, sequence: 1 },
+          ];
+        }
+      }
+
+      const seqOf = (stationId: string) => effectiveStopTimes.find(s => s.stationId === stationId)?.sequence;
       const reqFrom = seqOf(dto.originStationId);
       const reqTo   = seqOf(dto.destinationStationId);
 
@@ -604,6 +627,56 @@ export class SeatsService {
     await this.prisma.journey.deleteMany({ where: { bookingId } as any });
   }
 
+  async getCoachesWithAvailability(scheduleId: string, originStationId?: string, destinationStationId?: string) {
+    const schedule = await this.prisma.trainSchedule.findUnique({
+      where: { id: scheduleId },
+      select: { originStationId: true, destinationStationId: true },
+    });
+    if (!schedule) throw new NotFoundException('Schedule not found');
+
+    const assignments = await this.prisma.coachAssignment.findMany({
+      where: { scheduleId },
+      include: {
+        coach: {
+          include: {
+            seats: { select: { id: true, status: true, seatNumber: true } },
+            coachType: { include: { seatClasses: { select: { name: true } } } },
+          },
+        },
+      },
+      orderBy: { positionNumber: 'asc' },
+    });
+
+    const allSeatIds = assignments.flatMap(a => a.coach.seats.map(s => s.id));
+    const effectiveStatuses = await this.resolveEffectiveStatuses(
+      scheduleId,
+      allSeatIds,
+      originStationId ?? schedule.originStationId,
+      destinationStationId ?? schedule.destinationStationId,
+    );
+
+    return assignments.map(a => {
+      const seats = a.coach.seats.filter(s => s.seatNumber && !s.seatNumber.startsWith('-'));
+      const totalSeats = seats.length;
+      const unavailable = seats.filter(s => {
+        const status = effectiveStatuses.get(s.id) ?? (s.status === 'BLOCKED' || s.status === 'BOOKED' ? s.status : 'AVAILABLE');
+        return status === 'HELD' || status === 'BOOKED' || status === 'BLOCKED';
+      }).length;
+
+      return {
+        coachId: a.coach.id,
+        coachNumber: a.coach.number,
+        positionNumber: a.positionNumber,
+        coachTypeName: a.coach.coachType?.name ?? '',
+        seatClasses: a.coach.coachType?.seatClasses.map(sc => sc.name) ?? [],
+        totalSeats,
+        availableSeats: totalSeats - unavailable,
+        heldSeats: seats.filter(s => (effectiveStatuses.get(s.id) ?? (s.status === 'BLOCKED' || s.status === 'BOOKED' ? s.status : 'AVAILABLE')) === 'HELD').length,
+        bookedSeats: seats.filter(s => (effectiveStatuses.get(s.id) ?? (s.status === 'BLOCKED' || s.status === 'BOOKED' ? s.status : 'AVAILABLE')) === 'BOOKED').length,
+      };
+    });
+  }
+
   async autoAssignSeats(scheduleId: string, count: number, seatClassName: string): Promise<string[]> {
     const seats = await this.prisma.seat.findMany({
       where: {
@@ -794,11 +867,21 @@ export class SeatsService {
     if (expired.length === 0) return;
 
     const expiredSeatIds = expired.flatMap(h => h.seatIds as string[]);
-    // Only reset seats that are still HELD — BOOKED seats have been confirmed and must not be touched.
-    await this.prisma.seat.updateMany({
-      where: { id: { in: expiredSeatIds }, status: 'HELD' },
-      data: { status: 'AVAILABLE' },
+
+    // Only reset seats that have no remaining active holds
+    const stillHeld = await this.prisma.seatHold.findMany({
+      where: { expiresAt: { gte: new Date() }, seatIds: { hasSome: expiredSeatIds } },
+      select: { seatIds: true },
     });
+    const stillHeldIds = new Set(stillHeld.flatMap(h => h.seatIds as string[]));
+    const toRelease = expiredSeatIds.filter(id => !stillHeldIds.has(id));
+
+    if (toRelease.length > 0) {
+      await this.prisma.seat.updateMany({
+        where: { id: { in: toRelease }, status: 'HELD' },
+        data: { status: 'AVAILABLE' },
+      });
+    }
     await this.prisma.seatHold.deleteMany({ where: { expiresAt: { lt: new Date() } } });
   }
 }
diff --git a/apps/edr-passenger-api/src/modules/segments/booking-flow-example.ts b/apps/edr-passenger-api/src/modules/segments/booking-flow-example.ts
deleted file mode 100644
index 7e912a6e2..000000000
--- a/apps/edr-passenger-api/src/modules/segments/booking-flow-example.ts
+++ /dev/null
@@ -1,238 +0,0 @@
-/**
- * SEGMENT-BASED SEAT RESERVATION EXAMPLE
- *
- * Demonstrates the complete flow for booking Addis Ababa → Dire Dawa
- * on the Addis Ababa → Djibouti route with segment-based seat management.
- *
- * Route: Addis Ababa (seq:1) → Adama (seq:2) → Awash (seq:3) → Dire Dawa (seq:4) → Aysha (seq:5) → Djibouti (seq:6)
- * Booking: Addis Ababa → Dire Dawa (segments: 1→2, 2→3, 3→4)
- */
-
-import { PrismaClient } from '@prisma/client';
-
-const prisma = new PrismaClient();
-
-async function exampleBookingFlow() {
-  console.log('=== SEGMENT-BASED BOOKING FLOW ===\n');
-
-  const scheduleId = 'schedule_add_dji_001';
-  const passengerId = 'passenger_kelemu';
-  const seatIds = ['seat_coach_a_1a', 'seat_coach_a_1b'];
-  const originStationId = 'st_ADD';
-  const destinationStationId = 'st_DRE';
-
-  try {
-    console.log('1. Checking seat availability...');
-    const segments = await getJourneySegments(scheduleId, originStationId, destinationStationId);
-    console.log('Journey segments:', segments.map(s => `${s.fromName} → ${s.toName}`));
-
-    console.log('\n2. Holding seats...');
-    const holdResult = await holdSeatsTransaction(scheduleId, seatIds, passengerId, originStationId, destinationStationId);
-    console.log('Hold created:', holdResult);
-
-    console.log('\n3. Processing payment...');
-    await new Promise(resolve => setTimeout(resolve, 5000));
-
-    console.log('\n4. Confirming booking...');
-    const bookingId = 'booking_' + Date.now();
-    const confirmResult = await confirmBookingTransaction(holdResult.holdId, bookingId, segments);
-    console.log('Booking confirmed:', confirmResult);
-
-    console.log('\n5. Simulating trip progress...');
-    await simulateTripProgress(scheduleId, segments);
-
-  } catch (error) {
-    console.error('Booking flow error:', error);
-  }
-}
-
-async function getJourneySegments(scheduleId: string, originStationId: string, destinationStationId: string) {
-  const stopTimes = await prisma.tripStopTime.findMany({
-    where: { scheduleId },
-    include: { station: true },
-    orderBy: { sequence: 'asc' },
-  });
-
-  const originStop = stopTimes.find(st => st.stationId === originStationId);
-  const destinationStop = stopTimes.find(st => st.stationId === destinationStationId);
-
-  if (!originStop || !destinationStop || originStop.sequence >= destinationStop.sequence) {
-    throw new Error('Invalid origin/destination');
-  }
-
-  const segments = [];
-  for (let i = originStop.sequence; i < destinationStop.sequence; i++) {
-    const fromStop = stopTimes.find(st => st.sequence === i);
-    const toStop = stopTimes.find(st => st.sequence === i + 1);
-    if (fromStop && toStop) {
-      segments.push({
-        fromStationId: fromStop.stationId,
-        toStationId: toStop.stationId,
-        fromSequence: fromStop.sequence,
-        toSequence: toStop.sequence,
-        fromName: fromStop.station.name,
-        toName: toStop.station.name,
-      });
-    }
-  }
-  return segments;
-}
-
-async function holdSeatsTransaction(scheduleId: string, seatIds: string[], passengerId: string, originStationId: string, destinationStationId: string) {
-  return prisma.$transaction(async (tx) => {
-    console.log('  → Starting seat hold transaction...');
-
-    const seats = await tx.seat.findMany({ where: { id: { in: seatIds } }, include: { coach: true } });
-    if (seats.length !== seatIds.length) throw new Error('Some seats not found');
-
-    for (const seat of seats) {
-      if (seat.status !== 'AVAILABLE') {
-        throw new Error(`Seat ${seat.seatNumber} is not available (status: ${seat.status})`);
-      }
-    }
-
-    const expiresAt = new Date(Date.now() + 10 * 60 * 1000);
-    const seatHold = await tx.seatHold.create({
-      data: { scheduleId, seatIds, passengerId, expiresAt },
-    });
-
-    await tx.seat.updateMany({ where: { id: { in: seatIds } }, data: { status: 'HELD', heldUntil: expiresAt } });
-
-    console.log('  → Seats held successfully');
-    return { holdId: seatHold.id, expiresAt, seats: seatIds.length };
-  });
-}
-
-async function confirmBookingTransaction(holdId: string, bookingId: string, segments: any[]) {
-  return prisma.$transaction(async (tx) => {
-    console.log('  → Starting booking confirmation transaction...');
-
-    const hold = await tx.seatHold.findUnique({ where: { id: holdId } });
-    if (!hold || hold.expiresAt < new Date()) throw new Error('Hold expired or not found');
-
-    const booking = await tx.booking.create({
-      data: {
-        id: bookingId,
-        bookingRef: 'BK' + Date.now().toString().slice(-6),
-        passengerId: hold.passengerId,
-        scheduleId: hold.scheduleId,
-        status: 'CONFIRMED',
-        totalMinor: 45000,
-        currency: 'ETB',
-      },
-    });
-
-    const journey = await tx.journey.create({
-      data: { passengerId: hold.passengerId, status: 'CONFIRMED', totalMinor: 45000, currency: 'ETB' },
-    });
-
-    for (const seatId of hold.seatIds) {
-      for (let i = 0; i < segments.length; i++) {
-        await tx.journeySegment.create({
-          data: {
-            journeyId: journey.id,
-            scheduleId: hold.scheduleId,
-            segmentOrder: i + 1,
-            seatId,
-            departureStationId: segments[i].fromStationId,
-            arrivalStationId: segments[i].toStationId,
-          },
-        });
-      }
-    }
-
-    for (const seatId of hold.seatIds) {
-      await tx.bookingSeat.create({ data: { bookingId, seatId, passengerName: 'Kelemu Ketsela' } });
-    }
-
-    await tx.seat.updateMany({ where: { id: { in: hold.seatIds } }, data: { status: 'BOOKED', heldUntil: null } });
-    await tx.seatHold.delete({ where: { id: holdId } });
-
-    console.log('  → Booking confirmed successfully');
-    return { bookingId, bookingRef: booking.bookingRef, confirmedSeats: hold.seatIds.length, segments: segments.length };
-  });
-}
-
-async function simulateTripProgress(scheduleId: string, bookedSegments: any[]) {
-  console.log('  → Simulating trip progress...');
-
-  for (const segment of bookedSegments) {
-    console.log(`  → Train approaching ${segment.toName}...`);
-
-    await prisma.tripLiveStatus.upsert({
-      where: { scheduleId },
-      update: { currentLocationLabel: segment.toName, progressPercent: Math.round((segment.toSequence / 4) * 100) },
-      create: {
-        scheduleId,
-        state: 'EN_ROUTE',
-        currentLocationLabel: segment.toName,
-        progressPercent: Math.round((segment.toSequence / 4) * 100),
-        delayMinutes: 0,
-      },
-    });
-
-    if (segment.toName === 'Dire Dawa') {
-      console.log('  → Passengers reached destination, releasing seats...');
-      await releaseSeatsAtStation(scheduleId, segment.toStationId);
-    }
-
-    await new Promise(resolve => setTimeout(resolve, 2000));
-  }
-}
-
-async function releaseSeatsAtStation(scheduleId: string, stationId: string) {
-  return prisma.$transaction(async (tx) => {
-    const completedSegments = await tx.journeySegment.findMany({
-      where: { scheduleId, arrivalStationId: stationId },
-      include: { journey: { include: { journeySegments: { where: { scheduleId } } } } },
-    });
-
-    const seatsToRelease: string[] = [];
-
-    for (const segment of completedSegments) {
-      const passengerSegments = segment.journey.journeySegments.filter((js: any) => js.seatId === segment.seatId);
-      const maxOrder = Math.max(...passengerSegments.map((js: any) => js.segmentOrder));
-      if (segment.segmentOrder === maxOrder) seatsToRelease.push(segment.seatId!);
-    }
-
-    if (seatsToRelease.length > 0) {
-      await tx.seat.updateMany({ where: { id: { in: seatsToRelease } }, data: { status: 'AVAILABLE' } });
-      console.log(`  → Released ${seatsToRelease.length} seats at station`);
-    }
-
-    return seatsToRelease;
-  });
-}
-
-async function checkOverlappingReservations(tx: any, scheduleId: string, seatId: string, segments: any[]) {
-  const activeHolds = await tx.seatHold.findMany({
-    where: { scheduleId, seatIds: { has: seatId }, expiresAt: { gt: new Date() } },
-  });
-
-  const activeBookings = await tx.journeySegment.findMany({
-    where: {
-      scheduleId,
-      seatId,
-      journey: { status: { in: ['PENDING_PAYMENT', 'CONFIRMED'] } },
-    },
-  });
-
-  return [...activeHolds, ...activeBookings];
-}
-
-if (require.main === module) {
-  exampleBookingFlow()
-    .then(() => console.log('\n=== EXAMPLES COMPLETED ==='))
-    .catch(console.error)
-    .finally(() => prisma.$disconnect());
-}
-
-export {
-  exampleBookingFlow,
-  getJourneySegments,
-  holdSeatsTransaction,
-  confirmBookingTransaction,
-  simulateTripProgress,
-  releaseSeatsAtStation,
-  checkOverlappingReservations,
-};
diff --git a/apps/edr-passenger-api/src/modules/segments/segment-fare.controller.ts b/apps/edr-passenger-api/src/modules/segments/segment-fare.controller.ts
new file mode 100644
index 000000000..3cd7c5f06
--- /dev/null
+++ b/apps/edr-passenger-api/src/modules/segments/segment-fare.controller.ts
@@ -0,0 +1,49 @@
+import {
+  Controller, Get, Post, Put, Delete,
+  Param, Body, Query, UseGuards,
+} from '@nestjs/common';
+import { ApiTags, ApiBearerAuth, ApiOperation, ApiQuery } from '@nestjs/swagger';
+import { IamGuard } from '../../common/iam-adapter';
+import { Roles } from '../../common/roles.decorator';
+import { SegmentFareService } from './segment-fare.service';
+import { CreateSegmentFareDto, UpdateSegmentFareDto } from './segment-fare.dto';
+
+@ApiTags('Admin – Segment Fares')
+@Controller('admin/segment-fares')
+@ApiBearerAuth('IAM-auth')
+@UseGuards(IamGuard)
+@Roles('ADMIN', 'SUPERVISOR')
+export class SegmentFareController {
+  constructor(private readonly service: SegmentFareService) {}
+
+  @Get()
+  @ApiOperation({ summary: 'List all segment fare rules, optionally filtered by route' })
+  @ApiQuery({ name: 'routeId', required: false })
+  findAll(@Query('routeId') routeId?: string) {
+    return this.service.findAll(routeId);
+  }
+
+  @Get(':id')
+  @ApiOperation({ summary: 'Get a single segment fare rule' })
+  findOne(@Param('id') id: string) {
+    return this.service.findOne(id);
+  }
+
+  @Post()
+  @ApiOperation({ summary: 'Create a segment fare rule' })
+  create(@Body() dto: CreateSegmentFareDto) {
+    return this.service.create(dto);
+  }
+
+  @Put(':id')
+  @ApiOperation({ summary: 'Update a segment fare rule' })
+  update(@Param('id') id: string, @Body() dto: UpdateSegmentFareDto) {
+    return this.service.update(id, dto);
+  }
+
+  @Delete(':id')
+  @ApiOperation({ summary: 'Delete a segment fare rule' })
+  remove(@Param('id') id: string) {
+    return this.service.remove(id);
+  }
+}
diff --git a/apps/edr-passenger-api/src/modules/segments/segment-fare.dto.ts b/apps/edr-passenger-api/src/modules/segments/segment-fare.dto.ts
new file mode 100644
index 000000000..2f56f4fe1
--- /dev/null
+++ b/apps/edr-passenger-api/src/modules/segments/segment-fare.dto.ts
@@ -0,0 +1,67 @@
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+import {
+  IsString, IsInt, IsOptional, IsDateString, IsIn, Min,
+} from 'class-validator';
+
+export class CreateSegmentFareDto {
+  @ApiProperty({ example: 'route-uuid' })
+  @IsString()
+  routeId: string;
+
+  @ApiProperty({ example: 1 })
+  @IsInt() @Min(0)
+  originStopSequence: number;
+
+  @ApiProperty({ example: 5 })
+  @IsInt() @Min(1)
+  destinationStopSequence: number;
+
+  @ApiProperty({ example: 'seat-class-uuid' })
+  @IsString()
+  seatClassId: string;
+
+  @ApiProperty({ example: 35000, description: 'Base fare in minor units (e.g. 350.00 ETB = 35000)' })
+  @IsInt() @Min(0)
+  baseFareMinor: number;
+
+  @ApiPropertyOptional({ example: 'LOCAL', enum: ['LOCAL', 'INTERNATIONAL'] })
+  @IsOptional()
+  @IsIn(['LOCAL', 'INTERNATIONAL'])
+  nationality?: string;
+
+  @ApiPropertyOptional({ example: 'ETB', default: 'ETB' })
+  @IsOptional()
+  @IsString()
+  currency?: string;
+
+  @ApiProperty({ example: '2025-01-01T00:00:00.000Z' })
+  @IsDateString()
+  validFrom: string;
+
+  @ApiPropertyOptional({ example: '2026-12-31T23:59:59.000Z' })
+  @IsOptional()
+  @IsDateString()
+  validUntil?: string;
+}
+
+export class UpdateSegmentFareDto {
+  @ApiPropertyOptional({ example: 40000 })
+  @IsOptional()
+  @IsInt() @Min(0)
+  baseFareMinor?: number;
+
+  @ApiPropertyOptional({ example: 'ETB' })
+  @IsOptional()
+  @IsString()
+  currency?: string;
+
+  @ApiPropertyOptional({ example: '2025-06-01T00:00:00.000Z' })
+  @IsOptional()
+  @IsDateString()
+  validFrom?: string;
+
+  @ApiPropertyOptional({ example: '2026-12-31T23:59:59.000Z' })
+  @IsOptional()
+  @IsDateString()
+  validUntil?: string;
+}
diff --git a/apps/edr-passenger-api/src/modules/segments/segment-fare.service.ts b/apps/edr-passenger-api/src/modules/segments/segment-fare.service.ts
new file mode 100644
index 000000000..982ee7dd6
--- /dev/null
+++ b/apps/edr-passenger-api/src/modules/segments/segment-fare.service.ts
@@ -0,0 +1,62 @@
+import { Injectable, NotFoundException } from '@nestjs/common';
+import { PrismaService } from '../../common/prisma.service';
+import { CreateSegmentFareDto, UpdateSegmentFareDto } from './segment-fare.dto';
+
+@Injectable()
+export class SegmentFareService {
+  constructor(private readonly prisma: PrismaService) {}
+
+  findAll(routeId?: string) {
+    return this.prisma.segmentFareRule.findMany({
+      where: routeId ? { routeId } : undefined,
+      include: { seatClass: true, route: { select: { id: true, code: true, name: true } } },
+      orderBy: [{ routeId: 'asc' }, { originStopSequence: 'asc' }, { destinationStopSequence: 'asc' }],
+    });
+  }
+
+  async findOne(id: string) {
+    const rule = await this.prisma.segmentFareRule.findUnique({
+      where: { id },
+      include: { seatClass: true, route: { select: { id: true, code: true, name: true } } },
+    });
+    if (!rule) throw new NotFoundException(`SegmentFareRule ${id} not found`);
+    return rule;
+  }
+
+  create(dto: CreateSegmentFareDto) {
+    return this.prisma.segmentFareRule.create({
+      data: {
+        routeId:                 dto.routeId,
+        originStopSequence:      dto.originStopSequence,
+        destinationStopSequence: dto.destinationStopSequence,
+        seatClassId:             dto.seatClassId,
+        baseFareMinor:           dto.baseFareMinor,
+        nationality:             dto.nationality ?? null,
+        currency:                dto.currency ?? 'ETB',
+        validFrom:               new Date(dto.validFrom),
+        validUntil:              dto.validUntil ? new Date(dto.validUntil) : null,
+      },
+      include: { seatClass: true },
+    });
+  }
+
+  async update(id: string, dto: UpdateSegmentFareDto) {
+    await this.findOne(id);
+    return this.prisma.segmentFareRule.update({
+      where: { id },
+      data: {
+        ...(dto.baseFareMinor !== undefined && { baseFareMinor: dto.baseFareMinor }),
+        ...(dto.currency      !== undefined && { currency:      dto.currency }),
+        ...(dto.validFrom     !== undefined && { validFrom:     new Date(dto.validFrom) }),
+        ...(dto.validUntil    !== undefined && { validUntil:    new Date(dto.validUntil) }),
+      },
+      include: { seatClass: true },
+    });
+  }
+
+  async remove(id: string) {
+    await this.findOne(id);
+    await this.prisma.segmentFareRule.delete({ where: { id } });
+    return { deleted: true };
+  }
+}
diff --git a/apps/edr-passenger-api/src/modules/segments/segments.module.ts b/apps/edr-passenger-api/src/modules/segments/segments.module.ts
index f82da7fa9..053d1d33f 100644
--- a/apps/edr-passenger-api/src/modules/segments/segments.module.ts
+++ b/apps/edr-passenger-api/src/modules/segments/segments.module.ts
@@ -3,20 +3,24 @@ import { SegmentsService } from './segments.service';
 import { EnhancedSeatsService } from './enhanced-seats.service';
 import { TripProgressService } from './trip-progress.service';
 import { SegmentSeatsController } from './segments.controller';
+import { SegmentFareController } from './segment-fare.controller';
+import { SegmentFareService } from './segment-fare.service';
 import { PrismaService } from '../../common/prisma.service';
 
 @Module({
-  controllers: [SegmentSeatsController],
+  controllers: [SegmentSeatsController, SegmentFareController],
   providers: [
     SegmentsService,
     EnhancedSeatsService,
     TripProgressService,
-    PrismaService
+    SegmentFareService,
+    PrismaService,
   ],
   exports: [
     SegmentsService,
     EnhancedSeatsService,
-    TripProgressService
-  ]
+    TripProgressService,
+    SegmentFareService,
+  ],
 })
 export class SegmentsModule {}
\ No newline at end of file
diff --git a/apps/edr-passenger-api/src/modules/stations/stations.service.ts b/apps/edr-passenger-api/src/modules/stations/stations.service.ts
index 9e9fc824d..ec2480b21 100644
--- a/apps/edr-passenger-api/src/modules/stations/stations.service.ts
+++ b/apps/edr-passenger-api/src/modules/stations/stations.service.ts
@@ -3,6 +3,7 @@ import { REQUEST } from '@nestjs/core';
 import { PrismaService } from '../../common/prisma.service';
 import { AuditService } from '../../common/audit.service';
 import { CreateStationDto } from './stations.dto';
+import { DeleteOperationException } from '../../common/exceptions/delete-operation.exception';
 
 interface StationFilters {
   search?: string;
@@ -96,7 +97,35 @@ export class StationsService {
   }
 
   async remove(id: string) {
-    const station = await this.findOne(id);
+    const station = await this.prisma.station.findUnique({
+      where: { id },
+      include: {
+        _count: { select: { stopTimes: true } },
+        originSchedules: { take: 1, select: { id: true } },
+        destinationSchedules: { take: 1, select: { id: true } },
+      },
+    });
+    if (!station) throw new NotFoundException('Station not found');
+
+    const [routeStopCount, originCount, destCount, stopTimeCount] = await Promise.all([
+      this.prisma.routeStop.count({ where: { stationId: id } }),
+      this.prisma.trainSchedule.count({ where: { originStationId: id } }),
+      this.prisma.trainSchedule.count({ where: { destinationStationId: id } }),
+      (station as any)._count.stopTimes as number,
+    ]);
+
+    const constraints = [];
+    if (routeStopCount > 0)
+      constraints.push({ entityName: 'route', count: routeStopCount, action: 'delete' as const });
+    const scheduleCount = originCount + destCount;
+    if (scheduleCount > 0)
+      constraints.push({ entityName: 'schedule', count: scheduleCount, action: 'delete' as const });
+    if (stopTimeCount > 0)
+      constraints.push({ entityName: 'stop time', count: stopTimeCount, action: 'delete' as const });
+
+    if (constraints.length > 0)
+      throw new DeleteOperationException('Station', `${station.name} (${station.code})`, constraints);
+
     const deleted = await this.prisma.station.delete({ where: { id } });
 
     await this.auditService.log({
diff --git a/apps/edr-passenger-api/src/modules/wallet/wallet.controller.ts b/apps/edr-passenger-api/src/modules/wallet/wallet.controller.ts
index 1ecb2edea..8b0c5ed2e 100644
--- a/apps/edr-passenger-api/src/modules/wallet/wallet.controller.ts
+++ b/apps/edr-passenger-api/src/modules/wallet/wallet.controller.ts
@@ -1,4 +1,4 @@
-import { Body, Controller, Get, Param, Post, UseGuards } from '@nestjs/common';
+import { Body, Controller, Get, Param, Post, Delete, UseGuards, SetMetadata, Query } from '@nestjs/common';
 import { ApiTags, ApiOperation, ApiBearerAuth } from '@nestjs/swagger';
 import { Throttle } from '@nestjs/throttler';
 import { WalletService } from './wallet.service';
@@ -11,6 +11,8 @@ import { JwtGuard } from '../../common/jwt.guard';
 @Throttle({ strict: { limit: 20, ttl: 60_000 } })
 export class WalletController {
   constructor(private service: WalletService) {}
-  @Get(':passengerId')          @ApiOperation({ summary: 'Get wallet balance and ledger' }) getWallet(@Param('passengerId') id: string) { return this.service.getWallet(id); }
-  @Post(':passengerId/topup')   @ApiOperation({ summary: 'Top up wallet' })                 topUp(@Param('passengerId') id: string, @Body('amountMinor') amount: number) { return this.service.topUp(id, amount); }
+  @Get('accounts')              @SetMetadata('isPublic', true) @ApiOperation({ summary: 'List all wallet accounts' })      getAccounts(@Query() q: any) { return this.service.getAccounts(q); }
+  @Get(':passengerId')          @ApiOperation({ summary: 'Get wallet balance and ledger' })                                  getWallet(@Param('passengerId') id: string) { return this.service.getWallet(id); }
+  @Post(':passengerId/topup')   @ApiOperation({ summary: 'Top up wallet' })                                                  topUp(@Param('passengerId') id: string, @Body('amountMinor') amount: number) { return this.service.topUp(id, amount); }
+  @Delete('accounts/:id')       @SetMetadata('isPublic', true) @ApiOperation({ summary: 'Delete wallet account' })          deleteAccount(@Param('id') id: string) { return this.service.deleteAccount(id); }
 }
diff --git a/apps/edr-passenger-api/src/modules/wallet/wallet.service.ts b/apps/edr-passenger-api/src/modules/wallet/wallet.service.ts
index a83d97e0b..ac092ee41 100644
--- a/apps/edr-passenger-api/src/modules/wallet/wallet.service.ts
+++ b/apps/edr-passenger-api/src/modules/wallet/wallet.service.ts
@@ -5,6 +5,42 @@ import { PrismaService } from '../../common/prisma.service';
 export class WalletService {
   constructor(private prisma: PrismaService) {}
 
+  async getAccounts(params: { search?: string; page?: string; pageSize?: string } = {}) {
+    const { search, page = '1', pageSize = '20' } = params;
+    const skip = (parseInt(page) - 1) * parseInt(pageSize);
+    const where: any = {};
+    if (search) {
+      where.passenger = {
+        OR: [
+          { user: { fullName: { contains: search, mode: 'insensitive' } } },
+          { user: { email: { contains: search, mode: 'insensitive' } } },
+        ],
+      };
+    }
+    const [items, total] = await Promise.all([
+      this.prisma.walletAccount.findMany({
+        where,
+        skip,
+        take: parseInt(pageSize),
+        orderBy: { balanceMinor: 'desc' },
+        include: { passenger: { include: { user: true } } },
+      }),
+      this.prisma.walletAccount.count({ where }),
+    ]);
+    return {
+      items: items.map(w => ({
+        ...w,
+        passenger: w.passenger ? {
+          id: w.passenger.id,
+          fullName: (w.passenger as any).user?.fullName ?? null,
+          email: (w.passenger as any).user?.email ?? null,
+          phone: (w.passenger as any).user?.phone ?? null,
+        } : null,
+      })),
+      meta: { page: parseInt(page), pageSize: parseInt(pageSize), total, totalPages: Math.ceil(total / parseInt(pageSize)) },
+    };
+  }
+
   async getWallet(passengerId: string) {
     const wallet = await this.prisma.walletAccount.findUnique({ where: { passengerId }, include: { ledger: { orderBy: { createdAt: 'desc' }, take: 20 } } });
     if (!wallet) throw new NotFoundException('Wallet not found');
@@ -18,4 +54,14 @@ export class WalletService {
     await this.prisma.walletAccount.update({ where: { passengerId }, data: { balanceMinor: newBalance } });
     return this.prisma.walletLedgerEntry.create({ data: { walletId: wallet.id, type: 'CREDIT', amountMinor, balanceAfterMinor: newBalance, description } });
   }
+
+  async deleteAccount(id: string) {
+    const wallet = await this.prisma.walletAccount.findUnique({ where: { id } });
+    if (!wallet) throw new NotFoundException('Wallet account not found');
+    await this.prisma.$transaction([
+      this.prisma.walletLedgerEntry.deleteMany({ where: { walletId: id } }),
+      this.prisma.walletAccount.delete({ where: { id } }),
+    ]);
+    return { deleted: true, accountId: id };
+  }
 }
diff --git a/apps/edr-passenger-api/src/seed/segment-fare.seeder.ts b/apps/edr-passenger-api/src/seed/segment-fare.seeder.ts
new file mode 100644
index 000000000..4ae06b0a1
--- /dev/null
+++ b/apps/edr-passenger-api/src/seed/segment-fare.seeder.ts
@@ -0,0 +1,109 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { PrismaService } from '../common/prisma.service';
+
+const SEED_FLAG = 'SEED_SEGMENT_FARES';
+
+/**
+ * Seeds SegmentFareRule rows for every origin→destination pair on the
+ * Addis Ababa–Djibouti route across all active seat classes.
+ *
+ * Skip-if-loaded: uses Prisma upsert on the unique constraint
+ * (routeId, originStopSequence, destinationStopSequence, seatClassId, nationality).
+ * Re-running is safe — existing rows are updated in-place.
+ */
+@Injectable()
+export class SegmentFareSeeder {
+  private readonly logger = new Logger(SegmentFareSeeder.name);
+
+  constructor(private readonly prisma: PrismaService) {}
+
+  async run() {
+    if (process.env[SEED_FLAG]?.trim().toLowerCase() !== 'true') {
+      this.logger.log(`Skipping segment fare seed — set ${SEED_FLAG}=true to enable`);
+      return;
+    }
+
+    const route = await this.prisma.route.findFirst({
+      where: { active: true },
+      include: { stops: { orderBy: { sequence: 'asc' } } },
+    });
+
+    if (!route) {
+      this.logger.warn('No active route found — skipping segment fare seed');
+      return;
+    }
+
+    const seatClasses = await this.prisma.seatClass.findMany({
+      where: { isActive: true },
+    });
+
+    if (!seatClasses.length) {
+      this.logger.warn('No active seat classes found — skipping segment fare seed');
+      return;
+    }
+
+    const stops = route.stops;
+    const validFrom = new Date('2025-01-01T00:00:00.000Z');
+
+    // Rate table: ETB minor units per km, keyed by (nationalityType, bedPosition)
+    // null bedPosition = regular seat
+    const rateTable: Record<string, Record<string | 'null', number>> = {
+      LOCAL:         { null: 3000, UPPER: 4000, MIDDLE: 5500, LOWER: 6000 },
+      INTERNATIONAL: { null: 6000, UPPER: 8000, MIDDLE: 11000, LOWER: 12000 },
+    };
+
+    let upserted = 0;
+
+    for (const seatClass of seatClasses) {
+      const natType = seatClass.nationalityType ?? 'LOCAL';
+      const bedPos  = seatClass.bedPosition ?? 'null';
+      const ratePerKm = rateTable[natType]?.[bedPos] ?? rateTable['LOCAL']['null'];
+
+      for (let i = 0; i < stops.length - 1; i++) {
+        for (let j = i + 1; j < stops.length; j++) {
+          const origin = stops[i];
+          const dest   = stops[j];
+
+          // Approximate distance: sum of per-stop distanceKm if available,
+          // otherwise fall back to sequence-gap × 50 km.
+          let distanceKm = 0;
+          for (let k = i; k < j; k++) {
+            distanceKm += stops[k + 1].distanceKm ?? 50;
+          }
+
+          const baseFareMinor = Math.round(distanceKm * ratePerKm);
+
+          await this.prisma.segmentFareRule.upsert({
+            where: {
+              routeId_originStopSequence_destinationStopSequence_seatClassId_nationality: {
+                routeId:                 route.id,
+                originStopSequence:      origin.sequence,
+                destinationStopSequence: dest.sequence,
+                seatClassId:             seatClass.id,
+                nationality:             natType,
+              },
+            },
+            update: { baseFareMinor, validFrom },
+            create: {
+              routeId:                 route.id,
+              originStopSequence:      origin.sequence,
+              destinationStopSequence: dest.sequence,
+              seatClassId:             seatClass.id,
+              nationality:             natType,
+              baseFareMinor,
+              currency:                'ETB',
+              validFrom,
+            },
+          });
+
+          upserted++;
+        }
+      }
+    }
+
+    this.logger.log(
+      `Segment fare seed complete — ${upserted} rules upserted ` +
+      `(${stops.length} stops × ${seatClasses.length} seat classes)`,
+    );
+  }
+}
diff --git a/apps/edr-passenger-web/backoffice/src/app/app-releases/layout.tsx b/apps/edr-passenger-web/backoffice/src/app/app-releases/layout.tsx
new file mode 100644
index 000000000..86d53715f
--- /dev/null
+++ b/apps/edr-passenger-web/backoffice/src/app/app-releases/layout.tsx
@@ -0,0 +1,5 @@
+import DashboardLayout from '../dashboard/layout';
+
+export default function Layout({ children }: { children: React.ReactNode }) {
+  return <DashboardLayout>{children}</DashboardLayout>;
+}
diff --git a/apps/edr-passenger-web/backoffice/src/app/app-releases/page.tsx b/apps/edr-passenger-web/backoffice/src/app/app-releases/page.tsx
new file mode 100644
index 000000000..c5d5d7fa9
--- /dev/null
+++ b/apps/edr-passenger-web/backoffice/src/app/app-releases/page.tsx
@@ -0,0 +1,186 @@
+'use client';
+
+import { useState } from 'react';
+import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
+import { Plus, Pencil, Trash2 } from 'lucide-react';
+import DataTable from '@/components/ui/DataTable';
+import Badge from '@/components/ui/Badge';
+import ActionButton from '@/components/ui/ActionButton';
+import Modal from '@/components/ui/Modal';
+import ConfirmDialog from '@/components/ui/ConfirmDialog';
+import { appReleasesApi } from '@/lib/api';
+import { formatDateTime } from '@/lib/utils';
+
+const EMPTY_FORM = { os: 'android', version: '', forceUpdate: false, storeLink: '', notes: '' };
+
+export default function AppReleasesPage() {
+  const queryClient = useQueryClient();
+  const [formOpen, setFormOpen] = useState(false);
+  const [editing, setEditing] = useState<any>(null);
+  const [form, setForm] = useState({ ...EMPTY_FORM });
+  const [formError, setFormError] = useState('');
+  const [deleteTarget, setDeleteTarget] = useState<any>(null);
+  const [deleteError, setDeleteError] = useState<string | null>(null);
+  const [successMessage, setSuccessMessage] = useState('');
+
+  const { data, isLoading } = useQuery({
+    queryKey: ['app-releases'],
+    queryFn: () => appReleasesApi.getAll(),
+  });
+
+  const flash = (msg: string) => { setSuccessMessage(msg); setTimeout(() => setSuccessMessage(''), 3000); };
+
+  const saveMutation = useMutation({
+    mutationFn: (payload: any) =>
+      editing ? appReleasesApi.update(editing.id, payload) : appReleasesApi.create(payload),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ['app-releases'] });
+      setFormOpen(false);
+      setEditing(null);
+      setForm({ ...EMPTY_FORM });
+      setFormError('');
+      flash(editing ? 'Release updated.' : 'Release created.');
+    },
+    onError: (e: any) => setFormError(e?.response?.data?.message || e?.message || 'Failed to save.'),
+  });
+
+  const deleteMutation = useMutation({
+    mutationFn: (id: string) => appReleasesApi.remove(id),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ['app-releases'] });
+      setDeleteTarget(null);
+      setDeleteError(null);
+      flash('Release deleted.');
+    },
+    onError: (e: any) => setDeleteError(e?.response?.data?.message || e?.message || 'Failed to delete.'),
+  });
+
+  const openCreate = () => { setEditing(null); setForm({ ...EMPTY_FORM }); setFormError(''); setFormOpen(true); };
+  const openEdit = (r: any) => {
+    setEditing(r);
+    setForm({ os: r.os, version: r.version, forceUpdate: r.forceUpdate, storeLink: r.storeLink || '', notes: r.notes || '' });
+    setFormError('');
+    setFormOpen(true);
+  };
+
+  const handleSubmit = (e: React.FormEvent) => {
+    e.preventDefault();
+    if (!form.version.trim()) { setFormError('Version is required.'); return; }
+    saveMutation.mutate({ ...form, version: form.version.trim(), storeLink: form.storeLink || undefined, notes: form.notes || undefined });
+  };
+
+  const releases: any[] = Array.isArray(data) ? data : [];
+
+  const columns = [
+    {
+      key: 'os', label: 'OS',
+      render: (r: any) => (
+        <span className={`inline-flex items-center gap-1.5 px-2.5 py-1 rounded-full text-xs font-semibold ${r.os === 'ios' ? 'bg-blue-100 dark:bg-blue-900/40 text-blue-700 dark:text-blue-300' : 'bg-emerald-100 dark:bg-emerald-900/40 text-emerald-700 dark:text-emerald-300'}`}>
+          {r.os === 'ios' ? '🍎 iOS' : '🤖 Android'}
+        </span>
+      ),
+    },
+    { key: 'version', label: 'Version', render: (r: any) => <span className="font-mono font-semibold">{r.version}</span> },
+    {
+      key: 'forceUpdate', label: 'Force Update',
+      render: (r: any) => <Badge variant="status" status={r.forceUpdate ? 'ACTIVE' : 'INACTIVE'}>{r.forceUpdate ? 'Yes' : 'No'}</Badge>,
+    },
+    {
+      key: 'storeLink', label: 'Store Link',
+      render: (r: any) => r.storeLink
+        ? <a href={r.storeLink} target="_blank" rel="noreferrer" className="text-primary text-sm underline truncate max-w-[180px] block">{r.storeLink}</a>
+        : <span className="text-muted-foreground">—</span>,
+    },
+    { key: 'notes', label: 'Notes', render: (r: any) => <span className="text-sm text-muted-foreground truncate max-w-[200px] block">{r.notes || '—'}</span> },
+    { key: 'createdAt', label: 'Created', render: (r: any) => <span className="text-sm">{formatDateTime(r.createdAt)}</span> },
+  ];
+
+  const actions = [
+    { label: 'Edit', onClick: openEdit, variant: 'secondary' as const, icon: Pencil },
+    { label: 'Delete', onClick: (r: any) => { setDeleteError(null); setDeleteTarget(r); }, variant: 'danger' as const, icon: Trash2 },
+  ];
+
+  return (
+    <div className="space-y-6">
+      <div className="flex items-center justify-between">
+        <div>
+          <h1 className="text-2xl font-bold">App Releases</h1>
+          <p className="text-muted-foreground">Manage mobile app version release control</p>
+        </div>
+        <ActionButton icon={Plus} onClick={openCreate}>New Release</ActionButton>
+      </div>
+
+      {successMessage && (
+        <div className="rounded-lg bg-green-50 dark:bg-green-900/20 p-4 text-sm text-green-800 dark:text-green-200">✓ {successMessage}</div>
+      )}
+
+      <div className="card">
+        <DataTable data={releases} columns={columns} actions={actions} loading={isLoading} emptyMessage="No releases found" />
+      </div>
+
+      {/* Create / Edit Modal */}
+      <Modal isOpen={formOpen} onClose={() => setFormOpen(false)} title={editing ? 'Edit Release' : 'New Release'} size="md">
+        <form onSubmit={handleSubmit} className="space-y-4">
+          <div className="grid grid-cols-2 gap-4">
+            <div>
+              <label className="label">OS</label>
+              <select className="input" value={form.os} onChange={(e) => setForm({ ...form, os: e.target.value })}>
+                <option value="android">Android</option>
+                <option value="ios">iOS</option>
+              </select>
+            </div>
+            <div>
+              <label className="label">Version Number</label>
+              <input type="text" className="input" placeholder="e.g. 1.2.3" value={form.version}
+                onChange={(e) => setForm({ ...form, version: e.target.value })} />
+            </div>
+          </div>
+
+          <div>
+            <label className="label">Force Update</label>
+            <div className="flex items-center gap-3 mt-1">
+              {(['true', 'false'] as const).map((val) => (
+                <label key={val} className="flex items-center gap-2 cursor-pointer">
+                  <input type="radio" name="forceUpdate" checked={form.forceUpdate === (val === 'true')}
+                    onChange={() => setForm({ ...form, forceUpdate: val === 'true' })} className="w-4 h-4" />
+                  <span className="text-sm font-medium">{val === 'true' ? 'Yes — force update' : 'No — optional'}</span>
+                </label>
+              ))}
+            </div>
+          </div>
+
+          <div>
+            <label className="label">Store Link</label>
+            <input type="url" className="input" placeholder="https://play.google.com/..." value={form.storeLink}
+              onChange={(e) => setForm({ ...form, storeLink: e.target.value })} />
+          </div>
+
+          <div>
+            <label className="label">Notes</label>
+            <textarea className="input min-h-[80px] resize-y" placeholder="Release notes or changelog..." value={form.notes}
+              onChange={(e) => setForm({ ...form, notes: e.target.value })} />
+          </div>
+
+          {formError && <p className="text-sm text-red-600 dark:text-red-400">{formError}</p>}
+
+          <div className="flex justify-end gap-2 pt-2 border-t border-muted">
+            <ActionButton variant="secondary" onClick={() => setFormOpen(false)}>Cancel</ActionButton>
+            <ActionButton type="submit" loading={saveMutation.isPending}>
+              {editing ? 'Save Changes' : 'Create Release'}
+            </ActionButton>
+          </div>
+        </form>
+      </Modal>
+
+      <ConfirmDialog
+        isOpen={!!deleteTarget}
+        onClose={() => { setDeleteTarget(null); setDeleteError(null); }}
+        onConfirm={async () => { if (deleteTarget) await deleteMutation.mutateAsync(deleteTarget.id); }}
+        title="Delete Release"
+        message={`Delete ${deleteTarget?.os} v${deleteTarget?.version}? This cannot be undone.`}
+        confirmText="Delete" cancelText="Cancel" isLoading={deleteMutation.isPending} isDanger
+        error={deleteError ?? undefined}
+      />
+    </div>
+  );
+}
diff --git a/apps/edr-passenger-web/backoffice/src/app/audit/page.tsx b/apps/edr-passenger-web/backoffice/src/app/audit/page.tsx
index 4478fce74..fa4b58966 100644
--- a/apps/edr-passenger-web/backoffice/src/app/audit/page.tsx
+++ b/apps/edr-passenger-web/backoffice/src/app/audit/page.tsx
@@ -121,7 +121,7 @@ export default function AuditLogsPage() {
     },
   ];
 
-  const logs = data?.items || [];
+  const logs: any[] = Array.isArray(data?.items) ? data.items : [];
   const stats = {
     total: logs.length,
     creates: logs.filter((l: any) => l.action === 'CREATE').length,
@@ -140,7 +140,7 @@ export default function AuditLogsPage() {
           icon={Download}
           variant="secondary"
           onClick={() => {
-            const items = data?.items || [];
+            const items: any[] = Array.isArray(data?.items) ? data!.items : [];
             if (!items.length) return;
             const headers = ['Timestamp', 'Action', 'Entity Type', 'Entity ID', 'User ID', 'IP Address'];
             const rows = items.map((l: any) => [
diff --git a/apps/edr-passenger-web/backoffice/src/app/bookings/page.tsx b/apps/edr-passenger-web/backoffice/src/app/bookings/page.tsx
index d841d144d..974c25470 100644
--- a/apps/edr-passenger-web/backoffice/src/app/bookings/page.tsx
+++ b/apps/edr-passenger-web/backoffice/src/app/bookings/page.tsx
@@ -13,7 +13,7 @@ import { usePermission } from '@/lib/use-permission';
 import { PERMS } from '@/lib/permissions';
 import ConfirmDialog from '@/components/ui/ConfirmDialog';
 import { bookingsApi, apiClient } from '@/lib/api';
-import { formatCurrency, formatDateTime } from '@/lib/utils';
+import { formatCurrency, formatDateTime, formatDateTimeShort } from '@/lib/utils';
 import { BookingFilters } from '@/types';
 
 const Field = ({ label, value, mono = false, truncate = false }: { label: string; value: string; mono?: boolean; truncate?: boolean }) => (
@@ -142,11 +142,47 @@ function BookingsPageContent() {
       key: 'bookingRef', label: 'Reference', sortable: true,
       render: (booking: any) => (
         <div>
-          <div className="font-mono font-semibold">{booking.bookingRef}</div>
-          <div className="text-xs text-muted-foreground">{booking.bookingType || 'ONE_WAY'}</div>
+          <div className="font-mono font-semibold flex items-center gap-1.5">
+            {booking.bookingRef}
+            {booking.isPackageBooking && (
+              <span className="inline-flex items-center gap-1 bg-emerald-100 dark:bg-emerald-900/40 text-emerald-700 dark:text-emerald-400 text-xs font-semibold px-1.5 py-0.5 rounded" title="Package booking">
+                PKG
+              </span>
+            )}
+          </div>
+          {booking.isPackageBooking
+            ? <div className="text-xs text-muted-foreground">Boarding at: {booking.departureStationName || booking.schedule?.originStation?.name || '—'}</div>
+            : <div className="text-xs text-muted-foreground">{booking.bookingType || 'ONE_WAY'}</div>
+          }
         </div>
       ),
     },
+    {
+      key: 'trip',
+      label: 'Trip',
+      render: (booking: any) => {
+        const isRoundTrip = booking?.bookingType === 'ROUND_TRIP' || booking?.bookingType === 'ROUND_TRIP_TRANSIT';
+        const returnDeparture = booking?.returnSchedule?.departureAt;
+        console.log(JSON.stringify(booking.packageId));
+        return (
+          <div>
+            <div className="font-medium">
+              {booking.schedule?.originStation?.name || 'N/A'} → {booking.schedule?.destinationStation?.name || 'N/A'}
+            </div>
+            <div className="text-xs text-muted-foreground">
+              {!isRoundTrip ? (
+                <span>{booking.schedule?.departureAt ? formatDateTimeShort(booking.schedule.departureAt) : 'N/A'}</span>
+              ) : (
+                <span>
+                  {booking.schedule?.departureAt ? formatDateTimeShort(booking.schedule.departureAt) : 'N/A'} · 
+                  {returnDeparture ? formatDateTimeShort(returnDeparture) : ''}
+                </span>
+              )}
+            </div>
+          </div>
+        );
+      },
+    },
     {
       key: 'passengerNames', label: 'Names',
       render: (booking: any) => {
@@ -193,14 +229,6 @@ function BookingsPageContent() {
         </div>
       ),
     },
-    {
-      key: 'passengerCount', label: 'Passengers',
-      render: (booking: any) => {
-        const adults = booking.adultCount || 0, children = booking.childCount || 0;
-        if (!adults && !children) return '—';
-        return <><div>Adult: {adults}</div><div className="text-sm text-muted-foreground">Child: {children}</div></>;
-      },
-    },
     {
       key: 'paymentStatus', label: 'Payment',
       render: (booking: any) => (
@@ -254,6 +282,14 @@ function BookingsPageContent() {
               <option value="CANCELLED">Cancelled</option>
               <option value="BOARDED">Boarded</option>
             </select>
+            <select className="input w-44" value={extraFilters.bookingType}
+              onChange={(e) => setExtraFilters({ ...extraFilters, bookingType: e.target.value })}>
+              <option value="">All Types</option>
+              <option value="ONE_WAY">One Way</option>
+              <option value="ROUND_TRIP">Round Trip</option>
+              <option value="ROUND_TRIP_TRANSIT">Round Trip Transit</option>
+              <option value="PACKAGE">Package</option>
+            </select>
             <button type="button" className="input w-auto px-4 text-sm font-medium text-primary border-primary/40"
               onClick={() => setShowExtraFilters(v => !v)}>
               {showExtraFilters ? 'Hide Filters ▲' : 'More Filters ▼'}
@@ -261,16 +297,6 @@ function BookingsPageContent() {
           </div>
           {showExtraFilters && (
             <div className="grid grid-cols-1 sm:grid-cols-2 md:grid-cols-4 gap-3 pt-1">
-              <div>
-                <label className="label">Booking Type</label>
-                <select className="input" value={extraFilters.bookingType}
-                  onChange={(e) => setExtraFilters({ ...extraFilters, bookingType: e.target.value })}>
-                  <option value="">All Types</option>
-                  <option value="ONE_WAY">One Way</option>
-                  <option value="ROUND_TRIP">Round Trip</option>
-                  <option value="ROUND_TRIP_TRANSIT">Round Trip Transit</option>
-                </select>
-              </div>
               <div>
                 <label className="label">Payment Status</label>
                 <select className="input" value={extraFilters.paymentStatus}
@@ -324,9 +350,10 @@ function BookingsPageContent() {
                 <div className="mt-4 flex flex-wrap gap-2">
                   {[
                     (b.bookingType || 'ONE_WAY').replace(/_/g, ' '),
+                    b.isPackageBooking && b.packageName ? `PKG: ${b.packageName}` : null,
                     `${b.adultCount ?? 0} Adult${(b.adultCount ?? 0) !== 1 ? 's' : ''}${(b.childCount ?? 0) > 0 ? ` · ${b.childCount} Child${b.childCount !== 1 ? 'ren' : ''}` : ''}`,
                     b.displayCurrency || b.currency || 'ETB',
-                  ].map((tag) => (
+                  ].filter(Boolean).map((tag) => (
                     <span key={tag} className="inline-flex items-center gap-1.5 bg-white/20 text-white text-xs font-medium px-3 py-1 rounded-full">
                       <span className="w-1.5 h-1.5 rounded-full bg-emerald-200" />{tag}
                     </span>
@@ -346,18 +373,31 @@ function BookingsPageContent() {
                   </div>
                 </section>
 
+                {/* Package info */}
+                {b.isPackageBooking && (
+                  <section>
+                    <SectionHeader title="Package" />
+                    <div className="grid grid-cols-2 md:grid-cols-4 gap-3">
+                      <Field label="Package Name" value={b.packageName || '—'} />
+                      <Field label="Package Code" value={b.packageCode || '—'} mono />
+                      <Field label="Tier" value={b.tierLabel || '—'} />
+                      <Field label="Package ID" value={b.packageId || '—'} mono truncate />
+                    </div>
+                  </section>
+                )}
+
                 {/* Journey */}
                 <section>
                   <SectionHeader title="Journey" />
                   <div className="grid grid-cols-2 md:grid-cols-4 gap-3">
-                    <Field label="Origin" value={b.schedule?.originStation?.name} />
-                    <Field label="Destination" value={b.schedule?.destinationStation?.name} />
+                    <Field label="Origin" value={b.schedule?.originStation?.name || b.schedule?.origin?.name} />
+                    <Field label="Destination" value={b.schedule?.destinationStation?.name || b.schedule?.destination?.name} />
                     <Field label="Departure" value={b.schedule?.departureAt ? formatDateTime(b.schedule.departureAt) : ''} />
                     <Field label="Arrival" value={b.schedule?.arrivalAt ? formatDateTime(b.schedule.arrivalAt) : ''} />
                     <Field label="Adults" value={String(b.adultCount ?? 0)} />
                     <Field label="Children" value={String(b.childCount ?? 0)} />
                     <Field label="Promo Code" value={b.promoCode || 'None'} />
-                    <Field label="Schedule ID" value={b.scheduleId} mono truncate />
+                    {!b.isPackageBooking && <Field label="Schedule ID" value={b.scheduleId} mono truncate />}
                   </div>
                 </section>
 
@@ -398,32 +438,39 @@ function BookingsPageContent() {
                   </div>
                 </section>
 
-                {/* Seats */}
-                {b.seats && b.seats.length > 0 && (
-                  <section>
-                    <SectionHeader title={`Seats (${b.seats.length})`} />
-                    <div className="divide-y divide-muted rounded-lg border border-muted overflow-hidden">
-                      {b.seats.map((bs: any, i: number) => (
-                        <div key={i} className="flex items-center justify-between px-4 py-3 bg-muted/20 hover:bg-muted/40 transition-colors">
-                          <div className="flex items-center gap-3">
-                            <span className="w-6 h-6 rounded-full bg-emerald-100 dark:bg-emerald-900/40 text-emerald-700 dark:text-emerald-400 text-xs font-bold flex items-center justify-center shrink-0">{i + 1}</span>
-                            <div>
-                              <p className="text-sm font-semibold">{bs.passengerName || '—'}</p>
-                              <p className="text-xs text-muted-foreground">
-                                {bs.passengerCategory || '—'}{bs.leg ? ` · Leg ${bs.leg}` : ''}{bs.idDocumentType ? ` · ${bs.idDocumentType}` : ''}
-                                {bs.verifaydaVerified ? ' · ✓ Verified' : ''}
-                              </p>
+                {/* Seats / Passengers */}
+                {(() => {
+                  const items: any[] = b.seats?.length ? b.seats : (b.passengers?.length ? b.passengers : []);
+                  if (!items.length) return null;
+                  const isSeats = !!b.seats?.length;
+                  return (
+                    <section>
+                      <SectionHeader title={`${isSeats ? 'Seats' : 'Passengers'} (${items.length})`} />
+                      <div className="divide-y divide-muted rounded-lg border border-muted overflow-hidden">
+                        {items.map((p: any, i: number) => (
+                          <div key={i} className="flex items-center justify-between px-4 py-3 bg-muted/20 hover:bg-muted/40 transition-colors">
+                            <div className="flex items-center gap-3">
+                              <span className="w-6 h-6 rounded-full bg-emerald-100 dark:bg-emerald-900/40 text-emerald-700 dark:text-emerald-400 text-xs font-bold flex items-center justify-center shrink-0">{i + 1}</span>
+                              <div>
+                                <p className="text-sm font-semibold">{p.passengerName || p.fullName || p.name || '—'}</p>
+                                <p className="text-xs text-muted-foreground">
+                                  {p.passengerCategory || p.category || '—'}{p.leg ? ` · Leg ${p.leg}` : ''}{p.idDocumentType ? ` · ${p.idDocumentType}` : ''}
+                                  {p.verifaydaVerified ? ' · ✓ Verified' : ''}
+                                </p>
+                              </div>
                             </div>
+                            {isSeats && (
+                              <div className="text-right">
+                                <p className="text-sm font-mono font-semibold">{p.seat?.seatNumber || p.seatId || '—'}</p>
+                                <p className="text-xs text-muted-foreground">{formatCurrency(p.fareMinor ?? 0, b.currency || 'ETB')}</p>
+                              </div>
+                            )}
                           </div>
-                          <div className="text-right">
-                            <p className="text-sm font-mono font-semibold">{bs.seat?.seatNumber || bs.seatId || '—'}</p>
-                            <p className="text-xs text-muted-foreground">{formatCurrency(bs.fareMinor ?? 0, b.currency || 'ETB')}</p>
-                          </div>
-                        </div>
-                      ))}
-                    </div>
-                  </section>
-                )}
+                        ))}
+                      </div>
+                    </section>
+                  );
+                })()}
 
                 {/* Timestamps */}
                 <section>
diff --git a/apps/edr-passenger-web/backoffice/src/app/classes/page.tsx b/apps/edr-passenger-web/backoffice/src/app/classes/page.tsx
index a3c09cb63..65671959b 100644
--- a/apps/edr-passenger-web/backoffice/src/app/classes/page.tsx
+++ b/apps/edr-passenger-web/backoffice/src/app/classes/page.tsx
@@ -15,7 +15,7 @@ export default function ClassesPage() {
   const [filters, setFilters] = useState({ search: '' });
   const [showModal, setShowModal] = useState(false);
   const [editingClass, setEditingClass] = useState<any>(null);
-  const [deleteConfirm, setDeleteConfirm] = useState<{ isOpen: boolean; class: any | null }>({ isOpen: false, class: null });
+  const [deleteConfirm, setDeleteConfirm] = useState<{ isOpen: boolean; class: any | null; error?: string }>({ isOpen: false, class: null });
   const [selectedCoachTypeId, setSelectedCoachTypeId] = useState<string>('');
   const queryClient = useQueryClient();
 
@@ -60,6 +60,10 @@ export default function ClassesPage() {
     onSuccess: () => {
       queryClient.invalidateQueries({ queryKey: ['classes'] });
     },
+    onError: (e: any) => {
+      const msg = e?.response?.data?.message || e?.message || 'Failed to delete class';
+      setDeleteConfirm(prev => ({ ...prev, error: Array.isArray(msg) ? msg.join(' ') : msg }));
+    },
   });
 
   const handleSubmit = async (e: React.FormEvent<HTMLFormElement>) => {
@@ -89,13 +93,16 @@ export default function ClassesPage() {
   };
 
   const handleDelete = (cls: any) => {
-    setDeleteConfirm({ isOpen: true, class: cls });
+    setDeleteConfirm({ isOpen: true, class: cls, error: undefined });
   };
 
   const confirmDelete = async () => {
-    if (deleteConfirm.class) {
+    if (!deleteConfirm.class) return;
+    try {
       await deleteMutation.mutateAsync(deleteConfirm.class.id);
       setDeleteConfirm({ isOpen: false, class: null });
+    } catch {
+      // error is set by onError handler
     }
   };
 
@@ -230,6 +237,8 @@ export default function ClassesPage() {
         message={`Are you sure you want to delete ${deleteConfirm.class?.name}?`}
         confirmText="Delete"
         isDanger={true}
+        isLoading={deleteMutation.isPending}
+        error={deleteConfirm.error}
         warning="This class may be used by coaches and fare rules. Deleting it may impact seat assignments and pricing."
       />
 
@@ -280,7 +289,7 @@ export default function ClassesPage() {
               <h3 className="font-semibold text-foreground mb-4">Pricing Configuration</h3>
               
               <div>
-                <label className="label">Base Fare (ETB) *</label>
+                <label className="label">Base Fare *</label>
                 <input
                   type="number"
                   name="baseFareMinor"
diff --git a/apps/edr-passenger-web/backoffice/src/app/coaches/page.tsx b/apps/edr-passenger-web/backoffice/src/app/coaches/page.tsx
index 97ba2a708..91eec0082 100644
--- a/apps/edr-passenger-web/backoffice/src/app/coaches/page.tsx
+++ b/apps/edr-passenger-web/backoffice/src/app/coaches/page.tsx
@@ -2,7 +2,7 @@
 
 import { useState } from 'react';
 import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
-import { Plus, Search, Grid3x3, Edit, Trash2, Bed, Armchair } from 'lucide-react';
+import { Plus, Search, Grid3x3, Edit, Trash2, Bed, Armchair, Download } from 'lucide-react';
 import DataTable from '@/components/ui/DataTable';
 import ActionButton from '@/components/ui/ActionButton';
 import Modal from '@/components/ui/Modal';
@@ -147,6 +147,8 @@ export default function CoachesPage() {
   const [editingItem, setEditingItem] = useState<any>(null);
   const [deleteConfirm, setDeleteConfirm] = useState<{ isOpen: boolean; item: any | null; error?: string }>({ isOpen: false, item: null });
   const [selectedCoachTypeId, setSelectedCoachTypeId] = useState<string>('');
+  const [exportUtilModalOpen, setExportUtilModalOpen] = useState(false);
+  const [exportUtilFormat, setExportUtilFormat] = useState<'csv' | 'excel' | 'pdf'>('csv');
 
   const queryClient = useQueryClient();
 
@@ -245,7 +247,6 @@ export default function CoachesPage() {
       coachTypeId: formData.get('coachTypeId') as string,
       arrangement: formData.get('arrangement') as string,
       capacity: parseInt(formData.get('capacity') as string),
-      sequence: parseInt(formData.get('sequence') as string),
       status: formData.get('status') as string,
     };
 
@@ -361,14 +362,6 @@ export default function CoachesPage() {
 
   // Coaches Columns
   const coachColumns = [
-    {
-      key: 'sequence',
-      label: 'Sequence',
-      sortable: true,
-      render: (coach: any) => (
-        <span className="font-mono font-semibold text-sm">{coach.sequence}</span>
-      ),
-    },
     {
       key: 'number',
       label: 'Number',
@@ -584,11 +577,53 @@ export default function CoachesPage() {
         {/* Utilization Tab */}
         {activeTab === 'utilization' && (() => {
           const rows = Array.isArray(utilizationData) ? utilizationData : (utilizationData as any)?.data || [];
+
+          const UTIL_COLS = [
+            { key: 'number', label: 'Coach' },
+            { key: 'coachType', label: 'Type' },
+            { key: 'totalSeats', label: 'Total Seats' },
+            { key: 'availableSeats', label: 'Available' },
+            { key: 'bookedSeats', label: 'Booked' },
+            { key: 'blockedSeats', label: 'Blocked' },
+            { key: 'maintenanceSeats', label: 'Maintenance' },
+            { key: 'utilizationRate', label: 'Utilization %' },
+            { key: 'totalAssignments', label: 'Assignments' },
+            { key: 'totalBookings', label: 'Total Bookings' },
+          ];
+
+          const doExport = () => {
+            if (!rows.length) { alert('No data to export'); return; }
+            const headers = UTIL_COLS.map(c => c.label);
+            const exportRows = rows.map((r: any) => UTIL_COLS.map(({ key }) => String(r[key] ?? '')));
+            const dateStr = new Date().toISOString().split('T')[0];
+            if (exportUtilFormat === 'pdf') {
+              const w = window.open('', '_blank')!;
+              w.document.write(`<!DOCTYPE html><html><head><title>Coach Utilization Report</title><style>body{font-family:sans-serif;font-size:11px}table{border-collapse:collapse;width:100%}th,td{border:1px solid #ccc;padding:4px 8px}th{background:#10b981;color:#fff}</style></head><body>`);
+              w.document.write(`<h2>Coach Utilization Report — ${dateStr}</h2><table><thead><tr>${headers.map(h => `<th>${h}</th>`).join('')}</tr></thead><tbody>`);
+              exportRows.forEach((r: string[]) => { w.document.write(`<tr>${r.map((v: string) => `<td>${v}</td>`).join('')}</tr>`); });
+              w.document.write('</tbody></table></body></html>');
+              w.document.close(); w.print();
+            } else if (exportUtilFormat === 'excel') {
+              const tsv = [headers.join('\t'), ...exportRows.map((r: string[]) => r.join('\t'))].join('\n');
+              const blob = new Blob([tsv], { type: 'application/vnd.ms-excel' });
+              const url = URL.createObjectURL(blob);
+              const a = document.createElement('a'); a.href = url; a.download = `coach-utilization-${dateStr}.xls`; a.click(); URL.revokeObjectURL(url);
+            } else {
+              const csv = [headers.map(h => `"${h}"`).join(','), ...exportRows.map((r: string[]) => r.map((v: string) => `"${v.replace(/"/g, '""')}"`).join(','))].join('\n');
+              const blob = new Blob([csv], { type: 'text/csv' });
+              const url = URL.createObjectURL(blob);
+              const a = document.createElement('a'); a.href = url; a.download = `coach-utilization-${dateStr}.csv`; a.click(); URL.revokeObjectURL(url);
+            }
+            setExportUtilModalOpen(false);
+          };
+
           return (
             <div className="pt-6 space-y-4">
+              <div className="flex justify-end">
+                <ActionButton icon={Download} variant="secondary" onClick={() => setExportUtilModalOpen(true)}>Export</ActionButton>
+              </div>
               <DataTable
                 columns={[
-                  { key: 'sequence', label: 'Seq', render: (r: any) => <span className="font-mono">{r.sequence}</span> },
                   { key: 'number', label: 'Coach', render: (r: any) => <span className="font-medium">{r.number}</span> },
                   { key: 'coachType', label: 'Type', render: (r: any) => <span className="text-sm">{r.coachType || 'N/A'}</span> },
                   { key: 'totalSeats', label: 'Total Seats', render: (r: any) => <span className="font-mono">{r.totalSeats}</span> },
@@ -615,6 +650,26 @@ export default function CoachesPage() {
                 loading={utilizationLoading}
                 emptyMessage="No coach utilization data available"
               />
+
+              <Modal isOpen={exportUtilModalOpen} onClose={() => setExportUtilModalOpen(false)} title="Export Utilization Report" size="sm">
+                <div className="space-y-4">
+                  <div>
+                    <p className="text-sm font-medium mb-2">Export Format</p>
+                    <div className="flex gap-3">
+                      {(['csv', 'excel', 'pdf'] as const).map(fmt => (
+                        <label key={fmt} className="flex items-center gap-2 cursor-pointer">
+                          <input type="radio" name="utilExportFormat" value={fmt} checked={exportUtilFormat === fmt} onChange={() => setExportUtilFormat(fmt)} className="w-4 h-4" />
+                          <span className="text-sm font-medium capitalize">{fmt === 'excel' ? 'Excel (.xls)' : fmt === 'pdf' ? 'PDF (Print)' : 'CSV'}</span>
+                        </label>
+                      ))}
+                    </div>
+                  </div>
+                  <div className="flex justify-end gap-2 pt-4 border-t">
+                    <ActionButton variant="secondary" onClick={() => setExportUtilModalOpen(false)}>Cancel</ActionButton>
+                    <ActionButton onClick={doExport}>Export</ActionButton>
+                  </div>
+                </div>
+              </Modal>
             </div>
           );
         })()}
@@ -826,22 +881,6 @@ export default function CoachesPage() {
                 />
               </div>
 
-              <div>
-                <label className="label">Sequence Number *</label>
-                <input
-                  type="number"
-                  name="sequence"
-                  className="input"
-                  defaultValue={editingItem?.sequence }
-                  min="1"
-                  required
-                  placeholder="e.g., 1"
-                />
-                <p className="text-xs text-muted-foreground mt-1">
-                  Position in train consist
-                </p>
-              </div>
-
               <div>
                 <label className="label">Status *</label>
                 <select
diff --git a/apps/edr-passenger-web/backoffice/src/app/docs/page.tsx b/apps/edr-passenger-web/backoffice/src/app/docs/page.tsx
index 650dde2cf..4ce923279 100644
--- a/apps/edr-passenger-web/backoffice/src/app/docs/page.tsx
+++ b/apps/edr-passenger-web/backoffice/src/app/docs/page.tsx
@@ -3,193 +3,48 @@
 import React, { useState } from 'react';
 import Link from 'next/link';
 import { ChevronDown, ChevronRight, FileText, Home } from 'lucide-react';
+import { navSections } from './sections/_shared';
+import OverviewSection from './sections/OverviewSection';
+import OperationsSection from './sections/OperationsSection';
+import TourismSection from './sections/TourismSection';
+import MasterDataSection from './sections/MasterDataSection';
+import FinancialSection from './sections/FinancialSection';
+import CustomerServicesSection from './sections/CustomerServicesSection';
+import SecuritySection from './sections/SecuritySection';
+import AnalyticsSection from './sections/AnalyticsSection';
+import SystemSection from './sections/SystemSection';
 
-const DocPage = () => {
-  const [expandedSections, setExpandedSections] = useState<{ [key: string]: boolean }>({
-    overview: true,
-    operations: true,
-    masterdata: false,
-    financial: false,
-    services: false,
-    security: false,
-    analytics: false,
-    system: false,
-    enhanced: false,
+export default function DocPage() {
+  const [expanded, setExpanded] = useState<Record<string, boolean>>({
+    overview: true, operations: true, tourism: false, masterdata: false,
+    financial: false, services: false, security: false, analytics: false, system: false,
   });
 
-  const toggleSection = (section: string) => {
-    setExpandedSections(prev => (({
-      ...prev,
-      [section]: !prev[section]
-    })));
-  };
+  const toggle = (id: string) => setExpanded(prev => ({ ...prev, [id]: !prev[id] }));
 
-  const scrollToSection = (id: string) => {
+  const scrollTo = (id: string) => {
     setTimeout(() => {
-      const element = document.getElementById(id);
-      if (element) {
-        const headerOffset = 120;
-        const elementPosition = element.getBoundingClientRect().top + window.pageYOffset;
-        const offsetPosition = elementPosition - headerOffset;
-        window.scrollTo({
-          top: offsetPosition,
-          behavior: 'smooth'
-        });
-      }
+      const el = document.getElementById(id);
+      if (el) window.scrollTo({ top: el.getBoundingClientRect().top + window.pageYOffset - 120, behavior: 'smooth' });
     }, 0);
   };
 
-  const sections = [
-    {
-      id: 'overview',
-      title: '📋 Overview & Getting Started',
-      items: [
-        { id: 'about', label: 'Application Overview' },
-        { id: 'features', label: 'Key Features' },
-      ]
-    },
-    {
-      id: 'operations',
-      title: '📊 Operations',
-      items: [
-        { id: 'bookings', label: 'Bookings' },
-        { id: 'bookings-how', label: '→ How-To' },
-        { id: 'passengers', label: 'Passengers' },
-        { id: 'passengers-how', label: '→ How-To' },
-        { id: 'tickets', label: 'Tickets' },
-        { id: 'tickets-how', label: '→ How-To' },
-      ]
-    },
-    {
-      id: 'masterdata',
-      title: '🏢 Master Data',
-      items: [
-        { id: 'stations', label: 'Stations' },
-        { id: 'stations-how', label: '→ How-To' },
-        { id: 'trains', label: 'Trains' },
-        { id: 'trains-how', label: '→ How-To' },
-        { id: 'coaches', label: 'Coaches' },
-        { id: 'coaches-how', label: '→ How-To' },
-        { id: 'seats', label: 'Seats' },
-        { id: 'seats-how', label: '→ How-To' },
-        { id: 'classes', label: 'Seat Classes' },
-        { id: 'classes-how', label: '→ How-To' },
-        { id: 'routes', label: 'Routes' },
-        { id: 'routes-how', label: '→ How-To' },
-        { id: 'schedules', label: 'Schedules' },
-        { id: 'schedules-how', label: '→ How-To' },
-      ]
-    },
-    {
-      id: 'financial',
-      title: '💰 Financial',
-      items: [
-        { id: 'pricing', label: 'Pricing & Fares' },
-        { id: 'pricing-how', label: '→ How-To' },
-        { id: 'currencies', label: 'Currencies' },
-        { id: 'currencies-how', label: '→ How-To' },
-        { id: 'payments', label: 'Payments' },
-        { id: 'payments-how', label: '→ How-To' },
-        { id: 'promos', label: 'Promo Codes' },
-        { id: 'promos-how', label: '→ How-To' },
-      ]
-    },
-    {
-      id: 'services',
-      title: '🎁 Customer Services',
-      items: [
-        { id: 'loyalty', label: 'Loyalty' },
-        { id: 'loyalty-how', label: '→ How-To' },
-        { id: 'support', label: 'Support' },
-        { id: 'support-how', label: '→ How-To' },
-        { id: 'notifications', label: 'Notifications' },
-        { id: 'notifications-how', label: '→ How-To' },
-      ]
-    },
-    {
-      id: 'security',
-      title: '🔒 Security',
-      items: [
-        { id: 'audit', label: 'Audit Logs' },
-        { id: 'audit-how', label: '→ How-To' },
-        { id: 'fraud', label: 'Fraud Detection' },
-        { id: 'fraud-how', label: '→ How-To' },
-        { id: 'verifayda', label: 'Verifayda' },
-        { id: 'verifayda-how', label: '→ How-To' },
-      ]
-    },
-    {
-      id: 'analytics',
-      title: '📈 Analytics',
-      items: [
-        { id: 'reports', label: 'Reports' },
-        { id: 'reports-how', label: '→ How-To' },
-      ]
-    },
-    {
-      id: 'system',
-      title: '⚙️ System',
-      items: [
-        { id: 'agents', label: 'Agents' },
-        { id: 'agents-how', label: '→ How-To' },
-        { id: 'users', label: 'Users' },
-        { id: 'users-how', label: '→ How-To' },
-        { id: 'system-config', label: 'System Config' },
-        { id: 'system-config-how', label: '→ How-To' },
-        { id: 'settings', label: 'Settings' },
-        { id: 'settings-how', label: '→ How-To' },
-      ]
-    },
-    {
-      id: 'enhanced',
-      title: '✨ Enhanced Features',
-      items: [
-        { id: 'excess-baggage', label: 'Excess Baggage' },
-        { id: 'excess-baggage-how', label: '→ How-To' },
-        { id: 'packages', label: 'Travel Packages' },
-        { id: 'packages-how', label: '→ How-To' },
-        { id: 'package-inquiries', label: 'Package Inquiries' },
-        { id: 'package-inquiries-how', label: '→ How-To' },
-        { id: 'health', label: 'Health Monitoring' },
-        { id: 'health-how', label: '→ How-To' },
-        { id: 'boarding', label: 'Boarding Management' },
-        { id: 'boarding-how', label: '→ How-To' },
-        { id: 'fare-config', label: 'Advanced Fare Config' },
-        { id: 'fare-config-how', label: '→ How-To' },
-        { id: 'payment-methods', label: 'Payment Methods' },
-        { id: 'payment-methods-how', label: '→ How-To' },
-      ]
-    },
-  ];
-
-  const HowToStep = ({ number, title, children }: { number: number; title: string; children: React.ReactNode }) => (
-    <div className="bg-blue-50 dark:bg-blue-900/20 p-6 rounded-lg border border-blue-200 dark:border-blue-800">
-      <div className="flex items-start gap-4">
-        <div className="flex items-center justify-center w-10 h-10 rounded-full bg-blue-600 text-white font-bold flex-shrink-0">{number}</div>
-        <div className="flex-1">
-          <h4 className="text-lg font-semibold text-slate-900 dark:text-white mb-2">{title}</h4>
-          {children}
-        </div>
-      </div>
-    </div>
-  );
-
   return (
     <div className="min-h-screen bg-slate-50 dark:bg-slate-900">
+      {/* Top bar */}
       <div className="bg-white dark:bg-slate-800 border-b border-slate-200 dark:border-slate-700 sticky top-0 z-10">
         <div className="max-w-7xl mx-auto px-4 py-4 flex items-center justify-between">
           <div className="flex items-center gap-3">
-            <FileText className="h-8 w-8 text-emerald-600" />
-            <h1 className="text-2xl font-bold text-slate-900 dark:text-white">Documentation</h1>
+            <FileText className="h-7 w-7 text-emerald-600" />
+            <h1 className="text-xl font-bold text-slate-900 dark:text-white">Documentation</h1>
           </div>
           <div className="flex items-center gap-2">
-            <a href="http://localhost:4000/api-docs" target="_blank" rel="noopener noreferrer" className="flex items-center gap-2 px-4 py-2 rounded-lg bg-blue-600 text-white hover:bg-blue-700 transition" title="Opens API documentation in new tab">
-              <FileText className="h-4 w-4" />
-              View API Docs
+            <a href="http://localhost:4000/api-docs" target="_blank" rel="noopener noreferrer"
+              className="flex items-center gap-2 px-3 py-2 rounded-lg bg-blue-600 text-white text-sm hover:bg-blue-700 transition">
+              <FileText className="h-4 w-4" /> API Docs
             </a>
-            <Link href="/dashboard" target="_blank" className="flex items-center gap-2 px-4 py-2 rounded-lg bg-emerald-600 text-white hover:bg-emerald-700 transition">
-              <Home className="h-4 w-4" />
-              Dashboard
+            <Link href="/dashboard" className="flex items-center gap-2 px-3 py-2 rounded-lg bg-emerald-600 text-white text-sm hover:bg-emerald-700 transition">
+              <Home className="h-4 w-4" /> Dashboard
             </Link>
           </div>
         </div>
@@ -197,19 +52,25 @@ const DocPage = () => {
 
       <div className="max-w-7xl mx-auto px-4 py-8">
         <div className="grid grid-cols-1 lg:grid-cols-4 gap-6">
+
+          {/* Sidebar nav */}
           <div className="lg:col-span-1">
-            <div className="bg-white dark:bg-slate-800 rounded-lg border border-slate-200 dark:border-slate-700 sticky top-24 h-fit">
+            <div className="bg-white dark:bg-slate-800 rounded-lg border border-slate-200 dark:border-slate-700 sticky top-24 max-h-[calc(100vh-7rem)] overflow-y-auto">
               <nav>
-                {sections.map(section => (
+                {navSections.map(section => (
                   <div key={section.id}>
-                    <button onClick={() => toggleSection(section.id)} className="w-full flex items-center justify-between px-4 py-3 text-sm font-medium text-slate-900 dark:text-white hover:bg-slate-50 dark:hover:bg-slate-700 border-b border-slate-100 dark:border-slate-700">
+                    <button
+                      onClick={() => toggle(section.id)}
+                      className="w-full flex items-center justify-between px-4 py-3 text-sm font-medium text-slate-900 dark:text-white hover:bg-slate-50 dark:hover:bg-slate-700 border-b border-slate-100 dark:border-slate-700"
+                    >
                       <span>{section.title}</span>
-                      {expandedSections[section.id] ? <ChevronDown className="h-4 w-4" /> : <ChevronRight className="h-4 w-4" />}
+                      {expanded[section.id] ? <ChevronDown className="h-4 w-4" /> : <ChevronRight className="h-4 w-4" />}
                     </button>
-                    {expandedSections[section.id] && (
+                    {expanded[section.id] && (
                       <div className="bg-slate-50 dark:bg-slate-700/50">
                         {section.items.map(item => (
-                          <button key={item.id} onClick={() => scrollToSection(item.id)} className="w-full text-left px-6 py-2 text-sm text-slate-600 dark:text-slate-300 hover:text-emerald-600 dark:hover:text-emerald-400 hover:bg-white dark:hover:bg-slate-700 transition">
+                          <button key={item.id} onClick={() => scrollTo(item.id)}
+                            className="w-full text-left px-6 py-1.5 text-sm text-slate-600 dark:text-slate-300 hover:text-emerald-600 dark:hover:text-emerald-400 hover:bg-white dark:hover:bg-slate-700 transition">
                             {item.label}
                           </button>
                         ))}
@@ -221,337 +82,29 @@ const DocPage = () => {
             </div>
           </div>
 
+          {/* Content */}
           <div className="lg:col-span-3">
-            <div className="bg-white dark:bg-slate-800 rounded-lg border border-slate-200 dark:border-slate-700 p-8 space-y-12">
-              
-              <div id="about">
-                <h2 className="text-3xl font-bold text-slate-900 dark:text-white mb-4">Welcome to EDR Passenger Backoffice</h2>
-                <p className="text-slate-600 dark:text-slate-300 mb-4">Comprehensive management system for the Ethio-Djibouti Railway passenger platform. This documentation provides complete guidance on all features, operations, and best practices.</p>
-                <div className="bg-emerald-50 dark:bg-emerald-900/20 p-6 rounded-lg border border-emerald-200 dark:border-emerald-800">
-                  <h3 className="text-lg font-semibold text-emerald-900 dark:text-emerald-100 mb-2">🎆 Version 1.0.0 - Complete Platform Release</h3>
-                  <ul className="text-emerald-800 dark:text-emerald-200 space-y-1">
-                    <li>• <strong>Excess Baggage:</strong> Complete baggage handling with agent tools and passenger self-pay</li>
-                    <li>• <strong>Travel Packages:</strong> Bundled offerings with tiered pricing and inquiry management</li>
-                    <li>• <strong>Health Monitoring:</strong> Comprehensive system status and performance tracking</li>
-                    <li>• <strong>Boarding Management:</strong> Gate operations and passenger processing workflows</li>
-                    <li>• <strong>Advanced Fare Config:</strong> Dynamic pricing with segment-based rules</li>
-                    <li>• <strong>Payment Methods:</strong> Multi-provider payment configuration and management</li>
-                  </ul>
-                </div>
-              </div>
-
-              <div id="features" className="border-t pt-8">
-                <h2 className="text-2xl font-bold text-slate-900 dark:text-white mb-4">🌟 Key Features</h2>
-                <p className="text-slate-600 dark:text-slate-300">Complete booking, passenger, fleet, and financial management.</p>
-              </div>
-
-              {/* BOOKINGS */}
-              <div id="bookings" className="border-t pt-8">
-                <h2 className="text-2xl font-bold text-slate-900 dark:text-white mb-4">📋 Bookings</h2>
-                <p className="text-slate-600 dark:text-slate-300">Manage passenger bookings with search, view, modify, and refund capabilities.</p>
-              </div>
-
-              <div id="bookings-how" className="border-t pt-8">
-                <h3 className="text-2xl font-bold text-slate-900 dark:text-white mb-2">📋 How-To: Manage Bookings</h3>
-                <div className="space-y-4">
-                  <HowToStep number={1} title="Access Bookings">
-                    <ol className="list-decimal pl-5 space-y-1 text-sm text-slate-700 dark:text-slate-300">
-                      <li>Click "Bookings" in Operations section</li>
-                      <li>View all bookings in table format</li>
-                    </ol>
-                  </HowToStep>
-                  <HowToStep number={2} title="Search & Filter">
-                    <ol className="list-decimal pl-5 space-y-1 text-sm text-slate-700 dark:text-slate-300">
-                      <li>Use search box for reference, email, or phone</li>
-                      <li>Use Status dropdown to filter</li>
-                    </ol>
-                  </HowToStep>
-                  <HowToStep number={3} title="Manage Bookings">
-                    <ol className="list-decimal pl-5 space-y-1 text-sm text-slate-700 dark:text-slate-300">
-                      <li>Click "View Details" for full information</li>
-                      <li>Click "Cancel Booking" to process refunds</li>
-                    </ol>
-                  </HowToStep>
-                </div>
-              </div>
-
-              <div id="system-config" className="border-t pt-8">
-                <h2 className="text-2xl font-bold text-slate-900 dark:text-white mb-4">⚙️ System Config</h2>
-                <p className="text-slate-600 dark:text-slate-300">Centralized system configuration management with feature flags and operational controls.</p>
-              </div>
-
-              <div id="system-config-how" className="border-t pt-8">
-                <h3 className="text-2xl font-bold text-slate-900 dark:text-white mb-2">⚙️ How-To: Manage System Configuration</h3>
-                <div className="space-y-4">
-                  <HowToStep number={1} title="Access System Config">
-                    <ol className="list-decimal pl-5 space-y-1 text-sm text-slate-700 dark:text-slate-300">
-                      <li>Click "System Config" in System section</li>
-                      <li>View all configuration categories</li>
-                    </ol>
-                  </HowToStep>
-                  <HowToStep number={2} title="Rate Limiting">
-                    <ol className="list-decimal pl-5 space-y-1 text-sm text-slate-700 dark:text-slate-300">
-                      <li>Adjust auth endpoints limit (default: 5 req/min)</li>
-                      <li>Set strict endpoints limit (default: 20 req/min)</li>
-                      <li>Configure default endpoints limit (default: 100 req/min)</li>
-                    </ol>
-                  </HowToStep>
-                  <HowToStep number={3} title="Seat Booking Settings">
-                    <ol className="list-decimal pl-5 space-y-1 text-sm text-slate-700 dark:text-slate-300">
-                      <li>Set seat hold duration (default: 5 minutes)</li>
-                      <li>Configure hold cutoff before departure (default: 2 hours)</li>
-                      <li>Click "Save Changes" to apply</li>
-                    </ol>
-                  </HowToStep>
-                </div>
-              </div>
-
-              {/* EXCESS BAGGAGE */}
-              <div id="excess-baggage" className="border-t pt-8">
-                <h2 className="text-2xl font-bold text-slate-900 dark:text-white mb-4">📦 Excess Baggage</h2>
-                <p className="text-slate-600 dark:text-slate-300">Manage excess baggage charges at boarding with agent tools and passenger self-pay options.</p>
-              </div>
-
-              <div id="excess-baggage-how" className="border-t pt-8">
-                <h3 className="text-2xl font-bold text-slate-900 dark:text-white mb-2">📦 How-To: Handle Excess Baggage</h3>
-                <div className="space-y-4">
-                  <HowToStep number={1} title="Access Excess Baggage">
-                    <ol className="list-decimal pl-5 space-y-1 text-sm text-slate-700 dark:text-slate-300">
-                      <li>Click "Excess Baggage" in Enhanced Features</li>
-                      <li>View all baggage charges and their status</li>
-                    </ol>
-                  </HowToStep>
-                  <HowToStep number={2} title="Search & Filter">
-                    <ol className="list-decimal pl-5 space-y-1 text-sm text-slate-700 dark:text-slate-300">
-                      <li>Search by booking reference</li>
-                      <li>Filter by status: PENDING, PAID, CASH_COLLECTED, EXPIRED, WAIVED</li>
-                      <li>Use date filters for specific periods</li>
-                    </ol>
-                  </HowToStep>
-                  <HowToStep number={3} title="Manage Charges">
-                    <ol className="list-decimal pl-5 space-y-1 text-sm text-slate-700 dark:text-slate-300">
-                      <li>"Resend Link" for pending charges to passenger</li>
-                      <li>"Waive" charges with reason (supervisor authority)</li>
-                      <li>"Delete" expired or waived charges</li>
-                    </ol>
-                  </HowToStep>
-                </div>
-              </div>
-
-              {/* TRAVEL PACKAGES */}
-              <div id="packages" className="border-t pt-8">
-                <h2 className="text-2xl font-bold text-slate-900 dark:text-white mb-4">🎒 Travel Packages</h2>
-                <p className="text-slate-600 dark:text-slate-300">Manage pilgrimage and group travel packages with tiered pricing and capacity management.</p>
-              </div>
-
-              <div id="packages-how" className="border-t pt-8">
-                <h3 className="text-2xl font-bold text-slate-900 dark:text-white mb-2">🎒 How-To: Manage Travel Packages</h3>
-                <div className="space-y-4">
-                  <HowToStep number={1} title="Create Package">
-                    <ol className="list-decimal pl-5 space-y-1 text-sm text-slate-700 dark:text-slate-300">
-                      <li>Click "New Package" button</li>
-                      <li>Fill package details: code, name, stations, schedules</li>
-                      <li>Set capacity, validity period, and included services</li>
-                      <li>Save package (starts in DRAFT status)</li>
-                    </ol>
-                  </HowToStep>
-                  <HowToStep number={2} title="Configure Price Tiers">
-                    <ol className="list-decimal pl-5 space-y-1 text-sm text-slate-700 dark:text-slate-300">
-                      <li>Click "Tiers" on package to manage pricing</li>
-                      <li>Add tiers: seat type, label, price, capacity</li>
-                      <li>Edit existing tiers (limited if bookings exist)</li>
-                      <li>Delete unused tiers</li>
-                    </ol>
-                  </HowToStep>
-                  <HowToStep number={3} title="Activate & Manage">
-                    <ol className="list-decimal pl-5 space-y-1 text-sm text-slate-700 dark:text-slate-300">
-                      <li>"Activate" draft packages to make bookable</li>
-                      <li>"Deactivate" active packages to stop new bookings</li>
-                      <li>"Delete" packages with no bookings if needed</li>
-                    </ol>
-                  </HowToStep>
-                </div>
-              </div>
-
-              {/* PACKAGE INQUIRIES */}
-              <div id="package-inquiries" className="border-t pt-8">
-                <h2 className="text-2xl font-bold text-slate-900 dark:text-white mb-4">📝 Package Inquiries</h2>
-                <p className="text-slate-600 dark:text-slate-300">Manage incoming package booking inquiries and track lead conversion.</p>
-              </div>
-
-              <div id="package-inquiries-how" className="border-t pt-8">
-                <h3 className="text-2xl font-bold text-slate-900 dark:text-white mb-2">📝 How-To: Handle Package Inquiries</h3>
-                <div className="space-y-4">
-                  <HowToStep number={1} title="View Inquiries">
-                    <ol className="list-decimal pl-5 space-y-1 text-sm text-slate-700 dark:text-slate-300">
-                      <li>Click "Package Inquiries" in Enhanced Features</li>
-                      <li>Filter by package or inquiry status</li>
-                      <li>View contact details, package interest, traveler count</li>
-                    </ol>
-                  </HowToStep>
-                  <HowToStep number={2} title="Update Status">
-                    <ol className="list-decimal pl-5 space-y-1 text-sm text-slate-700 dark:text-slate-300">
-                      <li>Use status dropdown: NEW → CONTACTED → CONVERTED/CLOSED</li>
-                      <li>Mark as CONTACTED after first customer contact</li>
-                      <li>Mark as CONVERTED when inquiry becomes booking</li>
-                      <li>Mark as CLOSED if customer not interested</li>
-                    </ol>
-                  </HowToStep>
-                  <HowToStep number={3} title="Lead Management">
-                    <ol className="list-decimal pl-5 space-y-1 text-sm text-slate-700 dark:text-slate-300">
-                      <li>Respond to NEW inquiries within 24 hours</li>
-                      <li>Follow up on CONTACTED inquiries regularly</li>
-                      <li>Delete spam or duplicate inquiries as needed</li>
-                    </ol>
-                  </HowToStep>
-                </div>
-              </div>
-
-              {/* HEALTH MONITORING */}
-              <div id="health" className="border-t pt-8">
-                <h2 className="text-2xl font-bold text-slate-900 dark:text-white mb-4">🏥 Health Monitoring</h2>
-                <p className="text-slate-600 dark:text-slate-300">Monitor EDR Passenger API health with real-time system status and performance metrics.</p>
-              </div>
-
-              <div id="health-how" className="border-t pt-8">
-                <h3 className="text-2xl font-bold text-slate-900 dark:text-white mb-2">🏥 How-To: Monitor System Health</h3>
-                <div className="space-y-4">
-                  <HowToStep number={1} title="Access Health Dashboard">
-                    <ol className="list-decimal pl-5 space-y-1 text-sm text-slate-700 dark:text-slate-300">
-                      <li>Click "Health Monitoring" in Enhanced Features</li>
-                      <li>View overall system status banner</li>
-                      <li>Check individual probe cards (auto-refreshing)</li>
-                    </ol>
-                  </HowToStep>
-                  <HowToStep number={2} title="Interpret Health Checks">
-                    <ol className="list-decimal pl-5 space-y-1 text-sm text-slate-700 dark:text-slate-300">
-                      <li>Liveness: API process alive (30s refresh)</li>
-                      <li>Readiness: Database connectivity + latency (30s refresh)</li>
-                      <li>App Info: Version, uptime, environment (60s refresh)</li>
-                    </ol>
-                  </HowToStep>
-                  <HowToStep number={3} title="Troubleshoot Issues">
-                    <ol className="list-decimal pl-5 space-y-1 text-sm text-slate-700 dark:text-slate-300">
-                      <li>Red status: Check error details and system logs</li>
-                      <li>High DB latency: Monitor database performance</li>
-                      <li>Failed checks: Verify API server and connections</li>
-                      <li>Use "Refresh" button for manual status update</li>
-                    </ol>
-                  </HowToStep>
-                </div>
-              </div>
-
-              {/* BOARDING MANAGEMENT */}
-              <div id="boarding" className="border-t pt-8">
-                <h2 className="text-2xl font-bold text-slate-900 dark:text-white mb-4">🚆 Boarding Management</h2>
-                <p className="text-slate-600 dark:text-slate-300">Manage gate operations and passenger boarding processes with real-time tracking.</p>
-              </div>
-
-              <div id="boarding-how" className="border-t pt-8">
-                <h3 className="text-2xl font-bold text-slate-900 dark:text-white mb-2">🚆 How-To: Manage Boarding Operations</h3>
-                <div className="space-y-4">
-                  <HowToStep number={1} title="Access Boarding Management">
-                    <ol className="list-decimal pl-5 space-y-1 text-sm text-slate-700 dark:text-slate-300">
-                      <li>Click "Boarding" in Enhanced Features</li>
-                      <li>Select active trip/schedule for boarding</li>
-                      <li>View real-time boarding dashboard</li>
-                    </ol>
-                  </HowToStep>
-                  <HowToStep number={2} title="Monitor Boarding Process">
-                    <ol className="list-decimal pl-5 space-y-1 text-sm text-slate-700 dark:text-slate-300">
-                      <li>Track total passengers expected vs boarded</li>
-                      <li>Monitor boarding progress percentage</li>
-                      <li>View gate status and any alerts</li>
-                    </ol>
-                  </HowToStep>
-                  <HowToStep number={3} title="Handle Boarding Operations">
-                    <ol className="list-decimal pl-5 space-y-1 text-sm text-slate-700 dark:text-slate-300">
-                      <li>Validate passenger tickets and documents</li>
-                      <li>Resolve seat conflicts or issues</li>
-                      <li>Process last-minute passengers and no-shows</li>
-                    </ol>
-                  </HowToStep>
-                </div>
-              </div>
-
-              {/* ADVANCED FARE CONFIG */}
-              <div id="fare-config" className="border-t pt-8">
-                <h2 className="text-2xl font-bold text-slate-900 dark:text-white mb-4">📊 Advanced Fare Config</h2>
-                <p className="text-slate-600 dark:text-slate-300">Configure complex fare rules and dynamic pricing strategies with segment-based pricing.</p>
-              </div>
-
-              <div id="fare-config-how" className="border-t pt-8">
-                <h3 className="text-2xl font-bold text-slate-900 dark:text-white mb-2">📊 How-To: Configure Advanced Fares</h3>
-                <div className="space-y-4">
-                  <HowToStep number={1} title="Access Fare Configuration">
-                    <ol className="list-decimal pl-5 space-y-1 text-sm text-slate-700 dark:text-slate-300">
-                      <li>Click "Advanced Fare Config" in Enhanced Features</li>
-                      <li>Choose between Schedule Fares or Segment Fares</li>
-                      <li>View existing fare rules and calculations</li>
-                    </ol>
-                  </HowToStep>
-                  <HowToStep number={2} title="Create Fare Rules">
-                    <ol className="list-decimal pl-5 space-y-1 text-sm text-slate-700 dark:text-slate-300">
-                      <li>Set fare amounts for specific schedules or segments</li>
-                      <li>Define passenger categories (ADULT/CHILD) and nationalities</li>
-                      <li>Configure validity periods and seasonal adjustments</li>
-                    </ol>
-                  </HowToStep>
-                  <HowToStep number={3} title="Manage Dynamic Pricing">
-                    <ol className="list-decimal pl-5 space-y-1 text-sm text-slate-700 dark:text-slate-300">
-                      <li>Apply route segment-specific pricing</li>
-                      <li>Set nationality-based rate variations</li>
-                      <li>Monitor fare engine integration and real-time calculations</li>
-                    </ol>
-                  </HowToStep>
-                </div>
-              </div>
-
-              {/* PAYMENT METHODS */}
-              <div id="payment-methods" className="border-t pt-8">
-                <h2 className="text-2xl font-bold text-slate-900 dark:text-white mb-4">💳 Payment Methods</h2>
-                <p className="text-slate-600 dark:text-slate-300">Configure and manage payment provider integrations with multi-provider support.</p>
-              </div>
-
-              <div id="payment-methods-how" className="border-t pt-8">
-                <h3 className="text-2xl font-bold text-slate-900 dark:text-white mb-2">💳 How-To: Configure Payment Methods</h3>
-                <div className="space-y-4">
-                  <HowToStep number={1} title="Access Payment Configuration">
-                    <ol className="list-decimal pl-5 space-y-1 text-sm text-slate-700 dark:text-slate-300">
-                      <li>Click "Payment Methods" in Enhanced Features</li>
-                      <li>View all configured payment providers</li>
-                      <li>Check provider status and connectivity</li>
-                    </ol>
-                  </HowToStep>
-                  <HowToStep number={2} title="Configure Providers">
-                    <ol className="list-decimal pl-5 space-y-1 text-sm text-slate-700 dark:text-slate-300">
-                      <li>Set up API credentials (URLs, keys, merchant IDs)</li>
-                      <li>Configure transaction fees and limits</li>
-                      <li>Enable/disable specific payment methods</li>
-                    </ol>
-                  </HowToStep>
-                  <HowToStep number={3} title="Test & Validate">
-                    <ol className="list-decimal pl-5 space-y-1 text-sm text-slate-700 dark:text-slate-300">
-                      <li>Run test transactions for each provider</li>
-                      <li>Validate webhook endpoints and security</li>
-                      <li>Monitor API connectivity and error logs</li>
-                    </ol>
-                  </HowToStep>
-                </div>
-              </div>
-
+            <div className="bg-white dark:bg-slate-800 rounded-lg border border-slate-200 dark:border-slate-700 p-8 space-y-2">
+              <OverviewSection />
+              <OperationsSection />
+              <TourismSection />
+              <MasterDataSection />
+              <FinancialSection />
+              <CustomerServicesSection />
+              <SecuritySection />
+              <AnalyticsSection />
+              <SystemSection />
             </div>
           </div>
+
         </div>
       </div>
 
-      <div className="mt-12 bg-slate-900 text-white py-8">
-        <div className="max-w-7xl mx-auto px-4 text-center text-slate-400">
-          <p>© 2026 Ethio-Djibouti Railway | Passenger Backoffice Documentation v1.0.0</p>
+      <div className="mt-12 bg-slate-900 text-white py-6">
+        <div className="max-w-7xl mx-auto px-4 text-center text-slate-400 text-sm">
+          © 2026 Ethio-Djibouti Railway · Passenger Backoffice Documentation v1.0.0
         </div>
       </div>
     </div>
   );
-};
-
-export default DocPage;
\ No newline at end of file
+}
diff --git a/apps/edr-passenger-web/backoffice/src/app/docs/sections/AnalyticsSection.tsx b/apps/edr-passenger-web/backoffice/src/app/docs/sections/AnalyticsSection.tsx
new file mode 100644
index 000000000..ab1bf40fc
--- /dev/null
+++ b/apps/edr-passenger-web/backoffice/src/app/docs/sections/AnalyticsSection.tsx
@@ -0,0 +1,39 @@
+import { HowToStep } from './_shared';
+
+const li = 'text-sm text-slate-700 dark:text-slate-300';
+const ol = 'list-decimal pl-5 space-y-1 ' + li;
+
+export default function AnalyticsSection() {
+  return (
+    <>
+      <div id="reports" className="border-t pt-8">
+        <h2 className="text-2xl font-bold text-slate-900 dark:text-white mb-2">📈 Reports</h2>
+        <p className={li}>Generate revenue, occupancy, agent performance, and passenger analytics reports with custom date ranges. Access level: Supervisor, Admin.</p>
+        <div className="mt-3 grid grid-cols-2 gap-2 text-xs text-slate-600 dark:text-slate-400">
+          {[
+            ['Revenue', 'Total, by route, by class, by payment method'],
+            ['Occupancy', 'Seat utilisation %, peak/off-peak analysis'],
+            ['Agent Performance', 'Counter bookings, commission, ranking'],
+            ['Passenger Analytics', 'New vs repeat, loyalty stats, regional split'],
+          ].map(([t, d]) => (
+            <div key={t} className="bg-slate-50 dark:bg-slate-700/50 rounded p-2 border border-slate-200 dark:border-slate-600">
+              <div className="font-semibold text-slate-700 dark:text-slate-300">{t}</div>
+              <div>{d}</div>
+            </div>
+          ))}
+        </div>
+      </div>
+      <div id="reports-how" className="border-t pt-8">
+        <h3 className="text-xl font-bold text-slate-900 dark:text-white mb-4">📈 How-To: Generate Reports</h3>
+        <div className="space-y-3">
+          <HowToStep number={1} title="Configure & Generate">
+            <ol className={ol}><li>Click <strong>Reports</strong> in Analytics &amp; Reports</li><li>Select report type, set date range, apply optional route/agent filters</li><li>Choose group-by: Day / Week / Month / Year</li><li>Click <strong>Generate Report</strong></li></ol>
+          </HowToStep>
+          <HowToStep number={2} title="Export">
+            <ol className={ol}><li>Download as PDF, Excel, or CSV</li><li>Click <strong>Save Report</strong> to store config for one-click re-runs</li></ol>
+          </HowToStep>
+        </div>
+      </div>
+    </>
+  );
+}
diff --git a/apps/edr-passenger-web/backoffice/src/app/docs/sections/CustomerServicesSection.tsx b/apps/edr-passenger-web/backoffice/src/app/docs/sections/CustomerServicesSection.tsx
new file mode 100644
index 000000000..e18bdc8ac
--- /dev/null
+++ b/apps/edr-passenger-web/backoffice/src/app/docs/sections/CustomerServicesSection.tsx
@@ -0,0 +1,59 @@
+import { HowToStep } from './_shared';
+
+const li = 'text-sm text-slate-700 dark:text-slate-300';
+const ol = 'list-decimal pl-5 space-y-1 ' + li;
+
+export default function CustomerServicesSection() {
+  return (
+    <>
+      <div id="loyalty" className="border-t pt-8">
+        <h2 className="text-2xl font-bold text-slate-900 dark:text-white mb-2">🏆 Loyalty Program</h2>
+        <p className={li}>View and manage passenger loyalty accounts, tiers, points, and rewards. Access level: Agent, Supervisor, Admin.</p>
+        <div className="mt-3 overflow-x-auto">
+          <table className="text-xs w-full border-collapse">
+            <thead><tr className="bg-slate-100 dark:bg-slate-700">{['Tier','Points','Bonus'].map(h => <th key={h} className="text-left px-3 py-2 text-slate-700 dark:text-slate-300">{h}</th>)}</tr></thead>
+            <tbody className="text-slate-600 dark:text-slate-400">
+              <tr><td className="px-3 py-1">BRONZE</td><td>0–999</td><td>Standard</td></tr>
+              <tr className="bg-slate-50 dark:bg-slate-700/30"><td className="px-3 py-1">SILVER</td><td>1,000–2,999</td><td>+5%</td></tr>
+              <tr><td className="px-3 py-1">GOLD</td><td>3,000–4,999</td><td>+10%</td></tr>
+              <tr className="bg-slate-50 dark:bg-slate-700/30"><td className="px-3 py-1">PLATINUM</td><td>5,000+</td><td>+15% + Priority</td></tr>
+            </tbody>
+          </table>
+        </div>
+      </div>
+      <div id="loyalty-how" className="border-t pt-8">
+        <h3 className="text-xl font-bold text-slate-900 dark:text-white mb-4">🏆 How-To: Manage Loyalty</h3>
+        <div className="space-y-3">
+          <HowToStep number={1} title="View Accounts">
+            <ol className={ol}><li>Click <strong>Loyalty Program</strong> in Customer Services</li><li>Search by name/email; filter by tier</li></ol>
+          </HowToStep>
+          <HowToStep number={2} title="Adjust Points (Admin)">
+            <ol className={ol}><li>Click <strong>Adjust Points</strong> on an account</li><li>Enter amount, select reason (Bonus / Correction / Promotion), click <strong>Apply</strong></li></ol>
+          </HowToStep>
+          <HowToStep number={3} title="Grant Rewards">
+            <ol className={ol}><li>Click <strong>Grant Reward</strong>, select from catalog, specify quantity</li><li>Confirmation email sent to passenger automatically</li></ol>
+          </HowToStep>
+        </div>
+      </div>
+
+      <div id="notifications" className="border-t pt-8">
+        <h2 className="text-2xl font-bold text-slate-900 dark:text-white mb-2">🔔 Notifications</h2>
+        <p className={li}>View logs, manage templates, and send manual notifications via Email, SMS, or Push. Access level: Supervisor, Admin.</p>
+      </div>
+      <div id="notifications-how" className="border-t pt-8">
+        <h3 className="text-xl font-bold text-slate-900 dark:text-white mb-4">🔔 How-To: Manage Notifications</h3>
+        <div className="space-y-3">
+          <HowToStep number={1} title="View Log">
+            <ol className={ol}><li>Click <strong>Notifications</strong> in Customer Services</li><li>Filter by recipient, channel, status, or date; click <strong>Retry</strong> on failures (max 3)</li></ol>
+          </HowToStep>
+          <HowToStep number={2} title="Send Manual Notification">
+            <ol className={ol}><li>Click <strong>Send Notification</strong></li><li>Select recipients, choose template or custom message, pick channels</li><li>Preview then <strong>Send</strong></li></ol>
+          </HowToStep>
+          <HowToStep number={3} title="Manage Templates">
+            <ol className={ol}><li>Open <strong>Templates</strong> tab; click a template to edit</li><li>Use placeholders: <code>{'{{name}}'}</code> <code>{'{{bookingRef}}'}</code></li><li>Click <strong>Add Template</strong> to create new ones</li></ol>
+          </HowToStep>
+        </div>
+      </div>
+    </>
+  );
+}
diff --git a/apps/edr-passenger-web/backoffice/src/app/docs/sections/FinancialSection.tsx b/apps/edr-passenger-web/backoffice/src/app/docs/sections/FinancialSection.tsx
new file mode 100644
index 000000000..7ee860bb2
--- /dev/null
+++ b/apps/edr-passenger-web/backoffice/src/app/docs/sections/FinancialSection.tsx
@@ -0,0 +1,152 @@
+import { HowToStep } from './_shared';
+
+const li = 'text-sm text-slate-700 dark:text-slate-300';
+const ol = 'list-decimal pl-5 space-y-1 ' + li;
+
+export default function FinancialSection() {
+  return (
+    <>
+      {/* PRICING */}
+      <div id="pricing" className="border-t pt-8">
+        <h2 className="text-2xl font-bold text-slate-900 dark:text-white mb-2">💲 Pricing & Fares</h2>
+        <p className={li}>View dynamically calculated fares per schedule and seat class. Fare = Base + Premium + Insurance. ADULT pays 100%; first CHILD free, subsequent CHILD 100%. Access level: Admin, Supervisor.</p>
+      </div>
+      <div id="pricing-how" className="border-t pt-8">
+        <h3 className="text-xl font-bold text-slate-900 dark:text-white mb-4">💲 How-To: View Schedule Fares</h3>
+        <div className="space-y-3">
+          <HowToStep number={1} title="Select Schedule">
+            <ol className={ol}><li>Click <strong>Pricing &amp; Fares</strong> in Financial</li><li>Choose a schedule from the dropdown</li><li>Table shows calculated fares per seat class and passenger type</li></ol>
+          </HowToStep>
+        </div>
+      </div>
+
+      {/* TARIFF RATES */}
+      <div id="tariff-rates" className="border-t pt-8">
+        <h2 className="text-2xl font-bold text-slate-900 dark:text-white mb-2">📊 Tariff Rates</h2>
+        <p className={li}>Manage base per-km tariff rates used to calculate fares across routes and seat classes. Access level: Admin.</p>
+      </div>
+      <div id="tariff-rates-how" className="border-t pt-8">
+        <h3 className="text-xl font-bold text-slate-900 dark:text-white mb-4">📊 How-To: Manage Tariff Rates</h3>
+        <div className="space-y-3">
+          <HowToStep number={1} title="Create / Edit Rate">
+            <ol className={ol}><li>Click <strong>Tariff Rates</strong> in Financial</li><li>Click <strong>Add Rate</strong> — set seat class, rate per km (ETB), passenger type, nationality, validity dates</li><li>Click <strong>Edit</strong> on existing rows to update; changes apply to new bookings only</li></ol>
+          </HowToStep>
+        </div>
+      </div>
+
+      {/* FARE RULES */}
+      <div id="fare-rules" className="border-t pt-8">
+        <h2 className="text-2xl font-bold text-slate-900 dark:text-white mb-2">📐 Fare Rules</h2>
+        <p className={li}>Override or extend fares with schedule-specific or segment-specific rules, including nationality and passenger-type filters. Access level: Admin, Supervisor.</p>
+        <div className="mt-3 bg-slate-50 dark:bg-slate-700/50 rounded p-3 text-xs text-slate-600 dark:text-slate-400 font-mono">
+          Priority: Segment (nationality) → Segment (generic) → Schedule (nationality) → Schedule (generic) → Default class fare
+        </div>
+      </div>
+      <div id="fare-rules-how" className="border-t pt-8">
+        <h3 className="text-xl font-bold text-slate-900 dark:text-white mb-4">📐 How-To: Manage Fare Rules</h3>
+        <div className="space-y-3">
+          <HowToStep number={1} title="Schedule Fare Override">
+            <ol className={ol}><li>Click <strong>Fare Rules</strong> in Financial → <strong>Schedule Fares</strong> tab</li><li>Click <strong>Add Fare Rule</strong>: select schedule, seat class, fare (ETB), passenger type, nationality, validity dates</li></ol>
+          </HowToStep>
+          <HowToStep number={2} title="Segment Fare Rule">
+            <ol className={ol}><li>Switch to <strong>Segment Fares</strong> tab</li><li>Select route, then origin and destination stations</li><li>Set seat class, fare, passenger type, nationality, validity dates</li><li>Destination must be after origin on the route</li></ol>
+          </HowToStep>
+          <HowToStep number={3} title="Edit / Delete">
+            <ol className={ol}><li>Click <strong>Edit</strong> to update amount or dates</li><li>Click <strong>Delete</strong> — removed immediately for new bookings</li></ol>
+          </HowToStep>
+        </div>
+      </div>
+
+      {/* PAYMENTS */}
+      <div id="payments" className="border-t pt-8">
+        <h2 className="text-2xl font-bold text-slate-900 dark:text-white mb-2">💳 Payments</h2>
+        <p className={li}>Monitor transactions across all providers and process refunds. Providers: Telebirr · CBE Birr · eBirr · Card · Wallet · WAAFI. Access level: Supervisor, Admin.</p>
+      </div>
+      <div id="payments-how" className="border-t pt-8">
+        <h3 className="text-xl font-bold text-slate-900 dark:text-white mb-4">💳 How-To: Manage Payments</h3>
+        <div className="space-y-3">
+          <HowToStep number={1} title="Search Transactions">
+            <ol className={ol}><li>Click <strong>Payments</strong> in Financial</li><li>Search by booking reference or transaction ID</li><li>Filter by status (Succeeded · Failed · Processing · Refunded) or provider</li></ol>
+          </HowToStep>
+          <HowToStep number={2} title="Process Refund">
+            <ol className={ol}><li>Click <strong>Process Refund</strong> on a completed payment</li><li>Enter amount, select reason, add notes</li><li>Confirm — refund status: Pending → Processing → Completed</li></ol>
+          </HowToStep>
+        </div>
+      </div>
+
+      {/* CURRENCIES */}
+      <div id="currencies" className="border-t pt-8">
+        <h2 className="text-2xl font-bold text-slate-900 dark:text-white mb-2">💱 Currencies</h2>
+        <p className={li}>Manage ETB→DJF and ETB→USD exchange rates used for display conversion. ETB is the transaction currency. Access level: Admin.</p>
+        <div className="mt-3 overflow-x-auto">
+          <table className="text-xs w-full border-collapse">
+            <thead><tr className="bg-slate-100 dark:bg-slate-700">{['From','To','Rate','Example (3500 ETB)'].map(h=><th key={h} className="text-left px-3 py-2 text-slate-700 dark:text-slate-300">{h}</th>)}</tr></thead>
+            <tbody className="text-slate-600 dark:text-slate-400">
+              <tr><td className="px-3 py-1">ETB</td><td>DJF</td><td>3.25</td><td>11,375 DJF</td></tr>
+              <tr className="bg-slate-50 dark:bg-slate-700/30"><td className="px-3 py-1">ETB</td><td>USD</td><td>0.018</td><td>63 USD</td></tr>
+            </tbody>
+          </table>
+        </div>
+      </div>
+      <div id="currencies-how" className="border-t pt-8">
+        <h3 className="text-xl font-bold text-slate-900 dark:text-white mb-4">💱 How-To: Manage Exchange Rates</h3>
+        <div className="space-y-3">
+          <HowToStep number={1} title="Add / Update Rate">
+            <ol className={ol}><li>Click <strong>Currencies</strong> in Financial</li><li>Click <strong>Add Currency Rate</strong>: from/to currency, rate value, effective date</li><li>Click <strong>Edit</strong> on existing rows to update; applies to future bookings/display</li></ol>
+          </HowToStep>
+        </div>
+      </div>
+
+      {/* PROMOS */}
+      <div id="promos" className="border-t pt-8">
+        <h2 className="text-2xl font-bold text-slate-900 dark:text-white mb-2">🎁 Promo Codes</h2>
+        <p className={li}>Create percentage or fixed-amount discount codes with expiry dates. Access level: Admin, Supervisor.</p>
+      </div>
+      <div id="promos-how" className="border-t pt-8">
+        <h3 className="text-xl font-bold text-slate-900 dark:text-white mb-4">🎁 How-To: Manage Promo Codes</h3>
+        <div className="space-y-3">
+          <HowToStep number={1} title="Create Code">
+            <ol className={ol}><li>Click <strong>Add Promo Code</strong></li><li>Fill: code (uppercase), title, discount type (Percentage / Amount), value, valid until date</li><li>Toggle active and save</li></ol>
+          </HowToStep>
+          <HowToStep number={2} title="Edit / Deactivate">
+            <ol className={ol}><li>Click <strong>Edit</strong> to update value, dates, or active status</li><li>Click <strong>Delete</strong> — already-applied bookings keep their discount</li></ol>
+          </HowToStep>
+        </div>
+      </div>
+
+      {/* PAYMENT METHODS */}
+      <div id="payment-methods" className="border-t pt-8">
+        <h2 className="text-2xl font-bold text-slate-900 dark:text-white mb-2">🔌 Payment Methods</h2>
+        <p className={li}>Configure API credentials, fees, and enable/disable payment providers. Access level: Admin.</p>
+      </div>
+      <div id="payment-methods-how" className="border-t pt-8">
+        <h3 className="text-xl font-bold text-slate-900 dark:text-white mb-4">🔌 How-To: Configure Payment Methods</h3>
+        <div className="space-y-3">
+          <HowToStep number={1} title="Configure Provider">
+            <ol className={ol}><li>Click <strong>Payment Methods</strong> in Financial</li><li>Select a provider (Telebirr, CBE Birr, eBirr, Card, WAAFI)</li><li>Enter base URL, API key/secret, merchant ID, webhook endpoint</li><li>Set transaction fees, min/max amounts, enable/disable toggle</li></ol>
+          </HowToStep>
+          <HowToStep number={2} title="Test & Validate">
+            <ol className={ol}><li>Run a test transaction to verify connectivity</li><li>Validate webhook endpoint accessibility and security secret</li></ol>
+          </HowToStep>
+        </div>
+      </div>
+
+      {/* WALLET ACCOUNTS */}
+      <div id="wallet-accounts" className="border-t pt-8">
+        <h2 className="text-2xl font-bold text-slate-900 dark:text-white mb-2">👛 Wallet Accounts</h2>
+        <p className={li}>View and manage passenger EDR wallet balances and transaction ledgers. Access level: Supervisor, Admin.</p>
+      </div>
+      <div id="wallet-accounts-how" className="border-t pt-8">
+        <h3 className="text-xl font-bold text-slate-900 dark:text-white mb-4">👛 How-To: Manage Wallet Accounts</h3>
+        <div className="space-y-3">
+          <HowToStep number={1} title="View Wallets">
+            <ol className={ol}><li>Click <strong>Wallet Accounts</strong> in Financial</li><li>Search by passenger name or email</li><li>View current balance (ETB minor units) and last activity</li></ol>
+          </HowToStep>
+          <HowToStep number={2} title="View Ledger">
+            <ol className={ol}><li>Click a wallet row to open the transaction ledger</li><li>See all credits, debits, top-ups, and refunds with timestamps</li></ol>
+          </HowToStep>
+        </div>
+      </div>
+    </>
+  );
+}
diff --git a/apps/edr-passenger-web/backoffice/src/app/docs/sections/MasterDataSection.tsx b/apps/edr-passenger-web/backoffice/src/app/docs/sections/MasterDataSection.tsx
new file mode 100644
index 000000000..877f54c5d
--- /dev/null
+++ b/apps/edr-passenger-web/backoffice/src/app/docs/sections/MasterDataSection.tsx
@@ -0,0 +1,142 @@
+import { HowToStep } from './_shared';
+
+const li = 'text-sm text-slate-700 dark:text-slate-300';
+const ol = 'list-decimal pl-5 space-y-1 ' + li;
+
+export default function MasterDataSection() {
+  return (
+    <>
+      {/* STATIONS */}
+      <div id="stations" className="border-t pt-8">
+        <h2 className="text-2xl font-bold text-slate-900 dark:text-white mb-2">📍 Stations</h2>
+        <p className={li}>Configure railway stations with code, city, country, coordinates, and operational status. Access level: Supervisor, Admin.</p>
+      </div>
+      <div id="stations-how" className="border-t pt-8">
+        <h3 className="text-xl font-bold text-slate-900 dark:text-white mb-4">📍 How-To: Manage Stations</h3>
+        <div className="space-y-3">
+          <HowToStep number={1} title="Create Station">
+            <ol className={ol}><li>Click <strong>Add Station</strong></li><li>Fill: 3-letter code (e.g. ADD), name, city, country code, lat/lng, timezone</li><li>Toggle operational status and save</li></ol>
+          </HowToStep>
+          <HowToStep number={2} title="Edit / Delete">
+            <ol className={ol}><li>Click <strong>Edit</strong> on any row to update fields</li><li>Click <strong>Delete</strong> — system warns if routes or schedules depend on this station</li></ol>
+          </HowToStep>
+        </div>
+      </div>
+
+      {/* TRAINS */}
+      <div id="trains" className="border-t pt-8">
+        <h2 className="text-2xl font-bold text-slate-900 dark:text-white mb-2">🚂 Trains</h2>
+        <p className={li}>Manage the train fleet — number, name, operator, status, and attached coaches. Access level: Supervisor, Admin.</p>
+      </div>
+      <div id="trains-how" className="border-t pt-8">
+        <h3 className="text-xl font-bold text-slate-900 dark:text-white mb-4">🚂 How-To: Manage Trains</h3>
+        <div className="space-y-3">
+          <HowToStep number={1} title="Create Train">
+            <ol className={ol}><li>Click <strong>Add Train</strong></li><li>Fill: unique number, name, operator, description, status</li><li>Save, then assign coaches</li></ol>
+          </HowToStep>
+          <HowToStep number={2} title="Edit / Delete">
+            <ol className={ol}><li>Click <strong>Edit</strong> to update details or change status</li><li>Delete only if no active schedules reference this train</li></ol>
+          </HowToStep>
+        </div>
+      </div>
+
+      {/* COACHES */}
+      <div id="coaches" className="border-t pt-8">
+        <h2 className="text-2xl font-bold text-slate-900 dark:text-white mb-2">🚃 Coaches</h2>
+        <p className={li}>Manage coach inventory, seat layout, type, and maintenance status. Access level: Supervisor, Admin.</p>
+      </div>
+      <div id="coaches-how" className="border-t pt-8">
+        <h3 className="text-xl font-bold text-slate-900 dark:text-white mb-4">🚃 How-To: Manage Coaches</h3>
+        <div className="space-y-3">
+          <HowToStep number={1} title="Create Coach">
+            <ol className={ol}><li>Click <strong>Add Coach</strong></li><li>Fill: number, coach type, arrangement (e.g. 2+2), capacity, status</li><li>Auto-generate seats from arrangement or configure manually</li></ol>
+          </HowToStep>
+          <HowToStep number={2} title="Edit / Delete">
+            <ol className={ol}><li>Update arrangement (limited if seats are occupied)</li><li>Delete only if no scheduled trips use this coach</li></ol>
+          </HowToStep>
+        </div>
+      </div>
+
+      {/* SEATS */}
+      <div id="seats" className="border-t pt-8">
+        <h2 className="text-2xl font-bold text-slate-900 dark:text-white mb-2">💺 Seats</h2>
+        <p className={li}>View seat maps, update properties, block/unblock seats, and bulk import/export via CSV. Access level: Supervisor, Admin.</p>
+      </div>
+      <div id="seats-how" className="border-t pt-8">
+        <h3 className="text-xl font-bold text-slate-900 dark:text-white mb-4">💺 How-To: Manage Seats</h3>
+        <div className="space-y-3">
+          <HowToStep number={1} title="View Seat Map">
+            <ol className={ol}><li>Select a coach from the dropdown</li><li>Color-coded grid: Green=Available · Yellow=Held · Blue=Booked · Red=Blocked</li></ol>
+          </HowToStep>
+          <HowToStep number={2} title="Block / Unblock">
+            <ol className={ol}><li>Click a seat → <strong>Block</strong> with reason (Maintenance, Reserved, Damaged)</li><li>Optionally set an expiry date; click <strong>Unblock</strong> to release</li></ol>
+          </HowToStep>
+          <HowToStep number={3} title="Bulk Operations">
+            <ol className={ol}><li>Select multiple seats via checkboxes for bulk status changes</li><li>Use <strong>CSV Import</strong> to create/update seats in bulk; <strong>CSV Export</strong> for backup</li></ol>
+          </HowToStep>
+        </div>
+      </div>
+
+      {/* CLASSES */}
+      <div id="classes" className="border-t pt-8">
+        <h2 className="text-2xl font-bold text-slate-900 dark:text-white mb-2">🏷️ Seat Classes</h2>
+        <p className={li}>Define seat class types with base fare, premium fee, and insurance fee. Access level: Supervisor, Admin.</p>
+        <div className="mt-3 overflow-x-auto">
+          <table className="text-xs w-full border-collapse">
+            <thead><tr className="bg-slate-100 dark:bg-slate-700">{['Class','Base Fare','Premium','Insurance','Total/Adult'].map(h=><th key={h} className="text-left px-3 py-2 text-slate-700 dark:text-slate-300">{h}</th>)}</tr></thead>
+            <tbody className="text-slate-600 dark:text-slate-400">
+              <tr><td className="px-3 py-1">Economy Regular</td><td>350 ETB</td><td>0 ETB</td><td>5 ETB</td><td>355 ETB</td></tr>
+              <tr className="bg-slate-50 dark:bg-slate-700/30"><td className="px-3 py-1">Economy Bed</td><td>490 ETB</td><td>50 ETB</td><td>10 ETB</td><td>550 ETB</td></tr>
+              <tr><td className="px-3 py-1">VIP Bed</td><td>630 ETB</td><td>150 ETB</td><td>15 ETB</td><td>795 ETB</td></tr>
+            </tbody>
+          </table>
+        </div>
+      </div>
+      <div id="classes-how" className="border-t pt-8">
+        <h3 className="text-xl font-bold text-slate-900 dark:text-white mb-4">🏷️ How-To: Manage Seat Classes</h3>
+        <div className="space-y-3">
+          <HowToStep number={1} title="Create Class">
+            <ol className={ol}><li>Click <strong>Add Class</strong></li><li>Fill: name, coach type, base fare (ETB), premium fee, insurance fee</li><li>Toggle active and save — changes apply to new bookings only</li></ol>
+          </HowToStep>
+        </div>
+      </div>
+
+      {/* ROUTES */}
+      <div id="routes" className="border-t pt-8">
+        <h2 className="text-2xl font-bold text-slate-900 dark:text-white mb-2">🗺️ Routes</h2>
+        <p className={li}>Define routes as ordered station sequences with cumulative distances. Access level: Supervisor, Admin.</p>
+      </div>
+      <div id="routes-how" className="border-t pt-8">
+        <h3 className="text-xl font-bold text-slate-900 dark:text-white mb-4">🗺️ How-To: Manage Routes</h3>
+        <div className="space-y-3">
+          <HowToStep number={1} title="Create Route">
+            <ol className={ol}><li>Click <strong>Add Route</strong></li><li>Fill: code (e.g. ADD-DJI), name, effective dates, active status</li><li>Add stops: select station, enter distance from previous stop</li></ol>
+          </HowToStep>
+          <HowToStep number={2} title="Edit Stops">
+            <ol className={ol}><li>Reorder stops via drag-and-drop; update distances</li><li>Remove stops only if no bookings exist on that segment</li></ol>
+          </HowToStep>
+        </div>
+      </div>
+
+      {/* SCHEDULES */}
+      <div id="schedules" className="border-t pt-8">
+        <h2 className="text-2xl font-bold text-slate-900 dark:text-white mb-2">📅 Schedules</h2>
+        <p className={li}>Create individual or bulk-generated trip schedules with coach assignments. Access level: Supervisor, Admin.</p>
+      </div>
+      <div id="schedules-how" className="border-t pt-8">
+        <h3 className="text-xl font-bold text-slate-900 dark:text-white mb-4">📅 How-To: Manage Schedules</h3>
+        <div className="space-y-3">
+          <HowToStep number={1} title="Create Single Schedule">
+            <ol className={ol}><li>Click <strong>Create Schedule</strong></li><li>Select train, route, departure/arrival date-time</li><li>Assign coaches (order matters for position numbers)</li></ol>
+          </HowToStep>
+          <HowToStep number={2} title="Bulk Generate">
+            <ol className={ol}><li>Click <strong>Bulk Generate</strong></li><li>Set train, route, start date/time, duration (hrs), repeat interval (days), and period (days)</li><li>Preview count then click <strong>Generate Schedules</strong></li></ol>
+          </HowToStep>
+          <HowToStep number={3} title="Edit / Delete">
+            <ol className={ol}><li>Edit departure/arrival times, status, or coach assignments</li><li>Delete cascades to seat holds and live status records</li><li>Bulk-select rows for multi-delete</li></ol>
+          </HowToStep>
+        </div>
+      </div>
+    </>
+  );
+}
diff --git a/apps/edr-passenger-web/backoffice/src/app/docs/sections/OperationsSection.tsx b/apps/edr-passenger-web/backoffice/src/app/docs/sections/OperationsSection.tsx
new file mode 100644
index 000000000..7c14cc357
--- /dev/null
+++ b/apps/edr-passenger-web/backoffice/src/app/docs/sections/OperationsSection.tsx
@@ -0,0 +1,106 @@
+import { HowToStep } from './_shared';
+
+const li = 'text-sm text-slate-700 dark:text-slate-300';
+const ol = 'list-decimal pl-5 space-y-1 ' + li;
+
+export default function OperationsSection() {
+  return (
+    <>
+      {/* BOOKINGS */}
+      <div id="bookings" className="border-t pt-8">
+        <h2 className="text-2xl font-bold text-slate-900 dark:text-white mb-2">📋 Bookings</h2>
+        <p className={li}>View, search, cancel, and delete passenger bookings. Access level: Agent, Supervisor, Admin.</p>
+      </div>
+      <div id="bookings-how" className="border-t pt-8">
+        <h3 className="text-xl font-bold text-slate-900 dark:text-white mb-4">📋 How-To: Manage Bookings</h3>
+        <div className="space-y-3">
+          <HowToStep number={1} title="Search & Filter">
+            <ol className={ol}><li>Click <strong>Bookings</strong> in Operations</li><li>Use search box for reference, email, or phone</li><li>Filter by status: Pending · Confirmed · Cancelled · Completed</li></ol>
+          </HowToStep>
+          <HowToStep number={2} title="View Details">
+            <ol className={ol}><li>Click <strong>View Details</strong> to open booking modal</li><li>See passenger info, journey, payment, and booking source</li></ol>
+          </HowToStep>
+          <HowToStep number={3} title="Cancel or Delete">
+            <ol className={ol}><li>Click <strong>Cancel Booking</strong> — auto-processes refund (80% confirmed, 0% pending)</li><li>Click <strong>Delete</strong> to permanently remove and release seats</li></ol>
+          </HowToStep>
+        </div>
+      </div>
+
+      {/* PASSENGERS */}
+      <div id="passengers" className="border-t pt-8">
+        <h2 className="text-2xl font-bold text-slate-900 dark:text-white mb-2">👥 Passengers</h2>
+        <p className={li}>View passenger profiles, verification status, loyalty tier, and wallet balance. Access level: Agent, Supervisor, Admin.</p>
+      </div>
+      <div id="passengers-how" className="border-t pt-8">
+        <h3 className="text-xl font-bold text-slate-900 dark:text-white mb-4">👥 How-To: Manage Passengers</h3>
+        <div className="space-y-3">
+          <HowToStep number={1} title="Search Passengers">
+            <ol className={ol}><li>Click <strong>Passengers</strong> in Operations</li><li>Search by name, email, phone, or ID</li><li>Filter by nationality, Verifayda status, or loyalty tier</li></ol>
+          </HowToStep>
+          <HowToStep number={2} title="View Profile">
+            <ol className={ol}><li>Click a passenger row to open profile modal</li><li>Review account info, verification status, loyalty points, wallet balance, and booking history</li></ol>
+          </HowToStep>
+        </div>
+      </div>
+
+      {/* TICKETS */}
+      <div id="tickets" className="border-t pt-8">
+        <h2 className="text-2xl font-bold text-slate-900 dark:text-white mb-2">🎫 Tickets</h2>
+        <p className={li}>View issued tickets, QR/barcode status, and gate validation logs. Access level: Supervisor, Admin.</p>
+      </div>
+      <div id="tickets-how" className="border-t pt-8">
+        <h3 className="text-xl font-bold text-slate-900 dark:text-white mb-4">🎫 How-To: Manage Tickets</h3>
+        <div className="space-y-3">
+          <HowToStep number={1} title="Find a Ticket">
+            <ol className={ol}><li>Click <strong>Tickets</strong> in Operations</li><li>Search by booking reference or passenger name</li><li>Filter by status: Confirmed · Validated · Cancelled</li></ol>
+          </HowToStep>
+          <HowToStep number={2} title="View & Resend">
+            <ol className={ol}><li>Click <strong>View</strong> to see QR/barcode, seat, and fare breakdown</li><li>Download PDF or resend to passenger email</li></ol>
+          </HowToStep>
+          <HowToStep number={3} title="Validation Status">
+            <ol className={ol}><li>Unvalidated: not yet scanned at gate</li><li>Validated: scanned and approved for boarding</li><li>View gate validation logs with timestamp and validator ID</li></ol>
+          </HowToStep>
+        </div>
+      </div>
+
+      {/* BOARDING */}
+      <div id="boarding" className="border-t pt-8">
+        <h2 className="text-2xl font-bold text-slate-900 dark:text-white mb-2">🚆 Boarding</h2>
+        <p className={li}>Manage gate operations and real-time passenger boarding for active trips. Access level: Agent, Supervisor, Admin.</p>
+      </div>
+      <div id="boarding-how" className="border-t pt-8">
+        <h3 className="text-xl font-bold text-slate-900 dark:text-white mb-4">🚆 How-To: Manage Boarding</h3>
+        <div className="space-y-3">
+          <HowToStep number={1} title="Open Boarding Dashboard">
+            <ol className={ol}><li>Click <strong>Boarding</strong> in Operations</li><li>Select the active trip/schedule</li><li>View real-time passenger count and progress</li></ol>
+          </HowToStep>
+          <HowToStep number={2} title="Process Passengers">
+            <ol className={ol}><li>Scan or validate tickets at gate</li><li>Resolve seat conflicts or duplicate assignments</li><li>Mark no-shows and process late arrivals</li></ol>
+          </HowToStep>
+        </div>
+      </div>
+
+      {/* EXCESS BAGGAGE */}
+      <div id="excess-baggage" className="border-t pt-8">
+        <h2 className="text-2xl font-bold text-slate-900 dark:text-white mb-2">📦 Luggage (Excess Baggage)</h2>
+        <p className={li}>Handle excess baggage charges at boarding — passenger self-pay or agent cash collection. Access level: Agent, Supervisor, Admin.</p>
+        <div className="mt-3 flex flex-wrap gap-2 text-xs">
+          {['PENDING','PAID','CASH_COLLECTED','EXPIRED','WAIVED'].map(s => (
+            <span key={s} className="bg-slate-100 dark:bg-slate-700 text-slate-700 dark:text-slate-300 px-2 py-1 rounded font-mono">{s}</span>
+          ))}
+        </div>
+      </div>
+      <div id="excess-baggage-how" className="border-t pt-8">
+        <h3 className="text-xl font-bold text-slate-900 dark:text-white mb-4">📦 How-To: Handle Excess Baggage</h3>
+        <div className="space-y-3">
+          <HowToStep number={1} title="Find Charges">
+            <ol className={ol}><li>Click <strong>Luggage</strong> in Operations</li><li>Search by booking reference; filter by status or date</li></ol>
+          </HowToStep>
+          <HowToStep number={2} title="Take Action">
+            <ol className={ol}><li><strong>Resend Link</strong> — sends fresh 5-min payment link to passenger</li><li><strong>Waive</strong> — enter reason (supervisor authority); logged for audit</li><li><strong>Delete</strong> — only for EXPIRED or WAIVED charges</li></ol>
+          </HowToStep>
+        </div>
+      </div>
+    </>
+  );
+}
diff --git a/apps/edr-passenger-web/backoffice/src/app/docs/sections/OverviewSection.tsx b/apps/edr-passenger-web/backoffice/src/app/docs/sections/OverviewSection.tsx
new file mode 100644
index 000000000..10b011718
--- /dev/null
+++ b/apps/edr-passenger-web/backoffice/src/app/docs/sections/OverviewSection.tsx
@@ -0,0 +1,43 @@
+export default function OverviewSection() {
+  return (
+    <>
+      <div id="about">
+        <h2 className="text-3xl font-bold text-slate-900 dark:text-white mb-4">Welcome to EDR Passenger Backoffice</h2>
+        <p className="text-slate-600 dark:text-slate-300 mb-4">
+          Comprehensive management system for the Ethio-Djibouti Railway passenger platform. Covers bookings, fleet, financials, security, and analytics for agents, supervisors, and admins.
+        </p>
+        <div className="bg-emerald-50 dark:bg-emerald-900/20 p-5 rounded-lg border border-emerald-200 dark:border-emerald-800">
+          <h3 className="text-base font-semibold text-emerald-900 dark:text-emerald-100 mb-2">✅ Version 1.0.0 — Complete Platform</h3>
+          <ul className="text-emerald-800 dark:text-emerald-200 space-y-1 text-sm">
+            <li>• <strong>Roles:</strong> AGENT · SUPERVISOR · ADMIN · STAFF</li>
+            <li>• <strong>Auth:</strong> Corporate IAM (back-office) + JWT (passenger-facing)</li>
+            <li>• <strong>Currencies:</strong> ETB (transaction) · DJF · USD (display)</li>
+            <li>• <strong>Age pricing:</strong> ADULT ≥5 yrs full fare · CHILD &lt;5 yrs first free</li>
+            <li>• <strong>ID verification:</strong> Verifayda 2.0 for Ethiopian nationals</li>
+          </ul>
+        </div>
+      </div>
+
+      <div id="features" className="border-t pt-8">
+        <h2 className="text-2xl font-bold text-slate-900 dark:text-white mb-4">🌟 Key Features</h2>
+        <div className="grid grid-cols-1 sm:grid-cols-2 gap-3 text-sm text-slate-700 dark:text-slate-300">
+          {[
+            ['📊 Operations', 'Bookings, passengers, tickets, boarding, excess baggage'],
+            ['🎒 Tourism', 'Travel packages with tiered pricing and inquiry management'],
+            ['🏢 Master Data', 'Stations, trains, coaches, seats, classes, routes, schedules'],
+            ['💰 Financial', 'Fares, tariffs, payments, currencies, promos, wallets'],
+            ['🎁 Customer Services', 'Loyalty program and notification management'],
+            ['🔒 Security', 'Audit logs and fraud detection'],
+            ['📈 Analytics', 'Revenue, occupancy, and agent performance reports'],
+            ['⚙️ System', 'Agents, users, settings, health monitoring, app releases'],
+          ].map(([title, desc]) => (
+            <div key={title} className="bg-slate-50 dark:bg-slate-700/50 rounded-lg p-3 border border-slate-200 dark:border-slate-600">
+              <div className="font-semibold mb-1">{title}</div>
+              <div className="text-slate-500 dark:text-slate-400">{desc}</div>
+            </div>
+          ))}
+        </div>
+      </div>
+    </>
+  );
+}
diff --git a/apps/edr-passenger-web/backoffice/src/app/docs/sections/SecuritySection.tsx b/apps/edr-passenger-web/backoffice/src/app/docs/sections/SecuritySection.tsx
new file mode 100644
index 000000000..97507752d
--- /dev/null
+++ b/apps/edr-passenger-web/backoffice/src/app/docs/sections/SecuritySection.tsx
@@ -0,0 +1,53 @@
+import { HowToStep } from './_shared';
+
+const li = 'text-sm text-slate-700 dark:text-slate-300';
+const ol = 'list-decimal pl-5 space-y-1 ' + li;
+
+export default function SecuritySection() {
+  return (
+    <>
+      <div id="audit" className="border-t pt-8">
+        <h2 className="text-2xl font-bold text-slate-900 dark:text-white mb-2">📋 Audit Logs</h2>
+        <p className={li}>Immutable log of all user actions — creates, updates, deletes, payments, cancellations, and auth events. Access level: Supervisor, Admin.</p>
+      </div>
+      <div id="audit-how" className="border-t pt-8">
+        <h3 className="text-xl font-bold text-slate-900 dark:text-white mb-4">📋 How-To: Use Audit Logs</h3>
+        <div className="space-y-3">
+          <HowToStep number={1} title="Search & Filter">
+            <ol className={ol}><li>Click <strong>Audit Logs</strong> in Security &amp; Compliance</li><li>Filter by user, action type (Create / Update / Delete), entity type, or date range</li></ol>
+          </HowToStep>
+          <HowToStep number={2} title="View Change Detail">
+            <ol className={ol}><li>Click a log entry to open the detail modal</li><li>Side-by-side old vs new values with highlighted changed fields</li><li>Includes IP address and user-agent</li></ol>
+          </HowToStep>
+          <HowToStep number={3} title="Export">
+            <ol className={ol}><li>Click <strong>Export</strong> — choose CSV, JSON, or PDF</li><li>Apply current filters before exporting for targeted compliance reports</li><li>Logs retained 12 months active, 7 years archived</li></ol>
+          </HowToStep>
+        </div>
+      </div>
+
+      <div id="fraud" className="border-t pt-8">
+        <h2 className="text-2xl font-bold text-slate-900 dark:text-white mb-2">🛡️ Fraud Detection</h2>
+        <p className={li}>Monitor fraud alerts triggered by rules (rapid bookings, high-value transactions, failed payments, duplicate IDs). Access level: Supervisor, Admin.</p>
+        <div className="mt-3 flex flex-wrap gap-2 text-xs">
+          {[['LOW','bg-yellow-100 text-yellow-800'],['MEDIUM','bg-orange-100 text-orange-800'],['HIGH','bg-red-100 text-red-800']].map(([s, cls]) => (
+            <span key={s} className={`${cls} dark:bg-opacity-20 px-2 py-1 rounded font-semibold`}>{s}</span>
+          ))}
+        </div>
+      </div>
+      <div id="fraud-how" className="border-t pt-8">
+        <h3 className="text-xl font-bold text-slate-900 dark:text-white mb-4">🛡️ How-To: Manage Fraud Alerts</h3>
+        <div className="space-y-3">
+          <HowToStep number={1} title="Review Alerts">
+            <ol className={ol}><li>Click <strong>Fraud Detection</strong> in Security &amp; Compliance</li><li>Filter by severity or status (Open / Acknowledged / Resolved)</li><li>Click an alert to see full context, triggering rules, and risk score</li></ol>
+          </HowToStep>
+          <HowToStep number={2} title="Take Action">
+            <ol className={ol}><li><strong>Allow</strong> — booking proceeds; logged for audit</li><li><strong>Block User</strong> — set duration and reason; user cannot book during block period</li><li><strong>Escalate to Admin</strong> — adds to priority review queue</li></ol>
+          </HowToStep>
+          <HowToStep number={3} title="Manage Rules">
+            <ol className={ol}><li>Open <strong>Rules</strong> tab to view all active detection rules</li><li>Click a rule to adjust threshold values or toggle active/inactive</li></ol>
+          </HowToStep>
+        </div>
+      </div>
+    </>
+  );
+}
diff --git a/apps/edr-passenger-web/backoffice/src/app/docs/sections/SystemSection.tsx b/apps/edr-passenger-web/backoffice/src/app/docs/sections/SystemSection.tsx
new file mode 100644
index 000000000..4c73a8d89
--- /dev/null
+++ b/apps/edr-passenger-web/backoffice/src/app/docs/sections/SystemSection.tsx
@@ -0,0 +1,98 @@
+import { HowToStep } from './_shared';
+
+const li = 'text-sm text-slate-700 dark:text-slate-300';
+const ol = 'list-decimal pl-5 space-y-1 ' + li;
+
+export default function SystemSection() {
+  return (
+    <>
+      {/* AGENTS */}
+      <div id="agents" className="border-t pt-8">
+        <h2 className="text-2xl font-bold text-slate-900 dark:text-white mb-2">🧑‍💼 Agents</h2>
+        <p className={li}>Counter booking, shift management, commission tracking, and daily reconciliation. Access level: Supervisor, Admin.</p>
+      </div>
+      <div id="agents-how" className="border-t pt-8">
+        <h3 className="text-xl font-bold text-slate-900 dark:text-white mb-4">🧑‍💼 How-To: Agent Operations</h3>
+        <div className="space-y-3">
+          <HowToStep number={1} title="Create Counter Booking">
+            <ol className={ol}><li>Click <strong>Agents</strong> in System → <strong>New Booking</strong></li><li>Select schedule, seats, passengers, and seat class</li><li>Choose payment method (Cash / Card / Check); enter amount received</li><li>Click <strong>Create Booking</strong> — prints or emails ticket</li></ol>
+          </HowToStep>
+          <HowToStep number={2} title="Manage Shifts">
+            <ol className={ol}><li><strong>Open Shift</strong> — enter opening cash balance</li><li><strong>Close Shift</strong> — enter closing balance; system calculates variance</li><li>View shift summary: total bookings, revenue, commission earned</li></ol>
+          </HowToStep>
+        </div>
+      </div>
+
+      {/* USERS */}
+      <div id="users" className="border-t pt-8">
+        <h2 className="text-2xl font-bold text-slate-900 dark:text-white mb-2">👤 Users</h2>
+        <p className={li}>Manage back-office user accounts and role assignments. Roles: AGENT · SUPERVISOR · ADMIN · STAFF. Access level: Admin.</p>
+      </div>
+      <div id="users-how" className="border-t pt-8">
+        <h3 className="text-xl font-bold text-slate-900 dark:text-white mb-4">👤 How-To: Manage Users</h3>
+        <div className="space-y-3">
+          <HowToStep number={1} title="Create User">
+            <ol className={ol}><li>Click <strong>Users</strong> in System → <strong>Add User</strong></li><li>Fill: email, full name, phone, role, department</li><li>Save — temporary password emailed to user automatically</li></ol>
+          </HowToStep>
+          <HowToStep number={2} title="Edit / Reset Password">
+            <ol className={ol}><li>Click a user row to open profile modal</li><li>Update name, role, or department; toggle active status</li><li>Click <strong>Reset Password</strong> to generate and email a new temporary password</li></ol>
+          </HowToStep>
+          <HowToStep number={3} title="Deactivate / Delete">
+            <ol className={ol}><li><strong>Deactivate</strong> — keeps records, disables login (preferred)</li><li><strong>Delete</strong> — permanently removes user</li></ol>
+          </HowToStep>
+        </div>
+      </div>
+
+      {/* SETTINGS */}
+      <div id="settings" className="border-t pt-8">
+        <h2 className="text-2xl font-bold text-slate-900 dark:text-white mb-2">⚙️ Settings</h2>
+        <p className={li}>Configure application-wide settings: general, email (SMTP), payment provider credentials, API integrations, and rate limits. Access level: Admin.</p>
+      </div>
+      <div id="settings-how" className="border-t pt-8">
+        <h3 className="text-xl font-bold text-slate-900 dark:text-white mb-4">⚙️ How-To: Manage Settings</h3>
+        <div className="space-y-3">
+          <HowToStep number={1} title="Update Configuration">
+            <ol className={ol}><li>Click <strong>Settings</strong> in System</li><li>Select category tab: General · Email · Payments · API</li><li>Modify values, test connections where applicable, then <strong>Save</strong></li><li>Changes take effect immediately and are audit-logged</li></ol>
+          </HowToStep>
+          <HowToStep number={2} title="Rate Limiting (System Config)">
+            <ol className={ol}><li>Auth endpoints default: 5 req/min</li><li>Strict endpoints (bookings, payments, wallet) default: 20 req/min</li><li>Default endpoints: 100 req/min · Health/webhooks: exempt</li><li>Seat hold duration default: 5 min · Hold cutoff before departure: 2 hrs</li></ol>
+          </HowToStep>
+        </div>
+      </div>
+
+      {/* HEALTH */}
+      <div id="health" className="border-t pt-8">
+        <h2 className="text-2xl font-bold text-slate-900 dark:text-white mb-2">🏥 Health</h2>
+        <p className={li}>Real-time API health dashboard — liveness, readiness (DB latency), and app info. Auto-refreshes every 30–60 s. Access level: Admin, Supervisor.</p>
+      </div>
+      <div id="health-how" className="border-t pt-8">
+        <h3 className="text-xl font-bold text-slate-900 dark:text-white mb-4">🏥 How-To: Monitor Health</h3>
+        <div className="space-y-3">
+          <HowToStep number={1} title="Read the Dashboard">
+            <ol className={ol}><li>Click <strong>Health</strong> in System</li><li>Green banner = all systems operational; Red = degraded</li><li>Liveness probe: API process alive (30 s) · Readiness: DB ping + latency (30 s) · App Info: version, uptime (60 s)</li></ol>
+          </HowToStep>
+          <HowToStep number={2} title="Troubleshoot">
+            <ol className={ol}><li>Red readiness: check DB server and connection string</li><li>High latency: review slow queries and server resources</li><li>Click <strong>Refresh</strong> for an immediate manual check</li></ol>
+          </HowToStep>
+        </div>
+      </div>
+
+      {/* APP RELEASES */}
+      <div id="app-releases" className="border-t pt-8">
+        <h2 className="text-2xl font-bold text-slate-900 dark:text-white mb-2">📱 App Releases</h2>
+        <p className={li}>Manage mobile app release notes and version announcements shown to passengers. Access level: Admin.</p>
+      </div>
+      <div id="app-releases-how" className="border-t pt-8">
+        <h3 className="text-xl font-bold text-slate-900 dark:text-white mb-4">📱 How-To: Manage App Releases</h3>
+        <div className="space-y-3">
+          <HowToStep number={1} title="Create Release">
+            <ol className={ol}><li>Click <strong>App Releases</strong> in System → <strong>New Release</strong></li><li>Fill: version number, platform (iOS / Android / Both), release notes, release date</li><li>Toggle <strong>Force Update</strong> if the release is mandatory</li><li>Save to publish the announcement</li></ol>
+          </HowToStep>
+          <HowToStep number={2} title="Edit / Delete">
+            <ol className={ol}><li>Click <strong>Edit</strong> to update notes or toggle force-update flag</li><li>Click <strong>Delete</strong> to remove an outdated release entry</li></ol>
+          </HowToStep>
+        </div>
+      </div>
+    </>
+  );
+}
diff --git a/apps/edr-passenger-web/backoffice/src/app/docs/sections/TourismSection.tsx b/apps/edr-passenger-web/backoffice/src/app/docs/sections/TourismSection.tsx
new file mode 100644
index 000000000..415fa5d1d
--- /dev/null
+++ b/apps/edr-passenger-web/backoffice/src/app/docs/sections/TourismSection.tsx
@@ -0,0 +1,83 @@
+import { HowToStep } from './_shared';
+
+const li = 'text-sm text-slate-700 dark:text-slate-300';
+const ol = 'list-decimal pl-5 space-y-1 ' + li;
+
+export default function TourismSection() {
+  return (
+    <>
+      {/* PACKAGES */}
+      <div id="packages" className="border-t pt-8">
+        <h2 className="text-2xl font-bold text-slate-900 dark:text-white mb-2">🎒 Travel Packages</h2>
+        <p className={li}>Create and manage pilgrimage/group travel packages with tiered pricing and capacity control. Access level: Supervisor, Admin.</p>
+        <div className="mt-3 flex flex-wrap gap-2 text-xs">
+          {['DRAFT','ACTIVE','SOLD_OUT','EXPIRED','CANCELLED'].map(s => (
+            <span key={s} className="bg-slate-100 dark:bg-slate-700 text-slate-700 dark:text-slate-300 px-2 py-1 rounded font-mono">{s}</span>
+          ))}
+        </div>
+      </div>
+      <div id="packages-how" className="border-t pt-8">
+        <h3 className="text-xl font-bold text-slate-900 dark:text-white mb-4">🎒 How-To: Manage Travel Packages</h3>
+        <div className="space-y-3">
+          <HowToStep number={1} title="Create a Package">
+            <ol className={ol}>
+              <li>Click <strong>New Package</strong></li>
+              <li>Fill: code, name, origin/destination stations, outbound/return schedules</li>
+              <li>Set total capacity, validity period, included services, and optional bus transfer</li>
+              <li>Save — package starts in <strong>DRAFT</strong> status</li>
+            </ol>
+          </HowToStep>
+          <HowToStep number={2} title="Configure Price Tiers">
+            <ol className={ol}>
+              <li>Click <strong>Tiers</strong> on the package row</li>
+              <li>Add tiers: seat type, label, price (minor units), available seats</li>
+              <li>Edit or delete tiers (restricted once bookings exist)</li>
+            </ol>
+          </HowToStep>
+          <HowToStep number={3} title="Activate / Deactivate">
+            <ol className={ol}>
+              <li>Click <strong>Activate</strong> on a DRAFT package to open for booking</li>
+              <li>Click <strong>Deactivate</strong> to stop new bookings (existing bookings remain valid)</li>
+              <li>Click <strong>Delete</strong> only if no bookings exist</li>
+            </ol>
+          </HowToStep>
+        </div>
+      </div>
+
+      {/* PACKAGE INQUIRIES */}
+      <div id="package-inquiries" className="border-t pt-8">
+        <h2 className="text-2xl font-bold text-slate-900 dark:text-white mb-2">📝 Package Inquiries</h2>
+        <p className={li}>Track and convert incoming package booking inquiries. Access level: Agent, Supervisor, Admin.</p>
+        <div className="mt-3 flex flex-wrap gap-2 text-xs">
+          {['NEW','CONTACTED','CONVERTED','CLOSED'].map(s => (
+            <span key={s} className="bg-slate-100 dark:bg-slate-700 text-slate-700 dark:text-slate-300 px-2 py-1 rounded font-mono">{s}</span>
+          ))}
+        </div>
+      </div>
+      <div id="package-inquiries-how" className="border-t pt-8">
+        <h3 className="text-xl font-bold text-slate-900 dark:text-white mb-4">📝 How-To: Handle Inquiries</h3>
+        <div className="space-y-3">
+          <HowToStep number={1} title="View & Filter">
+            <ol className={ol}>
+              <li>Click <strong>Inquiries</strong> in Tourism</li>
+              <li>Filter by package or status</li>
+              <li>View contact details, requested tier, and traveler count</li>
+            </ol>
+          </HowToStep>
+          <HowToStep number={2} title="Update Status">
+            <ol className={ol}>
+              <li>Use the status dropdown on each row — saves immediately</li>
+              <li>Workflow: <strong>NEW → CONTACTED → CONVERTED / CLOSED</strong></li>
+              <li>Respond to NEW inquiries within 24 hours</li>
+            </ol>
+          </HowToStep>
+          <HowToStep number={3} title="Clean Up">
+            <ol className={ol}>
+              <li>Click <strong>Delete</strong> to remove spam or duplicate inquiries</li>
+            </ol>
+          </HowToStep>
+        </div>
+      </div>
+    </>
+  );
+}
diff --git a/apps/edr-passenger-web/backoffice/src/app/docs/sections/_shared.tsx b/apps/edr-passenger-web/backoffice/src/app/docs/sections/_shared.tsx
new file mode 100644
index 000000000..aa7051063
--- /dev/null
+++ b/apps/edr-passenger-web/backoffice/src/app/docs/sections/_shared.tsx
@@ -0,0 +1,95 @@
+import React from 'react';
+
+export const HowToStep = ({ number, title, children }: { number: number; title: string; children: React.ReactNode }) => (
+  <div className="bg-blue-50 dark:bg-blue-900/20 p-5 rounded-lg border border-blue-200 dark:border-blue-800">
+    <div className="flex items-start gap-4">
+      <div className="flex items-center justify-center w-9 h-9 rounded-full bg-blue-600 text-white font-bold flex-shrink-0 text-sm">{number}</div>
+      <div className="flex-1">
+        <h4 className="text-base font-semibold text-slate-900 dark:text-white mb-2">{title}</h4>
+        {children}
+      </div>
+    </div>
+  </div>
+);
+
+export const navSections = [
+  {
+    id: 'overview', title: '📋 Overview',
+    items: [
+      { id: 'about', label: 'Application Overview' },
+      { id: 'features', label: 'Key Features' },
+    ],
+  },
+  {
+    id: 'operations', title: '📊 Operations',
+    items: [
+      { id: 'bookings', label: 'Bookings' }, { id: 'bookings-how', label: '→ How-To' },
+      { id: 'passengers', label: 'Passengers' }, { id: 'passengers-how', label: '→ How-To' },
+      { id: 'tickets', label: 'Tickets' }, { id: 'tickets-how', label: '→ How-To' },
+      { id: 'boarding', label: 'Boarding' }, { id: 'boarding-how', label: '→ How-To' },
+      { id: 'excess-baggage', label: 'Luggage (Excess)' }, { id: 'excess-baggage-how', label: '→ How-To' },
+    ],
+  },
+  {
+    id: 'tourism', title: '🎒 Tourism',
+    items: [
+      { id: 'packages', label: 'Travel Packages' }, { id: 'packages-how', label: '→ How-To' },
+      { id: 'package-inquiries', label: 'Inquiries' }, { id: 'package-inquiries-how', label: '→ How-To' },
+    ],
+  },
+  {
+    id: 'masterdata', title: '🏢 Master Data',
+    items: [
+      { id: 'stations', label: 'Stations' }, { id: 'stations-how', label: '→ How-To' },
+      { id: 'trains', label: 'Trains' }, { id: 'trains-how', label: '→ How-To' },
+      { id: 'coaches', label: 'Coaches' }, { id: 'coaches-how', label: '→ How-To' },
+      { id: 'seats', label: 'Seats' }, { id: 'seats-how', label: '→ How-To' },
+      { id: 'classes', label: 'Seat Classes' }, { id: 'classes-how', label: '→ How-To' },
+      { id: 'routes', label: 'Routes' }, { id: 'routes-how', label: '→ How-To' },
+      { id: 'schedules', label: 'Schedules' }, { id: 'schedules-how', label: '→ How-To' },
+    ],
+  },
+  {
+    id: 'financial', title: '💰 Financial',
+    items: [
+      { id: 'pricing', label: 'Pricing & Fares' }, { id: 'pricing-how', label: '→ How-To' },
+      { id: 'tariff-rates', label: 'Tariff Rates' }, { id: 'tariff-rates-how', label: '→ How-To' },
+      { id: 'fare-rules', label: 'Fare Rules' }, { id: 'fare-rules-how', label: '→ How-To' },
+      { id: 'payments', label: 'Payments' }, { id: 'payments-how', label: '→ How-To' },
+      { id: 'currencies', label: 'Currencies' }, { id: 'currencies-how', label: '→ How-To' },
+      { id: 'promos', label: 'Promo Codes' }, { id: 'promos-how', label: '→ How-To' },
+      { id: 'payment-methods', label: 'Payment Methods' }, { id: 'payment-methods-how', label: '→ How-To' },
+      { id: 'wallet-accounts', label: 'Wallet Accounts' }, { id: 'wallet-accounts-how', label: '→ How-To' },
+    ],
+  },
+  {
+    id: 'services', title: '🎁 Customer Services',
+    items: [
+      { id: 'loyalty', label: 'Loyalty Program' }, { id: 'loyalty-how', label: '→ How-To' },
+      { id: 'notifications', label: 'Notifications' }, { id: 'notifications-how', label: '→ How-To' },
+    ],
+  },
+  {
+    id: 'security', title: '🔒 Security',
+    items: [
+      { id: 'audit', label: 'Audit Logs' }, { id: 'audit-how', label: '→ How-To' },
+      { id: 'fraud', label: 'Fraud Detection' }, { id: 'fraud-how', label: '→ How-To' },
+    ],
+  },
+  {
+    id: 'analytics', title: '📈 Analytics',
+    items: [
+      { id: 'reports', label: 'Reports' }, { id: 'reports-how', label: '→ How-To' },
+    ],
+  },
+  {
+    id: 'system', title: '⚙️ System',
+    items: [
+      { id: 'agents', label: 'Agents' }, { id: 'agents-how', label: '→ How-To' },
+      { id: 'users', label: 'Users' }, { id: 'users-how', label: '→ How-To' },
+      { id: 'settings', label: 'Settings' }, { id: 'settings-how', label: '→ How-To' },
+      { id: 'health', label: 'Health' }, { id: 'health-how', label: '→ How-To' },
+      { id: 'app-releases', label: 'App Releases' }, { id: 'app-releases-how', label: '→ How-To' },
+    ],
+  },
+];
diff --git a/apps/edr-passenger-web/backoffice/src/app/fare-management/page.tsx b/apps/edr-passenger-web/backoffice/src/app/fare-management/page.tsx
index fdd61ef19..860874883 100644
--- a/apps/edr-passenger-web/backoffice/src/app/fare-management/page.tsx
+++ b/apps/edr-passenger-web/backoffice/src/app/fare-management/page.tsx
@@ -107,7 +107,7 @@ export default function FareManagementPage() {
       render: (r: any) => <span className="text-sm">{r.nationality || 'All'}</span>,
     },
     {
-      key: 'baseFareMinor', label: 'Base Fare (ETB)',
+      key: 'baseFareMinor', label: 'Base Fare',
       render: (r: any) => <span className="font-mono">{(r.baseFareMinor / 100).toFixed(2)}</span>,
     },
     {
@@ -214,7 +214,7 @@ export default function FareManagementPage() {
               </select>
             </div>
             <div>
-              <label className="label">Base Fare (ETB) *</label>
+              <label className="label">Base Fare *</label>
               <input type="number" name="baseFareMinor" className="input" min="0" step="0.01"
                 defaultValue={editingRule ? (editingRule.baseFareMinor / 100).toFixed(2) : ''} required
                 placeholder="e.g. 350.00" />
diff --git a/apps/edr-passenger-web/backoffice/src/app/layout.tsx b/apps/edr-passenger-web/backoffice/src/app/layout.tsx
index 23838f62c..b302ee74d 100644
--- a/apps/edr-passenger-web/backoffice/src/app/layout.tsx
+++ b/apps/edr-passenger-web/backoffice/src/app/layout.tsx
@@ -1,4 +1,5 @@
 import type { Metadata } from 'next';
+import { headers } from 'next/headers';
 import '@/styles/globals.css';
 import Providers from './providers';
 
@@ -12,10 +13,13 @@ export default function RootLayout({
 }: {
   children: React.ReactNode;
 }) {
+  // Nonce set per-request by middleware; required for this inline script under the CSP.
+  const nonce = headers().get('x-nonce') ?? undefined;
   return (
     <html lang="en" suppressHydrationWarning>
       <head>
         <script
+          nonce={nonce}
           dangerouslySetInnerHTML={{
             __html: `
               (function() {
diff --git a/apps/edr-passenger-web/backoffice/src/app/loyalty/page.tsx b/apps/edr-passenger-web/backoffice/src/app/loyalty/page.tsx
index 7fbfffbf0..dcfc04841 100644
--- a/apps/edr-passenger-web/backoffice/src/app/loyalty/page.tsx
+++ b/apps/edr-passenger-web/backoffice/src/app/loyalty/page.tsx
@@ -1,12 +1,12 @@
 'use client';
 
 import { useState } from 'react';
-import { useQuery } from '@tanstack/react-query';
-import { Download, Eye, Star } from 'lucide-react';
+import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
+import { Download, Eye, Star, Trash2 } from 'lucide-react';
 import DataTable from '@/components/ui/DataTable';
-import Badge from '@/components/ui/Badge';
 import ActionButton from '@/components/ui/ActionButton';
 import Modal from '@/components/ui/Modal';
+import ConfirmDialog from '@/components/ui/ConfirmDialog';
 import { loyaltyApi } from '@/lib/api';
 import { formatDateTime } from '@/lib/utils';
 
@@ -40,12 +40,25 @@ const TIER_GRAD: Record<string, string> = {
 export default function LoyaltyPage() {
   const [filters, setFilters] = useState({ search: '', tier: '' });
   const [selected, setSelected] = useState<any>(null);
+  const [toDelete, setToDelete] = useState<any>(null);
+  const [deleteError, setDeleteError] = useState('');
+  const queryClient = useQueryClient();
 
   const { data, isLoading } = useQuery({
     queryKey: ['loyalty', filters],
     queryFn: () => loyaltyApi.getAccounts(filters),
   });
 
+  const deleteMutation = useMutation({
+    mutationFn: (id: string) => loyaltyApi.delete(id),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ['loyalty'] });
+      setToDelete(null);
+      setDeleteError('');
+    },
+    onError: (err: any) => setDeleteError(err?.message || 'Failed to delete loyalty account'),
+  });
+
   const columns = [
     { key: 'passenger', label: 'Passenger', render: (account: any) => (
       <div>
@@ -64,6 +77,7 @@ export default function LoyaltyPage() {
 
   const actions = [
     { label: 'View Details', onClick: (a: any) => setSelected(a), variant: 'secondary' as const, icon: Eye },
+    { label: 'Delete', onClick: (a: any) => { setDeleteError(''); setToDelete(a); }, variant: 'danger' as const, icon: Trash2 },
   ];
 
   return (
@@ -103,6 +117,19 @@ export default function LoyaltyPage() {
         emptyMessage="No loyalty accounts found"
       />
 
+      {/* Delete Confirm Dialog */}
+      <ConfirmDialog
+        isOpen={!!toDelete}
+        onClose={() => { setToDelete(null); setDeleteError(''); }}
+        onConfirm={() => deleteMutation.mutate(toDelete.id)}
+        title="Delete Loyalty Account"
+        message={`Are you sure you want to delete the loyalty account for ${toDelete?.passenger?.fullName || 'this passenger'}? This will permanently remove all points, ledger entries, and rewards.`}
+        confirmText="Delete"
+        isDanger
+        isLoading={deleteMutation.isPending}
+        error={deleteError}
+      />
+
       {/* Loyalty Details Modal */}
       <Modal isOpen={!!selected} onClose={() => setSelected(null)} title="Loyalty Account Details" size="xl">
         {selected && (() => {
diff --git a/apps/edr-passenger-web/backoffice/src/app/package-bookings/layout.tsx b/apps/edr-passenger-web/backoffice/src/app/package-bookings/layout.tsx
new file mode 100644
index 000000000..68677e174
--- /dev/null
+++ b/apps/edr-passenger-web/backoffice/src/app/package-bookings/layout.tsx
@@ -0,0 +1,7 @@
+'use client';
+
+import DashboardLayout from '../dashboard/layout';
+
+export default function PackageBookingsLayout({ children }: { children: React.ReactNode }) {
+  return <DashboardLayout>{children}</DashboardLayout>;
+}
diff --git a/apps/edr-passenger-web/backoffice/src/app/package-bookings/page.tsx b/apps/edr-passenger-web/backoffice/src/app/package-bookings/page.tsx
new file mode 100644
index 000000000..2912eeee3
--- /dev/null
+++ b/apps/edr-passenger-web/backoffice/src/app/package-bookings/page.tsx
@@ -0,0 +1,255 @@
+'use client';
+
+import { useState } from 'react';
+import { useQuery } from '@tanstack/react-query';
+import { Eye } from 'lucide-react';
+import DataTable from '@/components/ui/DataTable';
+import Badge from '@/components/ui/Badge';
+import ActionButton from '@/components/ui/ActionButton';
+import Modal from '@/components/ui/Modal';
+import Pagination from '@/components/ui/Pagination';
+import { packagesApi } from '@/lib/api';
+import { formatDateTime, formatCurrency } from '@/lib/utils';
+
+const Field = ({ label, value, mono = false, truncate = false }: { label: string; value: string; mono?: boolean; truncate?: boolean }) => (
+  <div className="bg-muted/40 rounded-lg p-3">
+    <p className="text-xs text-muted-foreground mb-1">{label}</p>
+    <p className={`text-sm font-semibold text-foreground${mono ? ' font-mono' : ''}${truncate ? ' truncate' : ''}`} title={value}>{value || '—'}</p>
+  </div>
+);
+
+const SectionHeader = ({ title }: { title: string }) => (
+  <h3 className="text-xs font-bold uppercase tracking-widest text-muted-foreground mb-3 flex items-center gap-2">
+    <span className="w-4 h-px bg-muted-foreground/40 inline-block" />{title}
+  </h3>
+);
+
+export default function PackageBookingsPage() {
+  const [filters, setFilters] = useState({ packageId: '', status: '', page: 1, pageSize: 20 });
+  const [selected, setSelected] = useState<any>(null);
+
+  const { data: rawData, isLoading, error } = useQuery({
+    queryKey: ['package-bookings', filters],
+    queryFn: () => packagesApi.getBookings(filters),
+  });
+
+  // Unwrap in case the interceptor double-wraps: { data: { items, ... } } or { items, ... }
+  const data: any = (rawData as any)?.items ? rawData : (rawData as any)?.data ?? rawData;
+
+  const { data: packagesData } = useQuery({
+    queryKey: ['packages-all-simple'],
+    queryFn: () => packagesApi.getAll({ pageSize: 100 }),
+  });
+
+  const packages: any[] = packagesData?.items || [];
+
+  const columns = [
+    {
+      key: 'bookingRef',
+      label: 'Reference',
+      sortable: true,
+      render: (b: any) => (
+        <div>
+          <div className="font-mono font-semibold flex items-center gap-1.5">
+            {b.bookingRef}
+            <span className="inline-flex items-center bg-emerald-100 dark:bg-emerald-900/40 text-emerald-700 dark:text-emerald-400 text-xs font-semibold px-1.5 py-0.5 rounded">PKG</span>
+          </div>
+          <div className="text-xs text-muted-foreground">{b.package?.name}</div>
+        </div>
+      ),
+    },
+    {
+      key: 'tier',
+      label: 'Tier',
+      render: (b: any) => b.priceTier ? (
+        <div>
+          <div className="text-sm font-medium">{b.priceTier.label}</div>
+          <div className="text-xs text-muted-foreground">{b.priceTier.seatType}</div>
+        </div>
+      ) : <span className="text-muted-foreground">—</span>,
+    },
+    {
+      key: 'passengers',
+      label: 'Passengers',
+      render: (b: any) => (
+        <div>
+          <div className="font-semibold">{b.passengerCount}</div>
+          <div className="text-xs text-muted-foreground">{b.contactPhone || b.contactEmail || '—'}</div>
+        </div>
+      ),
+    },
+    {
+      key: 'payment',
+      label: 'Payment',
+      render: (b: any) => (
+        <div>
+          <Badge variant="status" status={b.paymentIntent?.status || 'PENDING'}>
+            {b.paymentIntent?.status || 'PENDING'}
+          </Badge>
+          <div className="text-xs text-muted-foreground mt-1">{formatCurrency(b.totalMinor, b.currency || 'ETB')}</div>
+        </div>
+      ),
+    },
+    {
+      key: 'status',
+      label: 'Status',
+      render: (b: any) => <Badge variant="status" status={b.status}>{b.status}</Badge>,
+    },
+    {
+      key: 'createdAt',
+      label: 'Booked At',
+      render: (b: any) => <span className="text-sm text-muted-foreground">{formatDateTime(b.createdAt)}</span>,
+    },
+  ];
+
+  const actions = [
+    { label: 'View', onClick: (b: any) => setSelected(b), variant: 'secondary' as const, icon: Eye },
+  ];
+
+  return (
+    <div className="space-y-6">
+      <div>
+        <h1 className="text-2xl font-bold text-foreground">Package Bookings</h1>
+        <p className="text-muted-foreground">All bookings made through travel packages</p>
+      </div>
+
+      <div className="card">
+        {error && (
+          <div className="mb-4 rounded-lg bg-red-50 dark:bg-red-900/20 p-4 text-sm text-red-800 dark:text-red-200">
+            Error: {(error as any)?.response?.data?.message || (error as any)?.message || String(error)}
+          </div>
+        )}
+        <div className="flex flex-wrap gap-3 mb-4">
+          <div className="flex-1 min-w-48">
+            <select className="input" value={filters.packageId}
+              onChange={(e) => setFilters({ ...filters, packageId: e.target.value, page: 1 })}>
+              <option value="">All Packages</option>
+              {packages.map((p: any) => (
+                <option key={p.id} value={p.id}>{p.name} ({p.code})</option>
+              ))}
+            </select>
+          </div>
+          <select className="input w-48" value={filters.status}
+            onChange={(e) => setFilters({ ...filters, status: e.target.value, page: 1 })}>
+            <option value="">All Statuses</option>
+            <option value="PENDING_PAYMENT">Pending Payment</option>
+            <option value="CONFIRMED">Confirmed</option>
+            <option value="CANCELLED">Cancelled</option>
+          </select>
+        </div>
+        <DataTable data={data?.items || []} columns={columns} actions={actions} loading={isLoading} emptyMessage="No package bookings found" />
+        {data?.totalPages > 1 && (
+          <Pagination currentPage={filters.page} totalPages={data.totalPages}
+            onPageChange={(page) => setFilters({ ...filters, page })} />
+        )}
+      </div>
+
+      <Modal isOpen={!!selected} onClose={() => setSelected(null)} title="Package Booking Details" size="xl">
+        {selected && (() => {
+          const b = selected;
+          return (
+            <div>
+              <div className="-mx-6 -mt-4 mb-6 px-6 py-5 bg-gradient-to-r from-emerald-600 to-emerald-700 rounded-t-lg">
+                <div className="flex items-start justify-between gap-4">
+                  <div>
+                    <p className="text-emerald-100 text-xs font-semibold uppercase tracking-widest mb-1">Booking Reference</p>
+                    <p className="text-white text-3xl font-mono font-bold tracking-wider">{b.bookingRef}</p>
+                  </div>
+                  <div className="text-right shrink-0">
+                    <Badge variant="status" status={b.status}>{b.status}</Badge>
+                    <p className="text-emerald-200 text-xs mt-2">{formatDateTime(b.createdAt)}</p>
+                  </div>
+                </div>
+                <div className="mt-4 flex flex-wrap gap-2">
+                  {[b.package?.name, b.priceTier?.label, `${b.passengerCount} passenger${b.passengerCount !== 1 ? 's' : ''}`].filter(Boolean).map((tag) => (
+                    <span key={tag} className="inline-flex items-center gap-1.5 bg-white/20 text-white text-xs font-medium px-3 py-1 rounded-full">
+                      <span className="w-1.5 h-1.5 rounded-full bg-emerald-200" />{tag}
+                    </span>
+                  ))}
+                </div>
+              </div>
+
+              <div className="space-y-6">
+                <section>
+                  <SectionHeader title="Package" />
+                  <div className="grid grid-cols-2 md:grid-cols-4 gap-3">
+                    <Field label="Package Name" value={b.package?.name} />
+                    <Field label="Package Code" value={b.package?.code} mono />
+                    <Field label="Tier" value={b.priceTier?.label} />
+                    <Field label="Seat Type" value={b.priceTier?.seatType} />
+                  </div>
+                </section>
+
+                <section>
+                  <SectionHeader title="Contact" />
+                  <div className="grid grid-cols-2 md:grid-cols-4 gap-3">
+                    <Field label="Email" value={b.contactEmail} truncate />
+                    <Field label="Phone" value={b.contactPhone} />
+                    <Field label="Promo Code" value={b.promoCode || 'None'} />
+                    <Field label="Passenger ID" value={b.passengerId || 'Guest'} mono truncate />
+                  </div>
+                </section>
+
+                <section>
+                  <SectionHeader title="Payment" />
+                  <div className="grid grid-cols-2 md:grid-cols-4 gap-3">
+                    <div className="bg-emerald-50 dark:bg-emerald-900/20 border border-emerald-100 dark:border-emerald-800 rounded-lg p-3 col-span-2">
+                      <p className="text-xs text-emerald-700 dark:text-emerald-400 mb-1">Total Amount</p>
+                      <p className="text-xl font-bold text-emerald-800 dark:text-emerald-300">{formatCurrency(b.totalMinor, b.currency || 'ETB')}</p>
+                      {b.displayCurrency && b.displayCurrency !== (b.currency || 'ETB') && (
+                        <p className="text-xs text-emerald-600 dark:text-emerald-500 mt-0.5">
+                          ≈ {formatCurrency(b.displayTotalMinor ?? b.totalMinor, b.displayCurrency)}
+                        </p>
+                      )}
+                    </div>
+                    <div className="bg-muted/40 rounded-lg p-3">
+                      <p className="text-xs text-muted-foreground mb-2">Payment Status</p>
+                      <Badge variant="status" status={b.paymentIntent?.status || 'PENDING'}>{b.paymentIntent?.status || 'PENDING'}</Badge>
+                    </div>
+                    <Field label="Method" value={b.paymentIntent?.method || '—'} />
+                  </div>
+                </section>
+
+                {b.passengers?.length > 0 && (
+                  <section>
+                    <SectionHeader title={`Passengers (${b.passengers.length})`} />
+                    <div className="divide-y divide-muted rounded-lg border border-muted overflow-hidden">
+                      {b.passengers.map((p: any, i: number) => (
+                        <div key={i} className="flex items-center justify-between px-4 py-3 bg-muted/20 hover:bg-muted/40 transition-colors">
+                          <div className="flex items-center gap-3">
+                            <span className="w-6 h-6 rounded-full bg-emerald-100 dark:bg-emerald-900/40 text-emerald-700 dark:text-emerald-400 text-xs font-bold flex items-center justify-center shrink-0">{i + 1}</span>
+                            <div>
+                              <p className="text-sm font-semibold">{p.passengerName}</p>
+                              <p className="text-xs text-muted-foreground">
+                                {p.dateOfBirth ? new Date(p.dateOfBirth).toLocaleDateString() : ''}
+                                {p.idDocumentType ? ` · ${p.idDocumentType}` : ''}
+                                {p.passportNumber ? ` · ${p.passportNumber}` : ''}
+                              </p>
+                            </div>
+                          </div>
+                        </div>
+                      ))}
+                    </div>
+                  </section>
+                )}
+
+                <section>
+                  <SectionHeader title="Timestamps" />
+                  <div className="grid grid-cols-2 md:grid-cols-3 gap-3">
+                    <Field label="Created" value={formatDateTime(b.createdAt)} />
+                    <Field label="Last Updated" value={formatDateTime(b.updatedAt)} />
+                    <Field label="Booking ID" value={b.id} mono truncate />
+                  </div>
+                </section>
+              </div>
+
+              <div className="flex justify-end gap-2 pt-6 mt-2 border-t border-muted">
+                <ActionButton variant="secondary" onClick={() => setSelected(null)}>Close</ActionButton>
+              </div>
+            </div>
+          );
+        })()}
+      </Modal>
+    </div>
+  );
+}
diff --git a/apps/edr-passenger-web/backoffice/src/app/payments/page.tsx b/apps/edr-passenger-web/backoffice/src/app/payments/page.tsx
index 8bd4400cc..30639e82d 100644
--- a/apps/edr-passenger-web/backoffice/src/app/payments/page.tsx
+++ b/apps/edr-passenger-web/backoffice/src/app/payments/page.tsx
@@ -1,13 +1,14 @@
 'use client';
 
 import { useState } from 'react';
-import { useQuery } from '@tanstack/react-query';
-import { Download, Eye } from 'lucide-react';
+import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
+import { Download, Eye, Trash2 } from 'lucide-react';
 import DataTable from '@/components/ui/DataTable';
 import Badge from '@/components/ui/Badge';
 import ActionButton from '@/components/ui/ActionButton';
 import Modal from '@/components/ui/Modal';
-import { paymentsApi } from '@/lib/api';
+import ConfirmDialog from '@/components/ui/ConfirmDialog';
+import { paymentsApi, apiClient } from '@/lib/api';
 import { formatDateTime, formatCurrency } from '@/lib/utils';
 
 const Field = ({ label, value, mono = false, truncate = false }: { label: string; value: string; mono?: boolean; truncate?: boolean }) => (
@@ -26,6 +27,10 @@ const SectionHeader = ({ title }: { title: string }) => (
 export default function PaymentsPage() {
   const [filters, setFilters] = useState({ search: '', status: '', method: '' });
   const [selectedPayment, setSelectedPayment] = useState<any>(null);
+  const [deleteConfirmOpen, setDeleteConfirmOpen] = useState(false);
+  const [paymentToDelete, setPaymentToDelete] = useState<any>(null);
+  const [deleteError, setDeleteError] = useState<string | null>(null);
+  const [successMessage, setSuccessMessage] = useState('');
   const [exportModalOpen, setExportModalOpen] = useState(false);
   const [exportDateFrom, setExportDateFrom] = useState('');
   const [exportDateTo, setExportDateTo] = useState('');
@@ -33,6 +38,23 @@ export default function PaymentsPage() {
     reference: true, booking: true, amount: true, method: true, status: true, createdAt: true,
   });
 
+  const queryClient = useQueryClient();
+
+  const deleteMutation = useMutation({
+    mutationFn: (id: string) => apiClient.delete(`/payments/${id}`),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ['payments'] });
+      setDeleteConfirmOpen(false);
+      setPaymentToDelete(null);
+      setDeleteError(null);
+      setSuccessMessage('Payment deleted successfully');
+      setTimeout(() => setSuccessMessage(''), 3000);
+    },
+    onError: (error: any) => {
+      setDeleteError(error?.response?.data?.message || error?.message || 'Failed to delete payment');
+    },
+  });
+
   const { data, isLoading } = useQuery({
     queryKey: ['payments', filters],
     queryFn: () => paymentsApi.getAll({
@@ -102,6 +124,7 @@ export default function PaymentsPage() {
 
   const paymentActions = [
     { label: 'View Details', onClick: (p: any) => setSelectedPayment(p), variant: 'secondary' as const, icon: Eye },
+    { label: 'Delete', onClick: (p: any) => { setDeleteError(null); setPaymentToDelete(p); setDeleteConfirmOpen(true); }, variant: 'danger' as const, icon: Trash2 },
   ];
 
   return (
@@ -115,6 +138,9 @@ export default function PaymentsPage() {
       </div>
 
       <div className="card">
+        {successMessage && (
+          <div className="mb-4 rounded-lg bg-green-50 dark:bg-green-900/20 p-4 text-sm text-green-800 dark:text-green-200">✓ {successMessage}</div>
+        )}
         <div className="grid grid-cols-1 md:grid-cols-3 gap-4">
           <div>
             <label className="label">Search</label>
@@ -244,6 +270,16 @@ export default function PaymentsPage() {
         })()}
       </Modal>
 
+      <ConfirmDialog
+        isOpen={deleteConfirmOpen}
+        onClose={() => { setDeleteConfirmOpen(false); setPaymentToDelete(null); setDeleteError(null); }}
+        onConfirm={async () => { if (paymentToDelete) await deleteMutation.mutateAsync(paymentToDelete.id); }}
+        title="Delete Payment"
+        message={`Permanently delete payment ${paymentToDelete?.reference || paymentToDelete?.id?.substring(0, 8)}? This cannot be undone.`}
+        confirmText="Delete" cancelText="Cancel" isLoading={deleteMutation.isPending} isDanger
+        error={deleteError ?? undefined}
+      />
+
       {/* Export Modal */}
       <Modal isOpen={exportModalOpen} onClose={() => setExportModalOpen(false)} title="Export Payments" size="md">
         <div className="space-y-4">
diff --git a/apps/edr-passenger-web/backoffice/src/app/pricing/page.tsx b/apps/edr-passenger-web/backoffice/src/app/pricing/page.tsx
index 0efeab47d..3e221839b 100644
--- a/apps/edr-passenger-web/backoffice/src/app/pricing/page.tsx
+++ b/apps/edr-passenger-web/backoffice/src/app/pricing/page.tsx
@@ -116,7 +116,7 @@ export default function PricingPage() {
 
   const { data: segmentFares = [], isLoading: segmentFaresLoading, refetch: refetchSegmentFares } = useQuery({
     queryKey: ['segment-fares', selectedRoute],
-    queryFn: () => (selectedRoute ? apiClient.get(`/schedules/routes/${selectedRoute}/segment-fares`) : Promise.resolve([])),
+    queryFn: () => (selectedRoute ? apiClient.get(`/admin/segment-fares?routeId=${selectedRoute}`) : Promise.resolve([])),
     enabled: !!selectedRoute && tab === 'segment',
   });
 
@@ -199,7 +199,7 @@ export default function PricingPage() {
   });
 
   const createSegmentFareMutation = useMutation({
-    mutationFn: (data: any) => apiClient.post(`/schedules/segment-fares`, data),
+    mutationFn: (data: any) => apiClient.post(`/admin/segment-fares`, data),
     onSuccess: () => {
       refetchSegmentFares();
       resetSegmentForm();
@@ -211,7 +211,7 @@ export default function PricingPage() {
   });
 
   const updateSegmentFareMutation = useMutation({
-    mutationFn: (data: any) => apiClient.patch(`/schedules/segment-fares/${data.id}`, data),
+    mutationFn: ({ id, ...data }: any) => apiClient.put(`/admin/segment-fares/${id}`, data),
     onSuccess: () => {
       refetchSegmentFares();
       setEditingFare(null);
@@ -224,7 +224,7 @@ export default function PricingPage() {
   });
 
   const deleteSegmentFareMutation = useMutation({
-    mutationFn: (id: string) => apiClient.delete(`/schedules/segment-fares/${id}`),
+    mutationFn: (id: string) => apiClient.delete(`/admin/segment-fares/${id}`),
     onSuccess: () => {
       refetchSegmentFares();
       setDeleteConfirm({ isOpen: false, id: null });
@@ -422,7 +422,7 @@ export default function PricingPage() {
     },
     {
       key: 'baseFare',
-      label: 'Fare (ETB)',
+      label: 'Fare',
       render: (fare: any) => {
         const minor = fare.baseFareMinor ?? fare.baseFare;
         if (minor == null) return <span className="text-muted-foreground">—</span>;
@@ -495,7 +495,7 @@ export default function PricingPage() {
     },
     {
       key: 'baseFare',
-      label: 'Fare (ETB)',
+      label: 'Fare',
       render: (fare: any) => {
         const fareValue = fare.baseFare ?? fare.baseFareMinor;
         if (fareValue == null) return <span className="text-muted-foreground">—</span>;
@@ -870,7 +870,7 @@ export default function PricingPage() {
                 </div>
 
                 <div>
-                  <label className="label">Fare (ETB) *</label>
+                  <label className="label">Fare *</label>
                   <input
                     type="number"
                     min="0"
@@ -1000,7 +1000,7 @@ export default function PricingPage() {
                 </div>
 
                 <div>
-                  <label className="label">Fare (ETB) *</label>
+                  <label className="label">Fare *</label>
                   <input
                     type="number"
                     min="0"
diff --git a/apps/edr-passenger-web/backoffice/src/app/reports/page.tsx b/apps/edr-passenger-web/backoffice/src/app/reports/page.tsx
index ceeb078d1..c5d283a8e 100644
--- a/apps/edr-passenger-web/backoffice/src/app/reports/page.tsx
+++ b/apps/edr-passenger-web/backoffice/src/app/reports/page.tsx
@@ -6,6 +6,7 @@ import { Download, TrendingUp, Users, DollarSign, AlertCircle } from 'lucide-rea
 import { LineChart, Line, BarChart, Bar, XAxis, YAxis, CartesianGrid, Tooltip, Legend, ResponsiveContainer, PieChart, Pie, Cell } from 'recharts';
 import { bookingsApi } from '@/lib/api';
 import ActionButton from '@/components/ui/ActionButton';
+import Modal from '@/components/ui/Modal';
 
 const COLORS = ['#3b82f6', '#10b981', '#f59e0b'];
 
@@ -13,6 +14,8 @@ export default function ReportsPage() {
   const [dateRange, setDateRange] = useState('30');
   const [startDate, setStartDate] = useState('');
   const [endDate, setEndDate] = useState('');
+  const [exportModalOpen, setExportModalOpen] = useState(false);
+  const [exportFormat, setExportFormat] = useState<'csv' | 'excel' | 'pdf'>('csv');
 
   const getDateRange = () => {
     const end = new Date();
@@ -49,21 +52,23 @@ export default function ReportsPage() {
     queryFn: () => bookingsApi.getAll({ pageSize: 1000 }),
   });
 
-  // Filter bookings by date range
-  const bookings = Array.isArray(bookingsData?.items) 
+  // Filter bookings by date range — exclude CANCELLED from revenue calculations
+  const bookings = Array.isArray(bookingsData?.items)
     ? bookingsData.items.filter((b: any) => {
         const bookingDate = new Date(b.createdAt).toISOString().split('T')[0];
         return bookingDate >= dates.startDate && bookingDate <= dates.endDate;
       })
     : [];
 
-  // Calculate metrics
-  const totalRevenue = bookings.reduce((sum: number, b: any) => sum + (b.totalMinor || 0), 0);
-  const totalBookings = bookings.length;
-  const avgTicketPrice = totalBookings > 0 ? Math.round(totalRevenue / totalBookings) : 0;
+  const revenueBookings = bookings.filter((b: any) => b.status !== 'CANCELLED' && b.status !== 'REFUNDED');
 
-  // Group by date for revenue chart
-  const byDate = bookings.reduce((acc: Record<string, any>, b: any) => {
+  // Calculate metrics — revenue excludes cancelled/refunded bookings
+  const totalRevenue = revenueBookings.reduce((sum: number, b: any) => sum + (b.totalMinor || 0), 0);
+  const totalBookings = bookings.length;
+  const avgTicketPrice = revenueBookings.length > 0 ? Math.round(totalRevenue / revenueBookings.length) : 0;
+
+  // Group by date for revenue chart — exclude cancelled/refunded
+  const byDate = revenueBookings.reduce((acc: Record<string, any>, b: any) => {
     const date = new Date(b.createdAt).toISOString().split('T')[0];
     if (!acc[date]) {
       acc[date] = { totalMinor: 0, count: 0 };
@@ -81,6 +86,40 @@ export default function ReportsPage() {
       bookings: d.count || 0,
     }));
 
+  const REPORT_COLS = [
+    { key: 'date', label: 'Date' },
+    { key: 'revenue', label: 'Revenue (ETB)' },
+    { key: 'bookings', label: 'Bookings' },
+  ];
+
+  const doExport = () => {
+    if (!chartData.length) { alert('No data to export'); return; }
+    const headers = REPORT_COLS.map(c => c.label);
+    const rows = chartData.map(r => [r.date, String(Math.round(r.revenue)), String(r.bookings)]);
+    const dateStr = new Date().toISOString().split('T')[0];
+    if (exportFormat === 'pdf') {
+      const w = window.open('', '_blank')!;
+      w.document.write(`<!DOCTYPE html><html><head><title>Revenue Report</title><style>body{font-family:sans-serif;font-size:11px}table{border-collapse:collapse;width:100%}th,td{border:1px solid #ccc;padding:4px 8px}th{background:#10b981;color:#fff}</style></head><body>`);
+      w.document.write(`<h2>Revenue Report — ${dates.startDate} to ${dates.endDate}</h2>`);
+      w.document.write(`<p>Total Revenue: ETB ${Math.round(totalRevenue / 100).toLocaleString()} | Total Bookings: ${totalBookings} | Cancelled: ${bookings.filter((b: any) => b.status === 'CANCELLED').length}</p>`);
+      w.document.write(`<table><thead><tr>${headers.map(h => `<th>${h}</th>`).join('')}</tr></thead><tbody>`);
+      rows.forEach(r => { w.document.write(`<tr>${r.map(v => `<td>${v}</td>`).join('')}</tr>`); });
+      w.document.write('</tbody></table></body></html>');
+      w.document.close(); w.print();
+    } else if (exportFormat === 'excel') {
+      const tsv = [headers.join('\t'), ...rows.map(r => r.join('\t'))].join('\n');
+      const blob = new Blob([tsv], { type: 'application/vnd.ms-excel' });
+      const url = URL.createObjectURL(blob);
+      const a = document.createElement('a'); a.href = url; a.download = `revenue-report-${dateStr}.xls`; a.click(); URL.revokeObjectURL(url);
+    } else {
+      const csv = [headers.map(h => `"${h}"`).join(','), ...rows.map(r => r.map(v => `"${v}"`).join(','))].join('\n');
+      const blob = new Blob([csv], { type: 'text/csv' });
+      const url = URL.createObjectURL(blob);
+      const a = document.createElement('a'); a.href = url; a.download = `revenue-report-${dateStr}.csv`; a.click(); URL.revokeObjectURL(url);
+    }
+    setExportModalOpen(false);
+  };
+
   return (
     <div className="space-y-6">
       <div>
@@ -131,7 +170,7 @@ export default function ReportsPage() {
             </>
           )}
 
-          <ActionButton icon={Download} variant="secondary" disabled={isLoading}>
+          <ActionButton icon={Download} variant="secondary" disabled={isLoading} onClick={() => setExportModalOpen(true)}>
             Export
           </ActionButton>
         </div>
@@ -147,7 +186,7 @@ export default function ReportsPage() {
             <div>
               <p className="text-muted-foreground text-sm font-medium">Total Revenue</p>
               <p className="text-2xl font-bold mt-2">ETB {Math.round(totalRevenue / 100).toLocaleString()}</p>
-              <p className="text-xs text-muted-foreground mt-1">Last {dateRange} days</p>
+              <p className="text-xs text-muted-foreground mt-1">Excl. cancelled &amp; refunded</p>
             </div>
             <DollarSign className="h-8 w-8 text-blue-500 opacity-20" />
           </div>
@@ -169,7 +208,7 @@ export default function ReportsPage() {
             <div>
               <p className="text-muted-foreground text-sm font-medium">Avg. Ticket Price</p>
               <p className="text-2xl font-bold mt-2">ETB {(avgTicketPrice / 100).toLocaleString()}</p>
-              <p className="text-xs text-muted-foreground mt-1">Per booking</p>
+              <p className="text-xs text-muted-foreground mt-1">Non-cancelled bookings</p>
             </div>
             <TrendingUp className="h-8 w-8 text-purple-500 opacity-20" />
           </div>
@@ -314,6 +353,28 @@ export default function ReportsPage() {
           </div>
         </div>
       </div>
+
+      {/* Export Modal */}
+      <Modal isOpen={exportModalOpen} onClose={() => setExportModalOpen(false)} title="Export Revenue Report" size="sm">
+        <div className="space-y-4">
+          <p className="text-sm text-muted-foreground">Exports daily revenue and booking counts for the selected date range. Cancelled and refunded bookings are excluded from revenue figures.</p>
+          <div>
+            <p className="text-sm font-medium mb-2">Export Format</p>
+            <div className="flex gap-3">
+              {(['csv', 'excel', 'pdf'] as const).map(fmt => (
+                <label key={fmt} className="flex items-center gap-2 cursor-pointer">
+                  <input type="radio" name="reportExportFormat" value={fmt} checked={exportFormat === fmt} onChange={() => setExportFormat(fmt)} className="w-4 h-4" />
+                  <span className="text-sm font-medium capitalize">{fmt === 'excel' ? 'Excel (.xls)' : fmt === 'pdf' ? 'PDF (Print)' : 'CSV'}</span>
+                </label>
+              ))}
+            </div>
+          </div>
+          <div className="flex justify-end gap-2 pt-4 border-t">
+            <ActionButton variant="secondary" onClick={() => setExportModalOpen(false)}>Cancel</ActionButton>
+            <ActionButton onClick={doExport}>Export</ActionButton>
+          </div>
+        </div>
+      </Modal>
     </div>
   );
 }
diff --git a/apps/edr-passenger-web/backoffice/src/app/routes/page.tsx b/apps/edr-passenger-web/backoffice/src/app/routes/page.tsx
index 882ff0917..43592c4f7 100644
--- a/apps/edr-passenger-web/backoffice/src/app/routes/page.tsx
+++ b/apps/edr-passenger-web/backoffice/src/app/routes/page.tsx
@@ -171,7 +171,7 @@ export default function RoutesPage() {
   const [originStationId, setOriginStationId] = useState('');
   const [destinationStationId, setDestinationStationId] = useState('');
   const [destinationDistance, setDestinationDistance] = useState<number | undefined>(undefined);
-  const [deleteConfirm, setDeleteConfirm] = useState<{ isOpen: boolean; route: any | null }>({ isOpen: false, route: null });
+  const [deleteConfirm, setDeleteConfirm] = useState<{ isOpen: boolean; route: any | null; error?: string }>({ isOpen: false, route: null });
   const [search, setSearch] = useState('');
   const queryClient = useQueryClient();
 
@@ -211,6 +211,10 @@ export default function RoutesPage() {
     onSuccess: () => {
       queryClient.invalidateQueries({ queryKey: ['routes'] });
     },
+    onError: (e: any) => {
+      const msg = e?.response?.data?.message || e?.message || 'Failed to delete route';
+      setDeleteConfirm(prev => ({ ...prev, error: Array.isArray(msg) ? msg.join(' ') : msg }));
+    },
   });
 
   const handleSubmit = async (e: React.FormEvent<HTMLFormElement>) => {
@@ -315,13 +319,16 @@ export default function RoutesPage() {
   };
 
   const handleDelete = (route: any) => {
-    setDeleteConfirm({ isOpen: true, route });
+    setDeleteConfirm({ isOpen: true, route, error: undefined });
   };
 
   const confirmDelete = async () => {
-    if (deleteConfirm.route) {
+    if (!deleteConfirm.route) return;
+    try {
       await deleteMutation.mutateAsync(deleteConfirm.route.id);
       setDeleteConfirm({ isOpen: false, route: null });
+    } catch {
+      // error is set by onError handler
     }
   };
 
@@ -462,6 +469,8 @@ export default function RoutesPage() {
         message={`Are you sure you want to delete ${deleteConfirm.route?.name}?`}
         confirmText="Delete"
         isDanger={true}
+        isLoading={deleteMutation.isPending}
+        error={deleteConfirm.error}
         warning="This route may be referenced by schedules and bookings. Deleting it may impact these systems."
       />
 
diff --git a/apps/edr-passenger-web/backoffice/src/app/stations/page.tsx b/apps/edr-passenger-web/backoffice/src/app/stations/page.tsx
index 6bd53a4cf..aef1ece25 100644
--- a/apps/edr-passenger-web/backoffice/src/app/stations/page.tsx
+++ b/apps/edr-passenger-web/backoffice/src/app/stations/page.tsx
@@ -14,7 +14,7 @@ export default function StationsPage() {
   const [filters, setFilters] = useState({ search: '', country: '', operational: '' });
   const [showModal, setShowModal] = useState(false);
   const [editingStation, setEditingStation] = useState<any>(null);
-  const [deleteConfirm, setDeleteConfirm] = useState<{ isOpen: boolean; station: any | null }>({ isOpen: false, station: null });
+  const [deleteConfirm, setDeleteConfirm] = useState<{ isOpen: boolean; station: any | null; error?: string }>({ isOpen: false, station: null });
   const [formError, setFormError] = useState<string | null>(null);
   const queryClient = useQueryClient();
 
@@ -50,6 +50,10 @@ export default function StationsPage() {
     onSuccess: () => {
       queryClient.invalidateQueries({ queryKey: ['stations'] });
     },
+    onError: (e: any) => {
+      const msg = e?.response?.data?.message || e?.message || 'Failed to delete station';
+      setDeleteConfirm(prev => ({ ...prev, error: Array.isArray(msg) ? msg.join(' ') : msg }));
+    },
   });
 
   const handleSubmit = async (e: React.FormEvent<HTMLFormElement>) => {
@@ -82,13 +86,16 @@ export default function StationsPage() {
   };
 
   const handleDelete = (station: any) => {
-    setDeleteConfirm({ isOpen: true, station });
+    setDeleteConfirm({ isOpen: true, station, error: undefined });
   };
 
   const confirmDelete = async () => {
-    if (deleteConfirm.station) {
+    if (!deleteConfirm.station) return;
+    try {
       await deleteMutation.mutateAsync(deleteConfirm.station.id);
       setDeleteConfirm({ isOpen: false, station: null });
+    } catch {
+      // error is set by onError handler
     }
   };
 
@@ -235,6 +242,8 @@ export default function StationsPage() {
         message={`Are you sure you want to delete ${deleteConfirm.station?.name}?`}
         confirmText="Delete"
         isDanger={true}
+        isLoading={deleteMutation.isPending}
+        error={deleteConfirm.error}
         warning="This station may be referenced by routes, schedules, and bookings. Deleting it may impact these systems."
       />
 
diff --git a/apps/edr-passenger-web/backoffice/src/app/tickets/page.tsx b/apps/edr-passenger-web/backoffice/src/app/tickets/page.tsx
index e17391f32..53ae0584a 100644
--- a/apps/edr-passenger-web/backoffice/src/app/tickets/page.tsx
+++ b/apps/edr-passenger-web/backoffice/src/app/tickets/page.tsx
@@ -9,6 +9,7 @@ import Badge from '@/components/ui/Badge';
 import ActionButton from '@/components/ui/ActionButton';
 import ConfirmDialog from '@/components/ui/ConfirmDialog';
 import Modal from '@/components/ui/Modal';
+import Image from 'next/image';
 import { ticketsApi, apiClient, stationsApi, excessBaggageApi } from '@/lib/api';
 import { formatDateTime, formatCurrency, formatDateTimeShort } from '@/lib/utils';
 import { useAuthStore } from '@/lib/auth-store';
@@ -241,10 +242,14 @@ export default function TicketsPage() {
           '</div>' +
         '</div>' +
       '</div>' +
-      '<script>window.onload=function(){window.print();window.onafterprint=function(){window.close()};}<\/script>' +
       '</body></html>'
     );
     w.document.close();
+    // Drive printing from the opener rather than an inline <script> in the popup — the
+    // about:blank window inherits this page's CSP, which blocks non-nonced inline scripts.
+    w.focus();
+    w.onafterprint = () => w.close();
+    w.print();
   };
 
   const handleDeleteClick = (ticket: any) => {
@@ -844,10 +849,13 @@ export default function TicketsPage() {
                     <SectionHeader title="QR Code" />
                     <div className="flex justify-center">
                       <div className="bg-white p-4 rounded-xl border border-muted inline-block">
-                        <img
+                        <Image
                           src={t.qrCode.startsWith('data:') ? t.qrCode : `data:image/png;base64,${t.qrCode}`}
                           alt={`QR Code for ${t.ticketNumber}`}
-                          className="w-48 h-48 object-contain"
+                          width={192}
+                          height={192}
+                          className="object-contain"
+                          unoptimized
                         />
                         <p className="text-center text-xs text-muted-foreground mt-2 font-mono">{t.ticketNumber}</p>
                       </div>
diff --git a/apps/edr-passenger-web/backoffice/src/app/trains/page.tsx b/apps/edr-passenger-web/backoffice/src/app/trains/page.tsx
index 29386f8bd..b54615f3e 100644
--- a/apps/edr-passenger-web/backoffice/src/app/trains/page.tsx
+++ b/apps/edr-passenger-web/backoffice/src/app/trains/page.tsx
@@ -16,7 +16,7 @@ export default function TrainsPage() {
   const [showModal, setShowModal] = useState(false);
   const [editingTrain, setEditingTrain] = useState<TrainType | null>(null);
   const [search, setSearch] = useState('');
-  const [deleteConfirm, setDeleteConfirm] = useState<{ isOpen: boolean; train: TrainType | null }>({ isOpen: false, train: null });
+  const [deleteConfirm, setDeleteConfirm] = useState<{ isOpen: boolean; train: TrainType | null; error?: string }>({ isOpen: false, train: null });
   
   const queryClient = useQueryClient();
 
@@ -54,6 +54,10 @@ export default function TrainsPage() {
     onSuccess: () => {
       queryClient.invalidateQueries({ queryKey: ['trains'] });
     },
+    onError: (error: any) => {
+      const msg = error?.response?.data?.message || error?.message || 'Failed to delete train';
+      setDeleteConfirm(prev => ({ ...prev, error: Array.isArray(msg) ? msg.join(' ') : msg }));
+    },
   });
 
   const restoreTrainMutation = useMutation({
@@ -67,13 +71,16 @@ export default function TrainsPage() {
   });
 
   const handleDelete = (train: TrainType) => {
-    setDeleteConfirm({ isOpen: true, train });
+    setDeleteConfirm({ isOpen: true, train, error: undefined });
   };
 
   const confirmDelete = async () => {
-    if (deleteConfirm.train) {
+    if (!deleteConfirm.train) return;
+    try {
       await deleteTrainMutation.mutateAsync(deleteConfirm.train.id);
       setDeleteConfirm({ isOpen: false, train: null });
+    } catch {
+      // error is set by onError handler
     }
   };
 
@@ -228,6 +235,8 @@ export default function TrainsPage() {
         message={`Are you sure you want to delete train ${deleteConfirm.train?.number}?`}
         confirmText="Delete"
         isDanger={true}
+        isLoading={deleteTrainMutation.isPending}
+        error={deleteConfirm.error}
         warning="This train may be assigned to schedules and trips. Deleting it may impact these systems and associated bookings."
       />
 
diff --git a/apps/edr-passenger-web/backoffice/src/app/wallet-accounts/layout.tsx b/apps/edr-passenger-web/backoffice/src/app/wallet-accounts/layout.tsx
new file mode 100644
index 000000000..86d53715f
--- /dev/null
+++ b/apps/edr-passenger-web/backoffice/src/app/wallet-accounts/layout.tsx
@@ -0,0 +1,5 @@
+import DashboardLayout from '../dashboard/layout';
+
+export default function Layout({ children }: { children: React.ReactNode }) {
+  return <DashboardLayout>{children}</DashboardLayout>;
+}
diff --git a/apps/edr-passenger-web/backoffice/src/app/wallet-accounts/page.tsx b/apps/edr-passenger-web/backoffice/src/app/wallet-accounts/page.tsx
new file mode 100644
index 000000000..a95791340
--- /dev/null
+++ b/apps/edr-passenger-web/backoffice/src/app/wallet-accounts/page.tsx
@@ -0,0 +1,206 @@
+'use client';
+
+import { useState } from 'react';
+import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
+import { Download, Eye, Wallet, Trash2 } from 'lucide-react';
+import DataTable from '@/components/ui/DataTable';
+import Badge from '@/components/ui/Badge';
+import ActionButton from '@/components/ui/ActionButton';
+import Modal from '@/components/ui/Modal';
+import ConfirmDialog from '@/components/ui/ConfirmDialog';
+import { walletApi } from '@/lib/api';
+import { formatDateTime, formatCurrency } from '@/lib/utils';
+
+const Field = ({ label, value, mono = false, truncate = false }: { label: string; value: string; mono?: boolean; truncate?: boolean }) => (
+  <div className="bg-muted/40 rounded-lg p-3">
+    <p className="text-xs text-muted-foreground mb-1">{label}</p>
+    <p className={`text-sm font-semibold text-foreground${mono ? ' font-mono' : ''}${truncate ? ' truncate' : ''}`} title={value}>{value || '—'}</p>
+  </div>
+);
+
+const SectionHeader = ({ title }: { title: string }) => (
+  <h3 className="text-xs font-bold uppercase tracking-widest text-muted-foreground mb-3 flex items-center gap-2">
+    <span className="w-4 h-px bg-muted-foreground/40 inline-block" />{title}
+  </h3>
+);
+
+export default function WalletAccountsPage() {
+  const [filters, setFilters] = useState({ search: '' });
+  const [selected, setSelected] = useState<any>(null);
+  const [toDelete, setToDelete] = useState<any>(null);
+  const [deleteError, setDeleteError] = useState('');
+  const queryClient = useQueryClient();
+
+  const { data, isLoading } = useQuery({
+    queryKey: ['wallet-accounts', filters],
+    queryFn: () => walletApi.getAccounts(filters),
+  });
+
+  const deleteMutation = useMutation({
+    mutationFn: (id: string) => walletApi.delete(id),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ['wallet-accounts'] });
+      setToDelete(null);
+      setDeleteError('');
+    },
+    onError: (err: any) => setDeleteError(err?.message || 'Failed to delete wallet account'),
+  });
+
+  const columns = [
+    { key: 'passenger', label: 'Passenger', render: (w: any) => (
+      <div>
+        <div className="font-medium">{w.passenger?.fullName || 'N/A'}</div>
+        <div className="text-xs text-muted-foreground">{w.passenger?.email || ''}</div>
+      </div>
+    )},
+    { key: 'balanceMinor', label: 'Balance', render: (w: any) => (
+      <span className="font-semibold">{formatCurrency(w.balanceMinor ?? 0, w.currency || 'ETB')}</span>
+    )},
+    { key: 'currency', label: 'Currency', render: (w: any) => w.currency || 'ETB' },
+    { key: 'status', label: 'Status', render: (w: any) => (
+      <Badge variant="status" status={w.isActive !== false ? 'CONFIRMED' : 'CANCELLED'}>
+        {w.isActive !== false ? 'Active' : 'Inactive'}
+      </Badge>
+    )},
+  ];
+
+  const actions = [
+    { label: 'View Details', onClick: (w: any) => setSelected(w), variant: 'secondary' as const, icon: Eye },
+    { label: 'Delete', onClick: (w: any) => { setDeleteError(''); setToDelete(w); }, variant: 'danger' as const, icon: Trash2 },
+  ];
+
+  return (
+    <div className="space-y-6">
+      <div className="flex items-center justify-between">
+        <div>
+          <h1 className="text-2xl font-bold text-foreground">Wallet Accounts</h1>
+          <p className="text-muted-foreground">Manage passenger wallet accounts</p>
+        </div>
+        <ActionButton icon={Download} variant="secondary">Export</ActionButton>
+      </div>
+
+      <div className="card">
+        <div className="grid grid-cols-1 md:grid-cols-3 gap-4">
+          <div>
+            <label className="label">Search</label>
+            <input type="text" placeholder="Search by name or email..." className="input" value={filters.search} onChange={(e) => setFilters({ ...filters, search: e.target.value })} />
+          </div>
+        </div>
+      </div>
+
+      <DataTable
+        data={Array.isArray(data) ? data : (data?.items || [])}
+        columns={columns}
+        actions={actions}
+        loading={isLoading}
+        emptyMessage="No wallet accounts found"
+      />
+
+      {/* Delete Confirm Dialog */}
+      <ConfirmDialog
+        isOpen={!!toDelete}
+        onClose={() => { setToDelete(null); setDeleteError(''); }}
+        onConfirm={() => deleteMutation.mutate(toDelete.id)}
+        title="Delete Wallet Account"
+        message={`Are you sure you want to delete the wallet account for ${toDelete?.passenger?.fullName || 'this passenger'}? This will permanently remove the account and all ledger entries.`}
+        confirmText="Delete"
+        isDanger
+        isLoading={deleteMutation.isPending}
+        error={deleteError}
+      />
+
+      {/* Wallet Details Modal */}
+      <Modal isOpen={!!selected} onClose={() => setSelected(null)} title="Wallet Account Details" size="xl">
+        {selected && (() => {
+          const w = selected;
+          const balance = w.balanceMinor ?? 0;
+          const passengerName = w.passenger?.fullName || 'N/A';
+          return (
+            <div>
+              <div className="from-blue-600 to-blue-700 -mx-6 -mt-4 mb-6 px-6 py-5 bg-gradient-to-r rounded-t-lg">
+                <div className="flex items-center gap-4">
+                  <div className="w-14 h-14 rounded-full bg-white/20 flex items-center justify-center shrink-0">
+                    <Wallet className="w-7 h-7 text-white" />
+                  </div>
+                  <div className="flex-1 min-w-0">
+                    <p className="text-white text-xl font-bold truncate">{passengerName}</p>
+                    <p className="text-blue-200 text-sm">{w.passenger?.email || ''}</p>
+                  </div>
+                  <div className="text-right shrink-0">
+                    <Badge variant="status" status={w.isActive !== false ? 'CONFIRMED' : 'CANCELLED'}>
+                      {w.isActive !== false ? 'Active' : 'Inactive'}
+                    </Badge>
+                  </div>
+                </div>
+                <div className="mt-4 grid grid-cols-3 gap-3">
+                  {[
+                    { label: 'Current Balance', value: formatCurrency(balance, w.currency || 'ETB') },
+                    { label: 'Currency', value: w.currency || 'ETB' },
+                    { label: 'Total Topped Up', value: formatCurrency(w.totalTopUp ?? 0, w.currency || 'ETB') },
+                  ].map(({ label, value }) => (
+                    <div key={label} className="bg-white/10 rounded-lg px-3 py-2">
+                      <p className="text-blue-200 text-xs">{label}</p>
+                      <p className="text-white text-sm font-bold truncate">{value}</p>
+                    </div>
+                  ))}
+                </div>
+              </div>
+
+              <div className="space-y-6">
+                <section>
+                  <SectionHeader title="Balance" />
+                  <div className="grid grid-cols-2 md:grid-cols-4 gap-3">
+                    <div className="bg-blue-50 dark:bg-blue-900/20 border border-blue-100 dark:border-blue-800 rounded-lg p-3 col-span-2">
+                      <p className="text-xs text-blue-700 dark:text-blue-400 mb-1">Current Balance</p>
+                      <p className="text-xl font-bold text-blue-800 dark:text-blue-300">{formatCurrency(balance, w.currency || 'ETB')}</p>
+                    </div>
+                    <Field label="Total Topped Up" value={formatCurrency(w.totalTopUp ?? 0, w.currency || 'ETB')} />
+                    <Field label="Total Spent" value={formatCurrency(w.totalSpent ?? 0, w.currency || 'ETB')} />
+                  </div>
+                </section>
+
+                <section>
+                  <SectionHeader title="Account Details" />
+                  <div className="grid grid-cols-2 md:grid-cols-4 gap-3">
+                    <Field label="Currency" value={w.currency || 'ETB'} />
+                    <div className="bg-muted/40 rounded-lg p-3">
+                      <p className="text-xs text-muted-foreground mb-2">Status</p>
+                      <Badge variant="status" status={w.isActive !== false ? 'CONFIRMED' : 'CANCELLED'}>
+                        {w.isActive !== false ? 'Active' : 'Inactive'}
+                      </Badge>
+                    </div>
+                    <Field label="Locked" value={w.isLocked ? 'Yes' : 'No'} />
+                    <Field label="Lock Reason" value={w.lockReason || 'N/A'} truncate />
+                  </div>
+                </section>
+
+                <section>
+                  <SectionHeader title="Passenger" />
+                  <div className="grid grid-cols-2 md:grid-cols-3 gap-3">
+                    <Field label="Full Name" value={w.passenger?.fullName} />
+                    <Field label="Email" value={w.passenger?.email} truncate />
+                    <Field label="Phone" value={w.passenger?.phone} />
+                    <Field label="Passenger ID" value={w.passengerId || w.passenger?.id} mono truncate />
+                  </div>
+                </section>
+
+                <section>
+                  <SectionHeader title="Timestamps & IDs" />
+                  <div className="grid grid-cols-2 md:grid-cols-3 gap-3">
+                    <Field label="Created" value={formatDateTime(w.createdAt)} />
+                    <Field label="Last Updated" value={formatDateTime(w.updatedAt)} />
+                    <Field label="Account ID" value={w.id} mono truncate />
+                  </div>
+                </section>
+              </div>
+
+              <div className="flex justify-end gap-2 pt-6 mt-2 border-t border-muted">
+                <ActionButton variant="secondary" onClick={() => setSelected(null)}>Close</ActionButton>
+              </div>
+            </div>
+          );
+        })()}
+      </Modal>
+    </div>
+  );
+}
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 9e1f7bb61..d9ca1da7d 100644
--- a/apps/edr-passenger-web/backoffice/src/components/layout/Sidebar.tsx
+++ b/apps/edr-passenger-web/backoffice/src/components/layout/Sidebar.tsx
@@ -36,6 +36,7 @@ import {
   Grid3x3,
   Banknote,
   Activity,
+  Smartphone,
 } from 'lucide-react';
 import { useAuthStore } from '@/lib/auth-store';
 import { cn } from '@/lib/utils';
@@ -69,8 +70,9 @@ const navigationSections: { title: string; items: NavItem[] }[] = [
   {
     title: 'Tourism',
     items: [
-      { name: 'Packages',  href: '/packages',          icon: Package,       permission: PERMS.admin },
-      { name: 'Inquiries', href: '/package-inquiries', icon: MessageSquare, permission: PERMS.admin },
+      { name: 'Packages',         href: '/packages',          icon: Package,       permission: PERMS.admin },
+      // { name: 'Bookings',     href: '/package-bookings',  icon: Ticket,        permission: PERMS.admin },
+      { name: 'Inquiries',        href: '/package-inquiries', icon: MessageSquare, permission: PERMS.admin },
     ]
   },
   {
@@ -91,49 +93,44 @@ const navigationSections: { title: string; items: NavItem[] }[] = [
       { name: 'Pricing & Fares',       href: '/pricing',         icon: DollarSign, permission: PERMS.admin },
       { name: 'Tariff Rates',           href: '/tariff-rates',    icon: Banknote,   permission: PERMS.admin },
       { name: 'Fare Rules',             href: '/fare-management', icon: Settings,   permission: PERMS.admin },
-      { name: 'Currencies',           href: '/currencies',      icon: Banknote,   permission: PERMS.currencies.manage },
-      { name: 'Payment Methods',      href: '/payment-methods', icon: CreditCard, permission: PERMS.payments.view },
+      { name: 'Payments',             href: '/payments',        icon: CreditCard, permission: PERMS.payments.view },
+      { name: 'Currencies',           href: '/currencies',      icon: Banknote,   permission: PERMS.currencies.manage },      
       { name: 'Promo Codes',          href: '/promos',          icon: Gift,       permission: PERMS.admin },
+      { name: 'Payment Methods',      href: '/payment-methods',  icon: CreditCard, permission: PERMS.payments.view },
+      { name: 'Wallet Accounts',        href: '/wallet-accounts',  icon: Wallet,     permission: PERMS.payments.view },
     ]
   },
   {
     title: 'Customer Services',
     items: [
       { name: 'Loyalty Program', href: '/loyalty',       icon: Gift,          permission: PERMS.passengers.view },
-      { name: 'Support Center',  href: '/support',       icon: MessageSquare, permission: PERMS.bookings.view },
+      // { name: 'Support Center',  href: '/support',       icon: MessageSquare, permission: PERMS.bookings.view },
       { name: 'Notifications',   href: '/notifications', icon: Bell,          permission: PERMS.notifications.send },
     ]
   },
-  // {
-  //   title: 'Customer Services',
-  //   items: [
-  //     { name: 'Loyalty Program', href: '/loyalty', icon: Gift },
-  //     { name: 'Support Center', href: '/support', icon: MessageSquare },
-  //     { name: 'Notifications', href: '/notifications', icon: Bell },      
-  //   ]
-  // },
   {
     title: 'Security & Compliance',
     items: [
       { name: 'Audit Logs',            href: '/audit',     icon: AlertTriangle, permission: PERMS.audit.view },
       { name: 'Fraud Detection',       href: '/fraud',     icon: Shield,        permission: PERMS.fraud.view },
-      { name: 'Verifayda Integration', href: '/verifayda', icon: UserCheck,     permission: PERMS.admin },
+      // { name: 'Verifayda Integration', href: '/verifayda', icon: UserCheck,     permission: PERMS.admin },
     ]
   },
   {
     title: 'Analytics & Reports',
     items: [
       { name: 'Reports',             href: '/reports',             icon: BarChart3, permission: PERMS.reports.view },
-      { name: 'Operational Reports', href: '/operational-reports', icon: FileText,  permission: PERMS.reports.view },
+      // { name: 'Operational Reports', href: '/operational-reports', icon: FileText,  permission: PERMS.reports.view },
     ]
   },
   {
     title: 'System',
     items: [
-      { name: 'Agent Operations', href: '/agents',         icon: Briefcase, permission: PERMS.agents.view },
-      { name: 'User Management',  href: '/settings/users', icon: Users,     permission: PERMS.admin },
+      { name: 'Agents', href: '/agents',         icon: Briefcase, permission: PERMS.agents.view },
+      { name: 'Users',  href: '/settings/users', icon: Users,     permission: PERMS.admin },
       { name: 'Settings',         href: '/settings',       icon: Settings,  permission: PERMS.admin },
       { name: 'Health',           href: '/health',         icon: Activity,  permission: PERMS.admin },
+      { name: 'App Releases',     href: '/app-releases',   icon: Smartphone, permission: PERMS.admin },
     ]
   }
 ];
diff --git a/apps/edr-passenger-web/backoffice/src/components/ui/ConfirmDialog.tsx b/apps/edr-passenger-web/backoffice/src/components/ui/ConfirmDialog.tsx
index 730aae428..39c68b397 100644
--- a/apps/edr-passenger-web/backoffice/src/components/ui/ConfirmDialog.tsx
+++ b/apps/edr-passenger-web/backoffice/src/components/ui/ConfirmDialog.tsx
@@ -103,12 +103,32 @@ export default function ConfirmDialog({
             </div>
           )}
 
-          {error && (
-            <div className="flex gap-3 rounded-xl bg-red-50 dark:bg-red-900/20 border border-red-200 dark:border-red-800 px-4 py-3">
-              <AlertCircle className="h-4 w-4 text-red-600 dark:text-red-400 shrink-0 mt-0.5" />
-              <p className="text-xs text-red-800 dark:text-red-300 leading-relaxed">{error}</p>
-            </div>
-          )}
+          {error && (() => {
+            const lines = error.split('\n').map(l => l.trim()).filter(Boolean);
+            const bullets = lines.filter(l => l.startsWith('•'));
+            const intro = lines.find(l => l.startsWith('Cannot') || (!l.startsWith('•') && !l.startsWith('Once') && !l.startsWith('The following')));
+            const outro = lines.find(l => l.startsWith('Once'));
+            return (
+              <div className="rounded-xl bg-red-50 dark:bg-red-900/20 border border-red-200 dark:border-red-800 px-4 py-3 space-y-2">
+                <div className="flex gap-2 items-start">
+                  <AlertCircle className="h-4 w-4 text-red-600 dark:text-red-400 shrink-0 mt-0.5" />
+                  <p className="text-xs font-medium text-red-800 dark:text-red-300 leading-relaxed">{intro ?? error}</p>
+                </div>
+                {bullets.length > 0 && (
+                  <ul className="list-disc list-inside space-y-1 pl-6">
+                    {bullets.map((b, i) => (
+                      <li key={i} className="text-xs text-red-800 dark:text-red-300 leading-relaxed">
+                        {b.replace(/^•\s*/, '')}
+                      </li>
+                    ))}
+                  </ul>
+                )}
+                {outro && (
+                  <p className="text-xs text-red-700 dark:text-red-400 pl-6">{outro}</p>
+                )}
+              </div>
+            );
+          })()}
         </div>
 
         {/* Footer */}
diff --git a/apps/edr-passenger-web/backoffice/src/lib/api/bookings.ts b/apps/edr-passenger-web/backoffice/src/lib/api/bookings.ts
index 1669d8dcf..9d9dc554f 100644
--- a/apps/edr-passenger-web/backoffice/src/lib/api/bookings.ts
+++ b/apps/edr-passenger-web/backoffice/src/lib/api/bookings.ts
@@ -6,6 +6,8 @@ export const bookingsApi = {
   getAll: (filters?: BookingFilters) => {
     const params = new URLSearchParams();
     if (filters?.status) params.append('status', filters.status);
+    if (filters?.bookingType) params.append('bookingType', filters.bookingType);
+    if (filters?.paymentStatus) params.append('paymentStatus', filters.paymentStatus);
     if (filters?.dateFrom) params.append('dateFrom', filters.dateFrom);
     if (filters?.dateTo) params.append('dateTo', filters.dateTo);
     if (filters?.search) params.append('search', filters.search);
diff --git a/apps/edr-passenger-web/backoffice/src/lib/api/index.ts b/apps/edr-passenger-web/backoffice/src/lib/api/index.ts
index 5dd23ef2c..b44e33f74 100644
--- a/apps/edr-passenger-web/backoffice/src/lib/api/index.ts
+++ b/apps/edr-passenger-web/backoffice/src/lib/api/index.ts
@@ -158,8 +158,11 @@ export const seatsApi = {
 // Payments API
 export const paymentsApi = {
   getAll: async (params?: any) => {
-    const query = new URLSearchParams(params as Record<string, string>).toString();
-    const response = await apiClient.get<any>(`/payments${query ? `?${query}` : ''}`);
+    const cleanParams = Object.fromEntries(
+      Object.entries(params || {}).filter(([, v]) => v !== '' && v !== undefined && v !== null)
+    ) as Record<string, string>;
+    const query = new URLSearchParams(cleanParams).toString();
+    const response = await apiClient.get<any>(`/payments/all${query ? `?${query}` : ''}`);
     if (response?.data) {
       return Array.isArray(response.data) ? { items: response.data } : response;
     }
@@ -229,6 +232,7 @@ export const loyaltyApi = {
   adjustPoints: (accountId: string, data: any) => apiClient.post<any>(`/loyalty/accounts/${accountId}/adjust`, data),
   getRewards: () => apiClient.get<any[]>('/loyalty/rewards'),
   createReward: (data: any) => apiClient.post<any>('/loyalty/rewards', data),
+  delete: (id: string) => apiClient.delete(`/loyalty/accounts/${id}`),
 };
 
 // Wallet API
@@ -244,6 +248,7 @@ export const walletApi = {
   getAccount: (passengerId: string) => apiClient.get<any>(`/wallet/accounts/${passengerId}`),
   adjustBalance: (accountId: string, data: any) => apiClient.post<any>(`/wallet/accounts/${accountId}/adjust`, data),
   getLedger: (accountId: string) => apiClient.get<any[]>(`/wallet/accounts/${accountId}/ledger`),
+  delete: (id: string) => apiClient.delete(`/wallet/accounts/${id}`),
 };
 
 // Promotions API
@@ -301,12 +306,14 @@ export const notificationsApi = {
 // Fraud API
 export const fraudApi = {
   getAlerts: async (params?: any) => {
-    const query = new URLSearchParams(params as Record<string, string>).toString();
+    const cleanParams = Object.fromEntries(
+      Object.entries(params || {}).filter(([, v]) => v !== '' && v !== undefined && v !== null)
+    ) as Record<string, string>;
+    const query = new URLSearchParams(cleanParams).toString();
     const response = await apiClient.get<any>(`/fraud/alerts${query ? `?${query}` : ''}`);
-    if (response?.data) {
-      return Array.isArray(response.data) ? { items: response.data } : response;
-    }
-    return Array.isArray(response) ? { items: response } : response;
+    // Backend returns { data: [...], total } or { items: [...] }
+    const arr = (response as any)?.data ?? (response as any)?.items ?? response;
+    return { items: Array.isArray(arr) ? arr : [] };
   },
   acknowledgeAlert: (id: string) => apiClient.patch<any>(`/fraud/alerts/${id}/acknowledge`),
   getRules: () => apiClient.get<any[]>('/fraud/rules'),
@@ -403,6 +410,15 @@ export const packagesApi = {
   activate: (id: string) => apiClient.patch<any>(`/packages/${id}/activate`, {}),
   deactivate: (id: string) => apiClient.patch<any>(`/packages/${id}/deactivate`, {}),
   remove: (id: string) => apiClient.delete(`/packages/${id}`),
+  getBookings: async (params?: any) => {
+    const cleanParams = Object.fromEntries(
+      Object.entries(params || {}).filter(([_, value]) => value !== '' && value !== undefined && value !== null)
+    ) as Record<string, string>;
+    const query = new URLSearchParams(cleanParams).toString();
+    const response = await apiClient.get<any>(`/packages/bookings${query ? `?${query}` : ''}`);
+    if ((response as any)?.data) return Array.isArray((response as any).data) ? { items: (response as any).data } : response;
+    return Array.isArray(response) ? { items: response } : response;
+  },
   addTier: (packageId: string, data: any) => apiClient.post<any>(`/packages/${packageId}/tiers`, data),
   updateTier: (tierId: string, data: any) => apiClient.patch<any>(`/packages/tiers/${tierId}`, data),
   deleteTier: (tierId: string) => apiClient.delete(`/packages/tiers/${tierId}`),
@@ -442,6 +458,14 @@ export const excessBaggageApi = {
   delete: (id: string) => apiClient.delete(`/agents/excess-baggage/${id}`),
 };
 
+// Segment Fares API
+export const segmentFaresApi = {
+  getAll: (routeId?: string) => apiClient.get<any>(`/admin/segment-fares${routeId ? `?routeId=${routeId}` : ''}`),
+  create: (data: any) => apiClient.post<any>('/admin/segment-fares', data),
+  update: (id: string, data: any) => apiClient.put<any>(`/admin/segment-fares/${id}`, data),
+  remove: (id: string) => apiClient.delete(`/admin/segment-fares/${id}`),
+};
+
 // Route Coach Templates API
 export const routeCoachTemplatesApi = {
   get: (routeId: string) => apiClient.get<any>(`/routes/${routeId}/coaches`),
@@ -455,3 +479,14 @@ export const systemConfigApi = {
   getAll: () => apiClient.get<Record<string, string>>('/config'),
   update: (data: Record<string, string>) => apiClient.patch<Record<string, string>>('/config', data),
 };
+
+// App Releases API
+export const appReleasesApi = {
+  getAll: async () => {
+    const response = await apiClient.get<any>('/app-releases');
+    return Array.isArray(response) ? response : (response as any)?.items || (response as any)?.data || [];
+  },
+  create: (data: any) => apiClient.post<any>('/app-releases', data),
+  update: (id: string, data: any) => apiClient.patch<any>(`/app-releases/${id}`, data),
+  remove: (id: string) => apiClient.delete(`/app-releases/${id}`),
+};
diff --git a/apps/edr-passenger-web/backoffice/src/middleware.ts b/apps/edr-passenger-web/backoffice/src/middleware.ts
index 7e8a1545d..db7af8568 100644
--- a/apps/edr-passenger-web/backoffice/src/middleware.ts
+++ b/apps/edr-passenger-web/backoffice/src/middleware.ts
@@ -2,21 +2,93 @@ import { NextRequest, NextResponse } from 'next/server';
 
 const PUBLIC_PATHS = ['/login', '/reset-password'];
 
+/**
+ * Build the Content-Security-Policy for a single request.
+ *
+ * Production uses a strict, nonce-based policy with `strict-dynamic`: only scripts
+ * carrying this request's nonce (and scripts they load) may execute, which neutralises
+ * reflected/stored XSS regardless of any host allowlist. Next.js applies the nonce to
+ * its own bootstrap/chunk scripts automatically because middleware forwards it on the
+ * request `Content-Security-Policy` header (see below); our own inline scripts read it
+ * from the `x-nonce` request header in the root layout.
+ *
+ * `strict-dynamic` also covers the jsQR script the boarding scanner injects at runtime
+ * (a trusted script's dynamically-created <script> is allowed), so no CDN host needs
+ * allowlisting.
+ *
+ * Development relaxes `script-src` (Next.js HMR/react-refresh needs `unsafe-eval` and
+ * inline) and allows the HMR websocket, and drops `upgrade-insecure-requests` so
+ * plain-HTTP localhost keeps working.
+ */
+function buildCsp(nonce: string): string {
+  const isProd = process.env.NODE_ENV === 'production';
+
+  // Origin the browser calls for API/XHR/fetch — must be allowed in connect-src.
+  let apiOrigin = '';
+  try {
+    apiOrigin = new URL(process.env.NEXT_PUBLIC_API_URL ?? 'http://localhost:4000').origin;
+  } catch {
+    apiOrigin = '';
+  }
+
+  const scriptSrc = isProd
+    ? `'self' 'nonce-${nonce}' 'strict-dynamic'`
+    : `'self' 'unsafe-inline' 'unsafe-eval'`;
+
+  const connectSrc = isProd
+    ? `'self' ${apiOrigin}`.trim()
+    : `'self' ${apiOrigin} ws: wss:`.trim();
+
+  const directives = [
+    `default-src 'self'`,
+    `base-uri 'self'`,
+    `script-src ${scriptSrc}`,
+    // Inline styles (Tailwind runtime + React `style=` attributes) can't execute JS;
+    // nonce-ing them reliably breaks Next/React, so 'unsafe-inline' is the accepted stance.
+    `style-src 'self' 'unsafe-inline'`,
+    `img-src 'self' data: blob: ${apiOrigin}`.trim(),
+    `font-src 'self' data:`,
+    `connect-src ${connectSrc}`,
+    `worker-src 'self' blob:`,
+    `frame-src 'self'`,
+    `object-src 'none'`,
+    `form-action 'self'`,
+    `frame-ancestors 'none'`,
+    ...(isProd ? ['upgrade-insecure-requests'] : []),
+  ];
+
+  return directives.join('; ');
+}
+
 export function middleware(request: NextRequest) {
+  const nonce = btoa(crypto.randomUUID());
+  const csp = buildCsp(nonce);
+
+  // Forward the nonce + CSP on the *request* so Next.js nonces its own scripts and our
+  // layout can read `x-nonce`. The browser-enforced copy is set on the response below.
+  const requestHeaders = new Headers(request.headers);
+  requestHeaders.set('x-nonce', nonce);
+  requestHeaders.set('Content-Security-Policy', csp);
+
+  const render = () => NextResponse.next({ request: { headers: requestHeaders } });
+
   const { pathname } = request.nextUrl;
 
+  let response: NextResponse;
   if (PUBLIC_PATHS.some((p) => pathname.startsWith(p))) {
-    return NextResponse.next();
+    response = render();
+  } else {
+    // Token is stored in localStorage (client-side only), so middleware can't
+    // read it directly. We use a cookie set on login as the server-side signal.
+    const token = request.cookies.get('auth_token')?.value;
+    response = token ? render() : NextResponse.redirect(new URL('/login', request.url));
   }
 
-  // Token is stored in localStorage (client-side only), so middleware can't
-  // read it directly. We use a cookie set on login as the server-side signal.
-  const token = request.cookies.get('auth_token')?.value;
-  if (!token) {
-    return NextResponse.redirect(new URL('/login', request.url));
-  }
-
-  return NextResponse.next();
+  response.headers.set('Content-Security-Policy', csp);
+  // Anti-clickjacking. `frame-ancestors 'none'` (in the CSP above) is the modern control;
+  // X-Frame-Options: DENY is the legacy equivalent for older browsers and scanners.
+  response.headers.set('X-Frame-Options', 'DENY');
+  return response;
 }
 
 export const config = {
diff --git a/apps/edr-passenger-web/backoffice/src/types/index.ts b/apps/edr-passenger-web/backoffice/src/types/index.ts
index f853ec95e..88ffee43d 100644
--- a/apps/edr-passenger-web/backoffice/src/types/index.ts
+++ b/apps/edr-passenger-web/backoffice/src/types/index.ts
@@ -46,6 +46,8 @@ export interface RevenueData {
 
 export interface BookingFilters {
   status?: string;
+  bookingType?: string;
+  paymentStatus?: string;
   dateFrom?: string;
   dateTo?: string;
   search?: string;
diff --git a/apps/edr-passenger-web/backoffice/test-routes.html b/apps/edr-passenger-web/backoffice/test-routes.html
deleted file mode 100644
index e34849a03..000000000
--- a/apps/edr-passenger-web/backoffice/test-routes.html
+++ /dev/null
@@ -1,100 +0,0 @@
-<!DOCTYPE html>
-<html>
-<head>
-    <title>Test Routes API</title>
-    <style>
-        body { font-family: Arial, sans-serif; padding: 20px; }
-        button { padding: 10px 20px; margin: 10px 0; cursor: pointer; }
-        pre { background: #f4f4f4; padding: 15px; border-radius: 5px; overflow-x: auto; }
-        .route { border: 1px solid #ddd; padding: 10px; margin: 10px 0; border-radius: 5px; }
-    </style>
-</head>
-<body>
-    <h1>Routes API Test</h1>
-    
-    <button onclick="fetchRoutes()">Fetch All Routes</button>
-    <button onclick="deleteRoute()">Delete ADD-DDW Route</button>
-    
-    <div id="output"></div>
-
-    <script>
-        const API_URL = 'http://localhost:4000';
-        const TOKEN = localStorage.getItem('token') || 'YOUR_JWT_TOKEN_HERE';
-
-        async function fetchRoutes() {
-            try {
-                const response = await fetch(`${API_URL}/routes`, {
-                    headers: {
-                        'Authorization': `Bearer ${TOKEN}`
-                    }
-                });
-                const data = await response.json();
-                console.log('Routes response:', data);
-                
-                const output = document.getElementById('output');
-                output.innerHTML = '<h2>Routes Found:</h2>';
-                
-                if (Array.isArray(data)) {
-                    output.innerHTML += `<p>Total routes: ${data.length}</p>`;
-                    data.forEach(route => {
-                        output.innerHTML += `
-                            <div class="route">
-                                <strong>${route.code}</strong> - ${route.name}<br>
-                                <small>ID: ${route.id}</small><br>
-                                <small>Active: ${route.active}</small><br>
-                                <small>Stops: ${route._count?.stops || route.stops?.length || 0}</small>
-                            </div>
-                        `;
-                    });
-                } else {
-                    output.innerHTML += '<pre>' + JSON.stringify(data, null, 2) + '</pre>';
-                }
-            } catch (error) {
-                document.getElementById('output').innerHTML = 
-                    '<p style="color: red;">Error: ' + error.message + '</p>';
-                console.error('Error:', error);
-            }
-        }
-
-        async function deleteRoute() {
-            const code = 'ADD-DDW';
-            try {
-                // First fetch to get the route ID
-                const listResponse = await fetch(`${API_URL}/routes`, {
-                    headers: { 'Authorization': `Bearer ${TOKEN}` }
-                });
-                const routes = await listResponse.json();
-                const route = routes.find(r => r.code === code);
-                
-                if (!route) {
-                    alert('Route ADD-DDW not found');
-                    return;
-                }
-                
-                if (confirm(`Delete route ${route.code} - ${route.name}?`)) {
-                    const response = await fetch(`${API_URL}/routes/${route.id}`, {
-                        method: 'DELETE',
-                        headers: {
-                            'Authorization': `Bearer ${TOKEN}`
-                        }
-                    });
-                    
-                    if (response.ok) {
-                        alert('Route deleted successfully');
-                        fetchRoutes();
-                    } else {
-                        const error = await response.json();
-                        alert('Error: ' + JSON.stringify(error));
-                    }
-                }
-            } catch (error) {
-                alert('Error: ' + error.message);
-                console.error('Error:', error);
-            }
-        }
-
-        // Auto-fetch on load
-        fetchRoutes();
-    </script>
-</body>
-</html>
diff --git a/apps/edr-passenger-web/backoffice/test-stations-crud.js b/apps/edr-passenger-web/backoffice/test-stations-crud.js
deleted file mode 100644
index 7964cc813..000000000
--- a/apps/edr-passenger-web/backoffice/test-stations-crud.js
+++ /dev/null
@@ -1,132 +0,0 @@
-// Test script for Stations CRUD operations
-// Run this in the browser console on the backoffice app
-
-async function testStationsCRUD() {
-  const API_URL = 'http://localhost:4000';
-  const token = localStorage.getItem('auth_token');
-  
-  const headers = {
-    'Content-Type': 'application/json',
-    'Authorization': token ? `Bearer ${token}` : ''
-  };
-
-  console.log('🧪 Testing Stations CRUD Operations...\n');
-
-  try {
-    // 1. CREATE - Add a new station
-    console.log('1️⃣ Testing CREATE Station...');
-    const newStation = {
-      code: 'TEST',
-      name: 'Test Station',
-      city: 'Test City',
-      countryCode: 'ET',
-      lat: '9.0320',
-      lng: '38.7469',
-      timezone: 'Africa/Addis_Ababa',
-      isOperational: true
-    };
-
-    const createResponse = await fetch(`${API_URL}/stations`, {
-      method: 'POST',
-      headers,
-      body: JSON.stringify(newStation)
-    });
-
-    if (!createResponse.ok) {
-      throw new Error(`CREATE failed: ${createResponse.status} ${await createResponse.text()}`);
-    }
-
-    const createdStation = await createResponse.json();
-    console.log('✅ Station created:', createdStation);
-    const stationId = createdStation.id || createdStation.data?.id;
-
-    if (!stationId) {
-      throw new Error('No station ID returned from create');
-    }
-
-    // 2. READ - Get the created station
-    console.log('\n2️⃣ Testing READ Station...');
-    const readResponse = await fetch(`${API_URL}/stations/${stationId}`, {
-      method: 'GET',
-      headers
-    });
-
-    if (!readResponse.ok) {
-      throw new Error(`READ failed: ${readResponse.status}`);
-    }
-
-    const readStation = await readResponse.json();
-    console.log('✅ Station retrieved:', readStation);
-
-    // 3. UPDATE - Modify the station
-    console.log('\n3️⃣ Testing UPDATE Station...');
-    const updateData = {
-      name: 'Test Station Updated',
-      city: 'Test City Updated',
-      isOperational: false
-    };
-
-    const updateResponse = await fetch(`${API_URL}/stations/${stationId}`, {
-      method: 'PATCH',
-      headers,
-      body: JSON.stringify(updateData)
-    });
-
-    if (!updateResponse.ok) {
-      throw new Error(`UPDATE failed: ${updateResponse.status} ${await updateResponse.text()}`);
-    }
-
-    const updatedStation = await updateResponse.json();
-    console.log('✅ Station updated:', updatedStation);
-
-    // 4. LIST - Get all stations
-    console.log('\n4️⃣ Testing LIST Stations...');
-    const listResponse = await fetch(`${API_URL}/stations`, {
-      method: 'GET',
-      headers
-    });
-
-    if (!listResponse.ok) {
-      throw new Error(`LIST failed: ${listResponse.status}`);
-    }
-
-    const stations = await listResponse.json();
-    console.log('✅ Stations list retrieved:', stations);
-
-    // 5. DELETE - Remove the test station
-    console.log('\n5️⃣ Testing DELETE Station...');
-    const deleteResponse = await fetch(`${API_URL}/stations/${stationId}`, {
-      method: 'DELETE',
-      headers
-    });
-
-    if (!deleteResponse.ok) {
-      throw new Error(`DELETE failed: ${deleteResponse.status} ${await deleteResponse.text()}`);
-    }
-
-    console.log('✅ Station deleted successfully');
-
-    // 6. Verify deletion
-    console.log('\n6️⃣ Verifying deletion...');
-    const verifyResponse = await fetch(`${API_URL}/stations/${stationId}`, {
-      method: 'GET',
-      headers
-    });
-
-    if (verifyResponse.status === 404) {
-      console.log('✅ Station deletion verified (404 Not Found)');
-    } else {
-      console.warn('⚠️ Station might still exist');
-    }
-
-    console.log('\n🎉 All tests passed!');
-    return { success: true, message: 'All CRUD operations working correctly' };
-
-  } catch (error) {
-    console.error('❌ Test failed:', error);
-    return { success: false, error: error.message };
-  }
-}
-
-// Run the test
-testStationsCRUD();
diff --git a/apps/edr-passenger-web/portal/src/app/booking/confirmation/page.tsx b/apps/edr-passenger-web/portal/src/app/booking/confirmation/page.tsx
index 8c3479f83..e5fbe674a 100644
--- a/apps/edr-passenger-web/portal/src/app/booking/confirmation/page.tsx
+++ b/apps/edr-passenger-web/portal/src/app/booking/confirmation/page.tsx
@@ -4,10 +4,11 @@ export const dynamic = 'force-dynamic';
 
 import { useRouter } from 'next/navigation';
 import { useBookingStore } from '@/lib/booking-store';
+import { usePaymentStore } from '@/lib/payment-store';
 import { useQuery } from '@tanstack/react-query';
 import { apiClient } from '@/lib/api-client';
 import { useEffect, useState, useRef } from 'react';
-import { CheckCircle, Download, Share2, Copy, Printer, Mail, Train, FileText } from 'lucide-react';
+import { CheckCircle, Copy, Train, FileText } from 'lucide-react';
 import { format } from 'date-fns';
 
 type BookingWithTicket = {
@@ -25,7 +26,10 @@ type BookingWithTicket = {
 
 export default function ConfirmationPage() {
   const router = useRouter();
-  const { bookingId, pnr, selectedSchedule, outboundSchedule, inboundSchedule, searchCriteria, passengers, clearBooking } = useBookingStore();
+  const { bookingId, pnr, selectedSchedule, outboundSchedule, inboundSchedule, searchCriteria, passengers, clearBooking, packageName } = useBookingStore();
+  // The currency/amount actually confirmed for the payment option the user selected —
+  // null when no payment step ran (e.g. a fully-discounted, zero-amount booking).
+  const { selectedCurrency: paidCurrency, paidAmountMinor } = usePaymentStore();
   const isRoundTrip = searchCriteria?.tripType === 'ROUND_TRIP';
   const [copied, setCopied] = useState(false);
   const [isGeneratingVoucher, setIsGeneratingVoucher] = useState(false);
@@ -37,7 +41,6 @@ export default function ConfirmationPage() {
       try {
         return await apiClient.get(`/bookings/${bookingId}`);
       } catch (error) {
-        console.log('Booking API not available, using local data');
         return {
           id: bookingId || '',
           pnr: pnr || undefined,
@@ -57,13 +60,9 @@ export default function ConfirmationPage() {
       // For other payment methods, ticket is generated by the payment webhook after payment completes
       apiClient.get(`/bookings/${bookingId}`).then((data: any) => {
         if (data?.status === 'CONFIRMED') {
-          apiClient.post(`/tickets/generate/${bookingId}`).catch((err) => {
-            console.error('Failed to generate ticket:', err);
-          });
+          apiClient.post(`/tickets/generate/${bookingId}`).catch(() => {});
         }
-      }).catch((err) => {
-        console.error('Failed to fetch booking status:', err);
-      });
+      }).catch(() => {});
     }
   }, [bookingId]);
 
@@ -90,8 +89,12 @@ export default function ConfirmationPage() {
       const { generatePassengerVoucherPDF } = await import('@/lib/generate-voucher');
 
       const activeSchedule = isRoundTrip ? outboundSchedule : selectedSchedule;
-      const totalFare = _booking?.totalMinor
-        || passengers.reduce((s) => s + (activeSchedule?.baseFareAdult || 0), 0);
+      // Prefer the amount/currency actually confirmed for the selected payment option;
+      // only fall back to the ETB booking fare when no payment step ran (e.g. $0 total).
+      const totalFare = paidAmountMinor
+        ?? _booking?.totalMinor
+        ?? passengers.reduce((s) => s + (activeSchedule?.baseFareAdult || 0), 0);
+      const voucherCurrency = paidAmountMinor != null ? paidCurrency : 'ETB';
       const farePerPassenger = Math.round(totalFare / passengers.length);
       const createdAt = _booking?.createdAt || new Date().toISOString();
       const status = _booking?.status || 'CONFIRMED';
@@ -134,7 +137,7 @@ export default function ConfirmationPage() {
           inboundSchedule:     inbound,
           isRoundTrip,
           fareMinor:           farePerPassenger,
-          currency:            'ETB',
+          currency:            voucherCurrency,
           createdAt,
         });
 
@@ -142,29 +145,20 @@ export default function ConfirmationPage() {
         if (i < passengers.length - 1) await new Promise(r => setTimeout(r, 400));
       }
     } catch (error) {
-      console.error('❌ Failed to generate voucher:', error);
       alert(`Failed to generate voucher: ${error instanceof Error ? error.message : 'Unknown error'}`);
     } finally {
       setIsGeneratingVoucher(false);
     }
   };
 
-  const handlePrintTickets = () => {
-    window.print();
-  };
-
-  const handleEmailTickets = () => {
-    alert('Tickets have been sent to your registered email address.');
-  };
-
   const handleNewBooking = () => {
     clearBooking();
-    router.push('/booking/search');
+    window.location.href = '/';
   };
 
   useEffect(() => {
     if (!bookingId || !pnr) {
-      router.push('/booking/search');
+      window.location.href = '/';
     }
   }, [bookingId, pnr, router]);
 
@@ -181,14 +175,16 @@ export default function ConfirmationPage() {
                 <CheckCircle className="w-12 h-12 text-green-600 dark:text-green-400" />
               </div>
             </div>
-            <h1 className="text-4xl font-bold text-green-600 dark:text-green-400 mb-2">Booking confirmed!</h1>
+            <h1 className="text-4xl font-bold text-green-600 dark:text-green-400 mb-2">
+              {packageName ? `${packageName} booking confirmed!` : 'Booking confirmed!'}
+            </h1>
             <p className="text-gray-600 dark:text-gray-400 text-lg">Your train tickets are ready</p>
           </div>
 
           {/* PNR Card */}
-          <div className="card mb-6 bg-gradient-to-r from-primary to-primary-600 dark:from-primary-700 dark:to-primary-900 text-white">
+          <div className="card mb-6 bg-primary text-white">
             <div className="text-center">
-              <p className="text-sm opacity-90 mb-2">Booking reference (PNR)</p>
+              <p className="text-sm font-medium mb-2">Booking reference (PNR)</p>
               <div className="flex items-center justify-center gap-3">
                 <span className="text-5xl font-bold tracking-widest">{pnr}</span>
                 <button 
@@ -203,7 +199,7 @@ export default function ConfirmationPage() {
                   )}
                 </button>
               </div>
-              <p className="text-sm opacity-90 mt-2">Save this reference number for future use</p>
+              <p className="text-sm font-medium mt-2">Save this reference number for future use</p>
             </div>
           </div>
 
@@ -334,7 +330,7 @@ export default function ConfirmationPage() {
               <div>
                 <p className="text-sm text-gray-600 dark:text-gray-400">Total paid</p>
                 <p className="font-semibold text-gray-900 dark:text-gray-100">
-                  ETB {((_booking?.totalMinor || passengers.reduce((s) => s + (selectedSchedule?.baseFareAdult || 0), 0)) / 100).toFixed(2)}
+                  {paidAmountMinor != null ? paidCurrency : 'ETB'} {((paidAmountMinor ?? _booking?.totalMinor ?? passengers.reduce((s) => s + (selectedSchedule?.baseFareAdult || 0), 0)) / 100).toFixed(2)}
                 </p>
               </div>
             </div>
@@ -374,8 +370,21 @@ export default function ConfirmationPage() {
                           <p className="font-semibold text-gray-900 dark:text-gray-100">{passenger.nationality}</p>
                         </div>
                         <div>
-                          <p className="text-gray-600 dark:text-gray-400">Seat</p>
-                          <p className="font-semibold text-gray-900 dark:text-gray-100">{passenger.seatNumber || 'Will be assigned'}</p>
+                          <p className="text-gray-600 dark:text-gray-400">Seat(s)</p>
+                          {isRoundTrip ? (
+                            <div className="space-y-0.5">
+                              <p className="font-semibold text-gray-900 dark:text-gray-100">
+                                Outbound: {(passenger as any).outboundCoachNumber && <span className='text-xs text-gray-500 dark:text-gray-400 ml-1'>{(passenger as any).outboundCoachNumber}</span>} — {(passenger as any).outboundSeatNumber || 'Auto-assigned at boarding'}
+                              </p>
+                              <p className="font-semibold text-gray-900 dark:text-gray-100">
+                                Return: {(passenger as any).inboundCoachNumber && <span className='text-xs text-gray-500 dark:text-gray-400 ml-1'>{(passenger as any).inboundCoachNumber}</span>} — {(passenger as any).inboundSeatNumber || 'Auto-assigned at boarding'}
+                              </p>
+                            </div>
+                          ) : (
+                            <p className="font-semibold text-gray-900 dark:text-gray-100">
+                              {passenger.coachNumber && <span className='text-xs text-gray-500 dark:text-gray-400 ml-1'>(Coach {passenger.coachNumber})</span>} — {passenger.seatNumber || 'Auto-assigned at boarding'}
+                            </p>
+                          )}
                         </div>
                       </div>
                     </div>
@@ -386,50 +395,24 @@ export default function ConfirmationPage() {
           </div>
 
           {/* Action Buttons */}
-          <div className="grid grid-cols-2 md:grid-cols-5 gap-3 mb-6">
-            <button 
+          <div className="mb-6">
+            <button
               onClick={handleDownloadVoucher}
               disabled={isGeneratingVoucher}
-              className="btn-primary flex items-center justify-center gap-2 relative"
+              className="btn-primary w-full flex items-center justify-center gap-2 relative"
             >
               {isGeneratingVoucher ? (
                 <>
                   <div className="w-4 h-4 border-2 border-white border-t-transparent rounded-full animate-spin" />
-                  <span className="hidden sm:inline">Generating...</span>
+                  <span>Generating...</span>
                 </>
               ) : (
                 <>
                   <FileText className="w-4 h-4" />
-                  <span className="hidden sm:inline">Download Voucher</span>
-                  <span className="sm:hidden">Voucher</span>
+                  <span>Download Voucher</span>
                 </>
               )}
             </button>
-            <button 
-              onClick={handlePrintTickets}
-              className="btn-secondary flex items-center justify-center gap-2"
-            >
-              <Printer className="w-4 h-4" />
-              <span className="hidden sm:inline">Print</span>
-            </button>
-            <button 
-              onClick={handleEmailTickets}
-              className="btn-secondary flex items-center justify-center gap-2"
-            >
-              <Mail className="w-4 h-4" />
-              <span className="hidden sm:inline">Email</span>
-            </button>
-            <button 
-              onClick={() => alert('Tickets download will be available soon.')}
-              className="btn-secondary flex items-center justify-center gap-2"
-            >
-              <Download className="w-4 h-4" />
-              <span className="hidden sm:inline">Download</span>
-            </button>
-            <button className="btn-secondary flex items-center justify-center gap-2">
-              <Share2 className="w-4 h-4" />
-              <span className="hidden sm:inline">Share</span>
-            </button>
           </div>
 
           {/* New Booking Button */}
diff --git a/apps/edr-passenger-web/portal/src/app/booking/detail/page.tsx b/apps/edr-passenger-web/portal/src/app/booking/detail/page.tsx
index f01ab89c6..5087b7e4d 100644
--- a/apps/edr-passenger-web/portal/src/app/booking/detail/page.tsx
+++ b/apps/edr-passenger-web/portal/src/app/booking/detail/page.tsx
@@ -34,9 +34,7 @@ function BookingDetailContent() {
     queryKey: ['booking-detail', bookingRef],
     queryFn: async () => {
       if (!bookingRef) throw new Error('No booking reference provided');
-      console.log('🔍 Fetching Booking:', bookingRef);
       const response = await apiClient.get(`/bookings/${bookingRef}`);
-      console.log('✅ Booking Response:', response);
       // Handle wrapped response
       return (response as any)?.data || response;
     },
@@ -56,7 +54,6 @@ function BookingDetailContent() {
       return response;
     },
     onSuccess: async (data: any) => {
-      console.log('Payment intent created:', data);
       await apiClient.patch(`/bookings/${booking?.id}/confirm`, {
         paymentIntentId: data.id,
         paymentMethod: selectedPaymentMethod,
@@ -64,7 +61,6 @@ function BookingDetailContent() {
       refetch();
     },
     onError: (error: any) => {
-      console.error('Payment failed:', error);
       alert(error?.response?.data?.message || 'Payment failed. Please try again.');
     },
   });
@@ -99,11 +95,9 @@ function BookingDetailContent() {
 
     setIsGeneratingVoucher(true);
     try {
-      console.log('📄 Generating voucher for booking:', booking);
       const { generateVoucherPDF } = await import('@/lib/generate-voucher');
       await generateVoucherPDF(booking as any);
     } catch (error) {
-      console.error('Failed to generate voucher:', error);
       alert(`Failed to generate voucher: ${error instanceof Error ? error.message : 'Unknown error'}`);
     } finally {
       setIsGeneratingVoucher(false);
@@ -148,11 +142,6 @@ function BookingDetailContent() {
   const isExpired = booking.status === 'EXPIRED';
   const isCancelled = booking.status === 'CANCELLED';
 
-  console.log('📊 Booking Status:', booking.status);
-  console.log('📊 isPendingPayment:', isPendingPayment);
-  console.log('📊 isConfirmed:', isConfirmed);
-  console.log('📊 isExpired:', isExpired);
-  console.log('📊 isCancelled:', isCancelled);
 
   const StatusBadge = () => {
     const statusConfig = {
diff --git a/apps/edr-passenger-web/portal/src/app/booking/passengers/page.tsx b/apps/edr-passenger-web/portal/src/app/booking/passengers/page.tsx
index d5857ac98..e443ccf07 100644
--- a/apps/edr-passenger-web/portal/src/app/booking/passengers/page.tsx
+++ b/apps/edr-passenger-web/portal/src/app/booking/passengers/page.tsx
@@ -529,6 +529,10 @@ const passengerSchema = z.object({
   dateOfBirth: z.string().min(1, 'Date of birth is required'),
   gender: z.string().min(1, 'Gender is required'),
   nationality: z.string().min(1, 'Nationality is required'),
+  // Adults enter these themselves; children inherit the primary adult's values (see the
+  // sync effect in the page component) rather than collecting their own.
+  phone: z.string(),
+  email: z.string(),
   nationalId: z.string().optional(),
   passportNumber: z.string().optional(),
   passportCountry: z.string().optional(),
@@ -557,27 +561,29 @@ function createFormSchema(adultCount: number) {
   return z.object({
     passengers: z.array(passengerSchema),
     createAccount: z.boolean(),
-    contactPhone: z.string(),
-    contactEmail: z.string(),
   }).superRefine((data, ctx) => {
-    if (!data.contactEmail || data.contactEmail.trim().length === 0) {
-      ctx.addIssue({ code: z.ZodIssueCode.custom, message: 'Contact email is required', path: ['contactEmail'] });
-    } else {
-      const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-      if (!emailRegex.test(data.contactEmail)) {
-        ctx.addIssue({ code: z.ZodIssueCode.custom, message: 'Invalid email format', path: ['contactEmail'] });
-      }
-    }
-    const contactNationality = data.passengers[0]?.nationality || 'ETHIOPIAN';
-    const phoneError = validatePhone(data.contactPhone, contactNationality);
-    if (phoneError) {
-      ctx.addIssue({ code: z.ZodIssueCode.custom, message: phoneError, path: ['contactPhone'] });
-    }
-
     data.passengers.forEach((p, i) => {
+      const isAdult = i < adultCount;
+
+      // Contact fields are only collected from — and validated against — adults.
+      // Children's phone/email are inherited from the primary adult, not user-entered.
+      if (isAdult) {
+        if (!p.email || p.email.trim().length === 0) {
+          ctx.addIssue({ code: z.ZodIssueCode.custom, message: 'Email is required', path: ['passengers', i, 'email'] });
+        } else {
+          const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+          if (!emailRegex.test(p.email)) {
+            ctx.addIssue({ code: z.ZodIssueCode.custom, message: 'Invalid email format', path: ['passengers', i, 'email'] });
+          }
+        }
+        const phoneError = validatePhone(p.phone, p.nationality);
+        if (phoneError) {
+          ctx.addIssue({ code: z.ZodIssueCode.custom, message: phoneError, path: ['passengers', i, 'phone'] });
+        }
+      }
+
       const age = calculateAge(p.dateOfBirth);
       if (age === null) return;
-      const isAdult = i < adultCount;
       if (isAdult && age <= 5) {
         ctx.addIssue({ code: z.ZodIssueCode.custom, message: 'Adult passengers must be older than 5 years', path: ['passengers', i, 'dateOfBirth'] });
       } else if (!isAdult && age > 5) {
@@ -623,6 +629,8 @@ export default function PassengersPage() {
             dateOfBirth: stored.dateOfBirth || '',
             gender: (stored.gender as any) || undefined,
             nationality: stored.nationality || searchCriteria?.nationality || 'ETHIOPIAN',
+            phone: (i >= adultCount ? storedPassengers[0]?.phone : stored.phone) || '',
+            email: (i >= adultCount ? storedPassengers[0]?.email : stored.email) || '',
             nationalId: stored.nationalId || '',
             passportNumber: stored.passportNumber || '',
             passportCountry: stored.passportCountry || '',
@@ -638,6 +646,10 @@ export default function PassengersPage() {
           dateOfBirth: '',
           gender: undefined,
           nationality: searchCriteria?.nationality || 'ETHIOPIAN',
+          // Children start out mirroring whatever the primary adult already has on file;
+          // the sync effect below keeps this current as the primary adult's info changes.
+          phone: (i >= adultCount ? storedPassengers[0]?.phone : '') || '',
+          email: (i >= adultCount ? storedPassengers[0]?.email : '') || '',
           nationalId: '',
           passportNumber: '',
           passportCountry: '',
@@ -649,14 +661,28 @@ export default function PassengersPage() {
         };
       }),
       createAccount: false,
-      contactPhone: storedPassengers[0]?.phone || '',
-      contactEmail: storedPassengers[0]?.email || '',
     },
   });
 
   const { fields } = useFieldArray({ control, name: 'passengers' });
   const passengers = watch('passengers');
 
+  // Children don't collect their own contact info — keep their phone/email mirrored to
+  // whatever the primary adult (index 0) currently has, so it's always in sync.
+  const primaryPhone = passengers[0]?.phone;
+  const primaryEmail = passengers[0]?.email;
+  useEffect(() => {
+    for (let i = adultCount; i < passengers.length; i++) {
+      if (passengers[i]?.phone !== (primaryPhone || '')) {
+        setValue(`passengers.${i}.phone`, primaryPhone || '', { shouldValidate: true });
+      }
+      if (passengers[i]?.email !== (primaryEmail || '')) {
+        setValue(`passengers.${i}.email`, primaryEmail || '', { shouldValidate: true });
+      }
+    }
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [primaryPhone, primaryEmail, adultCount, passengers.length]);
+
   useEffect(() => {
     const checkFaydaStatus = async () => {
       try {
@@ -719,10 +745,9 @@ export default function PassengersPage() {
             const normalizedGender = normalizeFaydaGender(d.gender);
             if (normalizedGender) setValue(`passengers.${targetIndex}.gender`, normalizedGender, { shouldValidate: true });
             if (faydaSub) setValue(`passengers.${targetIndex}.faydaSub`, faydaSub);
-            // Contact info is shared across all passengers — only fill it in if nobody has
-            // entered it yet, so verifying passenger 2 can't clobber passenger 1's contact.
-            if (d.email && !watch('contactEmail')) setValue('contactEmail', d.email, { shouldValidate: true });
-            if (d.phoneNumber && !watch('contactPhone')) setValue('contactPhone', d.phoneNumber, { shouldValidate: true });
+            // Only fill in this passenger's own contact fields if they haven't entered them yet.
+            if (d.email && !watch(`passengers.${targetIndex}.email`)) setValue(`passengers.${targetIndex}.email`, d.email, { shouldValidate: true });
+            if (d.phoneNumber && !watch(`passengers.${targetIndex}.phone`)) setValue(`passengers.${targetIndex}.phone`, d.phoneNumber, { shouldValidate: true });
             setValue(`passengers.${targetIndex}.faydaVerified`, true);
             setValue(`passengers.${targetIndex}.formExpanded`, true);
             setVerificationStatus((prev) => ({ ...prev, [targetIndex]: 'success' }));
@@ -736,7 +761,6 @@ export default function PassengersPage() {
         // Remove code/state from the URL so a refresh doesn't re-trigger
         router.replace('/booking/passengers');
       } catch (error) {
-        console.error('Failed to complete Fayda verification:', error);
         setVerificationStatus((prev) => ({ ...prev, [targetIndex]: 'error' }));
         setFaydaErrors((prev) => ({ ...prev, [targetIndex]: 'Fayda verification failed. Please try again or enter details manually.' }));
       } finally {
@@ -768,7 +792,6 @@ export default function PassengersPage() {
       try {
         // Fetch passenger profile from backend
         const passengerData: any = await apiClient.get(`/passengers/me`);
-        console.log('Fetched passenger data:', passengerData);
 
         if (!passengerData) {
           setFormInitialized(true);
@@ -776,13 +799,12 @@ export default function PassengersPage() {
         }
 
         // Only populate first passenger
-        console.log('Setting passenger 0 values');
         setValue('passengers.0.name', passengerData?.fullName || user.fullName || '');
         setValue('passengers.0.dateOfBirth', passengerData?.dateOfBirth || user.dateOfBirth || '');
         if (passengerData?.gender || user.gender) setValue('passengers.0.gender', (passengerData?.gender || user.gender) as any);
         setValue('passengers.0.nationality', passengerData?.nationality || user.nationality || 'ETHIOPIAN');
-        if (passengerData?.phone || user.phone) setValue('contactPhone', passengerData?.phone || user.phone || '');
-        if (passengerData?.email || user.email) setValue('contactEmail', passengerData?.email || user.email || '');
+        if (passengerData?.phone || user.phone) setValue('passengers.0.phone', passengerData?.phone || user.phone || '');
+        if (passengerData?.email || user.email) setValue('passengers.0.email', passengerData?.email || user.email || '');
         if (passengerData?.passportNumber) setValue('passengers.0.passportNumber', passengerData.passportNumber);
         if (passengerData?.passportCountry) setValue('passengers.0.passportCountry', passengerData.passportCountry);
         if (passengerData?.passportIssueDate) setValue('passengers.0.passportIssueDate', passengerData.passportIssueDate);
@@ -793,7 +815,6 @@ export default function PassengersPage() {
 
         setFormInitialized(true);
       } catch (error) {
-        console.error('Failed to fetch passenger data:', error);
         setFormInitialized(true);
       }
     };
@@ -879,9 +900,8 @@ export default function PassengersPage() {
               setFaydaErrors((prev) => ({ ...prev, [index]: 'Fayda verification was not completed. Please try again or enter details manually.' }));
             }
           } catch (error) {
-            console.error('Failed to get verification status:', error);
             setVerificationStatus((prev) => ({ ...prev, [index]: 'error' }));
-            setFaydaErrors((prev) => ({ ...prev, [index]: 'Failed to confirm verification status. Please try again or enter details manually.' }));
+            setFaydaErrors((prev) => ({ ...prev, [index]: 'Failed to confirm verification status. Please try again.' }));
           } finally {
             setVerifyingIndex(null);
             clearPendingFaydaIndex();
@@ -889,7 +909,6 @@ export default function PassengersPage() {
         }
       }, 1000);
     } catch (error) {
-      console.error('Failed to start Fayda verification:', error);
       setVerificationStatus((prev) => ({ ...prev, [index]: 'error' }));
       setFaydaErrors((prev) => ({ ...prev, [index]: 'Failed to start verification. Please try again.' }));
       setVerifyingIndex(null);
@@ -918,9 +937,7 @@ export default function PassengersPage() {
         try {
           const passengerProfile: any = await apiClient.get('/passengers/me');
           passengerId = passengerProfile?.id || '';
-          console.log('Fetched passengerId:', passengerId);
         } catch (error) {
-          console.error('Failed to fetch passenger profile:', error);
         }
       }
 
@@ -935,8 +952,8 @@ export default function PassengersPage() {
         passportIssueDate: p.passportIssueDate,
         passportExpiryDate: p.passportExpiryDate,
         passportIssuingAuthority: p.passportIssuingAuthority,
-        phone: data.contactPhone,
-        email: data.contactEmail,
+        phone: p.phone,
+        email: p.email,
         isPrimaryPassenger: i === 0,
         passengerId: i === 0 && passengerId ? passengerId : undefined,
       }))
@@ -958,12 +975,10 @@ export default function PassengersPage() {
       if (isAuthenticated && passengerId) {
         const { setPassengerId } = useBookingStore.getState();
         setPassengerId(passengerId);
-        console.log('Saved passengerId to booking store:', passengerId);
       }
       
       router.push('/booking/seats');
     } catch (error) {
-      console.error('Failed to save passenger details:', error);
       alert('Failed to save passenger details. Please try again.');
     } finally {
       setSaving(false);
@@ -972,7 +987,7 @@ export default function PassengersPage() {
 
   useEffect(() => {
     if (!searchCriteria) {
-      router.push('/booking/search');
+      window.location.href = '/';
     }
   }, [searchCriteria, router]);
 
@@ -1155,6 +1170,40 @@ export default function PassengersPage() {
                                 disabled
                               />
                             </div>
+
+                            {isChildPassenger ? (
+                              <div className="md:col-span-2 p-3 bg-gray-50 dark:bg-gray-800 rounded-lg text-sm text-gray-600 dark:text-gray-400">
+                                Contact details (phone &amp; email) are shared with the primary passenger and don&apos;t need to be entered separately.
+                              </div>
+                            ) : (
+                              <>
+                                {/* Phone */}
+                                <div>
+                                  <label className="block text-sm font-medium mb-1 text-gray-700 dark:text-gray-300">Phone Number *</label>
+                                  <PhoneInput
+                                    nationality={passengers[index]?.nationality || 'ETHIOPIAN'}
+                                    storedValue={passengers[index]?.phone || ''}
+                                    onInterimChange={(v) => setValue(`passengers.${index}.phone`, v)}
+                                    onNormalized={(v) => setValue(`passengers.${index}.phone`, v, { shouldValidate: true })}
+                                    error={errors.passengers?.[index]?.phone?.message}
+                                  />
+                                </div>
+
+                                {/* Email */}
+                                <div>
+                                  <label className="block text-sm font-medium mb-1 text-gray-700 dark:text-gray-300">Email *</label>
+                                  <input
+                                    type="email"
+                                    {...register(`passengers.${index}.email`)}
+                                    className={`input-field ${errors.passengers?.[index]?.email ? 'border-red-500' : ''}`}
+                                    placeholder="email@example.com"
+                                  />
+                                  {errors.passengers?.[index]?.email && (
+                                    <p className="text-red-500 text-xs mt-1">{errors.passengers[index]?.email?.message}</p>
+                                  )}
+                                </div>
+                              </>
+                            )}
                           </div>
                         </>
                       ) : (
@@ -1210,6 +1259,40 @@ export default function PassengersPage() {
                                 disabled
                               />
                             </div>
+
+                            {isChildPassenger ? (
+                              <div className="md:col-span-2 p-3 bg-gray-50 dark:bg-gray-800 rounded-lg text-sm text-gray-600 dark:text-gray-400">
+                                Contact details (phone &amp; email) are shared with the primary passenger and don&apos;t need to be entered separately.
+                              </div>
+                            ) : (
+                              <>
+                                {/* Phone */}
+                                <div>
+                                  <label className="block text-sm font-medium mb-1 text-gray-700 dark:text-gray-300">Phone Number *</label>
+                                  <PhoneInput
+                                    nationality={passengers[index]?.nationality || 'OTHER'}
+                                    storedValue={passengers[index]?.phone || ''}
+                                    onInterimChange={(v) => setValue(`passengers.${index}.phone`, v)}
+                                    onNormalized={(v) => setValue(`passengers.${index}.phone`, v, { shouldValidate: true })}
+                                    error={errors.passengers?.[index]?.phone?.message}
+                                  />
+                                </div>
+
+                                {/* Email */}
+                                <div>
+                                  <label className="block text-sm font-medium mb-1 text-gray-700 dark:text-gray-300">Email *</label>
+                                  <input
+                                    type="email"
+                                    {...register(`passengers.${index}.email`)}
+                                    className={`input-field ${errors.passengers?.[index]?.email ? 'border-red-500' : ''}`}
+                                    placeholder="email@example.com"
+                                  />
+                                  {errors.passengers?.[index]?.email && (
+                                    <p className="text-red-500 text-xs mt-1">{errors.passengers[index]?.email?.message}</p>
+                                  )}
+                                </div>
+                              </>
+                            )}
                           </div>
 
                           {/* Passport fields */}
@@ -1267,40 +1350,6 @@ export default function PassengersPage() {
               );
             })}
 
-            <div className="card">
-              <h3 className="text-lg font-semibold mb-1 text-gray-900 dark:text-gray-100">Contact Information</h3>
-              <p className="text-sm text-gray-500 dark:text-gray-400 mb-4">
-                This phone number and email will be used for booking and ticketing communication for all passengers.
-              </p>
-              <div className="grid md:grid-cols-2 gap-4">
-                {/* Contact Phone */}
-                <div>
-                  <label className="block text-sm font-medium mb-1 text-gray-700 dark:text-gray-300">Phone Number *</label>
-                  <PhoneInput
-                    nationality={passengers[0]?.nationality || searchCriteria?.nationality || 'ETHIOPIAN'}
-                    storedValue={watch('contactPhone') || ''}
-                    onInterimChange={(v) => setValue('contactPhone', v)}
-                    onNormalized={(v) => setValue('contactPhone', v, { shouldValidate: true })}
-                    error={errors.contactPhone?.message}
-                  />
-                </div>
-
-                {/* Contact Email */}
-                <div>
-                  <label className="block text-sm font-medium mb-1 text-gray-700 dark:text-gray-300">Email *</label>
-                  <input
-                    type="email"
-                    {...register('contactEmail')}
-                    className={`input-field ${errors.contactEmail ? 'border-red-500' : ''}`}
-                    placeholder="email@example.com"
-                  />
-                  {errors.contactEmail && (
-                    <p className="text-red-500 text-xs mt-1">{errors.contactEmail.message}</p>
-                  )}
-                </div>
-              </div>
-            </div>
-
             {!isAuthenticated && (
               <div className="card">
                 <label className="flex items-center gap-2 cursor-pointer">
diff --git a/apps/edr-passenger-web/portal/src/app/booking/payment/page.tsx b/apps/edr-passenger-web/portal/src/app/booking/payment/page.tsx
index 730d2ad92..468058fe1 100644
--- a/apps/edr-passenger-web/portal/src/app/booking/payment/page.tsx
+++ b/apps/edr-passenger-web/portal/src/app/booking/payment/page.tsx
@@ -28,22 +28,21 @@ const getIconForMethod = (methodId: string) => {
 
 export default function PaymentPage() {
   const router = useRouter();
-  const { bookingId, pnr, selectedSchedule, outboundSchedule, inboundSchedule, passengers, searchCriteria } = useBookingStore();
-  const { setPaymentIntent, updateStatus, setCurrency } = usePaymentStore();
+  const { bookingId, pnr, selectedSchedule, outboundSchedule, inboundSchedule, passengers, searchCriteria, packageName, packageTierPriceMinor } = useBookingStore();
+  const { setPaymentIntent, updateStatus, setCurrency, setPaidAmount } = usePaymentStore();
   const [selectedMethod, setSelectedMethod] = useState<string | null>(null);
   const [selectedMethodCurrency, setSelectedMethodCurrency] = useState<string | null>(null);
   const [isProcessing, setIsProcessing] = useState(false);
   const [paymentError, setPaymentError] = useState<string | null>(null);
 
   const isRoundTrip = searchCriteria?.tripType === 'ROUND_TRIP';
+  const isPackage = !!packageTierPriceMinor;
+  const pkgRoundTripMultiplier = isPackage && isRoundTrip ? 2 : 1;
+  const pkgAdultFare = isPackage ? packageTierPriceMinor! * pkgRoundTripMultiplier : 0;
+  const pkgChildFare = isPackage ? Math.round(pkgAdultFare * 0.1) : 0;
 
   const displayCurrency = 'ETB' as const;
 
-  // Keep payment store in sync so the mutation picks up the right currency.
-  useEffect(() => {
-    setCurrency(displayCurrency);
-  }, [displayCurrency, setCurrency]);
-
   const { data: paymentMethods = [], isLoading: loadingMethods, error } = useQuery<PaymentMethod[]>({
     queryKey: ['paymentMethods', displayCurrency],
     queryFn: async () => {
@@ -59,36 +58,66 @@ export default function PaymentPage() {
     queryKey: ['bookingAmount', bookingId, amountCurrency, selectedMethod],
     queryFn: async () => {
       const url = `/payments/booking-amount?bookingId=${bookingId}&currency=${amountCurrency}`;
-      console.log('[BookingAmount] Request:', { url, bookingId, currency: amountCurrency, selectedMethod });
       const response: any = await apiClient.get(url);
-      console.log('[BookingAmount] Response:', response);
       return response;
     },
     enabled: !!selectedMethod && !!bookingId,
   });
 
-  // Fallback: estimate from local store while API hasn't responded yet.
-  // Uses the same first-child-free calculation as the review page so the
-  // breakdown shown here matches what the passenger already saw there.
-  const outboundBaseFare = isRoundTrip && outboundSchedule ? passengers.reduce((sum, _, i) => {
-    return sum + calculatePassengerFare(passengers, i, outboundSchedule.baseFareAdult || 0);
-  }, 0) : 0;
+  // Per-leg totals across all passengers.
+  // Package: one leg = pkgAdultFare/pkgChildFare (already ×1 per leg; pkgAdultFare already has ×2 for round-trip baked in via pkgRoundTripMultiplier — so per-leg is packageTierPriceMinor).
+  const adultCount = searchCriteria?.adultCount ?? passengers.filter(p => !isChild(p)).length;
+  const childCount = searchCriteria?.childCount ?? passengers.filter(p => isChild(p)).length;
+  const pkgPerLegAdultFare = isPackage ? packageTierPriceMinor! : 0;
+  const pkgPerLegChildFare = isPackage ? Math.round(pkgPerLegAdultFare * 0.1) : 0;
+  const pkgPerLegTotal = isPackage ? adultCount * pkgPerLegAdultFare + childCount * pkgPerLegChildFare : 0;
 
-  const inboundBaseFare = isRoundTrip && inboundSchedule ? passengers.reduce((sum, _, i) => {
-    return sum + calculatePassengerFare(passengers, i, inboundSchedule.baseFareAdult || 0);
-  }, 0) : 0;
+  // Prefer each passenger's own seat fare (set during seat selection) over the schedule's
+  // flat baseFareAdult — bed coaches price Upper/Middle/Lower berths differently, so a
+  // single schedule-level fare can't correctly represent every passenger's actual seat.
+  const outboundBaseFare = isPackage
+    ? pkgPerLegTotal
+    : (isRoundTrip && outboundSchedule ? passengers.reduce((sum, p, i) => {
+        const fare = (p as any).outboundSeatFareMinor ?? (outboundSchedule.baseFareAdult || 0);
+        return sum + calculatePassengerFare(passengers, i, fare);
+      }, 0) : 0);
 
-  const baseFare = isRoundTrip ? (outboundBaseFare + inboundBaseFare) : passengers.reduce((sum, _, i) => {
-    const farePerPassenger = selectedSchedule?.baseFareAdult || (selectedSchedule as any)?.fareAdult || (selectedSchedule as any)?.price || 0;
-    return sum + calculatePassengerFare(passengers, i, farePerPassenger);
-  }, 0);
+  const inboundBaseFare = isPackage
+    ? pkgPerLegTotal
+    : (isRoundTrip && inboundSchedule ? passengers.reduce((sum, p, i) => {
+        const fare = (p as any).inboundSeatFareMinor ?? (inboundSchedule.baseFareAdult || 0);
+        return sum + calculatePassengerFare(passengers, i, fare);
+      }, 0) : 0);
 
-  // API returns amount in major units (e.g. 11602.5 DJF); convert to minor for display consistency
+  const baseFare = isPackage
+    ? adultCount * pkgAdultFare + childCount * pkgChildFare
+    : isRoundTrip ? (outboundBaseFare + inboundBaseFare) : passengers.reduce((sum, p, i) => {
+        const scheduleFare = selectedSchedule?.baseFareAdult || (selectedSchedule as any)?.fareAdult || (selectedSchedule as any)?.price || 0;
+        const farePerPassenger = (p as any).seatFareMinor ?? scheduleFare;
+        return sum + calculatePassengerFare(passengers, i, farePerPassenger);
+      }, 0);
+
+  // Amount to show on screen: /payments/booking-amount already returns a ready-to-display
+  // major-unit amount, so render it directly instead of round-tripping it through minor
+  // units and back (× 100 to convert, ÷ 100 again to display).
+  const totalAmountDisplay = bookingAmountData != null ? bookingAmountData.amount : baseFare / 100;
+
+  // Minor-unit form, kept only for the actual charge request and for persisting the
+  // confirmed amount — the rest of the app's fare fields (baseFareMinor, fareMinor, etc.)
+  // are minor-unit based, so this keeps that convention internally without affecting display.
   const totalAmount = bookingAmountData != null
     ? Math.round(bookingAmountData.amount * 100)
     : baseFare;
   const confirmedCurrency = bookingAmountData?.currency || amountCurrency;
 
+  // Persist the amount/currency actually confirmed for the selected payment option so
+  // downstream screens (e.g. the voucher) use it instead of a default ETB fare.
+  useEffect(() => {
+    if (bookingAmountData == null) return;
+    setCurrency(confirmedCurrency as 'ETB' | 'DJF' | 'USD');
+    setPaidAmount(totalAmount);
+  }, [bookingAmountData, confirmedCurrency, totalAmount, setCurrency, setPaidAmount]);
+
   const paymentMutation = useMutation({
     mutationFn: async (data: any) => {
       return await apiClient.post("/payments/initiate", {
@@ -115,7 +144,6 @@ export default function PaymentPage() {
       router.push("/booking/confirmation");
     },
     onError: (error: any) => {
-      console.error("Payment failed:", error);
       updateStatus("FAILED");
       setPaymentError(
         error?.response?.data?.message ||
@@ -160,10 +188,6 @@ export default function PaymentPage() {
     // Add a small delay to allow state to be set from previous page
     const timer = setTimeout(() => {
       if (!bookingId || !pnr) {
-        console.log(
-          "Payment page: Missing booking data, redirecting to search",
-        );
-        console.log("bookingId:", bookingId, "pnr:", pnr);
         router.push("/booking/search");
       }
     }, 500);
@@ -266,17 +290,24 @@ export default function PaymentPage() {
       <div className="pt-2 border-t-2 border-gray-200 dark:border-gray-700 space-y-2">
         <h3 className="text-sm font-bold text-gray-900 dark:text-gray-100">Fare breakdown</h3>
         {passengers.map((p, i) => {
-          const outFare = outboundSchedule?.baseFareAdult || 0;
-          const inFare = inboundSchedule?.baseFareAdult || 0;
-          const onewayFare = selectedSchedule?.baseFareAdult || 0;
-
-          const outboundFare = calculatePassengerFare(passengers, i, outFare);
-          const inboundFare = calculatePassengerFare(passengers, i, inFare);
-          const oneWayFare = calculatePassengerFare(passengers, i, onewayFare);
-
-          const passengerTotal = isRoundTrip ? outboundFare + inboundFare : oneWayFare;
           const isChildPassenger = isChild(p);
-          const isFreeChild = isChildPassenger && isFirstChild(passengers, i);
+
+          let passengerTotal: number;
+          let isFreeChild = false;
+          if (isPackage) {
+            passengerTotal = isChildPassenger ? pkgChildFare : pkgAdultFare;
+          } else {
+            // Prefer this passenger's actual seat fare (varies by berth for bed coaches)
+            // over the schedule's flat baseFareAdult.
+            const outFare = (p as any).outboundSeatFareMinor ?? (outboundSchedule?.baseFareAdult || 0);
+            const inFare = (p as any).inboundSeatFareMinor ?? (inboundSchedule?.baseFareAdult || 0);
+            const onewayFare = (p as any).seatFareMinor ?? (selectedSchedule?.baseFareAdult || 0);
+            const outboundFare = calculatePassengerFare(passengers, i, outFare);
+            const inboundFare = calculatePassengerFare(passengers, i, inFare);
+            const oneWayFare = calculatePassengerFare(passengers, i, onewayFare);
+            passengerTotal = isRoundTrip ? outboundFare + inboundFare : oneWayFare;
+            isFreeChild = isChildPassenger && isFirstChild(passengers, i);
+          }
 
           return (
             <div key={i} className="border-b border-gray-100 dark:border-gray-800 pb-2 last:border-0">
@@ -285,9 +316,9 @@ export default function PaymentPage() {
                   {p.name || `Passenger ${i + 1}`}
                   {isChildPassenger && (
                     <span className={`text-xs font-semibold ml-1 ${
-                      isFreeChild ? 'text-green-600' : 'text-blue-600'
+                      isPackage ? 'text-blue-600' : isFreeChild ? 'text-green-600' : 'text-blue-600'
                     }`}>
-                      ({isFreeChild ? 'CHILD - FREE' : 'CHILD'})
+                      ({isPackage ? 'CHILD - 10%' : isFreeChild ? 'CHILD - FREE' : 'CHILD'})
                     </span>
                   )}
                 </span>
@@ -298,12 +329,22 @@ export default function PaymentPage() {
               {isRoundTrip && (
                 <div className="pl-3 space-y-0.5 text-xs text-gray-500 dark:text-gray-400">
                   <div className="flex justify-between">
-                    <span>Outbound {isFreeChild ? '(Free)' : ''}</span>
-                    <span>{formatFare(outboundFare, displayCurrency)}</span>
+                    <span>Outbound {!isPackage && isFreeChild ? '(Free)' : ''}</span>
+                    <span>{formatFare(
+                      isPackage
+                        ? (isChildPassenger ? pkgPerLegChildFare : pkgPerLegAdultFare)
+                        : calculatePassengerFare(passengers, i, (p as any).outboundSeatFareMinor ?? (outboundSchedule?.baseFareAdult || 0)),
+                      displayCurrency
+                    )}</span>
                   </div>
                   <div className="flex justify-between">
-                    <span>Return {isFreeChild ? '(Free)' : ''}</span>
-                    <span>{formatFare(inboundFare, displayCurrency)}</span>
+                    <span>Return {!isPackage && isFreeChild ? '(Free)' : ''}</span>
+                    <span>{formatFare(
+                      isPackage
+                        ? (isChildPassenger ? pkgPerLegChildFare : pkgPerLegAdultFare)
+                        : calculatePassengerFare(passengers, i, (p as any).inboundSeatFareMinor ?? (inboundSchedule?.baseFareAdult || 0)),
+                      displayCurrency
+                    )}</span>
                   </div>
                 </div>
               )}
@@ -319,7 +360,7 @@ export default function PaymentPage() {
             {loadingAmount && (
               <Loader2 className="w-4 h-4 animate-spin text-primary" />
             )}
-            {confirmedCurrency} {(totalAmount / 100).toFixed(2)}
+            {confirmedCurrency} {totalAmountDisplay.toFixed(2)}
           </span>
         </div>
       </div>
@@ -343,7 +384,7 @@ export default function PaymentPage() {
               <Loader2 className="w-4 h-4 animate-spin" /> Calculating amount...
             </span>
           ) : (
-            `Pay ${confirmedCurrency} ${(totalAmount / 100).toFixed(2)}`
+            `Pay ${confirmedCurrency} ${totalAmountDisplay.toFixed(2)}`
           )}
         </button>
         <button onClick={() => router.back()} disabled={isProcessing} className="btn-secondary w-full flex items-center justify-center gap-2">
@@ -368,7 +409,7 @@ export default function PaymentPage() {
             <CheckCircle className="w-6 h-6 text-green-600 dark:text-green-400 flex-shrink-0 mt-0.5" />
             <div>
               <p className="text-sm font-semibold text-green-800 dark:text-green-300">
-                Your booking is successfully reserved
+                {packageName ? `Your ${packageName} booking is successfully reserved` : 'Your booking is successfully reserved'}
               </p>
               <p className="text-sm text-green-700 dark:text-green-400 mt-0.5">
                 Booking Reference: <span className="font-bold">{pnr}</span>
@@ -386,8 +427,7 @@ export default function PaymentPage() {
                 {paymentMutation.isSuccess ? (
                   <>
                     <CheckCircle className="w-14 h-14 text-green-500 mx-auto mb-4" />
-                    <h3 className="text-lg font-bold mb-1 text-gray-900 dark:text-gray-100">Payment successful!</h3>
-                    <p className="text-sm text-gray-500 dark:text-gray-400 mb-4">Redirecting to confirmation...</p>
+                    <h3 className="text-lg font-bold mb-4 text-gray-900 dark:text-gray-100">Loading...</h3>
                     <Loader2 className="w-6 h-6 text-primary animate-spin mx-auto" />
                   </>
                 ) : (
@@ -479,7 +519,7 @@ export default function PaymentPage() {
           <span className="text-sm text-gray-600 dark:text-gray-400">Total</span>
           <span className="text-lg font-bold text-primary flex items-center gap-1.5">
             {loadingAmount && <Loader2 className="w-3.5 h-3.5 animate-spin" />}
-            {confirmedCurrency} {(totalAmount / 100).toFixed(2)}
+            {confirmedCurrency} {totalAmountDisplay.toFixed(2)}
           </span>
         </div>
         {paymentError && (
@@ -504,7 +544,7 @@ export default function PaymentPage() {
                 <Loader2 className="w-4 h-4 animate-spin" /> Calculating...
               </span>
             ) : (
-              `Pay ${confirmedCurrency} ${(totalAmount / 100).toFixed(2)}`
+              `Pay ${confirmedCurrency} ${totalAmountDisplay.toFixed(2)}`
             )}
           </button>
         </div>
diff --git a/apps/edr-passenger-web/portal/src/app/booking/results/page.tsx b/apps/edr-passenger-web/portal/src/app/booking/results/page.tsx
index 810e0689a..b94b9ee14 100644
--- a/apps/edr-passenger-web/portal/src/app/booking/results/page.tsx
+++ b/apps/edr-passenger-web/portal/src/app/booking/results/page.tsx
@@ -1,4 +1,4 @@
-'use client';
+'use client';
 
 import { useSearchParams, useRouter } from 'next/navigation';
 import { useQuery } from '@tanstack/react-query';
@@ -107,11 +107,9 @@ export default function ResultsPage() {
         payload.returnDate = searchData.returnDate;
       }
       
-      console.log('🚂 Search Request:', JSON.stringify(payload, null, 2));
       
       const response = await apiClient.post('/search', payload) as any;
       
-      console.log('✅ Search Response:', JSON.stringify(response, null, 2));
       
       return response;
     },
@@ -147,10 +145,16 @@ export default function ResultsPage() {
   
   // For one-way, check if outbound has results
   // For round-trip, check if BOTH outbound and inbound have results
-  const hasResults = isRoundTrip 
+  const hasResults = isRoundTrip
     ? (outboundSchedules.length > 0 && inboundSchedules.length > 0)
     : outboundSchedules.length > 0;
 
+  // One-way searches that come back with an empty outbound list may still include
+  // date-shifted alternatives from the API — surface those instead of a dead end.
+  const isOneWayNoOutbound = !isRoundTrip && !!results && outboundSchedules.length === 0;
+  const alternativeOutbound: Schedule[] = isOneWayNoOutbound ? (results.alternativeOutbound || []) : [];
+  const requestedDate: string = (results && results.requestedDate) || searchData.date;
+
   const handleSelectCoachType = (scheduleId: string, coachTypeId: string, coachTypeCode: string, coachTypeName: string, seatClassName: string) => {
     setSelectedCoachTypes(prev => ({ ...prev, [scheduleId]: { id: coachTypeId, code: coachTypeCode, name: coachTypeName, seatClassName } }));
   };
@@ -181,6 +185,8 @@ export default function ResultsPage() {
       trainNumber: schedule.trainNumber,
       origin: schedule.origin?.name || 'Origin',
       destination: schedule.destination?.name || 'Destination',
+      originStationId: schedule.origin?.id || schedule.originStationId || '',
+      destinationStationId: schedule.destination?.id || schedule.destinationStationId || '',
       departureTime: schedule.departureAt || schedule.departureTime || '',
       arrivalTime: schedule.arrivalAt || schedule.arrivalTime || '',
       duration: durationStr,
@@ -193,6 +199,9 @@ export default function ResultsPage() {
       selectedCoachTypeCode: selectedCoachType.code,
       selectedCoachTypeName: selectedCoachType.name,
       seatClassName: (selectedCoachType as any).seatClassName || selectedCoachType.name,
+      // Retained so the seat map's coach preview can price a switch to a different
+      // coach type without needing a fresh API call.
+      coachTypes: schedule.coachTypes || [],
     };
 
     // For round trip, store outbound and advance to inbound step
@@ -217,7 +226,191 @@ export default function ResultsPage() {
     router.push('/booking/auth-check');
   };
 
-  const renderScheduleCard = (schedule: Schedule, isOutbound: boolean = false) => {
+  // Shared "Choose Your Coach" drawer — used by both the normal results view and the
+  // Alternative Travel Options fallback, so selecting an alternative opens the exact
+  // same coach-type picker as a normal schedule.
+  const renderClassModal = () => {
+    if (!classModal) return null;
+
+    const scheduleId = classModal.scheduleId || classModal.id || '';
+    const selectedCoachType = selectedCoachTypes[scheduleId];
+    const isOutbound = (classModal as any).isOutbound;
+    // Dining coaches aren't bookable seat/bed classes — exclude them from selection.
+    const coachTypes = (classModal.coachTypes || []).filter((ct: any) => ct.coachTypeCode !== 'DPC');
+
+    const getCoachIcon = (typeName: string) => {
+      const lower = typeName.toLowerCase();
+      if (lower.includes('soft') || lower.includes('vip')) return Star;
+      if (lower.includes('bed')) return Bed;
+      return Armchair;
+    };
+
+    return (
+      <>
+        <div className="fixed inset-0 z-[99] bg-black/50 backdrop-blur-sm" onClick={() => setClassModal(null)} />
+        <div className="fixed inset-y-0 right-0 z-[100] w-full sm:w-[680px] lg:w-[95vw] xl:w-[90vw] 2xl:w-[85vw] max-w-[1400px] bg-white dark:bg-gray-900 shadow-2xl flex flex-col"
+          style={{ animation: 'drawer-slide-in 0.3s cubic-bezier(0.22,1,0.36,1)' }}
+        >
+            <div className="flex items-center justify-between px-6 py-5 border-b border-gray-100 dark:border-gray-800 flex-shrink-0">
+              <div>
+                <h2 className="text-lg font-bold text-gray-900 dark:text-white">Choose Your Coach</h2>
+                <p className="text-xs text-gray-500 dark:text-gray-400 mt-1 flex items-center gap-1.5">
+                  <Train className="w-3.5 h-3.5" />
+                  <span className="font-medium">{classModal.trainNumber}</span>
+                  <span className="text-gray-400">·</span>
+                  <span>{classModal.origin?.name} → {classModal.destination?.name}</span>
+                </p>
+              </div>
+              <button
+                type="button"
+                onClick={() => setClassModal(null)}
+                className="w-10 h-10 flex items-center justify-center rounded-full hover:bg-gray-100 dark:hover:bg-gray-800 transition-all"
+                aria-label="Close"
+              >
+                <X className="w-5 h-5 text-gray-500" />
+              </button>
+            </div>
+
+            <div className="flex-1 overflow-y-auto px-6 py-4">
+              {coachTypes.length > 0 ? (
+                <div className="grid grid-cols-1 lg:grid-cols-2 xl:grid-cols-3 gap-4 pt-2">
+                  {coachTypes.map((coachType: any, index: number) => {
+                    const isSelected = selectedCoachType?.id === coachType.coachTypeId;
+                    const minPrice = coachType.classes.length ? Math.min(...coachType.classes.map((c: any) => c.baseFareMinor)) : 0;
+                    const coachCurrency = 'ETB';
+                    const CoachIcon = getCoachIcon(coachType.coachTypeName);
+
+                    return (
+                      <button
+                        key={coachType.coachId}
+                        onClick={() => handleSelectCoachType(scheduleId, coachType.coachTypeId, coachType.coachTypeCode, coachType.coachTypeName, coachType.classes?.[0]?.name || coachType.coachTypeName)}
+                        className={`group relative w-full p-5 rounded-2xl border-2 text-left transition-all duration-200 ${
+                          isSelected
+                            ? 'border-primary bg-gradient-to-br from-primary/8 to-primary/3 dark:from-primary/15 dark:to-primary/5 shadow-lg shadow-primary/20 scale-[1.02]'
+                            : 'border-gray-200 dark:border-gray-700 hover:border-primary/40 hover:shadow-md hover:scale-[1.01] bg-white dark:bg-gray-800/50'
+                        }`}
+                        style={{ animation: `fade-in-up 0.3s ease-out ${index * 0.1}s both` }}
+                      >
+                        {isSelected && (
+                          <div className="absolute top-4 right-4 w-7 h-7 bg-primary rounded-full flex items-center justify-center shadow-lg animate-scale-in">
+                            <Check className="w-4 h-4 text-white" strokeWidth={3} />
+                          </div>
+                        )}
+
+                        <div className="flex flex-col">
+                          <div className="flex items-start gap-4 pr-2">
+                            <div className={`w-12 h-12 rounded-xl flex items-center justify-center flex-shrink-0 transition-all ${
+                              isSelected
+                                ? 'bg-primary/15 dark:bg-primary/25 shadow-inner'
+                                : 'bg-gray-100 dark:bg-gray-700 group-hover:bg-primary/10'
+                            }`}>
+                              <CoachIcon className={`w-6 h-6 transition-colors ${
+                                isSelected ? 'text-primary' : 'text-gray-600 dark:text-gray-400 group-hover:text-primary'
+                              }`} />
+                            </div>
+
+                            <div className="flex-1 min-w-0">
+                              <div className="flex items-start justify-between gap-2 mb-2">
+                                <div>
+                                  <h3 className="font-bold text-base text-gray-900 dark:text-white leading-tight">
+                                    {coachType.coachTypeName}
+                                  </h3>
+                                </div>
+                              </div>
+
+                              <div className="mt-3">
+                                <div className="flex items-baseline gap-1">
+                                  <span className="text-xs text-gray-500 dark:text-gray-400 font-medium">From</span>
+                                  <span className={`text-2xl font-bold tracking-tight ${
+                                    isSelected ? 'text-primary' : 'text-gray-900 dark:text-white'
+                                  }`}>
+                                    {(minPrice / 100).toFixed(2)}
+                                  </span>
+                                  <span className="text-sm font-semibold text-gray-600 dark:text-gray-400">{coachCurrency}</span>
+                                </div>
+                              </div>
+                            </div>
+                          </div>
+
+                          {coachType.classes.length > 0 && (
+                            <div className="mt-4 pt-4 border-t border-gray-200/60 dark:border-gray-700/60">
+                              <div className="flex items-center justify-between mb-3">
+                                <p className="text-xs font-bold text-gray-700 dark:text-gray-300 uppercase tracking-wider">
+                                  Class Options
+                                </p>
+                                <span className="text-xs text-gray-500 dark:text-gray-400 font-medium">
+                                  {coachType.classes.length} available
+                                </span>
+                              </div>
+                              <div className="space-y-2.5">
+                                {coachType.classes.map((cls: any, idx: number) => (
+                                  <div
+                                    key={idx}
+                                    className="flex items-center justify-between py-2 px-3 rounded-lg bg-gray-50/80 dark:bg-gray-800/40 hover:bg-gray-100/80 dark:hover:bg-gray-800/60 transition-colors"
+                                  >
+                                    <div className="flex items-center gap-2.5">
+                                      <CoachIcon className="w-3.5 h-3.5 text-gray-500 dark:text-gray-400" />
+                                      <span className="text-sm font-medium text-gray-700 dark:text-gray-300">
+                                        {cls.name}
+                                      </span>
+                                    </div>
+                                    <div className="flex items-baseline gap-1">
+                                      <span className="text-base font-bold tabular-nums text-gray-900 dark:text-white">
+                                        {(cls.baseFareMinor / 100).toFixed(2)}
+                                      </span>
+                                      <span className="text-xs text-gray-500 dark:text-gray-400 font-medium">
+                                        {coachCurrency}
+                                      </span>
+                                    </div>
+                                  </div>
+                                ))}
+                              </div>
+                            </div>
+                          )}
+                        </div>
+                      </button>
+                    );
+                  })}
+                </div>
+              ) : (
+                <div className="flex flex-col items-center justify-center py-16 text-center">
+                  <div className="w-16 h-16 bg-gray-100 dark:bg-gray-800 rounded-full flex items-center justify-center mb-4">
+                    <Train className="w-8 h-8 text-gray-400" />
+                  </div>
+                  <p className="text-gray-500 dark:text-gray-400 text-sm">No coach types available for this journey</p>
+                </div>
+              )}
+            </div>
+
+            <div className="px-6 py-5 border-t border-gray-100 dark:border-gray-800 flex-shrink-0 bg-gray-50/50 dark:bg-gray-800/30 flex justify-center">
+              <div className="w-full max-w-md">
+                <button
+                  onClick={() => { if (selectedCoachType) { handleSelect(classModal, isOutbound); } }}
+                  disabled={!selectedCoachType}
+                  className="w-full flex items-center justify-center gap-2.5 px-6 py-3.5 bg-gradient-to-r from-[rgb(20,113,76)] to-[rgb(16,95,65)] hover:from-[rgb(16,89,60)] hover:to-[rgb(12,75,50)] text-white font-bold text-sm rounded-xl transition-all disabled:opacity-50 disabled:cursor-not-allowed shadow-lg shadow-primary/30 disabled:shadow-none hover:shadow-xl hover:scale-[1.02] active:scale-[0.98]"
+                >
+                  <span>{isRoundTrip && isOutbound ? 'Continue to Return Journey' : 'Continue to Passenger Details'}</span>
+                  <ArrowRight className="w-4 h-4" />
+                </button>
+                {!selectedCoachType && (
+                  <p className="text-center text-xs text-gray-500 dark:text-gray-400 mt-3 flex items-center justify-center gap-1">
+                    <span className="w-1.5 h-1.5 rounded-full bg-gray-400 animate-pulse" />
+                    Select a coach type to continue
+                  </p>
+                )}
+              </div>
+            </div>
+        </div>
+        <style>{`
+          @keyframes drawer-slide-in{from{transform:translateX(100%)}to{transform:translateX(0)}}
+          @keyframes fade-in-up{from{opacity:0;transform:translateY(10px)}to{opacity:1;transform:translateY(0)}}
+          @keyframes scale-in{from{transform:scale(0)}to{transform:scale(1)}}
+        `}</style>
+      </>
+    );
+  };
+
+  const renderScheduleCard = (schedule: Schedule, isOutbound: boolean = false, isAlternative: boolean = false) => {
     const scheduleId = schedule.scheduleId || schedule.id || '';
     const selectedCoachType = selectedCoachTypes[scheduleId];
     
@@ -242,7 +435,22 @@ export default function ResultsPage() {
     const isNextDay = departureDate && arrivalDate && departureDate.toDateString() !== arrivalDate.toDateString();
 
     return (
-      <div key={scheduleId} className="card">
+      <div key={scheduleId} className={`card ${isAlternative ? 'border-2 border-amber-200 dark:border-amber-800/60' : ''}`}>
+        {isAlternative && (
+          <div className="flex flex-wrap items-center gap-2 mb-4">
+            <span className="inline-flex items-center gap-1.5 text-xs font-semibold px-2.5 py-1 rounded-full bg-amber-100 dark:bg-amber-900/30 text-amber-700 dark:text-amber-300">
+              <Calendar className="w-3.5 h-3.5" />
+              Different date — {schedule.departureAt ? format(new Date(schedule.departureAt), 'EEEE, MMMM d, yyyy') : 'N/A'}
+            </span>
+            <span className={`inline-flex items-center gap-1.5 text-xs font-semibold px-2.5 py-1 rounded-full ${
+              schedule.hasAvailability
+                ? 'bg-green-100 dark:bg-green-900/30 text-green-700 dark:text-green-300'
+                : 'bg-red-100 dark:bg-red-900/30 text-red-700 dark:text-red-300'
+            }`}>
+              {schedule.hasAvailability ? 'Seats available' : 'Fully booked'}
+            </span>
+          </div>
+        )}
         <div className="flex flex-col lg:flex-row lg:items-center gap-6">
           <div className="flex-1">
             <div className="flex items-center gap-3 mb-4">
@@ -310,9 +518,10 @@ export default function ResultsPage() {
               )}
               <button
                 onClick={() => setClassModal({ ...schedule, isOutbound } as any)}
-                className="btn-secondary w-full flex items-center justify-center gap-2"
+                disabled={isAlternative && schedule.hasAvailability === false}
+                className="btn-secondary w-full flex items-center justify-center gap-2 disabled:opacity-50 disabled:cursor-not-allowed"
               >
-                {selectedCoachType ? 'Change' : 'Select'}
+                {isAlternative && schedule.hasAvailability === false ? 'Unavailable' : selectedCoachType ? 'Change' : 'Select'}
               </button>
             </div>
           </div>
@@ -478,6 +687,54 @@ export default function ResultsPage() {
   }
 
   if (!hasResults) {
+    // ONE_WAY search with an explicit empty outbound list — surface any date-shifted
+    // alternatives the API suggests instead of a dead-end "no trains found" screen.
+    if (isOneWayNoOutbound) {
+      const requestedDateLabel = requestedDate
+        ? format(new Date(`${requestedDate}T00:00:00`), 'EEEE, MMMM d, yyyy')
+        : 'your selected date';
+      const hasAlternatives = alternativeOutbound.length > 0;
+
+      return (
+        <div className="min-h-screen bg-gray-50 dark:bg-gray-900 py-12">
+          {renderClassModal()}
+          <div className="container mx-auto px-4">
+            <div className="max-w-6xl mx-auto">
+              <div className="card text-center mb-8 max-w-3xl mx-auto">
+                <div className="w-20 h-20 bg-amber-100 dark:bg-amber-900/30 rounded-full flex items-center justify-center mx-auto mb-6">
+                  <Calendar className="w-10 h-10 text-amber-500" />
+                </div>
+                <h2 className="text-2xl font-bold mb-3 text-gray-900 dark:text-gray-100">No trains available</h2>
+                <p className="text-gray-600 dark:text-gray-400 mb-8">
+                  No trains are available on <span className="font-semibold text-gray-900 dark:text-gray-100">{requestedDateLabel}</span>. This
+                  may be due to no scheduled service or full capacity. {hasAlternatives
+                    ? 'Please check the alternative options below or try a different date.'
+                    : 'Please try a different date.'}
+                </p>
+                <button onClick={() => router.push(buildSearchUrl())} className="btn-primary">
+                  Change travel date
+                </button>
+              </div>
+
+              {hasAlternatives && (
+                <div>
+                  <div className="mb-4">
+                    <h3 className="text-lg font-bold text-gray-900 dark:text-white">Alternative Travel Options</h3>
+                    <p className="text-sm text-amber-600 dark:text-amber-400 mt-1">
+                      These trains run on different dates than requested — adjust your travel date to book one of them.
+                    </p>
+                  </div>
+                  <div className="space-y-4">
+                    {alternativeOutbound.map((schedule) => renderScheduleCard(schedule, true, true))}
+                  </div>
+                </div>
+              )}
+            </div>
+          </div>
+        </div>
+      );
+    }
+
     return (
       <div className="min-h-screen bg-gray-50 dark:bg-gray-900 py-12">
         <div className="container mx-auto px-4">
@@ -505,183 +762,7 @@ export default function ResultsPage() {
       <div className="container mx-auto px-4">
         <div className="max-w-6xl mx-auto">
 
-          {classModal && (() => {
-            const scheduleId = classModal.scheduleId || classModal.id || '';
-            const selectedCoachType = selectedCoachTypes[scheduleId];
-            const isOutbound = (classModal as any).isOutbound;
-            const coachTypes = classModal.coachTypes || [];
-            
-            const getCoachIcon = (typeName: string) => {
-              const lower = typeName.toLowerCase();
-              if (lower.includes('soft') || lower.includes('vip')) return Star;
-              if (lower.includes('bed')) return Bed;
-              return Armchair;
-            };
-            
-            return (
-              <>
-                <div className="fixed inset-0 z-[99] bg-black/50 backdrop-blur-sm" onClick={() => setClassModal(null)} />
-                <div className="fixed inset-y-0 right-0 z-[100] w-full sm:w-[680px] lg:w-[95vw] xl:w-[90vw] 2xl:w-[85vw] max-w-[1400px] bg-white dark:bg-gray-900 shadow-2xl flex flex-col"
-                  style={{ animation: 'drawer-slide-in 0.3s cubic-bezier(0.22,1,0.36,1)' }}
-                >
-                    <div className="flex items-center justify-between px-6 py-5 border-b border-gray-100 dark:border-gray-800 flex-shrink-0">
-                      <div>
-                        <h2 className="text-lg font-bold text-gray-900 dark:text-white">Choose Your Coach</h2>
-                        <p className="text-xs text-gray-500 dark:text-gray-400 mt-1 flex items-center gap-1.5">
-                          <Train className="w-3.5 h-3.5" />
-                          <span className="font-medium">{classModal.trainNumber}</span>
-                          <span className="text-gray-400">·</span>
-                          <span>{classModal.origin?.name} → {classModal.destination?.name}</span>
-                        </p>
-                      </div>
-                      <button
-                        type="button"
-                        onClick={() => setClassModal(null)}
-                        className="w-10 h-10 flex items-center justify-center rounded-full hover:bg-gray-100 dark:hover:bg-gray-800 transition-all"
-                        aria-label="Close"
-                      >
-                        <X className="w-5 h-5 text-gray-500" />
-                      </button>
-                    </div>
-
-                    <div className="flex-1 overflow-y-auto px-6 py-4">
-                      {coachTypes.length > 0 ? (
-                        <div className="grid grid-cols-1 lg:grid-cols-2 xl:grid-cols-3 gap-4 pt-2">
-                          {coachTypes.map((coachType: any, index: number) => {
-                            const isSelected = selectedCoachType?.id === coachType.coachTypeId;
-                            const minPrice = coachType.classes.length ? Math.min(...coachType.classes.map((c: any) => c.baseFareMinor)) : 0;
-                            const coachCurrency = 'ETB';
-                            const CoachIcon = getCoachIcon(coachType.coachTypeName);
-                            
-                            return (
-                              <button
-                                key={coachType.coachId}
-                                onClick={() => handleSelectCoachType(scheduleId, coachType.coachTypeId, coachType.coachTypeCode, coachType.coachTypeName, coachType.classes?.[0]?.name || coachType.coachTypeName)}
-                                className={`group relative w-full p-5 rounded-2xl border-2 text-left transition-all duration-200 ${
-                                  isSelected
-                                    ? 'border-primary bg-gradient-to-br from-primary/8 to-primary/3 dark:from-primary/15 dark:to-primary/5 shadow-lg shadow-primary/20 scale-[1.02]'
-                                    : 'border-gray-200 dark:border-gray-700 hover:border-primary/40 hover:shadow-md hover:scale-[1.01] bg-white dark:bg-gray-800/50'
-                                }`}
-                                style={{ animation: `fade-in-up 0.3s ease-out ${index * 0.1}s both` }}
-                              >
-                                {isSelected && (
-                                  <div className="absolute top-4 right-4 w-7 h-7 bg-primary rounded-full flex items-center justify-center shadow-lg animate-scale-in">
-                                    <Check className="w-4 h-4 text-white" strokeWidth={3} />
-                                  </div>
-                                )}
-
-                                <div className="flex flex-col">
-                                  <div className="flex items-start gap-4 pr-2">
-                                    <div className={`w-12 h-12 rounded-xl flex items-center justify-center flex-shrink-0 transition-all ${
-                                      isSelected
-                                        ? 'bg-primary/15 dark:bg-primary/25 shadow-inner'
-                                        : 'bg-gray-100 dark:bg-gray-700 group-hover:bg-primary/10'
-                                    }`}>
-                                      <CoachIcon className={`w-6 h-6 transition-colors ${
-                                        isSelected ? 'text-primary' : 'text-gray-600 dark:text-gray-400 group-hover:text-primary'
-                                      }`} />
-                                    </div>
-
-                                    <div className="flex-1 min-w-0">
-                                      <div className="flex items-start justify-between gap-2 mb-2">
-                                        <div>
-                                          <h3 className="font-bold text-base text-gray-900 dark:text-white leading-tight">
-                                            {coachType.coachTypeName}
-                                          </h3>
-                                        </div>
-                                      </div>
-
-                                      <div className="mt-3">
-                                        <div className="flex items-baseline gap-1">
-                                          <span className="text-xs text-gray-500 dark:text-gray-400 font-medium">From</span>
-                                          <span className={`text-2xl font-bold tracking-tight ${
-                                            isSelected ? 'text-primary' : 'text-gray-900 dark:text-white'
-                                          }`}>
-                                            {(minPrice / 100).toFixed(2)}
-                                          </span>
-                                          <span className="text-sm font-semibold text-gray-600 dark:text-gray-400">{coachCurrency}</span>
-                                        </div>
-                                      </div>
-                                    </div>
-                                  </div>
-
-                                  {coachType.classes.length > 0 && (
-                                    <div className="mt-4 pt-4 border-t border-gray-200/60 dark:border-gray-700/60">
-                                      <div className="flex items-center justify-between mb-3">
-                                        <p className="text-xs font-bold text-gray-700 dark:text-gray-300 uppercase tracking-wider">
-                                          Class Options
-                                        </p>
-                                        <span className="text-xs text-gray-500 dark:text-gray-400 font-medium">
-                                          {coachType.classes.length} available
-                                        </span>
-                                      </div>
-                                      <div className="space-y-2.5">
-                                        {coachType.classes.map((cls: any, idx: number) => (
-                                          <div 
-                                            key={idx} 
-                                            className="flex items-center justify-between py-2 px-3 rounded-lg bg-gray-50/80 dark:bg-gray-800/40 hover:bg-gray-100/80 dark:hover:bg-gray-800/60 transition-colors"
-                                          >
-                                            <div className="flex items-center gap-2.5">
-                                              <CoachIcon className="w-3.5 h-3.5 text-gray-500 dark:text-gray-400" />
-                                              <span className="text-sm font-medium text-gray-700 dark:text-gray-300">
-                                                {cls.name}
-                                              </span>
-                                            </div>
-                                            <div className="flex items-baseline gap-1">
-                                              <span className="text-base font-bold tabular-nums text-gray-900 dark:text-white">
-                                                {(cls.baseFareMinor / 100).toFixed(2)}
-                                              </span>
-                                              <span className="text-xs text-gray-500 dark:text-gray-400 font-medium">
-                                                {coachCurrency}
-                                              </span>
-                                            </div>
-                                          </div>
-                                        ))}
-                                      </div>
-                                    </div>
-                                  )}
-                                </div>
-                              </button>
-                            );
-                          })}
-                        </div>
-                      ) : (
-                        <div className="flex flex-col items-center justify-center py-16 text-center">
-                          <div className="w-16 h-16 bg-gray-100 dark:bg-gray-800 rounded-full flex items-center justify-center mb-4">
-                            <Train className="w-8 h-8 text-gray-400" />
-                          </div>
-                          <p className="text-gray-500 dark:text-gray-400 text-sm">No coach types available for this journey</p>
-                        </div>
-                      )}
-                    </div>
-
-                    <div className="px-6 py-5 border-t border-gray-100 dark:border-gray-800 flex-shrink-0 bg-gray-50/50 dark:bg-gray-800/30 flex justify-center">
-                      <div className="w-full max-w-md">
-                        <button
-                          onClick={() => { if (selectedCoachType) { handleSelect(classModal, isOutbound); } }}
-                          disabled={!selectedCoachType}
-                          className="w-full flex items-center justify-center gap-2.5 px-6 py-3.5 bg-gradient-to-r from-[rgb(20,113,76)] to-[rgb(16,95,65)] hover:from-[rgb(16,89,60)] hover:to-[rgb(12,75,50)] text-white font-bold text-sm rounded-xl transition-all disabled:opacity-50 disabled:cursor-not-allowed shadow-lg shadow-primary/30 disabled:shadow-none hover:shadow-xl hover:scale-[1.02] active:scale-[0.98]"
-                        >
-                          <span>{isRoundTrip && isOutbound ? 'Continue to Return Journey' : 'Continue to Passenger Details'}</span>
-                          <ArrowRight className="w-4 h-4" />
-                        </button>
-                        {!selectedCoachType && (
-                          <p className="text-center text-xs text-gray-500 dark:text-gray-400 mt-3 flex items-center justify-center gap-1">
-                            <span className="w-1.5 h-1.5 rounded-full bg-gray-400 animate-pulse" />
-                            Select a coach type to continue
-                          </p>
-                        )}
-                      </div>
-                    </div>
-                </div>
-                <style>{`
-                  @keyframes drawer-slide-in{from{transform:translateX(100%)}to{transform:translateX(0)}}
-                  @keyframes fade-in-up{from{opacity:0;transform:translateY(10px)}to{opacity:1;transform:translateY(0)}}
-                  @keyframes scale-in{from{transform:scale(0)}to{transform:scale(1)}}
-                `}</style>
-              </>
-            );
-          })()}
+          {renderClassModal()}
 
           {promoData && (
             <div className="mb-6 bg-green-50 dark:bg-green-900/20 border border-green-200 dark:border-green-800 rounded-lg p-4 flex items-start gap-3">
diff --git a/apps/edr-passenger-web/portal/src/app/booking/review/page.tsx b/apps/edr-passenger-web/portal/src/app/booking/review/page.tsx
index 89bc115d4..359da2236 100644
--- a/apps/edr-passenger-web/portal/src/app/booking/review/page.tsx
+++ b/apps/edr-passenger-web/portal/src/app/booking/review/page.tsx
@@ -7,21 +7,19 @@ import { useMutation } from '@tanstack/react-query';
 import { apiClient } from '@/lib/api-client';
 import { format } from 'date-fns';
 import { formatTime, getTimePeriod } from '@/utils/format';
-import { useState, useEffect } from 'react';
+import { useState, useEffect, useCallback } from 'react';
 import { ChevronLeft } from 'lucide-react';
-import { calculatePassengerFare, isChild, isFirstChild, formatFare } from '@/utils/fare-utils';
+import { isChild, isFirstChild, formatFare } from '@/utils/fare-utils';
 
 // Helper function to decode JWT token and extract passengerId
 function getPassengerIdFromToken(token: string): string | null {
   try {
     if (!token) {
-      console.warn('No token provided');
       return null;
     }
 
     const parts = token.split('.');
     if (parts.length !== 3) {
-      console.warn('Invalid token format - expected 3 parts, got', parts.length);
       return null;
     }
     
@@ -33,31 +31,27 @@ function getPassengerIdFromToken(token: string): string | null {
     try {
       decoded = JSON.parse(atob(padded));
     } catch (e) {
-      console.error('Failed to parse base64:', e);
       return null;
     }
     
-    console.log('Decoded JWT payload keys:', Object.keys(decoded));
-    console.log('passengerId from JWT:', decoded.passengerId);
     
     if (!decoded.passengerId) {
-      console.warn('No passengerId in JWT payload, available keys:', Object.keys(decoded));
       return null;
     }
     
     return decoded.passengerId;
   } catch (error) {
-    console.error('Error in getPassengerIdFromToken:', error);
     return null;
   }
 }
 
 export default function ReviewPage() {
   const router = useRouter();
-  const { selectedSchedule, outboundSchedule, inboundSchedule, passengers, seatHold, setBookingId, setPNR, createAccount, passengerId: storedPassengerId, searchCriteria } = useBookingStore();
+  const { selectedSchedule, outboundSchedule, inboundSchedule, passengers, seatHold, setBookingId, setPNR, createAccount, passengerId: storedPassengerId, searchCriteria, packageId, priceTierId, packageTierPriceMinor, packageName } = useBookingStore();
   const { user, isAuthenticated } = useAuthStore();
   const [timeLeft, setTimeLeft] = useState<string>('');
   const [seatDetails, setSeatDetails] = useState<Record<string, string>>({});
+  const [fareBreakdown, setFareBreakdown] = useState<any>(null);
 
   const isRoundTrip = searchCriteria?.tripType === 'ROUND_TRIP';
 
@@ -97,8 +91,8 @@ export default function ReviewPage() {
   // The seat class/category is chosen once per leg (coach type selected on /booking/seats),
   // so every seat on that leg shares it — no need to look it up per-seat.
   const formatSeatClass = (schedule: any): string => {
-    const raw = schedule?.selectedSeatClassName || schedule?.seatClassName || schedule?.selectedSeatClass;
-    if (!raw) return 'Standard';
+    const raw = schedule?.seatClassName;
+    if (!raw) return '';
     return String(raw).replace(/_/g, ' ');
   };
 
@@ -148,7 +142,6 @@ export default function ReviewPage() {
         
         setSeatDetails(details);
       } catch (error) {
-        console.error('Failed to fetch seat details:', error);
       }
     };
     
@@ -158,9 +151,6 @@ export default function ReviewPage() {
   const createBookingMutation = useMutation({
     mutationFn: (data: any) => {
       const endpoint = isAuthenticated ? '/bookings' : '/bookings/guest';
-      console.log('=== API REQUEST ===');
-      console.log('Endpoint:', endpoint);
-      console.log('Request Data:', JSON.stringify(data, null, 2));
       return apiClient.post(endpoint, data);
     },
     onSuccess: (data: any) => {
@@ -200,9 +190,8 @@ export default function ReviewPage() {
       }
       
       if (!searchCriteria?.originStationId || !searchCriteria?.destinationStationId) {
-        console.error('Missing search criteria');
         alert('Missing search criteria. Please start over.');
-        router.push('/booking/search');
+        window.location.href = '/';
         return;
       }
       
@@ -224,10 +213,8 @@ export default function ReviewPage() {
 
           seatClassId = outboundClassName ? findByName(outboundClassName) : seatClasses[0].id;
           returnSeatClassId = returnClassName ? findByName(returnClassName) : seatClasses[0].id;
-          console.log('Seat class lookup:', { outboundClassName, returnClassName, seatClassId, returnSeatClassId });
         }
       } catch (err) {
-        console.error('Failed to fetch seat classes:', err);
       }
 
       if (!seatClassId) {
@@ -241,11 +228,9 @@ export default function ReviewPage() {
         const token = typeof window !== 'undefined' ? localStorage.getItem('auth_token') : null;
         
         if (!token) {
-          console.error('No token in localStorage');
           throw new Error('Authentication token not found. Please log in again.');
         }
 
-        console.log('Token found, length:', token.length);
 
         let passengerId = getPassengerIdFromToken(token);
         
@@ -273,7 +258,6 @@ export default function ReviewPage() {
             const me: any = await apiClient.get('/passengers/me');
             passengerId = me?.id || me?.passengerId || '';
           } catch (err) {
-            console.error('Failed to resolve passengerId from /passengers/me:', err);
           }
         }
 
@@ -320,6 +304,10 @@ export default function ReviewPage() {
         if (searchCriteria.promoCode) {
           bookingData.promoCode = searchCriteria.promoCode;
         }
+
+        // Add package fields if this is a package booking
+        if (packageId) bookingData.packageId = packageId;
+        if (priceTierId) bookingData.priceTierId = priceTierId;
       } else {
         // For guests: send full passenger details array
         bookingData = {
@@ -364,17 +352,18 @@ export default function ReviewPage() {
         if (searchCriteria.promoCode) {
           bookingData.promoCode = searchCriteria.promoCode;
         }
+
+        // Add package fields if this is a package booking
+        if (packageId) bookingData.packageId = packageId;
+        if (priceTierId) bookingData.priceTierId = priceTierId;
       }
 
       if (typeof window !== 'undefined' && !isAuthenticated && bookingData.deviceId && !localStorage.getItem('deviceId')) {
         localStorage.setItem('deviceId', bookingData.deviceId);
       }
 
-      console.log('Creating booking with payload:', JSON.stringify(bookingData, null, 2));
-      console.log('API endpoint:', isAuthenticated ? '/bookings' : '/bookings/guest');
       await createBookingMutation.mutateAsync(bookingData);
     } catch (error) {
-      console.error('Error in handleConfirm:', error);
       alert(error instanceof Error ? error.message : 'An unexpected error occurred. Please try again.');
     }
   };
@@ -383,20 +372,71 @@ export default function ReviewPage() {
     if (isRoundTrip) {
       if (!outboundSchedule || !inboundSchedule || !passengers.length) {
         if (!createBookingMutation.isPending && !createBookingMutation.isSuccess) {
-          console.log('Redirecting to search - missing round trip data');
-          router.push('/booking/search');
+          window.location.href = '/';
         }
       }
     } else {
       if (!selectedSchedule || !passengers.length) {
         if (!createBookingMutation.isPending && !createBookingMutation.isSuccess) {
-          console.log('Redirecting to search - missing data');
-          router.push('/booking/search');
+          window.location.href = '/';
         }
       }
     }
   }, [isRoundTrip, selectedSchedule, outboundSchedule, inboundSchedule, passengers.length, createBookingMutation.isPending, createBookingMutation.isSuccess, router]);
 
+  const fetchFareBreakdown = useCallback(async (scheduleId: string, originStationId: string, destinationStationId: string) => {
+    // Package bookings use the stored tier price — no fare calculation needed
+    if (packageTierPriceMinor !== null) return;
+
+    try {
+      const seatClasses: any[] = await apiClient.get('/seat-classes');
+      const scheduleSeatClassName = isRoundTrip
+        ? (outboundSchedule as any)?.seatClassName
+        : (selectedSchedule as any)?.seatClassName;
+      const fallbackSeatClassId = seatClasses.find((sc: any) => sc.name === scheduleSeatClassName)?.id || seatClasses[0]?.id;
+      if (!fallbackSeatClassId) return;
+
+      // Bed coaches price Upper/Middle/Lower as separate classes, so a passenger's own
+      // assigned berth (captured on the seats page) must resolve its own seatClassId here
+      // — a single shared class can't correctly price passengers in different berths.
+      const resolveSeatClassId = (p: any): string => {
+        const bedPosition: string | undefined = isRoundTrip ? (p as any).outboundBedPosition : (p as any).bedPosition;
+        if (!bedPosition) return fallbackSeatClassId;
+        const match = seatClasses.find((sc: any) => sc.name?.toLowerCase().includes(bedPosition));
+        return match?.id || fallbackSeatClassId;
+      };
+
+      const passengersParam = JSON.stringify(
+        passengers.map(p => ({
+          passengerName: p.name,
+          dateOfBirth: p.dateOfBirth,
+          seatClassId: resolveSeatClassId(p),
+          nationality: p.nationality,
+        }))
+      );
+
+      const params = new URLSearchParams({
+        scheduleId,
+        originStationId,
+        destinationStationId,
+        passengers: passengersParam,
+        displayCurrency,
+        ...(searchCriteria?.promoCode ? { promoCode: searchCriteria.promoCode } : {}),
+      });
+
+      const result: any = await apiClient.get(`/search/fare-breakdown?${params}`);
+      setFareBreakdown(result);
+    } catch (err) {
+    }
+  }, [packageTierPriceMinor, passengers, selectedSchedule, outboundSchedule, isRoundTrip, searchCriteria, displayCurrency]);
+
+  useEffect(() => {
+    if (!searchCriteria?.originStationId || !searchCriteria?.destinationStationId) return;
+    const scheduleId = isRoundTrip ? outboundSchedule?.id : selectedSchedule?.id;
+    if (!scheduleId) return;
+    fetchFareBreakdown(scheduleId, searchCriteria.originStationId, searchCriteria.destinationStationId);
+  }, [fetchFareBreakdown, isRoundTrip, outboundSchedule?.id, selectedSchedule?.id, searchCriteria?.originStationId, searchCriteria?.destinationStationId]);
+
   if (isRoundTrip && (!outboundSchedule || !inboundSchedule || !passengers.length)) {
     return null;
   }
@@ -405,20 +445,37 @@ export default function ReviewPage() {
     return null;
   }
 
+  const isPackageBooking = packageTierPriceMinor !== null;
+  // packageTierPriceMinor is the per-adult fare for ONE leg.
+  // Round-trip packages multiply by 2; children pay 10% of the adult fare.
+  const pkgRoundTripMultiplier = isPackageBooking && isRoundTrip ? 2 : 1;
+  const pkgAdultFare = isPackageBooking ? packageTierPriceMinor! * pkgRoundTripMultiplier : 0;
+  const pkgChildFare = isPackageBooking ? Math.round(pkgAdultFare * 0.1) : 0;
+  const adultPassengerCount = searchCriteria?.adultCount ?? passengers.filter(p => !isChild(p)).length;
+  const childPassengerCount = searchCriteria?.childCount ?? passengers.filter(p => isChild(p)).length;
 
-  const outboundBaseFare = isRoundTrip && outboundSchedule ? passengers.reduce((sum, _, i) => {
-    return sum + calculatePassengerFare(passengers, i, outboundSchedule.baseFareAdult || 0);
-  }, 0) : 0;
-  
-  const inboundBaseFare = isRoundTrip && inboundSchedule ? passengers.reduce((sum, _, i) => {
-    return sum + calculatePassengerFare(passengers, i, inboundSchedule.baseFareAdult || 0);
-  }, 0) : 0;
-  
-  const baseFare = isRoundTrip ? (outboundBaseFare + inboundBaseFare) : passengers.reduce((sum, _, i) => {
-    const farePerPassenger = selectedSchedule?.baseFareAdult || (selectedSchedule as any)?.fareAdult || (selectedSchedule as any)?.price || 0;
-    return sum + calculatePassengerFare(passengers, i, farePerPassenger);
-  }, 0);
-  const total = baseFare;
+  // Per-seat fare captured on the seats page (bed-position-aware, computed locally from
+  // the schedule's own coachTypes/classes) is guaranteed correct for berths, unlike the
+  // backend /search/fare-breakdown call whose seatClassId matching for bed positions can't
+  // be verified here. Prefer it whenever the passenger actually has an assigned seat.
+  const getPassengerSeatFare = (p: any): number | null => {
+    if (isRoundTrip) {
+      if (p.outboundSeatFareMinor == null && p.inboundSeatFareMinor == null) return null;
+      return (p.outboundSeatFareMinor ?? 0) + (p.inboundSeatFareMinor ?? 0);
+    }
+    return p.seatFareMinor ?? null;
+  };
+
+  const total = isPackageBooking
+    ? adultPassengerCount * pkgAdultFare + childPassengerCount * pkgChildFare
+    : passengers.reduce((sum, p, i) => {
+        const isChildPassenger = isChild(p);
+        const line = fareBreakdown?.passengers?.[i];
+        const isFreeChild = line?.isFree ?? (isChildPassenger && isFirstChild(passengers, i));
+        if (isFreeChild) return sum;
+        const seatFare = getPassengerSeatFare(p);
+        return sum + (seatFare ?? line?.fareMinor ?? 0);
+      }, 0);
 
   // Shared fare sidebar — rendered in right column (desktop) and inline (mobile)
   const FareSidebar = () => (
@@ -427,29 +484,24 @@ export default function ReviewPage() {
         Fare breakdown
       </h2>
       {passengers.map((p, i) => {
-        const outFare   = outboundSchedule?.baseFareAdult || 0;
-        const inFare    = inboundSchedule?.baseFareAdult  || 0;
-        const onewayFare = selectedSchedule?.baseFareAdult || 0;
-        
-        // Apply first child free logic using utility functions
-        const outboundFare = calculatePassengerFare(passengers, i, outFare);
-        const inboundFare = calculatePassengerFare(passengers, i, inFare);
-        const oneWayFare = calculatePassengerFare(passengers, i, onewayFare);
-        
-        const passengerTotal = isRoundTrip ? outboundFare + inboundFare : oneWayFare;
+        const line = fareBreakdown?.passengers?.[i];
         const isChildPassenger = isChild(p);
-        const isFreeChild = isChildPassenger && isFirstChild(passengers, i);
-        
+        const isFreeChild = !isPackageBooking && (line?.isFree ?? (isChildPassenger && isFirstChild(passengers, i)));
+        const seatFare = getPassengerSeatFare(p);
+        const passengerTotal = isPackageBooking
+          ? (isChildPassenger ? pkgChildFare : pkgAdultFare)
+          : (isFreeChild ? 0 : (seatFare ?? line?.fareMinor ?? 0));
+
         return (
           <div key={i} className="border-b border-gray-100 dark:border-gray-800 pb-2 last:border-0">
             <div className="flex justify-between mb-0.5">
               <span className="text-sm font-medium text-gray-900 dark:text-gray-100 truncate max-w-[60%]">
-                {p.name || `Passenger ${i + 1}`} 
+                {p.name || `Passenger ${i + 1}`}
                 {isChildPassenger && (
                   <span className={`text-xs font-semibold ml-1 ${
-                    isFreeChild ? 'text-green-600' : 'text-blue-600'
+                    isPackageBooking ? 'text-blue-600' : isFreeChild ? 'text-green-600' : 'text-blue-600'
                   }`}>
-                    ({isFreeChild ? 'CHILD - FREE' : 'CHILD'})
+                    ({isPackageBooking ? 'CHILD - 10%' : isFreeChild ? 'CHILD - FREE' : 'CHILD'})
                   </span>
                 )}
               </span>
@@ -457,18 +509,6 @@ export default function ReviewPage() {
                 {formatFare(passengerTotal, displayCurrency)}
               </span>
             </div>
-            {isRoundTrip && (
-              <div className="pl-3 space-y-0.5 text-xs text-gray-500 dark:text-gray-400">
-                <div className="flex justify-between">
-                  <span>Outbound {isFreeChild ? '(Free)' : ''}</span>
-                  <span>{formatFare(outboundFare, displayCurrency)}</span>
-                </div>
-                <div className="flex justify-between">
-                  <span>Return {isFreeChild ? '(Free)' : ''}</span>
-                  <span>{formatFare(inboundFare, displayCurrency)}</span>
-                </div>
-              </div>
-            )}
           </div>
         );
       })}
@@ -503,7 +543,9 @@ export default function ReviewPage() {
     <div className="min-h-screen bg-gray-50 dark:bg-gray-900 py-6 pb-28 lg:pb-10">
       <div className="container mx-auto px-4">
         <div className="max-w-6xl mx-auto">
-          <h1 className="text-2xl font-bold mb-4 text-gray-900 dark:text-gray-100">Review your booking</h1>
+          <h1 className="text-2xl font-bold mb-4 text-gray-900 dark:text-gray-100">
+            {packageName ? `Review your ${packageName} booking` : 'Review your booking'}
+          </h1>
 
           {seatHold && (
             <div className="bg-yellow-50 dark:bg-yellow-900/20 border border-yellow-200 dark:border-yellow-800 rounded-lg p-3 mb-4 flex items-center gap-2">
@@ -767,7 +809,8 @@ export default function ReviewPage() {
                         <div className="bg-gray-50 dark:bg-gray-800 rounded-lg p-2">
                           <p className="text-xs text-gray-500 dark:text-gray-400">Outbound Seat</p>
                           <p className="font-semibold text-sm text-gray-900 dark:text-gray-100">
-                            {(p as any).outboundSeatId ? (seatDetails[`outbound-${(p as any).outboundSeatId}`] || 'Loading...') : 'Auto-assign'}
+                            {(p as any).outboundCoachNumber && <span className="text-gray-500 dark:text-gray-400 ml-1">{(p as any).outboundCoachNumber} — </span>}
+                            {(p as any).outboundSeatId ? (seatDetails[`outbound-${(p as any).outboundSeatId}`] || 'Loading...') : 'Auto-assign'}                            
                           </p>
                           {(p as any).outboundSeatId && (
                             <p className="text-[10px] text-gray-400 dark:text-gray-500 mt-0.5">{formatSeatClass(outboundSchedule)}</p>
@@ -776,6 +819,7 @@ export default function ReviewPage() {
                         <div className="bg-gray-50 dark:bg-gray-800 rounded-lg p-2">
                           <p className="text-xs text-gray-500 dark:text-gray-400">Return Seat</p>
                           <p className="font-semibold text-sm text-gray-900 dark:text-gray-100">
+                            {(p as any).inboundCoachNumber && <span className="text-gray-500 dark:text-gray-400 ml-1">{(p as any).inboundCoachNumber}  —</span>}
                             {(p as any).inboundSeatId ? (seatDetails[`inbound-${(p as any).inboundSeatId}`] || 'Loading...') : 'Auto-assign'}
                           </p>
                           {(p as any).inboundSeatId && (
@@ -786,7 +830,10 @@ export default function ReviewPage() {
                     ) : (
                       <div className="text-right">
                         <p className="text-sm text-gray-600 dark:text-gray-400">Seat</p>
-                        <p className="font-medium text-gray-900 dark:text-gray-100">{p.seatId ? (seatDetails[p.seatId] || 'Loading...') : 'Auto-assign'}</p>
+                        <p className="font-medium text-gray-900 dark:text-gray-100">
+                          {p.coachNumber && <span className="text-gray-500 dark:text-gray-400 ml-1">{p.coachNumber} — </span>}
+                          {p.seatId ? (seatDetails[p.seatId] || 'Loading...') : 'Auto-assign'}
+                        </p>
                         {p.seatId && (
                           <p className="text-[10px] text-gray-400 dark:text-gray-500 mt-0.5">{formatSeatClass(selectedSchedule)}</p>
                         )}
diff --git a/apps/edr-passenger-web/portal/src/app/booking/seats/page.tsx b/apps/edr-passenger-web/portal/src/app/booking/seats/page.tsx
index d8fdd4da6..b1987f588 100644
--- a/apps/edr-passenger-web/portal/src/app/booking/seats/page.tsx
+++ b/apps/edr-passenger-web/portal/src/app/booking/seats/page.tsx
@@ -6,11 +6,12 @@ import { useRouter } from "next/navigation";
 import { useBookingStore } from "@/lib/booking-store";
 import { useQuery, useMutation } from "@tanstack/react-query";
 import { apiClient } from "@/lib/api-client";
-import { useState, useEffect, useCallback, useMemo, memo } from "react";
-import { Armchair, Bed, ChevronLeft, ChevronDown } from "lucide-react";
+import { useState, useEffect, useCallback, useMemo, useRef, memo } from "react";
+import { Armchair, Bed, ChevronLeft, ChevronDown, Train, TrainFront, X } from "lucide-react";
 import Image from "next/image";
 
 import CustomModal from "@/components/CustomModal";
+import { isChild } from "@/utils/fare-utils";
 
 const BED_POSITION_SUFFIX: Record<string, string> = { lower: 'L', middle: 'M', upper: 'U' };
 
@@ -36,28 +37,34 @@ const BedCard = memo(({ bed, isSelected, isAssignedToOther, onToggle }: any) =>
     <button
       onClick={() => onToggle(bed.id)}
       disabled={isDisabled}
-      className={`relative flex flex-col items-center justify-center gap-1 px-3 py-2 rounded-lg transition-all ${
-        isSelected
-          ? "bg-blue-50 border-2 border-blue-500 dark:bg-blue-900/20 dark:border-blue-400"
-          : isAssignedToOther
-            ? "bg-purple-50 border border-purple-300 cursor-not-allowed dark:bg-purple-900/20 dark:border-purple-700"
-            : bed.status === "AVAILABLE"
-              ? "bg-green-50 border border-green-300 hover:bg-green-100 dark:bg-green-900/20 dark:border-green-700"
-              : bed.status === "BOOKED"
-                ? "bg-red-50 border border-red-300 cursor-not-allowed dark:bg-red-900/20 dark:border-red-700"
-                : "bg-gray-100 border border-gray-300 cursor-not-allowed dark:bg-gray-800 dark:border-gray-700"
-      }`}
       title={
         isAssignedToOther
           ? `Bed ${seatLabel} - already assigned to another passenger`
-          : `Bed ${seatLabel} - ${bedType} - ${bed.status}`
+          : `${bedType} Berth ${seatLabel} - ${bed.status}`
       }
+      className={`relative flex flex-col items-center justify-center gap-0.5 w-16 sm:w-[4.5rem] py-2.5 rounded-xl border shadow-sm transition-all duration-150 ${
+        isDisabled ? "" : "hover:shadow-md hover:-translate-y-0.5 active:translate-y-0 active:scale-95"
+      } ${
+        isSelected
+          ? "bg-blue-50 border-2 border-blue-500 shadow-blue-200/60 dark:bg-blue-900/30 dark:border-blue-400 dark:shadow-none scale-[1.03]"
+          : isAssignedToOther
+            ? "bg-purple-50 border-purple-300 cursor-not-allowed dark:bg-purple-900/20 dark:border-purple-700"
+            : bed.status === "AVAILABLE"
+              ? "bg-green-50 border-green-300 hover:bg-green-100 hover:border-green-400 dark:bg-green-900/20 dark:border-green-700"
+              : bed.status === "BOOKED"
+                ? "bg-red-50 border-red-300 cursor-not-allowed dark:bg-red-900/20 dark:border-red-700"
+                : "bg-gray-100 border-gray-300 cursor-not-allowed dark:bg-gray-800 dark:border-gray-700"
+      }`}
     >
-      <Image src="/bed.png" alt="bed" width={32} height={32} className="object-contain" />
+      {/* bed.png is a portrait (headboard-to-footboard) silhouette; rotate it so the
+          berth lies horizontally, matching the direction beds actually run in the coach. */}
+      <div className="w-9 h-6 flex items-center justify-center overflow-visible">
+        <Image src="/bed.png" alt="bed" width={22} height={36} className="object-contain rotate-90" />
+      </div>
       <div className="text-xs font-bold text-gray-900 dark:text-white">
         {seatLabel}
       </div>
-      <div className="text-[10px] text-gray-600 dark:text-gray-400">
+      <div className="text-[10px] font-medium text-gray-500 dark:text-gray-400">
         {bedType}
       </div>
     </button>
@@ -66,6 +73,31 @@ const BedCard = memo(({ bed, isSelected, isAssignedToOther, onToggle }: any) =>
 
 BedCard.displayName = "BedCard";
 
+// A real berth ladder is a single fixed rail mounted at the end of the bay that a
+// passenger climbs to reach every level — not a separate rung floating between each
+// pair of beds. So this renders once per bay, right after the last berth card, with
+// solid rounded rails/rungs (like a real metal ladder) rather than thin decorative lines.
+const LadderConnector = memo(() => (
+  <div
+    className="flex flex-col items-center justify-center flex-shrink-0 self-stretch w-6 sm:w-7 py-1.5"
+    title="Ladder to the middle & upper berths"
+    aria-hidden="true"
+  >
+    <svg width="100%" height="100%" viewBox="0 0 24 90" preserveAspectRatio="none" className="text-gray-400 dark:text-gray-500 drop-shadow-sm">
+      {/* Side rails */}
+      <rect x="2" y="0" width="3.5" height="90" rx="1.75" fill="currentColor" />
+      <rect x="18.5" y="0" width="3.5" height="90" rx="1.75" fill="currentColor" />
+      {/* Rungs, evenly spaced top (upper) to bottom (lower) */}
+      <rect x="2" y="6" width="20" height="4" rx="2" fill="currentColor" />
+      <rect x="2" y="30" width="20" height="4" rx="2" fill="currentColor" />
+      <rect x="2" y="54" width="20" height="4" rx="2" fill="currentColor" />
+      <rect x="2" y="78" width="20" height="4" rx="2" fill="currentColor" />
+    </svg>
+  </div>
+));
+
+LadderConnector.displayName = "LadderConnector";
+
 const SeatButton = memo(
   ({
     seat,
@@ -134,14 +166,27 @@ export default function SeatsPage() {
     passengers,
     setSeatHold,
     setPassengers,
+    setSelectedSchedule,
+    setOutboundSchedule,
+    setInboundSchedule,
     searchCriteria,
     bookingId,
+    packageName,
   } = useBookingStore();
   // Maps passenger index -> assigned seat id. A passenger can only get a seat while
   // they are the "active" passenger, which prevents bulk/batch selection across passengers.
   const [passengerSeatMap, setPassengerSeatMap] = useState<Record<number, string>>({});
+  // Outbound seat IDs locked in after the outbound hold — used to prevent the
+  // same physical seat being picked again on the inbound leg.
+
   const [activePassengerIndex, setActivePassengerIndex] = useState(0);
   const [selectedCoach, setSelectedCoach] = useState<string | null>(null);
+  // Label of the coach the user picked from the Train Coach Preview, waiting to be
+  // focused once the (possibly newly-fetched) seat map data for its coach type is ready.
+  // Matched by label rather than id since the preview and seatmap endpoints are separate
+  // API calls and may not share the same coach id scheme.
+  const [pendingCoachLabel, setPendingCoachLabel] = useState<string | null>(null);
+  const [showCoachPreview, setShowCoachPreview] = useState(false);
   const [currentJourneyType, setCurrentJourneyType] = useState<
     "outbound" | "inbound"
   >("outbound");
@@ -150,6 +195,8 @@ export default function SeatsPage() {
     title: "",
     message: "",
     type: "info" as "warning" | "error" | "success" | "info",
+    onConfirm: undefined as (() => void) | undefined,
+    showCancel: false,
   });
 
   const isRoundTrip = searchCriteria?.tripType === "ROUND_TRIP";
@@ -160,35 +207,238 @@ export default function SeatsPage() {
         ? outboundSchedule
         : selectedSchedule;
   const coachTypeId = (currentSchedule as any)?.selectedCoachTypeId;
+  const journeyDirection = isRoundTrip
+    ? currentJourneyType === "inbound" ? "RETURN" : "OUTBOUND"
+    : "ONE_WAY";
+
+  // Baseline fare for each leg as it was when this page first loaded — i.e. whatever was
+  // picked on the results page ("starting from" price). Captured once and never
+  // overwritten, so a later coach-type switch (or just picking a pricier berth) can still
+  // be compared against what the user originally saw/selected.
+  const originalFaresRef = useRef<{ outbound: number | null; inbound: number | null; oneWay: number | null }>({
+    outbound: null,
+    inbound: null,
+    oneWay: null,
+  });
+  if (originalFaresRef.current.outbound === null && outboundSchedule?.baseFareAdult != null) {
+    originalFaresRef.current.outbound = outboundSchedule.baseFareAdult;
+  }
+  if (originalFaresRef.current.inbound === null && inboundSchedule?.baseFareAdult != null) {
+    originalFaresRef.current.inbound = inboundSchedule.baseFareAdult;
+  }
+  if (originalFaresRef.current.oneWay === null && selectedSchedule?.baseFareAdult != null) {
+    originalFaresRef.current.oneWay = selectedSchedule.baseFareAdult;
+  }
+  const originalFareForCurrentLeg = isRoundTrip
+    ? (currentJourneyType === "inbound" ? originalFaresRef.current.inbound : originalFaresRef.current.outbound)
+    : originalFaresRef.current.oneWay;
+
+  // Child seat allocation rule: let A = adults, C = children (isChild = under 5).
+  // If C > A, only A - 1 children get their own seat and the rest share with an adult.
+  // If C <= A, no child gets a separate seat — all of them share with an adult.
+  // Adults always need their own seat.
+  const seatEligibility = useMemo(() => {
+    const adultIndices = passengers.map((_, i) => i).filter((i) => !isChild(passengers[i]));
+    const childIndices = passengers.map((_, i) => i).filter((i) => isChild(passengers[i]));
+    const adultCount = adultIndices.length;
+    const childCount = childIndices.length;
+    const eligibleChildCount = childCount > adultCount ? Math.max(adultCount - 1, 0) : 0;
+    const eligibleChildIndices = childIndices.slice(0, eligibleChildCount);
+    const eligibleSet = new Set<number>([...adultIndices, ...eligibleChildIndices]);
+
+    // Children who don't get their own seat share with an adult (round-robin, for display).
+    const sharingWithAdult = new Map<number, string>();
+    childIndices.slice(eligibleChildCount).forEach((childIdx, offset) => {
+      const adultIdx = adultIndices[offset % Math.max(adultIndices.length, 1)];
+      if (adultIdx != null) {
+        sharingWithAdult.set(childIdx, passengers[adultIdx]?.name || `Adult ${adultIdx + 1}`);
+      }
+    });
+
+    return { eligibleSet, sharingWithAdult };
+  }, [passengers]);
+
+  const seatEligibleIndices = useMemo(
+    () => passengers.map((_, i) => i).filter((i) => seatEligibility.eligibleSet.has(i)),
+    [passengers, seatEligibility],
+  );
 
   const {
     data: seatMapData,
     isLoading,
     error,
   } = useQuery({
-    queryKey: ["seatmap", currentSchedule?.id, coachTypeId, currentJourneyType],
+    queryKey: ["seatmap", currentSchedule?.id, coachTypeId, currentJourneyType, (currentSchedule as any)?.originStationId, (currentSchedule as any)?.destinationStationId],
     queryFn: async () => {
-      const endpoint = `/seats/seatmap/${currentSchedule?.id}?coachTypeId=${coachTypeId}`;
-      console.log("🪑 Seatmap Request:", {
-        endpoint,
-      });
+      const scheduleForMap = isRoundTrip && currentJourneyType === "inbound" ? inboundSchedule : (isRoundTrip ? outboundSchedule : selectedSchedule);
+      const originId = (scheduleForMap as any)?.originStationId || searchCriteria?.originStationId;
+      const destinationId = (scheduleForMap as any)?.destinationStationId || searchCriteria?.destinationStationId;
+      const endpoint = `/seats/seatmap/${currentSchedule?.id}?coachTypeId=${coachTypeId}&journeyDirection=${journeyDirection}${originId ? `&originStationId=${originId}` : ''}${destinationId ? `&destinationStationId=${destinationId}` : ''}`;
 
       const response = await apiClient.get(endpoint);
 
-      console.log("✅ Seatmap Response:", {
-        endpoint,
-        fullResponse: response,
-        dataCoaches: (response as any)?.data?.coaches?.length || 0,
-        rootCoaches: (response as any)?.coaches?.length || 0,
-      });
 
       const finalData = (response as any)?.data || response;
-      console.log("🎯 Final data structure:", finalData);
       return finalData;
     },
     enabled: !!currentSchedule?.id && !!coachTypeId,
   });
 
+  // Whole-train coach layout for the "Preview Train Coach" panel — a separate, lazily
+  // fetched list of every coach on this schedule (not just the currently selected coach
+  // type), so users can see the full train arrangement and spot the dining coach.
+  const { data: trainCoachesData, isLoading: loadingTrainCoaches } = useQuery({
+    queryKey: ["trainCoaches", currentSchedule?.id],
+    queryFn: async () => {
+      const response = await apiClient.get(`/seats/coaches/${currentSchedule?.id}`);
+      return (response as any)?.data || response;
+    },
+    enabled: showCoachPreview && !!currentSchedule?.id,
+  });
+
+  const trainCoachList = useMemo(() => {
+    const raw = (trainCoachesData as any)?.coaches || trainCoachesData || [];
+    if (!Array.isArray(raw)) return [];
+    return raw
+      .map((c: any, idx: number) => ({
+        id: c.id || c.coachId || String(idx),
+        label: c.label || c.coachNumber || c.name || c.coachTypeName || `Coach ${idx + 1}`,
+        type: String(c.type || c.coachType || c.category || c.coachTypeCode || c.coachTypeName || ""),
+        typeName: c.coachTypeName || c.coachType || c.category || c.type || "",
+        coachTypeId: c.coachTypeId ?? c.typeId ?? null,
+        remainingSeats: c.remainingSeats ?? c.availableSeats ?? c.available ?? null,
+        sequence: c.sequence ?? c.order ?? idx,
+      }))
+      .sort((a: any, b: any) => a.sequence - b.sequence);
+  }, [trainCoachesData]);
+
+  const isDiningCoachType = (type: string) => /dining|dpc/i.test(type);
+
+  // Looks up a coach type's lowest per-adult fare from the coach-type/fare data captured
+  // when this schedule was first selected on the results page (see booking-store.ts).
+  // Returns null if the type can't be matched or has no priced classes.
+  const getCoachTypeFare = (coachTypeId: string | null | undefined): number | null => {
+    if (!coachTypeId) return null;
+    const types = (currentSchedule as any)?.coachTypes || [];
+    const match = types.find((ct: any) => ct.coachTypeId === coachTypeId || ct.coachId === coachTypeId);
+    const fares = (match?.classes || []).map((c: any) => c.baseFareMinor).filter((f: number) => f > 0);
+    return fares.length ? Math.min(...fares) : null;
+  };
+
+  // The current coach type's priced classes (e.g. bed coaches price Upper/Middle/Lower
+  // differently) — used to look up the real fare for a specific seat, not just the
+  // coach type's cheapest class.
+  const currentCoachTypeClasses = useMemo(() => {
+    const types = (currentSchedule as any)?.coachTypes || [];
+    const match = types.find((ct: any) => ct.coachTypeId === coachTypeId || ct.coachId === coachTypeId);
+    return match?.classes || [];
+  }, [currentSchedule, coachTypeId]);
+
+  // A specific seat's actual fare: bed positions (Upper/Middle/Lower) are priced as
+  // separate classes, so this can differ from the coach type's flat minimum fare.
+  const getSeatFare = useCallback(
+    (seat: any): number | null => {
+      if (!currentCoachTypeClasses.length) return null;
+      if (seat?.bedPosition) {
+        const match = currentCoachTypeClasses.find((c: any) =>
+          c.name?.toLowerCase().includes(seat.bedPosition),
+        );
+        if (match) return match.baseFareMinor;
+      }
+      const regular = currentCoachTypeClasses.find((c: any) => /regular/i.test(c.name || ""));
+      return (regular || currentCoachTypeClasses[0])?.baseFareMinor ?? null;
+    },
+    [currentCoachTypeClasses],
+  );
+
+  // Switches the schedule to a different coach type (updates fare/class fields in the
+  // booking store, which the seatmap query picks up automatically since it's keyed on
+  // coachTypeId) and clears any seat picks made under the old coach type, since they no
+  // longer correspond to real seats. Queues the clicked coach's label to be focused once
+  // the new seat map data has finished loading.
+  const applyCoachTypeSwitch = (coach: any, matchedType: any) => {
+    const newFare = getCoachTypeFare(matchedType.coachTypeId || matchedType.coachId);
+    const firstClass = matchedType.classes?.[0];
+    const updatedSchedule = {
+      ...(currentSchedule as any),
+      selectedCoachTypeId: matchedType.coachTypeId || matchedType.coachId,
+      selectedCoachTypeCode: matchedType.coachTypeCode,
+      selectedCoachTypeName: matchedType.coachTypeName,
+      selectedSeatClass: firstClass?.name || matchedType.coachTypeName,
+      selectedSeatClassName: firstClass?.name || matchedType.coachTypeName,
+      // review/page.tsx's fare-breakdown request reads THIS field (not
+      // selectedSeatClassName) to resolve the seat class — must stay in sync or the
+      // review page keeps pricing against the coach type the user switched away from.
+      seatClassName: firstClass?.name || matchedType.coachTypeName,
+      baseFareAdult: newFare ?? (currentSchedule as any)?.baseFareAdult,
+      baseFareChild: newFare ?? (currentSchedule as any)?.baseFareChild,
+    };
+
+    if (isRoundTrip && currentJourneyType === "inbound") {
+      setInboundSchedule(updatedSchedule);
+    } else if (isRoundTrip) {
+      setOutboundSchedule(updatedSchedule);
+    } else {
+      setSelectedSchedule(updatedSchedule);
+    }
+
+    setPassengerSeatMap({});
+    setActivePassengerIndex(seatEligibleIndices[0] ?? 0);
+    setSelectedCoach(null);
+    setPendingCoachLabel(coach.label);
+    setShowCoachPreview(false);
+  };
+
+  // Same coach type as the one already loaded — no refetch needed, just bring this
+  // specific physical coach into view once we can match it against the (already
+  // available) seat map data.
+  const focusCoachInPlace = (coach: any) => {
+    setPendingCoachLabel(coach.label);
+    setShowCoachPreview(false);
+  };
+
+  // Coach card click handler for the Train Coach Preview: validates availability, then
+  // immediately loads that coach's seat map (switching coach type if needed) — no price
+  // confirmation here. Individual seats within a coach type/bed coach can still be priced
+  // differently (e.g. Upper/Middle/Lower berths), so the fare confirmation instead happens
+  // at the point of actually picking a seat (see handleSeatClick), once real seat data is
+  // in view.
+  const handlePreviewCoachSelect = (coach: any) => {
+    if (coach.remainingSeats != null && coach.remainingSeats <= 0) {
+      setModalState({
+        isOpen: true,
+        title: "Coach Full",
+        message: `${coach.label} has no remaining seats. Please choose a different coach.`,
+        type: "warning",
+        onConfirm: undefined,
+        showCancel: false,
+      });
+      return;
+    }
+
+    const types = (currentSchedule as any)?.coachTypes || [];
+    const matchedType = types.find(
+      (ct: any) =>
+        ct.coachTypeId === coach.coachTypeId ||
+        ct.coachId === coach.coachTypeId ||
+        ct.coachTypeCode === coach.type ||
+        ct.coachTypeName === coach.type,
+    );
+    const isSameType =
+      matchedType &&
+      (matchedType.coachTypeId === coachTypeId || matchedType.coachId === coachTypeId);
+
+    if (!matchedType || isSameType) {
+      // Same coach type — just bring this physical coach's seat map into view.
+      focusCoachInPlace(coach);
+      return;
+    }
+
+    // Different coach type — switch to it and load its seat map; per-seat fare
+    // confirmation (if any) happens once the user picks an actual seat.
+    applyCoachTypeSwitch(coach, matchedType);
+  };
+
   const holdMutation = useMutation({
     mutationFn: async (seatIds: string[]) => {
       const passengersForHold = passengers
@@ -198,24 +448,24 @@ export default function SeatsPage() {
           seatId: seatIds[i],
         }));
 
-      // For round trip inbound, swap origin and destination
-      const isInbound = isRoundTrip && currentJourneyType === "inbound";
-      const originId = isInbound
-        ? searchCriteria?.destinationStationId
-        : searchCriteria?.originStationId;
-      const destinationId = isInbound
-        ? searchCriteria?.originStationId
-        : searchCriteria?.destinationStationId;
+      const isInbound = currentJourneyType === "inbound";
+
+      // Always use the schedule's own station IDs (set from schedule.origin.id / schedule.destination.id)
+      // so they are guaranteed to exist in the trip's TripStopTime records.
+      const scheduleForHold = isInbound && inboundSchedule ? inboundSchedule : (outboundSchedule || selectedSchedule);
+      const originId = (scheduleForHold as any)?.originStationId || searchCriteria?.originStationId;
+      const destinationId = (scheduleForHold as any)?.destinationStationId || searchCriteria?.destinationStationId;
 
       return apiClient.post(`/seats/hold`, {
         scheduleId: currentSchedule?.id,
         originStationId: originId,
         destinationStationId: destinationId,
+        journeyDirection: isInbound ? "RETURN" : "OUTBOUND",
         passengers: passengersForHold,
       });
     },
     onSuccess: (data: any) => {
-      const isInbound = isRoundTrip && currentJourneyType === "inbound";
+      const isInbound = currentJourneyType === "inbound";
       if (isInbound) {
         // Merge the return hold into the existing outbound hold
         const current = useBookingStore.getState().seatHold;
@@ -253,29 +503,10 @@ export default function SeatsPage() {
       (seatMapData as any)?.coaches ||
       (seatMapData as any)?.data?.coaches ||
       [];
-    console.log("📦 Raw coaches data:", {
-      fromRoot: (seatMapData as any)?.coaches?.length || 0,
-      fromData: (seatMapData as any)?.data?.coaches?.length || 0,
-      using: rawCoaches.length,
-      hasRooms: rawCoaches.some((c: any) => c.rooms?.length > 0),
-      sampleRooms: rawCoaches[0]?.rooms?.length || 0,
-    });
     return rawCoaches;
   }, [seatMapData]);
 
   const filteredCoaches = useMemo(() => {
-    console.log("🔍 Filtering coaches:", {
-      totalCoaches: coaches.length,
-      selectedSeatClass: currentSchedule?.selectedSeatClass,
-      coachesData: coaches.map((c: any) => ({
-        id: c.id,
-        name: c.name,
-        label: c.label,
-        seatClass: c.seatClass,
-        seatClasses: c.seatClasses,
-        seatsCount: c.seats?.length || 0,
-      })),
-    });
 
     const coachesWithSeats = coaches.filter((c: any) => {
       // Bed coaches store occupants in rooms.beds, not seats
@@ -283,13 +514,23 @@ export default function SeatsPage() {
       return c.seats && c.seats.length > 0;
     });
 
-    console.log(
-      "✅ Returning all coaches with seats/beds:",
-      coachesWithSeats.length,
-    );
     return coachesWithSeats;
-  }, [coaches, currentSchedule?.selectedSeatClass]);
+  }, [coaches]);
 
+  // Resolves a coach picked from the Train Coach Preview once its seat map data is
+  // actually ready — matching by label (not id) since the preview list and this seat
+  // map come from separate API calls. Waits out any in-flight refetch triggered by a
+  // coach-type switch before trying to match, so it doesn't act on stale/old-type data.
+  useEffect(() => {
+    if (!pendingCoachLabel) return;
+    if (isLoading) return;
+    if (!filteredCoaches.length) return;
+    const match = filteredCoaches.find(
+      (c: any) => (c.label || c.name || c.coachNumber || "") === pendingCoachLabel,
+    );
+    setSelectedCoach((match || filteredCoaches[0])?.id || null);
+    setPendingCoachLabel(null);
+  }, [pendingCoachLabel, filteredCoaches, isLoading]);
 
   const selectedCoachData = useMemo(
     () => filteredCoaches.find((c: any) => c.id === selectedCoach),
@@ -362,20 +603,23 @@ export default function SeatsPage() {
     return seats;
   }, [allSeats, selectedCoachData, currentSchedule?.selectedSeatClass]);
 
-  // Seats already claimed by any passenger in this journey leg
+  // Seats already claimed by any passenger in this journey leg, plus outbound
   const assignedSeatIds = useMemo(
     () => new Set(Object.values(passengerSeatMap)),
     [passengerSeatMap],
   );
 
   // The furthest passenger a user is allowed to jump to — cannot skip ahead of the
-  // first passenger who still needs a seat.
+  // first seat-eligible passenger who still needs a seat. Passengers who share a seat
+  // with an adult (see seatEligibility) never need their own pick.
   const firstUnassignedIndex = useMemo(
-    () => passengers.findIndex((_, i) => !passengerSeatMap[i]),
-    [passengers, passengerSeatMap],
+    () => seatEligibleIndices.find((i) => !passengerSeatMap[i]) ?? -1,
+    [seatEligibleIndices, passengerSeatMap],
   );
   const maxSelectableIndex =
-    firstUnassignedIndex === -1 ? passengers.length - 1 : firstUnassignedIndex;
+    firstUnassignedIndex === -1
+      ? seatEligibleIndices[seatEligibleIndices.length - 1] ?? 0
+      : firstUnassignedIndex;
 
   const isSeatSelected = useCallback(
     (seatId: string) => passengerSeatMap[activePassengerIndex] === seatId,
@@ -392,20 +636,18 @@ export default function SeatsPage() {
 
   const handleSelectPassenger = useCallback(
     (index: number) => {
+      if (!seatEligibility.eligibleSet.has(index)) return; // shares a seat with an adult — no pick needed
       if (index > maxSelectableIndex) return; // no skipping ahead of unassigned passengers
       setActivePassengerIndex(index);
     },
-    [maxSelectableIndex],
+    [maxSelectableIndex, seatEligibility],
   );
 
-  const handleSeatClick = useCallback(
+  // Actually applies a seat pick/deselect for the active passenger — split out from
+  // handleSeatClick so a price-difference confirmation can defer this until the user
+  // confirms, instead of assigning immediately.
+  const commitSeatAssignment = useCallback(
     (seatId: string) => {
-      // Seat already claimed by a different passenger — never allow duplicate assignment
-      const takenByOther = Object.entries(passengerSeatMap).some(
-        ([idx, sid]) => Number(idx) !== activePassengerIndex && sid === seatId,
-      );
-      if (takenByOther) return;
-
       const isDeselecting = passengerSeatMap[activePassengerIndex] === seatId;
       const next = { ...passengerSeatMap };
       if (isDeselecting) {
@@ -417,32 +659,104 @@ export default function SeatsPage() {
 
       if (!isDeselecting) {
         // Move on to the next passenger who still needs a seat — one passenger at a time
-        const nextUnassigned = passengers.findIndex(
-          (_, i) => i !== activePassengerIndex && !next[i],
+        const nextUnassigned = seatEligibleIndices.find(
+          (i) => i !== activePassengerIndex && !next[i],
         );
-        if (nextUnassigned !== -1) setActivePassengerIndex(nextUnassigned);
+        if (nextUnassigned !== undefined) setActivePassengerIndex(nextUnassigned);
       }
     },
-    [passengerSeatMap, activePassengerIndex, passengers],
+    [passengerSeatMap, activePassengerIndex, seatEligibleIndices],
+  );
+
+  const handleSeatClick = useCallback(
+    (seatId: string) => {
+      // Seat already claimed by a different passenger — never allow duplicate assignment
+      const takenByOther = Object.entries(passengerSeatMap).some(
+        ([idx, sid]) => Number(idx) !== activePassengerIndex && sid === seatId,
+      );
+      if (takenByOther) return;
+
+      const isDeselecting = passengerSeatMap[activePassengerIndex] === seatId;
+      if (isDeselecting) {
+        commitSeatAssignment(seatId);
+        return;
+      }
+
+      // Bed coaches price Upper/Middle/Lower differently, so picking a seat whose fare
+      // differs from what the user originally selected (e.g. after switching coach type
+      // via the preview, or just picking a pricier berth) — or from another passenger's
+      // already-selected seat — needs a heads-up before it's applied.
+      const newSeat = validSeats?.find((s: any) => s.id === seatId);
+      const newFare = newSeat ? getSeatFare(newSeat) : null;
+
+      if (newFare != null) {
+        let referenceFare: number | null = null;
+        let referenceLabel = "the fare you originally selected";
+
+        if (originalFareForCurrentLeg != null && originalFareForCurrentLeg !== newFare) {
+          referenceFare = originalFareForCurrentLeg;
+        } else {
+          const differingEntry = Object.entries(passengerSeatMap).find(([idx, sid]) => {
+            if (Number(idx) === activePassengerIndex) return false;
+            const otherSeat = validSeats?.find((s: any) => s.id === sid);
+            const otherFare = otherSeat ? getSeatFare(otherSeat) : null;
+            return otherFare != null && otherFare !== newFare;
+          });
+
+          if (differingEntry) {
+            const otherSeat = validSeats?.find((s: any) => s.id === differingEntry[1]);
+            referenceFare = otherSeat ? getSeatFare(otherSeat) : null;
+            referenceLabel = "another already-selected seat";
+          }
+        }
+
+        if (referenceFare != null) {
+          const seatLabel = buildSeatLabel(newSeat);
+          const positionLabel = newSeat?.bedPosition
+            ? `${newSeat.bedPosition.charAt(0).toUpperCase()}${newSeat.bedPosition.slice(1)} berth`
+            : "This seat";
+
+          setModalState({
+            isOpen: true,
+            title: "Fare Will Change",
+            message: `${positionLabel} ${seatLabel} costs ETB ${(newFare / 100).toFixed(2)}, different from ${referenceLabel}. Continue with this selection?`,
+            type: "warning",
+            showCancel: true,
+            onConfirm: () => commitSeatAssignment(seatId),
+          });
+          return;
+        }
+      }
+
+      commitSeatAssignment(seatId);
+    },
+    [passengerSeatMap, activePassengerIndex, validSeats, getSeatFare, originalFareForCurrentLeg, commitSeatAssignment],
   );
 
   const allSeatsAssigned =
-    passengers.length > 0 &&
-    passengers.every((_, i) => !!passengerSeatMap[i]);
+    seatEligibleIndices.length > 0 &&
+    seatEligibleIndices.every((i) => !!passengerSeatMap[i]);
 
   const handleContinue = async () => {
     if (!allSeatsAssigned) return;
+    // Indexed by original passenger position — holes for passengers who share a seat
+    // with an adult (no seat picked, and none required).
     const seatIds = passengers.map((_, i) => passengerSeatMap[i]);
+    // Only real, distinct seat ids go to the hold API.
+    const seatIdsForHold = seatEligibleIndices.map((i) => passengerSeatMap[i]);
 
     if (isRoundTrip && currentJourneyType === "outbound") {
       try {
-        await holdMutation.mutateAsync(seatIds);
+        await holdMutation.mutateAsync(seatIdsForHold);
         const updatedPassengers = passengers.map((p, i) => {
           const seatData = validSeats?.find((s: any) => s.id === seatIds[i]);
           return {
             ...p,
             outboundSeatId: seatIds[i],
             outboundSeatNumber: seatData ? buildSeatLabel(seatData) : '',
+            outboundCoachNumber: selectedCoachData?.label || selectedCoachData?.name || selectedCoachData?.number || '',
+            outboundSeatFareMinor: seatData ? (getSeatFare(seatData) ?? undefined) : undefined,
+            outboundBedPosition: seatData?.bedPosition || undefined,
           };
         });
         setPassengers(updatedPassengers);
@@ -454,18 +768,20 @@ export default function SeatsPage() {
             error?.response?.data?.message ||
             "Failed to hold seats. Please try again.",
           type: "error",
+          onConfirm: undefined,
+          showCancel: false,
         });
         return;
       }
       setCurrentJourneyType("inbound");
       setPassengerSeatMap({});
-      setActivePassengerIndex(0);
+      setActivePassengerIndex(seatEligibleIndices[0] ?? 0);
       setSelectedCoach(null);
       return;
     }
 
     try {
-      await holdMutation.mutateAsync(seatIds);
+      await holdMutation.mutateAsync(seatIdsForHold);
       const updatedPassengers = passengers.map((p, i) => {
         const seatData = validSeats?.find((s: any) => s.id === seatIds[i]);
         if (isRoundTrip && currentJourneyType === "inbound") {
@@ -473,12 +789,18 @@ export default function SeatsPage() {
             ...p,
             inboundSeatId: seatIds[i],
             inboundSeatNumber: seatData ? buildSeatLabel(seatData) : '',
+            inboundCoachNumber: selectedCoachData?.label || selectedCoachData?.name || selectedCoachData?.number || '',
+            inboundSeatFareMinor: seatData ? (getSeatFare(seatData) ?? undefined) : undefined,
+            inboundBedPosition: seatData?.bedPosition || undefined,
           };
         }
         return {
           ...p,
           seatId: seatIds[i],
           seatNumber: seatData ? buildSeatLabel(seatData) : '',
+          coachNumber: selectedCoachData?.label || selectedCoachData?.name || selectedCoachData?.number || '',
+          seatFareMinor: seatData ? (getSeatFare(seatData) ?? undefined) : undefined,
+          bedPosition: seatData?.bedPosition || undefined,
         };
       });
       setPassengers(updatedPassengers);
@@ -490,6 +812,8 @@ export default function SeatsPage() {
           error?.response?.data?.message ||
           "Failed to hold seats. Please try again.",
         type: "error",
+        onConfirm: undefined,
+        showCancel: false,
       });
       return;
     }
@@ -497,9 +821,7 @@ export default function SeatsPage() {
   };
 
   const handleAutoAssign = () => {
-    const unassignedIndices = passengers
-      .map((_, i) => i)
-      .filter((i) => !passengerSeatMap[i]);
+    const unassignedIndices = seatEligibleIndices.filter((i) => !passengerSeatMap[i]);
 
     if (unassignedIndices.length === 0) return;
 
@@ -513,6 +835,8 @@ export default function SeatsPage() {
         title: "Not Enough Seats",
         message: `Only ${availableSeats.length} seat(s) available in this coach, but you need ${unassignedIndices.length} more seat(s). Please select another coach.`,
         type: "warning",
+        onConfirm: undefined,
+        showCancel: false,
       });
       return;
     }
@@ -522,7 +846,7 @@ export default function SeatsPage() {
       next[passengerIndex] = availableSeats[offset].id;
     });
     setPassengerSeatMap(next);
-    setActivePassengerIndex(passengers.length - 1);
+    setActivePassengerIndex(seatEligibleIndices[seatEligibleIndices.length - 1] ?? 0);
   };
 
   const handleBackToPassengers = () => {
@@ -556,6 +880,15 @@ export default function SeatsPage() {
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [bookingId]);
 
+  // A passenger who shares a seat with an adult should never be "active" for seat
+  // picking — snap back to the first seat-eligible passenger if that ever happens
+  // (e.g. right after passengers/counts change).
+  useEffect(() => {
+    if (!seatEligibility.eligibleSet.has(activePassengerIndex) && seatEligibleIndices.length > 0) {
+      setActivePassengerIndex(seatEligibleIndices[0]);
+    }
+  }, [seatEligibility, seatEligibleIndices, activePassengerIndex]);
+
   const parseSeatArrangement = (
     arrangement: string | null,
     seatClasses?: string[],
@@ -585,13 +918,6 @@ export default function SeatsPage() {
     return parts.length >= 2 ? parts : parts.length === 1 ? [parts[0]] : [2, 2];
   };
 
-  const getBedLabel = (bedPosition: string | null): string => {
-    if (bedPosition === "upper") return "U";
-    if (bedPosition === "middle") return "M";
-    if (bedPosition === "lower") return "L";
-    return "";
-  };
-
   const renderCoachSeats = (coach: any, isBedCoach: boolean) => {
     const arrangement = parseSeatArrangement(
       coach.seatArrangement,
@@ -608,6 +934,54 @@ export default function SeatsPage() {
         ? selectedCoachData.seatClass
         : selectedCoachData?.seatClass?.name || "";
 
+    // Indian-sleeper-style berth bay: Lower / Middle / Upper laid out horizontally, with
+    // the single ladder that actually serves the whole bay shown once at the end.
+    const renderBerthBay = (beds: any[], keyPrefix: string) => (
+      <div className="flex items-stretch gap-2">
+        {beds.map((bed: any) => (
+          <BedCard
+            key={bed.id}
+            bed={bed}
+            isSelected={isSeatSelected(bed.id)}
+            isAssignedToOther={isSeatAssignedToOther(bed.id)}
+            onToggle={handleSeatClick}
+          />
+        ))}
+        {beds.length > 1 && <LadderConnector key={`${keyPrefix}-ladder`} />}
+      </div>
+    );
+
+    // Two-side compartment: the left bay and right bay each get their own row (berths
+    // still laid out horizontally within a row), stacked one above the other and split
+    // by a dashed aisle divider — instead of squeezing both sides into a single row.
+    const renderCompartment = (leftBay: any[], rightBay: any[], key: string) => (
+      <div
+        key={key}
+        className="bg-gray-50 dark:bg-gray-800/40 rounded-2xl p-4 border border-gray-200 dark:border-gray-700 shadow-sm"
+      >
+        <div className="flex flex-col items-center gap-3">
+          {leftBay.length > 0 && (
+            <div className="flex justify-center">{renderBerthBay(leftBay, `${key}-left`)}</div>
+          )}
+          {leftBay.length > 0 && rightBay.length > 0 && (
+            <div className="w-full border-t-2 border-dashed border-gray-300 dark:border-gray-600" />
+          )}
+          {rightBay.length > 0 && (
+            <div className="flex justify-center">{renderBerthBay(rightBay, `${key}-right`)}</div>
+          )}
+        </div>
+      </div>
+    );
+
+    // Bay position ordering + left/right side detection shared by both bed layouts below.
+    const BERTH_ORDER = ["lower", "middle", "upper"];
+    const bedSideIsLeft = (bed: any, leftColByPosition: Record<string, string>) => {
+      if (bed.position === "LEFT") return true;
+      if (bed.position === "RIGHT") return false;
+      const leftCol = leftColByPosition[bed.bedPosition];
+      return leftCol ? bed.col === leftCol : true;
+    };
+
     // Bed coach with bed positions (Upper, Middle, Lower)
     if (isBedCoach && hasBedPositionData) {
       // Check if this is VIP_BED or ECONOMY_BED based on room data
@@ -675,205 +1049,35 @@ export default function SeatsPage() {
                     </div>
                   </div>
 
-                  {/* VIP BED Layout (2x2 grid) */}
-                  {isVipBed && (
-                    <div className="space-y-4">
-                      {/* Upper Berths */}
-                      <div className="flex items-start gap-2">
-                        <div className="text-[10px] font-semibold text-gray-600 dark:text-gray-400 uppercase tracking-wide w-16 pt-2 flex-shrink-0">
-                          Upper
-                          <br />
-                          Berth
-                        </div>
-                        <div className="flex-1 grid grid-cols-2 gap-4 items-center relative">
-                          {sortedBeds
-                            .filter((b: any) => b.bedPosition === "upper")
-                            .map((bed: any) => (
-                              <div key={bed.id} className="relative">
-                                <BedCard
-                                  bed={bed}
-                                  isSelected={isSeatSelected(bed.id)}
-                                isAssignedToOther={isSeatAssignedToOther(bed.id)}
-                                  onToggle={handleSeatClick}
-                                  bedLabel="U"
-                                />
-                              </div>
-                            ))}
-                          {/* Vertical aisle indicator */}
-                          <div className="absolute left-1/2 top-0 bottom-0 w-px border-l-2 border-dashed border-gray-300 dark:border-gray-600 -translate-x-1/2" />
-                        </div>
-                      </div>
+                  {/* VIP BED Layout — 2-tier compartment (Lower/Upper), left + right of the aisle */}
+                  {isVipBed && (() => {
+                    const lowerBeds = sortedBeds.filter((b: any) => b.bedPosition === "lower");
+                    const upperBeds = sortedBeds.filter((b: any) => b.bedPosition === "upper");
+                    const isLeft = (bed: any, idx: number) =>
+                      bed.position === "LEFT" ? true : bed.position === "RIGHT" ? false : idx % 2 === 0;
 
-                      {/* Lower Berths */}
-                      <div className="flex items-start gap-2">
-                        <div className="text-[10px] font-semibold text-gray-600 dark:text-gray-400 uppercase tracking-wide w-16 pt-2 flex-shrink-0">
-                          Lower
-                          <br />
-                          Berth
-                        </div>
-                        <div className="flex-1 grid grid-cols-2 gap-4 items-center relative">
-                          {sortedBeds
-                            .filter((b: any) => b.bedPosition === "lower")
-                            .map((bed: any) => (
-                              <div key={bed.id} className="relative">
-                                <BedCard
-                                  bed={bed}
-                                  isSelected={isSeatSelected(bed.id)}
-                                isAssignedToOther={isSeatAssignedToOther(bed.id)}
-                                  onToggle={handleSeatClick}
-                                  bedLabel="L"
-                                />
-                              </div>
-                            ))}
-                          {/* Vertical aisle indicator */}
-                          <div className="absolute left-1/2 top-0 bottom-0 w-px border-l-2 border-dashed border-gray-300 dark:border-gray-600 -translate-x-1/2" />
-                        </div>
-                      </div>
-                    </div>
-                  )}
+                    const leftBay = [lowerBeds, upperBeds]
+                      .map((arr) => arr.find((b: any, i: number) => isLeft(b, i)))
+                      .filter(Boolean);
+                    const rightBay = [lowerBeds, upperBeds]
+                      .map((arr) => arr.find((b: any, i: number) => !isLeft(b, i)))
+                      .filter(Boolean);
 
-                  {/* ECONOMY BED Layout (3 rows: Lower, Middle, Upper on both sides) */}
-                  {isEconomyBed && (
-                    <div className="space-y-3">
-                      {/* Lower Berths */}
-                      <div className="flex items-center gap-3">
-                        <div className="text-[10px] font-semibold text-gray-600 dark:text-gray-400 uppercase tracking-wide w-16 flex-shrink-0">
-                          Lower
-                          <br />
-                          Berth
-                        </div>
-                        <div className="flex-1 grid grid-cols-[1fr_auto_1fr] gap-4 items-center">
-                          {sortedBeds
-                            .filter(
-                              (b: any) =>
-                                b.bedPosition === "lower" &&
-                                (b.col === "A" || b.position === "LEFT"),
-                            )
-                            .map((bed: any) => (
-                              <BedCard
-                                key={bed.id}
-                                bed={bed}
-                                isSelected={isSeatSelected(bed.id)}
-                                isAssignedToOther={isSeatAssignedToOther(bed.id)}
-                                onToggle={handleSeatClick}
-                                bedLabel="L"
-                              />
-                            ))}
-                          {/* Vertical aisle */}
-                          <div className="w-px h-12 border-l-2 border-dashed border-gray-300 dark:border-gray-600" />
-                          {sortedBeds
-                            .filter(
-                              (b: any) =>
-                                b.bedPosition === "lower" &&
-                                b.col !== "A" &&
-                                b.position !== "LEFT",
-                            )
-                            .map((bed: any) => (
-                              <BedCard
-                                key={bed.id}
-                                bed={bed}
-                                isSelected={isSeatSelected(bed.id)}
-                                isAssignedToOther={isSeatAssignedToOther(bed.id)}
-                                onToggle={handleSeatClick}
-                                bedLabel="L"
-                              />
-                            ))}
-                        </div>
-                      </div>
+                    return renderCompartment(leftBay, rightBay, `${room.room_id}-vip`);
+                  })()}
 
-                      {/* Middle Berths */}
-                      <div className="flex items-center gap-3">
-                        <div className="text-[10px] font-semibold text-gray-600 dark:text-gray-400 uppercase tracking-wide w-16 flex-shrink-0">
-                          Middle
-                          <br />
-                          Berth
-                        </div>
-                        <div className="flex-1 grid grid-cols-[1fr_auto_1fr] gap-4 items-center">
-                          {sortedBeds
-                            .filter(
-                              (b: any) =>
-                                b.bedPosition === "middle" &&
-                                (b.col === "B" || b.position === "LEFT"),
-                            )
-                            .map((bed: any) => (
-                              <BedCard
-                                key={bed.id}
-                                bed={bed}
-                                isSelected={isSeatSelected(bed.id)}
-                                isAssignedToOther={isSeatAssignedToOther(bed.id)}
-                                onToggle={handleSeatClick}
-                                bedLabel="M"
-                              />
-                            ))}
-                          {/* Vertical aisle */}
-                          <div className="w-px h-12 border-l-2 border-dashed border-gray-300 dark:border-gray-600" />
-                          {sortedBeds
-                            .filter(
-                              (b: any) =>
-                                b.bedPosition === "middle" &&
-                                b.col !== "B" &&
-                                b.position !== "LEFT",
-                            )
-                            .map((bed: any) => (
-                              <BedCard
-                                key={bed.id}
-                                bed={bed}
-                                isSelected={isSeatSelected(bed.id)}
-                                isAssignedToOther={isSeatAssignedToOther(bed.id)}
-                                onToggle={handleSeatClick}
-                                bedLabel="M"
-                              />
-                            ))}
-                        </div>
-                      </div>
+                  {/* ECONOMY BED Layout — 3-tier compartment (Lower/Middle/Upper), left + right of the aisle */}
+                  {isEconomyBed && (() => {
+                    const leftColByPosition: Record<string, string> = { lower: "A", middle: "B", upper: "C" };
+                    const leftBay = BERTH_ORDER
+                      .map((pos) => sortedBeds.find((b: any) => b.bedPosition === pos && bedSideIsLeft(b, leftColByPosition)))
+                      .filter(Boolean);
+                    const rightBay = BERTH_ORDER
+                      .map((pos) => sortedBeds.find((b: any) => b.bedPosition === pos && !bedSideIsLeft(b, leftColByPosition)))
+                      .filter(Boolean);
 
-                      {/* Upper Berths */}
-                      <div className="flex items-center gap-3">
-                        <div className="text-[10px] font-semibold text-gray-600 dark:text-gray-400 uppercase tracking-wide w-16 flex-shrink-0">
-                          Upper
-                          <br />
-                          Berth
-                        </div>
-                        <div className="flex-1 grid grid-cols-[1fr_auto_1fr] gap-4 items-center">
-                          {sortedBeds
-                            .filter(
-                              (b: any) =>
-                                b.bedPosition === "upper" &&
-                                (b.col === "C" || b.position === "LEFT"),
-                            )
-                            .map((bed: any) => (
-                              <BedCard
-                                key={bed.id}
-                                bed={bed}
-                                isSelected={isSeatSelected(bed.id)}
-                                isAssignedToOther={isSeatAssignedToOther(bed.id)}
-                                onToggle={handleSeatClick}
-                                bedLabel="U"
-                              />
-                            ))}
-                          {/* Vertical aisle */}
-                          <div className="w-px h-12 border-l-2 border-dashed border-gray-300 dark:border-gray-600" />
-                          {sortedBeds
-                            .filter(
-                              (b: any) =>
-                                b.bedPosition === "upper" &&
-                                b.col !== "C" &&
-                                b.position !== "LEFT",
-                            )
-                            .map((bed: any) => (
-                              <BedCard
-                                key={bed.id}
-                                bed={bed}
-                                isSelected={isSeatSelected(bed.id)}
-                                isAssignedToOther={isSeatAssignedToOther(bed.id)}
-                                onToggle={handleSeatClick}
-                                bedLabel="U"
-                              />
-                            ))}
-                        </div>
-                      </div>
-                    </div>
-                  )}
+                    return renderCompartment(leftBay, rightBay, `${room.room_id}-eco`);
+                  })()}
                 </div>
               );
             })}
@@ -881,7 +1085,8 @@ export default function SeatsPage() {
         );
       }
 
-      // Fallback: Old layout for beds without room data
+      // Fallback: beds without room data — group into numbered bays (Lower/Middle/Upper),
+      // then pair adjacent bays into two-side compartments, same as the room-based layouts.
       const seatGroups = new Map<string, any[]>();
 
       for (const seat of validSeats) {
@@ -898,88 +1103,18 @@ export default function SeatsPage() {
         return numA - numB;
       });
 
+      const bays = sortedGroups
+        .map(([, beds]) =>
+          BERTH_ORDER.map((pos) => beds.find((seat: any) => seat.bedPosition === pos)).filter(Boolean),
+        )
+        .filter((bay) => bay.length > 0);
+
       return (
         <div className="space-y-4">
-          {sortedGroups.map(([seatNumber, beds], idx) => {
-            const shouldFlipIcon = idx % 2 === 0;
-
-            const orderedBeds = ["lower", "middle", "upper"]
-              .map((pos) => beds.find((seat) => seat.bedPosition === pos))
-              .filter((seat) => seat !== undefined);
-
-            if (orderedBeds.length === 0) return null;
-
-            return (
-              <div
-                key={`bed-group-${seatNumber}`}
-                className="pb-4 border-b-2 border-dashed border-gray-300 dark:border-gray-600 last:border-b-0"
-              >
-                <div className="flex items-center gap-3">
-                  {shouldFlipIcon && (
-                    <div className="flex flex-col gap-3">
-                      {orderedBeds.map((seat: any) => {
-                        const seatLabel =
-                          seat.seatNumber || seat.number || seat.label || "";
-                        const bedLabelFull = seat.bedPosition
-                          ? seat.bedPosition === "upper"
-                            ? "Upper"
-                            : seat.bedPosition === "middle"
-                              ? "Middle"
-                              : "Lower"
-                          : "";
-                        return (
-                          <div
-                            key={seat.id}
-                            className="w-20 text-xs font-bold text-foreground text-right"
-                          >
-                            {seatLabel ? `${seatLabel} ${bedLabelFull}` : ""}
-                          </div>
-                        );
-                      })}
-                    </div>
-                  )}
-
-                  <div className="flex flex-col gap-3">
-                    {orderedBeds.map((seat: any) => (
-                      <SeatButton
-                        key={seat.id}
-                        seat={seat}
-                        isSelected={isSeatSelected(seat.id)}
-                        isAssignedToOther={isSeatAssignedToOther(seat.id)}
-                        onToggle={handleSeatClick}
-                        isBedCoach={true}
-                        bedLabel={getBedLabel(seat.bedPosition)}
-                        coachSeatClass={seatClassStr}
-                      />
-                    ))}
-                  </div>
-
-                  {!shouldFlipIcon && (
-                    <div className="flex flex-col gap-3">
-                      {orderedBeds.map((seat: any) => {
-                        const seatLabel =
-                          seat.seatNumber || seat.number || seat.label || "";
-                        const bedLabelFull = seat.bedPosition
-                          ? seat.bedPosition === "upper"
-                            ? "Upper"
-                            : seat.bedPosition === "middle"
-                              ? "Middle"
-                              : "Lower"
-                          : "";
-                        return (
-                          <div
-                            key={seat.id}
-                            className="w-20 text-xs font-bold text-foreground"
-                          >
-                            {seatLabel ? `${seatLabel} ${bedLabelFull}` : ""}
-                          </div>
-                        );
-                      })}
-                    </div>
-                  )}
-                </div>
-              </div>
-            );
+          {Array.from({ length: Math.ceil(bays.length / 2) }, (_, i) => {
+            const leftBay = bays[i * 2] || [];
+            const rightBay = bays[i * 2 + 1] || [];
+            return renderCompartment(leftBay, rightBay, `bay-compartment-${i}`);
           })}
         </div>
       );
@@ -1131,7 +1266,7 @@ export default function SeatsPage() {
     );
   }
 
-  const assignedCount = passengers.filter((_, i) => !!passengerSeatMap[i]).length;
+  const assignedCount = seatEligibleIndices.filter((i) => !!passengerSeatMap[i]).length;
   const activePassenger = passengers[activePassengerIndex];
   const isBedCoach =
     selectedCoachData?.isBedCoach === true ||
@@ -1139,6 +1274,114 @@ export default function SeatsPage() {
     selectedCoachData?.seatClass?.toLowerCase().includes("bed") ||
     selectedCoachData?.mode?.toLowerCase().includes("bed");
 
+  // Train coach preview content — shared between the desktop side panel and the
+  // mobile full-screen modal. Shows every coach on this schedule in order, so users
+  // can see where their selected coach type sits relative to the rest of the train
+  // and spot the dining coach at a glance.
+  const TrainCoachPreviewContent = () => (
+    <>
+      <p className="text-xs text-gray-500 dark:text-gray-400 mb-3">
+        Coach order along the train, front to back.
+      </p>
+
+      {/* Legend */}
+      <div className="flex flex-wrap gap-3 mb-4 pb-4 border-b border-gray-100 dark:border-gray-800 text-xs text-gray-600 dark:text-gray-400">
+        <div className="flex items-center gap-1.5">
+          <div className="w-3 h-3 rounded bg-amber-100 border-2 border-amber-400 dark:bg-amber-900/30 dark:border-amber-500" />
+          <span>🍽 Dining coach</span>
+        </div>
+        <div className="flex items-center gap-1.5">
+          <div className="w-3 h-3 rounded bg-primary/10 border-2 border-primary" />
+          <span>Your selected coach type</span>
+        </div>
+      </div>
+
+      {loadingTrainCoaches ? (
+        <div className="flex items-center justify-center py-10 gap-2">
+          <div className="w-6 h-6 border-2 border-primary border-t-transparent rounded-full animate-spin" />
+          <span className="text-sm text-gray-500 dark:text-gray-400">Loading coach layout...</span>
+        </div>
+      ) : trainCoachList.length === 0 ? (
+        <p className="text-sm text-gray-500 dark:text-gray-400 py-6 text-center">
+          Coach layout is not available for this train.
+        </p>
+      ) : (
+        <div className="flex flex-col items-stretch">
+          {/* Locomotive */}
+          <div className="flex items-center gap-3 rounded-lg bg-[rgb(20,113,76)] text-white py-2.5 px-3">
+            <TrainFront className="w-5 h-5 flex-shrink-0" />
+            <span className="text-sm font-bold">Locomotive</span>
+          </div>
+
+          {trainCoachList.map((coach: any, coachIndex: number) => {
+            const dining = isDiningCoachType(coach.type);
+            const isFull = !dining && coach.remainingSeats != null && coach.remainingSeats <= 0;
+            const isCurrentType =
+              !!coachTypeId &&
+              (coach.coachTypeId === coachTypeId ||
+                coach.type === (currentSchedule as any)?.selectedCoachTypeCode ||
+                coach.type === (currentSchedule as any)?.selectedCoachTypeName);
+            return (
+              <div key={coach.id}>
+                {/* Coach connector — same coupling-joint visual as the seat map's coach list */}
+                <div className="flex justify-center py-0.5">
+                  <div className="flex flex-col items-center gap-px">
+                    <div className="w-7 h-1.5 bg-gray-300 dark:bg-gray-600 rounded-sm" />
+                    <div className="w-2.5 h-2.5 bg-gray-400 dark:bg-gray-500 rounded-sm" />
+                    <div className="w-7 h-1.5 bg-gray-300 dark:bg-gray-600 rounded-sm" />
+                  </div>
+                </div>
+
+                <button
+                  type="button"
+                  disabled={dining || isFull}
+                  onClick={() => handlePreviewCoachSelect(coach)}
+                  title={dining ? "Dining coach — not bookable" : isFull ? "This coach is full" : `Select ${coach.label}`}
+                  className={`w-full flex items-center gap-3 rounded-lg border-2 py-2.5 px-3 text-left transition-colors ${
+                    dining
+                      ? "bg-amber-100 border-amber-400 dark:bg-amber-900/30 dark:border-amber-500 cursor-not-allowed"
+                      : isFull
+                        ? "bg-gray-100 border-gray-200 dark:bg-gray-800/60 dark:border-gray-700 opacity-60 cursor-not-allowed"
+                        : isCurrentType
+                          ? "bg-primary/10 border-primary hover:bg-primary/15"
+                          : "bg-gray-50 border-gray-200 dark:bg-gray-800 dark:border-gray-700 hover:border-primary/50"
+                  }`}
+                >
+                  <div className="w-8 h-8 flex items-center justify-center flex-shrink-0 rounded-md bg-white/70 dark:bg-black/20">
+                    {dining ? (
+                      <span className="text-base leading-none">🍽</span>
+                    ) : (
+                      <span className="text-sm font-bold text-gray-600 dark:text-gray-300">{coachIndex + 1}</span>
+                    )}
+                  </div>
+                  <div className="flex-1 min-w-0">
+                    <p className="text-sm font-bold text-gray-900 dark:text-white truncate">
+                      {coach.label}
+                    </p>
+                    {dining ? (
+                      <p className="text-[11px] text-amber-700 dark:text-amber-400 font-medium">Dining Coach</p>
+                    ) : coach.typeName ? (
+                      <p className="text-[11px] text-gray-500 dark:text-gray-400 truncate">{coach.typeName}</p>
+                    ) : null}
+                  </div>
+                  {!dining && (
+                    <span
+                      className={`text-xs font-semibold flex-shrink-0 ${
+                        isFull ? "text-red-500 dark:text-red-400" : "text-gray-600 dark:text-gray-300"
+                      }`}
+                    >
+                      {isFull ? "Full" : coach.remainingSeats != null ? `${coach.remainingSeats} left` : "—"}
+                    </span>
+                  )}
+                </button>
+              </div>
+            );
+          })}
+        </div>
+      )}
+    </>
+  );
+
   // Summary card content — shared between sidebar and mobile modal
   const SummaryContent = () => (
     <>
@@ -1153,13 +1396,13 @@ export default function SeatsPage() {
               : "bg-amber-100 text-amber-700 dark:bg-amber-900/30 dark:text-amber-400"
           }`}
         >
-          {assignedCount}/{passengers.length} selected
+          {assignedCount}/{seatEligibleIndices.length} selected
         </span>
       </div>
       <p className="text-xs text-gray-500 dark:text-gray-400 mb-4">
         {allSeatsAssigned
           ? "All seats selected — ready to continue"
-          : `Selecting seat for ${activePassenger?.name || `Passenger ${activePassengerIndex + 1}`} (${activePassengerIndex + 1} of ${passengers.length})`}
+          : `Selecting seat for ${activePassenger?.name || `Passenger ${activePassengerIndex + 1}`} (${seatEligibleIndices.indexOf(activePassengerIndex) + 1} of ${seatEligibleIndices.length})`}
       </p>
 
       {/* Progress bar */}
@@ -1167,13 +1410,35 @@ export default function SeatsPage() {
         <div
           className="h-full bg-[rgb(20,113,76)] rounded-full transition-all duration-300"
           style={{
-            width: `${(assignedCount / passengers.length) * 100}%`,
+            width: `${(assignedCount / Math.max(seatEligibleIndices.length, 1)) * 100}%`,
           }}
         />
       </div>
 
       <div className="space-y-2 mb-5">
         {passengers.map((p, i) => {
+          const sharesWithAdult = seatEligibility.sharingWithAdult.get(i);
+          if (sharesWithAdult) {
+            return (
+              <div
+                key={i}
+                className="w-full flex items-center justify-between py-2 px-2 rounded-lg border border-transparent opacity-70"
+              >
+                <div className="flex items-center gap-2 min-w-0">
+                  <div className="w-6 h-6 rounded-full flex items-center justify-center text-xs font-bold flex-shrink-0 bg-gray-200 dark:bg-gray-700 text-gray-500">
+                    {i + 1}
+                  </div>
+                  <span className="text-sm text-gray-700 dark:text-gray-300 truncate block max-w-[120px]">
+                    {p.name}
+                  </span>
+                </div>
+                <span className="text-xs font-medium text-gray-400 flex-shrink-0 text-right">
+                  Shares seat with {sharesWithAdult}
+                </span>
+              </div>
+            );
+          }
+
           const assignedSeatId = passengerSeatMap[i];
           const assignedSeat = assignedSeatId
             ? validSeats?.find((s: any) => s.id === assignedSeatId)
@@ -1261,8 +1526,62 @@ export default function SeatsPage() {
         title={modalState.title}
         message={modalState.message}
         type={modalState.type}
+        onConfirm={modalState.onConfirm}
+        showCancel={modalState.showCancel}
+        confirmText={modalState.showCancel ? "Switch Coach" : "OK"}
       />
 
+      {/* Train Coach Preview */}
+      {showCoachPreview && (
+        <>
+          {/* Mobile: full-screen modal */}
+          <div className="fixed inset-0 z-[120] bg-white dark:bg-gray-900 flex flex-col lg:hidden">
+            <div className="flex items-center justify-between px-4 py-4 border-b border-gray-100 dark:border-gray-800 flex-shrink-0">
+              <h2 className="text-base font-bold text-gray-900 dark:text-white flex items-center gap-2">
+                <Train className="w-5 h-5 text-primary" />
+                Train Coach Preview
+              </h2>
+              <button
+                type="button"
+                onClick={() => setShowCoachPreview(false)}
+                className="w-9 h-9 flex items-center justify-center rounded-full hover:bg-gray-100 dark:hover:bg-gray-800"
+                aria-label="Close"
+              >
+                <X className="w-5 h-5 text-gray-500" />
+              </button>
+            </div>
+            <div className="flex-1 overflow-y-auto scrollbar-hide p-4">
+              <TrainCoachPreviewContent />
+            </div>
+          </div>
+
+          {/* Desktop: right-side panel, no backdrop — seat selection stays fully usable */}
+          <div
+            className="hidden lg:flex fixed inset-y-0 right-0 z-[120] w-[380px] bg-white dark:bg-gray-900 shadow-2xl border-l border-gray-200 dark:border-gray-700 flex-col"
+            style={{ animation: "drawer-slide-in 0.25s cubic-bezier(0.32,0.72,0,1)" }}
+          >
+            <div className="flex items-center justify-between px-5 py-4 border-b border-gray-100 dark:border-gray-800 flex-shrink-0">
+              <h2 className="text-base font-bold text-gray-900 dark:text-white flex items-center gap-2">
+                <Train className="w-5 h-5 text-primary" />
+                Train Coach Preview
+              </h2>
+              <button
+                type="button"
+                onClick={() => setShowCoachPreview(false)}
+                className="w-9 h-9 flex items-center justify-center rounded-full hover:bg-gray-100 dark:hover:bg-gray-800"
+                aria-label="Close"
+              >
+                <X className="w-5 h-5 text-gray-500" />
+              </button>
+            </div>
+            <div className="flex-1 overflow-y-auto scrollbar-hide p-5">
+              <TrainCoachPreviewContent />
+            </div>
+          </div>
+          <style>{`@keyframes drawer-slide-in{from{transform:translateX(100%)}to{transform:translateX(0)}}`}</style>
+        </>
+      )}
+
       {/* Mobile summary bottom-sheet — always visible so the active passenger is clear */}
       <div
         className="fixed inset-x-0 bottom-0 z-50 lg:hidden bg-white dark:bg-gray-900 rounded-t-2xl shadow-2xl p-5 max-h-[70vh] overflow-y-auto"
@@ -1291,8 +1610,8 @@ export default function SeatsPage() {
                 <h1 className="text-base font-bold text-gray-900 dark:text-white">
                   {isRoundTrip
                     ? currentJourneyType === "outbound"
-                      ? "Select Outbound Seats"
-                      : "Select Return Seats"
+                      ? packageName ? `Select Outbound Seats for ${packageName}` : "Select Outbound Seats"
+                      : packageName ? `Select Return Seats for ${packageName}` : "Select Return Seats"
                     : "Select Seats"}
                 </h1>
                 {!allSeatsAssigned && (
@@ -1313,6 +1632,16 @@ export default function SeatsPage() {
             <div className="grid grid-cols-1 lg:grid-cols-3 gap-5">
               {/* ── Seat map panel ── */}
               <div className="lg:col-span-2 space-y-4">
+                <div className="flex justify-end">
+                  <button
+                    type="button"
+                    onClick={() => setShowCoachPreview(true)}
+                    className="flex items-center gap-2 px-4 py-2 rounded-lg border border-gray-200 dark:border-gray-700 bg-white dark:bg-gray-800 text-sm font-semibold text-gray-700 dark:text-gray-300 hover:border-primary hover:text-primary transition-colors shadow-sm"
+                  >
+                    <Train className="w-4 h-4" />
+                    Preview Train Coach
+                  </button>
+                </div>
                 {isLoading ? (
                   <div className="bg-white dark:bg-gray-800 rounded-2xl p-8 text-center">
                     <div className="w-10 h-10 border-4 border-primary border-t-transparent rounded-full animate-spin mx-auto mb-3" />
diff --git a/apps/edr-passenger-web/portal/src/app/layout.tsx b/apps/edr-passenger-web/portal/src/app/layout.tsx
index da774c15f..d38f63ca2 100644
--- a/apps/edr-passenger-web/portal/src/app/layout.tsx
+++ b/apps/edr-passenger-web/portal/src/app/layout.tsx
@@ -1,4 +1,5 @@
 import type { Metadata } from 'next';
+import { headers } from 'next/headers';
 import './globals.css';
 import { Providers } from './providers';
 import AppHeader from '@/components/AppHeader';
@@ -15,10 +16,13 @@ export default function RootLayout({
 }: {
   children: React.ReactNode;
 }) {
+  // Nonce set per-request by middleware; required for this inline script under the CSP.
+  const nonce = headers().get('x-nonce') ?? undefined;
   return (
     <html lang="en" suppressHydrationWarning>
       <body className="font-sans antialiased flex flex-col min-h-screen">
         <script
+          nonce={nonce}
           dangerouslySetInnerHTML={{
             __html: `
               (function() {
diff --git a/apps/edr-passenger-web/portal/src/app/packages/[id]/page.tsx b/apps/edr-passenger-web/portal/src/app/packages/[id]/page.tsx
index 8edd9f04a..16f9197e7 100644
--- a/apps/edr-passenger-web/portal/src/app/packages/[id]/page.tsx
+++ b/apps/edr-passenger-web/portal/src/app/packages/[id]/page.tsx
@@ -5,9 +5,7 @@ import { apiClient } from "@/lib/api-client";
 import { useParams, useRouter } from "next/navigation";
 import Image from "next/image";
 import { useState } from "react";
-import { useForm } from "react-hook-form";
-import { zodResolver } from "@hookform/resolvers/zod";
-import { z } from "zod";
+import { useBookingStore } from "@/lib/booking-store";
 import {
   ChevronLeft,
   Calendar,
@@ -23,11 +21,6 @@ import {
   Tag,
   Shield,
   X,
-  CheckCircle2,
-  Phone,
-  Mail,
-  User,
-  FileText,
 } from "lucide-react";
 
 // ─── Types ────────────────────────────────────────────────────────────────────
@@ -47,6 +40,11 @@ interface TrainInfo {
   operatorName: string;
 }
 
+interface StopTime {
+  sequence: number;
+  station: Station;
+}
+
 interface Schedule {
   id: string;
   departureAt: string;
@@ -57,6 +55,7 @@ interface Schedule {
   originStation: Station;
   destinationStation: Station;
   train: TrainInfo;
+  stopTimes?: StopTime[];
 }
 
 interface PriceTier {
@@ -87,6 +86,7 @@ interface PackageDetail {
   busTransferRoute: string | null;
   validFrom: string;
   validUntil: string;
+  journeyType: 'ONE_WAY' | 'ROUND_TRIP';
   priceTiers: PriceTier[];
   outboundSchedule: Schedule;
   returnSchedule: Schedule | null;
@@ -122,313 +122,6 @@ function formatPrice(minor: number, currency: string): string {
   return `${currency} ${(minor / 100).toLocaleString(undefined, { minimumFractionDigits: 2, maximumFractionDigits: 2 })}`;
 }
 
-// ─── Inquiry form ────────────────────────────────────────────────────────────
-
-const inquirySchema = z.object({
-  travelerCount: z
-    .number({ invalid_type_error: "Enter a valid number" })
-    .int("Must be a whole number")
-    .min(1, "At least 1 traveler required")
-    .max(50, "Maximum 50 travelers per booking"),
-  contactName: z
-    .string()
-    .min(2, "Name must be at least 2 characters")
-    .max(100),
-  contactEmail: z
-    .string()
-    .min(1, "Email is required")
-    .email("Enter a valid email address"),
-  contactPhone: z
-    .string()
-    .min(7, "Enter a valid phone number")
-    .max(20, "Phone number too long")
-    .regex(/^[+\d\s\-()\\.]+$/, "Invalid phone number format"),
-  notes: z.string().max(500, "Notes must be under 500 characters").optional(),
-});
-
-type InquiryForm = z.infer<typeof inquirySchema>;
-
-interface InquiryModalProps {
-  packageId: string;
-  packageName: string;
-  tier: PriceTier;
-  onClose: () => void;
-}
-
-function InquiryModal({ packageId, packageName, tier, onClose }: InquiryModalProps) {
-  const [submitted, setSubmitted] = useState(false);
-  const [submitError, setSubmitError] = useState<string | null>(null);
-
-  const {
-    register,
-    handleSubmit,
-    formState: { errors, isSubmitting },
-  } = useForm<InquiryForm>({
-    resolver: zodResolver(inquirySchema as any),
-    defaultValues: { travelerCount: 1 },
-  });
-
-  const onSubmit = async (data: InquiryForm) => {
-    setSubmitError(null);
-    try {
-      await apiClient.post("/packages/inquiries", {
-        packageId,
-        priceTierId: tier.id,
-        travelerCount: data.travelerCount,
-        contactName: data.contactName,
-        contactEmail: data.contactEmail,
-        contactPhone: data.contactPhone,
-        notes: data.notes ?? "",
-      });
-      setSubmitted(true);
-    } catch (err: any) {
-      setSubmitError(
-        err?.response?.data?.message ||
-          "Something went wrong. Please try again.",
-      );
-    }
-  };
-
-  return (
-    <>
-      {/* Backdrop */}
-      <div
-        className="fixed inset-0 z-[90] bg-black/50 backdrop-blur-sm"
-        onClick={onClose}
-      />
-
-      {/* Modal */}
-      <div className="fixed inset-0 z-[100] flex items-end sm:items-center justify-center p-0 sm:p-4">
-        <div className="w-full sm:max-w-lg bg-white dark:bg-gray-900 rounded-t-3xl sm:rounded-2xl shadow-2xl overflow-hidden max-h-[92vh] flex flex-col">
-
-          {/* Header */}
-          <div className="flex items-center justify-between px-6 py-4 border-b border-gray-100 dark:border-gray-800 flex-shrink-0">
-            <div>
-              <h2 className="text-base font-bold text-gray-900 dark:text-white">
-                Book Package
-              </h2>
-              <p className="text-xs text-gray-400 mt-0.5 line-clamp-1">
-                {packageName.trim()}
-              </p>
-            </div>
-            <button
-              type="button"
-              onClick={onClose}
-              className="w-8 h-8 flex items-center justify-center rounded-full hover:bg-gray-100 dark:hover:bg-gray-800 transition-colors"
-            >
-              <X className="w-4 h-4 text-gray-500" />
-            </button>
-          </div>
-
-          {/* Success state */}
-          {submitted ? (
-            <div className="flex-1 flex flex-col items-center justify-center px-6 py-12 text-center">
-              <div className="w-16 h-16 bg-green-50 dark:bg-green-900/20 rounded-full flex items-center justify-center mb-4">
-                <CheckCircle2 className="w-8 h-8 text-green-500" />
-              </div>
-              <h3 className="text-lg font-bold text-gray-900 dark:text-white mb-2">
-                Inquiry Submitted!
-              </h3>
-              <p className="text-sm text-gray-500 dark:text-gray-400 max-w-xs">
-                We&apos;ve received your booking inquiry. Our team will contact you
-                shortly to confirm your reservation.
-              </p>
-              <button
-                type="button"
-                onClick={onClose}
-                className="mt-6 px-6 py-2.5 bg-primary text-white text-sm font-semibold rounded-xl hover:bg-[rgb(16,89,60)] transition-colors"
-              >
-                Done
-              </button>
-            </div>
-          ) : (
-            <>
-              {/* Selected tier summary */}
-              <div className="px-6 py-3 bg-primary/5 border-b border-primary/10 flex-shrink-0">
-                <div className="flex items-center justify-between">
-                  <div>
-                    <p className="text-[10px] text-gray-400 uppercase tracking-wide font-semibold">
-                      Selected seat type
-                    </p>
-                    <p className="text-sm font-bold text-gray-900 dark:text-white mt-0.5">
-                      {tier.label.trim()}{" "}
-                      <span className="text-[10px] font-normal text-gray-400 bg-gray-100 dark:bg-gray-800 px-1.5 py-0.5 rounded ml-1">
-                        {tier.seatType.trim()}
-                      </span>
-                    </p>
-                  </div>
-                  <div className="text-right">
-                    <p className="text-[10px] text-gray-400 uppercase tracking-wide font-semibold">
-                      Per person
-                    </p>
-                    <p className="text-base font-extrabold text-primary mt-0.5">
-                      {formatPrice(tier.priceMinor, tier.currency)}
-                    </p>
-                  </div>
-                </div>
-              </div>
-
-              {/* Form */}
-              <form
-                onSubmit={handleSubmit(onSubmit)}
-                className="flex-1 overflow-y-auto scrollbar-hide px-6 py-5 space-y-4"
-              >
-                {/* Traveler count */}
-                <div>
-                  <label className="block text-xs font-semibold text-gray-700 dark:text-gray-300 mb-1.5">
-                    Number of Travelers <span className="text-red-500">*</span>
-                  </label>
-                  <div className="relative">
-                    <Users className="absolute left-3.5 top-1/2 -translate-y-1/2 w-4 h-4 text-gray-400" />
-                    <input
-                      type="number"
-                      min={1}
-                      max={50}
-                      {...register("travelerCount", { valueAsNumber: true })}
-                      className={`w-full pl-10 pr-4 py-3 rounded-xl border-2 text-sm bg-white dark:bg-gray-800 text-gray-900 dark:text-white focus:outline-none focus:ring-2 focus:ring-primary/30 transition-colors ${
-                        errors.travelerCount
-                          ? "border-red-400 focus:border-red-400"
-                          : "border-gray-200 dark:border-gray-700 focus:border-primary"
-                      }`}
-                    />
-                  </div>
-                  {errors.travelerCount && (
-                    <p className="text-xs text-red-500 mt-1">{errors.travelerCount.message}</p>
-                  )}
-                </div>
-
-                {/* Contact name */}
-                <div>
-                  <label className="block text-xs font-semibold text-gray-700 dark:text-gray-300 mb-1.5">
-                    Full Name <span className="text-red-500">*</span>
-                  </label>
-                  <div className="relative">
-                    <User className="absolute left-3.5 top-1/2 -translate-y-1/2 w-4 h-4 text-gray-400" />
-                    <input
-                      type="text"
-                      placeholder="Your full name"
-                      {...register("contactName")}
-                      className={`w-full pl-10 pr-4 py-3 rounded-xl border-2 text-sm bg-white dark:bg-gray-800 text-gray-900 dark:text-white placeholder-gray-400 focus:outline-none focus:ring-2 focus:ring-primary/30 transition-colors ${
-                        errors.contactName
-                          ? "border-red-400 focus:border-red-400"
-                          : "border-gray-200 dark:border-gray-700 focus:border-primary"
-                      }`}
-                    />
-                  </div>
-                  {errors.contactName && (
-                    <p className="text-xs text-red-500 mt-1">{errors.contactName.message}</p>
-                  )}
-                </div>
-
-                {/* Email */}
-                <div>
-                  <label className="block text-xs font-semibold text-gray-700 dark:text-gray-300 mb-1.5">
-                    Email Address <span className="text-red-500">*</span>
-                  </label>
-                  <div className="relative">
-                    <Mail className="absolute left-3.5 top-1/2 -translate-y-1/2 w-4 h-4 text-gray-400" />
-                    <input
-                      type="email"
-                      placeholder="you@example.com"
-                      {...register("contactEmail")}
-                      className={`w-full pl-10 pr-4 py-3 rounded-xl border-2 text-sm bg-white dark:bg-gray-800 text-gray-900 dark:text-white placeholder-gray-400 focus:outline-none focus:ring-2 focus:ring-primary/30 transition-colors ${
-                        errors.contactEmail
-                          ? "border-red-400 focus:border-red-400"
-                          : "border-gray-200 dark:border-gray-700 focus:border-primary"
-                      }`}
-                    />
-                  </div>
-                  {errors.contactEmail && (
-                    <p className="text-xs text-red-500 mt-1">{errors.contactEmail.message}</p>
-                  )}
-                </div>
-
-                {/* Phone */}
-                <div>
-                  <label className="block text-xs font-semibold text-gray-700 dark:text-gray-300 mb-1.5">
-                    Phone Number <span className="text-red-500">*</span>
-                  </label>
-                  <div className="relative">
-                    <Phone className="absolute left-3.5 top-1/2 -translate-y-1/2 w-4 h-4 text-gray-400" />
-                    <input
-                      type="tel"
-                      placeholder="+251 912 345 678"
-                      {...register("contactPhone")}
-                      className={`w-full pl-10 pr-4 py-3 rounded-xl border-2 text-sm bg-white dark:bg-gray-800 text-gray-900 dark:text-white placeholder-gray-400 focus:outline-none focus:ring-2 focus:ring-primary/30 transition-colors ${
-                        errors.contactPhone
-                          ? "border-red-400 focus:border-red-400"
-                          : "border-gray-200 dark:border-gray-700 focus:border-primary"
-                      }`}
-                    />
-                  </div>
-                  {errors.contactPhone && (
-                    <p className="text-xs text-red-500 mt-1">{errors.contactPhone.message}</p>
-                  )}
-                </div>
-
-                {/* Notes */}
-                <div>
-                  <label className="block text-xs font-semibold text-gray-700 dark:text-gray-300 mb-1.5">
-                    Additional Notes{" "}
-                    <span className="text-gray-400 font-normal">(optional)</span>
-                  </label>
-                  <div className="relative">
-                    <FileText className="absolute left-3.5 top-3.5 w-4 h-4 text-gray-400" />
-                    <textarea
-                      rows={3}
-                      placeholder="Any special requirements or questions..."
-                      {...register("notes")}
-                      className={`w-full pl-10 pr-4 py-3 rounded-xl border-2 text-sm bg-white dark:bg-gray-800 text-gray-900 dark:text-white placeholder-gray-400 focus:outline-none focus:ring-2 focus:ring-primary/30 resize-none transition-colors ${
-                        errors.notes
-                          ? "border-red-400 focus:border-red-400"
-                          : "border-gray-200 dark:border-gray-700 focus:border-primary"
-                      }`}
-                    />
-                  </div>
-                  {errors.notes && (
-                    <p className="text-xs text-red-500 mt-1">{errors.notes.message}</p>
-                  )}
-                </div>
-
-                {/* API error */}
-                {submitError && (
-                  <div className="flex items-start gap-2.5 p-3.5 bg-red-50 dark:bg-red-900/20 border border-red-200 dark:border-red-800 rounded-xl">
-                    <AlertCircle className="w-4 h-4 text-red-500 flex-shrink-0 mt-0.5" />
-                    <p className="text-xs text-red-600 dark:text-red-400">{submitError}</p>
-                  </div>
-                )}
-
-                {/* Submit */}
-                <div className="pt-1 pb-2">
-                  <button
-                    type="submit"
-                    disabled={isSubmitting}
-                    className="w-full py-3.5 bg-[rgb(20,113,76)] hover:bg-[rgb(16,89,60)] disabled:opacity-60 text-white font-bold text-sm rounded-xl transition-all shadow-lg flex items-center justify-center gap-2"
-                  >
-                    {isSubmitting ? (
-                      <>
-                        <Loader2 className="w-4 h-4 animate-spin" />
-                        Submitting...
-                      </>
-                    ) : (
-                      <>
-                        Submit Inquiry <ArrowRight className="w-4 h-4" />
-                      </>
-                    )}
-                  </button>
-                  <p className="text-[10px] text-gray-400 text-center mt-2">
-                    Our team will contact you shortly to confirm.
-                  </p>
-                </div>
-              </form>
-            </>
-          )}
-        </div>
-      </div>
-    </>
-  );
-}
-
 // ─── Journey Card ─────────────────────────────────────────────────────────────
 
 function JourneyCard({ schedule, label }: { schedule: Schedule; label: string }) {
@@ -505,127 +198,238 @@ function PriceTiersPanel({
   tiers,
   selectedTierId,
   onSelect,
-  selectedTier,
   onBookNow,
+  isRoundTrip,
 }: {
   tiers: PriceTier[];
   selectedTierId: string | null;
   onSelect: (id: string) => void;
-  selectedTier?: PriceTier;
   onBookNow: () => void;
+  isRoundTrip: boolean;
 }) {
+  const priceMultiplier = isRoundTrip ? 2 : 1;
   return (
-    <div className="space-y-4">
-      <div className="bg-white dark:bg-gray-900 rounded-2xl p-5 border border-gray-100 dark:border-gray-800">
-        <h2 className="text-base font-bold text-gray-900 dark:text-white mb-4">
-          Select Seat Type
-        </h2>
+    <div className="bg-white dark:bg-gray-900 rounded-2xl p-5 border border-gray-100 dark:border-gray-800">
+      <h2 className="text-base font-bold text-gray-900 dark:text-white mb-4">
+        Select Seat Type
+      </h2>
 
-        {!tiers?.length ? (
-          <p className="text-sm text-gray-400 text-center py-4">
-            No price tiers available
-          </p>
-        ) : (
-          <div className="space-y-2.5">
-            {tiers.map((tier) => {
-              const soldOut = tier.availableSeats === 0;
-              const selected = tier.id === selectedTierId;
-              return (
-                <button
-                  key={tier.id}
-                  type="button"
-                  disabled={soldOut}
-                  onClick={() => onSelect(tier.id)}
-                  className={`w-full text-left rounded-xl border-2 p-3.5 transition-all ${
-                    soldOut
-                      ? "border-gray-200 dark:border-gray-700 opacity-50 cursor-not-allowed"
-                      : selected
-                        ? "border-primary bg-primary/5"
-                        : "border-gray-200 dark:border-gray-700 hover:border-primary/50 hover:shadow-sm"
-                  }`}
-                >
-                  {/* Row 1: radio + full label */}
-                  <div className="flex items-start gap-2.5">
-                    <div
-                      className={`w-4 h-4 rounded-full border-2 flex-shrink-0 flex items-center justify-center mt-0.5 transition-colors ${
-                        selected
-                          ? "border-primary bg-primary"
-                          : "border-gray-300 dark:border-gray-600"
-                      }`}
-                    >
-                      {selected && <div className="w-1.5 h-1.5 rounded-full bg-white" />}
-                    </div>
-                    <p className="text-sm font-semibold text-gray-900 dark:text-white leading-snug">
-                      {tier.label.trim()}
-                    </p>
+      {!tiers?.length ? (
+        <p className="text-sm text-gray-400 text-center py-4">
+          No price tiers available
+        </p>
+      ) : (
+        <div className="space-y-2.5">
+          {tiers.map((tier) => {
+            const soldOut = tier.availableSeats === 0;
+            const selected = tier.id === selectedTierId;
+            return (
+              <div
+                key={tier.id}
+                onClick={() => !soldOut && onSelect(tier.id)}
+                className={`rounded-xl border-2 p-3.5 transition-all ${
+                  soldOut
+                    ? "border-gray-200 dark:border-gray-700 opacity-50 cursor-not-allowed"
+                    : selected
+                      ? "border-primary bg-primary/5"
+                      : "border-gray-200 dark:border-gray-700 hover:border-primary/50 hover:shadow-sm cursor-pointer"
+                }`}
+              >
+                {/* Row 1: radio + full label */}
+                <div className="flex items-start gap-2.5">
+                  <div
+                    className={`w-4 h-4 rounded-full border-2 flex-shrink-0 flex items-center justify-center mt-0.5 transition-colors ${
+                      selected
+                        ? "border-primary bg-primary"
+                        : "border-gray-300 dark:border-gray-600"
+                    }`}
+                  >
+                    {selected && <div className="w-1.5 h-1.5 rounded-full bg-white" />}
                   </div>
+                  <p className="text-sm font-semibold text-gray-900 dark:text-white leading-snug">
+                    {tier.label.trim()}
+                  </p>
+                </div>
 
-                  {/* Row 2: seatType badge + seats + price */}
-                  <div className="flex items-center justify-between mt-2 pl-[26px]">
-                    <div className="flex items-center gap-2">
-                      <span className="text-[10px] font-bold text-gray-400 bg-gray-100 dark:bg-gray-800 px-1.5 py-0.5 rounded">
-                        {tier.seatType.trim()}
+                {/* Row 2: seatType badge + seats + price */}
+                <div className="flex items-center justify-between mt-2 pl-[26px]">
+                  <div className="flex items-center gap-2">
+                    <span className="text-[10px] font-bold text-gray-400 bg-gray-100 dark:bg-gray-800 px-1.5 py-0.5 rounded">
+                      {tier.seatType.trim()}
+                    </span>
+                    {soldOut ? (
+                      <span className="text-[10px] font-bold text-red-500 bg-red-50 dark:bg-red-900/20 px-1.5 py-0.5 rounded">
+                        SOLD OUT
                       </span>
-                      {soldOut ? (
-                        <span className="text-[10px] font-bold text-red-500 bg-red-50 dark:bg-red-900/20 px-1.5 py-0.5 rounded">
-                          SOLD OUT
-                        </span>
-                      ) : (
-                        <span className="text-[10px] text-gray-400">
-                          {tier.availableSeats} left
-                        </span>
-                      )}
-                    </div>
-                    <p className="text-sm font-extrabold text-primary">
-                      {formatPrice(tier.priceMinor, tier.currency)}
-                    </p>
+                    ) : (
+                      <span className="text-[10px] text-gray-400">
+                        {tier.availableSeats} left
+                      </span>
+                    )}
                   </div>
-                </button>
-              );
-            })}
-          </div>
-        )}
-      </div>
+                  <p className="text-sm font-extrabold text-primary">
+                    {formatPrice(tier.priceMinor * priceMultiplier, tier.currency)}
+                  </p>
+                </div>
 
-      {/* Summary + CTA */}
-      {selectedTier && (
-        <div className="bg-white dark:bg-gray-900 rounded-2xl p-5 border border-primary/30 shadow-sm">
-          <div className="space-y-2 mb-4">
-            <div className="flex items-center justify-between">
-              <p className="text-xs text-gray-500 dark:text-gray-400">Seat type</p>
-              <p className="text-xs font-semibold text-gray-900 dark:text-white">
-                {selectedTier.label.trim()}
-              </p>
-            </div>
-            <div className="flex items-center justify-between">
-              <p className="text-xs text-gray-500 dark:text-gray-400">Price per person</p>
-              <p className="text-base font-extrabold text-primary">
-                {formatPrice(selectedTier.priceMinor, selectedTier.currency)}
-              </p>
-            </div>
-          </div>
-          <button
-            type="button"
-            onClick={onBookNow}
-            className="w-full py-3.5 bg-[rgb(20,113,76)] hover:bg-[rgb(16,89,60)] text-white font-bold text-sm rounded-xl transition-all shadow-lg flex items-center justify-center gap-2"
-          >
-            Book Now <ArrowRight className="w-4 h-4" />
-          </button>
+                {/* Book Now — shown only when selected */}
+                {selected && (
+                  <button
+                    type="button"
+                    onClick={(e) => { e.stopPropagation(); onBookNow(); }}
+                    className="mt-3.5 w-full py-3 bg-[rgb(20,113,76)] hover:bg-[rgb(16,89,60)] text-white font-bold text-sm rounded-xl transition-all shadow-md flex items-center justify-center gap-2"
+                  >
+                    Book Now <ArrowRight className="w-4 h-4" />
+                  </button>
+                )}
+              </div>
+            );
+          })}
         </div>
       )}
     </div>
   );
 }
 
+// ─── Passenger count picker ──────────────────────────────────────────────────
+
+const PKG_MAX_ADULTS = 5;
+const PKG_MAX_CHILDREN = 2;
+const PKG_CHILD_FARE_RATIO = 0.1;
+
+function PassengerCountModal({
+  tier,
+  onClose,
+  onConfirm,
+  loading,
+  error,
+  priceMultiplier,
+  stations,
+}: {
+  tier: PriceTier;
+  onClose: () => void;
+  onConfirm: (adultCount: number, childCount: number, departureStationId: string, departureStationName: string) => void;
+  loading: boolean;
+  error: string | null;
+  priceMultiplier: number;
+  stations: Station[];
+}) {
+  const [adultCount, setAdultCount] = useState(1);
+  const [childCount, setChildCount] = useState(0);
+  const [departureStationId, setDepartureStationId] = useState('');
+  const [showStationError, setShowStationError] = useState(false);
+  const remaining = tier.availableSeats - tier.bookedSeats;
+  const childFareMinor = Math.round(tier.priceMinor * PKG_CHILD_FARE_RATIO);
+  const totalMinor = (adultCount * tier.priceMinor + childCount * childFareMinor) * priceMultiplier;
+
+  return (
+    <>
+      <div className="fixed inset-0 z-[90] bg-black/50 backdrop-blur-sm" onClick={onClose} />
+      <div className="fixed inset-0 z-[100] flex items-end sm:items-center justify-center p-0 sm:p-4">
+        <div className="w-full sm:max-w-sm bg-white dark:bg-gray-900 rounded-t-3xl sm:rounded-2xl shadow-2xl overflow-hidden">
+          <div className="flex items-center justify-between px-6 py-4 border-b border-gray-100 dark:border-gray-800">
+            <h2 className="text-base font-bold text-gray-900 dark:text-white">Number of passengers & boarding station selection</h2>
+            <button type="button" onClick={onClose} className="w-8 h-8 flex items-center justify-center rounded-full hover:bg-gray-100 dark:hover:bg-gray-800">
+              <X className="w-4 h-4 text-gray-500" />
+            </button>
+          </div>
+
+          <div className="px-6 py-3 bg-primary/5 border-b border-primary/10">
+            <p className="text-xs text-gray-400 uppercase tracking-wide font-semibold">Selected tier</p>
+            <p className="text-sm font-bold text-gray-900 dark:text-white mt-0.5">{tier.label.trim()}</p>
+            <p className="text-xs text-gray-400 mt-0.5">{remaining} seats remaining · {formatPrice(tier.priceMinor * priceMultiplier, tier.currency)} per adult</p>
+          </div>
+
+          <div className="px-6 py-5 space-y-4">
+            {[
+              { label: "Adults", sub: `Age 5+ · max ${PKG_MAX_ADULTS}`, value: adultCount, min: 1, max: Math.min(PKG_MAX_ADULTS, remaining), set: setAdultCount },
+              { label: "Children", sub: `Under 5 · max ${PKG_MAX_CHILDREN} · 10% of adult fare`, value: childCount, min: 0, max: Math.min(PKG_MAX_CHILDREN, remaining - adultCount), set: setChildCount },
+            ].map(({ label, sub, value, min, max, set }) => (
+                <div key={label} className="flex items-center justify-between">
+                  <div>
+                    <p className="text-sm font-semibold text-gray-900 dark:text-white">{label}</p>
+                    <p className="text-xs text-gray-400">{sub}</p>
+                  </div>
+                  <div className="flex items-center gap-3">
+                    <button type="button" onClick={() => set(Math.max(min, value - 1))}
+                      disabled={value <= min}
+                      className="w-8 h-8 rounded-full border-2 border-gray-200 dark:border-gray-700 flex items-center justify-center text-lg font-bold text-gray-600 dark:text-gray-300 disabled:opacity-30 hover:border-primary hover:text-primary transition-colors">
+                      −
+                    </button>
+                    <span className="w-6 text-center text-base font-bold text-gray-900 dark:text-white">{value}</span>
+                    <button type="button" onClick={() => set(value + 1)}
+                      disabled={value >= max}
+                      className="w-8 h-8 rounded-full border-2 border-gray-200 dark:border-gray-700 flex items-center justify-center text-lg font-bold text-gray-600 dark:text-gray-300 disabled:opacity-30 hover:border-primary hover:text-primary transition-colors">
+                      +
+                    </button>
+                  </div>
+                </div>
+              ))}
+
+            <div className="flex items-center justify-between pt-2 border-t border-gray-100 dark:border-gray-800">
+              <span className="text-sm text-gray-500">Total{priceMultiplier === 2 ? ' (round-trip)' : ''}</span>
+              <span className="text-base font-extrabold text-primary">{formatPrice(totalMinor, tier.currency)}</span>
+            </div>
+
+            {error && (
+              <div className="flex items-start gap-2 p-3 bg-red-50 dark:bg-red-900/20 border border-red-200 dark:border-red-800 rounded-xl">
+                <AlertCircle className="w-4 h-4 text-red-500 flex-shrink-0 mt-0.5" />
+                <p className="text-xs text-red-600 dark:text-red-400">{error}</p>
+              </div>
+            )}
+
+            {/* Departure Station */}
+            <div>
+              <label className="flex items-center gap-1.5 text-sm font-semibold text-gray-700 dark:text-gray-300 mb-1.5 border-t pt-3">                
+                Departure Station
+              </label>
+              <select
+                value={departureStationId}
+                onChange={(e) => { setDepartureStationId(e.target.value); setShowStationError(false); }}
+                className={`w-full rounded-xl border bg-white dark:bg-gray-800 text-sm text-gray-900 dark:text-white px-3 py-2.5 focus:outline-none focus:ring-2 focus:ring-primary/40 ${
+                  showStationError && !departureStationId ? 'border-red-400 dark:border-red-500' : 'border-gray-200 dark:border-gray-700'
+                }`}
+              >
+                <option value="">Select your boarding station</option>
+                {stations.map((s) => (
+                  <option key={s.id} value={s.id}>{s.name.trim()} ({s.code})</option>
+                ))}
+              </select>
+              <p className="text-[10px] text-gray-400 mt-1">For informational purposes — pricing remains fixed regardless of boarding point.</p>
+            </div>
+
+            {showStationError && !departureStationId && (
+              <p className="text-xs text-red-500 -mt-2">Please select your boarding station to continue.</p>
+            )}
+
+            <button type="button" onClick={() => {
+                if (!departureStationId) { setShowStationError(true); return; }
+                const station = stations.find(s => s.id === departureStationId);
+                onConfirm(adultCount, childCount, departureStationId, station?.name ?? '');
+              }}
+              disabled={loading || adultCount + childCount < 1}
+              className="w-full py-3.5 bg-[rgb(20,113,76)] hover:bg-[rgb(16,89,60)] disabled:opacity-60 text-white font-bold text-sm rounded-xl transition-all shadow-lg flex items-center justify-center gap-2">
+              {loading ? <><Loader2 className="w-4 h-4 animate-spin" /> Loading...</> : <>Continue <ArrowRight className="w-4 h-4" /></>}
+            </button>
+          </div>
+        </div>
+      </div>
+    </>
+  );
+}
+
 // ─── Main Page ────────────────────────────────────────────────────────────────
 
 export default function PackageDetailPage() {
   const params = useParams();
   const router = useRouter();
   const id = params?.id as string;
+  const { clearBooking, setSearchCriteria, setSelectedSchedule, setOutboundSchedule, setInboundSchedule, setPassengers, setPackageContext } = useBookingStore();
 
   const [selectedTierId, setSelectedTierId] = useState<string | null>(null);
-  const [inquiryOpen, setInquiryOpen] = useState(false);
+  const [passengerModalOpen, setPassengerModalOpen] = useState(false);
+  const [bookingContextLoading, setBookingContextLoading] = useState(false);
+  const [bookingContextError, setBookingContextError] = useState<string | null>(null);
 
   const { data: pkg, isLoading, isError } = useQuery<PackageDetail>({
     queryKey: ["package", id],
@@ -634,8 +438,90 @@ export default function PackageDetailPage() {
     enabled: !!id,
   });
 
+  // Build departure station list from the outbound schedule's route stops (ordered by sequence)
+  const routeStopStations: Station[] = pkg?.outboundSchedule?.stopTimes?.length
+    ? pkg.outboundSchedule.stopTimes.map((st) => st.station).filter(Boolean)
+    : [];
+
   const selectedTier = pkg?.priceTiers?.find((t) => t.id === selectedTierId);
 
+  const isRoundTripPkg = pkg?.journeyType === 'ROUND_TRIP';
+
+  const handleBookNow = async (adultCount: number, childCount: number, departureStationId: string, departureStationName: string) => {
+    if (!selectedTier || !pkg) return;
+    setBookingContextLoading(true);
+    setBookingContextError(null);
+    try {
+      const ctx: any = await apiClient.get(
+        `/packages/${id}/booking-context?tierId=${selectedTier.id}&adultCount=${adultCount}&childCount=${childCount}`,
+      );
+
+      clearBooking();
+
+      const passengerCount = adultCount + childCount;
+      const isRoundTrip = !!ctx.returnSchedule;
+
+      const toSchedule = (s: any) => ({
+        id: s.scheduleId,
+        trainNumber: s.trainNumber ?? "",
+        origin: s.originStation?.name ?? "",
+        destination: s.destinationStation?.name ?? "",
+        originStationId: s.originStationId ?? s.originStation?.id ?? "",
+        destinationStationId: s.destinationStationId ?? s.destinationStation?.id ?? "",
+        departureTime: s.departureAt,
+        arrivalTime: s.arrivalAt,
+        duration: s.durationMinutes ? `${Math.floor(s.durationMinutes / 60)}h ${s.durationMinutes % 60}m` : "",
+        baseFareAdult: Math.round(ctx.totalMinor / passengerCount),
+        baseFareChild: 0,
+        displayCurrency: selectedTier.currency,
+        selectedSeatClass: ctx.seatClassId,
+        selectedSeatClassName: ctx.seatClassName ?? "",
+        seatClassName: ctx.seatClassName ?? "",
+        selectedCoachTypeId: ctx.coachTypeId ?? "",
+      });
+
+      const outboundSched = toSchedule(ctx.outboundSchedule);
+
+      setSearchCriteria({
+        originStationId: ctx.outboundSchedule.originStation?.id ?? "",
+        destinationStationId: ctx.outboundSchedule.destinationStation?.id ?? "",
+        departureDate: ctx.outboundSchedule.departureAt?.slice(0, 10) ?? "",
+        returnDate: ctx.returnSchedule?.departureAt?.slice(0, 10),
+        tripType: isRoundTrip ? "ROUND_TRIP" : "ONE_WAY",
+        adultCount,
+        childCount,
+        nationality: "ETHIOPIAN",
+      });
+
+      if (isRoundTrip) {
+        setOutboundSchedule(outboundSched);
+        setInboundSchedule(toSchedule(ctx.returnSchedule));
+      } else {
+        setSelectedSchedule(outboundSched);
+      }
+
+      setPassengers(
+        Array.from({ length: passengerCount }, (_, i) => ({
+          name: "",
+          dateOfBirth: "",
+          nationality: "ETHIOPIAN",
+          isPrimaryPassenger: i === 0,
+        })),
+      );
+
+      // Store per-adult tier price (×1 leg); review page applies round-trip multiplier and child pricing
+      setPackageContext(id, selectedTier.id, selectedTier.priceMinor, pkg.name, departureStationId, departureStationName);
+
+      router.push("/booking/passengers");
+    } catch (err: any) {
+      setBookingContextError(
+        err?.response?.data?.message ?? "Failed to load booking context. Please try again.",
+      );
+    } finally {
+      setBookingContextLoading(false);
+    }
+  };
+
   if (isLoading) {
     return (
       <div className="min-h-screen flex items-center justify-center bg-gray-50 dark:bg-gray-950">
@@ -670,13 +556,16 @@ export default function PackageDetailPage() {
 
   return (
     <div className="min-h-screen bg-gray-50 dark:bg-gray-950">
-      {/* Inquiry modal */}
-      {inquiryOpen && selectedTier && (
-        <InquiryModal
-          packageId={pkg.id}
-          packageName={pkg.name}
+      {/* Passenger count modal */}
+      {passengerModalOpen && selectedTier && (
+        <PassengerCountModal
           tier={selectedTier}
-          onClose={() => setInquiryOpen(false)}
+          onClose={() => { setPassengerModalOpen(false); setBookingContextError(null); }}
+          onConfirm={handleBookNow}
+          loading={bookingContextLoading}
+          error={bookingContextError}
+          priceMultiplier={isRoundTripPkg ? 2 : 1}
+          stations={routeStopStations}
         />
       )}
 
@@ -756,7 +645,7 @@ export default function PackageDetailPage() {
                 <p className="text-xs font-bold text-gray-800 dark:text-white mt-0.5">
                   {pkg.priceTiers.length
                     ? formatPrice(
-                        Math.min(...pkg.priceTiers.map((t) => t.priceMinor)),
+                        Math.min(...pkg.priceTiers.map((t) => t.priceMinor)) * (isRoundTripPkg ? 2 : 1),
                         pkg.priceTiers[0].currency,
                       )
                     : "—"}
@@ -864,8 +753,8 @@ export default function PackageDetailPage() {
                 tiers={pkg.priceTiers}
                 selectedTierId={selectedTierId}
                 onSelect={setSelectedTierId}
-                selectedTier={selectedTier}
-                onBookNow={() => setInquiryOpen(true)}
+                onBookNow={() => setPassengerModalOpen(true)}
+                isRoundTrip={isRoundTripPkg}
               />
             </div>
           </div>
@@ -877,8 +766,8 @@ export default function PackageDetailPage() {
                 tiers={pkg.priceTiers}
                 selectedTierId={selectedTierId}
                 onSelect={setSelectedTierId}
-                selectedTier={selectedTier}
-                onBookNow={() => setInquiryOpen(true)}
+                onBookNow={() => setPassengerModalOpen(true)}
+                isRoundTrip={isRoundTripPkg}
               />
             </div>
           </div>
diff --git a/apps/edr-passenger-web/portal/src/app/packages/page.tsx b/apps/edr-passenger-web/portal/src/app/packages/page.tsx
new file mode 100644
index 000000000..01c52bb26
--- /dev/null
+++ b/apps/edr-passenger-web/portal/src/app/packages/page.tsx
@@ -0,0 +1,5 @@
+import PackagesSection from "@/components/PackagesSection";
+
+export default function PackagesPage() {
+  return <PackagesSection />;
+}
diff --git a/apps/edr-passenger-web/portal/src/app/profile/page.tsx b/apps/edr-passenger-web/portal/src/app/profile/page.tsx
index dbc64d4a9..d44474976 100644
--- a/apps/edr-passenger-web/portal/src/app/profile/page.tsx
+++ b/apps/edr-passenger-web/portal/src/app/profile/page.tsx
@@ -161,7 +161,7 @@ export default function ProfilePage() {
     mutationFn: () => apiClient.delete('/auth/account'),
     onSuccess: () => {
       logout();
-      router.push('/booking/search');
+      window.location.href = '/';
     },
   });
 
diff --git a/apps/edr-passenger-web/portal/src/app/register/page.tsx b/apps/edr-passenger-web/portal/src/app/register/page.tsx
index c335d9e98..a39810be1 100644
--- a/apps/edr-passenger-web/portal/src/app/register/page.tsx
+++ b/apps/edr-passenger-web/portal/src/app/register/page.tsx
@@ -9,18 +9,11 @@ import { useAuthStore } from '@/lib/auth-store';
 import { useState } from 'react';
 import { Train, ShieldCheck } from 'lucide-react';
 
-const registerSchema = z
-  .object({
-    fullName: z.string().min(2, 'Full name is required'),
-    email: z.string().email('Invalid email address'),
-    phone: z.string().min(9, 'Phone number is required'),
-    password: z.string().min(8, 'Password must be at least 8 characters'),
-    confirmPassword: z.string(),
-  })
-  .refine((data) => data.password === data.confirmPassword, {
-    message: 'Passwords do not match',
-    path: ['confirmPassword'],
-  });
+const registerSchema = z.object({
+  fullName: z.string().min(2, 'Full name is required'),
+  email: z.string().email('Invalid email address'),
+  phone: z.string().min(9, 'Phone number is required'),
+});
 
 type RegisterForm = z.infer<typeof registerSchema>;
 
@@ -38,14 +31,17 @@ export default function RegisterPage() {
     setLoading(true);
     setError('');
     try {
-      await registerUser({
+      const result = await registerUser({
         fullName: data.fullName,
         email: data.email,
         phone: data.phone,
-        password: data.password,
-        confirmPassword: data.confirmPassword,
       });
-      router.push('/booking/search');
+      const params = new URLSearchParams({
+        email: result.email,
+        userId: result.iamUserId,
+        phone: result.phoneNumber,
+      });
+      router.push(`/verify-account?${params.toString()}`);
     } catch (err: any) {
       if (err.response?.status === 409) {
         setError('An account with this email or phone number already exists.');
@@ -67,7 +63,7 @@ export default function RegisterPage() {
             </div>
           </div>
           <h1 className="text-3xl font-bold text-gray-900 dark:text-gray-100">Create account</h1>
-          <p className="text-gray-600 dark:text-gray-400 mt-2">Book faster and manage your trips</p>
+          <p className="text-gray-600 dark:text-gray-400 mt-2">We&apos;ll text you a code to verify your phone</p>
         </div>
 
         <div className="card">
@@ -120,36 +116,8 @@ export default function RegisterPage() {
               )}
             </div>
 
-            <div>
-              <label className="block text-sm font-medium mb-1 text-gray-700 dark:text-gray-300">Password</label>
-              <input
-                type="password"
-                {...register('password')}
-                className="input-field"
-                placeholder="••••••••"
-                autoComplete="new-password"
-              />
-              {errors.password && (
-                <p className="text-red-500 text-sm mt-1">{errors.password.message}</p>
-              )}
-            </div>
-
-            <div>
-              <label className="block text-sm font-medium mb-1 text-gray-700 dark:text-gray-300">Confirm password</label>
-              <input
-                type="password"
-                {...register('confirmPassword')}
-                className="input-field"
-                placeholder="••••••••"
-                autoComplete="new-password"
-              />
-              {errors.confirmPassword && (
-                <p className="text-red-500 text-sm mt-1">{errors.confirmPassword.message}</p>
-              )}
-            </div>
-
             <button type="submit" className="btn-primary w-full" disabled={loading}>
-              {loading ? 'Creating account...' : 'Create account'}
+              {loading ? 'Sending code...' : 'Send verification code'}
             </button>
           </form>
 
diff --git a/apps/edr-passenger-web/portal/src/app/verify-account/page.tsx b/apps/edr-passenger-web/portal/src/app/verify-account/page.tsx
new file mode 100644
index 000000000..b2fd491b3
--- /dev/null
+++ b/apps/edr-passenger-web/portal/src/app/verify-account/page.tsx
@@ -0,0 +1,215 @@
+'use client';
+
+import { Suspense, useState } from 'react';
+import { useSearchParams } from 'next/navigation';
+import Link from 'next/link';
+import { Train, ArrowLeft, ShieldCheck } from 'lucide-react';
+import { iamAuthApi } from '@/lib/api/auth';
+import { useAuthStore } from '@/lib/auth-store';
+
+// Mirrors the IAM set-password requirement (class-validator @IsStrongPassword defaults):
+// min length 8, with lower- and upper-case letters, a number, and a symbol.
+function isStrongPassword(pw: string): boolean {
+  return (
+    pw.length >= 8 &&
+    /[a-z]/.test(pw) &&
+    /[A-Z]/.test(pw) &&
+    /[0-9]/.test(pw) &&
+    /[^A-Za-z0-9]/.test(pw)
+  );
+}
+
+function VerifyAccountContent() {
+  const searchParams = useSearchParams();
+  const login = useAuthStore((s) => s.login);
+
+  const email = searchParams.get('email') || '';
+  const userId = searchParams.get('userId') || '';
+  const phone = searchParams.get('phone') || '';
+  const linkValid = Boolean(email && userId);
+
+  const [verificationCode, setVerificationCode] = useState('');
+  const [newPassword, setNewPassword] = useState('');
+  const [confirmPassword, setConfirmPassword] = useState('');
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState('');
+  const [resending, setResending] = useState(false);
+  const [resent, setResent] = useState(false);
+
+  const handleSubmit = async (e: React.FormEvent) => {
+    e.preventDefault();
+    setError('');
+    if (!verificationCode.trim()) {
+      setError('Enter the verification code sent to your phone.');
+      return;
+    }
+    if (!isStrongPassword(newPassword)) {
+      setError('Password must be at least 8 characters and include upper- and lower-case letters, a number, and a symbol.');
+      return;
+    }
+    if (newPassword !== confirmPassword) {
+      setError('Passwords do not match.');
+      return;
+    }
+    setLoading(true);
+    try {
+      // Completes signup: PATCH /v1/auth/set-password with the SMS code, which activates
+      // the account and sets the password.
+      await iamAuthApi.resetPassword({
+        userId,
+        email,
+        verificationCode: verificationCode.trim(),
+        newPassword,
+        confirmPassword,
+      });
+      // Auto-login with the freshly-set password; login lazy-provisions the passenger record.
+      await login(email, newPassword);
+      window.location.href = '/';
+    } catch (err: any) {
+      const msg = err.response?.data?.message || err.message || '';
+      setError(msg || 'Could not verify your account. Check the code and try again, or resend it.');
+      setLoading(false);
+    }
+  };
+
+  const handleResend = async () => {
+    setError('');
+    setResent(false);
+    setResending(true);
+    try {
+      await iamAuthApi.resendRegistrationCode({ email, phoneNumber: phone });
+      setResent(true);
+    } catch {
+      setError('Could not resend the code. Please try again in a moment.');
+    } finally {
+      setResending(false);
+    }
+  };
+
+  return (
+    <div className="min-h-screen bg-gradient-to-br from-[rgb(20_113_76)] from-10% via-transparent to-[rgb(20_113_76)] to-90% dark:from-gray-900 dark:to-gray-800 flex items-center justify-center py-12 px-4">
+      <div className="max-w-md w-full">
+        <div className="text-center mb-8">
+          <div className="flex justify-center mb-4">
+            <div className="w-12 h-12 bg-[rgb(20_113_76)] rounded-lg flex items-center justify-center">
+              <Train className="w-6 h-6 text-white" />
+            </div>
+          </div>
+          <h1 className="text-3xl font-bold text-gray-900 dark:text-gray-100">Verify your account</h1>
+          {linkValid && (
+            <p className="text-gray-600 dark:text-gray-400 mt-2">
+              Enter the code we sent to your phone and choose a password for{' '}
+              <span className="font-medium">{email}</span>.
+            </p>
+          )}
+        </div>
+
+        <div className="card">
+          {!linkValid ? (
+            <div className="space-y-4">
+              <div className="bg-red-50 dark:bg-red-900/30 border border-red-200 dark:border-red-800 text-red-700 dark:text-red-300 px-4 py-3 rounded">
+                This verification link is invalid or incomplete. Please start registration again.
+              </div>
+              <Link href="/register" className="btn-primary w-full flex items-center justify-center">
+                Back to registration
+              </Link>
+            </div>
+          ) : (
+            <form onSubmit={handleSubmit} className="space-y-4">
+              {error && (
+                <div className="bg-red-50 dark:bg-red-900/30 border border-red-200 dark:border-red-800 text-red-700 dark:text-red-300 px-4 py-3 rounded">
+                  {error}
+                </div>
+              )}
+              {resent && !error && (
+                <div className="flex items-start gap-3 bg-emerald-50 dark:bg-emerald-900/30 border border-emerald-200 dark:border-emerald-800 text-emerald-700 dark:text-emerald-300 px-4 py-3 rounded">
+                  <ShieldCheck className="w-5 h-5 flex-shrink-0 mt-0.5" />
+                  <p className="text-sm">A new code has been sent to your phone.</p>
+                </div>
+              )}
+
+              <div>
+                <label className="block text-sm font-medium mb-1 text-gray-700 dark:text-gray-300">Verification code</label>
+                <input
+                  type="text"
+                  inputMode="numeric"
+                  autoComplete="one-time-code"
+                  value={verificationCode}
+                  onChange={(e) => { setVerificationCode(e.target.value); setError(''); }}
+                  className="input-field tracking-widest"
+                  placeholder="123456"
+                  maxLength={6}
+                  required
+                />
+              </div>
+
+              <div>
+                <label className="block text-sm font-medium mb-1 text-gray-700 dark:text-gray-300">New password</label>
+                <input
+                  type="password"
+                  value={newPassword}
+                  onChange={(e) => { setNewPassword(e.target.value); setError(''); }}
+                  className="input-field"
+                  placeholder="••••••••"
+                  autoComplete="new-password"
+                  minLength={8}
+                  required
+                />
+                <p className="text-xs text-gray-500 dark:text-gray-400 mt-1">
+                  At least 8 characters with upper &amp; lower case, a number, and a symbol.
+                </p>
+              </div>
+
+              <div>
+                <label className="block text-sm font-medium mb-1 text-gray-700 dark:text-gray-300">Confirm password</label>
+                <input
+                  type="password"
+                  value={confirmPassword}
+                  onChange={(e) => { setConfirmPassword(e.target.value); setError(''); }}
+                  className="input-field"
+                  placeholder="••••••••"
+                  autoComplete="new-password"
+                  minLength={8}
+                  required
+                />
+              </div>
+
+              <button
+                type="submit"
+                className="btn-primary w-full"
+                disabled={loading || !verificationCode || !newPassword || !confirmPassword}
+              >
+                {loading ? 'Verifying...' : 'Verify and continue'}
+              </button>
+
+              <button
+                type="button"
+                onClick={handleResend}
+                disabled={resending}
+                className="w-full text-sm text-gray-600 dark:text-gray-400 hover:text-[rgb(20_113_76)] dark:hover:text-emerald-400 transition-colors disabled:opacity-50"
+              >
+                {resending ? 'Resending...' : "Didn't get a code? Resend"}
+              </button>
+
+              <Link
+                href="/register"
+                className="flex items-center justify-center gap-1.5 text-sm text-gray-600 dark:text-gray-400 hover:text-[rgb(20_113_76)] dark:hover:text-emerald-400 transition-colors"
+              >
+                <ArrowLeft className="w-4 h-4" />
+                Back to registration
+              </Link>
+            </form>
+          )}
+        </div>
+      </div>
+    </div>
+  );
+}
+
+export default function VerifyAccountPage() {
+  return (
+    <Suspense fallback={null}>
+      <VerifyAccountContent />
+    </Suspense>
+  );
+}
diff --git a/apps/edr-passenger-web/portal/src/components/PackagesSection.tsx b/apps/edr-passenger-web/portal/src/components/PackagesSection.tsx
index abadbe4e7..5fb5c0b8a 100644
--- a/apps/edr-passenger-web/portal/src/components/PackagesSection.tsx
+++ b/apps/edr-passenger-web/portal/src/components/PackagesSection.tsx
@@ -51,6 +51,7 @@ interface HolidayPackage {
   includedServices?: string[];
   busTransferIncluded?: boolean;
   busTransferRoute?: string | null;
+  journeyType?: 'ONE_WAY' | 'ROUND_TRIP';
   returnSchedule?: Schedule | null;
   outboundSchedule?: Schedule;
   priceTiers: PriceTier[];
@@ -82,10 +83,11 @@ function daysUntil(iso: string): number {
 
 function minPrice(
   tiers: PriceTier[],
+  multiplier = 1,
 ): { amount: number; currency: string } | null {
   if (!tiers?.length) return null;
   const min = tiers.reduce((a, b) => (a.priceMinor < b.priceMinor ? a : b));
-  return { amount: min.priceMinor / 100, currency: min.currency };
+  return { amount: (min.priceMinor * multiplier) / 100, currency: min.currency };
 }
 
 function fmtPrice(minor: number, currency: string): string {
@@ -142,7 +144,8 @@ function AvailBar({ booked, total }: { booked: number; total: number }) {
 // ─── Featured Card (first package — full-width, image left) ───────────────────
 
 function FeaturedCard({ pkg }: { pkg: HolidayPackage }) {
-  const price = minPrice(pkg.priceTiers);
+  const multiplier = pkg.journeyType === 'ROUND_TRIP' ? 2 : 1;
+  const price = minPrice(pkg.priceTiers, multiplier);
   const origin = pkg.outboundSchedule?.originStation;
   const dest = pkg.outboundSchedule?.destinationStation;
   const days = daysUntil(pkg.validUntil);
@@ -312,7 +315,8 @@ function FeaturedCard({ pkg }: { pkg: HolidayPackage }) {
 // ─── Regular Package Card ─────────────────────────────────────────────────────
 
 function PackageCard({ pkg }: { pkg: HolidayPackage }) {
-  const price = minPrice(pkg.priceTiers);
+  const multiplier = pkg.journeyType === 'ROUND_TRIP' ? 2 : 1;
+  const price = minPrice(pkg.priceTiers, multiplier);
   const origin = pkg.outboundSchedule?.originStation;
   const dest = pkg.outboundSchedule?.destinationStation;
 
@@ -485,7 +489,6 @@ export default function PackagesSection() {
     queryKey: ["packages"],
     queryFn: async () =>
       (await apiClient.get<HolidayPackage[]>("/packages")) as HolidayPackage[],
-    staleTime: 5 * 60 * 1000,
   });
 
   if (isError) return null;
diff --git a/apps/edr-passenger-web/portal/src/lib/api-client.ts b/apps/edr-passenger-web/portal/src/lib/api-client.ts
index 472c66e70..471218532 100644
--- a/apps/edr-passenger-web/portal/src/lib/api-client.ts
+++ b/apps/edr-passenger-web/portal/src/lib/api-client.ts
@@ -21,7 +21,11 @@ class ApiClient {
       return config;
     });
 
-    const PUBLIC_PREFIXES = ['/config/', '/auth/login', '/auth/register', '/passengers/me'];
+    // /fayda/verification/* is used by guests filling out the passenger form, and a 401
+    // there just means the user canceled/closed the Fayda popup without completing it (no
+    // valid verification session) — that should surface as an inline error on the page,
+    // not force-clear the session and redirect to /login out from under them.
+    const PUBLIC_PREFIXES = ['/config/', '/auth/login', '/auth/register', '/passengers/me', '/fayda/verification'];
 
     this.client.interceptors.response.use(
       (response) => response,
diff --git a/apps/edr-passenger-web/portal/src/lib/api/auth.ts b/apps/edr-passenger-web/portal/src/lib/api/auth.ts
index aa5272173..14e9a16a1 100644
--- a/apps/edr-passenger-web/portal/src/lib/api/auth.ts
+++ b/apps/edr-passenger-web/portal/src/lib/api/auth.ts
@@ -11,6 +11,10 @@ export const iamAuthApi = {
   forgotPassword: (email: string) =>
     axios.post(`${API_URL}/v1/auth/forgot-password`, { email }),
 
+  // Re-sends the registration verification code for a still-pending account.
+  resendRegistrationCode: (data: { email: string; phoneNumber: string }) =>
+    axios.post(`${API_URL}/auth/register/resend-code`, data),
+
   // Completes the forgot-password flow using the link sent via SMS:
   // ${FE_BASE_URL}/reset-password?email=..&userId=..&verificationCode=..
   resetPassword: (data: {
diff --git a/apps/edr-passenger-web/portal/src/lib/auth-store.ts b/apps/edr-passenger-web/portal/src/lib/auth-store.ts
index 2157cfc0a..0d6e46fd9 100644
--- a/apps/edr-passenger-web/portal/src/lib/auth-store.ts
+++ b/apps/edr-passenger-web/portal/src/lib/auth-store.ts
@@ -31,7 +31,7 @@ interface AuthState {
   isAuthenticated: boolean;
   isInitialized: boolean;
   login: (email: string, password: string) => Promise<void>;
-  register: (data: RegisterData) => Promise<void>;
+  register: (data: RegisterData) => Promise<RegisterResult>;
   logout: () => Promise<void>;
   setUser: (user: User, token: string) => void;
   updateUser: (userData: Partial<User>) => void;
@@ -43,8 +43,12 @@ interface RegisterData {
   fullName: string;
   email: string;
   phone: string;
-  password: string;
-  confirmPassword: string;
+}
+
+interface RegisterResult {
+  iamUserId: string;
+  email: string;
+  phoneNumber: string;
 }
 
 export const useAuthStore = create<AuthState>((set, get) => ({
@@ -118,25 +122,24 @@ export const useAuthStore = create<AuthState>((set, get) => ({
         set({ user, token, isAuthenticated: true });
       },
 
-      register: async (data: RegisterData) => {
+      register: async (data: RegisterData): Promise<RegisterResult> => {
         // Shape required by the passenger-api RegisterDto; username = email by convention.
+        // Registration no longer takes a password — the account is created as pending and
+        // an SMS verification code is sent. The user completes signup on the verify-account
+        // page (set-password). No token is issued here; the user is NOT logged in yet.
         const payload = {
           email: data.email,
           username: data.email,
           phoneNumber: data.phone,
           name: { en: data.fullName, am: data.fullName },
-          password: data.password,
-          confirmPassword: data.confirmPassword,
         };
         const response: any = await apiClient.post('/auth/register', payload);
-        const { token, user } = response.data || response;
-        
-        if (typeof window !== 'undefined') {
-          localStorage.setItem('auth_token', token);
-          localStorage.setItem('auth_user', JSON.stringify(user));
-        }
-        
-        set({ user, token, isAuthenticated: true });
+        const result = response.data || response;
+        return {
+          iamUserId: result.iamUserId,
+          email: result.email,
+          phoneNumber: result.phoneNumber,
+        };
       },
 
       logout: async () => {
diff --git a/apps/edr-passenger-web/portal/src/lib/booking-store.ts b/apps/edr-passenger-web/portal/src/lib/booking-store.ts
index 93262f5b8..ec2b34e5b 100644
--- a/apps/edr-passenger-web/portal/src/lib/booking-store.ts
+++ b/apps/edr-passenger-web/portal/src/lib/booking-store.ts
@@ -29,14 +29,30 @@ export interface PassengerDetail {
   isPrimaryPassenger: boolean;
   seatId?: string;
   seatNumber?: string;
+  coachNumber?: string;
+  // Fare for this passenger's actual assigned seat (minor units). Bed coaches price
+  // Upper/Middle/Lower differently, so this can differ from the schedule's flat
+  // baseFareAdult (which is only the coach type's cheapest class) — review/payment
+  // should prefer this per-seat fare when it's available.
+  seatFareMinor?: number;
+  // Raw bed position ("lower"/"middle"/"upper") of the assigned seat, if it's a berth —
+  // used to resolve this passenger's actual seat class server-side (see review page's
+  // fare-breakdown request), since a shared coach-level class can't distinguish berths.
+  bedPosition?: string;
   phone?: string;
   email?: string;
   gender?: string;
   // Round-trip specific seat assignments
   outboundSeatId?: string;
   outboundSeatNumber?: string;
+  outboundCoachNumber?: string;
+  outboundSeatFareMinor?: number;
+  outboundBedPosition?: string;
   inboundSeatId?: string;
   inboundSeatNumber?: string;
+  inboundCoachNumber?: string;
+  inboundSeatFareMinor?: number;
+  inboundBedPosition?: string;
   returnSeatId?: string;
   returnSeatNumber?: string;
 }
@@ -46,6 +62,8 @@ export interface SelectedSchedule {
   trainNumber: string;
   origin: string;
   destination: string;
+  originStationId?: string;
+  destinationStationId?: string;
   departureTime: string;
   arrivalTime: string;
   duration: string;
@@ -58,6 +76,21 @@ export interface SelectedSchedule {
   selectedCoachTypeId?: string;
   selectedCoachTypeCode?: string;
   selectedCoachTypeName?: string;
+  // All coach types (with per-class fares) offered on this schedule at selection time —
+  // kept so the seat map's coach preview can compute the fare difference before letting
+  // a passenger switch to a different coach type.
+  coachTypes?: Array<{
+    coachId: string;
+    coachTypeId: string;
+    coachTypeName: string;
+    coachTypeCode: string;
+    classes: Array<{
+      name: string;
+      baseFareMinor: number;
+      displayCurrency?: string;
+      displayAmountMinor?: number;
+    }>;
+  }>;
 }
 
 export interface SeatHold {
@@ -79,7 +112,13 @@ interface BookingState {
   selectedPaymentMethod: string | null;
   createAccount: boolean;
   passengerId: string | null;
-  
+  packageId: string | null;
+  packageName: string | null;
+  priceTierId: string | null;
+  packageTierPriceMinor: number | null;
+  packageDepartureStationId: string | null;
+  packageDepartureStationName: string | null;
+
   setSearchCriteria: (criteria: SearchCriteria) => void;
   setSelectedSchedule: (schedule: SelectedSchedule) => void;
   setOutboundSchedule: (schedule: SelectedSchedule) => void;
@@ -91,6 +130,7 @@ interface BookingState {
   setPaymentMethod: (method: string) => void;
   setCreateAccount: (create: boolean) => void;
   setPassengerId: (id: string | null) => void;
+  setPackageContext: (packageId: string, priceTierId: string, priceMinor: number, packageName?: string, departureStationId?: string, departureStationName?: string) => void;
   clearBooking: () => void;
 }
 
@@ -107,8 +147,15 @@ export const useBookingStore = create<BookingState>()(persist(
       selectedPaymentMethod: null,
       createAccount: false,
       passengerId: null,
+      packageId: null,
+      packageName: null,
+      priceTierId: null,
+      packageTierPriceMinor: null,
+      packageDepartureStationId: null,
+      packageDepartureStationName: null,
 
       setSearchCriteria: (criteria) => set({ searchCriteria: criteria }),
+      setPackageContext: (packageId, priceTierId, priceMinor, packageName, departureStationId, departureStationName) => set({ packageId, packageName: packageName ?? null, priceTierId, packageTierPriceMinor: priceMinor, packageDepartureStationId: departureStationId ?? null, packageDepartureStationName: departureStationName ?? null }),
       setSelectedSchedule: (schedule) => set({ selectedSchedule: schedule }),
       setOutboundSchedule: (schedule) => set({ outboundSchedule: schedule }),
       setInboundSchedule: (schedule) => set({ inboundSchedule: schedule }),
@@ -131,6 +178,12 @@ export const useBookingStore = create<BookingState>()(persist(
         selectedPaymentMethod: null,
         createAccount: false,
         passengerId: null,
+        packageId: null,
+        packageName: null,
+        priceTierId: null,
+        packageTierPriceMinor: null,
+        packageDepartureStationId: null,
+        packageDepartureStationName: null,
       }),
   } as BookingState)),
   {
diff --git a/apps/edr-passenger-web/portal/src/lib/generate-voucher.ts b/apps/edr-passenger-web/portal/src/lib/generate-voucher.ts
index 4dd969d69..37f421d71 100644
--- a/apps/edr-passenger-web/portal/src/lib/generate-voucher.ts
+++ b/apps/edr-passenger-web/portal/src/lib/generate-voucher.ts
@@ -1,5 +1,6 @@
 import jsPDF from 'jspdf';
 import autoTable from 'jspdf-autotable';
+import QRCode from 'qrcode';
 
 interface ScheduleInfo {
   trainNumber: string;
@@ -36,6 +37,40 @@ const DARK    = [51,  51,  51] as const;
 const MED     = [102, 102, 102] as const;
 const LIGHT   = [200, 200, 200] as const;
 
+// ─── QR code ───────────────────────────────────────────────────────────────
+// Encodes everything a gate scanner needs to verify this specific ticket without
+// a network round-trip: booking reference, ticket number, passenger, train, seat(s),
+// departure time and fare. Kept as compact JSON so any generic QR reader can parse it.
+function buildTicketQrPayload(data: PassengerVoucherData): string {
+  return JSON.stringify({
+    type: 'EDR_TICKET',
+    pnr: data.bookingRef,
+    ticket: data.ticketNumber,
+    passenger: data.passengerName,
+    status: data.status,
+    train: data.outboundSchedule.trainNumber,
+    seat: data.isRoundTrip
+      ? { outbound: data.outboundSeatNumber || null, inbound: data.inboundSeatNumber || null }
+      : (data.seatNumber || null),
+    departure: data.outboundSchedule.departureAt,
+    fare: { amountMinor: data.fareMinor, currency: data.currency },
+  });
+}
+
+async function generateTicketQrDataUrl(data: PassengerVoucherData): Promise<string | null> {
+  try {
+    return await QRCode.toDataURL(buildTicketQrPayload(data), {
+      width: 240,
+      margin: 0,
+      errorCorrectionLevel: 'M',
+      color: { dark: '#0f172a', light: '#ffffff' },
+    });
+  } catch (error) {
+    console.error('Failed to generate ticket QR code:', error);
+    return null;
+  }
+}
+
 async function drawHeader(doc: jsPDF, margin: number): Promise<number> {
   const pageWidth = doc.internal.pageSize.getWidth();
 
@@ -81,22 +116,41 @@ function drawStatusBadge(doc: jsPDF, status: string, y: number, pageWidth: numbe
   return y + 12;
 }
 
-function drawBookingRefBox(doc: jsPDF, bookingRef: string, ticketNumber: string, y: number, margin: number, pageWidth: number): number {
+function drawBookingRefBox(doc: jsPDF, bookingRef: string, ticketNumber: string, qrDataUrl: string | null, y: number, margin: number, pageWidth: number): number {
+  const boxHeight = 32;
+  const qrSize = 24;
+  const qrPad = 3;
+  const qrBlockWidth = qrDataUrl ? qrSize + qrPad * 2 + 5 : 0;
+
   doc.setFillColor(245, 245, 245);
-  doc.rect(margin, y, pageWidth - margin * 2, 22, 'F');
+  doc.roundedRect(margin, y, pageWidth - margin * 2, boxHeight, 2, 2, 'F');
 
+  // Booking reference (top-left)
   doc.setTextColor(...MED); doc.setFontSize(8); doc.setFont('helvetica', 'normal');
-  doc.text('BOOKING REFERENCE', margin + 5, y + 6);
-  doc.setTextColor(...PRIMARY); doc.setFontSize(16); doc.setFont('helvetica', 'bold');
-  doc.text(bookingRef, margin + 5, y + 14);
+  doc.text('BOOKING REFERENCE', margin + 5, y + 8);
+  doc.setTextColor(...PRIMARY); doc.setFontSize(18); doc.setFont('helvetica', 'bold');
+  doc.text(bookingRef, margin + 5, y + 18);
 
-  const rightX = pageWidth - margin - 5;
+  // Ticket number, stacked below — leaves room on the right for the QR block
+  const textRightBound = pageWidth - margin - qrBlockWidth - 5;
   doc.setTextColor(...MED); doc.setFontSize(8); doc.setFont('helvetica', 'normal');
-  doc.text('TICKET NUMBER', rightX, y + 6, { align: 'right' });
+  doc.text('TICKET NUMBER', textRightBound, y + 8, { align: 'right' });
   doc.setTextColor(...DARK); doc.setFontSize(11); doc.setFont('helvetica', 'bold');
-  doc.text(ticketNumber, rightX, y + 14, { align: 'right' });
+  doc.text(ticketNumber, textRightBound, y + 16, { align: 'right' });
 
-  return y + 28;
+  // QR code — clean white card with a thin border, right-aligned in the box
+  if (qrDataUrl) {
+    const cardSize = qrSize + qrPad * 2;
+    const cardX = pageWidth - margin - cardSize - 3;
+    const cardY = y + (boxHeight - cardSize) / 2;
+    doc.setFillColor(255, 255, 255);
+    doc.setDrawColor(...LIGHT);
+    doc.setLineWidth(0.4);
+    doc.roundedRect(cardX, cardY, cardSize, cardSize, 2, 2, 'FD');
+    doc.addImage(qrDataUrl, 'PNG', cardX + qrPad, cardY + qrPad, qrSize, qrSize);
+  }
+
+  return y + boxHeight + 6;
 }
 
 function drawJourneyLeg(doc: jsPDF, schedule: ScheduleInfo, label: string | null, y: number, margin: number, pageWidth: number): number {
@@ -244,6 +298,7 @@ export const generatePassengerVoucherPDF = async (data: PassengerVoucherData): P
   const margin = 15;
 
   let y = await drawHeader(doc, margin);
+  const qrDataUrl = await generateTicketQrDataUrl(data);
 
   // Title
   doc.setTextColor(...DARK); doc.setFontSize(18); doc.setFont('helvetica', 'bold');
@@ -251,7 +306,7 @@ export const generatePassengerVoucherPDF = async (data: PassengerVoucherData): P
   y += 10;
 
   y = drawStatusBadge(doc, data.status, y, pageW);
-  y = drawBookingRefBox(doc, data.bookingRef, data.ticketNumber, y, margin, pageW);
+  y = drawBookingRefBox(doc, data.bookingRef, data.ticketNumber, qrDataUrl, y, margin, pageW);
   y = drawJourneyLeg(doc, data.outboundSchedule, data.isRoundTrip ? 'Outbound' : null, y, margin, pageW);
 
   if (data.isRoundTrip && data.inboundSchedule) {
diff --git a/apps/edr-passenger-web/portal/src/lib/payment-store.ts b/apps/edr-passenger-web/portal/src/lib/payment-store.ts
index 057639004..85b74b55c 100644
--- a/apps/edr-passenger-web/portal/src/lib/payment-store.ts
+++ b/apps/edr-passenger-web/portal/src/lib/payment-store.ts
@@ -3,11 +3,17 @@ import { create } from 'zustand';
 interface PaymentState {
   paymentIntentId: string | null;
   paymentStatus: 'PENDING' | 'PROCESSING' | 'REQUIRES_ACTION' | 'SUCCEEDED' | 'FAILED' | null;
+  // The currency actually confirmed for the selected payment option (from
+  // /payments/booking-amount), not just a default — kept in sync by the payment page.
   selectedCurrency: 'ETB' | 'DJF' | 'USD';
-  
+  // The exact minor-unit amount confirmed for that currency/payment option. Downstream
+  // screens (e.g. the voucher) should use this instead of recomputing a default ETB fare.
+  paidAmountMinor: number | null;
+
   setPaymentIntent: (id: string) => void;
   updateStatus: (status: 'PENDING' | 'PROCESSING' | 'REQUIRES_ACTION' | 'SUCCEEDED' | 'FAILED') => void;
   setCurrency: (currency: 'ETB' | 'DJF' | 'USD') => void;
+  setPaidAmount: (amountMinor: number) => void;
   clearPayment: () => void;
 }
 
@@ -15,13 +21,16 @@ export const usePaymentStore = create<PaymentState>((set) => ({
   paymentIntentId: null,
   paymentStatus: null,
   selectedCurrency: 'ETB',
+  paidAmountMinor: null,
 
   setPaymentIntent: (id) => set({ paymentIntentId: id }),
   updateStatus: (status) => set({ paymentStatus: status }),
   setCurrency: (currency) => set({ selectedCurrency: currency }),
+  setPaidAmount: (amountMinor) => set({ paidAmountMinor: amountMinor }),
   clearPayment: () => set({
     paymentIntentId: null,
     paymentStatus: null,
     selectedCurrency: 'ETB',
+    paidAmountMinor: null,
   }),
 }));
diff --git a/apps/edr-passenger-web/portal/src/middleware.ts b/apps/edr-passenger-web/portal/src/middleware.ts
new file mode 100644
index 000000000..c7960a601
--- /dev/null
+++ b/apps/edr-passenger-web/portal/src/middleware.ts
@@ -0,0 +1,119 @@
+import { NextRequest, NextResponse } from 'next/server';
+
+// Routes that should NOT redirect to home on hard refresh
+const PRESERVED_ROUTES = [
+  '/booking/',
+  '/login',
+  '/register',
+  '/forgot-password',
+  '/reset-password',
+  '/set-password',
+  '/verify-account',
+  '/fayda-setup',
+  '/profile',
+  '/about',
+  '/contact',
+  '/help',
+  '/guide',
+  '/services',
+  '/go/',
+];
+
+/**
+ * Build the Content-Security-Policy for a single request.
+ *
+ * Production uses a strict, nonce-based policy with `strict-dynamic`: only scripts
+ * carrying this request's nonce (and scripts they load) may execute, which neutralises
+ * reflected/stored XSS regardless of any host allowlist. Next.js applies the nonce to
+ * its own bootstrap/chunk scripts automatically because middleware forwards it on the
+ * request `Content-Security-Policy` header (see below); our own inline scripts read it
+ * from the `x-nonce` request header in the root layout.
+ *
+ * Development relaxes `script-src` (Next.js HMR/react-refresh needs `unsafe-eval` and
+ * inline) and allows the HMR websocket, and drops `upgrade-insecure-requests` so
+ * plain-HTTP localhost keeps working.
+ */
+function buildCsp(nonce: string): string {
+  const isProd = process.env.NODE_ENV === 'production';
+
+  // Origin the browser calls for API/XHR/fetch — must be allowed in connect-src.
+  let apiOrigin = '';
+  try {
+    apiOrigin = new URL(process.env.NEXT_PUBLIC_API_URL ?? 'http://localhost:4000').origin;
+  } catch {
+    apiOrigin = '';
+  }
+
+  const scriptSrc = isProd
+    ? `'self' 'nonce-${nonce}' 'strict-dynamic'`
+    : `'self' 'unsafe-inline' 'unsafe-eval'`;
+
+  const connectSrc = isProd
+    ? `'self' ${apiOrigin}`.trim()
+    : `'self' ${apiOrigin} ws: wss:`.trim();
+
+  const directives = [
+    `default-src 'self'`,
+    `base-uri 'self'`,
+    `script-src ${scriptSrc}`,
+    // Inline styles (Tailwind runtime + React `style=` attributes) can't execute JS;
+    // nonce-ing them reliably breaks Next/React, so 'unsafe-inline' is the accepted stance.
+    `style-src 'self' 'unsafe-inline'`,
+    `img-src 'self' data: blob: ${apiOrigin}`.trim(),
+    `font-src 'self' data:`,
+    `connect-src ${connectSrc}`,
+    `worker-src 'self' blob:`,
+    `frame-src 'self'`,
+    `object-src 'none'`,
+    `form-action 'self'`,
+    `frame-ancestors 'none'`,
+    ...(isProd ? ['upgrade-insecure-requests'] : []),
+  ];
+
+  return directives.join('; ');
+}
+
+export function middleware(request: NextRequest) {
+  const nonce = btoa(crypto.randomUUID());
+  const csp = buildCsp(nonce);
+
+  // Forward the nonce + CSP on the *request* so Next.js nonces its own scripts and our
+  // layout can read `x-nonce`. The browser-enforced copy is set on the response below.
+  const requestHeaders = new Headers(request.headers);
+  requestHeaders.set('x-nonce', nonce);
+  requestHeaders.set('Content-Security-Policy', csp);
+
+  const render = () => NextResponse.next({ request: { headers: requestHeaders } });
+
+  const { pathname } = request.nextUrl;
+  const isHardRefresh = !request.headers.get('referer');
+
+  let response: NextResponse;
+  if (
+    pathname.startsWith('/_next') ||
+    pathname.startsWith('/api') ||
+    pathname.includes('.') ||
+    pathname === '/'
+  ) {
+    // Next.js internals, static files, API routes, and home: no redirect, just render.
+    response = render();
+  } else if (PRESERVED_ROUTES.some((r) => pathname.startsWith(r))) {
+    // On hard refresh of a preserved route, let it through.
+    response = render();
+  } else if (isHardRefresh && pathname.startsWith('/packages')) {
+    // On hard refresh of package detail or packages list, redirect to home.
+    response = NextResponse.redirect(new URL('/', request.url));
+  } else {
+    response = render();
+  }
+
+  response.headers.set('Content-Security-Policy', csp);
+  // Anti-clickjacking. `frame-ancestors 'none'` (in the CSP above) is the modern control;
+  // X-Frame-Options: DENY is the legacy equivalent for older browsers and scanners.
+  response.headers.set('X-Frame-Options', 'DENY');
+  return response;
+}
+
+export const config = {
+  matcher: ['/((?!_next/static|_next/image|favicon.ico).*)'],
+};
diff --git a/apps/edr-passenger-web/portal/src/types/index.ts b/apps/edr-passenger-web/portal/src/types/index.ts
index 1baabfd3b..d1a906cbb 100644
--- a/apps/edr-passenger-web/portal/src/types/index.ts
+++ b/apps/edr-passenger-web/portal/src/types/index.ts
@@ -28,6 +28,8 @@ export interface Schedule {
   };
   originStation?: Station; // For backward compatibility
   destinationStation?: Station; // For backward compatibility
+  originStationId?: string; // For backward compatibility
+  destinationStationId?: string; // For backward compatibility
   departureAt?: string; // API returns this
   arrivalAt?: string; // API returns this
   departureTime?: string; // For backward compatibility
@@ -41,6 +43,7 @@ export interface Schedule {
   faresByClass?: Array<{ seatClassName: string; baseFareMinor: number; displayCurrency?: string; displayAmountMinor?: number }>; // API returns this
   coachTypes?: Array<{
     coachId: string;
+    coachTypeId: string;
     coachTypeName: string;
     coachTypeCode: string;
     classes: Array<{
diff --git a/apps/edr-passenger-web/portal/src/utils/fare-utils.ts b/apps/edr-passenger-web/portal/src/utils/fare-utils.ts
index 0fe88dd41..22fdaff31 100644
--- a/apps/edr-passenger-web/portal/src/utils/fare-utils.ts
+++ b/apps/edr-passenger-web/portal/src/utils/fare-utils.ts
@@ -33,15 +33,15 @@ export function isChild(passenger: PassengerWithAge): boolean {
 }
 
 /**
- * Check if this child gets the free fare (first child in the list)
+ * Check if this child gets a free fare (1 free child per adult)
  */
 export function isFirstChild(passengers: PassengerWithAge[], currentIndex: number): boolean {
   const currentPassenger = passengers[currentIndex];
   if (!isChild(currentPassenger)) return false;
-  
-  // Count children before this passenger
+
+  const adultCount = passengers.filter(p => !isChild(p)).length;
   const childrenBefore = passengers.slice(0, currentIndex).filter(p => isChild(p));
-  return childrenBefore.length === 0;
+  return childrenBefore.length < adultCount;
 }
 
 /**
@@ -93,8 +93,8 @@ export function formatFare(amountMinor: number, currency: string = 'ETB'): strin
 export function getPricingSummary(passengers: PassengerWithAge[], baseFare: number) {
   const adults = passengers.filter(p => !isChild(p));
   const children = passengers.filter(p => isChild(p));
-  const freeChildren = Math.min(children.length, 1);
-  const paidChildren = Math.max(0, children.length - 1);
+  const freeChildren = Math.min(children.length, adults.length);
+  const paidChildren = Math.max(0, children.length - adults.length);
   
   return {
     adultCount: adults.length,
diff --git a/packages/types/src/freight/contracts.ts b/packages/types/src/freight/contracts.ts
index ef893e68f..829ae3217 100644
--- a/packages/types/src/freight/contracts.ts
+++ b/packages/types/src/freight/contracts.ts
@@ -132,6 +132,13 @@ export interface IContractCargoScope {
   /** "20ft" | "40ft"; null for bulk. */
   containerSize?: string | null;
   cargoTypeId?: string | null;
+  /** Bulk cargo type detail (name + unit), loaded on the contract detail. */
+  cargoType?: {
+    id: string;
+    code?: string | null;
+    cargoTypeName?: string | null;
+    unitOfMeasure?: string | null;
+  } | null;
   cargoFreeText?: string | null;
   /**
    * GENERAL contracts: total quantity bookable across all shipments on this line
@@ -258,6 +265,7 @@ export interface ClearanceT1State {
 
 /** Train link state for the booking tied to a customs clearance flow. */
 export interface ClearanceTrainState {
+  scheduleId: string | null;
   wagonAllocated: boolean;
   departedAt: string | null;
   arrivedAt: string | null;
@@ -298,31 +306,6 @@ export interface ClearanceSecondDuty {
   paid: boolean;
 }
 
-/** A customs booking riding a train schedule, as shown on the GL DJ schedules tab. */
-export interface DjClearanceScheduleBooking {
-  bookingId: string;
-  reference: string;
-  tradeDirection: string;
-  contractId: string | null;
-  gatepassGranted: boolean;
-  gatepassAt: string | null;
-}
-
-/** Train schedule row for the GL Djibouti gate-pass table. */
-export interface DjClearanceSchedule {
-  id: string;
-  trainNumber: string | null;
-  routeName: string | null;
-  origin: string | null;
-  destination: string | null;
-  status: string;
-  scheduledDepartureDate: string | null;
-  actualDepartureAt: string | null;
-  actualArrivalAt: string | null;
-  freightType: string | null;
-  customsBookings: DjClearanceScheduleBooking[];
-}
-
 export interface ContractClearanceView {
   contractId: string;
   /** Overall contract status (e.g. CLEARANCE_UNDER_REVIEW). */
@@ -356,6 +339,9 @@ export interface ContractClearanceView {
   /** Export post-booking clearance finalized after transit permit upload. */
   exportClearanceFinalized?: boolean;
   linkedBookingId?: string | null;
+  /** Reference + status of the GL-created shipment booking, once it exists. */
+  linkedBookingReference?: string | null;
+  linkedBookingStatus?: string | null;
   dutyAdvice?: {
     amount: number;
     currency: string;
@@ -577,6 +563,12 @@ export interface IContract extends BaseEntity {
   status: ContractStatus;
   clearanceStatus: ContractClearanceStatus;
   clearanceCycleNumber: number;
+  /**
+   * Latest clearance cycle's current phase (list responses only). Lets list
+   * consumers show step-accurate customer actions without fetching the full
+   * clearance view per contract.
+   */
+  clearancePhase?: ContractDocPhase | string | null;
 
   pricingBreakdown?: ContractPricingBreakdown | null;
   pricingDisplayMode?: "UNIT_RATES";
diff --git a/packages/types/src/freight/etrade.ts b/packages/types/src/freight/etrade.ts
index 9067569fb..c125b75c5 100644
--- a/packages/types/src/freight/etrade.ts
+++ b/packages/types/src/freight/etrade.ts
@@ -76,4 +76,6 @@ export interface CompanyRegistrationData {
   managerName: string;
   managerEmail?: string;
   managerPhone: string;
+  /** True when this TIN is already registered to an existing company. */
+  tinTaken?: boolean;
 }
diff --git a/packages/types/src/freight/index.ts b/packages/types/src/freight/index.ts
index 261f22d0b..698266f67 100644
--- a/packages/types/src/freight/index.ts
+++ b/packages/types/src/freight/index.ts
@@ -198,6 +198,11 @@ export enum TrainSetWagonStatus {
   Departed = "DEPARTED",
 }
 
+export enum LoadingStatus {
+  Loaded = "LOADED",
+  Unloaded = "UNLOADED",
+}
+
 export enum WagonStatus {
   Available = "AVAILABLE",
   Assigned = "ASSIGNED",
@@ -378,6 +383,32 @@ export interface IYard extends BaseEntity {
   displayOrder: number;
 }
 
+/** One container number loaded onto a customer self-haul truck. */
+export interface ICustomerTruckContainer {
+  id: string;
+  containerNumber: string;
+}
+
+/** A customer self-haul truck on a booking, carrying 1–2 containers. */
+export interface ICustomerTruck {
+  id: string;
+  bookingId: string;
+  plateNumber: string;
+  driverName: string;
+  truckType: string;
+  assignedAt: string;
+  arrivedAt?: string | null;
+  containers?: ICustomerTruckContainer[];
+}
+
+/** Payload to add a customer self-haul truck (1–2 container numbers). */
+export interface AddCustomerTruckPayload {
+  truckPlateNumber: string;
+  driverName: string;
+  truckType: string;
+  containerNumbers: string[];
+}
+
 export interface IBooking extends BaseEntity {
   reference: string;
   customerId: string;
@@ -429,6 +460,8 @@ export interface IBooking extends BaseEntity {
   customerTruckArrivedAt?: string | null;
 
   customsClearingEnabled?: boolean;
+  // (multi-truck self-haul lives in ICustomerTruck[], fetched via the
+  //  /customer-trucks endpoint; the fields above are the booking-level flag.)
   customsClearingAgent?: string | null;
 
   equipmentReturn: "WITH_RETURN" | "WITHOUT_RETURN";
@@ -461,6 +494,10 @@ export interface IBooking extends BaseEntity {
 
   containers?: Array<{ type: string; qty: number; vgm: number }> | null;
 
+  /** Physical container numbers on this booking (from booking container units),
+   *  surfaced for the customer truck-assignment container picker. */
+  containerNumbers?: string[] | null;
+
   versionNumber: number;
   priorityScore: number;
 
diff --git a/packages/ui-common/src/components/CountdownTimer/CountdownTimer.tsx b/packages/ui-common/src/components/CountdownTimer/CountdownTimer.tsx
new file mode 100644
index 000000000..faadb0adf
--- /dev/null
+++ b/packages/ui-common/src/components/CountdownTimer/CountdownTimer.tsx
@@ -0,0 +1,87 @@
+import { Group, Text } from "@mantine/core";
+import { Clock } from "lucide-react";
+import { useEffect, useState } from "react";
+
+export interface CountdownTimerProps {
+  /** ISO timestamp the countdown targets. */
+  deadline: string | null | undefined;
+  /** Optional label shown before the time (e.g. "Window closes in"). */
+  label?: string;
+  /** Text shown once the deadline has passed. */
+  expiredText?: string;
+  /** Visual size of the time text. */
+  size?: "xs" | "sm" | "md" | "lg";
+  /** Colour once under this many seconds remain (urgency). Default 300 (5 min). */
+  urgentUnderSeconds?: number;
+}
+
+function pad(n: number): string {
+  return String(n).padStart(2, "0");
+}
+
+/** Break a remaining-milliseconds figure into a human string. */
+function formatRemaining(ms: number): string {
+  const total = Math.floor(ms / 1000);
+  const days = Math.floor(total / 86400);
+  const hours = Math.floor((total % 86400) / 3600);
+  const minutes = Math.floor((total % 3600) / 60);
+  const seconds = total % 60;
+
+  if (days > 0) return `${days}d ${pad(hours)}h ${pad(minutes)}m`;
+  if (hours > 0) return `${hours}h ${pad(minutes)}m ${pad(seconds)}s`;
+  return `${pad(minutes)}m ${pad(seconds)}s`;
+}
+
+/**
+ * Live countdown to an ISO deadline. Ticks once a second, shows the remaining
+ * time (d/h/m/s), turns red when under `urgentUnderSeconds`, and shows
+ * `expiredText` once the deadline is in the past. Display only — enforcement
+ * lives server-side.
+ */
+export function CountdownTimer({
+  deadline,
+  label,
+  expiredText = "Expired",
+  size = "sm",
+  urgentUnderSeconds = 300,
+}: CountdownTimerProps) {
+  const [remaining, setRemaining] = useState<number | null>(() =>
+    deadline ? new Date(deadline).getTime() - Date.now() : null,
+  );
+
+  useEffect(() => {
+    if (!deadline) {
+      setRemaining(null);
+      return;
+    }
+    const target = new Date(deadline).getTime();
+    const tick = () => setRemaining(target - Date.now());
+    tick();
+    const id = setInterval(tick, 1000);
+    return () => clearInterval(id);
+  }, [deadline]);
+
+  if (!deadline || remaining == null || Number.isNaN(remaining)) {
+    return null;
+  }
+
+  const expired = remaining <= 0;
+  const urgent = !expired && remaining <= urgentUnderSeconds * 1000;
+  const color = expired ? "red.7" : urgent ? "orange.7" : "dimmed";
+
+  return (
+    <Group gap={6} align="center" wrap="nowrap">
+      <Clock size={size === "lg" ? 18 : 14} />
+      {label && (
+        <Text size={size} c="dimmed">
+          {label}
+        </Text>
+      )}
+      <Text size={size} fw={600} c={color}>
+        {expired ? expiredText : formatRemaining(remaining)}
+      </Text>
+    </Group>
+  );
+}
+
+export default CountdownTimer;
diff --git a/packages/ui-common/src/components/CountdownTimer/index.ts b/packages/ui-common/src/components/CountdownTimer/index.ts
new file mode 100644
index 000000000..d1f61e322
--- /dev/null
+++ b/packages/ui-common/src/components/CountdownTimer/index.ts
@@ -0,0 +1,2 @@
+export { CountdownTimer, default } from "./CountdownTimer";
+export type { CountdownTimerProps } from "./CountdownTimer";
diff --git a/packages/ui-common/src/components/SmartFileInput/index.tsx b/packages/ui-common/src/components/SmartFileInput/index.tsx
index 0da3e2f37..1e1eaf223 100644
--- a/packages/ui-common/src/components/SmartFileInput/index.tsx
+++ b/packages/ui-common/src/components/SmartFileInput/index.tsx
@@ -153,6 +153,76 @@ function ExistingFileLink({
   );
 }
 
+/**
+ * A file the user just picked (in memory, not yet persisted). Rendered with a
+ * subtle "just added" entrance + an emerald accent so a fresh upload reads as
+ * distinct from the neutral surrounding surface.
+ */
+function NewFileCard({
+  file: fileObj,
+  onRemove,
+  disabled,
+  hasError,
+  inputName,
+}: {
+  file: File;
+  onRemove: () => void;
+  disabled?: boolean;
+  hasError?: boolean;
+  inputName: string;
+}) {
+  return (
+    <div
+      className={cn(
+        "relative z-10 flex items-center justify-between gap-3 rounded-lg border bg-card p-3 shadow-2xs transition",
+        "animate-in fade-in slide-in-from-top-1 duration-300 hover:shadow-xs",
+        hasError
+          ? "border-destructive/30"
+          : "border-emerald-300/60 dark:border-emerald-500/25",
+      )}
+    >
+      <div className="flex min-w-0 items-center gap-3">
+        <div className="flex items-center justify-center rounded-md bg-muted p-2">
+          <FileIcon name={fileObj.name} className="h-5 w-5" />
+        </div>
+
+        <div className="min-w-0">
+          <p
+            className="truncate max-w-[200px] text-sm font-medium text-foreground md:max-w-md"
+            title={fileObj.name}
+          >
+            {fileObj.name}
+          </p>
+          <div className="mt-0.5 flex items-center gap-2">
+            <span className="text-xs text-muted-foreground">
+              {formatBytes(fileObj.size)}
+            </span>
+            <span className="flex items-center gap-0.5 text-xs font-medium text-emerald-600 dark:text-emerald-400">
+              <CheckCircle2 className="h-3 w-3" /> Ready to upload
+            </span>
+          </div>
+        </div>
+      </div>
+
+      <button
+        type="button"
+        disabled={disabled}
+        onClick={onRemove}
+        className={cn(
+          "relative z-10 rounded-md p-1.5 text-muted-foreground transition-colors hover:bg-destructive/10 hover:text-destructive",
+          disabled && "pointer-events-none opacity-50",
+        )}
+        aria-label={`Remove file ${fileObj.name}`}
+      >
+        <Trash2 className="h-4 w-4" />
+      </button>
+
+      {/* Hidden input to represent file details in traditional form submissions */}
+      <input type="hidden" name={inputName} value={fileObj.name} />
+    </div>
+  );
+}
+
 export function SmartFileInput({
   file,
   value,
@@ -407,228 +477,352 @@ export function SmartFileInput({
                 </p>
               )}
 
-              {/* Selected Files List */}
-              {currentFiles.length > 0 && (
-                <div className="flex flex-col gap-2">
-                  {currentFiles.map((fileObj, idx) => (
-                    <div
-                      key={`${fileObj.name}-${idx}`}
-                      className={cn(
-                        "flex items-center justify-between p-3 rounded-lg border bg-card transition shadow-2xs hover:shadow-xs",
-                        fieldError ? "border-destructive/30" : "border-border",
-                      )}
-                    >
-                      <div className="flex items-center gap-3 min-w-0">
-                        <div className="p-2 bg-muted rounded-md flex items-center justify-center">
-                          <FileIcon name={fileObj.name} className="h-5 w-5" />
-                        </div>
-
-                        <div className="min-w-0">
-                          <p
-                            className="text-sm font-medium text-foreground truncate max-w-[200px] md:max-w-md"
-                            title={fileObj.name}
-                          >
-                            {fileObj.name}
-                          </p>
-                          <div className="flex items-center gap-2 mt-0.5">
-                            <span className="text-xs text-muted-foreground">
-                              {formatBytes(fileObj.size)}
-                            </span>
-                            <span className="flex items-center gap-0.5 text-xs text-primary font-medium">
-                              <CheckCircle2 className="h-3 w-3" /> Ready
-                            </span>
-                          </div>
-                        </div>
-                      </div>
-
-                      <button
-                        type="button"
-                        disabled={disabled}
-                        onClick={() => removeFile(field.fileKey, idx)}
-                        className={cn(
-                          "p-1.5 rounded-md text-muted-foreground hover:text-destructive hover:bg-destructive/10 transition-colors",
-                          disabled && "opacity-50 pointer-events-none",
-                        )}
-                        aria-label={`Remove file ${fileObj.name}`}
-                      >
-                        <Trash2 className="h-4 w-4" />
-                      </button>
-
-                      {/* Hidden inputs to represent file details in traditional form submissions */}
-                      <input
-                        type="hidden"
-                        name={
-                          field.isMultiple
-                            ? `${field.fileKey}[]`
-                            : field.fileKey
-                        }
-                        value={fileObj.name}
-                      />
-                    </div>
-                  ))}
-                </div>
-              )}
-
-              {/* Dropzone area */}
-              {!reachedLimit &&
-                (variant === "minimal" ? (
-                  <div className="flex flex-wrap items-center gap-3">
-                    <Button
-                      type="button"
-                      variant="outline"
-                      size="sm"
-                      disabled={disabled}
-                      onClick={() =>
-                        fileInputRefs.current[field.fileKey]?.click()
-                      }
-                      className="gap-1.5 cursor-pointer"
-                    >
-                      <UploadCloud className="h-4 w-4 text-muted-foreground" />
-                      <span>{isUploaded ? "Replace File" : "Upload File"}</span>
-                    </Button>
+              {/*
+                Multiple-file fields (default variant) render as ONE integrated
+                drag-and-drop surface. Uploaded files live INSIDE the dropzone as
+                lightweight rows — part of the surface, not separate cards — with
+                the "add more" prompt on the same surface below them. A full-cover
+                transparent input makes clicking anywhere (outside a file row)
+                open the picker; the prompt is pointer-transparent so clicks fall
+                through to it, while file rows and their controls sit above it.
+              */}
+              {variant === "default" && field.isMultiple ? (
+                <div
+                  onDragOver={(e) => handleDrag(e, field.fileKey, true)}
+                  onDragLeave={(e) => handleDrag(e, field.fileKey, false)}
+                  onDrop={(e) => handleDrop(e, field)}
+                  className={cn(
+                    "relative flex flex-col gap-2.5 rounded-xl border-2 border-dashed p-4 transition-all",
+                    isDragOver
+                      ? "border-primary bg-primary/5 dark:bg-primary/10"
+                      : fieldError
+                        ? "border-destructive/70"
+                        : "border-border bg-card/40 hover:border-primary/40",
+                    disabled && "pointer-events-none opacity-50",
+                  )}
+                >
+                  {/* Click anywhere on the surface (except a file row) to browse */}
+                  {!reachedLimit && (
                     <input
                       type="file"
-                      ref={(el) => {
-                        if (fileInputRefs.current) {
-                          fileInputRefs.current[field.fileKey] = el;
-                        }
-                      }}
-                      multiple={field.isMultiple}
+                      multiple
                       accept={acceptString}
                       disabled={disabled}
                       onChange={(e) => handleFileSelect(e, field)}
-                      className="hidden"
-                    />
-                    <span className="text-xs text-muted-foreground">
-                      Accepts:{" "}
-                      {field.allowedExtensions.join(", ").toUpperCase() ||
-                        "All"}
-                    </span>
-                    {existingForField.length > 0 && (
-                      <div className="flex flex-col gap-1 basis-full">
-                        {existingForField.map((f, idx) => (
-                          <ExistingFileLink
-                            key={`${f.url}-${idx}`}
-                            file={f}
-                            onViewFile={onViewFile}
-                          />
-                        ))}
-                      </div>
-                    )}
-                  </div>
-                ) : isUploaded ? (
-                  // Uploaded state: a solid success panel that still doubles as a
-                  // replace target (click anywhere or drag a new file onto it).
-                  <div
-                    onDragOver={(e) => handleDrag(e, field.fileKey, true)}
-                    onDragLeave={(e) => handleDrag(e, field.fileKey, false)}
-                    onDrop={(e) => handleDrop(e, field)}
-                    className={cn(
-                      "group relative flex items-center gap-4 rounded-lg border p-4 transition-all",
-                      isDragOver
-                        ? "border-2 border-dashed border-primary bg-primary/5 dark:bg-primary/10"
-                        : "border-emerald-300/70 bg-emerald-50/60 dark:border-emerald-500/30 dark:bg-emerald-500/10",
-                      disabled &&
-                        "opacity-50 pointer-events-none cursor-not-allowed",
-                    )}
-                  >
-                    <input
-                      type="file"
-                      multiple={field.isMultiple}
-                      accept={acceptString}
-                      disabled={disabled}
-                      onChange={(e) => handleFileSelect(e, field)}
-                      id={`file-input-${field.fileKey}`}
-                      className="absolute inset-0 w-full h-full opacity-0 cursor-pointer disabled:cursor-not-allowed"
-                      aria-label={`Replace ${field.fileLabel}`}
+                      className="absolute inset-0 z-0 h-full w-full cursor-pointer opacity-0 disabled:cursor-not-allowed"
+                      aria-label={`Add files to ${field.fileLabel}`}
                     />
+                  )}
 
-                    <div className="flex h-10 w-10 shrink-0 items-center justify-center rounded-full bg-emerald-100 text-emerald-600 dark:bg-emerald-500/20 dark:text-emerald-400">
-                      {isDragOver ? (
-                        <UploadCloud className="h-5 w-5 animate-bounce" />
-                      ) : (
-                        <CheckCircle2 className="h-5 w-5" />
-                      )}
-                    </div>
-
-                    <div className="min-w-0 flex-1">
-                      <p className="text-sm font-semibold text-foreground">
-                        {isDragOver ? "Drop to replace" : "Document uploaded"}
-                      </p>
-                      {existingForField.length > 0 ? (
-                        <div className="mt-0.5 flex flex-col gap-0.5">
-                          {existingForField.map((f, idx) => (
+                  {(existingForField.length > 0 || currentFiles.length > 0) && (
+                    <div className="relative z-10 flex flex-col gap-1.5">
+                      {/* Already-saved (server) files — view/download only */}
+                      {existingForField.map((f, idx) => (
+                        <div
+                          key={`${f.url}-${idx}`}
+                          className="flex items-center gap-2.5 rounded-lg bg-background/70 px-3 py-2 ring-1 ring-inset ring-border/60"
+                        >
+                          <FileIcon name={f.name} className="h-4 w-4 shrink-0" />
+                          <div className="min-w-0 flex-1">
                             <ExistingFileLink
-                              key={`${f.url}-${idx}`}
                               file={f}
                               onViewFile={onViewFile}
+                              className="max-w-none font-medium text-foreground hover:text-primary"
                               showSize
                             />
-                          ))}
+                          </div>
+                          <span className="shrink-0 text-[11px] text-muted-foreground">
+                            Saved
+                          </span>
                         </div>
-                      ) : (
-                        <p className="mt-0.5 text-xs text-muted-foreground">
-                          {isDragOver
-                            ? "Release to replace the document on file."
-                            : "Saved to your application. Drag a new file here or click to replace it."}
-                        </p>
+                      ))}
+
+                      {/* Just-added (in-memory) files */}
+                      {currentFiles.map((fileObj, idx) => (
+                        <div
+                          key={`${fileObj.name}-${idx}`}
+                          className="flex items-center gap-2.5 rounded-lg bg-background/70 px-3 py-2 ring-1 ring-inset ring-emerald-300/50 dark:ring-emerald-500/25 animate-in fade-in slide-in-from-top-1 duration-300"
+                        >
+                          <FileIcon
+                            name={fileObj.name}
+                            className="h-4 w-4 shrink-0"
+                          />
+                          <div className="min-w-0 flex-1">
+                            <p
+                              className="truncate text-xs font-medium text-foreground"
+                              title={fileObj.name}
+                            >
+                              {fileObj.name}
+                            </p>
+                            <p className="text-[11px] text-muted-foreground">
+                              {formatBytes(fileObj.size)}
+                            </p>
+                          </div>
+                          <span className="flex shrink-0 items-center gap-0.5 text-[11px] font-medium text-emerald-600 dark:text-emerald-400">
+                            <CheckCircle2 className="h-3 w-3" /> Ready
+                          </span>
+                          <button
+                            type="button"
+                            disabled={disabled}
+                            onClick={() => removeFile(field.fileKey, idx)}
+                            className={cn(
+                              "rounded-md p-1 text-muted-foreground transition-colors hover:bg-destructive/10 hover:text-destructive",
+                              disabled && "pointer-events-none opacity-50",
+                            )}
+                            aria-label={`Remove file ${fileObj.name}`}
+                          >
+                            <Trash2 className="h-3.5 w-3.5" />
+                          </button>
+                          <input
+                            type="hidden"
+                            name={`${field.fileKey}[]`}
+                            value={fileObj.name}
+                          />
+                        </div>
+                      ))}
+                    </div>
+                  )}
+
+                  {reachedLimit ? (
+                    <div className="relative z-10 flex items-center justify-center gap-1.5 py-2 text-xs font-medium text-muted-foreground">
+                      <CheckCircle2 className="h-3.5 w-3.5 text-emerald-500" />
+                      Maximum of {maxFiles} files reached
+                    </div>
+                  ) : (
+                    <div
+                      className={cn(
+                        "pointer-events-none relative z-10 flex flex-col items-center justify-center gap-1 text-center",
+                        existingForField.length > 0 || currentFiles.length > 0
+                          ? "py-1"
+                          : "py-6",
                       )}
-                    </div>
-
-                    <span className="hidden shrink-0 items-center gap-1.5 rounded-md border border-border bg-card px-3 py-1.5 text-xs font-medium text-foreground shadow-2xs transition group-hover:border-primary/50 group-hover:text-primary sm:inline-flex">
-                      <UploadCloud className="h-3.5 w-3.5" />
-                      Replace
-                    </span>
-                  </div>
-                ) : (
-                  <div
-                    onDragOver={(e) => handleDrag(e, field.fileKey, true)}
-                    onDragLeave={(e) => handleDrag(e, field.fileKey, false)}
-                    onDrop={(e) => handleDrop(e, field)}
-                    className={cn(
-                      "relative border-2 border-dashed rounded-lg p-6 flex flex-col items-center justify-center text-center transition-all bg-card/50",
-                      isDragOver
-                        ? "border-primary bg-primary/5 dark:bg-primary/10"
-                        : "border-border hover:border-primary/50 hover:bg-muted/10",
-                      fieldError &&
-                        "border-destructive hover:border-destructive/80",
-                      disabled &&
-                        "opacity-50 pointer-events-none cursor-not-allowed",
-                    )}
-                  >
-                    <input
-                      type="file"
-                      multiple={field.isMultiple}
-                      accept={acceptString}
-                      disabled={disabled}
-                      onChange={(e) => handleFileSelect(e, field)}
-                      id={`file-input-${field.fileKey}`}
-                      className="absolute inset-0 w-full h-full opacity-0 cursor-pointer disabled:cursor-not-allowed"
-                    />
-
-                    <div className="p-3 bg-muted rounded-full mb-3 text-muted-foreground transition group-hover:scale-110">
-                      <UploadCloud
+                    >
+                      <div
                         className={cn(
-                          "h-6 w-6 text-muted-foreground",
-                          isDragOver && "text-primary animate-bounce",
+                          "rounded-full bg-muted text-muted-foreground",
+                          existingForField.length > 0 || currentFiles.length > 0
+                            ? "p-1.5"
+                            : "p-3",
                         )}
-                      />
+                      >
+                        <UploadCloud
+                          className={cn(
+                            existingForField.length > 0 ||
+                              currentFiles.length > 0
+                              ? "h-4 w-4"
+                              : "h-6 w-6",
+                            isDragOver && "animate-bounce text-primary",
+                          )}
+                        />
+                      </div>
+                      <p className="text-sm font-semibold text-foreground">
+                        {isDragOver
+                          ? "Drop your files here"
+                          : existingForField.length > 0 ||
+                              currentFiles.length > 0
+                            ? "Add more files, or "
+                            : "Drag & drop your files here, or "}
+                        {!isDragOver && (
+                          <span className="text-primary font-bold">browse</span>
+                        )}
+                      </p>
+                      <p className="text-xs text-muted-foreground">
+                        {field.allowedExtensions.join(", ").toUpperCase() ||
+                          "All formats"}
+                        {" • "}
+                        {currentFiles.length}/{maxFiles} added
+                      </p>
                     </div>
+                  )}
+                </div>
+              ) : (
+                <>
+                  {/* Selected Files List */}
+                  {currentFiles.length > 0 && (
+                    <div className="flex flex-col gap-2">
+                      {currentFiles.map((fileObj, idx) => (
+                        <NewFileCard
+                          key={`${fileObj.name}-${idx}`}
+                          file={fileObj}
+                          disabled={disabled}
+                          hasError={!!fieldError}
+                          inputName={
+                            field.isMultiple
+                              ? `${field.fileKey}[]`
+                              : field.fileKey
+                          }
+                          onRemove={() => removeFile(field.fileKey, idx)}
+                        />
+                      ))}
+                    </div>
+                  )}
 
-                    <p className="text-sm font-semibold text-foreground">
-                      Drag & drop your file here, or{" "}
-                      <span className="text-primary font-bold hover:underline">
-                        browse
-                      </span>
-                    </p>
+                  {/* Dropzone area */}
+                  {!reachedLimit &&
+                    (variant === "minimal" ? (
+                      <div className="flex flex-wrap items-center gap-3">
+                        <Button
+                          type="button"
+                          variant="outline"
+                          size="sm"
+                          disabled={disabled}
+                          onClick={() =>
+                            fileInputRefs.current[field.fileKey]?.click()
+                          }
+                          className="gap-1.5 cursor-pointer"
+                        >
+                          <UploadCloud className="h-4 w-4 text-muted-foreground" />
+                          <span>
+                            {isUploaded ? "Replace File" : "Upload File"}
+                          </span>
+                        </Button>
+                        <input
+                          type="file"
+                          ref={(el) => {
+                            if (fileInputRefs.current) {
+                              fileInputRefs.current[field.fileKey] = el;
+                            }
+                          }}
+                          multiple={field.isMultiple}
+                          accept={acceptString}
+                          disabled={disabled}
+                          onChange={(e) => handleFileSelect(e, field)}
+                          className="hidden"
+                        />
+                        <span className="text-xs text-muted-foreground">
+                          Accepts:{" "}
+                          {field.allowedExtensions.join(", ").toUpperCase() ||
+                            "All"}
+                        </span>
+                        {existingForField.length > 0 && (
+                          <div className="flex flex-col gap-1 basis-full">
+                            {existingForField.map((f, idx) => (
+                              <ExistingFileLink
+                                key={`${f.url}-${idx}`}
+                                file={f}
+                                onViewFile={onViewFile}
+                              />
+                            ))}
+                          </div>
+                        )}
+                      </div>
+                    ) : isUploaded ? (
+                      // Uploaded state: a solid success panel that still doubles as a
+                      // replace target (click anywhere or drag a new file onto it).
+                      <div
+                        onDragOver={(e) => handleDrag(e, field.fileKey, true)}
+                        onDragLeave={(e) => handleDrag(e, field.fileKey, false)}
+                        onDrop={(e) => handleDrop(e, field)}
+                        className={cn(
+                          "group relative flex items-center gap-4 rounded-lg border p-4 transition-all",
+                          isDragOver
+                            ? "border-2 border-dashed border-primary bg-primary/5 dark:bg-primary/10"
+                            : "border-emerald-300/70 bg-emerald-50/60 dark:border-emerald-500/30 dark:bg-emerald-500/10",
+                          disabled &&
+                            "opacity-50 pointer-events-none cursor-not-allowed",
+                        )}
+                      >
+                        <input
+                          type="file"
+                          multiple={field.isMultiple}
+                          accept={acceptString}
+                          disabled={disabled}
+                          onChange={(e) => handleFileSelect(e, field)}
+                          id={`file-input-${field.fileKey}`}
+                          className="absolute inset-0 w-full h-full opacity-0 cursor-pointer disabled:cursor-not-allowed"
+                          aria-label={`Replace ${field.fileLabel}`}
+                        />
 
-                    <p className="text-xs text-muted-foreground mt-1">
-                      Supported formats:{" "}
-                      {field.allowedExtensions.join(", ").toUpperCase() ||
-                        "All"}
-                    </p>
-                  </div>
-                ))}
+                        <div className="flex h-10 w-10 shrink-0 items-center justify-center rounded-full bg-emerald-100 text-emerald-600 dark:bg-emerald-500/20 dark:text-emerald-400">
+                          {isDragOver ? (
+                            <UploadCloud className="h-5 w-5 animate-bounce" />
+                          ) : (
+                            <CheckCircle2 className="h-5 w-5" />
+                          )}
+                        </div>
+
+                        <div className="min-w-0 flex-1">
+                          <p className="text-sm font-semibold text-foreground">
+                            {isDragOver
+                              ? "Drop to replace"
+                              : "Document uploaded"}
+                          </p>
+                          {existingForField.length > 0 ? (
+                            <div className="mt-0.5 flex flex-col gap-0.5">
+                              {existingForField.map((f, idx) => (
+                                <ExistingFileLink
+                                  key={`${f.url}-${idx}`}
+                                  file={f}
+                                  onViewFile={onViewFile}
+                                  showSize
+                                />
+                              ))}
+                            </div>
+                          ) : (
+                            <p className="mt-0.5 text-xs text-muted-foreground">
+                              {isDragOver
+                                ? "Release to replace the document on file."
+                                : "Saved to your application. Drag a new file here or click to replace it."}
+                            </p>
+                          )}
+                        </div>
+
+                        <span className="hidden shrink-0 items-center gap-1.5 rounded-md border border-border bg-card px-3 py-1.5 text-xs font-medium text-foreground shadow-2xs transition group-hover:border-primary/50 group-hover:text-primary sm:inline-flex">
+                          <UploadCloud className="h-3.5 w-3.5" />
+                          Replace
+                        </span>
+                      </div>
+                    ) : (
+                      <div
+                        onDragOver={(e) => handleDrag(e, field.fileKey, true)}
+                        onDragLeave={(e) => handleDrag(e, field.fileKey, false)}
+                        onDrop={(e) => handleDrop(e, field)}
+                        className={cn(
+                          "relative border-2 border-dashed rounded-lg p-6 flex flex-col items-center justify-center text-center transition-all bg-card/50",
+                          isDragOver
+                            ? "border-primary bg-primary/5 dark:bg-primary/10"
+                            : "border-border hover:border-primary/50 hover:bg-muted/10",
+                          fieldError &&
+                            "border-destructive hover:border-destructive/80",
+                          disabled &&
+                            "opacity-50 pointer-events-none cursor-not-allowed",
+                        )}
+                      >
+                        <input
+                          type="file"
+                          multiple={field.isMultiple}
+                          accept={acceptString}
+                          disabled={disabled}
+                          onChange={(e) => handleFileSelect(e, field)}
+                          id={`file-input-${field.fileKey}`}
+                          className="absolute inset-0 w-full h-full opacity-0 cursor-pointer disabled:cursor-not-allowed"
+                        />
+
+                        <div className="p-3 bg-muted rounded-full mb-3 text-muted-foreground transition group-hover:scale-110">
+                          <UploadCloud
+                            className={cn(
+                              "h-6 w-6 text-muted-foreground",
+                              isDragOver && "text-primary animate-bounce",
+                            )}
+                          />
+                        </div>
+
+                        <p className="text-sm font-semibold text-foreground">
+                          Drag & drop your file here, or{" "}
+                          <span className="text-primary font-bold hover:underline">
+                            browse
+                          </span>
+                        </p>
+
+                        <p className="text-xs text-muted-foreground mt-1">
+                          Supported formats:{" "}
+                          {field.allowedExtensions.join(", ").toUpperCase() ||
+                            "All"}
+                        </p>
+                      </div>
+                    ))}
+                </>
+              )}
 
               {/* Validation Error Message */}
               {fieldError && (
diff --git a/packages/ui-common/src/index.ts b/packages/ui-common/src/index.ts
index 43c39d962..136e9e93b 100644
--- a/packages/ui-common/src/index.ts
+++ b/packages/ui-common/src/index.ts
@@ -25,6 +25,9 @@ export { useFileViewer } from "./hooks/useFileViewer";
 export { OperationDatePicker } from "./components/OperationDatePicker";
 export type { OperationDatePickerProps } from "./components/OperationDatePicker";
 
+export { CountdownTimer } from "./components/CountdownTimer";
+export type { CountdownTimerProps } from "./components/CountdownTimer";
+
 export { Badge } from "./components/badge";
 // export type { BadgeProps  } from "./components/badge";
 
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 9fcc8ce59..a610ea30a 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -117,6 +117,9 @@ importers:
       handlebars:
         specifier: ^4.7.9
         version: 4.7.9
+      jose:
+        specifier: ^5.10.0
+        version: 5.10.0
       libphonenumber-js:
         specifier: ^1.13.6
         version: 1.13.6