diff --git a/apps/edr-freight-api/.env.example b/apps/edr-freight-api/.env.example
index 2b3b855cb..6fdaab48b 100644
--- a/apps/edr-freight-api/.env.example
+++ b/apps/edr-freight-api/.env.example
@@ -1,5 +1,7 @@
 # Copy to .env for local/docker compose (not committed).
 PORT=3001
+# GT06 GPS tracker TCP listener port (raw TCP, must be reachable by tracker SIMs). 0 disables.
+GT06_TCP_PORT=5023
 DB_HOST=localhost
 DB_PORT=5433
 DB_USER=postgres
diff --git a/apps/edr-freight-api/Dockerfile b/apps/edr-freight-api/Dockerfile
index f9107ed23..d88029a80 100644
--- a/apps/edr-freight-api/Dockerfile
+++ b/apps/edr-freight-api/Dockerfile
@@ -40,4 +40,6 @@ RUN addgroup --system --gid 1001 nodejs \
 COPY --from=deployer --chown=nestjs:nodejs /deploy .
 USER nestjs
 EXPOSE 3001
+# GT06 GPS tracker TCP listener (raw TCP, not HTTP). Change via GT06_TCP_PORT.
+EXPOSE 5023
 CMD ["node", "dist/main.js"]
diff --git a/apps/edr-freight-api/package.json b/apps/edr-freight-api/package.json
index 457786cbe..636bb7e05 100644
--- a/apps/edr-freight-api/package.json
+++ b/apps/edr-freight-api/package.json
@@ -93,6 +93,7 @@
     "@types/supertest": "^6.0.2",
     "@types/vorpal": "^1.12.8",
     "jest": "^29.7.0",
+    "socket.io-client": "^4.8.3",
     "supertest": "^7.0.0",
     "ts-jest": "^29.2.5",
     "ts-loader": "^9.5.1",
diff --git a/apps/edr-freight-api/src/app.module.ts b/apps/edr-freight-api/src/app.module.ts
index d23d5bd2a..e10fb7e47 100644
--- a/apps/edr-freight-api/src/app.module.ts
+++ b/apps/edr-freight-api/src/app.module.ts
@@ -80,6 +80,10 @@ import { VehiclesModule } from "./modules/vehicles/vehicles.module";
 import { DriversModule } from "./modules/drivers/drivers.module";
 import { FuelModule } from "./modules/fuel/fuel.module";
 import { MaintenanceModule } from "./modules/maintenance/maintenance.module";
+import { ComplianceModule } from "./modules/compliance/compliance.module";
+import { IncidentsModule } from "./modules/incidents/incidents.module";
+import { ProcurementModule } from "./modules/procurement/procurement.module";
+import { GpsTrackingModule } from "./modules/gps-tracking/gps-tracking.module";
 import { FirstMileModule } from "./modules/first-mile/first-mile.module";
 import { LastMileModule } from "./modules/last-mile/last-mile.module";
 import { InterchangeDocumentsModule } from "./modules/interchange-documents/interchange-documents.module";
@@ -148,6 +152,10 @@ import { LoggerMiddleware } from "./logger.middleware";
     DriversModule,
     FuelModule,
     MaintenanceModule,
+    ComplianceModule,
+    IncidentsModule,
+    ProcurementModule,
+    GpsTrackingModule,
     FirstMileModule,
     LastMileModule,
     InterchangeDocumentsModule,
diff --git a/apps/edr-freight-api/src/migrations/1950000000000-AddVehicleCompliance.ts b/apps/edr-freight-api/src/migrations/1950000000000-AddVehicleCompliance.ts
new file mode 100644
index 000000000..f83f0a236
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/1950000000000-AddVehicleCompliance.ts
@@ -0,0 +1,59 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+/**
+ * Vehicle Compliance & Expiry Alerts.
+ * - Adds expiry-tracking columns to freight.vehicles.
+ * - Creates freight.compliance_records for per-document compliance tracking.
+ */
+export class AddVehicleCompliance1950000000000 implements MigrationInterface {
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    // Vehicle expiry / compliance columns.
+    await queryRunner.query(`
+      ALTER TABLE freight.vehicles
+        ADD COLUMN IF NOT EXISTS vin VARCHAR,
+        ADD COLUMN IF NOT EXISTS ownership VARCHAR,
+        ADD COLUMN IF NOT EXISTS insurance_expiry DATE,
+        ADD COLUMN IF NOT EXISTS registration_expiry DATE,
+        ADD COLUMN IF NOT EXISTS next_inspection_date DATE;
+    `);
+
+    // Compliance records table.
+    await queryRunner.query(`
+      CREATE TABLE IF NOT EXISTS freight.compliance_records (
+        id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+        vehicle_id UUID NOT NULL REFERENCES freight.vehicles(id),
+        type VARCHAR NOT NULL,
+        document_number VARCHAR,
+        issued_date DATE,
+        expiry_date DATE NOT NULL,
+        status VARCHAR NOT NULL DEFAULT 'VALID',
+        notes TEXT,
+        created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+        updated_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+        deleted_at TIMESTAMPTZ
+      );
+    `);
+
+    await queryRunner.query(
+      `CREATE INDEX IF NOT EXISTS idx_compliance_records_vehicle_id ON freight.compliance_records(vehicle_id);`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX IF NOT EXISTS idx_compliance_records_expiry_date ON freight.compliance_records(expiry_date);`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX IF NOT EXISTS idx_compliance_records_type ON freight.compliance_records(type);`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`DROP TABLE IF EXISTS freight.compliance_records CASCADE;`);
+    await queryRunner.query(`
+      ALTER TABLE freight.vehicles
+        DROP COLUMN IF EXISTS vin,
+        DROP COLUMN IF EXISTS ownership,
+        DROP COLUMN IF EXISTS insurance_expiry,
+        DROP COLUMN IF EXISTS registration_expiry,
+        DROP COLUMN IF EXISTS next_inspection_date;
+    `);
+  }
+}
diff --git a/apps/edr-freight-api/src/migrations/1960000000000-AddIncidents.ts b/apps/edr-freight-api/src/migrations/1960000000000-AddIncidents.ts
new file mode 100644
index 000000000..dbb2994c3
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/1960000000000-AddIncidents.ts
@@ -0,0 +1,46 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+/**
+ * Accident & Incident register for the fleet. Tracks accidents, breakdowns,
+ * traffic violations, thefts and other incidents against a vehicle, driver
+ * and/or booking, with severity, damage estimate, insurance claim tracking and
+ * a lifecycle status. Queried by driver_id for per-driver incident history.
+ */
+export class AddIncidents1960000000000 implements MigrationInterface {
+  name = 'AddIncidents1960000000000';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      CREATE TABLE IF NOT EXISTS freight.incidents (
+        id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+        created_at timestamptz NOT NULL DEFAULT now(),
+        updated_at timestamptz NOT NULL DEFAULT now(),
+        deleted_at timestamptz,
+        vehicle_id uuid,
+        driver_id uuid,
+        booking_id uuid,
+        type varchar NOT NULL,
+        severity varchar NOT NULL,
+        occurred_at timestamptz NOT NULL,
+        location varchar,
+        description text NOT NULL,
+        damage_estimate numeric(14,2),
+        status varchar NOT NULL DEFAULT 'REPORTED',
+        insurance_claim_number varchar,
+        reported_by varchar
+      )
+    `);
+    await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS "IDX_INCIDENTS_DRIVER"
+      ON freight.incidents (driver_id, occurred_at)
+    `);
+    await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS "IDX_INCIDENTS_VEHICLE"
+      ON freight.incidents (vehicle_id, occurred_at)
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`DROP TABLE IF EXISTS freight.incidents`);
+  }
+}
diff --git a/apps/edr-freight-api/src/migrations/1970000000000-AddMaintenanceDepth.ts b/apps/edr-freight-api/src/migrations/1970000000000-AddMaintenanceDepth.ts
new file mode 100644
index 000000000..87b52ceff
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/1970000000000-AddMaintenanceDepth.ts
@@ -0,0 +1,93 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class AddMaintenanceDepth1970000000000 implements MigrationInterface {
+  name = 'AddMaintenanceDepth1970000000000';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`CREATE SCHEMA IF NOT EXISTS freight`);
+
+    await queryRunner.query(`
+      CREATE TABLE IF NOT EXISTS freight.work_orders (
+        id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+        vehicle_id UUID NOT NULL,
+        title VARCHAR NOT NULL,
+        description TEXT,
+        status VARCHAR NOT NULL DEFAULT 'OPEN',
+        priority VARCHAR NOT NULL DEFAULT 'MEDIUM',
+        assigned_to VARCHAR,
+        opened_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+        closed_at TIMESTAMPTZ,
+        labor_cost NUMERIC(14, 2),
+        parts_cost NUMERIC(14, 2),
+        created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+        updated_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+        deleted_at TIMESTAMPTZ
+      );
+    `);
+
+    await queryRunner.query(`
+      CREATE TABLE IF NOT EXISTS freight.parts (
+        id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+        name VARCHAR NOT NULL,
+        sku VARCHAR,
+        category VARCHAR,
+        quantity_in_stock INT NOT NULL DEFAULT 0,
+        reorder_level INT NOT NULL DEFAULT 0,
+        unit_cost NUMERIC(14, 2),
+        location VARCHAR,
+        created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+        updated_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+        deleted_at TIMESTAMPTZ
+      );
+    `);
+
+    await queryRunner.query(`
+      CREATE TABLE IF NOT EXISTS freight.warranties (
+        id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+        vehicle_id UUID NOT NULL,
+        component VARCHAR NOT NULL,
+        provider VARCHAR,
+        start_date DATE,
+        expiry_date DATE NOT NULL,
+        coverage_notes TEXT,
+        created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+        updated_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+        deleted_at TIMESTAMPTZ
+      );
+    `);
+
+    await queryRunner.query(
+      `CREATE INDEX IF NOT EXISTS "IDX_work_orders_vehicle_id_status" ON freight.work_orders (vehicle_id, status)`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX IF NOT EXISTS "IDX_parts_category" ON freight.parts (category)`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX IF NOT EXISTS "IDX_warranties_vehicle_id_expiry_date" ON freight.warranties (vehicle_id, expiry_date)`,
+    );
+
+    await queryRunner.query(`
+      DO $$ BEGIN
+        ALTER TABLE freight.work_orders
+          ADD CONSTRAINT "FK_work_orders_vehicle_id"
+          FOREIGN KEY (vehicle_id) REFERENCES freight.vehicles(id) ON DELETE CASCADE;
+      EXCEPTION WHEN duplicate_object THEN NULL;
+      END $$;
+    `);
+
+    await queryRunner.query(`
+      DO $$ BEGIN
+        ALTER TABLE freight.warranties
+          ADD CONSTRAINT "FK_warranties_vehicle_id"
+          FOREIGN KEY (vehicle_id) REFERENCES freight.vehicles(id) ON DELETE CASCADE;
+      EXCEPTION WHEN duplicate_object THEN NULL;
+      END $$;
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`DROP TABLE IF EXISTS freight.warranties CASCADE`);
+    await queryRunner.query(`DROP TABLE IF EXISTS freight.parts CASCADE`);
+    await queryRunner.query(`DROP TABLE IF EXISTS freight.work_orders CASCADE`);
+  }
+}
diff --git a/apps/edr-freight-api/src/migrations/1980000000000-AddProcurement.ts b/apps/edr-freight-api/src/migrations/1980000000000-AddProcurement.ts
new file mode 100644
index 000000000..6d4304aaf
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/1980000000000-AddProcurement.ts
@@ -0,0 +1,73 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class AddProcurement1980000000000 implements MigrationInterface {
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      CREATE TABLE IF NOT EXISTS freight.vendors (
+        id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+        created_at timestamptz NOT NULL DEFAULT now(),
+        updated_at timestamptz NOT NULL DEFAULT now(),
+        deleted_at timestamptz,
+        name varchar NOT NULL,
+        type varchar,
+        contact_person varchar,
+        phone varchar,
+        email varchar,
+        address varchar,
+        is_active boolean NOT NULL DEFAULT true
+      );
+    `);
+
+    await queryRunner.query(`
+      CREATE TABLE IF NOT EXISTS freight.asset_acquisitions (
+        id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+        created_at timestamptz NOT NULL DEFAULT now(),
+        updated_at timestamptz NOT NULL DEFAULT now(),
+        deleted_at timestamptz,
+        vehicle_id uuid,
+        vendor_id uuid,
+        acquisition_type varchar NOT NULL,
+        acquisition_date date NOT NULL,
+        cost numeric(14,2),
+        useful_life_months integer,
+        salvage_value numeric(14,2),
+        lease_start date,
+        lease_end date,
+        monthly_payment numeric(14,2),
+        status varchar NOT NULL DEFAULT 'ACTIVE',
+        notes text
+      );
+    `);
+
+    await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS idx_asset_acquisitions_vehicle_date
+        ON freight.asset_acquisitions(vehicle_id, acquisition_date);
+    `);
+
+    await queryRunner.query(`
+      CREATE TABLE IF NOT EXISTS freight.asset_disposals (
+        id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+        created_at timestamptz NOT NULL DEFAULT now(),
+        updated_at timestamptz NOT NULL DEFAULT now(),
+        deleted_at timestamptz,
+        vehicle_id uuid NOT NULL,
+        disposal_date date NOT NULL,
+        method varchar NOT NULL,
+        sale_price numeric(14,2),
+        buyer varchar,
+        notes text
+      );
+    `);
+
+    await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS idx_asset_disposals_vehicle_date
+        ON freight.asset_disposals(vehicle_id, disposal_date);
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`DROP TABLE IF EXISTS freight.asset_disposals CASCADE;`);
+    await queryRunner.query(`DROP TABLE IF EXISTS freight.asset_acquisitions CASCADE;`);
+    await queryRunner.query(`DROP TABLE IF EXISTS freight.vendors CASCADE;`);
+  }
+}
diff --git a/apps/edr-freight-api/src/migrations/1990000000000-AddDoubleHandlingBasisAndMachinery.ts b/apps/edr-freight-api/src/migrations/1990000000000-AddDoubleHandlingBasisAndMachinery.ts
new file mode 100644
index 000000000..be4ed060a
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/1990000000000-AddDoubleHandlingBasisAndMachinery.ts
@@ -0,0 +1,25 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+/**
+ * Double-handling fee support. warehouse_fee_rules.basis: how a
+ * DOUBLE_HANDLING_FEE rule is charged — PER_CONTAINER | PER_TON | PER_ITEM
+ * (null for the day-based fee types). The PER_TON / PER_ITEM quantity comes from
+ * the booking's cargo total (cargo_total_weight_vgm, expressed in the cargo's
+ * unit of measure), so no new booking column is needed.
+ */
+export class AddDoubleHandlingBasisAndMachinery1990000000000 implements MigrationInterface {
+  name = 'AddDoubleHandlingBasisAndMachinery1990000000000';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE freight.warehouse_fee_rules ADD COLUMN IF NOT EXISTS basis varchar(20)`,
+    );
+    // machinery_units is not used (PER_ITEM reads cargo_total_weight_vgm); drop it
+    // if a prior version of this migration added it.
+    await queryRunner.query(`ALTER TABLE freight.bookings DROP COLUMN IF EXISTS machinery_units`);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`ALTER TABLE freight.warehouse_fee_rules DROP COLUMN IF EXISTS basis`);
+  }
+}
diff --git a/apps/edr-freight-api/src/migrations/1990000000000-AddVehiclePricePerKm.ts b/apps/edr-freight-api/src/migrations/1990000000000-AddVehiclePricePerKm.ts
new file mode 100644
index 000000000..7767cd796
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/1990000000000-AddVehiclePricePerKm.ts
@@ -0,0 +1,25 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+/**
+ * Per-km haulage rate on a vehicle (mainly trucks) plus the currency it's
+ * quoted in (ETB | USD, default ETB).
+ */
+export class AddVehiclePricePerKm1990000000000 implements MigrationInterface {
+  name = "AddVehiclePricePerKm1990000000000";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      ALTER TABLE freight.vehicles
+      ADD COLUMN IF NOT EXISTS price_per_km numeric(14,2),
+      ADD COLUMN IF NOT EXISTS currency varchar(8) NOT NULL DEFAULT 'ETB'
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      ALTER TABLE freight.vehicles
+      DROP COLUMN IF EXISTS price_per_km,
+      DROP COLUMN IF EXISTS currency
+    `);
+  }
+}
diff --git a/apps/edr-freight-api/src/migrations/2000000000000-AddGpsTracking.ts b/apps/edr-freight-api/src/migrations/2000000000000-AddGpsTracking.ts
new file mode 100644
index 000000000..3d440c678
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/2000000000000-AddGpsTracking.ts
@@ -0,0 +1,69 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+/**
+ * GPS tracking: physical trackers (gps_devices, one denormalized latest fix per
+ * device for the live map) + append-only fix history (gps_positions).
+ */
+export class AddGpsTracking2000000000000 implements MigrationInterface {
+  name = "AddGpsTracking2000000000000";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      CREATE TABLE IF NOT EXISTS freight.gps_devices (
+        id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+        imei varchar(20) NOT NULL UNIQUE,
+        name varchar,
+        vehicle_id uuid REFERENCES freight.vehicles(id),
+        status varchar(16) NOT NULL DEFAULT 'REGISTERED',
+        last_seen_at timestamptz,
+        last_lat numeric(10,6),
+        last_lng numeric(10,6),
+        last_speed numeric(6,2),
+        last_course int,
+        last_fix_at timestamptz,
+        voltage_level int,
+        gsm_level int,
+        created_at timestamptz NOT NULL DEFAULT now(),
+        updated_at timestamptz NOT NULL DEFAULT now(),
+        deleted_at timestamptz
+      )
+    `);
+    await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS "IDX_GPS_DEVICES_VEHICLE"
+      ON freight.gps_devices (vehicle_id)
+    `);
+
+    await queryRunner.query(`
+      CREATE TABLE IF NOT EXISTS freight.gps_positions (
+        id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+        device_id uuid NOT NULL,
+        imei varchar(20) NOT NULL,
+        vehicle_id uuid,
+        lat numeric(10,6) NOT NULL,
+        lng numeric(10,6) NOT NULL,
+        speed numeric(6,2) NOT NULL DEFAULT 0,
+        course int NOT NULL DEFAULT 0,
+        satellites int NOT NULL DEFAULT 0,
+        positioned boolean NOT NULL DEFAULT false,
+        gps_time timestamptz NOT NULL,
+        alarm int NOT NULL DEFAULT 0,
+        created_at timestamptz NOT NULL DEFAULT now(),
+        updated_at timestamptz NOT NULL DEFAULT now(),
+        deleted_at timestamptz
+      )
+    `);
+    await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS "IDX_GPS_POSITIONS_DEVICE_TIME"
+      ON freight.gps_positions (device_id, gps_time)
+    `);
+    await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS "IDX_GPS_POSITIONS_VEHICLE_TIME"
+      ON freight.gps_positions (vehicle_id, gps_time)
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`DROP TABLE IF EXISTS freight.gps_positions`);
+    await queryRunner.query(`DROP TABLE IF EXISTS freight.gps_devices`);
+  }
+}
diff --git a/apps/edr-freight-api/src/migrations/2000000000000-AddTruckDetentionTiming.ts b/apps/edr-freight-api/src/migrations/2000000000000-AddTruckDetentionTiming.ts
new file mode 100644
index 000000000..ce7bfd326
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/2000000000000-AddTruckDetentionTiming.ts
@@ -0,0 +1,32 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+/**
+ * Truck detention support.
+ *  - last_mile.arrived_at / delivered_at: the detention window for an EDR
+ *    last-mile vehicle. The clock runs from arrival at destination; the customer
+ *    has a grace period (default 3h) to clear/return, after which detention
+ *    accrues per truck per day until delivered_at (or now, if still out).
+ *  - warehouse_fee_rules.free_hours: configurable grace window (hours) for a
+ *    TRUCK_DETENTION_FEE rule; null/0 falls back to the 3-hour default.
+ */
+export class AddTruckDetentionTiming2000000000000 implements MigrationInterface {
+  name = 'AddTruckDetentionTiming2000000000000';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE freight.last_mile ADD COLUMN IF NOT EXISTS arrived_at timestamptz`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE freight.last_mile ADD COLUMN IF NOT EXISTS delivered_at timestamptz`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE freight.warehouse_fee_rules ADD COLUMN IF NOT EXISTS free_hours int`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`ALTER TABLE freight.warehouse_fee_rules DROP COLUMN IF EXISTS free_hours`);
+    await queryRunner.query(`ALTER TABLE freight.last_mile DROP COLUMN IF EXISTS delivered_at`);
+    await queryRunner.query(`ALTER TABLE freight.last_mile DROP COLUMN IF EXISTS arrived_at`);
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/backoffice/backoffice.service.ts b/apps/edr-freight-api/src/modules/backoffice/backoffice.service.ts
index 7c7805b28..d49cc304e 100644
--- a/apps/edr-freight-api/src/modules/backoffice/backoffice.service.ts
+++ b/apps/edr-freight-api/src/modules/backoffice/backoffice.service.ts
@@ -8,7 +8,11 @@ import { hashPassword } from "@tria-plc/api-common/utils/argon";
 import { EUserStatus } from "@tria-plc/api-common/utils/enums/user.enum";
 import { DataSource, EntityManager, In, IsNull, Repository } from "typeorm";
 
-import { Employee, Organization, UserCredential } from "@tria-plc/iamapi-common";
+// Subpath imports (not the package root) so ts-jest can resolve them when this
+// file lands in a spec's compile graph via the notification recipients chain.
+import { Employee } from "@tria-plc/iamapi-common/entities/iam/organization-structure/employee.entity";
+import { Organization } from "@tria-plc/iamapi-common/entities/iam/organization-structure/organization.entity";
+import { UserCredential } from "@tria-plc/iamapi-common/entities/iam/user/user-credential.entity";
 import { Role } from "@tria-plc/iamapi-common/entities/iam/user/role.entity";
 import { UserRole } from "@tria-plc/iamapi-common/entities/iam/user/user-role.entity";
 import { User } from "@tria-plc/iamapi-common/entities/iam/user/user.entity";
@@ -40,6 +44,21 @@ export class BackofficeService {
     private readonly dataSource: DataSource,
   ) {}
 
+  /**
+   * IAM user ids of every current employee across all organizations — used by
+   * the notification recipients resolver's `allBackoffice` selector.
+   */
+  async getAllCurrentEmployeeUserIds(): Promise<string[]> {
+    const employees = await this.employeeRepository.find({
+      where: { isCurrent: true },
+    });
+    return [
+      ...new Set(
+        employees.map((e) => e.userId).filter((id): id is string => Boolean(id)),
+      ),
+    ];
+  }
+
   async createOrganizationUser(
     organizationId: string,
     dto: CreateOrganizationUserDto,
diff --git a/apps/edr-freight-api/src/modules/billing/documents/styled-pdf.util.ts b/apps/edr-freight-api/src/modules/billing/documents/styled-pdf.util.ts
index 8eb90172e..b4f168e4e 100644
--- a/apps/edr-freight-api/src/modules/billing/documents/styled-pdf.util.ts
+++ b/apps/edr-freight-api/src/modules/billing/documents/styled-pdf.util.ts
@@ -121,6 +121,146 @@ export function sealOp(
   return ops.join("\n");
 }
 
+/** Hard-truncate to `max` chars (no marker — keeps dense table cells tight). */
+export function clipText(value: string, max: number): string {
+  const t = String(value ?? "");
+  return t.length > max ? t.slice(0, Math.max(1, max)) : t;
+}
+
+/** Strip HTML tags → plain text, decoding the basic entities the doc builders emit. */
+export function htmlToText(html: string): string {
+  return String(html ?? "")
+    .replace(/<br\s*\/?>/gi, " ")
+    .replace(/<[^>]+>/g, " ")
+    .replace(/&amp;/gi, "&")
+    .replace(/&lt;/gi, "<")
+    .replace(/&gt;/gi, ">")
+    .replace(/&quot;/gi, '"')
+    .replace(/&#39;/g, "'")
+    .replace(/&nbsp;/gi, " ")
+    .replace(/[^\x20-\x7e]/g, " ")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+/**
+ * Parse a "summary tiles + one <table> + notice + signature lines" document (the
+ * marshalling / load-list layout the train-scheduling builders emit) and draw it as a
+ * styled PDF grid. Used as the Chromium-less fallback so the manifest reads as a real
+ * document, not a flat text dump. Switches to landscape when the table is wide.
+ */
+export function buildTabularFallbackPdf(html: string): Buffer {
+  const pick = (re: RegExp) => html.match(re)?.[1];
+  const title = htmlToText(pick(/<h1[^>]*>([\s\S]*?)<\/h1>/i) ?? "Document");
+  const subtitle = htmlToText(pick(/class="subtitle"[^>]*>([\s\S]*?)<\/div>/i) ?? "");
+  const metaRef = htmlToText(pick(/class="meta"[\s\S]*?<strong>([\s\S]*?)<\/strong>/i) ?? "");
+  const generated = htmlToText(pick(/Generated:\s*([^<]+)/i) ?? "");
+
+  const tiles: Array<[string, string]> = [];
+  for (const m of html.matchAll(
+    /class="tile"[^>]*>\s*<span>([\s\S]*?)<\/span>\s*<strong>([\s\S]*?)<\/strong>/gi,
+  )) {
+    tiles.push([htmlToText(m[1]), htmlToText(m[2])]);
+  }
+
+  const thead = pick(/<thead>([\s\S]*?)<\/thead>/i) ?? "";
+  const headers = [...thead.matchAll(/<th[^>]*>([\s\S]*?)<\/th>/gi)].map((m) => htmlToText(m[1]));
+  const tbody = pick(/<tbody>([\s\S]*?)<\/tbody>/i) ?? "";
+  const rows: string[][] = [...tbody.matchAll(/<tr[^>]*>([\s\S]*?)<\/tr>/gi)].map((tr) =>
+    [...tr[1].matchAll(/<td[^>]*>([\s\S]*?)<\/td>/gi)].map((td) => htmlToText(td[1])),
+  );
+  const notice = htmlToText(pick(/class="notice"[^>]*>([\s\S]*?)<\/div>/i) ?? "");
+  const parsedSigs = [...html.matchAll(/class="line"[^>]*>([\s\S]*?)<\/div>/gi)]
+    .map((m) => htmlToText(m[1]))
+    .filter(Boolean);
+  const signatures = parsedSigs.length ? parsedSigs : ["Prepared / date", "Check / date", "Authorization / date"];
+
+  const landscape = headers.length > 7;
+  const page = landscape ? PageSize.landscape : PageSize.portrait;
+  const M = 32;
+  const contentW = page.width - M * 2;
+  const right = page.width - M;
+  const ops: string[] = [];
+
+  // Header
+  ops.push(lineOp(M, page.height - 28, right, page.height - 28, PdfColor.teal, 2.4));
+  ops.push(textOp("ETHIO-DJIBOUTI RAILWAY S.C.", M, page.height - 44, 8.5, "F2", PdfColor.gray));
+  ops.push(textOp(clipText(title, landscape ? 82 : 52), M, page.height - 68, 19, "F2", PdfColor.dark));
+  if (subtitle) ops.push(textOp(clipText(subtitle, 96), M, page.height - 82, 9, "F1", PdfColor.gray));
+  if (metaRef) {
+    ops.push(textOpRight("TRAIN / SCHEDULE", right, page.height - 42, 7.5, "F2", PdfColor.gray));
+    ops.push(textOpRight(clipText(metaRef, 28), right, page.height - 58, 12, "F2", PdfColor.dark));
+  }
+  if (generated) {
+    ops.push(textOpRight(clipText(`Generated ${generated}`, 40), right, page.height - 72, 8, "F1", PdfColor.gray));
+  }
+  ops.push(lineOp(M, page.height - 92, right, page.height - 92, PdfColor.line, 1));
+
+  // Summary tiles
+  let y = page.height - 100;
+  if (tiles.length) {
+    const cols = landscape ? 6 : 4;
+    const tileW = contentW / cols;
+    const tileH = 32;
+    tiles.forEach(([label, value], i) => {
+      const col = i % cols;
+      if (col === 0 && i > 0) y -= tileH;
+      const x = M + col * tileW;
+      ops.push(rectOp(x, y - tileH + 4, tileW - 4, tileH - 4, PdfColor.shade, PdfColor.line, 0.5));
+      ops.push(textOp(clipText(label.toUpperCase(), Math.floor((tileW - 12) / 3.6)), x + 6, y - 8, 6.5, "F1", PdfColor.gray));
+      ops.push(textOp(clipText(value, Math.floor((tileW - 12) / 4.4)), x + 6, y - 20, 9, "F2", PdfColor.dark));
+    });
+    y -= tileH + 12;
+  }
+
+  // Table
+  if (headers.length) {
+    const colW = contentW / headers.length;
+    const headerH = 16;
+    const rowH = 14;
+    const cellChars = Math.max(4, Math.floor(colW / 3.9));
+    ops.push(rectOp(M, y - headerH, contentW, headerH, PdfColor.tint, PdfColor.line, 0.6));
+    headers.forEach((h, c) =>
+      ops.push(textOp(clipText(h, cellChars), M + c * colW + 4, y - 11, 7, "F2", PdfColor.teal)),
+    );
+    y -= headerH;
+
+    let shown = 0;
+    for (const row of rows) {
+      if (y < 96) break;
+      ops.push(rectOp(M, y - rowH, contentW, rowH, "1 1 1", PdfColor.line, 0.4));
+      headers.forEach((_h, c) => {
+        if (c > 0) ops.push(lineOp(M + c * colW, y - rowH, M + c * colW, y, PdfColor.line, 0.3));
+        const cell = row[c] ?? "";
+        if (cell) ops.push(textOp(clipText(cell, cellChars), M + c * colW + 4, y - 10, 6.8, "F1", PdfColor.dark));
+      });
+      y -= rowH;
+      shown += 1;
+    }
+    if (shown < rows.length) {
+      ops.push(textOp(`... ${rows.length - shown} more row(s) not shown`, M, y - 10, 7, "F1", PdfColor.gray));
+    }
+  }
+
+  // Notice (verification clause)
+  if (notice) {
+    ops.push(lineOp(M, 78, M, 54, PdfColor.teal, 2));
+    wrapText(notice, landscape ? 155 : 104)
+      .slice(0, 2)
+      .forEach((ln, i) => ops.push(textOp(ln, M + 8, 72 - i * 11, 7.5, "F1", PdfColor.gray)));
+  }
+
+  // Signatures
+  const sigW = contentW / signatures.length;
+  signatures.forEach((s, i) => {
+    const x = M + i * sigW;
+    ops.push(lineOp(x, 40, x + sigW - 18, 40, PdfColor.dark, 0.7));
+    ops.push(textOp(clipText(s, Math.floor((sigW - 18) / 3.6)), x, 30, 7, "F1", PdfColor.gray));
+  });
+
+  return assembleSinglePagePdf(ops, page);
+}
+
 /** Greedy word-wrap to a maximum character width. */
 export function wrapText(text: string, maxChars: number): string[] {
   const out: string[] = [];
@@ -141,13 +281,22 @@ export function wrapText(text: string, maxChars: number): string[] {
   return out.length ? out : [""];
 }
 
-/** Assemble a single-page A4 PDF from content-stream ops (Helvetica fonts). */
-export function assembleSinglePagePdf(ops: string[]): Buffer {
+/** A4 page sizes in PDF points. */
+export const PageSize = {
+  portrait: { width: 595, height: 842 },
+  landscape: { width: 842, height: 595 },
+} as const;
+
+/** Assemble a single-page PDF from content-stream ops (Helvetica fonts). Defaults to A4 portrait. */
+export function assembleSinglePagePdf(
+  ops: string[],
+  page: { width: number; height: number } = PageSize.portrait,
+): Buffer {
   const stream = ops.join("\n");
   const objects = [
     "<< /Type /Catalog /Pages 2 0 R >>",
     "<< /Type /Pages /Kids [3 0 R] /Count 1 >>",
-    "<< /Type /Page /Parent 2 0 R /MediaBox [0 0 595 842] /Resources << /Font << /F1 4 0 R /F2 5 0 R >> >> /Contents 6 0 R >>",
+    `<< /Type /Page /Parent 2 0 R /MediaBox [0 0 ${page.width} ${page.height}] /Resources << /Font << /F1 4 0 R /F2 5 0 R >> >> /Contents 6 0 R >>`,
     "<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica >>",
     "<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica-Bold >>",
     `<< /Length ${Buffer.byteLength(stream, "latin1")} >>\nstream\n${stream}\nendstream`,
diff --git a/apps/edr-freight-api/src/modules/bookings/booking-lifecycle-notifier.service.ts b/apps/edr-freight-api/src/modules/bookings/booking-lifecycle-notifier.service.ts
new file mode 100644
index 000000000..a4546e301
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/bookings/booking-lifecycle-notifier.service.ts
@@ -0,0 +1,307 @@
+import { Injectable, Logger } from '@nestjs/common';
+import {
+  NotificationAudience,
+  NotificationType,
+  NotifyInput,
+} from '@edr/types';
+
+import { Booking } from './entities/booking.entity';
+import { NotificationsService } from '../notifications/notifications.service';
+import { NotificationInboxService } from '../notification-inbox/notification-inbox.service';
+
+/**
+ * Customer + staff notifications for the booking lifecycle: review, clearance
+ * and operation flow. Every customer event fans out over SMS + email (direct)
+ * and a persisted in-app notification deep-linking to the booking detail page;
+ * staff events land in the backoffice inbox. All sends are fire-and-forget and
+ * never throw — a notification failure must not break a booking transition.
+ *
+ * NOTE: the batch/payment-window notifications (pay-now, allocated, expired,
+ * displaced) are handled separately by {@link BookingNotifierService} in
+ * train-scheduling.
+ */
+@Injectable()
+export class BookingLifecycleNotifierService {
+  private readonly logger = new Logger(BookingLifecycleNotifierService.name);
+
+  constructor(
+    private readonly notifications: NotificationsService,
+    private readonly inbox: NotificationInboxService,
+  ) {}
+
+  private ref(b: Booking): string {
+    return `${b.reference}${b.isGovernment ? ' (gov)' : ''}`;
+  }
+
+  /** Send SMS + email to the booking's company contact; log-only on failure. */
+  private async notifyContact(
+    b: Booking,
+    message: string,
+    logLabel: string,
+  ): Promise<void> {
+    this.logger.log(`${logLabel} — ${this.ref(b)}`);
+    const phone = b.company?.contactPersonPhone ?? b.company?.phone ?? null;
+    const email = b.company?.email ?? b.company?.generalManagerEmail ?? null;
+
+    if (phone) {
+      try {
+        await this.notifications.directSend('sms', phone, message);
+      } catch (err) {
+        this.logger.warn(`SMS failed for ${this.ref(b)}: ${(err as Error).message}`);
+      }
+    }
+    if (email) {
+      try {
+        await this.notifications.directSend('email', email, message);
+      } catch (err) {
+        this.logger.warn(`Email failed for ${this.ref(b)}: ${(err as Error).message}`);
+      }
+    }
+    if (!phone && !email) {
+      this.logger.warn(`No contact on file for ${this.ref(b)} — notification not sent`);
+    }
+  }
+
+  /** Persist + push an in-app item to all portal users of the booking's company. */
+  private inApp(
+    b: Booking,
+    title: string,
+    body: string,
+    overrides: Partial<NotifyInput> = {},
+  ): void {
+    if (!b.companyId) return; // government/unlinked bookings have no portal users
+    void this.inbox.notify({
+      recipients: { companyId: b.companyId },
+      audience: NotificationAudience.PORTAL,
+      type: NotificationType.BOOKING_STATUS,
+      title,
+      body,
+      link: `/bookings/${b.id}`,
+      data: { bookingId: b.id, reference: b.reference },
+      ...overrides,
+    });
+  }
+
+  /** Persist + push an in-app item to every backoffice staff user. */
+  private inAppStaff(
+    b: Booking,
+    title: string,
+    body: string,
+    overrides: Partial<NotifyInput> = {},
+  ): void {
+    void this.inbox.notify({
+      recipients: { allBackoffice: true },
+      audience: NotificationAudience.BACKOFFICE,
+      type: NotificationType.REQUEST_SUBMITTED,
+      title,
+      body,
+      link: `/dashboard/booking-requests/${b.id}`,
+      data: { bookingId: b.id, reference: b.reference },
+      ...overrides,
+    });
+  }
+
+  // ── Customer-facing lifecycle events ───────────────────────────────────────
+
+  /** Line staff accepted intake → booking is under approval. */
+  accepted(b: Booking): void {
+    const msg =
+      `Your booking ${b.reference} has been accepted and is now under approval. ` +
+      `We will notify you once it is approved.`;
+    void this.notifyContact(b, msg, 'ACCEPTED');
+    this.inApp(b, 'Booking accepted', msg);
+  }
+
+  /** All approval steps complete → contract generated, ready for customer to sign. */
+  approved(b: Booking): void {
+    const msg =
+      `Your booking ${b.reference} has been approved. ` +
+      `Please review and sign your contract from the portal.`;
+    void this.notifyContact(b, msg, 'APPROVED');
+    this.inApp(b, 'Booking approved', msg);
+  }
+
+  /** Staff rejected the booking (intake or approval step). */
+  rejected(b: Booking, reason: string): void {
+    const msg =
+      `Your booking ${b.reference} was rejected. Reason: ${reason}. ` +
+      `Please contact us for details.`;
+    void this.notifyContact(b, msg, 'REJECTED');
+    this.inApp(b, 'Booking rejected', msg);
+  }
+
+  /** Staff requested changes before approval. */
+  changesRequested(b: Booking, note: string): void {
+    const msg =
+      `Changes were requested on your booking ${b.reference}: ${note}. ` +
+      `Please update and resubmit from the portal.`;
+    void this.notifyContact(b, msg, 'CHANGES REQUESTED');
+    this.inApp(b, 'Booking changes requested', msg);
+  }
+
+  /** A clearance document was queried and needs the customer to re-upload. */
+  documentQueried(b: Booking, fileKey: string, note: string): void {
+    const msg =
+      `A clearance document on booking ${b.reference} needs attention: "${fileKey}". ` +
+      `${note}. Please re-upload from the portal.`;
+    void this.notifyContact(b, msg, 'DOCUMENT QUERIED');
+    this.inApp(b, 'Document queried', msg, {
+      type: NotificationType.DOCUMENT_ACTION,
+    });
+  }
+
+  /** Clearance finalized → customer can proceed to request operation. */
+  clearanceReady(b: Booking): void {
+    const msg =
+      `Clearance for booking ${b.reference} is complete. ` +
+      `You can now proceed to request operation from the portal.`;
+    void this.notifyContact(b, msg, 'CLEARANCE READY');
+    this.inApp(b, 'Clearance complete', msg, {
+      type: NotificationType.CLEARANCE_DECISION,
+    });
+  }
+
+  /** Operations returned the operation request for changes. */
+  operationChangesRequested(b: Booking, note: string): void {
+    const msg =
+      `Your operation request for booking ${b.reference} needs changes: ${note}. ` +
+      `Please update and resubmit from the portal.`;
+    void this.notifyContact(b, msg, 'OPERATION CHANGES REQUESTED');
+    this.inApp(b, 'Operation request needs changes', msg);
+  }
+
+  /** Operation accepted → invoice ready; await payment / booking window. */
+  operationAccepted(b: Booking): void {
+    const msg =
+      `Your operation request for booking ${b.reference} has been accepted. ` +
+      `An invoice has been prepared — watch for the payment window to secure your slot.`;
+    void this.notifyContact(b, msg, 'OPERATION ACCEPTED');
+    this.inApp(b, 'Operation request accepted', msg);
+  }
+
+  /** Shipment started → in transit. */
+  inTransit(b: Booking): void {
+    const msg = `Your shipment for booking ${b.reference} is now in transit.`;
+    void this.notifyContact(b, msg, 'IN TRANSIT');
+    this.inApp(b, 'Shipment in transit', msg);
+  }
+
+  /** Shipment delivered → completed. */
+  completed(b: Booking): void {
+    const msg = `Your shipment for booking ${b.reference} has been delivered. Thank you.`;
+    void this.notifyContact(b, msg, 'COMPLETED');
+    this.inApp(b, 'Shipment delivered', msg);
+  }
+
+  /** Booking cancelled. */
+  cancelled(b: Booking, reason: string): void {
+    const msg = `Your booking ${b.reference} has been cancelled. Reason: ${reason}.`;
+    void this.notifyContact(b, msg, 'CANCELLED');
+    this.inApp(b, 'Booking cancelled', msg);
+  }
+
+  // ── Clearance milestones needing customer action ──────────────────────────
+
+  /** GL advised duty & tax — the customer must pay and upload the slip. */
+  dutyAdvised(b: Booking, amount: number, currency: string): void {
+    const msg =
+      `Duty & tax of ${amount} ${currency} has been advised for booking ${b.reference}. ` +
+      `Please pay and upload the payment slip from the portal.`;
+    void this.notifyContact(b, msg, 'DUTY ADVISED');
+    this.inApp(b, 'Duty & tax advised', msg, {
+      type: NotificationType.INVOICE_ISSUED,
+    });
+  }
+
+  /** GL advised the post-arrival additional duty round (import). */
+  secondDutyAdvised(b: Booking, amount: number, currency: string): void {
+    const msg =
+      `Additional duty & tax of ${amount} ${currency} has been advised for booking ${b.reference}. ` +
+      `Please pay and upload the payment slip from the portal.`;
+    void this.notifyContact(b, msg, 'SECOND DUTY ADVISED');
+    this.inApp(b, 'Additional duty & tax advised', msg, {
+      type: NotificationType.INVOICE_ISSUED,
+    });
+  }
+
+  /** GL raised the final (post-offload) invoice — customer pays + uploads slip. */
+  finalInvoiceCreated(b: Booking, amount: number, currency: string): void {
+    const msg =
+      `A final invoice of ${amount} ${currency} has been issued for booking ${b.reference}. ` +
+      `Please pay and upload the payment slip from the portal.`;
+    void this.notifyContact(b, msg, 'FINAL INVOICE');
+    this.inApp(b, 'Final invoice issued', msg, {
+      type: NotificationType.INVOICE_ISSUED,
+    });
+  }
+
+  /** GL confirmed the final-invoice payment slip. */
+  finalInvoicePaid(b: Booking): void {
+    const msg = `Your final invoice payment for booking ${b.reference} has been confirmed. Thank you.`;
+    void this.notifyContact(b, msg, 'FINAL INVOICE PAID');
+    this.inApp(b, 'Final invoice paid', msg, {
+      type: NotificationType.INVOICE_ISSUED,
+    });
+  }
+
+  // ── Staff-facing (backoffice inbox) ────────────────────────────────────────
+
+  /** Customer submitted a booking for review. */
+  submittedToStaff(b: Booking): void {
+    this.inAppStaff(
+      b,
+      'New booking submitted',
+      `Booking ${this.ref(b)} was submitted and is awaiting intake review.`,
+    );
+  }
+
+  /** Customer signed the booking contract. */
+  customerSignedToStaff(b: Booking): void {
+    this.inAppStaff(
+      b,
+      'Customer signed booking contract',
+      `The contract for booking ${this.ref(b)} was signed by the customer.`,
+    );
+  }
+
+  /** Customer requested operation (picked a shipment day). */
+  operationRequestedToStaff(b: Booking): void {
+    this.inAppStaff(
+      b,
+      'Operation requested',
+      `Booking ${this.ref(b)} requested operation — review capacity, documents and route.`,
+    );
+  }
+
+  /** Customer uploaded clearance documents — review is next. */
+  clearanceDocsUploadedToStaff(b: Booking): void {
+    this.inAppStaff(
+      b,
+      'Clearance documents uploaded',
+      `Customer uploaded clearance documents for booking ${this.ref(b)} — review them in the clearance queue.`,
+      {
+        type: NotificationType.CLEARANCE_REVIEW,
+        link: `/dashboard/bookings/${b.id}/clearance`,
+      },
+    );
+  }
+
+  /** Customer uploaded a duty/tax payment slip — GL verifies it. */
+  dutySlipUploadedToStaff(b: Booking, round: 'first' | 'second' | 'final'): void {
+    const label =
+      round === 'final'
+        ? 'final invoice'
+        : round === 'second'
+          ? 'additional duty & tax'
+          : 'duty & tax';
+    this.inAppStaff(
+      b,
+      'Payment slip uploaded',
+      `Customer uploaded the ${label} payment slip for booking ${this.ref(b)}.`,
+      {
+        type: NotificationType.PAYMENT_RECEIVED,
+        link: `/dashboard/bookings/${b.id}/clearance`,
+      },
+    );
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/bookings/booking-transition.accept.spec.ts b/apps/edr-freight-api/src/modules/bookings/booking-transition.accept.spec.ts
index 3c535f450..607a0d7a4 100644
--- a/apps/edr-freight-api/src/modules/bookings/booking-transition.accept.spec.ts
+++ b/apps/edr-freight-api/src/modules/bookings/booking-transition.accept.spec.ts
@@ -30,14 +30,32 @@ describe('BookingTransitionService — acceptIntake validity window', () => {
       ruleEngineService as never,
       {} as never, // pricingService
       {} as never, // contractService
-      {} as never, // invoiceService
       {} as never, // filesService
       {} as never, // fileUploadSettingsService
       {} as never, // bookingBatchService
       bookingsService as never,
       { isPhasedGeneralCustomsBooking: () => false } as never,
-      {} as never,
+      {} as never, // workflowService
+      {} as never, // invoiceService
       { validate20ftPairing: jest.fn().mockResolvedValue([]) } as never,
+      {
+        accepted: jest.fn(),
+        approved: jest.fn(),
+        rejected: jest.fn(),
+        changesRequested: jest.fn(),
+        documentQueried: jest.fn(),
+        clearanceReady: jest.fn(),
+        operationChangesRequested: jest.fn(),
+        operationAccepted: jest.fn(),
+        inTransit: jest.fn(),
+        completed: jest.fn(),
+        cancelled: jest.fn(),
+        submittedToStaff: jest.fn(),
+        customerSignedToStaff: jest.fn(),
+        operationRequestedToStaff: jest.fn(),
+        clearanceDocsUploadedToStaff: jest.fn(),
+        dutySlipUploadedToStaff: jest.fn(),
+      } as never, // notifier
     );
     return { service, bookingsRepository, ruleEngineService };
   }
diff --git a/apps/edr-freight-api/src/modules/bookings/booking-transition.clearance.spec.ts b/apps/edr-freight-api/src/modules/bookings/booking-transition.clearance.spec.ts
index 9f9aa5713..72c83e136 100644
--- a/apps/edr-freight-api/src/modules/bookings/booking-transition.clearance.spec.ts
+++ b/apps/edr-freight-api/src/modules/bookings/booking-transition.clearance.spec.ts
@@ -41,14 +41,32 @@ describe('BookingTransitionService — finalizeClearance gate', () => {
       {} as never, // ruleEngineService
       {} as never, // pricingService
       {} as never, // contractService
-      {} as never, // invoiceService
       filesService as never,
       fileUploadSettingsService as never,
       {} as never, // bookingBatchService
       bookingsService as never,
       { isPhasedGeneralCustomsBooking: () => false } as never,
-      {} as never,
+      {} as never, // workflowService
+      {} as never, // invoiceService
       { validate20ftPairing: jest.fn().mockResolvedValue([]) } as never,
+      {
+        accepted: jest.fn(),
+        approved: jest.fn(),
+        rejected: jest.fn(),
+        changesRequested: jest.fn(),
+        documentQueried: jest.fn(),
+        clearanceReady: jest.fn(),
+        operationChangesRequested: jest.fn(),
+        operationAccepted: jest.fn(),
+        inTransit: jest.fn(),
+        completed: jest.fn(),
+        cancelled: jest.fn(),
+        submittedToStaff: jest.fn(),
+        customerSignedToStaff: jest.fn(),
+        operationRequestedToStaff: jest.fn(),
+        clearanceDocsUploadedToStaff: jest.fn(),
+        dutySlipUploadedToStaff: jest.fn(),
+      } as never, // notifier
     );
     return { service, bookingsRepository };
   }
@@ -126,14 +144,32 @@ describe('BookingTransitionService — finalizeClearance customs output gate', (
       {} as never,
       {} as never,
       {} as never,
-      {} as never, // invoiceService
       filesService as never,
       fileUploadSettingsService as never,
-      {} as never,
+      {} as never, // bookingBatchService
       bookingsService as never,
       { isPhasedGeneralCustomsBooking: () => false } as never,
-      {} as never,
+      {} as never, // workflowService
+      {} as never, // invoiceService
       { validate20ftPairing: jest.fn().mockResolvedValue([]) } as never,
+      {
+        accepted: jest.fn(),
+        approved: jest.fn(),
+        rejected: jest.fn(),
+        changesRequested: jest.fn(),
+        documentQueried: jest.fn(),
+        clearanceReady: jest.fn(),
+        operationChangesRequested: jest.fn(),
+        operationAccepted: jest.fn(),
+        inTransit: jest.fn(),
+        completed: jest.fn(),
+        cancelled: jest.fn(),
+        submittedToStaff: jest.fn(),
+        customerSignedToStaff: jest.fn(),
+        operationRequestedToStaff: jest.fn(),
+        clearanceDocsUploadedToStaff: jest.fn(),
+        dutySlipUploadedToStaff: jest.fn(),
+      } as never, // notifier
     );
     return { service, bookingsRepository };
   }
@@ -197,14 +233,32 @@ describe('BookingTransitionService — submitClearanceDocuments required-fields
       {} as never,
       {} as never,
       {} as never,
-      {} as never, // invoiceService
       filesService as never,
       fileUploadSettingsService as never,
-      {} as never,
+      {} as never, // bookingBatchService
       bookingsService as never,
       { isPhasedGeneralCustomsBooking: () => false } as never,
-      {} as never,
+      {} as never, // workflowService
+      {} as never, // invoiceService
       { validate20ftPairing: jest.fn().mockResolvedValue([]) } as never,
+      {
+        accepted: jest.fn(),
+        approved: jest.fn(),
+        rejected: jest.fn(),
+        changesRequested: jest.fn(),
+        documentQueried: jest.fn(),
+        clearanceReady: jest.fn(),
+        operationChangesRequested: jest.fn(),
+        operationAccepted: jest.fn(),
+        inTransit: jest.fn(),
+        completed: jest.fn(),
+        cancelled: jest.fn(),
+        submittedToStaff: jest.fn(),
+        customerSignedToStaff: jest.fn(),
+        operationRequestedToStaff: jest.fn(),
+        clearanceDocsUploadedToStaff: jest.fn(),
+        dutySlipUploadedToStaff: jest.fn(),
+      } as never, // notifier
     );
     return { service, bookingsRepository, filesService };
   }
diff --git a/apps/edr-freight-api/src/modules/bookings/booking-transition.operation.spec.ts b/apps/edr-freight-api/src/modules/bookings/booking-transition.operation.spec.ts
index ea3618a08..9201e4fa9 100644
--- a/apps/edr-freight-api/src/modules/bookings/booking-transition.operation.spec.ts
+++ b/apps/edr-freight-api/src/modules/bookings/booking-transition.operation.spec.ts
@@ -3,14 +3,17 @@ import { BookingTransitionService } from './booking-transition.service';
 
 /**
  * Operation-request review for general-contract drawdown orders:
- *  - ACCEPT a train order → FULLY_EXECUTED and enqueued into the batch pool.
- *  - ACCEPT a road order  → ROAD_DISPATCH_PENDING, NOT enqueued.
+ *  - ACCEPT a train order → FULLY_EXECUTED with the invoice ensured; import/
+ *    domestic bookings wait for their booking-day window cycle (no immediate
+ *    batch enqueue at accept time).
+ *  - ACCEPT a road order  → ROAD_DISPATCH_PENDING, never enters the train batch.
  *  - REQUEST_CHANGES requires a note → OPERATION_CHANGES_REQUESTED.
  */
 describe('BookingTransitionService — operation review', () => {
   function makeService(serviceTypeCode: string) {
     const booking = {
       id: 'b-1',
+      reference: 'BKG-1',
       status: 'OPERATION_REQUEST_PENDING',
       originYardId: 'o-1',
       destinationYardId: 'd-1',
@@ -26,6 +29,14 @@ describe('BookingTransitionService — operation review', () => {
     };
     const bookingBatchService = {
       enqueueRouteDayProcessing: jest.fn(),
+      pickExportSchedule: jest.fn(),
+      acceptExportBooking: jest.fn(),
+    };
+    const invoiceService = {
+      ensureInvoiceForBooking: jest
+        .fn()
+        .mockResolvedValue({ id: 'inv-1', invoiceNumber: 'INV-0001' }),
+      updateStatus: jest.fn().mockResolvedValue(undefined),
     };
 
     const service = new BookingTransitionService(
@@ -33,37 +44,60 @@ describe('BookingTransitionService — operation review', () => {
       {} as never, // ruleEngineService
       {} as never, // pricingService
       {} as never, // contractService
-      {} as never, // invoiceService
       {} as never, // filesService
       {} as never, // fileUploadSettingsService
       bookingBatchService as never,
       bookingsService as never,
       { isPhasedGeneralCustomsBooking: () => false } as never,
-      {} as never,
+      {} as never, // workflowService
+      invoiceService as never,
       { validate20ftPairing: jest.fn().mockResolvedValue([]) } as never,
+      {
+        accepted: jest.fn(),
+        approved: jest.fn(),
+        rejected: jest.fn(),
+        changesRequested: jest.fn(),
+        documentQueried: jest.fn(),
+        clearanceReady: jest.fn(),
+        operationChangesRequested: jest.fn(),
+        operationAccepted: jest.fn(),
+        inTransit: jest.fn(),
+        completed: jest.fn(),
+        cancelled: jest.fn(),
+        submittedToStaff: jest.fn(),
+        customerSignedToStaff: jest.fn(),
+        operationRequestedToStaff: jest.fn(),
+        clearanceDocsUploadedToStaff: jest.fn(),
+        dutySlipUploadedToStaff: jest.fn(),
+      } as never, // notifier
     );
-    return { service, bookingsRepository, bookingBatchService };
+    return { service, bookingsRepository, bookingBatchService, invoiceService };
   }
 
-  it('ACCEPT of a train order → FULLY_EXECUTED and enqueues the batch pool', async () => {
-    const { service, bookingsRepository, bookingBatchService } =
+  it('ACCEPT of a train order → FULLY_EXECUTED, invoice ensured, batch waits for window cycle', async () => {
+    const { service, bookingsRepository, bookingBatchService, invoiceService } =
       makeService('RAIL_CONTAINER');
     await service.reviewOperationRequest('b-1', 'ACCEPT', 'staff-1');
     expect(bookingsRepository.update).toHaveBeenCalledWith(
       'b-1',
       expect.objectContaining({ status: 'FULLY_EXECUTED' }),
     );
-    expect(bookingBatchService.enqueueRouteDayProcessing).toHaveBeenCalledTimes(1);
+    expect(invoiceService.ensureInvoiceForBooking).toHaveBeenCalledTimes(1);
+    // Import/domestic train bookings are batched by the window cycle later —
+    // never enqueued directly at accept time.
+    expect(bookingBatchService.enqueueRouteDayProcessing).not.toHaveBeenCalled();
+    expect(bookingBatchService.acceptExportBooking).not.toHaveBeenCalled();
   });
 
-  it('ACCEPT of a road order → ROAD_DISPATCH_PENDING and does NOT enqueue', async () => {
-    const { service, bookingsRepository, bookingBatchService } =
+  it('ACCEPT of a road order → ROAD_DISPATCH_PENDING and does NOT enter the batch', async () => {
+    const { service, bookingsRepository, bookingBatchService, invoiceService } =
       makeService('ROAD_CONTAINER');
     await service.reviewOperationRequest('b-1', 'ACCEPT', 'staff-1');
     expect(bookingsRepository.update).toHaveBeenCalledWith(
       'b-1',
       expect.objectContaining({ status: 'ROAD_DISPATCH_PENDING' }),
     );
+    expect(invoiceService.ensureInvoiceForBooking).toHaveBeenCalledTimes(1);
     expect(bookingBatchService.enqueueRouteDayProcessing).not.toHaveBeenCalled();
   });
 
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 06edbf04e..b5c277073 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
@@ -4,6 +4,7 @@ import {
   Inject,
   Injectable,
   Logger,
+  Optional,
 } from "@nestjs/common";
 import type { TCurrentUser } from "@tria-plc/api-common/modules/auth/types/current-user.type";
 
@@ -15,6 +16,7 @@ import { RuleEngineService } from '../rule-engine/rule-engine.service';
 import { FilesService } from '../files/files.service';
 import { FileUploadSettingsService } from '../file-upload-settings/file-upload-settings.service';
 import { BookingContractService } from './booking-contract.service';
+import { BookingLifecycleNotifierService } from './booking-lifecycle-notifier.service';
 import { BookingPricingService } from './booking-pricing.service';
 import { ContainerValidationService } from './container-validation.service';
 import { BookingsRepository } from './bookings.repository';
@@ -26,6 +28,7 @@ import { PriceLineItemDto } from './dto/generate-price-response.dto';
 import { Booking } from './entities/booking.entity';
 import { BookingsService } from './bookings.service';
 import { BookingClearanceService } from '../contracts/booking-clearance.service';
+import { ClearanceMilestoneService } from '../contracts/clearance-milestone.service';
 import { ClearanceWorkflowService } from '../contracts/clearance-workflow.service';
 import { ContractDocPhase } from '@edr/types';
 
@@ -53,7 +56,8 @@ export class BookingTransitionService {
     private readonly workflowService: ClearanceWorkflowService,
         private readonly invoiceService: BookingInvoiceService,
     private readonly containerValidationService: ContainerValidationService,
-
+    private readonly notifier: BookingLifecycleNotifierService,
+    @Optional() private readonly milestoneService?: ClearanceMilestoneService,
   ) {}
 
   private isPhasedGeneralCustoms(booking: Booking): boolean {
@@ -124,6 +128,9 @@ export class BookingTransitionService {
       const finalBooking = await this.bookingsService.runConsolidationOnSubmit(
         updated!.id,
       );
+      if (finalBooking.status === "SUBMITTED") {
+        this.notifier.submittedToStaff(finalBooking);
+      }
       return {
         bookingId: finalBooking.id,
         status: finalBooking.status,
@@ -204,6 +211,9 @@ export class BookingTransitionService {
     const finalBooking = await this.bookingsService.runConsolidationOnSubmit(
       updated!.id,
     );
+    if (finalBooking.status === "SUBMITTED") {
+      this.notifier.submittedToStaff(finalBooking);
+    }
     return {
       bookingId: finalBooking.id,
       status: finalBooking.status,
@@ -233,7 +243,9 @@ export class BookingTransitionService {
     const updated = await this.bookingsRepository.update(bookingId, {
       status: "CHANGES_REQUESTED",
     } as never);
-    return this.bookingsService.findById(updated!.id);
+    const fresh = await this.bookingsService.findById(updated!.id);
+    this.notifier.changesRequested(fresh, note);
+    return fresh;
   }
 
   /** Auto-create booking approval steps from system rules when none exist yet. */
@@ -284,7 +296,9 @@ export class BookingTransitionService {
       contractValidFrom: validFrom,
       contractValidUntil: validUntil,
     } as never);
-    return this.bookingsService.findById(updated!.id);
+    const fresh = await this.bookingsService.findById(updated!.id);
+    this.notifier.accepted(fresh);
+    return fresh;
   }
 
   async staffReject(
@@ -305,7 +319,9 @@ export class BookingTransitionService {
     const updated = await this.bookingsRepository.update(bookingId, {
       status: "REJECTED",
     } as never);
-    return this.bookingsService.findById(updated!.id);
+    const fresh = await this.bookingsService.findById(updated!.id);
+    this.notifier.rejected(fresh, reason);
+    return fresh;
   }
 
   async approveStep(
@@ -394,7 +410,9 @@ export class BookingTransitionService {
 
     if (allDone) {
       const generated = await this.contractService.generateContract(bookingId);
-      return this.bookingsService.findById(generated.id);
+      const fresh = await this.bookingsService.findById(generated.id);
+      this.notifier.approved(fresh);
+      return fresh;
     }
 
     return this.bookingsService.findById(bookingId);
@@ -435,7 +453,9 @@ export class BookingTransitionService {
     const updated = await this.bookingsRepository.update(bookingId, {
       status: "REJECTED",
     } as never);
-    return this.bookingsService.findById(updated!.id);
+    const fresh = await this.bookingsService.findById(updated!.id);
+    this.notifier.rejected(fresh, reason);
+    return fresh;
   }
 
   async customerSign(bookingId: string): Promise<Booking> {
@@ -446,7 +466,9 @@ export class BookingTransitionService {
       status: "SIGNED_CUSTOMER",
       customerSignedAt: new Date(),
     } as never);
-    return this.bookingsService.findById(updated!.id);
+    const fresh = await this.bookingsService.findById(updated!.id);
+    this.notifier.customerSignedToStaff(fresh);
+    return fresh;
   }
 
   async startTransit(bookingId: string): Promise<Booking> {
@@ -456,7 +478,9 @@ export class BookingTransitionService {
     const updated = await this.bookingsRepository.update(bookingId, {
       status: "IN_TRANSIT",
     } as never);
-    return this.bookingsService.findById(updated!.id);
+    const fresh = await this.bookingsService.findById(updated!.id);
+    this.notifier.inTransit(fresh);
+    return fresh;
   }
 
   async complete(bookingId: string): Promise<Booking> {
@@ -467,7 +491,28 @@ export class BookingTransitionService {
       status: "COMPLETED",
       endDate: new Date(),
     } as never);
-    return this.bookingsService.findById(updated!.id);
+    const fresh = await this.bookingsService.findById(updated!.id);
+    this.notifier.completed(fresh);
+    // Customer tracking: close out the tail milestones so a finished shipment
+    // never shows a forever-pending timeline. EXIT_NOTE/PROCESS_COMPLETED are
+    // implied by delivery; a storage invoice that was never raised is skipped
+    // (storage billing does not apply to every shipment). All doc-trigger /
+    // best-effort — a booking without milestone rows is untouched.
+    if (this.milestoneService) {
+      for (const code of ["IMPORT_PROCESS_COMPLETED", "EXIT_NOTE_GENERATED"]) {
+        try {
+          await this.milestoneService.completeByDocTrigger({ bookingId }, code);
+        } catch {
+          /* tracking must never block completion */
+        }
+      }
+      try {
+        await this.milestoneService.skipForBooking(bookingId, "STORAGE_INVOICE_RAISED");
+      } catch {
+        /* no such milestone row (export / non-customs) — fine */
+      }
+    }
+    return fresh;
   }
 
   async cancel(bookingId: string, reason: string): Promise<Booking> {
@@ -491,7 +536,9 @@ export class BookingTransitionService {
     const updated = await this.bookingsRepository.update(bookingId, {
       status: "CANCELLED",
     } as never);
-    return this.bookingsService.findById(updated!.id);
+    const fresh = await this.bookingsService.findById(updated!.id);
+    this.notifier.cancelled(fresh, reason);
+    return fresh;
   }
 
   /**
@@ -723,7 +770,9 @@ export class BookingTransitionService {
       } as never);
     }
 
-    return this.bookingsService.findById(bookingId);
+    const fresh = await this.bookingsService.findById(bookingId);
+    this.notifier.clearanceDocsUploadedToStaff(fresh);
+    return fresh;
   }
 
   /**
@@ -824,6 +873,9 @@ export class BookingTransitionService {
     }
 
     const updated = await this.bookingsService.findById(bookingId);
+    if (status === "QUERIED") {
+      this.notifier.documentQueried(updated, fileKey, note ?? '');
+    }
     if (this.isPhasedGeneralCustoms(updated)) {
       const allApproved = await this.isClearanceFullyApproved(updated);
       if (allApproved) {
@@ -912,7 +964,9 @@ export class BookingTransitionService {
     await this.bookingsRepository.update(bookingId, {
       status: "CLEARANCE_READY",
     } as never);
-    return this.bookingsService.findById(bookingId);
+    const fresh = await this.bookingsService.findById(bookingId);
+    this.notifier.clearanceReady(fresh);
+    return fresh;
   }
 
   /**
@@ -957,7 +1011,9 @@ export class BookingTransitionService {
       status: "OPERATION_REQUEST_PENDING",
       scheduledDate: date,
     } as never);
-    return this.bookingsService.findById(bookingId);
+    const fresh = await this.bookingsService.findById(bookingId);
+    this.notifier.operationRequestedToStaff(fresh);
+    return fresh;
   }
 
   /**
@@ -992,7 +1048,9 @@ export class BookingTransitionService {
       await this.bookingsRepository.update(bookingId, {
         status: "OPERATION_CHANGES_REQUESTED",
       } as never);
-      return this.bookingsService.findById(bookingId);
+      const fresh = await this.bookingsService.findById(bookingId);
+      this.notifier.operationChangesRequested(fresh, options.note);
+      return fresh;
     }
 
     // ACCEPT — enter the batch holding pool.
@@ -1037,7 +1095,9 @@ export class BookingTransitionService {
         fullyExecutedAt: now,
         lockedAt: booking.lockedAt ?? now,
       } as never);
-      return this.bookingsService.findById(booking.id);
+      const roadFresh = await this.bookingsService.findById(booking.id);
+      this.notifier.operationAccepted(roadFresh);
+      return roadFresh;
     }
 
     await this.bookingsRepository.update(booking.id, {
@@ -1072,7 +1132,9 @@ export class BookingTransitionService {
     // 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);
+    const trainFresh = await this.bookingsService.findById(booking.id);
+    this.notifier.operationAccepted(trainFresh);
+    return trainFresh;
   }
 
   async enrichBookingResponse(booking: Booking): Promise<
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 2cb10ce8e..61dc78e13 100644
--- a/apps/edr-freight-api/src/modules/bookings/bookings.module.ts
+++ b/apps/edr-freight-api/src/modules/bookings/bookings.module.ts
@@ -18,7 +18,10 @@ import { BookingInvoiceService } from './booking-invoice.service';
 // import { BookingPaymentService } from './booking-payment.service';
 import { BookingPricingService } from './booking-pricing.service';
 import { BookingReferenceDataService } from './booking-reference-data.service';
+import { BookingLifecycleNotifierService } from './booking-lifecycle-notifier.service';
 import { BookingTransitionService } from './booking-transition.service';
+import { NotificationsModule } from '../notifications/notifications.module';
+import { NotificationInboxModule } from '../notification-inbox/notification-inbox.module';
 import { BookingsController } from './bookings.controller';
 // import { PayController } from './pay.controller';
 import { BookingsRepository } from './bookings.repository';
@@ -64,6 +67,8 @@ import { VehiclesModule } from "../vehicles/vehicles.module";
       CustomerTruckContainer,
     ]),
     BillingModule,
+    NotificationsModule,
+    NotificationInboxModule,
     forwardRef(() => FirstMileModule),
     forwardRef(() => TrainSchedulingModule),
     forwardRef(() => ContractsModule),
@@ -90,6 +95,7 @@ import { VehiclesModule } from "../vehicles/vehicles.module";
     ContainerValidationService,
     BookingReferenceDataService,
     BookingPricingService,
+    BookingLifecycleNotifierService,
     BookingTransitionService,
     BookingContractService,
     BookingInvoiceService,
@@ -107,6 +113,7 @@ import { VehiclesModule } from "../vehicles/vehicles.module";
     BookingsRepository,
     BookingPricingService,
     BookingInvoiceService,
+    BookingLifecycleNotifierService,
     CustomerTruckService,
     ContainerReceiptService,
   ],
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 d4791baf7..1fb37dc31 100644
--- a/apps/edr-freight-api/src/modules/bookings/bookings.service.ts
+++ b/apps/edr-freight-api/src/modules/bookings/bookings.service.ts
@@ -1388,6 +1388,17 @@ export class BookingsService {
       );
     }
 
+    // Surface the assigned train's operational status so the portal stepper
+    // can show the Arrival stage: the booking status stays IN_TRANSIT from
+    // dispatch until delivery, so arrival is only knowable from the schedule.
+    if (booking.trainScheduleId) {
+      const schedule = await this.dataSource
+        .getRepository(TrainSchedule)
+        .findOne({ where: { id: booking.trainScheduleId } });
+      (booking as Booking & { trainScheduleStatus?: string | null }).trainScheduleStatus =
+        schedule?.status ?? null;
+    }
+
     return booking;
   }
 
diff --git a/apps/edr-freight-api/src/modules/compliance/compliance.controller.ts b/apps/edr-freight-api/src/modules/compliance/compliance.controller.ts
new file mode 100644
index 000000000..2a5715647
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/compliance/compliance.controller.ts
@@ -0,0 +1,53 @@
+import { Controller, Post, Get, Patch, Delete, Body, Param, Query } from '@nestjs/common';
+import { ApiTags, ApiOperation } from '@nestjs/swagger';
+import { ComplianceService } from './compliance.service';
+import {
+  CreateComplianceRecordDto,
+  UpdateComplianceRecordDto,
+} from './dto/create-compliance-record.dto';
+import { ComplianceType } from './entities/compliance-record.entity';
+
+@ApiTags('Vehicle Compliance')
+@Controller('compliance')
+export class ComplianceController {
+  constructor(private readonly complianceService: ComplianceService) {}
+
+  @Post()
+  @ApiOperation({ summary: 'Create a compliance record' })
+  create(@Body() dto: CreateComplianceRecordDto) {
+    return this.complianceService.create(dto);
+  }
+
+  @Get()
+  @ApiOperation({ summary: 'List compliance records' })
+  findAll(
+    @Query('vehicleId') vehicleId?: string,
+    @Query('type') type?: ComplianceType,
+  ) {
+    return this.complianceService.findAll({ vehicleId, type });
+  }
+
+  @Get('alerts')
+  @ApiOperation({ summary: 'List overdue / due-soon compliance & expiry alerts' })
+  getAlerts() {
+    return this.complianceService.getAlerts();
+  }
+
+  @Get(':id')
+  @ApiOperation({ summary: 'Get a compliance record by ID' })
+  findOne(@Param('id') id: string) {
+    return this.complianceService.findById(id);
+  }
+
+  @Patch(':id')
+  @ApiOperation({ summary: 'Update a compliance record' })
+  update(@Param('id') id: string, @Body() dto: UpdateComplianceRecordDto) {
+    return this.complianceService.update(id, dto);
+  }
+
+  @Delete(':id')
+  @ApiOperation({ summary: 'Soft-delete a compliance record' })
+  remove(@Param('id') id: string) {
+    return this.complianceService.remove(id);
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/compliance/compliance.module.ts b/apps/edr-freight-api/src/modules/compliance/compliance.module.ts
new file mode 100644
index 000000000..1477fbc8b
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/compliance/compliance.module.ts
@@ -0,0 +1,16 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { ComplianceRecord } from './entities/compliance-record.entity';
+import { Vehicle } from '../vehicles/entities/vehicle.entity';
+import { Driver } from '../drivers/entities/driver.entity';
+import { ComplianceService } from './compliance.service';
+import { ComplianceRepository } from './compliance.repository';
+import { ComplianceController } from './compliance.controller';
+
+@Module({
+  imports: [TypeOrmModule.forFeature([ComplianceRecord, Vehicle, Driver])],
+  providers: [ComplianceService, ComplianceRepository],
+  controllers: [ComplianceController],
+  exports: [ComplianceService],
+})
+export class ComplianceModule {}
diff --git a/apps/edr-freight-api/src/modules/compliance/compliance.repository.ts b/apps/edr-freight-api/src/modules/compliance/compliance.repository.ts
new file mode 100644
index 000000000..e9764f8a4
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/compliance/compliance.repository.ts
@@ -0,0 +1,26 @@
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { BaseRepository } from '@edr/api-common';
+import { Repository, FindOptionsWhere } from 'typeorm';
+import { ComplianceRecord, ComplianceType } from './entities/compliance-record.entity';
+
+@Injectable()
+export class ComplianceRepository extends BaseRepository<ComplianceRecord> {
+  constructor(
+    @InjectRepository(ComplianceRecord)
+    private readonly complianceRepository: Repository<ComplianceRecord>,
+  ) {
+    super(complianceRepository);
+  }
+
+  async findWithFilters(filter: { vehicleId?: string; type?: ComplianceType } = {}) {
+    const where: FindOptionsWhere<ComplianceRecord> = {};
+    if (filter.vehicleId) where.vehicleId = filter.vehicleId;
+    if (filter.type) where.type = filter.type;
+
+    return this.complianceRepository.find({
+      where,
+      order: { expiryDate: 'ASC' },
+    });
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/compliance/compliance.service.ts b/apps/edr-freight-api/src/modules/compliance/compliance.service.ts
new file mode 100644
index 000000000..ec6e2a803
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/compliance/compliance.service.ts
@@ -0,0 +1,184 @@
+import { Injectable, NotFoundException } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { In, IsNull, Repository } from 'typeorm';
+import { ComplianceRepository } from './compliance.repository';
+import {
+  ComplianceRecord,
+  ComplianceStatus,
+  ComplianceType,
+} from './entities/compliance-record.entity';
+import {
+  CreateComplianceRecordDto,
+  UpdateComplianceRecordDto,
+} from './dto/create-compliance-record.dto';
+import { Vehicle } from '../vehicles/entities/vehicle.entity';
+import { Driver } from '../drivers/entities/driver.entity';
+
+const DUE_SOON_DAYS = 30;
+const MS_PER_DAY = 24 * 60 * 60 * 1000;
+
+export type AlertSeverity = 'OVERDUE' | 'DUE_SOON';
+
+export interface ComplianceAlert {
+  vehicleId: string;
+  vehiclePlate?: string;
+  kind: string;
+  label: string;
+  expiryDate: string;
+  daysUntil: number;
+  severity: AlertSeverity;
+}
+
+@Injectable()
+export class ComplianceService {
+  constructor(
+    private readonly complianceRepository: ComplianceRepository,
+    @InjectRepository(Vehicle)
+    private readonly vehicleRepo: Repository<Vehicle>,
+    @InjectRepository(Driver)
+    private readonly driverRepo: Repository<Driver>,
+  ) {}
+
+  async create(dto: CreateComplianceRecordDto): Promise<ComplianceRecord> {
+    return this.complianceRepository.create({
+      ...dto,
+      status: dto.status ?? this.deriveStatus(dto.expiryDate),
+    });
+  }
+
+  async findAll(filter: { vehicleId?: string; type?: ComplianceType } = {}) {
+    return this.complianceRepository.findWithFilters(filter);
+  }
+
+  async findById(id: string): Promise<ComplianceRecord> {
+    const record = await this.complianceRepository.findById(id);
+    if (!record) {
+      throw new NotFoundException(`Compliance record ${id} not found`);
+    }
+    return record;
+  }
+
+  async update(id: string, dto: UpdateComplianceRecordDto): Promise<ComplianceRecord> {
+    await this.findById(id);
+    const nextExpiry = dto.expiryDate;
+    const updated = await this.complianceRepository.update(id, {
+      ...dto,
+      // Re-derive status when expiry changes and the caller didn't set it explicitly.
+      status: dto.status ?? (nextExpiry ? this.deriveStatus(nextExpiry) : undefined),
+    });
+    return updated!;
+  }
+
+  async remove(id: string): Promise<void> {
+    await this.findById(id);
+    await this.complianceRepository.softDelete(id);
+  }
+
+  /**
+   * Flat list of compliance items that are overdue or due within 30 days.
+   * Combines the compliance_records table with the vehicle expiry columns
+   * (insurance / registration / next inspection) and assigned-driver license
+   * expiry. `new Date()` is fine here — this is the NestJS API runtime.
+   */
+  async getAlerts(): Promise<ComplianceAlert[]> {
+    const now = new Date();
+    const alerts: ComplianceAlert[] = [];
+
+    const vehicles = await this.vehicleRepo.find({ where: { deletedAt: IsNull() } });
+    const vehicleById = new Map(vehicles.map((v) => [v.id, v]));
+    const plateOf = (v?: Vehicle) => v?.plateNumber ?? v?.code ?? undefined;
+
+    // 1. Compliance records
+    const records = await this.complianceRepository.findWithFilters();
+    for (const record of records) {
+      const computed = this.computeSeverity(record.expiryDate, now);
+      if (!computed) continue;
+      const vehicle = vehicleById.get(record.vehicleId);
+      alerts.push({
+        vehicleId: record.vehicleId,
+        vehiclePlate: plateOf(vehicle),
+        kind: record.type,
+        label: record.documentNumber
+          ? `${record.type} · ${record.documentNumber}`
+          : record.type,
+        expiryDate: record.expiryDate,
+        daysUntil: computed.daysUntil,
+        severity: computed.severity,
+      });
+    }
+
+    // 2. Vehicle-level expiry columns
+    const vehicleFields: { field: keyof Vehicle; kind: string; label: string }[] = [
+      { field: 'insuranceExpiry', kind: 'INSURANCE', label: 'Insurance' },
+      { field: 'registrationExpiry', kind: 'REGISTRATION', label: 'Registration' },
+      { field: 'nextInspectionDate', kind: 'INSPECTION', label: 'Inspection' },
+    ];
+    for (const vehicle of vehicles) {
+      for (const { field, kind, label } of vehicleFields) {
+        const value = vehicle[field] as string | undefined;
+        if (!value) continue;
+        const computed = this.computeSeverity(value, now);
+        if (!computed) continue;
+        alerts.push({
+          vehicleId: vehicle.id,
+          vehiclePlate: plateOf(vehicle),
+          kind,
+          label,
+          expiryDate: value,
+          daysUntil: computed.daysUntil,
+          severity: computed.severity,
+        });
+      }
+    }
+
+    // 3. Assigned-driver license expiry
+    const driverIds = [
+      ...new Set(vehicles.map((v) => v.assignedDriverId).filter((id): id is string => !!id)),
+    ];
+    if (driverIds.length > 0) {
+      const drivers = await this.driverRepo.find({ where: { id: In(driverIds) } });
+      const driverById = new Map(drivers.map((d) => [d.id, d]));
+      for (const vehicle of vehicles) {
+        if (!vehicle.assignedDriverId) continue;
+        const driver = driverById.get(vehicle.assignedDriverId);
+        if (!driver?.licenseExpiryDate) continue;
+        const expiry =
+          driver.licenseExpiryDate instanceof Date
+            ? driver.licenseExpiryDate.toISOString().slice(0, 10)
+            : String(driver.licenseExpiryDate);
+        const computed = this.computeSeverity(expiry, now);
+        if (!computed) continue;
+        alerts.push({
+          vehicleId: vehicle.id,
+          vehiclePlate: plateOf(vehicle),
+          kind: 'DRIVER_LICENSE',
+          label: `Driver License · ${driver.firstName ?? ''} ${driver.lastName ?? ''}`.trim(),
+          expiryDate: expiry,
+          daysUntil: computed.daysUntil,
+          severity: computed.severity,
+        });
+      }
+    }
+
+    return alerts.sort((a, b) => a.daysUntil - b.daysUntil);
+  }
+
+  private computeSeverity(
+    expiryDate: string,
+    now: Date,
+  ): { daysUntil: number; severity: AlertSeverity } | null {
+    const daysUntil = Math.ceil((new Date(expiryDate).getTime() - now.getTime()) / MS_PER_DAY);
+    if (daysUntil < 0) return { daysUntil, severity: 'OVERDUE' };
+    if (daysUntil <= DUE_SOON_DAYS) return { daysUntil, severity: 'DUE_SOON' };
+    return null;
+  }
+
+  private deriveStatus(expiryDate: string): ComplianceStatus {
+    const daysUntil = Math.ceil(
+      (new Date(expiryDate).getTime() - Date.now()) / MS_PER_DAY,
+    );
+    if (daysUntil < 0) return ComplianceStatus.EXPIRED;
+    if (daysUntil <= DUE_SOON_DAYS) return ComplianceStatus.EXPIRING;
+    return ComplianceStatus.VALID;
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/compliance/dto/create-compliance-record.dto.ts b/apps/edr-freight-api/src/modules/compliance/dto/create-compliance-record.dto.ts
new file mode 100644
index 000000000..8b716ef15
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/compliance/dto/create-compliance-record.dto.ts
@@ -0,0 +1,55 @@
+import { IsUUID, IsString, IsDateString, IsOptional, IsEnum } from 'class-validator';
+import { ComplianceType, ComplianceStatus } from '../entities/compliance-record.entity';
+
+export class CreateComplianceRecordDto {
+  @IsUUID()
+  vehicleId!: string;
+
+  @IsEnum(ComplianceType)
+  type!: ComplianceType;
+
+  @IsOptional()
+  @IsString()
+  documentNumber?: string;
+
+  @IsOptional()
+  @IsDateString()
+  issuedDate?: string;
+
+  @IsDateString()
+  expiryDate!: string;
+
+  @IsOptional()
+  @IsEnum(ComplianceStatus)
+  status?: ComplianceStatus;
+
+  @IsOptional()
+  @IsString()
+  notes?: string;
+}
+
+export class UpdateComplianceRecordDto {
+  @IsOptional()
+  @IsEnum(ComplianceType)
+  type?: ComplianceType;
+
+  @IsOptional()
+  @IsString()
+  documentNumber?: string;
+
+  @IsOptional()
+  @IsDateString()
+  issuedDate?: string;
+
+  @IsOptional()
+  @IsDateString()
+  expiryDate?: string;
+
+  @IsOptional()
+  @IsEnum(ComplianceStatus)
+  status?: ComplianceStatus;
+
+  @IsOptional()
+  @IsString()
+  notes?: string;
+}
diff --git a/apps/edr-freight-api/src/modules/compliance/entities/compliance-record.entity.ts b/apps/edr-freight-api/src/modules/compliance/entities/compliance-record.entity.ts
new file mode 100644
index 000000000..04355c1f9
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/compliance/entities/compliance-record.entity.ts
@@ -0,0 +1,46 @@
+import { BaseEntity } from '@edr/api-common';
+import { Entity, Column, ManyToOne, JoinColumn, Index } from 'typeorm';
+import { Vehicle } from '../../vehicles/entities/vehicle.entity';
+
+export enum ComplianceType {
+  INSPECTION = 'INSPECTION',
+  INSURANCE = 'INSURANCE',
+  ROADWORTHINESS = 'ROADWORTHINESS',
+  PERMIT = 'PERMIT',
+  TAX = 'TAX',
+}
+
+export enum ComplianceStatus {
+  VALID = 'VALID',
+  EXPIRING = 'EXPIRING',
+  EXPIRED = 'EXPIRED',
+}
+
+@Entity({ name: 'compliance_records', schema: 'freight' })
+@Index(['vehicleId', 'expiryDate'])
+export class ComplianceRecord extends BaseEntity {
+  @Column({ name: 'vehicle_id', type: 'uuid' })
+  vehicleId!: string;
+
+  @ManyToOne(() => Vehicle, { eager: false, nullable: false })
+  @JoinColumn({ name: 'vehicle_id' })
+  vehicle!: Vehicle;
+
+  @Column({ name: 'type', type: 'varchar' })
+  type!: ComplianceType;
+
+  @Column({ name: 'document_number', type: 'varchar', nullable: true })
+  documentNumber?: string;
+
+  @Column({ name: 'issued_date', type: 'date', nullable: true })
+  issuedDate?: string;
+
+  @Column({ name: 'expiry_date', type: 'date' })
+  expiryDate!: string;
+
+  @Column({ name: 'status', type: 'varchar', default: ComplianceStatus.VALID })
+  status!: ComplianceStatus;
+
+  @Column({ name: 'notes', type: 'text', nullable: true })
+  notes?: string;
+}
diff --git a/apps/edr-freight-api/src/modules/contracts/booking-clearance.service.spec.ts b/apps/edr-freight-api/src/modules/contracts/booking-clearance.service.spec.ts
index 2b0126003..7b5cb77d6 100644
--- a/apps/edr-freight-api/src/modules/contracts/booking-clearance.service.spec.ts
+++ b/apps/edr-freight-api/src/modules/contracts/booking-clearance.service.spec.ts
@@ -85,6 +85,13 @@ function makeService(overrides?: {
     milestoneService as never,
     dropdownSettingsService as never,
     glOperationsService as never,
+    {
+      dutyAdvised: jest.fn(),
+      clearanceReady: jest.fn(),
+      documentQueried: jest.fn(),
+      dutySlipUploadedToStaff: jest.fn(),
+      clearanceDocsUploadedToStaff: jest.fn(),
+    } as never, // notifier
   );
 
   return {
@@ -115,12 +122,18 @@ describe('BookingClearanceService', () => {
 
     it('records duty advice when duty applies', async () => {
       const { service, milestoneService } = makeService();
-      await service.adviseDuty('b-general', {
-        dutyRequired: true,
-        amount: 1500,
-        currency: 'ETB',
-        declarationSerial: 'DS-1',
-      });
+      await service.adviseDuty(
+        'b-general',
+        {
+          dutyRequired: true,
+          amount: 1500,
+          currency: 'ETB',
+          declarationSerial: 'DS-1',
+        },
+        undefined,
+        // The duty notice attachment is now mandatory when duty applies.
+        { fieldname: 'duty_tax_notice' } as Express.Multer.File,
+      );
 
       expect(milestoneService.adviseDuty).toHaveBeenCalledWith(
         'b-general',
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 61ac93925..59dad2248 100644
--- a/apps/edr-freight-api/src/modules/contracts/booking-clearance.service.ts
+++ b/apps/edr-freight-api/src/modules/contracts/booking-clearance.service.ts
@@ -12,6 +12,7 @@ import { FileUploadSettingsService } from '../file-upload-settings/file-upload-s
 import { FilesService } from '../files/files.service';
 import { BookingsRepository } from '../bookings/bookings.repository';
 import { BookingsService } from '../bookings/bookings.service';
+import { BookingLifecycleNotifierService } from '../bookings/booking-lifecycle-notifier.service';
 import { ClearanceMilestone } from './entities/clearance-milestone.entity';
 import { Booking } from '../bookings/entities/booking.entity';
 import { clearanceCodesForBooking } from '../bookings/clearance.util';
@@ -100,6 +101,7 @@ export class BookingClearanceService {
     private readonly milestoneService: ClearanceMilestoneService,
     private readonly dropdownSettingsService: DropdownSettingsService,
     private readonly glOperationsService: GlOperationsService,
+    private readonly notifier: BookingLifecycleNotifierService,
   ) {}
 
   private async assertPhasedGeneralCustoms(booking: Booking): Promise<void> {
@@ -174,7 +176,28 @@ export class BookingClearanceService {
     }
 
     const allApproved = await this.isClearanceFullyApproved(booking);
-    const milestones = await this.workflowService.listMilestonesForBooking(bookingId);
+    let milestones = await this.workflowService.listMilestonesForBooking(bookingId);
+
+    // Self-heal: a booking that has settled its freight payment must have
+    // FREIGHT_PAYMENT_SETTLED completed. The batch settle path writes it, but an
+    // export FCFS booking (linked to its train at booking time) paid via the
+    // prepaid invoice can leave the milestone PENDING — the clearance "Payment &
+    // wagon allocation" step then never ticks. Backfill it here so already-stuck
+    // rows recover without a migration; idempotent (no-op once COMPLETED).
+    const paymentSettled = milestones.find(
+      (m) => m.milestoneCode === 'FREIGHT_PAYMENT_SETTLED',
+    );
+    if (
+      paymentSettled &&
+      paymentSettled.status === 'PENDING' &&
+      (booking.paymentStatus === 'PAID' || booking.status === 'PAID')
+    ) {
+      await this.workflowService.completeMilestoneForBooking(
+        bookingId,
+        'FREIGHT_PAYMENT_SETTLED',
+      );
+      milestones = await this.workflowService.listMilestonesForBooking(bookingId);
+    }
     const phase = this.workflowService.resolvePhaseForBooking(booking, milestones);
     const nextAction = this.workflowService.computeNextActionForBooking(booking, milestones);
     const boundary = await this.workflowService.isBoundaryCompleteForBooking(
@@ -414,6 +437,7 @@ export class BookingClearanceService {
         },
         userId,
       );
+      this.notifier.dutyAdvised(booking, dto.amount, dto.currency ?? 'ETB');
     }
 
     return this.bookingsService.findById(bookingId);
@@ -441,6 +465,7 @@ export class BookingClearanceService {
       clearanceCurrentPhase: ContractDocPhase.GlEtPostClearance,
     } as never);
 
+    this.notifier.dutySlipUploadedToStaff(booking, 'first');
     return this.bookingsService.findById(bookingId);
   }
 
diff --git a/apps/edr-freight-api/src/modules/contracts/booking-request.service.ts b/apps/edr-freight-api/src/modules/contracts/booking-request.service.ts
index 88a4ec725..4752b004f 100644
--- a/apps/edr-freight-api/src/modules/contracts/booking-request.service.ts
+++ b/apps/edr-freight-api/src/modules/contracts/booking-request.service.ts
@@ -10,6 +10,7 @@ import type { Freight } from '@edr/types';
 import { BookingRequestRepository } from './booking-request.repository';
 import { ContractsService } from './contracts.service';
 import { ContractBookingService } from './contract-booking.service';
+import { ContractNotifierService } from './contract-notifier.service';
 import { BookingRequest } from './entities/booking-request.entity';
 import { Contract } from './entities/contract.entity';
 import { CreateBookingRequestDto } from './dto/create-booking-request.dto';
@@ -26,6 +27,7 @@ export class BookingRequestService {
     private readonly repo: BookingRequestRepository,
     private readonly contractsService: ContractsService,
     private readonly contractBookingService: ContractBookingService,
+    private readonly notifier: ContractNotifierService,
   ) {}
 
   /** Only GENERAL contracts that bundle customs use the request → GL → clearance flow. */
@@ -107,7 +109,7 @@ export class BookingRequestService {
         };
 
     const reference = await this.generateReference();
-    return this.repo.create({
+    const request = await this.repo.create({
       reference,
       contractId,
       requestedByUserId: userId ?? null,
@@ -117,6 +119,8 @@ export class BookingRequestService {
       requestedLines,
       notes: dto.notes ?? null,
     } as never);
+    this.notifier.shipmentRequestedToStaff(contract, request.id, request.reference);
+    return request;
   }
 
   listForContract(contractId: string): Promise<BookingRequest[]> {
diff --git a/apps/edr-freight-api/src/modules/contracts/clearance-milestone.service.ts b/apps/edr-freight-api/src/modules/contracts/clearance-milestone.service.ts
index e033f8e9b..4a58e50be 100644
--- a/apps/edr-freight-api/src/modules/contracts/clearance-milestone.service.ts
+++ b/apps/edr-freight-api/src/modules/contracts/clearance-milestone.service.ts
@@ -6,6 +6,7 @@ import {
   CustomsRiskLevel,
   MilestoneMetadata,
 } from './entities/clearance-milestone.entity';
+import { Booking } from '../bookings/entities/booking.entity';
 import { Contract } from './entities/contract.entity';
 import {
   HANDOFF_MILESTONES,
@@ -85,10 +86,36 @@ export class ClearanceMilestoneService {
   }
 
   async listForBooking(bookingId: string): Promise<ClearanceMilestone[]> {
-    return this.repo.find({
+    const rows = await this.repo.find({
       where: { bookingId },
       order: { sortOrder: 'ASC' },
     });
+
+    // Self-heal: a booking that has settled its freight payment must have
+    // FREIGHT_PAYMENT_SETTLED completed. The batch settle path writes it, but an
+    // export FCFS booking (linked to its train at booking time) paid via the
+    // prepaid invoice can leave the milestone PENDING — the clearance "Payment &
+    // wagon allocation" step then never ticks. getClearanceView backfills it, but
+    // the stepper reads its gating milestones straight from here, so heal here too.
+    // Idempotent (no-op once COMPLETED); recovers already-stuck rows with no migration.
+    const paymentSettled = rows.find(
+      (m) => m.milestoneCode === 'FREIGHT_PAYMENT_SETTLED',
+    );
+    if (paymentSettled && paymentSettled.status === 'PENDING') {
+      const booking = await this.dataSource.getRepository(Booking).findOne({
+        where: { id: bookingId },
+        select: { id: true, status: true, paymentStatus: true },
+      });
+      if (booking?.paymentStatus === 'PAID' || booking?.status === 'PAID') {
+        await this.completeForBooking(bookingId, 'FREIGHT_PAYMENT_SETTLED');
+        return this.repo.find({
+          where: { bookingId },
+          order: { sortOrder: 'ASC' },
+        });
+      }
+    }
+
+    return rows;
   }
 
   /**
diff --git a/apps/edr-freight-api/src/modules/contracts/clearance-workflow.service.spec.ts b/apps/edr-freight-api/src/modules/contracts/clearance-workflow.service.spec.ts
index f30b64597..75178d640 100644
--- a/apps/edr-freight-api/src/modules/contracts/clearance-workflow.service.spec.ts
+++ b/apps/edr-freight-api/src/modules/contracts/clearance-workflow.service.spec.ts
@@ -48,6 +48,7 @@ function makeService(milestones: ClearanceMilestone[]) {
     contractsRepository as never,
     milestoneService as never,
     bookingsRepository as never,
+    { clearanceReady: jest.fn() } as never, // notifier
   );
   return { service, milestoneService, contractsRepository, bookingsRepository };
 }
diff --git a/apps/edr-freight-api/src/modules/contracts/clearance-workflow.service.ts b/apps/edr-freight-api/src/modules/contracts/clearance-workflow.service.ts
index 758da27ff..9b17a3e76 100644
--- a/apps/edr-freight-api/src/modules/contracts/clearance-workflow.service.ts
+++ b/apps/edr-freight-api/src/modules/contracts/clearance-workflow.service.ts
@@ -9,6 +9,7 @@ import { Contract } from './entities/contract.entity';
 import { ContractClearanceCycle } from './entities/contract-clearance-cycle.entity';
 import { ClearanceMilestone } from './entities/clearance-milestone.entity';
 import { BookingsRepository } from '../bookings/bookings.repository';
+import { BookingLifecycleNotifierService } from '../bookings/booking-lifecycle-notifier.service';
 import { Booking } from '../bookings/entities/booking.entity';
 import type { ClearanceMetaState } from './clearance-workflow.types';
 import { metaFromBooking } from './clearance-workflow.types';
@@ -34,6 +35,7 @@ export class ClearanceWorkflowService {
     private readonly contractsRepository: ContractsRepository,
     private readonly milestoneService: ClearanceMilestoneService,
     private readonly bookingsRepository: BookingsRepository,
+    private readonly notifier: BookingLifecycleNotifierService,
   ) {}
 
   boundaryMilestone(tradeDirection: string): string {
@@ -264,6 +266,14 @@ export class ClearanceWorkflowService {
       status: 'CLEARANCE_READY',
       clearanceCurrentPhase: ContractDocPhase.GlEtPostClearance,
     } as never);
+    // Tell the customer clearance is done and operation can be requested. Load
+    // failure only skips the notice — the status change above already committed.
+    try {
+      const booking = await this.bookingsRepository.findByIdWithFiles(bookingId);
+      if (booking) this.notifier.clearanceReady(booking);
+    } catch {
+      /* notification is best-effort */
+    }
   }
 
   resolvePhase(
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 2c79ba42f..3d41e68a5 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
@@ -16,6 +16,7 @@ import { BookingsService } from '../bookings/bookings.service';
 import { contractClearanceCodes } from './contract-clearance.util';
 import { ClearanceWorkflowService } from './clearance-workflow.service';
 import { ClearanceMilestoneService } from './clearance-milestone.service';
+import { ContractNotifierService } from './contract-notifier.service';
 import { GlOperationsService } from './gl-operations.service';
 import { ClearanceMilestone } from './entities/clearance-milestone.entity';
 import { Contract } from './entities/contract.entity';
@@ -118,6 +119,7 @@ export class ContractClearanceService {
     private readonly milestoneService: ClearanceMilestoneService,
     private readonly dropdownSettingsService: DropdownSettingsService,
     private readonly glOperationsService: GlOperationsService,
+    private readonly notifier: ContractNotifierService,
   ) {}
 
   private isPhasedCustoms(contract: Contract): boolean {
@@ -543,7 +545,9 @@ export class ContractClearanceService {
       await this.workflowService.onDocumentReviewReopened(contractId);
     }
 
-    return this.contractsService.findById(contractId);
+    const updated = await this.contractsService.findById(contractId);
+    this.notifier.clearanceDocsUploadedToStaff(updated);
+    return updated;
   }
 
   private async assertRequiredInputsPresent(
@@ -674,6 +678,7 @@ export class ContractClearanceService {
         status: 'AWAITING_CLEARANCE_DOCUMENTS',
         clearanceStatus: 'AWAITING_DOCUMENTS',
       } as never);
+      this.notifier.clearanceDocumentQueried(contract, fileKey, note ?? '');
       if (cycle) {
         await this.contractsRepository.setCycleStatus(cycle.id, 'AWAITING_DOCUMENTS');
       }
@@ -1009,6 +1014,7 @@ export class ContractClearanceService {
         },
         userId,
       );
+      this.notifier.dutyAdvised(contract, dto.amount, dto.currency ?? 'ETB');
     }
 
     return this.contractsService.findById(contractId);
@@ -1045,7 +1051,9 @@ export class ContractClearanceService {
       });
     }
 
-    return this.contractsService.findById(contractId);
+    const updated = await this.contractsService.findById(contractId);
+    this.notifier.dutySlipUploadedToStaff(updated);
+    return updated;
   }
 
   async uploadTransitPermit(
@@ -1118,6 +1126,7 @@ export class ContractClearanceService {
       await this.workflowService.markReadyForBooking(contractId);
     }
 
+    this.notifier.preClearanceFinalized(contract);
     return this.contractsService.findById(contractId);
   }
 
diff --git a/apps/edr-freight-api/src/modules/contracts/contract-notifier.service.ts b/apps/edr-freight-api/src/modules/contracts/contract-notifier.service.ts
new file mode 100644
index 000000000..d4f31e570
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/contracts/contract-notifier.service.ts
@@ -0,0 +1,245 @@
+import { Injectable, Logger } from '@nestjs/common';
+import {
+  NotificationAudience,
+  NotificationType,
+  NotifyInput,
+} from '@edr/types';
+
+import { Contract } from './entities/contract.entity';
+import { NotificationsService } from '../notifications/notifications.service';
+import { NotificationInboxService } from '../notification-inbox/notification-inbox.service';
+
+/**
+ * Customer + staff notifications for the contract lifecycle. Every customer
+ * event fans out over three channels: SMS + email (direct, via
+ * {@link NotificationsService}) and a persisted in-app notification (via
+ * {@link NotificationInboxService}) that deep-links to the contract detail page.
+ * Staff events go to the backoffice inbox. All sends are fire-and-forget and
+ * never throw — a notification failure must not break a contract transition.
+ */
+@Injectable()
+export class ContractNotifierService {
+  private readonly logger = new Logger(ContractNotifierService.name);
+
+  constructor(
+    private readonly notifications: NotificationsService,
+    private readonly inbox: NotificationInboxService,
+  ) {}
+
+  private ref(c: Contract): string {
+    return `${c.reference}${c.isGovernment ? ' (gov)' : ''}`;
+  }
+
+  /** Send SMS + email to the contract's company contact; log-only on failure. */
+  private async notifyContact(
+    c: Contract,
+    message: string,
+    logLabel: string,
+  ): Promise<void> {
+    this.logger.log(`${logLabel} — ${this.ref(c)}`);
+    const phone = c.company?.contactPersonPhone ?? c.company?.phone ?? null;
+    const email = c.company?.email ?? c.company?.generalManagerEmail ?? null;
+
+    if (phone) {
+      try {
+        await this.notifications.directSend('sms', phone, message);
+      } catch (err) {
+        this.logger.warn(`SMS failed for ${this.ref(c)}: ${(err as Error).message}`);
+      }
+    }
+    if (email) {
+      try {
+        await this.notifications.directSend('email', email, message);
+      } catch (err) {
+        this.logger.warn(`Email failed for ${this.ref(c)}: ${(err as Error).message}`);
+      }
+    }
+    if (!phone && !email) {
+      this.logger.warn(`No contact on file for ${this.ref(c)} — notification not sent`);
+    }
+  }
+
+  /** Persist + push an in-app item to all portal users of the contract's company. */
+  private inApp(
+    c: Contract,
+    title: string,
+    body: string,
+    overrides: Partial<NotifyInput> = {},
+  ): void {
+    if (!c.companyId) return; // government/unlinked contracts have no portal users
+    void this.inbox.notify({
+      recipients: { companyId: c.companyId },
+      audience: NotificationAudience.PORTAL,
+      type: NotificationType.CONTRACT_STATUS,
+      title,
+      body,
+      link: `/contracts/${c.id}`,
+      data: { contractId: c.id, reference: c.reference },
+      ...overrides,
+    });
+  }
+
+  /** Persist + push an in-app item to every backoffice staff user. */
+  private inAppStaff(
+    c: Contract,
+    title: string,
+    body: string,
+    overrides: Partial<NotifyInput> = {},
+  ): void {
+    void this.inbox.notify({
+      recipients: { allBackoffice: true },
+      audience: NotificationAudience.BACKOFFICE,
+      type: NotificationType.REQUEST_SUBMITTED,
+      title,
+      body,
+      link: `/dashboard/contract-requests/${c.id}`,
+      data: { contractId: c.id, reference: c.reference },
+      ...overrides,
+    });
+  }
+
+  // ── Customer-facing lifecycle events ───────────────────────────────────────
+
+  /** Line staff accepted intake → contract is under approval. */
+  accepted(c: Contract): void {
+    const msg =
+      `Your contract ${c.reference} has been accepted and is now under approval. ` +
+      `We will notify you once it is approved.`;
+    void this.notifyContact(c, msg, 'ACCEPTED');
+    this.inApp(c, 'Contract accepted', msg);
+  }
+
+  /** All approval steps complete → contract approved. */
+  approved(c: Contract): void {
+    const msg =
+      `Your contract ${c.reference} has been approved. ` +
+      `The final document will be prepared for signing.`;
+    void this.notifyContact(c, msg, 'APPROVED');
+    this.inApp(c, 'Contract approved', msg);
+  }
+
+  /** Fully executed (all parties signed) → contract active, customer can book. */
+  signedActive(c: Contract): void {
+    const msg =
+      `Your contract ${c.reference} has been signed and is now active. ` +
+      `You can start booking shipments from the portal.`;
+    void this.notifyContact(c, msg, 'SIGNED / ACTIVE');
+    this.inApp(c, 'Contract active', msg);
+  }
+
+  /** Staff rejected the contract. */
+  rejected(c: Contract, reason: string): void {
+    const msg =
+      `Your contract ${c.reference} was rejected. Reason: ${reason}. ` +
+      `Please contact us for details.`;
+    void this.notifyContact(c, msg, 'REJECTED');
+    this.inApp(c, 'Contract rejected', msg);
+  }
+
+  /** Staff requested changes before approval. */
+  changesRequested(c: Contract, note: string): void {
+    const msg =
+      `Changes were requested on your contract ${c.reference}: ${note}. ` +
+      `Please update and resubmit from the portal.`;
+    void this.notifyContact(c, msg, 'CHANGES REQUESTED');
+    this.inApp(c, 'Contract changes requested', msg);
+  }
+
+  // ── Clearance milestones needing customer action ──────────────────────────
+
+  /** GL advised duty & tax on the contract cycle — customer pays + uploads slip. */
+  dutyAdvised(c: Contract, amount: number, currency: string): void {
+    const msg =
+      `Duty & tax of ${amount} ${currency} has been advised for contract ${c.reference}. ` +
+      `Please pay and upload the payment slip from the portal.`;
+    void this.notifyContact(c, msg, 'DUTY ADVISED');
+    this.inApp(c, 'Duty & tax advised', msg, {
+      type: NotificationType.INVOICE_ISSUED,
+      link: `/contracts/${c.id}/clearance`,
+    });
+  }
+
+  /** A clearance document was queried — customer must re-upload it. */
+  clearanceDocumentQueried(c: Contract, fileKey: string, note: string): void {
+    const msg =
+      `A clearance document on contract ${c.reference} needs attention: "${fileKey}". ` +
+      `${note}. Please re-upload from the portal.`;
+    void this.notifyContact(c, msg, 'CLEARANCE DOC QUERIED');
+    this.inApp(c, 'Clearance document queried', msg, {
+      type: NotificationType.DOCUMENT_ACTION,
+      link: `/contracts/${c.id}/clearance`,
+    });
+  }
+
+  /** Import pre-clearance finalized — the process moves to GL Djibouti collection. */
+  preClearanceFinalized(c: Contract): void {
+    const msg =
+      `Pre-clearance for contract ${c.reference} is complete. ` +
+      `Your shipment is proceeding to document collection in Djibouti.`;
+    void this.notifyContact(c, msg, 'PRE-CLEARANCE FINALIZED');
+    this.inApp(c, 'Pre-clearance complete', msg, {
+      type: NotificationType.CLEARANCE_DECISION,
+      link: `/contracts/${c.id}/clearance`,
+    });
+  }
+
+  // ── Staff-facing (backoffice inbox) ────────────────────────────────────────
+
+  /** Customer submitted a contract for review. */
+  submittedToStaff(c: Contract): void {
+    this.inAppStaff(
+      c,
+      'New contract submitted',
+      `Contract ${this.ref(c)} was submitted and is awaiting intake review.`,
+    );
+  }
+
+  /** Customer signed the contract — staff counter-sign is next. */
+  customerSignedToStaff(c: Contract): void {
+    this.inAppStaff(
+      c,
+      'Customer signed contract',
+      `Contract ${this.ref(c)} was signed by the customer and awaits the EDR counter-signature.`,
+      { link: `/dashboard/contract-requests/${c.id}/view` },
+    );
+  }
+
+  /** Customer uploaded clearance documents — GL review is next. */
+  clearanceDocsUploadedToStaff(c: Contract): void {
+    this.inAppStaff(
+      c,
+      'Clearance documents uploaded',
+      `Customer uploaded clearance documents for contract ${this.ref(c)} — review them in the clearance queue.`,
+      {
+        type: NotificationType.CLEARANCE_REVIEW,
+        link: `/dashboard/contracts/clearance/${c.id}`,
+      },
+    );
+  }
+
+  /** Customer uploaded the duty/tax payment slip — GL verifies it. */
+  dutySlipUploadedToStaff(c: Contract): void {
+    this.inAppStaff(
+      c,
+      'Duty slip uploaded',
+      `Customer uploaded the duty & tax payment slip for contract ${this.ref(c)}.`,
+      {
+        type: NotificationType.PAYMENT_RECEIVED,
+        link: `/dashboard/contracts/clearance/${c.id}`,
+      },
+    );
+  }
+
+  /** Customer filed a shipment request under a GENERAL customs contract. */
+  shipmentRequestedToStaff(c: Contract, requestId: string, requestRef: string): void {
+    this.inAppStaff(
+      c,
+      'New shipment request',
+      `Shipment request ${requestRef} was filed under contract ${this.ref(c)} and awaits GL review.`,
+      {
+        link: `/dashboard/shipment-requests/${requestId}`,
+        data: { contractId: c.id, requestId, reference: requestRef },
+      },
+    );
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/contracts/contract-transition.service.ts b/apps/edr-freight-api/src/modules/contracts/contract-transition.service.ts
index e31392666..9f12b937d 100644
--- a/apps/edr-freight-api/src/modules/contracts/contract-transition.service.ts
+++ b/apps/edr-freight-api/src/modules/contracts/contract-transition.service.ts
@@ -22,6 +22,7 @@ import { FilesService } from '../files/files.service';
 import { SignaturesService } from '../signatures/signatures.service';
 import { OtpService } from '../otp/otp.service';
 import { ContractPricingService } from './contract-pricing.service';
+import { ContractNotifierService } from './contract-notifier.service';
 import { ClearanceMilestoneService } from './clearance-milestone.service';
 import { ContractsRepository } from './contracts.repository';
 import { ContractsService } from './contracts.service';
@@ -66,6 +67,7 @@ export class ContractTransitionService {
     private readonly pdfService: ContractPdfService,
     private readonly minioService: MinioService,
     private readonly otpService: OtpService,
+    private readonly notifier: ContractNotifierService,
   ) {}
 
   /** Customer submits the contract for approval → SUBMITTED; freeze unit rates. */
@@ -79,7 +81,9 @@ export class ContractTransitionService {
     await this.contractsRepository.update(contractId, {
       status: 'SUBMITTED',
     } as never);
-    return this.contractsService.findById(contractId);
+    const updated = await this.contractsService.findById(contractId);
+    this.notifier.submittedToStaff(updated);
+    return updated;
   }
 
   /** Confirm a price change before submit (mirrors booking confirm-submit). */
@@ -93,7 +97,9 @@ export class ContractTransitionService {
     await this.contractsRepository.update(contractId, {
       status: 'SUBMITTED',
     } as never);
-    return this.contractsService.findById(contractId);
+    const updated = await this.contractsService.findById(contractId);
+    this.notifier.submittedToStaff(updated);
+    return updated;
   }
 
   /**
@@ -130,7 +136,9 @@ export class ContractTransitionService {
       contractValidFrom: validFrom,
       contractValidUntil: validUntil,
     } as never);
-    return this.contractsService.findById(contractId);
+    const updated = await this.contractsService.findById(contractId);
+    this.notifier.accepted(updated);
+    return updated;
   }
 
   /**
@@ -218,7 +226,9 @@ export class ContractTransitionService {
     await this.contractsRepository.update(contractId, {
       status: 'CHANGES_REQUESTED',
     } as never);
-    return this.contractsService.findById(contractId);
+    const updated = await this.contractsService.findById(contractId);
+    this.notifier.changesRequested(updated, note);
+    return updated;
   }
 
   async reject(contractId: string, reason: string, actorId: string): Promise<Contract> {
@@ -235,7 +245,47 @@ export class ContractTransitionService {
     await this.contractsRepository.update(contractId, {
       status: 'REJECTED',
     } as never);
-    return this.contractsService.findById(contractId);
+    const updated = await this.contractsService.findById(contractId);
+    this.notifier.rejected(updated, reason);
+    return updated;
+  }
+
+  /**
+   * Reject one approval step (line staff / director / CEO). The rejecting
+   * approver must supply a reason. A rejection is terminal: the whole contract
+   * moves to REJECTED and the customer must create a new one — there is no
+   * resubmit of the same contract. The reason is recorded both on the step and
+   * as a REJECTION review note so it is visible to the customer and the rest of
+   * the approval chain.
+   */
+  async rejectStep(
+    contractId: string,
+    stepId: string,
+    actorId: string,
+    reason: string,
+  ): Promise<Contract> {
+    const contract = await this.contractsService.findById(contractId);
+    assertContractStatus(contract, ['PENDING_APPROVAL', 'APPROVED_PENDING_SIGNATURE']);
+
+    const step = await this.contractsRepository.findApprovalStepById(contractId, stepId);
+    if (!step) throw new BadRequestException('Approval step not found');
+
+    await this.contractsRepository.completeApprovalStep(step.id, actorId, 'REJECTED', reason);
+
+    await this.contractsRepository.createReviewNote(
+      contractId,
+      reason,
+      'REJECTION',
+      actorId,
+      'STAFF',
+    );
+
+    await this.contractsRepository.update(contractId, {
+      status: 'REJECTED',
+    } as never);
+    const updated = await this.contractsService.findById(contractId);
+    this.notifier.rejected(updated, reason);
+    return updated;
   }
 
   /** Approve one approval step in sequence; → APPROVED when all complete. */
@@ -297,7 +347,11 @@ export class ContractTransitionService {
     if (Object.keys(updates).length > 0) {
       await this.contractsRepository.update(contractId, updates as never);
     }
-    return this.contractsService.findById(contractId);
+    const updated = await this.contractsService.findById(contractId);
+    if (allDone) {
+      this.notifier.approved(updated);
+    }
+    return updated;
   }
 
   /**
@@ -535,7 +589,9 @@ export class ContractTransitionService {
         customerSignedAt: new Date(),
       } as never);
       await this.regenerateContractPdf(contractId, contract.reference);
-      return this.contractsService.findById(contractId);
+      const updated = await this.contractsService.findById(contractId);
+      this.notifier.customerSignedToStaff(updated);
+      return updated;
     }
 
     return this.counterSign(contractId, dto, options);
@@ -605,7 +661,9 @@ export class ContractTransitionService {
 
     await this.contractsRepository.update(contractId, updates as never);
     await this.regenerateContractPdf(contractId, contract.reference);
-    return this.contractsService.findById(contractId);
+    const updated = await this.contractsService.findById(contractId);
+    this.notifier.signedActive(updated);
+    return updated;
   }
 
   /** Customer requests renewal → RENEWAL_DRAFT linked via renewalOfId. */
diff --git a/apps/edr-freight-api/src/modules/contracts/contracts.controller.ts b/apps/edr-freight-api/src/modules/contracts/contracts.controller.ts
index 8591a54d8..4ea7634b6 100644
--- a/apps/edr-freight-api/src/modules/contracts/contracts.controller.ts
+++ b/apps/edr-freight-api/src/modules/contracts/contracts.controller.ts
@@ -60,6 +60,7 @@ import { AcceptContractDto } from './dto/accept-contract.dto';
 import {
   ApproveStepDto,
   RejectContractDto,
+  RejectStepDto,
   RequestChangesDto,
 } from './dto/approve-step.dto';
 import { SignContractDto } from './dto/sign-contract.dto';
@@ -390,6 +391,27 @@ export class ContractsController {
     );
   }
 
+  @Post(':id/approval-steps/:stepId/reject')
+  @BookingStaff([
+    FREIGHT_PERMS.contracts.approveLineStaff,
+    FREIGHT_PERMS.contracts.approveDirector,
+    FREIGHT_PERMS.contracts.approveCeo,
+  ])
+  @ApiOperation({ summary: 'Reject one approval step (terminal → REJECTED)' })
+  rejectStep(
+    @Param('id', ParseUUIDPipe) id: string,
+    @Param('stepId', ParseUUIDPipe) stepId: string,
+    @Body() dto: RejectStepDto,
+    @CurrentUser() user: AuthUserPayload,
+  ) {
+    return this.transitionService.rejectStep(
+      id,
+      stepId,
+      resolveAuthUserId(user),
+      dto.reason,
+    );
+  }
+
   @Post(':id/contract/generate')
   @BookingStaff(FREIGHT_PERMS.contracts.generateContract)
   @ApiOperation({ summary: 'Generate contract document → CONTRACT_READY' })
diff --git a/apps/edr-freight-api/src/modules/contracts/contracts.module.ts b/apps/edr-freight-api/src/modules/contracts/contracts.module.ts
index a9f9dcf5d..33a547a9f 100644
--- a/apps/edr-freight-api/src/modules/contracts/contracts.module.ts
+++ b/apps/edr-freight-api/src/modules/contracts/contracts.module.ts
@@ -12,6 +12,8 @@ import { FileUploadSettingsModule } from '../file-upload-settings/file-upload-se
 import { DropdownSettingsModule } from '../dropdown-settings/dropdown-settings.module';
 import { SignaturesModule } from '../signatures/signatures.module';
 import { OtpModule } from '../otp/otp.module';
+import { NotificationsModule } from '../notifications/notifications.module';
+import { NotificationInboxModule } from '../notification-inbox/notification-inbox.module';
 import { BookingsModule } from '../bookings/bookings.module';
 import { TrainSchedulingModule } from '../train-scheduling/train-scheduling.module';
 
@@ -19,6 +21,7 @@ import { ContractsController } from './contracts.controller';
 import { ContractsService } from './contracts.service';
 import { ContractsRepository } from './contracts.repository';
 import { ContractPricingService } from './contract-pricing.service';
+import { ContractNotifierService } from './contract-notifier.service';
 import { ContractTransitionService } from './contract-transition.service';
 import { ContractClearanceService } from './contract-clearance.service';
 import { BookingClearanceService } from './booking-clearance.service';
@@ -75,6 +78,8 @@ import { ContractDocumentViewModelBuilder } from '../../contracts/contract-docum
     MinioModule,
     SignaturesModule,
     OtpModule,
+    NotificationsModule,
+    NotificationInboxModule,
     CompaniesModule,
     // BookingsModule provides BookingsRepository/BookingPricingService used by the
     // contract PDF builders (they read a Booking today — see docs/new-doc.md §3.3).
@@ -94,6 +99,7 @@ import { ContractDocumentViewModelBuilder } from '../../contracts/contract-docum
     ContractsService,
     ContractsRepository,
     ContractPricingService,
+    ContractNotifierService,
     ContractTransitionService,
     ContractClearanceService,
     ClearanceWorkflowService,
diff --git a/apps/edr-freight-api/src/modules/contracts/contracts.service.ts b/apps/edr-freight-api/src/modules/contracts/contracts.service.ts
index 0e81f8dca..aaf064bff 100644
--- a/apps/edr-freight-api/src/modules/contracts/contracts.service.ts
+++ b/apps/edr-freight-api/src/modules/contracts/contracts.service.ts
@@ -567,6 +567,21 @@ export class ContractsService {
       );
     }
 
+    // Surface the staff "request changes" note so the portal can show the
+    // customer what to fix. Degrade to null on lookup failure — a missing note
+    // must never 500 a contract fetch.
+    if (contract.status === 'CHANGES_REQUESTED') {
+      try {
+        const note = await this.contractsRepository.findLatestReviewNote(
+          contract.id,
+          'CHANGES_REQUESTED',
+        );
+        contract.latestChangeRequestNote = note?.body ?? null;
+      } catch {
+        contract.latestChangeRequestNote = null;
+      }
+    }
+
     return contract;
   }
 
diff --git a/apps/edr-freight-api/src/modules/contracts/entities/contract.entity.ts b/apps/edr-freight-api/src/modules/contracts/entities/contract.entity.ts
index 07d08d3c0..0b0fab41b 100644
--- a/apps/edr-freight-api/src/modules/contracts/entities/contract.entity.ts
+++ b/apps/edr-freight-api/src/modules/contracts/entities/contract.entity.ts
@@ -260,4 +260,11 @@ export class Contract extends BaseEntity {
    * ContractsRepository.attachClearancePhases for list responses. Not a column.
    */
   clearancePhase?: string | null;
+
+  /**
+   * Body of the most recent CHANGES_REQUESTED review note, attached by
+   * ContractsService.findById so the portal can show the customer what staff
+   * asked them to fix. Lives in contract_review_notes, not a column here.
+   */
+  latestChangeRequestNote?: string | null;
 }
diff --git a/apps/edr-freight-api/src/modules/contracts/gl-operations.service.ts b/apps/edr-freight-api/src/modules/contracts/gl-operations.service.ts
index 72e2d14d9..181d8b688 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
@@ -11,6 +11,7 @@ import { BillingService } from '../billing/billing.service';
 import { InvoiceLine } from '../billing/entities/invoice-line.entity';
 import { FilesService } from '../files/files.service';
 import { Booking } from '../bookings/entities/booking.entity';
+import { BookingLifecycleNotifierService } from '../bookings/booking-lifecycle-notifier.service';
 import { TrainSchedule } from '../train-schedules/entities/train-schedule.entity';
 import { ImportDjiboutiOperation } from '../train-scheduling/entities/import-djibouti-operation.entity';
 import {
@@ -53,6 +54,7 @@ export class GlOperationsService {
     private readonly filesService: FilesService,
     private readonly milestoneService: ClearanceMilestoneService,
     private readonly billingService: BillingService,
+    private readonly notifier: BookingLifecycleNotifierService,
   ) {}
 
   private get bookings() {
@@ -64,7 +66,11 @@ export class GlOperationsService {
   }
 
   private async getBooking(bookingId: string): Promise<Booking> {
-    const booking = await this.bookings.findOne({ where: { id: bookingId } });
+    // company is loaded so customer notifications have a phone/email to target.
+    const booking = await this.bookings.findOne({
+      where: { id: bookingId },
+      relations: { company: true },
+    });
     if (!booking) throw new NotFoundException(`Booking ${bookingId} not found`);
     return booking;
   }
@@ -447,6 +453,7 @@ export class GlOperationsService {
     void userId;
     const summary = await this.finalInvoiceSummary(bookingId);
     if (!summary) throw new NotFoundException('Final invoice could not be created.');
+    this.notifier.finalInvoiceCreated(booking, input.amount, input.currency);
     return summary;
   }
 
@@ -455,7 +462,7 @@ export class GlOperationsService {
     bookingId: string,
     file: Express.Multer.File,
   ): Promise<{ uploaded: boolean }> {
-    await this.getBooking(bookingId);
+    const booking = await this.getBooking(bookingId);
     if (!file) throw new BadRequestException('No payment slip uploaded');
 
     const invoice = await this.billingService.findInvoice(
@@ -482,6 +489,7 @@ export class GlOperationsService {
       code: 'final_invoice_slip',
       file,
     });
+    this.notifier.dutySlipUploadedToStaff(booking, 'final');
     return { uploaded: true };
   }
 
@@ -490,7 +498,7 @@ export class GlOperationsService {
     bookingId: string,
     userId?: string,
   ): Promise<Freight.ClearanceFinalInvoiceSummary> {
-    await this.getBooking(bookingId);
+    const booking = await this.getBooking(bookingId);
     const invoice = await this.billingService.findInvoice(
       Freight.InvoiceSource.Booking,
       bookingId,
@@ -507,6 +515,7 @@ export class GlOperationsService {
         );
       }
       await this.billingService.markInvoiceAsPaid(invoice.id);
+      this.notifier.finalInvoicePaid(booking);
     }
 
     void userId;
@@ -575,6 +584,7 @@ export class GlOperationsService {
       },
       userId,
     );
+    this.notifier.secondDutyAdvised(booking, input.amount, input.currency ?? 'ETB');
     return { advised: true, skipped: false };
   }
 
@@ -605,6 +615,7 @@ export class GlOperationsService {
       booking.tradeDirection ?? 'IMPORT',
     );
     await this.milestoneService.completeForBooking(bookingId, 'SECOND_DUTY_PAID');
+    this.notifier.dutySlipUploadedToStaff(booking, 'second');
     return { milestoneCompleted: true };
   }
 
diff --git a/apps/edr-freight-api/src/modules/drivers/drivers.controller.ts b/apps/edr-freight-api/src/modules/drivers/drivers.controller.ts
index b4da558e2..d86ee823a 100644
--- a/apps/edr-freight-api/src/modules/drivers/drivers.controller.ts
+++ b/apps/edr-freight-api/src/modules/drivers/drivers.controller.ts
@@ -8,9 +8,13 @@ import {
   Body,
   Query,
   ParseUUIDPipe,
+  UploadedFiles,
+  UseInterceptors,
 } from '@nestjs/common';
-import { ApiBearerAuth, ApiOperation, ApiTags } from '@nestjs/swagger';
-import { FleetManage, FleetView } from '../../common/booking-guards';
+import { AnyFilesInterceptor } from '@nestjs/platform-express';
+import { ApiBearerAuth, ApiConsumes, ApiOperation, ApiTags } from '@nestjs/swagger';
+import { BookingStaff } from '../../common/booking-guards';
+import { FREIGHT_PERMS } from '../../seed/freight-permissions.registry';
 import { DriversService } from './drivers.service';
 import { CreateDriverDto } from './dto/create-driver.dto';
 import { UpdateDriverDto } from './dto/update-driver.dto';
@@ -19,7 +23,7 @@ import { FleetHistoryService } from '../fleet-history/fleet-history.service';
 @ApiTags('drivers')
 @ApiBearerAuth()
 @Controller('drivers')
-@FleetView()
+@BookingStaff(FREIGHT_PERMS.drivers.view)
 export class DriversController {
   constructor(
     private readonly driversService: DriversService,
@@ -27,7 +31,7 @@ export class DriversController {
   ) {}
 
   @Post()
-  @FleetManage()
+  @BookingStaff(FREIGHT_PERMS.drivers.create)
   @ApiOperation({ summary: 'Create a new driver' })
   create(@Body() createDriverDto: CreateDriverDto) {
     return this.driversService.create(createDriverDto);
@@ -65,8 +69,33 @@ export class DriversController {
     return this.fleetHistory.getDriverHistory(id);
   }
 
+  @Post(':id/documents')
+  @BookingStaff(FREIGHT_PERMS.drivers.update)
+  @ApiConsumes('multipart/form-data')
+  @UseInterceptors(AnyFilesInterceptor())
+  @ApiOperation({ summary: 'Upload driver documents (code driver_docs)' })
+  uploadDocuments(
+    @Param('id', ParseUUIDPipe) id: string,
+    @UploadedFiles() files: Express.Multer.File[],
+  ) {
+    return this.driversService.uploadDocuments(id, files ?? []);
+  }
+
+  @Get(':id/documents')
+  @ApiOperation({ summary: "List a driver's documents" })
+  listDocuments(@Param('id', ParseUUIDPipe) id: string) {
+    return this.driversService.listDocuments(id);
+  }
+
+  @Delete(':id/documents/:fileId')
+  @BookingStaff(FREIGHT_PERMS.drivers.update)
+  @ApiOperation({ summary: 'Delete a driver document' })
+  removeDocument(@Param('fileId', ParseUUIDPipe) fileId: string) {
+    return this.driversService.removeDocument(fileId);
+  }
+
   @Patch(':id')
-  @FleetManage()
+  @BookingStaff(FREIGHT_PERMS.drivers.update)
   @ApiOperation({ summary: 'Update a driver' })
   update(
     @Param('id', ParseUUIDPipe) id: string,
@@ -76,7 +105,7 @@ export class DriversController {
   }
 
   @Delete(':id')
-  @FleetManage()
+  @BookingStaff(FREIGHT_PERMS.drivers.delete)
   @ApiOperation({ summary: 'Delete a driver' })
   remove(@Param('id', ParseUUIDPipe) id: string) {
     return this.driversService.remove(id);
diff --git a/apps/edr-freight-api/src/modules/drivers/drivers.module.ts b/apps/edr-freight-api/src/modules/drivers/drivers.module.ts
index 9e685dcd6..1a6e29e15 100644
--- a/apps/edr-freight-api/src/modules/drivers/drivers.module.ts
+++ b/apps/edr-freight-api/src/modules/drivers/drivers.module.ts
@@ -3,9 +3,10 @@ import { TypeOrmModule } from '@nestjs/typeorm';
 import { Driver } from './entities/driver.entity';
 import { DriversService } from './drivers.service';
 import { DriversController } from './drivers.controller';
+import { FilesModule } from '../files/files.module';
 
 @Module({
-  imports: [TypeOrmModule.forFeature([Driver])],
+  imports: [TypeOrmModule.forFeature([Driver]), FilesModule],
   providers: [DriversService],
   controllers: [DriversController],
   exports: [DriversService],
diff --git a/apps/edr-freight-api/src/modules/drivers/drivers.service.ts b/apps/edr-freight-api/src/modules/drivers/drivers.service.ts
index 6e7c1f69c..e4fa992e8 100644
--- a/apps/edr-freight-api/src/modules/drivers/drivers.service.ts
+++ b/apps/edr-freight-api/src/modules/drivers/drivers.service.ts
@@ -6,6 +6,11 @@ import { UpdateDriverDto } from './dto/update-driver.dto';
 import { Driver, DriverStatus } from './entities/driver.entity';
 import { FleetHistoryService } from '../fleet-history/fleet-history.service';
 import { FleetEventType } from '../fleet-history/entities/fleet-event.entity';
+import { FilesService } from '../files/files.service';
+
+/** Resource + code the driver-documents upload area is stored under. */
+const DRIVER_DOCS_RESOURCE = 'driver';
+const DRIVER_DOCS_CODE = 'driver_docs';
 
 @Injectable()
 export class DriversService {
@@ -13,8 +18,37 @@ export class DriversService {
     @InjectRepository(Driver)
     private readonly driverRepo: Repository<Driver>,
     private readonly history: FleetHistoryService,
+    private readonly filesService: FilesService,
   ) {}
 
+  /** Upload one or more driver documents (code "driver_docs"). */
+  async uploadDocuments(driverId: string, files: Express.Multer.File[]) {
+    const driver = await this.driverRepo.findOneBy({ id: driverId });
+    if (!driver) throw new NotFoundException(`Driver ${driverId} not found`);
+    if (!files?.length) throw new BadRequestException('No files provided');
+    return Promise.all(
+      files.map((file) =>
+        this.filesService.upload({
+          resourceId: driverId,
+          resource: DRIVER_DOCS_RESOURCE,
+          code: DRIVER_DOCS_CODE,
+          file,
+        }),
+      ),
+    );
+  }
+
+  /** List a driver's uploaded documents (code "driver_docs"). */
+  async listDocuments(driverId: string) {
+    const all = await this.filesService.findByResource(driverId, DRIVER_DOCS_RESOURCE);
+    return all.filter((f) => f.code === DRIVER_DOCS_CODE);
+  }
+
+  /** Delete a single driver document by file id. */
+  async removeDocument(fileId: string): Promise<void> {
+    await this.filesService.remove(fileId);
+  }
+
   async create(dto: CreateDriverDto): Promise<Driver> {
     if (dto.faydaVerified !== true) {
       throw new BadRequestException(
diff --git a/apps/edr-freight-api/src/modules/files/files.service.ts b/apps/edr-freight-api/src/modules/files/files.service.ts
index a5c641dd7..4966d7ff9 100644
--- a/apps/edr-freight-api/src/modules/files/files.service.ts
+++ b/apps/edr-freight-api/src/modules/files/files.service.ts
@@ -119,6 +119,11 @@ export class FilesService {
     return record;
   }
 
+  /** Soft-delete a stored file row by id (object bytes are left in MinIO). */
+  async remove(id: string): Promise<void> {
+    await this.filesRepository.softDelete(id);
+  }
+
   findByResource(resourceId: string, resource: string): Promise<FileRecord[]> {
     return this.filesRepository.findByResource(resourceId, resource);
   }
diff --git a/apps/edr-freight-api/src/modules/first-mile/first-mile-invoice.service.ts b/apps/edr-freight-api/src/modules/first-mile/first-mile-invoice.service.ts
index f4935a87b..aa618cdb7 100644
--- a/apps/edr-freight-api/src/modules/first-mile/first-mile-invoice.service.ts
+++ b/apps/edr-freight-api/src/modules/first-mile/first-mile-invoice.service.ts
@@ -1,4 +1,4 @@
-import { Injectable, Logger } from '@nestjs/common';
+import { BadRequestException, Injectable, Logger } from '@nestjs/common';
 import { OnEvent } from '@nestjs/event-emitter';
 import { Freight } from '@edr/types';
 
@@ -66,13 +66,37 @@ export class FirstMileInvoiceService {
       return null;
     }
 
+    // Reject mixed-currency truck sets — a single invoice can only be one
+    // currency, and amounts across currencies can't be summed.
+    const billableTrucks = (record.vehicleAssignments ?? []).filter(
+      (a) => Number(a.distanceKm) > 0,
+    );
+    const currencies = [
+      ...new Set(
+        billableTrucks
+          .map((a) => (a.vehicle as { currency?: string } | undefined)?.currency)
+          .filter((c): c is string => Boolean(c)),
+      ),
+    ];
+    if (currencies.length > 1) {
+      throw new BadRequestException(
+        `Cannot generate invoice: assigned trucks use mixed currencies (${currencies.join(', ')}). Assign trucks that share one currency.`,
+      );
+    }
+
+    // Currency follows the truck (price/km is quoted per vehicle), falling back
+    // to the booking's currency, then ETB.
+    const truckCurrency =
+      (record.vehicle as { currency?: string } | undefined)?.currency ||
+      (record.vehicleAssignments?.[0]?.vehicle as { currency?: string } | undefined)?.currency;
+
     return this.billing.generateInvoice({
       source: 'first_mile' as Freight.InvoiceSource,
       sourceId: record.id,
       type: 'DELIVERY_FEE',
       companyId: fm.booking!.companyId,
       companyProfileId: fm.booking!.companyProfileId || '',
-      currency: fm.booking!.paymentCurrency || 'ETB',
+      currency: truckCurrency || fm.booking!.paymentCurrency || 'ETB',
       lines: [
         {
           chargeType: 'DELIVERY',
diff --git a/apps/edr-freight-api/src/modules/first-mile/first-mile.controller.ts b/apps/edr-freight-api/src/modules/first-mile/first-mile.controller.ts
index e43fbcae8..952f924d6 100644
--- a/apps/edr-freight-api/src/modules/first-mile/first-mile.controller.ts
+++ b/apps/edr-freight-api/src/modules/first-mile/first-mile.controller.ts
@@ -14,7 +14,8 @@ import {
 } from '@nestjs/common';
 import { ApiBearerAuth, ApiOperation, ApiTags } from '@nestjs/swagger';
 
-import { TrainSchedulingManage, TrainSchedulingView } from '../../common/booking-guards';
+import { BookingStaff } from '../../common/booking-guards';
+import { FREIGHT_PERMS } from '../../seed/freight-permissions.registry';
 
 import { CreateFirstMileDto } from './dto/create-first-mile.dto';
 import { UpdateFirstMileDto } from './dto/update-first-mile.dto';
@@ -27,7 +28,7 @@ import { FirstMileInvoiceService } from './first-mile-invoice.service';
 @ApiTags('first-mile')
 @ApiBearerAuth()
 @Controller('first-mile')
-@TrainSchedulingView()
+@BookingStaff(FREIGHT_PERMS.firstMile.view)
 export class FirstMileController {
   constructor(
     private readonly firstMileService: FirstMileService,
@@ -63,27 +64,28 @@ export class FirstMileController {
   }
 
   @Get('acceptitem/:id')
+  @BookingStaff(FREIGHT_PERMS.firstMile.accept)
   @ApiOperation({ summary: 'Get a first-mile accep by ID' })
   acceptItem(@Param('id', ParseUUIDPipe) id: string) {
     return this.firstMileService.acceptBooking(id);
   }
 
   @Post('accept/:reference')
-  @TrainSchedulingManage()
+  @BookingStaff(FREIGHT_PERMS.firstMile.accept)
   @ApiOperation({ summary: 'Accept a paid booking and create a first-mile leg' })
   acceptBooking(@Param('reference') reference: string) {
     return this.firstMileService.acceptBookingByReference(reference);
   }
 
   @Post()
-  @TrainSchedulingManage()
+  @BookingStaff(FREIGHT_PERMS.firstMile.create)
   @ApiOperation({ summary: 'Create a first-mile leg' })
   create(@Body() dto: CreateFirstMileDto) {
     return this.firstMileService.create(dto);
   }
 
   @Patch(':id')
-  @TrainSchedulingManage()
+  @BookingStaff(FREIGHT_PERMS.firstMile.update)
   @ApiOperation({ summary: 'Update a first-mile leg' })
   async update(@Param('id', ParseUUIDPipe) id: string, @Body() dto: UpdateFirstMileDto) {
     // No invoice side-effects — invoices are generated only via the explicit
@@ -92,7 +94,7 @@ export class FirstMileController {
   }
 
   @Post(':id/invoice')
-  @TrainSchedulingManage()
+  @BookingStaff(FREIGHT_PERMS.firstMile.generateInvoice)
   @ApiOperation({ summary: 'Generate the first-mile delivery-fee invoice' })
   async generateInvoice(@Param('id', ParseUUIDPipe) id: string) {
     const record = await this.firstMileService.findById(id);
@@ -106,7 +108,7 @@ export class FirstMileController {
   }
 
   @Post(':id/vehicles')
-  @TrainSchedulingManage()
+  @BookingStaff(FREIGHT_PERMS.firstMile.assignVehicles)
   @ApiOperation({ summary: 'Set the vehicles assigned to a first-mile pickup (multi-truck)' })
   async setVehicles(
     @Param('id', ParseUUIDPipe) id: string,
@@ -116,7 +118,7 @@ export class FirstMileController {
   }
 
   @Post(':id/distances')
-  @TrainSchedulingManage()
+  @BookingStaff(FREIGHT_PERMS.firstMile.setDistances)
   @ApiOperation({ summary: 'Set per-vehicle actual distances (does not generate an invoice)' })
   async setDistances(
     @Param('id', ParseUUIDPipe) id: string,
@@ -126,7 +128,7 @@ export class FirstMileController {
   }
 
   @Delete(':id')
-  @TrainSchedulingManage()
+  @BookingStaff(FREIGHT_PERMS.firstMile.delete)
   @HttpCode(HttpStatus.NO_CONTENT)
   @ApiOperation({ summary: 'Soft-delete a first-mile leg' })
   remove(@Param('id', ParseUUIDPipe) id: string) {
diff --git a/apps/edr-freight-api/src/modules/first-mile/first-mile.service.ts b/apps/edr-freight-api/src/modules/first-mile/first-mile.service.ts
index 5c12d94ee..00dbb80cc 100644
--- a/apps/edr-freight-api/src/modules/first-mile/first-mile.service.ts
+++ b/apps/edr-freight-api/src/modules/first-mile/first-mile.service.ts
@@ -640,10 +640,24 @@ export class FirstMileService {
         { distanceKm: d.distanceKm },
       );
     }
-    const total = distances.reduce((s, d) => s + (Number(d.distanceKm) || 0), 0);
+
+    // Billing is per truck: amount = Σ (truck distance × truck price/km). The
+    // per-vehicle rate + currency live on the vehicle, so we ignore the legacy
+    // FIRST_MILE flat rate and any client-sent amount. `remainingPayment` param
+    // kept only for signature back-compat.
+    void remainingPayment;
+    const assignments = await this.dataSource.manager.find(FirstMileVehicleAssignment, {
+      where: { firstMileId: id },
+      relations: { vehicle: true },
+    });
+    const total = assignments.reduce((s, a) => s + (Number(a.distanceKm) || 0), 0);
+    const amount = assignments.reduce(
+      (s, a) => s + (Number(a.distanceKm) || 0) * (Number(a.vehicle?.pricePerKm) || 0),
+      0,
+    );
     await this.firstMileRepository.update(id, {
       exactKm: total,
-      ...(remainingPayment != null ? { remainingPayment } : {}),
+      remainingPayment: amount,
     } as any);
     return this.findById(id);
   }
diff --git a/apps/edr-freight-api/src/modules/fuel/fuel.controller.ts b/apps/edr-freight-api/src/modules/fuel/fuel.controller.ts
index 62207bfa1..2e5cca199 100644
--- a/apps/edr-freight-api/src/modules/fuel/fuel.controller.ts
+++ b/apps/edr-freight-api/src/modules/fuel/fuel.controller.ts
@@ -1,26 +1,40 @@
 import { Controller, Post, Get, Body, Param, Query } from '@nestjs/common';
-import { ApiTags, ApiOperation } from '@nestjs/swagger';
+import { ApiBearerAuth, ApiTags, ApiOperation } from '@nestjs/swagger';
+import { BookingStaff } from '../../common/booking-guards';
+import { FREIGHT_PERMS } from '../../seed/freight-permissions.registry';
 import { FuelService } from './fuel.service';
 import { CreateFuelPurchaseDto } from './dto/create-fuel-purchase.dto';
 
+// Stats feed the Financial Reports + Fleet Dashboard pages, so their viewers may
+// read them without full fuel access.
+const FUEL_STATS_PERMS = [
+  FREIGHT_PERMS.fuel.view,
+  FREIGHT_PERMS.fleetReports.view,
+  FREIGHT_PERMS.fleetDashboard.view,
+];
+
 @ApiTags('Fuel Management')
+@ApiBearerAuth()
 @Controller('fuel')
 export class FuelController {
   constructor(private readonly fuelService: FuelService) {}
 
   @Post('purchases')
+  @BookingStaff(FREIGHT_PERMS.fuel.create)
   @ApiOperation({ summary: 'Record fuel purchase' })
   async recordFuelPurchase(@Body() dto: CreateFuelPurchaseDto) {
     return this.fuelService.recordFuelPurchase(dto);
   }
 
   @Get('purchases')
+  @BookingStaff(FREIGHT_PERMS.fuel.view)
   @ApiOperation({ summary: 'Get all fuel purchases' })
   async getAllFuelPurchases() {
     return this.fuelService.getAllFuelPurchases();
   }
 
   @Get('purchases/:vehicleId')
+  @BookingStaff(FREIGHT_PERMS.fuel.view)
   @ApiOperation({ summary: 'Get fuel purchases for vehicle' })
   async getFuelPurchases(
     @Param('vehicleId') vehicleId: string,
@@ -35,6 +49,7 @@ export class FuelController {
   }
 
   @Get('consumption/:vehicleId/:month')
+  @BookingStaff(FREIGHT_PERMS.fuel.view)
   @ApiOperation({ summary: 'Get monthly fuel consumption' })
   async getMonthlyConsumption(
     @Param('vehicleId') vehicleId: string,
@@ -44,12 +59,14 @@ export class FuelController {
   }
 
   @Get('stats')
+  @BookingStaff(FUEL_STATS_PERMS)
   @ApiOperation({ summary: 'Get fleet-wide fuel statistics' })
   async getFleetFuelStats(@Query('months') months: number = 12) {
     return this.fuelService.getFleetFuelStats(months);
   }
 
   @Get('stats/:vehicleId')
+  @BookingStaff(FUEL_STATS_PERMS)
   @ApiOperation({ summary: 'Get fuel statistics for vehicle' })
   async getVehicleFuelStats(
     @Param('vehicleId') vehicleId: string,
diff --git a/apps/edr-freight-api/src/modules/gps-tracking/dto/gps-device.dto.ts b/apps/edr-freight-api/src/modules/gps-tracking/dto/gps-device.dto.ts
new file mode 100644
index 000000000..933699f0b
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/gps-tracking/dto/gps-device.dto.ts
@@ -0,0 +1,24 @@
+import { IsOptional, IsString, IsUUID } from 'class-validator';
+
+export class RegisterDeviceDto {
+  @IsString()
+  imei!: string;
+
+  @IsOptional()
+  @IsString()
+  name?: string;
+
+  @IsOptional()
+  @IsUUID()
+  vehicleId?: string;
+}
+
+export class UpdateDeviceDto {
+  @IsOptional()
+  @IsString()
+  name?: string;
+
+  @IsOptional()
+  @IsUUID()
+  vehicleId?: string | null;
+}
diff --git a/apps/edr-freight-api/src/modules/gps-tracking/entities/gps-device.entity.ts b/apps/edr-freight-api/src/modules/gps-tracking/entities/gps-device.entity.ts
new file mode 100644
index 000000000..ac5f7dbc6
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/gps-tracking/entities/gps-device.entity.ts
@@ -0,0 +1,55 @@
+import { BaseEntity } from '@edr/api-common';
+import { Column, Entity, Index, JoinColumn, ManyToOne } from 'typeorm';
+
+import { Vehicle } from '../../vehicles/entities/vehicle.entity';
+
+/**
+ * A physical GPS tracker (GT06). Identified by IMEI, optionally bound to a
+ * vehicle. Carries the denormalized latest fix so the live map reads one row
+ * per device without scanning position history.
+ */
+@Entity({ name: 'gps_devices', schema: 'freight' })
+@Index(['vehicleId'])
+export class GpsDevice extends BaseEntity {
+  @Column({ name: 'imei', type: 'varchar', length: 20, unique: true })
+  imei!: string;
+
+  @Column({ name: 'name', type: 'varchar', nullable: true })
+  name?: string | null;
+
+  @Column({ name: 'vehicle_id', type: 'uuid', nullable: true })
+  vehicleId?: string | null;
+
+  @ManyToOne(() => Vehicle, { nullable: true, eager: false })
+  @JoinColumn({ name: 'vehicle_id' })
+  vehicle?: Vehicle | null;
+
+  /** ONLINE once a packet arrives; OFFLINE when stale (derived on read). */
+  @Column({ name: 'status', type: 'varchar', length: 16, default: 'REGISTERED' })
+  status!: string;
+
+  @Column({ name: 'last_seen_at', type: 'timestamptz', nullable: true })
+  lastSeenAt?: Date | null;
+
+  // ── Denormalized latest fix ──
+  @Column({ name: 'last_lat', type: 'numeric', precision: 10, scale: 6, nullable: true })
+  lastLat?: number | null;
+
+  @Column({ name: 'last_lng', type: 'numeric', precision: 10, scale: 6, nullable: true })
+  lastLng?: number | null;
+
+  @Column({ name: 'last_speed', type: 'numeric', precision: 6, scale: 2, nullable: true })
+  lastSpeed?: number | null;
+
+  @Column({ name: 'last_course', type: 'int', nullable: true })
+  lastCourse?: number | null;
+
+  @Column({ name: 'last_fix_at', type: 'timestamptz', nullable: true })
+  lastFixAt?: Date | null;
+
+  @Column({ name: 'voltage_level', type: 'int', nullable: true })
+  voltageLevel?: number | null;
+
+  @Column({ name: 'gsm_level', type: 'int', nullable: true })
+  gsmLevel?: number | null;
+}
diff --git a/apps/edr-freight-api/src/modules/gps-tracking/entities/gps-position.entity.ts b/apps/edr-freight-api/src/modules/gps-tracking/entities/gps-position.entity.ts
new file mode 100644
index 000000000..8c63bb78f
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/gps-tracking/entities/gps-position.entity.ts
@@ -0,0 +1,43 @@
+import { BaseEntity } from '@edr/api-common';
+import { Column, Entity, Index } from 'typeorm';
+
+/** One GPS fix from a tracker (append-only history). */
+@Entity({ name: 'gps_positions', schema: 'freight' })
+@Index(['deviceId', 'gpsTime'])
+@Index(['vehicleId', 'gpsTime'])
+export class GpsPosition extends BaseEntity {
+  @Column({ name: 'device_id', type: 'uuid' })
+  deviceId!: string;
+
+  @Column({ name: 'imei', type: 'varchar', length: 20 })
+  imei!: string;
+
+  @Column({ name: 'vehicle_id', type: 'uuid', nullable: true })
+  vehicleId?: string | null;
+
+  @Column({ name: 'lat', type: 'numeric', precision: 10, scale: 6 })
+  lat!: number;
+
+  @Column({ name: 'lng', type: 'numeric', precision: 10, scale: 6 })
+  lng!: number;
+
+  @Column({ name: 'speed', type: 'numeric', precision: 6, scale: 2, default: 0 })
+  speed!: number;
+
+  @Column({ name: 'course', type: 'int', default: 0 })
+  course!: number;
+
+  @Column({ name: 'satellites', type: 'int', default: 0 })
+  satellites!: number;
+
+  @Column({ name: 'positioned', type: 'boolean', default: false })
+  positioned!: boolean;
+
+  /** Fix time reported by the device (UTC). */
+  @Column({ name: 'gps_time', type: 'timestamptz' })
+  gpsTime!: Date;
+
+  /** Non-zero when the fix came in via an alarm packet. */
+  @Column({ name: 'alarm', type: 'int', default: 0 })
+  alarm!: number;
+}
diff --git a/apps/edr-freight-api/src/modules/gps-tracking/gps-tracking.controller.ts b/apps/edr-freight-api/src/modules/gps-tracking/gps-tracking.controller.ts
new file mode 100644
index 000000000..e380e541e
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/gps-tracking/gps-tracking.controller.ts
@@ -0,0 +1,66 @@
+import {
+  Body,
+  Controller,
+  Delete,
+  Get,
+  Param,
+  ParseUUIDPipe,
+  Patch,
+  Post,
+  Query,
+} from '@nestjs/common';
+import { ApiBearerAuth, ApiOperation, ApiTags } from '@nestjs/swagger';
+
+import { FleetManage, FleetView } from '../../common/booking-guards';
+import { GpsTrackingService } from './gps-tracking.service';
+import { RegisterDeviceDto, UpdateDeviceDto } from './dto/gps-device.dto';
+
+@ApiTags('gps-tracking')
+@ApiBearerAuth()
+@Controller('gps')
+@FleetView()
+export class GpsTrackingController {
+  constructor(private readonly gps: GpsTrackingService) {}
+
+  @Get('positions/latest')
+  @ApiOperation({ summary: 'Latest fix per device (live map feed)' })
+  latest() {
+    return this.gps.latest();
+  }
+
+  @Get('positions/:vehicleId/history')
+  @ApiOperation({ summary: 'Position history for a vehicle' })
+  history(
+    @Param('vehicleId', ParseUUIDPipe) vehicleId: string,
+    @Query('limit') limit?: string,
+  ) {
+    return this.gps.history(vehicleId, limit ? parseInt(limit, 10) : undefined);
+  }
+
+  @Get('devices')
+  @ApiOperation({ summary: 'List GPS trackers' })
+  listDevices() {
+    return this.gps.listDevices();
+  }
+
+  @Post('devices')
+  @FleetManage()
+  @ApiOperation({ summary: 'Register a GPS tracker' })
+  register(@Body() dto: RegisterDeviceDto) {
+    return this.gps.registerDevice(dto);
+  }
+
+  @Patch('devices/:id')
+  @FleetManage()
+  @ApiOperation({ summary: 'Update a GPS tracker (name / assigned vehicle)' })
+  update(@Param('id', ParseUUIDPipe) id: string, @Body() dto: UpdateDeviceDto) {
+    return this.gps.updateDevice(id, dto);
+  }
+
+  @Delete('devices/:id')
+  @FleetManage()
+  @ApiOperation({ summary: 'Delete a GPS tracker' })
+  remove(@Param('id', ParseUUIDPipe) id: string) {
+    return this.gps.removeDevice(id);
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/gps-tracking/gps-tracking.module.ts b/apps/edr-freight-api/src/modules/gps-tracking/gps-tracking.module.ts
new file mode 100644
index 000000000..da527fff0
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/gps-tracking/gps-tracking.module.ts
@@ -0,0 +1,17 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+
+import { GpsDevice } from './entities/gps-device.entity';
+import { GpsPosition } from './entities/gps-position.entity';
+import { GpsDeviceRepository, GpsPositionRepository } from './gps-tracking.repository';
+import { GpsTrackingService } from './gps-tracking.service';
+import { GpsTrackingController } from './gps-tracking.controller';
+import { Gt06Server } from './gt06/gt06.server';
+
+@Module({
+  imports: [TypeOrmModule.forFeature([GpsDevice, GpsPosition])],
+  controllers: [GpsTrackingController],
+  providers: [GpsDeviceRepository, GpsPositionRepository, GpsTrackingService, Gt06Server],
+  exports: [GpsTrackingService],
+})
+export class GpsTrackingModule {}
diff --git a/apps/edr-freight-api/src/modules/gps-tracking/gps-tracking.repository.ts b/apps/edr-freight-api/src/modules/gps-tracking/gps-tracking.repository.ts
new file mode 100644
index 000000000..326ef66ac
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/gps-tracking/gps-tracking.repository.ts
@@ -0,0 +1,29 @@
+import { BaseRepository } from '@edr/api-common';
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+
+import { GpsDevice } from './entities/gps-device.entity';
+import { GpsPosition } from './entities/gps-position.entity';
+
+@Injectable()
+export class GpsDeviceRepository extends BaseRepository<GpsDevice> {
+  constructor(
+    @InjectRepository(GpsDevice) repository: Repository<GpsDevice>,
+  ) {
+    super(repository);
+  }
+
+  findByImei(imei: string): Promise<GpsDevice | null> {
+    return this.repository.findOne({ where: { imei } });
+  }
+}
+
+@Injectable()
+export class GpsPositionRepository extends BaseRepository<GpsPosition> {
+  constructor(
+    @InjectRepository(GpsPosition) repository: Repository<GpsPosition>,
+  ) {
+    super(repository);
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/gps-tracking/gps-tracking.service.ts b/apps/edr-freight-api/src/modules/gps-tracking/gps-tracking.service.ts
new file mode 100644
index 000000000..b5bea3a3f
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/gps-tracking/gps-tracking.service.ts
@@ -0,0 +1,124 @@
+import { BadRequestException, Injectable, Logger, NotFoundException } from '@nestjs/common';
+
+import { GpsDeviceRepository, GpsPositionRepository } from './gps-tracking.repository';
+import { GpsDevice } from './entities/gps-device.entity';
+import { Gt06Gps, Gt06Status } from './gt06/gt06.codec';
+
+/** A device is considered ONLINE if seen within this window. */
+const ONLINE_WINDOW_MS = 5 * 60 * 1000;
+
+@Injectable()
+export class GpsTrackingService {
+  private readonly logger = new Logger(GpsTrackingService.name);
+
+  constructor(
+    private readonly devices: GpsDeviceRepository,
+    private readonly positions: GpsPositionRepository,
+  ) {}
+
+  private isOnline(d: GpsDevice): boolean {
+    return Boolean(d.lastSeenAt && Date.now() - new Date(d.lastSeenAt).getTime() < ONLINE_WINDOW_MS);
+  }
+
+  /** Find the device for an IMEI, auto-registering it on first contact. */
+  private async ensureDevice(imei: string): Promise<GpsDevice> {
+    const existing = await this.devices.findByImei(imei);
+    if (existing) return existing;
+    this.logger.log(`Auto-registering new GPS tracker ${imei}`);
+    return this.devices.create({ imei, status: 'REGISTERED', lastSeenAt: new Date() });
+  }
+
+  // ── Ingestion (called by the TCP server) ──
+
+  async handleLogin(imei: string): Promise<void> {
+    const device = await this.ensureDevice(imei);
+    await this.devices.update(device.id, { lastSeenAt: new Date(), status: 'ONLINE' });
+  }
+
+  async handleHeartbeat(imei: string, status: Gt06Status): Promise<void> {
+    const device = await this.ensureDevice(imei);
+    await this.devices.update(device.id, {
+      lastSeenAt: new Date(),
+      status: 'ONLINE',
+      voltageLevel: status.voltageLevel,
+      gsmLevel: status.gsmLevel,
+    });
+  }
+
+  async handleFix(imei: string, gps: Gt06Gps, alarm = 0, status?: Gt06Status): Promise<void> {
+    const device = await this.ensureDevice(imei);
+    const now = new Date();
+    await this.devices.update(device.id, {
+      lastSeenAt: now,
+      status: 'ONLINE',
+      lastLat: gps.latitude,
+      lastLng: gps.longitude,
+      lastSpeed: gps.speed,
+      lastCourse: gps.course,
+      lastFixAt: new Date(gps.time),
+      ...(status ? { voltageLevel: status.voltageLevel, gsmLevel: status.gsmLevel } : {}),
+    });
+    await this.positions.create({
+      deviceId: device.id,
+      imei,
+      vehicleId: device.vehicleId ?? null,
+      lat: gps.latitude,
+      lng: gps.longitude,
+      speed: gps.speed,
+      course: gps.course,
+      satellites: gps.satellites,
+      positioned: gps.positioned,
+      gpsTime: new Date(gps.time),
+      alarm,
+    });
+  }
+
+  // ── Queries / management (REST) ──
+
+  private decorate(d: GpsDevice) {
+    return { ...d, online: this.isOnline(d) };
+  }
+
+  async listDevices() {
+    const rows = await this.devices.findAll({ relations: { vehicle: true }, order: { createdAt: 'DESC' } });
+    return rows.map((d) => this.decorate(d));
+  }
+
+  /** Live map feed — devices that have at least one fix. */
+  async latest() {
+    const rows = await this.devices.findAll({ relations: { vehicle: true } });
+    return rows.filter((d) => d.lastLat != null && d.lastLng != null).map((d) => this.decorate(d));
+  }
+
+  async history(vehicleId: string, limit = 200) {
+    return this.positions.findAll({
+      where: { vehicleId },
+      order: { gpsTime: 'DESC' },
+      take: Math.min(limit, 1000),
+    });
+  }
+
+  async registerDevice(dto: { imei: string; name?: string; vehicleId?: string | null }) {
+    const existing = await this.devices.findByImei(dto.imei);
+    if (existing) throw new BadRequestException(`A device with IMEI ${dto.imei} already exists`);
+    return this.devices.create({
+      imei: dto.imei,
+      name: dto.name ?? null,
+      vehicleId: dto.vehicleId ?? null,
+      status: 'REGISTERED',
+    });
+  }
+
+  async updateDevice(id: string, dto: { name?: string; vehicleId?: string | null }) {
+    const updated = await this.devices.update(id, {
+      ...(dto.name !== undefined ? { name: dto.name } : {}),
+      ...(dto.vehicleId !== undefined ? { vehicleId: dto.vehicleId } : {}),
+    });
+    if (!updated) throw new NotFoundException(`GPS device ${id} not found`);
+    return updated;
+  }
+
+  async removeDevice(id: string): Promise<void> {
+    await this.devices.softDelete(id);
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/gps-tracking/gt06/gt06.codec.ts b/apps/edr-freight-api/src/modules/gps-tracking/gt06/gt06.codec.ts
new file mode 100644
index 000000000..d54f906a2
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/gps-tracking/gt06/gt06.codec.ts
@@ -0,0 +1,207 @@
+/**
+ * GT06 GPS-tracker protocol codec.
+ *
+ * Frame: 0x78 0x78 | len(1) | protocol(1) | content(N) | serial(2) | crc(2) | 0x0D 0x0A
+ * `len` counts protocol..crc (= 5 + N). CRC-ITU (CRC-16/X.25) is computed over
+ * len..serial (inclusive) and equals the 2 crc bytes.
+ */
+
+const START = 0x7878;
+const STOP = 0x0d0a;
+
+export const GT06_PROTOCOL = {
+  LOGIN: 0x01,
+  LOCATION: 0x12,
+  HEARTBEAT: 0x13,
+  STRING: 0x15,
+  ALARM: 0x16,
+  ADDRESS_BY_PHONE: 0x1a,
+  SERVER_COMMAND: 0x80,
+} as const;
+
+/** CRC-16/X.25 (a.k.a. CRC-ITU) used by GT06 — reflected, poly 0x8408, init/xorout 0xFFFF. */
+export function crcItu(bytes: Buffer): number {
+  let fcs = 0xffff;
+  for (const b of bytes) {
+    fcs ^= b;
+    for (let i = 0; i < 8; i++) {
+      fcs = fcs & 1 ? (fcs >> 1) ^ 0x8408 : fcs >> 1;
+    }
+  }
+  return (~fcs) & 0xffff;
+}
+
+export interface Gt06Gps {
+  time: string; // ISO (UTC)
+  satellites: number;
+  latitude: number;
+  longitude: number;
+  speed: number; // km/h
+  course: number; // 0-360
+  positioned: boolean;
+}
+
+export interface Gt06Lbs {
+  mcc: number;
+  mnc: number;
+  lac: number;
+  cellId: number;
+}
+
+export interface Gt06Status {
+  terminalInfo: number;
+  voltageLevel: number;
+  gsmLevel: number;
+  alarm: number; // former byte of alarm/language
+  charging: boolean;
+  accOn: boolean;
+  gpsTracking: boolean;
+  oilCut: boolean;
+}
+
+export type Gt06Packet =
+  | { type: 'login'; protocol: number; serial: number; imei: string }
+  | { type: 'location'; protocol: number; serial: number; gps: Gt06Gps; lbs: Gt06Lbs }
+  | { type: 'heartbeat'; protocol: number; serial: number; status: Gt06Status }
+  | { type: 'alarm'; protocol: number; serial: number; gps: Gt06Gps; lbs: Gt06Lbs; status: Gt06Status }
+  | { type: 'unknown'; protocol: number; serial: number };
+
+/** Terminal ID (8 BCD bytes) → 15-digit IMEI (drops the leading pad nibble). */
+function decodeImei(buf: Buffer): string {
+  return buf.toString('hex').replace(/^0/, '');
+}
+
+function decodeDateTime(buf: Buffer, off: number): string {
+  const year = 2000 + buf[off];
+  const month = buf[off + 1];
+  const day = buf[off + 2];
+  const hour = buf[off + 3];
+  const min = buf[off + 4];
+  const sec = buf[off + 5];
+  return new Date(Date.UTC(year, month - 1, day, hour, min, sec)).toISOString();
+}
+
+/** Convert a GT06 lat/long raw uint32 to decimal degrees (magnitude only). */
+function rawToDegrees(raw: number): number {
+  return raw / 30000 / 60;
+}
+
+function decodeGps(buf: Buffer, off: number): Gt06Gps {
+  const time = decodeDateTime(buf, off);
+  const lenSat = buf[off + 6];
+  const satellites = lenSat & 0x0f;
+  const latRaw = buf.readUInt32BE(off + 7);
+  const lonRaw = buf.readUInt32BE(off + 11);
+  const speed = buf[off + 15];
+  const cs = buf.readUInt16BE(off + 16);
+  const hi = (cs >> 8) & 0xff;
+  const positioned = Boolean(hi & 0x10); // BYTE_1 Bit4
+  const isWest = Boolean(hi & 0x08); // BYTE_1 Bit3 (1 = West)
+  const isNorth = Boolean(hi & 0x04); // BYTE_1 Bit2 (1 = North)
+  const course = cs & 0x03ff; // BYTE_1 Bit1-0 + BYTE_2
+  let latitude = rawToDegrees(latRaw);
+  let longitude = rawToDegrees(lonRaw);
+  if (!isNorth) latitude = -latitude;
+  if (isWest) longitude = -longitude;
+  return { time, satellites, latitude, longitude, speed, course, positioned };
+}
+
+function decodeStatus(buf: Buffer, off: number): Gt06Status {
+  const terminalInfo = buf[off];
+  const voltageLevel = buf[off + 1];
+  const gsmLevel = buf[off + 2];
+  const alarm = buf[off + 3]; // alarm/language former byte
+  return {
+    terminalInfo,
+    voltageLevel,
+    gsmLevel,
+    alarm,
+    oilCut: Boolean(terminalInfo & 0x80),
+    gpsTracking: Boolean(terminalInfo & 0x40),
+    charging: Boolean(terminalInfo & 0x04),
+    accOn: Boolean(terminalInfo & 0x02),
+  };
+}
+
+function decodeLbs(buf: Buffer, off: number): Gt06Lbs {
+  return {
+    mcc: buf.readUInt16BE(off),
+    mnc: buf[off + 2],
+    lac: buf.readUInt16BE(off + 3),
+    cellId: buf.readUIntBE(off + 5, 3),
+  };
+}
+
+function decodeFrame(frame: Buffer): Gt06Packet | null {
+  // frame = 78 78 len ...content... serial(2) crc(2) 0D 0A
+  const len = frame[2];
+  const protocol = frame[3];
+  const serialOff = 3 + (len - 4); // after protocol + content, before serial(2)+crc(2)
+  const serial = frame.readUInt16BE(serialOff);
+  const contentOff = 4; // start of content (after protocol)
+
+  switch (protocol) {
+    case GT06_PROTOCOL.LOGIN:
+      return { type: 'login', protocol, serial, imei: decodeImei(frame.subarray(contentOff, contentOff + 8)) };
+    case GT06_PROTOCOL.LOCATION:
+      return { type: 'location', protocol, serial, gps: decodeGps(frame, contentOff), lbs: decodeLbs(frame, contentOff + 18) };
+    case GT06_PROTOCOL.HEARTBEAT:
+      return { type: 'heartbeat', protocol, serial, status: decodeStatus(frame, contentOff) };
+    case GT06_PROTOCOL.ALARM: {
+      const gps = decodeGps(frame, contentOff);
+      // content: date(6)+lenSat(1)+lat(4)+lng(4)+speed(1)+course(2)=18, lbsLen(1), lbs(8), status(1+1+1+2)
+      const lbs = decodeLbs(frame, contentOff + 18 + 1);
+      const status = decodeStatus(frame, contentOff + 18 + 1 + 8);
+      return { type: 'alarm', protocol, serial, gps, lbs, status };
+    }
+    default:
+      return { type: 'unknown', protocol, serial };
+  }
+}
+
+/**
+ * Pull all complete frames out of a stream buffer. Returns the decoded packets
+ * (skipping CRC-failed ones) and the trailing bytes that form a partial frame.
+ */
+export function parseStream(buffer: Buffer): { packets: Gt06Packet[]; rest: Buffer } {
+  const packets: Gt06Packet[] = [];
+  let i = 0;
+  while (i + 5 <= buffer.length) {
+    if (buffer.readUInt16BE(i) !== START) {
+      i += 1; // resync
+      continue;
+    }
+    const len = buffer[i + 2];
+    const frameLen = 2 + 1 + len + 2; // start + lenByte + (protocol..crc) + stop
+    if (i + frameLen > buffer.length) break; // incomplete
+    const frame = buffer.subarray(i, i + frameLen);
+    if (frame.readUInt16BE(frameLen - 2) === STOP) {
+      // CRC over len..serial (frame[2 .. frameLen-4]); crc bytes are frameLen-4..frameLen-3.
+      const crcCalc = crcItu(frame.subarray(2, frameLen - 4));
+      const crcRecv = frame.readUInt16BE(frameLen - 4);
+      if (crcCalc === crcRecv) {
+        const pkt = decodeFrame(frame);
+        if (pkt) packets.push(pkt);
+      }
+      i += frameLen;
+    } else {
+      i += 1; // bad frame, resync
+    }
+  }
+  return { packets, rest: buffer.subarray(i) };
+}
+
+/** Build a server → terminal ACK (login/heartbeat/alarm) echoing the serial. */
+export function buildAck(protocol: number, serial: number): Buffer {
+  const body = Buffer.alloc(3); // protocol + serial(2)
+  body[0] = protocol;
+  body.writeUInt16BE(serial, 1);
+  const len = body.length + 2; // + crc(2)
+  const forCrc = Buffer.concat([Buffer.from([len]), body]);
+  const crc = crcItu(forCrc);
+  return Buffer.concat([
+    Buffer.from([0x78, 0x78, len]),
+    body,
+    Buffer.from([(crc >> 8) & 0xff, crc & 0xff, 0x0d, 0x0a]),
+  ]);
+}
diff --git a/apps/edr-freight-api/src/modules/gps-tracking/gt06/gt06.server.ts b/apps/edr-freight-api/src/modules/gps-tracking/gt06/gt06.server.ts
new file mode 100644
index 000000000..a2095fa12
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/gps-tracking/gt06/gt06.server.ts
@@ -0,0 +1,97 @@
+import { Injectable, Logger, OnApplicationBootstrap, OnModuleDestroy } from '@nestjs/common';
+import * as net from 'net';
+
+import { GpsTrackingService } from '../gps-tracking.service';
+import { buildAck, GT06_PROTOCOL, parseStream } from './gt06.codec';
+
+interface Session {
+  buffer: Buffer;
+  imei: string | null;
+}
+
+const MAX_BUFFER = 64 * 1024;
+
+/**
+ * Raw TCP listener for GT06 GPS trackers. Trackers open a socket, send a login
+ * (IMEI), then stream location/heartbeat/alarm packets; we decode, persist via
+ * {@link GpsTrackingService}, and ACK login/heartbeat/alarm so the device keeps
+ * the connection alive. Disabled when GT06_TCP_PORT=0.
+ */
+@Injectable()
+export class Gt06Server implements OnApplicationBootstrap, OnModuleDestroy {
+  private readonly logger = new Logger(Gt06Server.name);
+  private server?: net.Server;
+  private readonly sessions = new Map<net.Socket, Session>();
+
+  constructor(private readonly gps: GpsTrackingService) {}
+
+  onApplicationBootstrap(): void {
+    const port = Number(process.env.GT06_TCP_PORT ?? 5023);
+    if (!port) {
+      this.logger.log('GT06 TCP listener disabled (GT06_TCP_PORT=0)');
+      return;
+    }
+    const host = process.env.GT06_TCP_HOST ?? '0.0.0.0';
+    this.server = net.createServer((socket) => this.onConnection(socket));
+    this.server.on('error', (err) => this.logger.error(`GT06 server error: ${String(err)}`));
+    this.server.listen(port, host, () => this.logger.log(`GT06 GPS tracker listener on ${host}:${port}`));
+  }
+
+  onModuleDestroy(): void {
+    for (const socket of this.sessions.keys()) socket.destroy();
+    this.sessions.clear();
+    this.server?.close();
+  }
+
+  private onConnection(socket: net.Socket): void {
+    this.sessions.set(socket, { buffer: Buffer.alloc(0), imei: null });
+    socket.on('data', (chunk) => void this.onData(socket, chunk));
+    socket.on('error', () => this.sessions.delete(socket));
+    socket.on('close', () => this.sessions.delete(socket));
+  }
+
+  private async onData(socket: net.Socket, chunk: Buffer): Promise<void> {
+    const session = this.sessions.get(socket);
+    if (!session) return;
+    session.buffer = Buffer.concat([session.buffer, chunk]);
+    if (session.buffer.length > MAX_BUFFER) session.buffer = Buffer.alloc(0); // drop garbage
+
+    const { packets, rest } = parseStream(session.buffer);
+    session.buffer = rest;
+
+    for (const pkt of packets) {
+      try {
+        await this.handle(socket, session, pkt);
+      } catch (err) {
+        this.logger.error(`Failed to handle GT06 packet (${pkt.type}): ${String(err)}`);
+      }
+    }
+  }
+
+  private async handle(
+    socket: net.Socket,
+    session: Session,
+    pkt: ReturnType<typeof parseStream>['packets'][number],
+  ): Promise<void> {
+    switch (pkt.type) {
+      case 'login':
+        session.imei = pkt.imei;
+        await this.gps.handleLogin(pkt.imei);
+        socket.write(buildAck(GT06_PROTOCOL.LOGIN, pkt.serial));
+        break;
+      case 'heartbeat':
+        if (session.imei) await this.gps.handleHeartbeat(session.imei, pkt.status);
+        socket.write(buildAck(GT06_PROTOCOL.HEARTBEAT, pkt.serial));
+        break;
+      case 'location':
+        if (session.imei) await this.gps.handleFix(session.imei, pkt.gps);
+        break;
+      case 'alarm':
+        if (session.imei) await this.gps.handleFix(session.imei, pkt.gps, pkt.status.alarm, pkt.status);
+        socket.write(buildAck(GT06_PROTOCOL.ALARM, pkt.serial));
+        break;
+      default:
+        break;
+    }
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/incidents/dto/create-incident.dto.ts b/apps/edr-freight-api/src/modules/incidents/dto/create-incident.dto.ts
new file mode 100644
index 000000000..5d76885b4
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/incidents/dto/create-incident.dto.ts
@@ -0,0 +1,48 @@
+import { IsUUID, IsString, IsDateString, IsNumber, IsOptional, IsEnum } from 'class-validator';
+import { IncidentType, IncidentSeverity, IncidentStatus } from '../entities/incident.entity';
+
+export class CreateIncidentDto {
+  @IsOptional()
+  @IsUUID()
+  vehicleId?: string;
+
+  @IsOptional()
+  @IsUUID()
+  driverId?: string;
+
+  @IsOptional()
+  @IsUUID()
+  bookingId?: string;
+
+  @IsEnum(IncidentType)
+  type!: IncidentType;
+
+  @IsEnum(IncidentSeverity)
+  severity!: IncidentSeverity;
+
+  @IsDateString()
+  occurredAt!: string;
+
+  @IsOptional()
+  @IsString()
+  location?: string;
+
+  @IsString()
+  description!: string;
+
+  @IsOptional()
+  @IsNumber()
+  damageEstimate?: number;
+
+  @IsOptional()
+  @IsEnum(IncidentStatus)
+  status?: IncidentStatus;
+
+  @IsOptional()
+  @IsString()
+  insuranceClaimNumber?: string;
+
+  @IsOptional()
+  @IsString()
+  reportedBy?: string;
+}
diff --git a/apps/edr-freight-api/src/modules/incidents/dto/update-incident.dto.ts b/apps/edr-freight-api/src/modules/incidents/dto/update-incident.dto.ts
new file mode 100644
index 000000000..b45d478e0
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/incidents/dto/update-incident.dto.ts
@@ -0,0 +1,52 @@
+import { IsUUID, IsString, IsDateString, IsNumber, IsOptional, IsEnum } from 'class-validator';
+import { IncidentType, IncidentSeverity, IncidentStatus } from '../entities/incident.entity';
+
+export class UpdateIncidentDto {
+  @IsOptional()
+  @IsUUID()
+  vehicleId?: string;
+
+  @IsOptional()
+  @IsUUID()
+  driverId?: string;
+
+  @IsOptional()
+  @IsUUID()
+  bookingId?: string;
+
+  @IsOptional()
+  @IsEnum(IncidentType)
+  type?: IncidentType;
+
+  @IsOptional()
+  @IsEnum(IncidentSeverity)
+  severity?: IncidentSeverity;
+
+  @IsOptional()
+  @IsDateString()
+  occurredAt?: string;
+
+  @IsOptional()
+  @IsString()
+  location?: string;
+
+  @IsOptional()
+  @IsString()
+  description?: string;
+
+  @IsOptional()
+  @IsNumber()
+  damageEstimate?: number;
+
+  @IsOptional()
+  @IsEnum(IncidentStatus)
+  status?: IncidentStatus;
+
+  @IsOptional()
+  @IsString()
+  insuranceClaimNumber?: string;
+
+  @IsOptional()
+  @IsString()
+  reportedBy?: string;
+}
diff --git a/apps/edr-freight-api/src/modules/incidents/entities/incident.entity.ts b/apps/edr-freight-api/src/modules/incidents/entities/incident.entity.ts
new file mode 100644
index 000000000..2c71cc8a3
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/incidents/entities/incident.entity.ts
@@ -0,0 +1,76 @@
+import { BaseEntity } from '@edr/api-common';
+import { Entity, Column, ManyToOne, JoinColumn, Index } from 'typeorm';
+import { Vehicle } from '../../vehicles/entities/vehicle.entity';
+import { Driver } from '../../drivers/entities/driver.entity';
+
+export enum IncidentType {
+  ACCIDENT = 'ACCIDENT',
+  BREAKDOWN = 'BREAKDOWN',
+  TRAFFIC_VIOLATION = 'TRAFFIC_VIOLATION',
+  THEFT = 'THEFT',
+  OTHER = 'OTHER',
+}
+
+export enum IncidentSeverity {
+  MINOR = 'MINOR',
+  MODERATE = 'MODERATE',
+  MAJOR = 'MAJOR',
+  CRITICAL = 'CRITICAL',
+}
+
+export enum IncidentStatus {
+  REPORTED = 'REPORTED',
+  UNDER_REVIEW = 'UNDER_REVIEW',
+  CLAIM_FILED = 'CLAIM_FILED',
+  RESOLVED = 'RESOLVED',
+  CLOSED = 'CLOSED',
+}
+
+@Entity({ name: 'incidents', schema: 'freight' })
+@Index(['driverId', 'occurredAt'])
+@Index(['vehicleId', 'occurredAt'])
+export class Incident extends BaseEntity {
+  @Column({ name: 'vehicle_id', type: 'uuid', nullable: true })
+  vehicleId?: string;
+
+  @ManyToOne(() => Vehicle, { eager: false, nullable: true })
+  @JoinColumn({ name: 'vehicle_id' })
+  vehicle?: Vehicle;
+
+  @Column({ name: 'driver_id', type: 'uuid', nullable: true })
+  driverId?: string;
+
+  @ManyToOne(() => Driver, { eager: false, nullable: true })
+  @JoinColumn({ name: 'driver_id' })
+  driver?: Driver;
+
+  @Column({ name: 'booking_id', type: 'uuid', nullable: true })
+  bookingId?: string;
+
+  @Column({ name: 'type', type: 'varchar' })
+  type!: IncidentType;
+
+  @Column({ name: 'severity', type: 'varchar' })
+  severity!: IncidentSeverity;
+
+  @Column({ name: 'occurred_at', type: 'timestamptz' })
+  occurredAt!: Date;
+
+  @Column({ name: 'location', type: 'varchar', nullable: true })
+  location?: string;
+
+  @Column({ name: 'description', type: 'text' })
+  description!: string;
+
+  @Column({ name: 'damage_estimate', type: 'numeric', precision: 14, scale: 2, nullable: true })
+  damageEstimate?: number;
+
+  @Column({ name: 'status', type: 'varchar', default: IncidentStatus.REPORTED })
+  status!: IncidentStatus;
+
+  @Column({ name: 'insurance_claim_number', type: 'varchar', nullable: true })
+  insuranceClaimNumber?: string;
+
+  @Column({ name: 'reported_by', type: 'varchar', nullable: true })
+  reportedBy?: string;
+}
diff --git a/apps/edr-freight-api/src/modules/incidents/incidents.controller.ts b/apps/edr-freight-api/src/modules/incidents/incidents.controller.ts
new file mode 100644
index 000000000..ab6d5ef08
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/incidents/incidents.controller.ts
@@ -0,0 +1,69 @@
+import {
+  Controller,
+  Post,
+  Get,
+  Patch,
+  Delete,
+  Body,
+  Param,
+  Query,
+} from '@nestjs/common';
+import { ApiTags, ApiOperation } from '@nestjs/swagger';
+import { IncidentsService } from './incidents.service';
+import { CreateIncidentDto } from './dto/create-incident.dto';
+import { UpdateIncidentDto } from './dto/update-incident.dto';
+import { IncidentStatus, IncidentType } from './entities/incident.entity';
+
+@ApiTags('Accident & Incident Management')
+@Controller('incidents')
+export class IncidentsController {
+  constructor(private readonly incidentsService: IncidentsService) {}
+
+  @Post()
+  @ApiOperation({ summary: 'Report an incident' })
+  async create(@Body() dto: CreateIncidentDto) {
+    return this.incidentsService.create(dto);
+  }
+
+  @Get()
+  @ApiOperation({ summary: 'List incidents (optionally filtered)' })
+  async findAll(
+    @Query('vehicleId') vehicleId?: string,
+    @Query('driverId') driverId?: string,
+    @Query('status') status?: IncidentStatus,
+    @Query('type') type?: IncidentType,
+  ) {
+    return this.incidentsService.findAll({ vehicleId, driverId, status, type });
+  }
+
+  @Get('driver/:driverId/stats')
+  @ApiOperation({ summary: 'Get incident statistics for a driver' })
+  async statsForDriver(@Param('driverId') driverId: string) {
+    return this.incidentsService.statsForDriver(driverId);
+  }
+
+  @Get('driver/:driverId')
+  @ApiOperation({ summary: 'List incidents for a driver (incident history)' })
+  async findByDriver(@Param('driverId') driverId: string) {
+    return this.incidentsService.findByDriver(driverId);
+  }
+
+  @Get(':id')
+  @ApiOperation({ summary: 'Get an incident by id' })
+  async findById(@Param('id') id: string) {
+    return this.incidentsService.findById(id);
+  }
+
+  @Patch(':id')
+  @ApiOperation({ summary: 'Update an incident' })
+  async update(@Param('id') id: string, @Body() dto: UpdateIncidentDto) {
+    return this.incidentsService.update(id, dto);
+  }
+
+  @Delete(':id')
+  @ApiOperation({ summary: 'Delete an incident' })
+  async remove(@Param('id') id: string) {
+    await this.incidentsService.remove(id);
+    return { success: true };
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/incidents/incidents.module.ts b/apps/edr-freight-api/src/modules/incidents/incidents.module.ts
new file mode 100644
index 000000000..872fbaab1
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/incidents/incidents.module.ts
@@ -0,0 +1,14 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { Incident } from './entities/incident.entity';
+import { IncidentsService } from './incidents.service';
+import { IncidentsRepository } from './incidents.repository';
+import { IncidentsController } from './incidents.controller';
+
+@Module({
+  imports: [TypeOrmModule.forFeature([Incident])],
+  providers: [IncidentsService, IncidentsRepository],
+  controllers: [IncidentsController],
+  exports: [IncidentsService],
+})
+export class IncidentsModule {}
diff --git a/apps/edr-freight-api/src/modules/incidents/incidents.repository.ts b/apps/edr-freight-api/src/modules/incidents/incidents.repository.ts
new file mode 100644
index 000000000..1d9f17770
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/incidents/incidents.repository.ts
@@ -0,0 +1,15 @@
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { BaseRepository } from '@edr/api-common';
+import { Repository } from 'typeorm';
+import { Incident } from './entities/incident.entity';
+
+@Injectable()
+export class IncidentsRepository extends BaseRepository<Incident> {
+  constructor(
+    @InjectRepository(Incident)
+    incidentRepository: Repository<Incident>,
+  ) {
+    super(incidentRepository);
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/incidents/incidents.service.ts b/apps/edr-freight-api/src/modules/incidents/incidents.service.ts
new file mode 100644
index 000000000..ea28a96e2
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/incidents/incidents.service.ts
@@ -0,0 +1,95 @@
+import { Injectable, NotFoundException } from '@nestjs/common';
+import { FindOptionsWhere } from 'typeorm';
+import { IncidentsRepository } from './incidents.repository';
+import {
+  Incident,
+  IncidentStatus,
+  IncidentType,
+} from './entities/incident.entity';
+import { CreateIncidentDto } from './dto/create-incident.dto';
+import { UpdateIncidentDto } from './dto/update-incident.dto';
+
+export interface IncidentFilter {
+  vehicleId?: string;
+  driverId?: string;
+  status?: IncidentStatus;
+  type?: IncidentType;
+}
+
+export interface DriverIncidentStats {
+  total: number;
+  byType: Record<string, number>;
+  lastIncidentAt: Date | null;
+}
+
+@Injectable()
+export class IncidentsService {
+  constructor(private readonly incidentsRepository: IncidentsRepository) {}
+
+  async create(dto: CreateIncidentDto): Promise<Incident> {
+    return this.incidentsRepository.create({
+      ...dto,
+      occurredAt: new Date(dto.occurredAt),
+    });
+  }
+
+  async findAll(filter: IncidentFilter = {}): Promise<Incident[]> {
+    const where: FindOptionsWhere<Incident> = {};
+    if (filter.vehicleId) where.vehicleId = filter.vehicleId;
+    if (filter.driverId) where.driverId = filter.driverId;
+    if (filter.status) where.status = filter.status;
+    if (filter.type) where.type = filter.type;
+
+    return this.incidentsRepository.findAll({
+      where,
+      order: { occurredAt: 'DESC' },
+    });
+  }
+
+  async findByDriver(driverId: string): Promise<Incident[]> {
+    return this.incidentsRepository.findAll({
+      where: { driverId },
+      order: { occurredAt: 'DESC' },
+    });
+  }
+
+  async findById(id: string): Promise<Incident> {
+    const incident = await this.incidentsRepository.findById(id);
+    if (!incident) {
+      throw new NotFoundException(`Incident ${id} not found`);
+    }
+    return incident;
+  }
+
+  async update(id: string, dto: UpdateIncidentDto): Promise<Incident> {
+    await this.findById(id);
+    const updated = await this.incidentsRepository.update(id, {
+      ...dto,
+      occurredAt: dto.occurredAt ? new Date(dto.occurredAt) : undefined,
+    });
+    return updated!;
+  }
+
+  async remove(id: string): Promise<void> {
+    await this.findById(id);
+    await this.incidentsRepository.softDelete(id);
+  }
+
+  async statsForDriver(driverId: string): Promise<DriverIncidentStats> {
+    const incidents = await this.incidentsRepository.findAll({
+      where: { driverId },
+      order: { occurredAt: 'DESC' },
+    });
+
+    const byType: Record<string, number> = {};
+    for (const incident of incidents) {
+      byType[incident.type] = (byType[incident.type] || 0) + 1;
+    }
+
+    return {
+      total: incidents.length,
+      byType,
+      lastIncidentAt: incidents.length > 0 ? incidents[0].occurredAt : null,
+    };
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/last-mile/dto/update-last-mile.dto.ts b/apps/edr-freight-api/src/modules/last-mile/dto/update-last-mile.dto.ts
index 9d0c4262d..405273a54 100644
--- a/apps/edr-freight-api/src/modules/last-mile/dto/update-last-mile.dto.ts
+++ b/apps/edr-freight-api/src/modules/last-mile/dto/update-last-mile.dto.ts
@@ -1,5 +1,18 @@
-import { PartialType } from '@nestjs/mapped-types';
+import { ApiPropertyOptional, PartialType } from '@nestjs/swagger';
+import { IsISO8601, IsOptional } from 'class-validator';
 
 import { CreateLastMileDto } from './create-last-mile.dto';
 
-export class UpdateLastMileDto extends PartialType(CreateLastMileDto) {}
+export class UpdateLastMileDto extends PartialType(CreateLastMileDto) {
+  /** Truck-detention clock start (vehicle arrived at destination). Overrides the auto-stamp. */
+  @ApiPropertyOptional({ description: 'Vehicle arrival time (ISO 8601) — detention clock start.' })
+  @IsOptional()
+  @IsISO8601()
+  arrivedAt?: string;
+
+  /** Truck-detention clock end (cargo cleared / vehicle returned). Overrides the auto-stamp. */
+  @ApiPropertyOptional({ description: 'Delivery/return time (ISO 8601) — detention clock end.' })
+  @IsOptional()
+  @IsISO8601()
+  deliveredAt?: string;
+}
diff --git a/apps/edr-freight-api/src/modules/last-mile/entities/last-mile.entity.ts b/apps/edr-freight-api/src/modules/last-mile/entities/last-mile.entity.ts
index 1f8bda8fc..5dca86cc4 100644
--- a/apps/edr-freight-api/src/modules/last-mile/entities/last-mile.entity.ts
+++ b/apps/edr-freight-api/src/modules/last-mile/entities/last-mile.entity.ts
@@ -30,6 +30,15 @@ export class LastMile extends BaseEntity {
   @Column({ name: 'status', type: 'varchar', length: 30, default: 'PAYMENT_PENDING' })
   status!: LastMileStatus;
 
+  // Truck-detention window. arrivedAt = vehicle reached destination (IN_TRANSIT);
+  // deliveredAt = cargo cleared / vehicle returned (DELIVERED). Detention accrues
+  // between them beyond the rule's grace hours (default 3h), per truck per day.
+  @Column({ name: 'arrived_at', type: 'timestamptz', nullable: true })
+  arrivedAt?: Date | null;
+
+  @Column({ name: 'delivered_at', type: 'timestamptz', nullable: true })
+  deliveredAt?: Date | null;
+
   @Column({ name: 'advanced_payment', type: 'numeric', precision: 14, scale: 2, default: 0 })
   advancedPayment!: number;
 
diff --git a/apps/edr-freight-api/src/modules/last-mile/last-mile-invoice.service.ts b/apps/edr-freight-api/src/modules/last-mile/last-mile-invoice.service.ts
index 7b14f6887..8a6ec0779 100644
--- a/apps/edr-freight-api/src/modules/last-mile/last-mile-invoice.service.ts
+++ b/apps/edr-freight-api/src/modules/last-mile/last-mile-invoice.service.ts
@@ -1,4 +1,4 @@
-import { Injectable, Logger } from '@nestjs/common';
+import { BadRequestException, Injectable, Logger } from '@nestjs/common';
 import { OnEvent } from '@nestjs/event-emitter';
 import { Freight } from '@edr/types';
 
@@ -63,6 +63,30 @@ export class LastMileInvoiceService {
       return null;
     }
 
+    // Reject mixed-currency truck sets — a single invoice can only be one
+    // currency, and amounts across currencies can't be summed.
+    const billableTrucks = (record.vehicleAssignments ?? []).filter(
+      (a) => Number(a.distanceKm) > 0,
+    );
+    const currencies = [
+      ...new Set(
+        billableTrucks
+          .map((a) => (a.vehicle as { currency?: string } | undefined)?.currency)
+          .filter((c): c is string => Boolean(c)),
+      ),
+    ];
+    if (currencies.length > 1) {
+      throw new BadRequestException(
+        `Cannot generate invoice: assigned trucks use mixed currencies (${currencies.join(', ')}). Assign trucks that share one currency.`,
+      );
+    }
+
+    // Currency follows the truck (price/km is quoted per vehicle), falling back
+    // to the booking's currency, then ETB.
+    const truckCurrency =
+      (record.vehicle as { currency?: string } | undefined)?.currency ||
+      (record.vehicleAssignments?.[0]?.vehicle as { currency?: string } | undefined)?.currency;
+
     // Generate invoice with remainingPayment as totalAmount
     const input: GenerateInvoiceInput = {
       source: 'last_mile' as Freight.InvoiceSource,
@@ -70,7 +94,7 @@ export class LastMileInvoiceService {
       type: 'DELIVERY_FEE',
       companyId: lm.booking!.companyId,
       companyProfileId: lm.booking!.companyProfileId || '',
-      currency: lm.booking!.paymentCurrency || 'ETB',
+      currency: truckCurrency || lm.booking!.paymentCurrency || 'ETB',
       lines: [
         {
           chargeType: 'DELIVERY',
diff --git a/apps/edr-freight-api/src/modules/last-mile/last-mile.controller.ts b/apps/edr-freight-api/src/modules/last-mile/last-mile.controller.ts
index 2931a1f85..207b71a25 100644
--- a/apps/edr-freight-api/src/modules/last-mile/last-mile.controller.ts
+++ b/apps/edr-freight-api/src/modules/last-mile/last-mile.controller.ts
@@ -14,7 +14,8 @@ import {
 } from '@nestjs/common';
 import { ApiBearerAuth, ApiOperation, ApiTags } from '@nestjs/swagger';
 
-import { TrainSchedulingManage, TrainSchedulingView } from '../../common/booking-guards';
+import { BookingStaff } from '../../common/booking-guards';
+import { FREIGHT_PERMS } from '../../seed/freight-permissions.registry';
 
 import { CreateLastMileDto } from './dto/create-last-mile.dto';
 import { UpdateLastMileDto } from './dto/update-last-mile.dto';
@@ -27,7 +28,7 @@ import { LastMileInvoiceService } from './last-mile-invoice.service';
 @ApiTags('last-mile')
 @ApiBearerAuth()
 @Controller('last-mile')
-@TrainSchedulingView()
+@BookingStaff(FREIGHT_PERMS.lastMile.view)
 export class LastMileController {
   constructor(
     private readonly lastMileService: LastMileService,
@@ -63,21 +64,21 @@ export class LastMileController {
   }
 
   @Post('accept/:reference')
-  @TrainSchedulingManage()
+  @BookingStaff(FREIGHT_PERMS.lastMile.accept)
   @ApiOperation({ summary: 'Accept a paid booking and create a last-mile leg' })
   acceptBooking(@Param('reference') reference: string) {
     return this.lastMileService.acceptBookingByReference(reference);
   }
 
   @Post()
-  @TrainSchedulingManage()
+  @BookingStaff(FREIGHT_PERMS.lastMile.create)
   @ApiOperation({ summary: 'Create a last-mile leg' })
   create(@Body() dto: CreateLastMileDto) {
     return this.lastMileService.create(dto);
   }
 
   @Patch(':id')
-  @TrainSchedulingManage()
+  @BookingStaff(FREIGHT_PERMS.lastMile.update)
   @ApiOperation({ summary: 'Update a last-mile leg' })
   async update(@Param('id', ParseUUIDPipe) id: string, @Body() dto: UpdateLastMileDto) {
     // No invoice side-effects here — invoices are generated only via the
@@ -86,7 +87,7 @@ export class LastMileController {
   }
 
   @Delete(':id')
-  @TrainSchedulingManage()
+  @BookingStaff(FREIGHT_PERMS.lastMile.delete)
   @HttpCode(HttpStatus.NO_CONTENT)
   @ApiOperation({ summary: 'Soft-delete a last-mile leg' })
   remove(@Param('id', ParseUUIDPipe) id: string) {
@@ -95,7 +96,7 @@ export class LastMileController {
 
 
   @Post(':id/vehicles')
-  @TrainSchedulingManage()
+  @BookingStaff(FREIGHT_PERMS.lastMile.assignVehicles)
   @ApiOperation({ summary: 'Set the vehicles assigned to a last-mile delivery (multi-truck)' })
   async setVehicles(
     @Param('id', ParseUUIDPipe) id: string,
@@ -105,7 +106,7 @@ export class LastMileController {
   }
 
   @Post(':id/distances')
-  @TrainSchedulingManage()
+  @BookingStaff(FREIGHT_PERMS.lastMile.setDistances)
   @ApiOperation({ summary: 'Set per-vehicle actual distances (does not generate an invoice)' })
   async setDistances(
     @Param('id', ParseUUIDPipe) id: string,
@@ -115,7 +116,7 @@ export class LastMileController {
   }
 
   @Post(':id/invoice')
-  @TrainSchedulingManage()
+  @BookingStaff(FREIGHT_PERMS.lastMile.generateInvoice)
   @ApiOperation({ summary: 'Generate the delivery-fee invoice for a last-mile leg' })
   async generateInvoice(@Param('id', ParseUUIDPipe) id: string) {
     const record = await this.lastMileService.findById(id);
diff --git a/apps/edr-freight-api/src/modules/last-mile/last-mile.service.ts b/apps/edr-freight-api/src/modules/last-mile/last-mile.service.ts
index 22f25a6aa..15b8df3e7 100644
--- a/apps/edr-freight-api/src/modules/last-mile/last-mile.service.ts
+++ b/apps/edr-freight-api/src/modules/last-mile/last-mile.service.ts
@@ -282,6 +282,17 @@ export class LastMileService {
       ...(dto.exactKm !== undefined ? { exactKm: dto.exactKm } : {}),
       ...(dto.vehicleId !== undefined ? { vehicleId: dto.vehicleId } : {}),
       ...(dtoAny.paid !== undefined ? { paid: dtoAny.paid } : {}),
+      // Truck-detention clock: stamp arrival when the vehicle goes IN_TRANSIT and
+      // delivery when it reaches DELIVERED (first time only). Explicit dto values
+      // below override the auto-stamp so staff can record the real times.
+      ...(dto.status === 'IN_TRANSIT' && existing.status !== 'IN_TRANSIT' && !existing.arrivedAt
+        ? { arrivedAt: new Date() }
+        : {}),
+      ...(dto.status === 'DELIVERED' && existing.status !== 'DELIVERED' && !existing.deliveredAt
+        ? { deliveredAt: new Date() }
+        : {}),
+      ...(dtoAny.arrivedAt !== undefined ? { arrivedAt: dtoAny.arrivedAt ? new Date(dtoAny.arrivedAt) : null } : {}),
+      ...(dtoAny.deliveredAt !== undefined ? { deliveredAt: dtoAny.deliveredAt ? new Date(dtoAny.deliveredAt) : null } : {}),
     } as any);
 
     if (!updated) {
@@ -510,10 +521,24 @@ export class LastMileService {
         { distanceKm: d.distanceKm },
       );
     }
-    const total = distances.reduce((s, d) => s + (Number(d.distanceKm) || 0), 0);
+
+    // Billing is per truck: amount = Σ (truck distance × truck price/km). The
+    // per-vehicle rate + currency live on the vehicle, so we ignore the legacy
+    // LAST_MILE flat rate and any client-sent amount. `remainingPayment` param
+    // kept only for signature back-compat.
+    void remainingPayment;
+    const assignments = await this.dataSource.manager.find(LastMileVehicleAssignment, {
+      where: { lastMileId: id },
+      relations: { vehicle: true },
+    });
+    const total = assignments.reduce((s, a) => s + (Number(a.distanceKm) || 0), 0);
+    const amount = assignments.reduce(
+      (s, a) => s + (Number(a.distanceKm) || 0) * (Number(a.vehicle?.pricePerKm) || 0),
+      0,
+    );
     await this.lastMileRepository.update(id, {
       exactKm: total,
-      ...(remainingPayment != null ? { remainingPayment } : {}),
+      remainingPayment: amount,
     } as any);
     return this.findById(id);
   }
diff --git a/apps/edr-freight-api/src/modules/maintenance/dto/create-maintenance-depth.dto.ts b/apps/edr-freight-api/src/modules/maintenance/dto/create-maintenance-depth.dto.ts
new file mode 100644
index 000000000..56c886a74
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/maintenance/dto/create-maintenance-depth.dto.ts
@@ -0,0 +1,171 @@
+import {
+  IsUUID,
+  IsString,
+  IsDateString,
+  IsNumber,
+  IsInt,
+  IsOptional,
+  IsEnum,
+  Min,
+} from 'class-validator';
+import { WorkOrderStatus, WorkOrderPriority } from '../entities/work-order.entity';
+
+export class CreateWorkOrderDto {
+  @IsUUID()
+  vehicleId!: string;
+
+  @IsString()
+  title!: string;
+
+  @IsOptional()
+  @IsString()
+  description?: string;
+
+  @IsOptional()
+  @IsEnum(WorkOrderStatus)
+  status?: WorkOrderStatus;
+
+  @IsOptional()
+  @IsEnum(WorkOrderPriority)
+  priority?: WorkOrderPriority;
+
+  @IsOptional()
+  @IsString()
+  assignedTo?: string;
+
+  @IsOptional()
+  @IsDateString()
+  openedAt?: string;
+
+  @IsOptional()
+  @IsDateString()
+  closedAt?: string;
+
+  @IsOptional()
+  @IsNumber()
+  laborCost?: number;
+
+  @IsOptional()
+  @IsNumber()
+  partsCost?: number;
+}
+
+export class UpdateWorkOrderDto {
+  @IsOptional()
+  @IsString()
+  title?: string;
+
+  @IsOptional()
+  @IsString()
+  description?: string;
+
+  @IsOptional()
+  @IsEnum(WorkOrderStatus)
+  status?: WorkOrderStatus;
+
+  @IsOptional()
+  @IsEnum(WorkOrderPriority)
+  priority?: WorkOrderPriority;
+
+  @IsOptional()
+  @IsString()
+  assignedTo?: string;
+
+  @IsOptional()
+  @IsDateString()
+  closedAt?: string;
+
+  @IsOptional()
+  @IsNumber()
+  laborCost?: number;
+
+  @IsOptional()
+  @IsNumber()
+  partsCost?: number;
+}
+
+export class CreatePartDto {
+  @IsString()
+  name!: string;
+
+  @IsOptional()
+  @IsString()
+  sku?: string;
+
+  @IsOptional()
+  @IsString()
+  category?: string;
+
+  @IsOptional()
+  @IsInt()
+  @Min(0)
+  quantityInStock?: number;
+
+  @IsOptional()
+  @IsInt()
+  @Min(0)
+  reorderLevel?: number;
+
+  @IsOptional()
+  @IsNumber()
+  unitCost?: number;
+
+  @IsOptional()
+  @IsString()
+  location?: string;
+}
+
+export class UpdatePartDto {
+  @IsOptional()
+  @IsString()
+  name?: string;
+
+  @IsOptional()
+  @IsString()
+  sku?: string;
+
+  @IsOptional()
+  @IsString()
+  category?: string;
+
+  @IsOptional()
+  @IsInt()
+  @Min(0)
+  quantityInStock?: number;
+
+  @IsOptional()
+  @IsInt()
+  @Min(0)
+  reorderLevel?: number;
+
+  @IsOptional()
+  @IsNumber()
+  unitCost?: number;
+
+  @IsOptional()
+  @IsString()
+  location?: string;
+}
+
+export class CreateWarrantyDto {
+  @IsUUID()
+  vehicleId!: string;
+
+  @IsString()
+  component!: string;
+
+  @IsOptional()
+  @IsString()
+  provider?: string;
+
+  @IsOptional()
+  @IsDateString()
+  startDate?: string;
+
+  @IsDateString()
+  expiryDate!: string;
+
+  @IsOptional()
+  @IsString()
+  coverageNotes?: string;
+}
diff --git a/apps/edr-freight-api/src/modules/maintenance/entities/part.entity.ts b/apps/edr-freight-api/src/modules/maintenance/entities/part.entity.ts
new file mode 100644
index 000000000..caa478d88
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/maintenance/entities/part.entity.ts
@@ -0,0 +1,27 @@
+import { BaseEntity } from '@edr/api-common';
+import { Entity, Column, Index } from 'typeorm';
+
+@Entity({ name: 'parts', schema: 'freight' })
+@Index(['category'])
+export class Part extends BaseEntity {
+  @Column({ name: 'name', type: 'varchar' })
+  name!: string;
+
+  @Column({ name: 'sku', type: 'varchar', nullable: true })
+  sku?: string;
+
+  @Column({ name: 'category', type: 'varchar', nullable: true })
+  category?: string; // includes 'TIRE' — doubles as tire inventory
+
+  @Column({ name: 'quantity_in_stock', type: 'int', default: 0 })
+  quantityInStock!: number;
+
+  @Column({ name: 'reorder_level', type: 'int', default: 0 })
+  reorderLevel!: number;
+
+  @Column({ name: 'unit_cost', type: 'numeric', precision: 14, scale: 2, nullable: true })
+  unitCost?: number;
+
+  @Column({ name: 'location', type: 'varchar', nullable: true })
+  location?: string;
+}
diff --git a/apps/edr-freight-api/src/modules/maintenance/entities/warranty.entity.ts b/apps/edr-freight-api/src/modules/maintenance/entities/warranty.entity.ts
new file mode 100644
index 000000000..56c44fcbd
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/maintenance/entities/warranty.entity.ts
@@ -0,0 +1,29 @@
+import { BaseEntity } from '@edr/api-common';
+import { Entity, Column, ManyToOne, JoinColumn, Index } from 'typeorm';
+import { Vehicle } from '../../vehicles/entities/vehicle.entity';
+
+@Entity({ name: 'warranties', schema: 'freight' })
+@Index(['vehicleId', 'expiryDate'])
+export class Warranty extends BaseEntity {
+  @Column({ name: 'vehicle_id', type: 'uuid' })
+  vehicleId!: string;
+
+  @ManyToOne(() => Vehicle, { eager: false })
+  @JoinColumn({ name: 'vehicle_id' })
+  vehicle!: Vehicle;
+
+  @Column({ name: 'component', type: 'varchar' })
+  component!: string;
+
+  @Column({ name: 'provider', type: 'varchar', nullable: true })
+  provider?: string;
+
+  @Column({ name: 'start_date', type: 'date', nullable: true })
+  startDate?: string;
+
+  @Column({ name: 'expiry_date', type: 'date' })
+  expiryDate!: string;
+
+  @Column({ name: 'coverage_notes', type: 'text', nullable: true })
+  coverageNotes?: string;
+}
diff --git a/apps/edr-freight-api/src/modules/maintenance/entities/work-order.entity.ts b/apps/edr-freight-api/src/modules/maintenance/entities/work-order.entity.ts
new file mode 100644
index 000000000..224b74f74
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/maintenance/entities/work-order.entity.ts
@@ -0,0 +1,55 @@
+import { BaseEntity } from '@edr/api-common';
+import { Entity, Column, ManyToOne, JoinColumn, Index } from 'typeorm';
+import { Vehicle } from '../../vehicles/entities/vehicle.entity';
+
+export enum WorkOrderStatus {
+  OPEN = 'OPEN',
+  IN_PROGRESS = 'IN_PROGRESS',
+  COMPLETED = 'COMPLETED',
+  CANCELLED = 'CANCELLED',
+}
+
+export enum WorkOrderPriority {
+  LOW = 'LOW',
+  MEDIUM = 'MEDIUM',
+  HIGH = 'HIGH',
+  URGENT = 'URGENT',
+}
+
+@Entity({ name: 'work_orders', schema: 'freight' })
+@Index(['vehicleId', 'status'])
+export class WorkOrder extends BaseEntity {
+  @Column({ name: 'vehicle_id', type: 'uuid' })
+  vehicleId!: string;
+
+  @ManyToOne(() => Vehicle, { eager: false })
+  @JoinColumn({ name: 'vehicle_id' })
+  vehicle!: Vehicle;
+
+  @Column({ name: 'title', type: 'varchar' })
+  title!: string;
+
+  @Column({ name: 'description', type: 'text', nullable: true })
+  description?: string;
+
+  @Column({ name: 'status', type: 'varchar', default: WorkOrderStatus.OPEN })
+  status!: WorkOrderStatus;
+
+  @Column({ name: 'priority', type: 'varchar', default: WorkOrderPriority.MEDIUM })
+  priority!: WorkOrderPriority;
+
+  @Column({ name: 'assigned_to', type: 'varchar', nullable: true })
+  assignedTo?: string;
+
+  @Column({ name: 'opened_at', type: 'timestamptz' })
+  openedAt!: Date;
+
+  @Column({ name: 'closed_at', type: 'timestamptz', nullable: true })
+  closedAt?: Date;
+
+  @Column({ name: 'labor_cost', type: 'numeric', precision: 14, scale: 2, nullable: true })
+  laborCost?: number;
+
+  @Column({ name: 'parts_cost', type: 'numeric', precision: 14, scale: 2, nullable: true })
+  partsCost?: number;
+}
diff --git a/apps/edr-freight-api/src/modules/maintenance/maintenance-depth.service.ts b/apps/edr-freight-api/src/modules/maintenance/maintenance-depth.service.ts
new file mode 100644
index 000000000..212fe909a
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/maintenance/maintenance-depth.service.ts
@@ -0,0 +1,99 @@
+import { Injectable, NotFoundException } from '@nestjs/common';
+import { WorkOrderRepository } from './work-order.repository';
+import { PartRepository } from './part.repository';
+import { WarrantyRepository } from './warranty.repository';
+import { WorkOrder, WorkOrderStatus } from './entities/work-order.entity';
+import { Part } from './entities/part.entity';
+import { Warranty } from './entities/warranty.entity';
+import {
+  CreateWorkOrderDto,
+  UpdateWorkOrderDto,
+  CreatePartDto,
+  UpdatePartDto,
+  CreateWarrantyDto,
+} from './dto/create-maintenance-depth.dto';
+
+@Injectable()
+export class MaintenanceDepthService {
+  constructor(
+    private readonly workOrderRepository: WorkOrderRepository,
+    private readonly partRepository: PartRepository,
+    private readonly warrantyRepository: WarrantyRepository,
+  ) {}
+
+  // ---- Work Orders ----
+
+  async createWorkOrder(dto: CreateWorkOrderDto): Promise<WorkOrder> {
+    return this.workOrderRepository.create({
+      ...dto,
+      openedAt: dto.openedAt ? new Date(dto.openedAt) : new Date(),
+      closedAt: dto.closedAt ? new Date(dto.closedAt) : undefined,
+    });
+  }
+
+  async findWorkOrders(filters: { vehicleId?: string; status?: WorkOrderStatus }) {
+    return this.workOrderRepository.findFiltered(filters);
+  }
+
+  async findWorkOrderById(id: string): Promise<WorkOrder> {
+    const workOrder = await this.workOrderRepository.findById(id);
+    if (!workOrder) throw new NotFoundException(`Work order ${id} not found`);
+    return workOrder;
+  }
+
+  async updateWorkOrder(id: string, dto: UpdateWorkOrderDto): Promise<WorkOrder> {
+    await this.findWorkOrderById(id);
+    const updated = await this.workOrderRepository.update(id, {
+      ...dto,
+      closedAt: dto.closedAt ? new Date(dto.closedAt) : undefined,
+    });
+    return updated!;
+  }
+
+  async deleteWorkOrder(id: string): Promise<{ id: string; deleted: boolean }> {
+    await this.findWorkOrderById(id);
+    await this.workOrderRepository.softDelete(id);
+    return { id, deleted: true };
+  }
+
+  // ---- Parts / Tires ----
+
+  async createPart(dto: CreatePartDto): Promise<Part> {
+    return this.partRepository.create({ ...dto });
+  }
+
+  async findParts(filters: { category?: string; lowStock?: boolean }) {
+    return this.partRepository.findFiltered(filters);
+  }
+
+  async updatePart(id: string, dto: UpdatePartDto): Promise<Part> {
+    const part = await this.partRepository.findById(id);
+    if (!part) throw new NotFoundException(`Part ${id} not found`);
+    const updated = await this.partRepository.update(id, { ...dto });
+    return updated!;
+  }
+
+  async deletePart(id: string): Promise<{ id: string; deleted: boolean }> {
+    const part = await this.partRepository.findById(id);
+    if (!part) throw new NotFoundException(`Part ${id} not found`);
+    await this.partRepository.softDelete(id);
+    return { id, deleted: true };
+  }
+
+  // ---- Warranties ----
+
+  async createWarranty(dto: CreateWarrantyDto): Promise<Warranty> {
+    return this.warrantyRepository.create({ ...dto });
+  }
+
+  async findWarranties(filters: { vehicleId?: string }) {
+    return this.warrantyRepository.findFiltered(filters);
+  }
+
+  async deleteWarranty(id: string): Promise<{ id: string; deleted: boolean }> {
+    const warranty = await this.warrantyRepository.findById(id);
+    if (!warranty) throw new NotFoundException(`Warranty ${id} not found`);
+    await this.warrantyRepository.softDelete(id);
+    return { id, deleted: true };
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/maintenance/maintenance.controller.ts b/apps/edr-freight-api/src/modules/maintenance/maintenance.controller.ts
index de5ff08f2..4ad8026f2 100644
--- a/apps/edr-freight-api/src/modules/maintenance/maintenance.controller.ts
+++ b/apps/edr-freight-api/src/modules/maintenance/maintenance.controller.ts
@@ -1,52 +1,173 @@
-import { Controller, Post, Get, Patch, Body, Param } from '@nestjs/common';
-import { ApiTags, ApiOperation } from '@nestjs/swagger';
+import { Controller, Post, Get, Patch, Delete, Body, Param, Query } from '@nestjs/common';
+import { ApiBearerAuth, ApiTags, ApiOperation } from '@nestjs/swagger';
+import { BookingStaff } from '../../common/booking-guards';
+import { FREIGHT_PERMS } from '../../seed/freight-permissions.registry';
 import { MaintenanceService } from './maintenance.service';
+import { MaintenanceDepthService } from './maintenance-depth.service';
 import { CreateMaintenanceScheduleDto, CreateMaintenanceCostDto, UpdateMaintenanceScheduleDto } from './dto/create-maintenance.dto';
+import {
+  CreateWorkOrderDto,
+  UpdateWorkOrderDto,
+  CreatePartDto,
+  UpdatePartDto,
+  CreateWarrantyDto,
+} from './dto/create-maintenance-depth.dto';
+import { WorkOrderStatus } from './entities/work-order.entity';
 
 @ApiTags('Maintenance Management')
+@ApiBearerAuth()
 @Controller('maintenance')
 export class MaintenanceController {
-  constructor(private readonly maintenanceService: MaintenanceService) {}
+  constructor(
+    private readonly maintenanceService: MaintenanceService,
+    private readonly maintenanceDepthService: MaintenanceDepthService,
+  ) {}
 
   @Post('schedules')
+  @BookingStaff(FREIGHT_PERMS.maintenance.create)
   @ApiOperation({ summary: 'Schedule maintenance' })
   async scheduleMaintenanceAsync(@Body() dto: CreateMaintenanceScheduleDto) {
     return this.maintenanceService.scheduleMaintenanceAsync(dto);
   }
 
   @Post('costs')
+  @BookingStaff(FREIGHT_PERMS.maintenance.create)
   @ApiOperation({ summary: 'Record maintenance cost' })
   async recordCost(@Body() dto: CreateMaintenanceCostDto) {
     return this.maintenanceService.recordMaintenanceCost(dto);
   }
 
   @Patch('schedules/:id')
+  @BookingStaff(FREIGHT_PERMS.maintenance.update)
   @ApiOperation({ summary: 'Update maintenance schedule' })
   async updateSchedule(@Param('id') id: string, @Body() dto: UpdateMaintenanceScheduleDto) {
     return this.maintenanceService.updateMaintenanceSchedule(id, dto);
   }
 
   @Get('upcoming/:vehicleId')
+  @BookingStaff(FREIGHT_PERMS.maintenance.view)
   @ApiOperation({ summary: 'Get upcoming maintenance' })
   async getUpcoming(@Param('vehicleId') vehicleId: string) {
     return this.maintenanceService.getUpcomingMaintenance(vehicleId);
   }
 
   @Get('history/:vehicleId')
+  @BookingStaff(FREIGHT_PERMS.maintenance.view)
   @ApiOperation({ summary: 'Get maintenance history' })
   async getHistory(@Param('vehicleId') vehicleId: string) {
     return this.maintenanceService.getMaintenanceHistory(vehicleId);
   }
 
   @Get('stats')
+  @BookingStaff([FREIGHT_PERMS.maintenance.view, FREIGHT_PERMS.fleetReports.view, FREIGHT_PERMS.fleetDashboard.view])
   @ApiOperation({ summary: 'Get fleet-wide maintenance statistics' })
   async getFleetStats() {
     return this.maintenanceService.getFleetMaintenanceStats();
   }
 
   @Get('stats/:vehicleId')
+  @BookingStaff([FREIGHT_PERMS.maintenance.view, FREIGHT_PERMS.fleetReports.view, FREIGHT_PERMS.fleetDashboard.view])
   @ApiOperation({ summary: 'Get maintenance statistics' })
   async getStats(@Param('vehicleId') vehicleId: string) {
     return this.maintenanceService.getVehicleMaintenanceStats(vehicleId);
   }
+
+  // ---- Work Orders ----
+
+  @Post('work-orders')
+  @BookingStaff(FREIGHT_PERMS.maintenance.create)
+  @ApiOperation({ summary: 'Create work order' })
+  async createWorkOrder(@Body() dto: CreateWorkOrderDto) {
+    return this.maintenanceDepthService.createWorkOrder(dto);
+  }
+
+  @Get('work-orders')
+  @BookingStaff(FREIGHT_PERMS.maintenance.view)
+  @ApiOperation({ summary: 'List work orders' })
+  async listWorkOrders(
+    @Query('vehicleId') vehicleId?: string,
+    @Query('status') status?: WorkOrderStatus,
+  ) {
+    return this.maintenanceDepthService.findWorkOrders({ vehicleId, status });
+  }
+
+  @Get('work-orders/:id')
+  @BookingStaff(FREIGHT_PERMS.maintenance.view)
+  @ApiOperation({ summary: 'Get work order' })
+  async getWorkOrder(@Param('id') id: string) {
+    return this.maintenanceDepthService.findWorkOrderById(id);
+  }
+
+  @Patch('work-orders/:id')
+  @BookingStaff(FREIGHT_PERMS.maintenance.update)
+  @ApiOperation({ summary: 'Update work order' })
+  async updateWorkOrder(@Param('id') id: string, @Body() dto: UpdateWorkOrderDto) {
+    return this.maintenanceDepthService.updateWorkOrder(id, dto);
+  }
+
+  @Delete('work-orders/:id')
+  @BookingStaff(FREIGHT_PERMS.maintenance.delete)
+  @ApiOperation({ summary: 'Delete work order' })
+  async deleteWorkOrder(@Param('id') id: string) {
+    return this.maintenanceDepthService.deleteWorkOrder(id);
+  }
+
+  // ---- Parts / Tires ----
+
+  @Post('parts')
+  @BookingStaff(FREIGHT_PERMS.maintenance.create)
+  @ApiOperation({ summary: 'Create part' })
+  async createPart(@Body() dto: CreatePartDto) {
+    return this.maintenanceDepthService.createPart(dto);
+  }
+
+  @Get('parts')
+  @BookingStaff(FREIGHT_PERMS.maintenance.view)
+  @ApiOperation({ summary: 'List parts / tire inventory' })
+  async listParts(
+    @Query('category') category?: string,
+    @Query('lowStock') lowStock?: string,
+  ) {
+    return this.maintenanceDepthService.findParts({
+      category,
+      lowStock: lowStock === 'true',
+    });
+  }
+
+  @Patch('parts/:id')
+  @BookingStaff(FREIGHT_PERMS.maintenance.update)
+  @ApiOperation({ summary: 'Update part' })
+  async updatePart(@Param('id') id: string, @Body() dto: UpdatePartDto) {
+    return this.maintenanceDepthService.updatePart(id, dto);
+  }
+
+  @Delete('parts/:id')
+  @BookingStaff(FREIGHT_PERMS.maintenance.delete)
+  @ApiOperation({ summary: 'Delete part' })
+  async deletePart(@Param('id') id: string) {
+    return this.maintenanceDepthService.deletePart(id);
+  }
+
+  // ---- Warranties ----
+
+  @Post('warranties')
+  @BookingStaff(FREIGHT_PERMS.maintenance.create)
+  @ApiOperation({ summary: 'Create warranty' })
+  async createWarranty(@Body() dto: CreateWarrantyDto) {
+    return this.maintenanceDepthService.createWarranty(dto);
+  }
+
+  @Get('warranties')
+  @BookingStaff(FREIGHT_PERMS.maintenance.view)
+  @ApiOperation({ summary: 'List warranties' })
+  async listWarranties(@Query('vehicleId') vehicleId?: string) {
+    return this.maintenanceDepthService.findWarranties({ vehicleId });
+  }
+
+  @Delete('warranties/:id')
+  @BookingStaff(FREIGHT_PERMS.maintenance.delete)
+  @ApiOperation({ summary: 'Delete warranty' })
+  async deleteWarranty(@Param('id') id: string) {
+    return this.maintenanceDepthService.deleteWarranty(id);
+  }
 }
diff --git a/apps/edr-freight-api/src/modules/maintenance/maintenance.module.ts b/apps/edr-freight-api/src/modules/maintenance/maintenance.module.ts
index a0227a733..8f4fe1d0b 100644
--- a/apps/edr-freight-api/src/modules/maintenance/maintenance.module.ts
+++ b/apps/edr-freight-api/src/modules/maintenance/maintenance.module.ts
@@ -2,14 +2,30 @@ import { Module } from '@nestjs/common';
 import { TypeOrmModule } from '@nestjs/typeorm';
 import { MaintenanceSchedule } from './entities/maintenance-schedule.entity';
 import { MaintenanceCost } from './entities/maintenance-cost.entity';
+import { WorkOrder } from './entities/work-order.entity';
+import { Part } from './entities/part.entity';
+import { Warranty } from './entities/warranty.entity';
 import { MaintenanceService } from './maintenance.service';
+import { MaintenanceDepthService } from './maintenance-depth.service';
 import { MaintenanceRepository } from './maintenance.repository';
+import { WorkOrderRepository } from './work-order.repository';
+import { PartRepository } from './part.repository';
+import { WarrantyRepository } from './warranty.repository';
 import { MaintenanceController } from './maintenance.controller';
 
 @Module({
-  imports: [TypeOrmModule.forFeature([MaintenanceSchedule, MaintenanceCost])],
-  providers: [MaintenanceService, MaintenanceRepository],
+  imports: [
+    TypeOrmModule.forFeature([MaintenanceSchedule, MaintenanceCost, WorkOrder, Part, Warranty]),
+  ],
+  providers: [
+    MaintenanceService,
+    MaintenanceDepthService,
+    MaintenanceRepository,
+    WorkOrderRepository,
+    PartRepository,
+    WarrantyRepository,
+  ],
   controllers: [MaintenanceController],
-  exports: [MaintenanceService],
+  exports: [MaintenanceService, MaintenanceDepthService],
 })
 export class MaintenanceModule {}
diff --git a/apps/edr-freight-api/src/modules/maintenance/part.repository.ts b/apps/edr-freight-api/src/modules/maintenance/part.repository.ts
new file mode 100644
index 000000000..d6b221332
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/maintenance/part.repository.ts
@@ -0,0 +1,27 @@
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { BaseRepository } from '@edr/api-common';
+import { Repository } from 'typeorm';
+import { Part } from './entities/part.entity';
+
+@Injectable()
+export class PartRepository extends BaseRepository<Part> {
+  constructor(
+    @InjectRepository(Part)
+    private readonly partRepository: Repository<Part>,
+  ) {
+    super(partRepository);
+  }
+
+  async findFiltered(filters: { category?: string; lowStock?: boolean }) {
+    const qb = this.partRepository.createQueryBuilder('part');
+    if (filters.category) {
+      qb.andWhere('part.category = :category', { category: filters.category });
+    }
+    if (filters.lowStock) {
+      qb.andWhere('part.quantityInStock <= part.reorderLevel');
+    }
+    qb.orderBy('part.name', 'ASC');
+    return qb.getMany();
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/maintenance/warranty.repository.ts b/apps/edr-freight-api/src/modules/maintenance/warranty.repository.ts
new file mode 100644
index 000000000..e59bd358d
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/maintenance/warranty.repository.ts
@@ -0,0 +1,24 @@
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { BaseRepository } from '@edr/api-common';
+import { Repository, FindOptionsWhere } from 'typeorm';
+import { Warranty } from './entities/warranty.entity';
+
+@Injectable()
+export class WarrantyRepository extends BaseRepository<Warranty> {
+  constructor(
+    @InjectRepository(Warranty)
+    private readonly warrantyRepository: Repository<Warranty>,
+  ) {
+    super(warrantyRepository);
+  }
+
+  async findFiltered(filters: { vehicleId?: string }) {
+    const where: FindOptionsWhere<Warranty> = {};
+    if (filters.vehicleId) where.vehicleId = filters.vehicleId;
+    return this.warrantyRepository.find({
+      where,
+      order: { expiryDate: 'ASC' },
+    });
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/maintenance/work-order.repository.ts b/apps/edr-freight-api/src/modules/maintenance/work-order.repository.ts
new file mode 100644
index 000000000..057f1fa6d
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/maintenance/work-order.repository.ts
@@ -0,0 +1,25 @@
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { BaseRepository } from '@edr/api-common';
+import { Repository, FindOptionsWhere } from 'typeorm';
+import { WorkOrder, WorkOrderStatus } from './entities/work-order.entity';
+
+@Injectable()
+export class WorkOrderRepository extends BaseRepository<WorkOrder> {
+  constructor(
+    @InjectRepository(WorkOrder)
+    private readonly workOrderRepository: Repository<WorkOrder>,
+  ) {
+    super(workOrderRepository);
+  }
+
+  async findFiltered(filters: { vehicleId?: string; status?: WorkOrderStatus }) {
+    const where: FindOptionsWhere<WorkOrder> = {};
+    if (filters.vehicleId) where.vehicleId = filters.vehicleId;
+    if (filters.status) where.status = filters.status;
+    return this.workOrderRepository.find({
+      where,
+      order: { openedAt: 'DESC' },
+    });
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/notification-inbox/notification-recipients.service.ts b/apps/edr-freight-api/src/modules/notification-inbox/notification-recipients.service.ts
index 265e19303..be7964a3d 100644
--- a/apps/edr-freight-api/src/modules/notification-inbox/notification-recipients.service.ts
+++ b/apps/edr-freight-api/src/modules/notification-inbox/notification-recipients.service.ts
@@ -70,6 +70,18 @@ export class NotificationRecipientsService {
       }
     }
 
+    if (recipients.allBackoffice) {
+      try {
+        for (const uid of await this.backoffice.getAllCurrentEmployeeUserIds()) {
+          ids.add(uid);
+        }
+      } catch (err) {
+        this.logger.warn(
+          `Failed to resolve allBackoffice recipients: ${(err as Error).message}`,
+        );
+      }
+    }
+
     return [...ids];
   }
 }
diff --git a/apps/edr-freight-api/src/modules/procurement/dto/procurement.dto.ts b/apps/edr-freight-api/src/modules/procurement/dto/procurement.dto.ts
new file mode 100644
index 000000000..943d79296
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/procurement/dto/procurement.dto.ts
@@ -0,0 +1,193 @@
+import {
+  IsUUID,
+  IsString,
+  IsDateString,
+  IsNumber,
+  IsInt,
+  IsOptional,
+  IsEnum,
+  IsBoolean,
+} from 'class-validator';
+import { VendorType } from '../entities/vendor.entity';
+import { AcquisitionType, AcquisitionStatus } from '../entities/asset-acquisition.entity';
+import { DisposalMethod } from '../entities/asset-disposal.entity';
+
+export class CreateVendorDto {
+  @IsString()
+  name!: string;
+
+  @IsOptional()
+  @IsEnum(VendorType)
+  type?: VendorType;
+
+  @IsOptional()
+  @IsString()
+  contactPerson?: string;
+
+  @IsOptional()
+  @IsString()
+  phone?: string;
+
+  @IsOptional()
+  @IsString()
+  email?: string;
+
+  @IsOptional()
+  @IsString()
+  address?: string;
+
+  @IsOptional()
+  @IsBoolean()
+  isActive?: boolean;
+}
+
+export class UpdateVendorDto {
+  @IsOptional()
+  @IsString()
+  name?: string;
+
+  @IsOptional()
+  @IsEnum(VendorType)
+  type?: VendorType;
+
+  @IsOptional()
+  @IsString()
+  contactPerson?: string;
+
+  @IsOptional()
+  @IsString()
+  phone?: string;
+
+  @IsOptional()
+  @IsString()
+  email?: string;
+
+  @IsOptional()
+  @IsString()
+  address?: string;
+
+  @IsOptional()
+  @IsBoolean()
+  isActive?: boolean;
+}
+
+export class CreateAcquisitionDto {
+  @IsOptional()
+  @IsUUID()
+  vehicleId?: string;
+
+  @IsOptional()
+  @IsUUID()
+  vendorId?: string;
+
+  @IsEnum(AcquisitionType)
+  acquisitionType!: AcquisitionType;
+
+  @IsDateString()
+  acquisitionDate!: string;
+
+  @IsOptional()
+  @IsNumber()
+  cost?: number;
+
+  @IsOptional()
+  @IsInt()
+  usefulLifeMonths?: number;
+
+  @IsOptional()
+  @IsNumber()
+  salvageValue?: number;
+
+  @IsOptional()
+  @IsDateString()
+  leaseStart?: string;
+
+  @IsOptional()
+  @IsDateString()
+  leaseEnd?: string;
+
+  @IsOptional()
+  @IsNumber()
+  monthlyPayment?: number;
+
+  @IsOptional()
+  @IsEnum(AcquisitionStatus)
+  status?: AcquisitionStatus;
+
+  @IsOptional()
+  @IsString()
+  notes?: string;
+}
+
+export class UpdateAcquisitionDto {
+  @IsOptional()
+  @IsUUID()
+  vehicleId?: string;
+
+  @IsOptional()
+  @IsUUID()
+  vendorId?: string;
+
+  @IsOptional()
+  @IsEnum(AcquisitionType)
+  acquisitionType?: AcquisitionType;
+
+  @IsOptional()
+  @IsDateString()
+  acquisitionDate?: string;
+
+  @IsOptional()
+  @IsNumber()
+  cost?: number;
+
+  @IsOptional()
+  @IsInt()
+  usefulLifeMonths?: number;
+
+  @IsOptional()
+  @IsNumber()
+  salvageValue?: number;
+
+  @IsOptional()
+  @IsDateString()
+  leaseStart?: string;
+
+  @IsOptional()
+  @IsDateString()
+  leaseEnd?: string;
+
+  @IsOptional()
+  @IsNumber()
+  monthlyPayment?: number;
+
+  @IsOptional()
+  @IsEnum(AcquisitionStatus)
+  status?: AcquisitionStatus;
+
+  @IsOptional()
+  @IsString()
+  notes?: string;
+}
+
+export class CreateDisposalDto {
+  @IsUUID()
+  vehicleId!: string;
+
+  @IsDateString()
+  disposalDate!: string;
+
+  @IsEnum(DisposalMethod)
+  method!: DisposalMethod;
+
+  @IsOptional()
+  @IsNumber()
+  salePrice?: number;
+
+  @IsOptional()
+  @IsString()
+  buyer?: string;
+
+  @IsOptional()
+  @IsString()
+  notes?: string;
+}
diff --git a/apps/edr-freight-api/src/modules/procurement/entities/asset-acquisition.entity.ts b/apps/edr-freight-api/src/modules/procurement/entities/asset-acquisition.entity.ts
new file mode 100644
index 000000000..d4f781c15
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/procurement/entities/asset-acquisition.entity.ts
@@ -0,0 +1,64 @@
+import { BaseEntity } from '@edr/api-common';
+import { Entity, Column, ManyToOne, JoinColumn, Index } from 'typeorm';
+import { Vehicle } from '../../vehicles/entities/vehicle.entity';
+import { Vendor } from './vendor.entity';
+
+export enum AcquisitionType {
+  PURCHASE = 'PURCHASE',
+  LEASE = 'LEASE',
+  RENTAL = 'RENTAL',
+}
+
+export enum AcquisitionStatus {
+  ACTIVE = 'ACTIVE',
+  LEASE_EXPIRING = 'LEASE_EXPIRING',
+  DISPOSED = 'DISPOSED',
+}
+
+@Entity({ name: 'asset_acquisitions', schema: 'freight' })
+@Index(['vehicleId', 'acquisitionDate'])
+export class AssetAcquisition extends BaseEntity {
+  @Column({ name: 'vehicle_id', type: 'uuid', nullable: true })
+  vehicleId?: string;
+
+  @ManyToOne(() => Vehicle, { eager: false, nullable: true, onDelete: 'SET NULL' })
+  @JoinColumn({ name: 'vehicle_id' })
+  vehicle?: Vehicle;
+
+  @Column({ name: 'vendor_id', type: 'uuid', nullable: true })
+  vendorId?: string;
+
+  @ManyToOne(() => Vendor, { eager: false, nullable: true, onDelete: 'SET NULL' })
+  @JoinColumn({ name: 'vendor_id' })
+  vendor?: Vendor;
+
+  @Column({ name: 'acquisition_type', type: 'varchar' })
+  acquisitionType!: AcquisitionType;
+
+  @Column({ name: 'acquisition_date', type: 'date' })
+  acquisitionDate!: string;
+
+  @Column({ name: 'cost', type: 'numeric', precision: 14, scale: 2, nullable: true })
+  cost?: number;
+
+  @Column({ name: 'useful_life_months', type: 'int', nullable: true })
+  usefulLifeMonths?: number;
+
+  @Column({ name: 'salvage_value', type: 'numeric', precision: 14, scale: 2, nullable: true })
+  salvageValue?: number;
+
+  @Column({ name: 'lease_start', type: 'date', nullable: true })
+  leaseStart?: string;
+
+  @Column({ name: 'lease_end', type: 'date', nullable: true })
+  leaseEnd?: string;
+
+  @Column({ name: 'monthly_payment', type: 'numeric', precision: 14, scale: 2, nullable: true })
+  monthlyPayment?: number;
+
+  @Column({ name: 'status', type: 'varchar', default: AcquisitionStatus.ACTIVE })
+  status!: AcquisitionStatus;
+
+  @Column({ name: 'notes', type: 'text', nullable: true })
+  notes?: string;
+}
diff --git a/apps/edr-freight-api/src/modules/procurement/entities/asset-disposal.entity.ts b/apps/edr-freight-api/src/modules/procurement/entities/asset-disposal.entity.ts
new file mode 100644
index 000000000..301e3ec1c
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/procurement/entities/asset-disposal.entity.ts
@@ -0,0 +1,31 @@
+import { BaseEntity } from '@edr/api-common';
+import { Entity, Column, Index } from 'typeorm';
+
+export enum DisposalMethod {
+  SALE = 'SALE',
+  SCRAP = 'SCRAP',
+  RETURN_LEASE = 'RETURN_LEASE',
+  TRADE_IN = 'TRADE_IN',
+}
+
+@Entity({ name: 'asset_disposals', schema: 'freight' })
+@Index(['vehicleId', 'disposalDate'])
+export class AssetDisposal extends BaseEntity {
+  @Column({ name: 'vehicle_id', type: 'uuid' })
+  vehicleId!: string;
+
+  @Column({ name: 'disposal_date', type: 'date' })
+  disposalDate!: string;
+
+  @Column({ name: 'method', type: 'varchar' })
+  method!: DisposalMethod;
+
+  @Column({ name: 'sale_price', type: 'numeric', precision: 14, scale: 2, nullable: true })
+  salePrice?: number;
+
+  @Column({ name: 'buyer', nullable: true })
+  buyer?: string;
+
+  @Column({ name: 'notes', type: 'text', nullable: true })
+  notes?: string;
+}
diff --git a/apps/edr-freight-api/src/modules/procurement/entities/vendor.entity.ts b/apps/edr-freight-api/src/modules/procurement/entities/vendor.entity.ts
new file mode 100644
index 000000000..cbe394d16
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/procurement/entities/vendor.entity.ts
@@ -0,0 +1,34 @@
+import { BaseEntity } from '@edr/api-common';
+import { Entity, Column } from 'typeorm';
+
+export enum VendorType {
+  DEALER = 'DEALER',
+  LEASING = 'LEASING',
+  PARTS = 'PARTS',
+  SERVICE = 'SERVICE',
+  OTHER = 'OTHER',
+}
+
+@Entity({ name: 'vendors', schema: 'freight' })
+export class Vendor extends BaseEntity {
+  @Column({ name: 'name' })
+  name!: string;
+
+  @Column({ name: 'type', type: 'varchar', nullable: true })
+  type?: VendorType;
+
+  @Column({ name: 'contact_person', nullable: true })
+  contactPerson?: string;
+
+  @Column({ name: 'phone', nullable: true })
+  phone?: string;
+
+  @Column({ name: 'email', nullable: true })
+  email?: string;
+
+  @Column({ name: 'address', nullable: true })
+  address?: string;
+
+  @Column({ name: 'is_active', type: 'boolean', default: true })
+  isActive!: boolean;
+}
diff --git a/apps/edr-freight-api/src/modules/procurement/procurement.controller.ts b/apps/edr-freight-api/src/modules/procurement/procurement.controller.ts
new file mode 100644
index 000000000..e5c69f37c
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/procurement/procurement.controller.ts
@@ -0,0 +1,98 @@
+import { Controller, Post, Get, Patch, Delete, Body, Param, Query } from '@nestjs/common';
+import { ApiTags, ApiOperation } from '@nestjs/swagger';
+import { ProcurementService } from './procurement.service';
+import {
+  CreateVendorDto,
+  UpdateVendorDto,
+  CreateAcquisitionDto,
+  UpdateAcquisitionDto,
+  CreateDisposalDto,
+} from './dto/procurement.dto';
+
+@ApiTags('Procurement & Asset Lifecycle')
+@Controller('procurement')
+export class ProcurementController {
+  constructor(private readonly procurementService: ProcurementService) {}
+
+  // ---- Vendors ----
+  @Post('vendors')
+  @ApiOperation({ summary: 'Create a vendor' })
+  async createVendor(@Body() dto: CreateVendorDto) {
+    return this.procurementService.createVendor(dto);
+  }
+
+  @Get('vendors')
+  @ApiOperation({ summary: 'List vendors' })
+  async listVendors() {
+    return this.procurementService.listVendors();
+  }
+
+  @Patch('vendors/:id')
+  @ApiOperation({ summary: 'Update a vendor' })
+  async updateVendor(@Param('id') id: string, @Body() dto: UpdateVendorDto) {
+    return this.procurementService.updateVendor(id, dto);
+  }
+
+  @Delete('vendors/:id')
+  @ApiOperation({ summary: 'Delete a vendor' })
+  async deleteVendor(@Param('id') id: string) {
+    return this.procurementService.deleteVendor(id);
+  }
+
+  // ---- Acquisitions ----
+  @Post('acquisitions')
+  @ApiOperation({ summary: 'Create an asset acquisition' })
+  async createAcquisition(@Body() dto: CreateAcquisitionDto) {
+    return this.procurementService.createAcquisition(dto);
+  }
+
+  @Get('acquisitions')
+  @ApiOperation({ summary: 'List asset acquisitions (optionally filtered by vehicleId)' })
+  async listAcquisitions(@Query('vehicleId') vehicleId?: string) {
+    return this.procurementService.listAcquisitions(vehicleId);
+  }
+
+  @Get('acquisitions/:id')
+  @ApiOperation({ summary: 'Get an asset acquisition by id' })
+  async getAcquisition(@Param('id') id: string) {
+    return this.procurementService.getAcquisition(id);
+  }
+
+  @Patch('acquisitions/:id')
+  @ApiOperation({ summary: 'Update an asset acquisition' })
+  async updateAcquisition(@Param('id') id: string, @Body() dto: UpdateAcquisitionDto) {
+    return this.procurementService.updateAcquisition(id, dto);
+  }
+
+  @Delete('acquisitions/:id')
+  @ApiOperation({ summary: 'Delete an asset acquisition' })
+  async deleteAcquisition(@Param('id') id: string) {
+    return this.procurementService.deleteAcquisition(id);
+  }
+
+  // ---- Disposals ----
+  @Post('disposals')
+  @ApiOperation({ summary: 'Create an asset disposal' })
+  async createDisposal(@Body() dto: CreateDisposalDto) {
+    return this.procurementService.createDisposal(dto);
+  }
+
+  @Get('disposals')
+  @ApiOperation({ summary: 'List asset disposals' })
+  async listDisposals() {
+    return this.procurementService.listDisposals();
+  }
+
+  @Delete('disposals/:id')
+  @ApiOperation({ summary: 'Delete an asset disposal' })
+  async deleteDisposal(@Param('id') id: string) {
+    return this.procurementService.deleteDisposal(id);
+  }
+
+  // ---- Lifecycle ----
+  @Get('lifecycle/:vehicleId')
+  @ApiOperation({ summary: 'Get asset lifecycle (acquisition, disposal, depreciation) for a vehicle' })
+  async lifecycle(@Param('vehicleId') vehicleId: string) {
+    return this.procurementService.lifecycle(vehicleId);
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/procurement/procurement.module.ts b/apps/edr-freight-api/src/modules/procurement/procurement.module.ts
new file mode 100644
index 000000000..d4b0d8315
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/procurement/procurement.module.ts
@@ -0,0 +1,16 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { Vendor } from './entities/vendor.entity';
+import { AssetAcquisition } from './entities/asset-acquisition.entity';
+import { AssetDisposal } from './entities/asset-disposal.entity';
+import { ProcurementService } from './procurement.service';
+import { ProcurementRepository } from './procurement.repository';
+import { ProcurementController } from './procurement.controller';
+
+@Module({
+  imports: [TypeOrmModule.forFeature([Vendor, AssetAcquisition, AssetDisposal])],
+  providers: [ProcurementService, ProcurementRepository],
+  controllers: [ProcurementController],
+  exports: [ProcurementService],
+})
+export class ProcurementModule {}
diff --git a/apps/edr-freight-api/src/modules/procurement/procurement.repository.ts b/apps/edr-freight-api/src/modules/procurement/procurement.repository.ts
new file mode 100644
index 000000000..1a049d52b
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/procurement/procurement.repository.ts
@@ -0,0 +1,102 @@
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { BaseRepository } from '@edr/api-common';
+import { DeepPartial, Repository } from 'typeorm';
+import { Vendor } from './entities/vendor.entity';
+import { AssetAcquisition } from './entities/asset-acquisition.entity';
+import { AssetDisposal } from './entities/asset-disposal.entity';
+
+@Injectable()
+export class ProcurementRepository extends BaseRepository<AssetAcquisition> {
+  constructor(
+    @InjectRepository(AssetAcquisition)
+    private readonly acquisitionRepository: Repository<AssetAcquisition>,
+    @InjectRepository(Vendor)
+    private readonly vendorRepository: Repository<Vendor>,
+    @InjectRepository(AssetDisposal)
+    private readonly disposalRepository: Repository<AssetDisposal>,
+  ) {
+    super(acquisitionRepository);
+  }
+
+  // ---- Vendors ----
+  async createVendor(data: DeepPartial<Vendor>): Promise<Vendor> {
+    const vendor = this.vendorRepository.create(data);
+    return this.vendorRepository.save(vendor);
+  }
+
+  async findVendors(): Promise<Vendor[]> {
+    return this.vendorRepository.find({ order: { createdAt: 'DESC' } });
+  }
+
+  async updateVendor(id: string, data: DeepPartial<Vendor>): Promise<Vendor | null> {
+    await this.vendorRepository.update(id, data as never);
+    return this.vendorRepository.findOneBy({ id });
+  }
+
+  async softDeleteVendor(id: string): Promise<void> {
+    await this.vendorRepository.softDelete(id);
+  }
+
+  // ---- Acquisitions ----
+  async createAcquisition(data: DeepPartial<AssetAcquisition>): Promise<AssetAcquisition> {
+    const acquisition = this.acquisitionRepository.create(data);
+    return this.acquisitionRepository.save(acquisition);
+  }
+
+  async findAcquisitions(vehicleId?: string): Promise<AssetAcquisition[]> {
+    return this.acquisitionRepository.find({
+      where: vehicleId ? { vehicleId } : {},
+      relations: ['vehicle', 'vendor'],
+      order: { acquisitionDate: 'DESC' },
+    });
+  }
+
+  async findAcquisitionById(id: string): Promise<AssetAcquisition | null> {
+    return this.acquisitionRepository.findOne({
+      where: { id },
+      relations: ['vehicle', 'vendor'],
+    });
+  }
+
+  async updateAcquisition(
+    id: string,
+    data: DeepPartial<AssetAcquisition>,
+  ): Promise<AssetAcquisition | null> {
+    await this.acquisitionRepository.update(id, data as never);
+    return this.findAcquisitionById(id);
+  }
+
+  async softDeleteAcquisition(id: string): Promise<void> {
+    await this.acquisitionRepository.softDelete(id);
+  }
+
+  async findLatestAcquisitionByVehicle(vehicleId: string): Promise<AssetAcquisition | null> {
+    return this.acquisitionRepository.findOne({
+      where: { vehicleId },
+      relations: ['vehicle', 'vendor'],
+      order: { acquisitionDate: 'DESC' },
+    });
+  }
+
+  // ---- Disposals ----
+  async createDisposal(data: DeepPartial<AssetDisposal>): Promise<AssetDisposal> {
+    const disposal = this.disposalRepository.create(data);
+    return this.disposalRepository.save(disposal);
+  }
+
+  async findDisposals(): Promise<AssetDisposal[]> {
+    return this.disposalRepository.find({ order: { disposalDate: 'DESC' } });
+  }
+
+  async softDeleteDisposal(id: string): Promise<void> {
+    await this.disposalRepository.softDelete(id);
+  }
+
+  async findLatestDisposalByVehicle(vehicleId: string): Promise<AssetDisposal | null> {
+    return this.disposalRepository.findOne({
+      where: { vehicleId },
+      order: { disposalDate: 'DESC' },
+    });
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/procurement/procurement.service.ts b/apps/edr-freight-api/src/modules/procurement/procurement.service.ts
new file mode 100644
index 000000000..e799d5ff9
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/procurement/procurement.service.ts
@@ -0,0 +1,143 @@
+import { Injectable } from '@nestjs/common';
+import { ProcurementRepository } from './procurement.repository';
+import { Vendor } from './entities/vendor.entity';
+import { AssetAcquisition } from './entities/asset-acquisition.entity';
+import { AssetDisposal } from './entities/asset-disposal.entity';
+import {
+  CreateVendorDto,
+  UpdateVendorDto,
+  CreateAcquisitionDto,
+  UpdateAcquisitionDto,
+  CreateDisposalDto,
+} from './dto/procurement.dto';
+
+export interface DepreciationResult {
+  method: 'STRAIGHT_LINE';
+  cost: number;
+  salvageValue: number;
+  usefulLifeMonths: number;
+  monthsElapsed: number;
+  monthlyDepreciation: number;
+  bookValue: number;
+}
+
+export interface LifecycleResult {
+  vehicleId: string;
+  acquisition: AssetAcquisition | null;
+  disposal: AssetDisposal | null;
+  depreciation: DepreciationResult | null;
+}
+
+@Injectable()
+export class ProcurementService {
+  constructor(private readonly procurementRepository: ProcurementRepository) {}
+
+  // ---- Vendors ----
+  async createVendor(dto: CreateVendorDto): Promise<Vendor> {
+    return this.procurementRepository.createVendor(dto);
+  }
+
+  async listVendors(): Promise<Vendor[]> {
+    return this.procurementRepository.findVendors();
+  }
+
+  async updateVendor(id: string, dto: UpdateVendorDto): Promise<Vendor | null> {
+    return this.procurementRepository.updateVendor(id, dto);
+  }
+
+  async deleteVendor(id: string): Promise<{ success: boolean }> {
+    await this.procurementRepository.softDeleteVendor(id);
+    return { success: true };
+  }
+
+  // ---- Acquisitions ----
+  async createAcquisition(dto: CreateAcquisitionDto): Promise<AssetAcquisition> {
+    return this.procurementRepository.createAcquisition(dto);
+  }
+
+  async listAcquisitions(vehicleId?: string): Promise<AssetAcquisition[]> {
+    return this.procurementRepository.findAcquisitions(vehicleId);
+  }
+
+  async getAcquisition(id: string): Promise<AssetAcquisition | null> {
+    return this.procurementRepository.findAcquisitionById(id);
+  }
+
+  async updateAcquisition(id: string, dto: UpdateAcquisitionDto): Promise<AssetAcquisition | null> {
+    return this.procurementRepository.updateAcquisition(id, dto);
+  }
+
+  async deleteAcquisition(id: string): Promise<{ success: boolean }> {
+    await this.procurementRepository.softDeleteAcquisition(id);
+    return { success: true };
+  }
+
+  // ---- Disposals ----
+  async createDisposal(dto: CreateDisposalDto): Promise<AssetDisposal> {
+    return this.procurementRepository.createDisposal(dto);
+  }
+
+  async listDisposals(): Promise<AssetDisposal[]> {
+    return this.procurementRepository.findDisposals();
+  }
+
+  async deleteDisposal(id: string): Promise<{ success: boolean }> {
+    await this.procurementRepository.softDeleteDisposal(id);
+    return { success: true };
+  }
+
+  // ---- Lifecycle ----
+  async lifecycle(vehicleId: string): Promise<LifecycleResult> {
+    const acquisition = await this.procurementRepository.findLatestAcquisitionByVehicle(vehicleId);
+    const disposal = await this.procurementRepository.findLatestDisposalByVehicle(vehicleId);
+
+    return {
+      vehicleId,
+      acquisition,
+      disposal,
+      depreciation: this.computeStraightLineDepreciation(acquisition),
+    };
+  }
+
+  /**
+   * Straight-line depreciation. Requires a cost and a positive useful life.
+   * monthlyDep = (cost - salvageValue) / usefulLifeMonths
+   * bookValue  = cost - monthlyDep * monthsElapsedSinceAcquisition, floored at salvageValue.
+   */
+  private computeStraightLineDepreciation(
+    acquisition: AssetAcquisition | null,
+  ): DepreciationResult | null {
+    if (!acquisition) return null;
+
+    const cost = acquisition.cost != null ? Number(acquisition.cost) : null;
+    const usefulLifeMonths =
+      acquisition.usefulLifeMonths != null ? Number(acquisition.usefulLifeMonths) : null;
+
+    if (cost == null || usefulLifeMonths == null || usefulLifeMonths <= 0) {
+      return null;
+    }
+
+    const salvageValue = acquisition.salvageValue != null ? Number(acquisition.salvageValue) : 0;
+    const monthlyDepreciation = (cost - salvageValue) / usefulLifeMonths;
+
+    const acquiredAt = new Date(acquisition.acquisitionDate);
+    const now = new Date();
+    const monthsElapsed = Math.max(
+      0,
+      (now.getFullYear() - acquiredAt.getFullYear()) * 12 +
+        (now.getMonth() - acquiredAt.getMonth()),
+    );
+
+    const bookValue = Math.max(cost - monthlyDepreciation * monthsElapsed, salvageValue);
+
+    return {
+      method: 'STRAIGHT_LINE',
+      cost,
+      salvageValue,
+      usefulLifeMonths,
+      monthsElapsed,
+      monthlyDepreciation,
+      bookValue,
+    };
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/scheduling-reschedule/scheduling-reschedule.service.spec.ts b/apps/edr-freight-api/src/modules/scheduling-reschedule/scheduling-reschedule.service.spec.ts
index 905e827e8..289e502f1 100644
--- a/apps/edr-freight-api/src/modules/scheduling-reschedule/scheduling-reschedule.service.spec.ts
+++ b/apps/edr-freight-api/src/modules/scheduling-reschedule/scheduling-reschedule.service.spec.ts
@@ -78,6 +78,11 @@ describe('SchedulingRescheduleService', () => {
       bookingsRepository as never,
       trainSchedulingService as never,
       schedulingRescheduleRepository as never,
+      {
+        rescheduled: jest.fn(),
+        removedFromTrain: jest.fn(),
+        maintenanceMoved: jest.fn(),
+      } as never, // notifier
     );
   });
 
diff --git a/apps/edr-freight-api/src/modules/scheduling-reschedule/scheduling-reschedule.service.ts b/apps/edr-freight-api/src/modules/scheduling-reschedule/scheduling-reschedule.service.ts
index dd20b100d..a9a3ae246 100644
--- a/apps/edr-freight-api/src/modules/scheduling-reschedule/scheduling-reschedule.service.ts
+++ b/apps/edr-freight-api/src/modules/scheduling-reschedule/scheduling-reschedule.service.ts
@@ -10,6 +10,7 @@ import { BookingsRepository } from '../bookings/bookings.repository';
 import { compareSchedulingPriority } from '../scheduling/compare-scheduling-priority.util';
 import { TrainSchedulesRepository } from '../train-schedules/train-schedules.repository';
 import { TrainSchedulingService } from '../train-scheduling/train-scheduling.service';
+import { BookingNotifierService } from '../train-scheduling/booking-notifier.service';
 import { ExecuteRescheduleDto, PreviewRescheduleDto } from './dto/preview-reschedule.dto';
 import { SchedulingRescheduleRepository } from './scheduling-reschedule.repository';
 
@@ -38,6 +39,7 @@ export class SchedulingRescheduleService {
     private readonly bookingsRepository: BookingsRepository,
     private readonly trainSchedulingService: TrainSchedulingService,
     private readonly schedulingRescheduleRepository: SchedulingRescheduleRepository,
+    private readonly notifier: BookingNotifierService,
   ) {}
 
   /** Preview who is retained, displaced, and readmitted on a schedule. */
@@ -193,9 +195,64 @@ export class SchedulingRescheduleService {
       displacedBookingIds: dto.displacedBookingIds,
     });
 
+    // Notify affected customers (SMS + email). Best-effort — a notification
+    // failure must never fail the reschedule, so each send is fire-and-forget
+    // inside the notifier. Government pre-empt already notifies via the batch
+    // displaced() path, so skip removed-from-train notices for that trigger.
+    // Use the new departure date when the reschedule moved it (the in-memory
+    // `schedule` still holds the pre-update date).
+    const effectiveDeparture = dto.newDepartureDate
+      ? new Date(dto.newDepartureDate)
+      : schedule.scheduledDepartureDate;
+    await this.notifyRescheduleOutcome(dto, effectiveDeparture);
+
     return { plan, schedule: assignResult };
   }
 
+  /**
+   * Fan out reschedule notifications: bookings that stayed on the train hear the
+   * new departure date; bookings dropped off the train (staff reschedule, not a
+   * government pre-empt) hear they were removed. Loads each booking with its
+   * company so the notifier has a phone/email to reach.
+   */
+  private async notifyRescheduleOutcome(
+    dto: ExecuteRescheduleDto,
+    newDeparture: Date | null,
+  ): Promise<void> {
+    const isMaintenance = dto.trigger === 'TRAIN_MAINTENANCE';
+    const isGovPreempt = dto.trigger === 'GOVERNMENT_PREEMPT';
+
+    if (newDeparture) {
+      for (const bookingId of dto.finalBookingIds) {
+        const booking = await this.loadBookingForNotify(bookingId);
+        if (!booking) continue;
+        if (isMaintenance) {
+          this.notifier.maintenanceMoved(booking, newDeparture);
+        } else {
+          this.notifier.rescheduled(booking, newDeparture);
+        }
+      }
+    }
+
+    // Government pre-empt displacements are already announced by the batch
+    // displaced() notice — don't double-notify. Staff reschedules are not.
+    if (!isGovPreempt) {
+      for (const bookingId of dto.displacedBookingIds) {
+        const booking = await this.loadBookingForNotify(bookingId);
+        if (!booking) continue;
+        this.notifier.removedFromTrain(booking);
+      }
+    }
+  }
+
+  private async loadBookingForNotify(bookingId: string): Promise<Booking | null> {
+    try {
+      return await this.bookingsRepository.findByIdWithFiles(bookingId);
+    } catch {
+      return null;
+    }
+  }
+
   /** Maintenance shortcut: new departure + rebalance. */
   async maintenanceReschedule(
     scheduleId: string,
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 fd9b74d28..e2e339e9b 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
@@ -382,6 +382,18 @@ export class BookingBatchService implements OnModuleInit {
       this.logger.log(
         `Linked PAID booking ${booking.reference ?? bookingId} to schedule ${booking.trainScheduleId}`,
       );
+    } else {
+      // Already linked at booking time (export FCFS: the customer books a
+      // specific train, so allocate() ran up front). allocate() is where the
+      // payment-settled tracking milestones are written, so on this branch we
+      // record them here — otherwise a paid, already-linked booking leaves
+      // FREIGHT_PAYMENT_SETTLED stuck PENDING and the clearance step never ticks.
+      void this.completeTrackingMilestones(bookingId, [
+        "WAGON_REQUESTED",
+        "FREIGHT_PAYMENT_PENDING",
+        "FREIGHT_PAYMENT_SETTLED",
+      ]);
+      void this.markWagonAllocatedMilestone(bookingId);
     }
 
     const schedule = await this.trainSchedulesRepository.findByIdWithFullGraph(
@@ -1517,6 +1529,12 @@ export class BookingBatchService implements OnModuleInit {
       "PREPAID",
     );
     await this.notifier.payNow(booking, deadline);
+    // Customer tracking: a wagon slot is reserved and the freight pay window is
+    // open. Doc-trigger path — silent no-op for bookings without milestone rows.
+    void this.completeTrackingMilestones(booking.id, [
+      "WAGON_REQUESTED",
+      "FREIGHT_PAYMENT_PENDING",
+    ]);
   }
 
   /** Allocate a booking to the schedule's train (creates the TrainScheduleBooking link). */
@@ -1548,6 +1566,15 @@ export class BookingBatchService implements OnModuleInit {
     this.notifier.secured(booking, reason);
     void this.triggerWagonAllocation(scheduleId);
     void this.markWagonAllocatedMilestone(booking.id);
+    // Customer tracking: freight payment settled (commercial pay-window path).
+    // Government allocations don't pay upfront — theirs stay pending.
+    if (reason === 'paid') {
+      void this.completeTrackingMilestones(booking.id, [
+        'WAGON_REQUESTED',
+        'FREIGHT_PAYMENT_PENDING',
+        'FREIGHT_PAYMENT_SETTLED',
+      ]);
+    }
   }
 
   private async markWagonAllocatedMilestone(bookingId: string): Promise<void> {
@@ -1559,6 +1586,27 @@ export class BookingBatchService implements OnModuleInit {
     }
   }
 
+  /**
+   * Complete customer-tracking milestones on lifecycle events via the
+   * doc-trigger path — a silent no-op for bookings without milestone rows
+   * (non-customs bookings). Never blocks the batch action.
+   */
+  private async completeTrackingMilestones(
+    bookingId: string,
+    codes: string[],
+  ): Promise<void> {
+    if (!this.milestoneService) return;
+    for (const code of codes) {
+      try {
+        await this.milestoneService.completeByDocTrigger({ bookingId }, code);
+      } catch (err) {
+        this.logger.warn(
+          `Milestone ${code} completion failed for booking ${bookingId}: ${(err as Error).message}`,
+        );
+      }
+    }
+  }
+
   /**
    * Expire an unpaid reservation and free its capacity. With day-level pooling we
    * also clear `trainScheduleId` so the booking is no longer pinned to the train
diff --git a/apps/edr-freight-api/src/modules/train-scheduling/booking-notifier.service.ts b/apps/edr-freight-api/src/modules/train-scheduling/booking-notifier.service.ts
index 49df19758..f1f63802e 100644
--- a/apps/edr-freight-api/src/modules/train-scheduling/booking-notifier.service.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/booking-notifier.service.ts
@@ -1,13 +1,23 @@
 import { Injectable, Logger } from '@nestjs/common';
+import {
+  NotificationAudience,
+  NotificationType,
+  NotifyInput,
+} from '@edr/types';
 
 import { Booking } from '../bookings/entities/booking.entity';
 import { NotificationsService } from '../notifications/notifications.service';
+import { NotificationInboxService } from '../notification-inbox/notification-inbox.service';
+import { BATCH_TIMEZONE } from './booking-batch.constants';
 
 @Injectable()
 export class BookingNotifierService {
   private readonly logger = new Logger(BookingNotifierService.name);
 
-  constructor(private readonly notifications: NotificationsService) {}
+  constructor(
+    private readonly notifications: NotificationsService,
+    private readonly inbox: NotificationInboxService,
+  ) {}
 
   private ref(b: Booking): string {
     return `${b.reference}${b.isGovernment ? ' (gov)' : ''}`;
@@ -41,11 +51,34 @@ export class BookingNotifierService {
     }
   }
 
+  /** Persist + push an in-app item to all portal users of the booking's company. */
+  private inApp(
+    b: Booking,
+    title: string,
+    body: string,
+    overrides: Partial<NotifyInput> = {},
+  ): void {
+    if (!b.companyId) return; // government/unlinked bookings have no portal users
+    void this.inbox.notify({
+      recipients: { companyId: b.companyId },
+      audience: NotificationAudience.PORTAL,
+      type: NotificationType.SCHEDULE_UPDATE,
+      title,
+      body,
+      link: `/bookings/${b.id}`,
+      data: { bookingId: b.id, reference: b.reference },
+      ...overrides,
+    });
+  }
+
   async payNow(b: Booking, deadline: Date): Promise<void> {
     const payMinutes = Math.max(1, Math.round((deadline.getTime() - Date.now()) / 60_000));
     const eat = deadline.toLocaleString('en-GB', { timeZone: 'Africa/Addis_Ababa' });
     const msg = `Pay within ${payMinutes} minute${payMinutes === 1 ? '' : 's'} to secure train slot ${b.reference ?? b.id}. Deadline: ${eat} EAT.`;
     await this.notifyContact(b, msg, 'PAY NOW');
+    this.inApp(b, 'Payment window open', msg, {
+      type: NotificationType.INVOICE_ISSUED,
+    });
   }
 
   /**
@@ -66,6 +99,9 @@ export class BookingNotifierService {
       `Pay within ${payMinutes} minute${payMinutes === 1 ? '' : 's'} to accept and ship ${offeredWagons} wagon${offeredWagons === 1 ? '' : 's'} now ` +
       `(the rest returns to your contract to book later). If you do not pay, the booking stays whole and you can rebook in the next window. Deadline: ${eat} EAT.`;
     await this.notifyContact(b, msg, 'PAY NOW (PARTIAL)');
+    this.inApp(b, 'Partial allocation offer', msg, {
+      type: NotificationType.INVOICE_ISSUED,
+    });
   }
 
   secured(b: Booking, reason: 'paid' | 'gov'): void {
@@ -73,11 +109,13 @@ export class BookingNotifierService {
       reason === 'gov' ? ' (government)' : ''
     }.`;
     void this.notifyContact(b, msg, 'ALLOCATED');
+    this.inApp(b, 'Wagon allocated', msg);
   }
 
   expired(b: Booking): void {
     const msg = `Payment window expired for booking ${b.reference ?? b.id}. Reschedule or cancel — no re-approval needed.`;
     void this.notifyContact(b, msg, 'EXPIRED');
+    this.inApp(b, 'Payment window expired', msg);
   }
 
   scheduleFull(b: Booking): void {
@@ -100,5 +138,42 @@ export class BookingNotifierService {
   displaced(b: Booking): void {
     const msg = `Booking ${b.reference ?? b.id} was displaced by a government booking. Move to another schedule or cancel.`;
     void this.notifyContact(b, msg, 'DISPLACED');
+    this.inApp(b, 'Booking displaced', msg);
+  }
+
+  /**
+   * Staff rescheduled the train carrying this booking to a new departure date.
+   * The booking stays on the train — only the date moved.
+   */
+  rescheduled(b: Booking, newDeparture: Date): void {
+    const when = newDeparture.toLocaleDateString('en-GB', { timeZone: BATCH_TIMEZONE });
+    const msg = `Booking ${b.reference ?? b.id} has been rescheduled. New departure date: ${when}.`;
+    void this.notifyContact(b, msg, 'RESCHEDULED');
+    this.inApp(b, 'Booking rescheduled', msg);
+  }
+
+  /**
+   * Booking was removed from its train during a staff reschedule (not a government
+   * pre-empt). It returns to eligible — the customer must rebook or reschedule.
+   */
+  removedFromTrain(b: Booking): void {
+    const msg =
+      `Booking ${b.reference ?? b.id} has been removed from its train during rescheduling. ` +
+      `Please rebook or select a new schedule from the portal.`;
+    void this.notifyContact(b, msg, 'REMOVED FROM TRAIN');
+    this.inApp(b, 'Removed from train', msg);
+  }
+
+  /**
+   * The train carrying this booking was moved for maintenance to a new departure
+   * date. The booking stays on the train — only the date moved.
+   */
+  maintenanceMoved(b: Booking, newDeparture: Date): void {
+    const when = newDeparture.toLocaleDateString('en-GB', { timeZone: BATCH_TIMEZONE });
+    const msg =
+      `The train for booking ${b.reference ?? b.id} was rescheduled for maintenance. ` +
+      `New departure date: ${when}.`;
+    void this.notifyContact(b, msg, 'MAINTENANCE RESCHEDULE');
+    this.inApp(b, 'Train maintenance reschedule', msg);
   }
 }
diff --git a/apps/edr-freight-api/src/modules/train-scheduling/booking-window.gateway.spec.ts b/apps/edr-freight-api/src/modules/train-scheduling/booking-window.gateway.spec.ts
new file mode 100644
index 000000000..a439e442d
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/train-scheduling/booking-window.gateway.spec.ts
@@ -0,0 +1,109 @@
+import { BOOKING_WINDOW_WS_EVENTS, BOOKING_WINDOW_WS_NAMESPACE } from '@edr/types';
+import { INestApplication } from '@nestjs/common';
+import { Test } from '@nestjs/testing';
+import { io, type Socket } from 'socket.io-client';
+
+import { WsAuthService } from '../notification-inbox/ws-auth.service';
+import { BookingWindowGateway } from './booking-window.gateway';
+import type { TrainSchedule } from '../train-schedules/entities/train-schedule.entity';
+
+/**
+ * End-to-end proof the booking-window socket works: boots a real Nest app with
+ * the gateway, connects a real socket.io client to the namespace, emits a phase
+ * change, and asserts the client receives the exact payload. If this passes,
+ * any "no live update" report is environmental (stale server process, wrong
+ * checkout running, client not connecting) — not the gateway.
+ */
+describe('BookingWindowGateway (e2e)', () => {
+  let app: INestApplication;
+  let gateway: BookingWindowGateway;
+  let client: Socket;
+  let baseUrl: string;
+
+  beforeAll(async () => {
+    const moduleRef = await Test.createTestingModule({
+      providers: [
+        BookingWindowGateway,
+        // Accept any token — auth plumbing is covered by the real WsAuthService.
+        { provide: WsAuthService, useValue: { resolveUserId: async () => 'user-1' } },
+      ],
+    }).compile();
+
+    app = moduleRef.createNestApplication();
+    await app.listen(0);
+    const address = app.getHttpServer().address() as { port: number };
+    baseUrl = `http://127.0.0.1:${address.port}`;
+    gateway = app.get(BookingWindowGateway);
+  });
+
+  afterAll(async () => {
+    client?.disconnect();
+    await app?.close();
+  });
+
+  it('authenticated client receives the phase event with the schedule state', async () => {
+    client = io(`${baseUrl}/${BOOKING_WINDOW_WS_NAMESPACE}`, {
+      auth: { token: 'any' },
+      transports: ['websocket'],
+    });
+    await new Promise<void>((resolve, reject) => {
+      client.on('connect', () => resolve());
+      client.on('connect_error', (err) => reject(err));
+    });
+
+    const received = new Promise<Record<string, unknown>>((resolve) => {
+      client.on(BOOKING_WINDOW_WS_EVENTS.PHASE, (payload) => resolve(payload));
+    });
+
+    gateway.emitPhase({
+      id: 'sched-1',
+      originStationId: 'yard-a',
+      destinationStationId: 'yard-b',
+      direction: 'IMPORT',
+      windowPhase: 'OPEN',
+      bookingWindowStatus: 'OPEN',
+      bookingCycleNo: 2,
+      windowOpensAt: new Date('2026-07-06T16:15:00Z'),
+      windowClosesAt: new Date('2026-07-06T16:18:00Z'),
+      docReviewEndsAt: null,
+      paymentPhaseEndsAt: null,
+      scheduledDepartureDate: new Date('2026-07-09T05:53:00Z'),
+    } as unknown as TrainSchedule);
+
+    const payload = await received;
+    expect(payload).toMatchObject({
+      scheduleId: 'sched-1',
+      phase: 'OPEN',
+      bookingWindowStatus: 'OPEN',
+      bookingCycleNo: 2,
+      windowOpensAt: '2026-07-06T16:15:00.000Z',
+    });
+  });
+
+  it('rejects a client whose token does not resolve to a user', async () => {
+    const moduleRef = await Test.createTestingModule({
+      providers: [
+        BookingWindowGateway,
+        { provide: WsAuthService, useValue: { resolveUserId: async () => null } },
+      ],
+    }).compile();
+    const rejectingApp = moduleRef.createNestApplication();
+    await rejectingApp.listen(0);
+    const addr = rejectingApp.getHttpServer().address() as { port: number };
+
+    const rejected = io(`http://127.0.0.1:${addr.port}/${BOOKING_WINDOW_WS_NAMESPACE}`, {
+      auth: { token: 'bad' },
+      transports: ['websocket'],
+      reconnection: false,
+    });
+    const outcome = await new Promise<string>((resolve) => {
+      rejected.on('disconnect', () => resolve('disconnected'));
+      rejected.on('connect_error', () => resolve('rejected'));
+      // The server accepts the transport then drops it in handleConnection.
+      setTimeout(() => resolve(rejected.connected ? 'still-connected' : 'disconnected'), 500);
+    });
+    rejected.disconnect();
+    await rejectingApp.close();
+    expect(outcome).not.toBe('still-connected');
+  });
+});
diff --git a/apps/edr-freight-api/src/modules/train-scheduling/booking-window.gateway.ts b/apps/edr-freight-api/src/modules/train-scheduling/booking-window.gateway.ts
index d1c1d34a1..699471d90 100644
--- a/apps/edr-freight-api/src/modules/train-scheduling/booking-window.gateway.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/booking-window.gateway.ts
@@ -41,6 +41,9 @@ export class BookingWindowGateway implements OnGatewayConnection {
       return;
     }
     socket.data.userId = userId;
+    // Log at info so "is anyone actually connected?" is answerable from the
+    // API log when diagnosing missing live updates.
+    this.logger.log(`Booking-window client connected (user ${userId})`);
   }
 
   /** Push a schedule's current window state to every connected client. */
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 12a78047c..429a03a05 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
@@ -2,12 +2,17 @@ import { Injectable, Logger, NotFoundException, OnModuleInit } from '@nestjs/com
 import { Cron } from '@nestjs/schedule';
 import { InjectDataSource } from '@nestjs/typeorm';
 import { DataSource } from 'typeorm';
-import { TrainScheduleStatus as TrainScheduleStatusEnum } from '@edr/types';
+import {
+  NotificationAudience,
+  NotificationType,
+  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 { NotificationInboxService } from '../notification-inbox/notification-inbox.service';
 import { BookingBatchService } from './booking-batch.service';
 import { BookingWindowGateway } from './booking-window.gateway';
 import { TrainSchedulingService, effectiveWindowConfig } from './train-scheduling.service';
@@ -41,6 +46,7 @@ export class BookingWindowService implements OnModuleInit {
     private readonly bookingBatchService: BookingBatchService,
     private readonly trainSchedulingService: TrainSchedulingService,
     private readonly notifications: NotificationsService,
+    private readonly inbox: NotificationInboxService,
     private readonly gateway: BookingWindowGateway,
   ) {}
 
@@ -380,22 +386,26 @@ export class BookingWindowService implements OnModuleInit {
    */
   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],
-        );
+      const rows: Array<{
+        company_id: string;
+        phone: string | null;
+        email: string | null;
+      }> = await this.dataSource.query(
+        `SELECT DISTINCT
+                c.company_id,
+                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
@@ -410,6 +420,7 @@ export class BookingWindowService implements OnModuleInit {
 
       const seenPhone = new Set<string>();
       const seenEmail = new Set<string>();
+      const seenCompany = new Set<string>();
       for (const r of rows) {
         if (r.phone && !seenPhone.has(r.phone)) {
           seenPhone.add(r.phone);
@@ -423,9 +434,23 @@ export class BookingWindowService implements OnModuleInit {
             .directSend('email', r.email, msg)
             .catch((e) => this.logger.warn(`Window-open email failed: ${(e as Error).message}`));
         }
+        // In-app inbox item for every portal user of each eligible company,
+        // deep-linking to the new-booking page.
+        if (r.company_id && !seenCompany.has(r.company_id)) {
+          seenCompany.add(r.company_id);
+          void this.inbox.notify({
+            recipients: { companyId: r.company_id },
+            audience: NotificationAudience.PORTAL,
+            type: NotificationType.SCHEDULE_UPDATE,
+            title: 'Booking window open',
+            body: msg,
+            link: '/bookings/new',
+            data: { trainScheduleId: schedule.id },
+          });
+        }
       }
       this.logger.log(
-        `Notified ${seenPhone.size} phone / ${seenEmail.size} email contacts of open window for schedule ${schedule.id}`,
+        `Notified ${seenPhone.size} phone / ${seenEmail.size} email / ${seenCompany.size} companies (in-app) of open window for schedule ${schedule.id}`,
       );
     } catch (err) {
       this.logger.warn(
diff --git a/apps/edr-freight-api/src/modules/train-scheduling/train-scheduling.module.ts b/apps/edr-freight-api/src/modules/train-scheduling/train-scheduling.module.ts
index e01e0d629..792fb7c64 100644
--- a/apps/edr-freight-api/src/modules/train-scheduling/train-scheduling.module.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/train-scheduling.module.ts
@@ -33,6 +33,7 @@ import { WsAuthService } from '../notification-inbox/ws-auth.service';
 import { BookingSplitService } from './booking-split.service';
 import { BookingBatchOffer } from './entities/booking-batch-offer.entity';
 import { NotificationsModule } from '../notifications/notifications.module';
+import { NotificationInboxModule } from '../notification-inbox/notification-inbox.module';
 import { ContractsModule } from '../contracts/contracts.module';
 
 @Module({
@@ -56,6 +57,7 @@ import { ContractsModule } from '../contracts/contracts.module';
     forwardRef(() => BookingsModule),
     BillingModule,
     NotificationsModule,
+    NotificationInboxModule,
     LocomotivesModule,
     WagonTypesModule,
     TrainSetsModule,
@@ -76,6 +78,11 @@ import { ContractsModule } from '../contracts/contracts.module';
     BookingSplitService,
     IntercityService,
   ],
-  exports: [TrainSchedulingService, BookingBatchService, BookingWindowService],
+  exports: [
+    TrainSchedulingService,
+    BookingBatchService,
+    BookingWindowService,
+    BookingNotifierService,
+  ],
 })
 export class TrainSchedulingModule {}
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 16d5052bf..67eac7bd1 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
@@ -12,6 +12,7 @@ import {
   Injectable,
   Logger,
   NotFoundException,
+  Optional,
 } from '@nestjs/common';
 import { ConfigService } from '@nestjs/config';
 import { InjectDataSource } from '@nestjs/typeorm';
@@ -21,6 +22,7 @@ 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 { ClearanceMilestoneService } from '../contracts/clearance-milestone.service';
 import { Container } from '../container-management/entities/container.entity';
 import { Locomotive } from '../locomotives/entities/locomotive.entity';
 import { LocomotivesRepository } from '../locomotives/locomotives.repository';
@@ -274,9 +276,45 @@ export class TrainSchedulingService {
     private readonly warehouseInventoryService: WarehouseInventoryService,
     private readonly pdfDocuments: WarehouseReleaseDocumentService,
     private readonly bookingWindowGateway: BookingWindowGateway,
+    @Optional() private readonly milestoneService?: ClearanceMilestoneService,
     private readonly configService?: ConfigService,
   ) {}
 
+  /**
+   * Complete customer-tracking clearance milestones for every booking on a
+   * schedule when a physical lifecycle event fires (dispatch, arrive, load,
+   * unload, gatepass). Uses the doc-trigger path, which is a silent no-op for
+   * bookings without milestone rows (non-customs bookings), so this is safe to
+   * call for every direction and flow. Never blocks the operational action.
+   */
+  private async completeMilestonesForScheduleBookings(
+    scheduleId: string,
+    codes: string[],
+  ): Promise<void> {
+    if (!this.milestoneService || codes.length === 0) return;
+    try {
+      const rows: Array<{ booking_id: string }> = await this.dataSource.query(
+        `SELECT tsb.booking_id
+           FROM freight.train_schedule_bookings tsb
+          WHERE tsb.train_schedule_id = $1
+            AND tsb.deleted_at IS NULL`,
+        [scheduleId],
+      );
+      for (const { booking_id } of rows) {
+        for (const code of codes) {
+          await this.milestoneService.completeByDocTrigger(
+            { bookingId: booking_id },
+            code,
+          );
+        }
+      }
+    } catch (err) {
+      this.logger.warn(
+        `Milestone completion (${codes.join(', ')}) failed for schedule ${scheduleId}: ${(err as Error).message}`,
+      );
+    }
+  }
+
   /**
    * Push a schedule's current booking-window state over the socket so the
    * portal home card and backoffice GL/batch views update in real time —
@@ -1121,26 +1159,32 @@ export class TrainSchedulingService {
         { country: schedule.destinationCountry },
       );
       if (direction === 'IMPORT') {
+        const result = await this.warehouseInventoryService.autoUnloadArrivedBookings(
+          scheduleId,
+          'SYSTEM_TRAIN_ARRIVAL',
+        );
+        // Customer tracking: cargo is off the train at the destination yard.
+        void this.completeMilestonesForScheduleBookings(scheduleId, ['OFFLOADED']);
         return {
           direction,
           action: 'IMPORT_AUTO_UNLOAD',
           status: 'COMPLETED',
-          result: await this.warehouseInventoryService.autoUnloadArrivedBookings(
-            scheduleId,
-            'SYSTEM_TRAIN_ARRIVAL',
-          ),
+          result,
         };
       }
 
       if (direction === 'EXPORT' && this.isDjiboutiPortDestination(`${schedule.destinationCode ?? ''} ${schedule.destinationName ?? ''}`)) {
+        const result = await this.warehouseInventoryService.autoUnloadExportAtDjibouti(
+          scheduleId,
+          'SYSTEM_TRAIN_ARRIVAL',
+        );
+        // Customer tracking: cargo is off the train at the Djibouti port.
+        void this.completeMilestonesForScheduleBookings(scheduleId, ['OFFLOADED']);
         return {
           direction,
           action: 'EXPORT_DJIBOUTI_AUTO_UNLOAD',
           status: 'COMPLETED',
-          result: await this.warehouseInventoryService.autoUnloadExportAtDjibouti(
-            scheduleId,
-            'SYSTEM_TRAIN_ARRIVAL',
-          ),
+          result,
         };
       }
 
@@ -1443,6 +1487,20 @@ export class TrainSchedulingService {
 
     // Dispatch closed the window — drop it from portal/GL cards right away.
     void this.emitWindowState(scheduleId);
+    // Customer tracking: cargo is on the departing train — loading milestones
+    // plus the direction's "departed" handoff milestone.
+    if (schedule.direction === 'IMPORT' || schedule.direction === 'EXPORT') {
+      void this.completeMilestonesForScheduleBookings(scheduleId, [
+        // CARGO_ARRIVED is export-only (cargo reached the origin yard) — the
+        // doc-trigger path no-ops it for import bookings.
+        'CARGO_ARRIVED',
+        'READY_FOR_LOADING',
+        'LOADED',
+        schedule.direction === 'IMPORT'
+          ? 'DEPARTED_FROM_DJIBOUTI'
+          : 'DEPARTED_TO_DJIBOUTI',
+      ]);
+    }
     return this.getTrainScheduleById(scheduleId);
   }
 
@@ -1599,6 +1657,13 @@ export class TrainSchedulingService {
         LoadingStatus.Loaded,
       );
     }
+    // Customer tracking: staff confirmed cargo is on the wagons (CARGO_ARRIVED
+    // is the export-side "cargo reached origin yard" step that precedes it).
+    void this.completeMilestonesForScheduleBookings(scheduleId, [
+      'CARGO_ARRIVED',
+      'READY_FOR_LOADING',
+      'LOADED',
+    ]);
     return this.getTrainScheduleById(scheduleId);
   }
 
@@ -1662,9 +1727,9 @@ export class TrainSchedulingService {
       performedBy: 'DOCUMENT_GENERATION',
     });
     const html = this.buildImportLoadListHtml(loadList);
-    // 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');
+    // Styled table-aware fallback (marshalling grid) when Chromium is unavailable —
+    // NOT the release-order fallback (would mislabel this as a gate-clearance order).
+    const buffer = await this.pdfDocuments.renderTabularDocument(html, 'Import marshalling / load list');
     const reference = loadList.trainNumber ?? loadList.trainScheduleId;
     return {
       filename: `import-marshalling-${this.safeDocumentName(reference)}.pdf`,
@@ -1682,8 +1747,8 @@ export class TrainSchedulingService {
     }
 
     const html = this.buildExportLoadListHtml(schedule);
-    // Generic render — NOT the release-order fallback (see importLoadListDocument).
-    const buffer = await this.pdfDocuments.renderDocumentHtml(html, 'Export marshalling / load list');
+    // Styled table-aware fallback (marshalling grid) — see importLoadListDocument.
+    const buffer = await this.pdfDocuments.renderTabularDocument(html, 'Export marshalling / load list');
     const reference = schedule.trainNumber ?? schedule.id;
     return {
       filename: `export-marshalling-${this.safeDocumentName(reference)}.pdf`,
@@ -2417,6 +2482,13 @@ export class TrainSchedulingService {
       }
     });
 
+    // Customer tracking: the train reached the corridor's far end.
+    if (schedule.direction === 'IMPORT' || schedule.direction === 'EXPORT') {
+      void this.completeMilestonesForScheduleBookings(scheduleId, [
+        schedule.direction === 'IMPORT' ? 'ARRIVED_ETHIOPIA' : 'ARRIVED_AT_DJIBOUTI',
+      ]);
+    }
+
     const detail = await this.getTrainScheduleById(scheduleId);
     const warehouseAutomation = await this.runWarehouseArrivalAutomation(scheduleId);
     return Object.assign(detail, { warehouseAutomation });
diff --git a/apps/edr-freight-api/src/modules/vehicles/dto/create-vehicle.dto.ts b/apps/edr-freight-api/src/modules/vehicles/dto/create-vehicle.dto.ts
index 9158ecca0..33d441ecb 100644
--- a/apps/edr-freight-api/src/modules/vehicles/dto/create-vehicle.dto.ts
+++ b/apps/edr-freight-api/src/modules/vehicles/dto/create-vehicle.dto.ts
@@ -65,4 +65,12 @@ export class CreateVehicleDto {
   @IsOptional()
   @IsUUID()
   locationId?: string;
+
+  @IsOptional()
+  @IsNumber()
+  pricePerKm?: number;
+
+  @IsOptional()
+  @IsString()
+  currency?: string;
 }
diff --git a/apps/edr-freight-api/src/modules/vehicles/entities/vehicle.entity.ts b/apps/edr-freight-api/src/modules/vehicles/entities/vehicle.entity.ts
index 416cddee6..534019bc4 100644
--- a/apps/edr-freight-api/src/modules/vehicles/entities/vehicle.entity.ts
+++ b/apps/edr-freight-api/src/modules/vehicles/entities/vehicle.entity.ts
@@ -88,4 +88,29 @@ export class Vehicle extends BaseEntity {
 
   @Column({ name: 'location_id', type: 'uuid', nullable: true })
   locationId?: string;
+
+  // --- Haulage pricing ---
+  @Column({ name: 'price_per_km', type: 'numeric', precision: 14, scale: 2, nullable: true })
+  pricePerKm?: number;
+
+  /** Currency for pricePerKm: ETB | USD */
+  @Column({ name: 'currency', type: 'varchar', length: 8, default: 'ETB' })
+  currency?: string;
+
+  // --- Compliance / expiry tracking ---
+  @Column({ name: 'vin', type: 'varchar', nullable: true })
+  vin?: string;
+
+  /** Owned | Leased | Rented */
+  @Column({ name: 'ownership', type: 'varchar', nullable: true })
+  ownership?: string;
+
+  @Column({ name: 'insurance_expiry', type: 'date', nullable: true })
+  insuranceExpiry?: string;
+
+  @Column({ name: 'registration_expiry', type: 'date', nullable: true })
+  registrationExpiry?: string;
+
+  @Column({ name: 'next_inspection_date', type: 'date', nullable: true })
+  nextInspectionDate?: string;
 }
diff --git a/apps/edr-freight-api/src/modules/vehicles/vehicles.controller.ts b/apps/edr-freight-api/src/modules/vehicles/vehicles.controller.ts
index f0a77791a..737574dd9 100644
--- a/apps/edr-freight-api/src/modules/vehicles/vehicles.controller.ts
+++ b/apps/edr-freight-api/src/modules/vehicles/vehicles.controller.ts
@@ -10,7 +10,8 @@ import {
   ParseUUIDPipe,
 } from '@nestjs/common';
 import { ApiBearerAuth, ApiOperation, ApiTags } from '@nestjs/swagger';
-import { FleetManage, FleetView } from '../../common/booking-guards';
+import { BookingStaff } from '../../common/booking-guards';
+import { FREIGHT_PERMS } from '../../seed/freight-permissions.registry';
 import { VehiclesService } from './vehicles.service';
 import { CreateVehicleDto } from './dto/create-vehicle.dto';
 import { UpdateVehicleDto } from './dto/update-vehicle.dto';
@@ -19,7 +20,7 @@ import { FleetHistoryService } from '../fleet-history/fleet-history.service';
 @ApiTags('vehicles')
 @ApiBearerAuth()
 @Controller('vehicles')
-@FleetView()
+@BookingStaff(FREIGHT_PERMS.vehicles.view)
 export class VehiclesController {
   constructor(
     private readonly vehiclesService: VehiclesService,
@@ -27,7 +28,7 @@ export class VehiclesController {
   ) {}
 
   @Post()
-  @FleetManage()
+  @BookingStaff(FREIGHT_PERMS.vehicles.create)
   @ApiOperation({ summary: 'Create a new vehicle' })
   create(@Body() createVehicleDto: CreateVehicleDto) {
     return this.vehiclesService.create(createVehicleDto);
@@ -68,7 +69,7 @@ export class VehiclesController {
   }
 
   @Patch(':id')
-  @FleetManage()
+  @BookingStaff(FREIGHT_PERMS.vehicles.update)
   @ApiOperation({ summary: 'Update a vehicle' })
   update(
     @Param('id', ParseUUIDPipe) id: string,
@@ -78,7 +79,7 @@ export class VehiclesController {
   }
 
   @Delete(':id')
-  @FleetManage()
+  @BookingStaff(FREIGHT_PERMS.vehicles.delete)
   @ApiOperation({ summary: 'Delete a vehicle' })
   remove(@Param('id', ParseUUIDPipe) id: string) {
     return this.vehiclesService.remove(id);
diff --git a/apps/edr-freight-api/src/modules/warehouses/dto/fee-rule.dto.ts b/apps/edr-freight-api/src/modules/warehouses/dto/fee-rule.dto.ts
index 22e9f9491..680eb2591 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
@@ -2,7 +2,7 @@ import { ApiProperty, ApiPropertyOptional, PartialType } from '@nestjs/swagger';
 import { Type } from 'class-transformer';
 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';
+import { FEE_RULE_BASES, FEE_RULE_TYPES, FeeRuleBasis, FeeRuleType } from '../entities/warehouse-fee-rule.entity';
 
 export class FeeRuleTierDto {
   @ApiProperty({ example: 4 })
@@ -82,11 +82,25 @@ export class CreateFeeRuleDto {
   @Min(0)
   freeDays!: number;
 
-  @ApiProperty()
+  @ApiProperty({ description: 'Day-based fees: rate/day. Double handling: flat rate per basis unit.' })
   @IsNumber()
   @Min(0)
   ratePerDay!: number;
 
+  @ApiPropertyOptional({ description: 'Truck detention only: grace window in hours (default 3).' })
+  @IsOptional()
+  @IsInt()
+  @Min(0)
+  freeHours?: number;
+
+  @ApiPropertyOptional({
+    enum: FEE_RULE_BASES,
+    description: 'Double-handling charge basis: PER_CONTAINER | PER_TON | PER_ITEM.',
+  })
+  @IsOptional()
+  @IsEnum(FEE_RULE_BASES)
+  basis?: FeeRuleBasis;
+
   @ApiPropertyOptional({ type: [FeeRuleTierDto] })
   @IsOptional()
   @IsArray()
diff --git a/apps/edr-freight-api/src/modules/warehouses/entities/warehouse-fee-rule.entity.ts b/apps/edr-freight-api/src/modules/warehouses/entities/warehouse-fee-rule.entity.ts
index 38dffd235..f6ad7ec8f 100644
--- a/apps/edr-freight-api/src/modules/warehouses/entities/warehouse-fee-rule.entity.ts
+++ b/apps/edr-freight-api/src/modules/warehouses/entities/warehouse-fee-rule.entity.ts
@@ -1,9 +1,23 @@
 import { BaseEntity } from '@edr/api-common';
 import { Column, Entity, Index } from 'typeorm';
 
-export const FEE_RULE_TYPES = ['STORAGE_FEE', 'DEMURRAGE_FEE'] as const;
+export const FEE_RULE_TYPES = [
+  'STORAGE_FEE',
+  'DEMURRAGE_FEE',
+  'DOUBLE_HANDLING_FEE',
+  'TRUCK_DETENTION_FEE',
+] as const;
 export type FeeRuleType = (typeof FEE_RULE_TYPES)[number];
 
+/**
+ * Charge basis for a DOUBLE_HANDLING_FEE rule (flat rate × the chosen quantity):
+ *  - PER_CONTAINER: booking container count
+ *  - PER_TON:  cargo total in tonnes (bulk cargo)
+ *  - PER_ITEM: cargo total item count (break-bulk cargo, e.g. machinery)
+ */
+export const FEE_RULE_BASES = ['PER_CONTAINER', 'PER_TON', 'PER_ITEM'] as const;
+export type FeeRuleBasis = (typeof FEE_RULE_BASES)[number];
+
 export interface WarehouseFeeTier {
   fromDay: number;
   toDay: number | null;
@@ -57,9 +71,20 @@ export class WarehouseFeeRule extends BaseEntity {
   @Column({ name: 'free_days', type: 'int', default: 0 })
   freeDays!: number;
 
+  // Truck detention only: grace window in HOURS before detention accrues
+  // (contract default 3h). Null/0 → the 3-hour default.
+  @Column({ name: 'free_hours', type: 'int', nullable: true })
+  freeHours?: number | null;
+
   @Column({ name: 'rate_per_day', type: 'numeric', precision: 14, scale: 2, default: 0 })
   ratePerDay!: number;
 
+  // Double-handling only: PER_CONTAINER | PER_TON | PER_MACHINERY. The flat rate
+  // (rate_per_day, reused as rate-per-unit) is multiplied by the basis quantity;
+  // free days and tiers do not apply. Null for the day-based fee types.
+  @Column({ name: 'basis', type: 'varchar', length: 20, nullable: true })
+  basis?: FeeRuleBasis | null;
+
   @Column({ name: 'tiers', type: 'jsonb', default: () => "'[]'" })
   tiers!: WarehouseFeeTier[];
 
diff --git a/apps/edr-freight-api/src/modules/warehouses/warehouse-fee.service.ts b/apps/edr-freight-api/src/modules/warehouses/warehouse-fee.service.ts
index cfc7fbf6c..c322482b2 100644
--- a/apps/edr-freight-api/src/modules/warehouses/warehouse-fee.service.ts
+++ b/apps/edr-freight-api/src/modules/warehouses/warehouse-fee.service.ts
@@ -3,7 +3,7 @@ import { ExchangeService } from '@edr/api-common';
 import { DataSource } from 'typeorm';
 
 import { CreateFeeRuleDto, UpdateFeeRuleDto } from './dto/fee-rule.dto';
-import { FeeRuleType, WarehouseFeeRule, WarehouseFeeTier } from './entities/warehouse-fee-rule.entity';
+import { FeeRuleBasis, FeeRuleType, WarehouseFeeRule, WarehouseFeeTier } from './entities/warehouse-fee-rule.entity';
 import { WarehouseFeeRuleRepository } from './warehouse-fee-rule.repository';
 
 interface ItemAttributes {
@@ -16,6 +16,8 @@ interface ItemAttributes {
   containerTypeCode: string | null;
   inventoryQuantity: number;
   bookingContainerCount: number;
+  /** Booking cargo total in the cargo's unit of measure: tonnes (PER_TON) or item count (PER_ITEM). */
+  cargoQuantity: number;
   facilityId: string | null;
   warehouseId: string | null;
   yardId: string | null;
@@ -24,6 +26,8 @@ interface ItemAttributes {
 
 export interface FeePreview {
   ruleType: FeeRuleType;
+  /** Double-handling charge basis (PER_CONTAINER | PER_TON | PER_MACHINERY); null otherwise. */
+  basis: FeeRuleBasis | null;
   ruleId: string | null;
   ruleName: string | null;
   freeDays: number;
@@ -132,7 +136,8 @@ export class WarehouseFeeService {
               b.trade_direction     AS "tradeDirection",
               COALESCE(cgt.code, booking_cgt.code) AS "cargoTypeCode",
               COALESCE(ctt.code, booking_ctt.code) AS "containerTypeCode",
-              COALESCE(container_lines.container_count, 0) AS "bookingContainerCount"
+              COALESCE(container_lines.container_count, 0) AS "bookingContainerCount",
+              COALESCE(b.cargo_total_weight_vgm, 0) AS "cargoQuantity"
          FROM freight.warehouse_inventory inv
          LEFT JOIN freight.warehouses w ON w.id = inv.warehouse_id
          LEFT JOIN freight.bookings b ON b.id = inv.booking_id
@@ -283,6 +288,10 @@ export class WarehouseFeeService {
     now: Date,
     billingCurrency: string,
   ): Promise<FeePreview> {
+    // Double handling is a flat charge (rate × basis quantity), not day-based.
+    if (ruleType === 'DOUBLE_HANDLING_FEE') {
+      return this.computeDoubleHandling(rule, item, now, billingCurrency);
+    }
     const start = item.arrivedAt ? new Date(item.arrivedAt) : null;
     const endDate = item.gateClearedAt ?? item.releaseDate ?? now;
     const endIsOpen = !item.gateClearedAt && !item.releaseDate;
@@ -321,6 +330,7 @@ export class WarehouseFeeService {
 
     return {
       ruleType,
+      basis: null,
       ruleId: rule?.id ?? null,
       ruleName: rule?.name ?? null,
       freeDays,
@@ -340,13 +350,66 @@ export class WarehouseFeeService {
     };
   }
 
+  /**
+   * Double handling — a flat one-time charge, not time-based. Amount = rate ×
+   * the basis quantity: PER_CONTAINER (booking container count), or PER_TON /
+   * PER_ITEM (the booking cargo total in the cargo's unit of measure — tonnes
+   * for bulk, item count for break-bulk). No free days, no elapsed days, no tiers.
+   */
+  private async computeDoubleHandling(
+    rule: WarehouseFeeRule | null,
+    item: ItemAttributes,
+    now: Date,
+    billingCurrency: string,
+  ): Promise<FeePreview> {
+    const basis: FeeRuleBasis = rule?.basis ?? 'PER_CONTAINER';
+    const rate = Number(rule?.ratePerDay ?? 0);
+    const ruleCurrency = rule ? this.normalizeCurrency(rule.currency) : null;
+    const targetCurrency = this.normalizeCurrency(billingCurrency);
+    const isContainer = (item.freightType ?? '').toUpperCase() === 'CONTAINER';
+    const inventoryQuantity = Math.max(1, Math.round(Number(item.inventoryQuantity) || 1));
+    const containerCount = isContainer
+      ? Math.max(1, Math.round(Number(item.bookingContainerCount) || inventoryQuantity))
+      : 1;
+    // PER_TON (tonnes) and PER_ITEM (piece count) both read the cargo total,
+    // which is stored in the cargo's own unit of measure.
+    const cargoQuantity = Math.max(0, Number(item.cargoQuantity) || 0);
+    const quantity = basis === 'PER_CONTAINER' ? containerCount : cargoQuantity;
+    const sourceAmount = Math.round(rate * quantity * 100) / 100;
+    const amount = ruleCurrency ? await this.convertAmount(sourceAmount, ruleCurrency, targetCurrency) : 0;
+    const convertedRate = ruleCurrency ? await this.convertAmount(rate, ruleCurrency, targetCurrency) : 0;
+
+    return {
+      ruleType: 'DOUBLE_HANDLING_FEE',
+      basis,
+      ruleId: rule?.id ?? null,
+      ruleName: rule?.name ?? null,
+      freeDays: 0,
+      ratePerDay: convertedRate,
+      currency: targetCurrency,
+      ruleCurrency,
+      billingCurrency: targetCurrency,
+      startDate: null,
+      endDate: now.toISOString(),
+      endIsOpen: false,
+      elapsedDays: 0,
+      chargeableDays: 0,
+      containerCount,
+      billableUnits: quantity,
+      amount,
+      tiers: [],
+    };
+  }
+
   /** Preview demurrage + storage fees for an inventory item using the most specific active rules. */
   async previewForInventory(inventoryId: string, billingCurrency = 'USD'): Promise<FeePreview[]> {
     const item = await this.loadItem(inventoryId);
     const rules = await this.feeRuleRepository.findAll({ where: { isActive: true } });
     const now = new Date();
 
-    const byType: FeeRuleType[] = ['DEMURRAGE_FEE', 'STORAGE_FEE'];
+    // Truck detention is a per-truck last-mile charge, not a per-inventory fee —
+    // it is computed separately via previewTruckDetention(), not here.
+    const byType: FeeRuleType[] = ['DEMURRAGE_FEE', 'STORAGE_FEE', 'DOUBLE_HANDLING_FEE'];
     return Promise.all(
       byType.map((type) =>
         this.compute(
@@ -359,4 +422,111 @@ export class WarehouseFeeService {
       ),
     );
   }
+
+  /**
+   * Truck detention preview for an EDR last-mile leg. The vehicle should be
+   * returned within the rule's grace window (default 3h) of arriving; beyond
+   * that, detention accrues per truck per day (flat rate/day or progressive
+   * tiers by detention day) until it is delivered/returned (or now, if open).
+   */
+  async previewTruckDetention(lastMileId: string, billingCurrency = 'USD'): Promise<FeePreview> {
+    const [row] = await this.dataSource.query(
+      `SELECT lm.arrived_at   AS "arrivedAt",
+              lm.delivered_at AS "deliveredAt",
+              b.freight_type  AS "freightType",
+              b.trade_direction AS "tradeDirection",
+              (SELECT count(*) FROM freight.last_mile_vehicle_assignments va
+                WHERE va.last_mile_id = lm.id AND va.deleted_at IS NULL) AS "truckCount"
+         FROM freight.last_mile lm
+         LEFT JOIN freight.bookings b ON b.id = lm.booking_id
+        WHERE lm.id = $1 AND lm.deleted_at IS NULL`,
+      [lastMileId],
+    );
+    if (!row) throw new NotFoundException(`Last-mile record ${lastMileId} not found`);
+
+    const item: ItemAttributes = {
+      arrivedAt: null,
+      gateClearedAt: null,
+      releaseDate: null,
+      freightType: row.freightType ?? null,
+      tradeDirection: row.tradeDirection ?? null,
+      cargoTypeCode: null,
+      containerTypeCode: null,
+      inventoryQuantity: 1,
+      bookingContainerCount: 1,
+      cargoQuantity: 0,
+      facilityId: null,
+      warehouseId: null,
+      yardId: null,
+      zoneId: null,
+    };
+    const rules = await this.feeRuleRepository.findAll({ where: { isActive: true } });
+    const rule = this.bestRule(
+      rules.filter((r) => r.ruleType === 'TRUCK_DETENTION_FEE'),
+      item,
+    );
+    return this.computeTruckDetention(rule, row, new Date(), billingCurrency);
+  }
+
+  private async computeTruckDetention(
+    rule: WarehouseFeeRule | null,
+    row: { arrivedAt: Date | string | null; deliveredAt: Date | string | null; truckCount: number | string },
+    now: Date,
+    billingCurrency: string,
+  ): Promise<FeePreview> {
+    const graceHours = rule?.freeHours && Number(rule.freeHours) > 0 ? Number(rule.freeHours) : 3;
+    const truckCount = Math.max(1, Math.round(Number(row.truckCount) || 1));
+    const start = row.arrivedAt ? new Date(row.arrivedAt) : null;
+    const end = row.deliveredAt ? new Date(row.deliveredAt) : now;
+    const endIsOpen = !row.deliveredAt;
+
+    let chargeableDays = 0;
+    if (start) {
+      const detentionMs = end.getTime() - start.getTime() - graceHours * 60 * 60 * 1000;
+      chargeableDays = detentionMs > 0 ? Math.ceil(detentionMs / MS_PER_DAY) : 0;
+    }
+
+    const ratePerDay = Number(rule?.ratePerDay ?? 0);
+    const ruleCurrency = rule ? this.normalizeCurrency(rule.currency) : null;
+    const targetCurrency = this.normalizeCurrency(billingCurrency);
+    const hasTiers = Boolean(rule?.tiers?.length);
+    const tiered = this.calculateTieredAmount(rule?.tiers, chargeableDays, truckCount);
+    const billableUnits = hasTiers ? tiered.billableUnits : chargeableDays * truckCount;
+    const sourceAmount = hasTiers ? tiered.sourceAmount : Math.round(billableUnits * ratePerDay * 100) / 100;
+    const amount = ruleCurrency ? await this.convertAmount(sourceAmount, ruleCurrency, targetCurrency) : 0;
+    const sourceRatePerDay = hasTiers ? tiered.weightedRatePerDay : ratePerDay;
+    const convertedRatePerDay = ruleCurrency
+      ? await this.convertAmount(sourceRatePerDay, ruleCurrency, targetCurrency)
+      : 0;
+    const convertedTiers = ruleCurrency
+      ? await Promise.all(
+          tiered.tiers.map(async (tier) => ({
+            ...tier,
+            ratePerDay: await this.convertAmount(tier.ratePerDay, ruleCurrency, targetCurrency),
+            amount: await this.convertAmount(tier.amount, ruleCurrency, targetCurrency),
+          })),
+        )
+      : [];
+
+    return {
+      ruleType: 'TRUCK_DETENTION_FEE',
+      basis: null,
+      ruleId: rule?.id ?? null,
+      ruleName: rule?.name ?? null,
+      freeDays: 0,
+      ratePerDay: convertedRatePerDay,
+      currency: targetCurrency,
+      ruleCurrency,
+      billingCurrency: targetCurrency,
+      startDate: start ? start.toISOString() : null,
+      endDate: end.toISOString(),
+      endIsOpen,
+      elapsedDays: chargeableDays,
+      chargeableDays,
+      containerCount: truckCount, // reused as the per-truck count
+      billableUnits,
+      amount,
+      tiers: hasTiers ? convertedTiers : [],
+    };
+  }
 }
diff --git a/apps/edr-freight-api/src/modules/warehouses/warehouse-invoice.controller.ts b/apps/edr-freight-api/src/modules/warehouses/warehouse-invoice.controller.ts
index 8b16e3bec..a1c5db837 100644
--- a/apps/edr-freight-api/src/modules/warehouses/warehouse-invoice.controller.ts
+++ b/apps/edr-freight-api/src/modules/warehouses/warehouse-invoice.controller.ts
@@ -18,6 +18,15 @@ export class WarehouseInvoiceController {
     return this.invoiceService.generateForInventory(id, dto);
   }
 
+  @Post('last-mile/:id/generate-truck-detention-invoice')
+  @ApiOperation({ summary: 'Generate a truck-detention invoice for a last-mile leg (per truck per day)' })
+  generateTruckDetention(
+    @Param('id', ParseUUIDPipe) id: string,
+    @Body() dto: GenerateInvoiceDto,
+  ) {
+    return this.invoiceService.generateTruckDetentionInvoice(id, dto);
+  }
+
   @Get('warehouse-inventory/:id/fee-invoices')
   @ApiOperation({ summary: 'List fee invoices for an inventory item' })
   listForInventory(@Param('id', ParseUUIDPipe) id: string) {
diff --git a/apps/edr-freight-api/src/modules/warehouses/warehouse-invoice.service.ts b/apps/edr-freight-api/src/modules/warehouses/warehouse-invoice.service.ts
index 45591638a..4683b3bda 100644
--- a/apps/edr-freight-api/src/modules/warehouses/warehouse-invoice.service.ts
+++ b/apps/edr-freight-api/src/modules/warehouses/warehouse-invoice.service.ts
@@ -182,25 +182,38 @@ export class WarehouseInvoiceService {
     const items = previews
       .filter((p) => p.amount > 0)
       .map((p) => {
-        const feeType: WarehouseFeeType =
-          p.ruleType === "STORAGE_FEE"
-            ? "STORAGE_FEE"
-            : isContainer
-              ? "CONTAINER_DEMURRAGE"
-              : "BULK_DEMURRAGE";
+        const days = `${p.chargeableDays} chargeable day(s) x ${p.containerCount} container(s)`;
+        const tierSuffix = p.tiers.length ? " using tiered tariff" : ` after ${p.freeDays} free`;
+        let feeType: WarehouseFeeType;
+        let description: string;
+        switch (p.ruleType) {
+          case "STORAGE_FEE":
+            feeType = "STORAGE_FEE";
+            description = `Storage fee - ${days}${tierSuffix}`;
+            break;
+          case "DOUBLE_HANDLING_FEE": {
+            feeType = "DOUBLE_HANDLING";
+            const unit =
+              p.basis === "PER_TON"
+                ? "ton(s)"
+                : p.basis === "PER_ITEM"
+                  ? "item(s)"
+                  : "container(s)";
+            description = `Double handling - ${p.billableUnits} ${unit}`;
+            break;
+          }
+          case "TRUCK_DETENTION_FEE":
+            feeType = "TRUCK_DETENTION";
+            description = `Truck detention - ${days}${tierSuffix}`;
+            break;
+          default:
+            feeType = isContainer ? "CONTAINER_DEMURRAGE" : "BULK_DEMURRAGE";
+            description = `${isContainer ? "Container" : "Bulk"} demurrage - ${days}${tierSuffix}`;
+        }
         return {
           feeRuleId: p.ruleId,
           feeType,
-          description:
-            p.ruleType === "STORAGE_FEE"
-              ? `Storage fee - ${p.chargeableDays} chargeable day(s) x ${p.containerCount} container(s)${p.tiers.length
-                ? " using tiered tariff"
-                : ` after ${p.freeDays} free`
-              }`
-              : `${isContainer ? "Container" : "Bulk"} demurrage - ${p.chargeableDays} chargeable day(s) x ${p.containerCount} container(s)${p.tiers.length
-                ? " using tiered tariff"
-                : ` after ${p.freeDays} free`
-              }`,
+          description,
           quantity: p.billableUnits,
           unitRate: p.ratePerDay,
           amount: p.amount,
@@ -256,6 +269,79 @@ export class WarehouseInvoiceService {
     return detail;
   }
 
+  /**
+   * Generate a truck-detention invoice for a last-mile leg. Unlike warehouse fees
+   * (per inventory item), detention is a per-truck charge on the last-mile leg, so
+   * it becomes a `last_mile` invoice with its own `TRUCK_DETENTION_FEE` type — kept
+   * separate from the delivery-fee invoice. Returns the global Invoice.
+   */
+  async generateTruckDetentionInvoice(
+    lastMileId: string,
+    opts: { billingCurrency?: "ETB" | "USD"; confirmZero?: boolean } = {},
+  ): Promise<Invoice> {
+    const [lm] = await this.dataSource.query(
+      `SELECT lm.id,
+              b.company_id         AS "companyId",
+              b.company_profile_id AS "companyProfileId",
+              b.payment_currency   AS "paymentCurrency"
+         FROM freight.last_mile lm
+         LEFT JOIN freight.bookings b ON b.id = lm.booking_id
+        WHERE lm.id = $1 AND lm.deleted_at IS NULL`,
+      [lastMileId],
+    );
+    if (!lm) throw new NotFoundException(`Last-mile record ${lastMileId} not found`);
+    if (!lm.companyId) {
+      throw new BadRequestException(
+        "Cannot invoice truck detention: the last-mile leg has no billable company (no associated booking).",
+      );
+    }
+
+    const existing = await this.billing.findPayable(
+      "last_mile" as Freight.InvoiceSource,
+      lastMileId,
+      "TRUCK_DETENTION_FEE",
+    );
+    if (existing) {
+      throw new ConflictException(
+        "An active truck detention invoice already exists for this last-mile leg. Cancel it before generating a new one.",
+      );
+    }
+
+    const billingCurrency: "ETB" | "USD" =
+      opts.billingCurrency ?? (lm.paymentCurrency === "ETB" ? "ETB" : "USD");
+    const preview = await this.feeService.previewTruckDetention(lastMileId, billingCurrency);
+    if (preview.amount <= 0 && !opts.confirmZero) {
+      throw new BadRequestException(
+        "No truck detention is currently payable for this last-mile leg.",
+      );
+    }
+
+    const truckCount = preview.containerCount; // reused as the per-truck count
+    const line: InvoiceLineInput = {
+      chargeType: "TRUCK_DETENTION",
+      description: `Truck detention - ${preview.chargeableDays} day(s) x ${truckCount} truck(s)${preview.tiers.length ? " using tiered tariff" : ""}`,
+      quantity: preview.billableUnits,
+      unitRate: preview.ratePerDay,
+      amount: preview.amount,
+      currency: preview.currency,
+      metadata: {
+        feeRuleId: preview.ruleId ?? null,
+        chargeableDays: preview.chargeableDays ?? null,
+      },
+    };
+
+    return this.billing.generateInvoice({
+      source: "last_mile" as Freight.InvoiceSource,
+      sourceId: lastMileId,
+      type: "TRUCK_DETENTION_FEE",
+      companyId: lm.companyId,
+      companyProfileId: lm.companyProfileId || "",
+      currency: billingCurrency,
+      lines: [line],
+      status: Freight.InvoiceStatus.Issued,
+    });
+  }
+
   // ── Reads ────────────────────────────────────────────────────────────────
   async findById(id: string): Promise<WarehouseFeeInvoiceDetail> {
     const invoice = await this.loadWarehouseInvoice(id);
diff --git a/apps/edr-freight-api/src/modules/warehouses/warehouse-invoice.types.ts b/apps/edr-freight-api/src/modules/warehouses/warehouse-invoice.types.ts
index e201241ba..418816beb 100644
--- a/apps/edr-freight-api/src/modules/warehouses/warehouse-invoice.types.ts
+++ b/apps/edr-freight-api/src/modules/warehouses/warehouse-invoice.types.ts
@@ -26,6 +26,8 @@ export const WAREHOUSE_FEE_TYPES = [
   'BULK_DEMURRAGE',
   'STORAGE_FEE',
   'HANDLING_FEE',
+  'DOUBLE_HANDLING',
+  'TRUCK_DETENTION',
 ] as const;
 export type WarehouseFeeType = (typeof WAREHOUSE_FEE_TYPES)[number];
 
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 1d8e3d9ea..1d02633d5 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
@@ -1,6 +1,7 @@
 import { Injectable } from '@nestjs/common';
 
 import { PdfRenderService } from '../billing/documents/pdf-render.service';
+import { buildTabularFallbackPdf } from '../billing/documents/styled-pdf.util';
 
 const MIN_VALID_PDF_BYTES = 2_000;
 
@@ -32,6 +33,19 @@ export class WarehouseReleaseDocumentService {
     return this.pdf.htmlToPdfBuffer(html, { label });
   }
 
+  /**
+   * Render a "summary tiles + one table + notice + signatures" document (the
+   * marshalling / load-list layout) with a STYLED table-aware fallback for when
+   * Chromium is unavailable — so the manifest draws as a real gridded document
+   * instead of a flat plain-text dump.
+   */
+  renderTabularDocument(html: string, label = 'Document'): Promise<Buffer> {
+    return this.pdf.htmlToPdfBuffer(html, {
+      label,
+      fallback: (preparedHtml) => buildTabularFallbackPdf(preparedHtml),
+    });
+  }
+
   /**
    * Render document HTML with a STYLED hand-built fallback (the release layout,
    * but with a custom title + section heading) for when Chromium is unavailable.
diff --git a/apps/edr-freight-api/src/modules/warehouses/warehouse-rules.controller.ts b/apps/edr-freight-api/src/modules/warehouses/warehouse-rules.controller.ts
index 715080612..d35587d9e 100644
--- a/apps/edr-freight-api/src/modules/warehouses/warehouse-rules.controller.ts
+++ b/apps/edr-freight-api/src/modules/warehouses/warehouse-rules.controller.ts
@@ -85,4 +85,13 @@ export class WarehouseRulesController {
   ) {
     return this.feeService.previewForInventory(id, billingCurrency);
   }
+
+  @Get('last-mile/:id/truck-detention-preview')
+  @ApiOperation({ summary: 'Preview truck detention for a last-mile leg (per truck per day after grace)' })
+  truckDetentionPreview(
+    @Param('id', ParseUUIDPipe) id: string,
+    @Query('billingCurrency') billingCurrency?: string,
+  ) {
+    return this.feeService.previewTruckDetention(id, billingCurrency);
+  }
 }
diff --git a/apps/edr-freight-api/src/seed/file-upload-settings.seeder.ts b/apps/edr-freight-api/src/seed/file-upload-settings.seeder.ts
index e5e3bb139..1aef33801 100644
--- a/apps/edr-freight-api/src/seed/file-upload-settings.seeder.ts
+++ b/apps/edr-freight-api/src/seed/file-upload-settings.seeder.ts
@@ -512,6 +512,32 @@ const CONTRACT_INTAKE_SETTINGS: OnboardingDocumentSetting[] = [
 const CLEARANCE_DESCRIPTION =
   "Operation/clearance documents collected after contract execution, by operation, freight type and customs.";
 
+// ── Driver documents ────────────────────────────────────────────────────────
+// Configurable upload area (code "driver_docs") attached to a driver profile —
+// license, national ID, contracts, training certificates, etc.
+const DRIVER_DOCUMENT_FIELDS: OnboardingField[] = [
+  {
+    fileKey: "driver_docs",
+    fileLabel: "Driver documents",
+    helpText: "License, national ID, contracts, training certificates, etc.",
+    isRequired: false,
+    isMultiple: true,
+    maxFiles: 20,
+    allowedExtensions: ["pdf", "jpg", "jpeg", "png", "doc", "docx"],
+    maxSizeMb: 10,
+    displayOrder: 1,
+  },
+];
+
+const DRIVER_DOCUMENT_SETTINGS: OnboardingDocumentSetting[] = [
+  {
+    code: "driver_docs",
+    label: "Driver documents",
+    entity: "driver",
+    fields: DRIVER_DOCUMENT_FIELDS,
+  },
+];
+
 @Injectable()
 export class FileUploadSettingsSeeder {
   private readonly logger = new Logger(FileUploadSettingsSeeder.name);
@@ -549,6 +575,11 @@ export class FileUploadSettingsSeeder {
           description:
             "Commercial/framework documents attached at contract submission.",
         })),
+        ...DRIVER_DOCUMENT_SETTINGS.map((s) => ({
+          ...s,
+          description:
+            "Documents uploaded against a driver profile (license, ID, contracts, etc.).",
+        })),
       ];
 
       for (const documentSetting of allSettings) {
diff --git a/apps/edr-freight-web/backoffice/package.json b/apps/edr-freight-web/backoffice/package.json
index 4efc5c2d4..b89807b72 100644
--- a/apps/edr-freight-web/backoffice/package.json
+++ b/apps/edr-freight-web/backoffice/package.json
@@ -22,6 +22,7 @@
     "@tabler/icons-react": "^3.44.0",
     "@tanstack/react-query": "^5.100.11",
     "@tria-plc/iamui": "file:../../../local-packages/tria-plc-iamui-0.1.1.tgz",
+    "@vis.gl/react-google-maps": "^1.8.3",
     "axios": "^1.7.7",
     "class-variance-authority": "^0.7.1",
     "clsx": "^2.1.1",
@@ -44,6 +45,7 @@
     "@edr/eslint-config": "workspace:*",
     "@edr/tsconfig": "workspace:*",
     "@tailwindcss/vite": "^4.3.0",
+    "@types/google.maps": "^3.65.2",
     "@types/react": "^18.3.11",
     "@types/react-dom": "^18.3.0",
     "@vitejs/plugin-react": "^4.3.2",
diff --git a/apps/edr-freight-web/backoffice/src/App.tsx b/apps/edr-freight-web/backoffice/src/App.tsx
index 06454e885..df8db49d4 100644
--- a/apps/edr-freight-web/backoffice/src/App.tsx
+++ b/apps/edr-freight-web/backoffice/src/App.tsx
@@ -94,6 +94,10 @@ import { MaintenancePage } from "./pages/fleet/MaintenancePage";
 import { FinancialReportsPage } from "./pages/fleet/FinancialReportsPage";
 import { FleetDashboard } from "./pages/fleet/FleetDashboard";
 import { TrackingPage } from "./pages/fleet/TrackingPage";
+import CompliancePage from "./pages/fleet/CompliancePage";
+import IncidentsPage from "./pages/fleet/IncidentsPage";
+import WorkOrdersPage from "./pages/fleet/WorkOrdersPage";
+import ProcurementPage from "./pages/fleet/ProcurementPage";
 import { getCategorySidebarChildren } from "./pages/ruleEngine/config/resources";
 import RuleEngineLegacyRedirect from "./pages/ruleEngine/RuleEngineLegacyRedirect";
 import RuleEngineResourcePage from "./pages/ruleEngine/RuleEngineResourcePage";
@@ -212,13 +216,13 @@ const buildSidebarSections = (demoItems: SidebarItem[]): SidebarSection[] => [
         label: "First Mile",
         href: "/dashboard/operations/first-mile",
         icon: <Truck />,
-        permission: FREIGHT_PERMS.trainScheduling.view,
+        permission: FREIGHT_PERMS.firstMile.view,
       },
       {
         label: "Last Mile",
         href: "/dashboard/operations/last-mile",
         icon: <Truck />,
-        permission: FREIGHT_PERMS.trainScheduling.view,
+        permission: FREIGHT_PERMS.lastMile.view,
       },
     ],
   },
@@ -229,7 +233,7 @@ const buildSidebarSections = (demoItems: SidebarItem[]): SidebarSection[] => [
         label: "Fleet Dashboard",
         href: "/dashboard/fleet-dashboard",
         icon: <LayoutDashboard />,
-        permission: FREIGHT_PERMS.fleet.view,
+        permission: FREIGHT_PERMS.fleetDashboard.view,
       },
       {
         label: "Routes",
@@ -259,43 +263,67 @@ const buildSidebarSections = (demoItems: SidebarItem[]): SidebarSection[] => [
         label: "Vehicles",
         href: "/dashboard/vehicles",
         icon: <Truck />,
-        permission: FREIGHT_PERMS.fleet.view,
+        permission: FREIGHT_PERMS.vehicles.view,
       },
       {
         label: "Drivers",
         href: "/dashboard/drivers",
         icon: <Users />,
-        permission: FREIGHT_PERMS.fleet.view,
+        permission: FREIGHT_PERMS.drivers.view,
       },
       {
         label: "Track Vehicles",
         href: "/dashboard/tracking",
         icon: <MapPin />,
-        permission: FREIGHT_PERMS.fleet.view,
+        permission: FREIGHT_PERMS.tracking.view,
       },
       {
         label: "Fuel Purchases",
         href: "/dashboard/fuel-purchases",
         icon: <Truck />,
-        permission: FREIGHT_PERMS.fleet.view,
+        permission: FREIGHT_PERMS.fuel.view,
       },
       {
         label: "Fuel Analytics",
         href: "/dashboard/fuel-stats",
         icon: <Truck />,
-        permission: FREIGHT_PERMS.fleet.view,
+        permission: FREIGHT_PERMS.fuel.view,
       },
       {
         label: "Maintenance",
         href: "/dashboard/maintenance",
         icon: <Truck />,
+        permission: FREIGHT_PERMS.maintenance.view,
+      },
+      {
+        label: "Work Orders",
+        href: "/dashboard/work-orders",
+        icon: <SlidersHorizontal />,
+        permission: FREIGHT_PERMS.maintenance.view,
+      },
+      {
+        label: "Compliance & Alerts",
+        href: "/dashboard/compliance",
+        icon: <ShieldCheck />,
+        permission: FREIGHT_PERMS.fleet.view,
+      },
+      {
+        label: "Incidents",
+        href: "/dashboard/incidents",
+        icon: <FileText />,
+        permission: FREIGHT_PERMS.fleet.view,
+      },
+      {
+        label: "Procurement",
+        href: "/dashboard/procurement",
+        icon: <Package />,
         permission: FREIGHT_PERMS.fleet.view,
       },
       {
         label: "Financial Reports",
         href: "/dashboard/financial-reports",
         icon: <Wallet />,
-        permission: FREIGHT_PERMS.fleet.view,
+        permission: FREIGHT_PERMS.fleetReports.view,
       },
       // {
       //   label: "Containers",
@@ -868,7 +896,7 @@ const App = () => {
         <Route
           path="operations/first-mile"
           element={
-            <RequirePermission permission={FREIGHT_PERMS.trainScheduling.view}>
+            <RequirePermission permission={FREIGHT_PERMS.firstMile.view}>
               <FirstMilePage />
             </RequirePermission>
           }
@@ -876,7 +904,7 @@ const App = () => {
         <Route
           path="operations/last-mile"
           element={
-            <RequirePermission permission={FREIGHT_PERMS.trainScheduling.view}>
+            <RequirePermission permission={FREIGHT_PERMS.lastMile.view}>
               <LastMilePage />
             </RequirePermission>
           }
@@ -972,7 +1000,7 @@ const App = () => {
         <Route
           path="vehicles"
           element={
-            <RequirePermission permission={FREIGHT_PERMS.fleet.view}>
+            <RequirePermission permission={FREIGHT_PERMS.vehicles.view}>
               <FleetResourcePage />
             </RequirePermission>
           }
@@ -980,7 +1008,7 @@ const App = () => {
         <Route
           path="vehicles/:id"
           element={
-            <RequirePermission permission={FREIGHT_PERMS.fleet.view}>
+            <RequirePermission permission={FREIGHT_PERMS.vehicles.view}>
               <VehicleDetailPage />
             </RequirePermission>
           }
@@ -988,7 +1016,7 @@ const App = () => {
         <Route
           path="drivers"
           element={
-            <RequirePermission permission={FREIGHT_PERMS.fleet.view}>
+            <RequirePermission permission={FREIGHT_PERMS.drivers.view}>
               <FleetResourcePage />
             </RequirePermission>
           }
@@ -996,7 +1024,7 @@ const App = () => {
         <Route
           path="drivers/:id"
           element={
-            <RequirePermission permission={FREIGHT_PERMS.fleet.view}>
+            <RequirePermission permission={FREIGHT_PERMS.drivers.view}>
               <DriverDetailPage />
             </RequirePermission>
           }
@@ -1058,7 +1086,7 @@ const App = () => {
         <Route
           path="fuel-purchases"
           element={
-            <RequirePermission permission={FREIGHT_PERMS.fleet.view}>
+            <RequirePermission permission={FREIGHT_PERMS.fuel.view}>
               <FuelPurchasePage />
             </RequirePermission>
           }
@@ -1066,7 +1094,7 @@ const App = () => {
         <Route
           path="fuel-stats"
           element={
-            <RequirePermission permission={FREIGHT_PERMS.fleet.view}>
+            <RequirePermission permission={FREIGHT_PERMS.fuel.view}>
               <FuelStatsPage />
             </RequirePermission>
           }
@@ -1074,7 +1102,7 @@ const App = () => {
         <Route
           path="maintenance"
           element={
-            <RequirePermission permission={FREIGHT_PERMS.fleet.view}>
+            <RequirePermission permission={FREIGHT_PERMS.maintenance.view}>
               <MaintenancePage />
             </RequirePermission>
           }
@@ -1082,7 +1110,7 @@ const App = () => {
         <Route
           path="financial-reports"
           element={
-            <RequirePermission permission={FREIGHT_PERMS.fleet.view}>
+            <RequirePermission permission={FREIGHT_PERMS.fleetReports.view}>
               <FinancialReportsPage />
             </RequirePermission>
           }
@@ -1090,7 +1118,7 @@ const App = () => {
         <Route
           path="fleet-dashboard"
           element={
-            <RequirePermission permission={FREIGHT_PERMS.fleet.view}>
+            <RequirePermission permission={FREIGHT_PERMS.fleetDashboard.view}>
               <FleetDashboard />
             </RequirePermission>
           }
@@ -1098,11 +1126,43 @@ const App = () => {
         <Route
           path="tracking"
           element={
-            <RequirePermission permission={FREIGHT_PERMS.fleet.view}>
+            <RequirePermission permission={FREIGHT_PERMS.tracking.view}>
               <TrackingPage />
             </RequirePermission>
           }
         />
+        <Route
+          path="compliance"
+          element={
+            <RequirePermission permission={FREIGHT_PERMS.fleet.view}>
+              <CompliancePage />
+            </RequirePermission>
+          }
+        />
+        <Route
+          path="incidents"
+          element={
+            <RequirePermission permission={FREIGHT_PERMS.fleet.view}>
+              <IncidentsPage />
+            </RequirePermission>
+          }
+        />
+        <Route
+          path="work-orders"
+          element={
+            <RequirePermission permission={FREIGHT_PERMS.maintenance.view}>
+              <WorkOrdersPage />
+            </RequirePermission>
+          }
+        />
+        <Route
+          path="procurement"
+          element={
+            <RequirePermission permission={FREIGHT_PERMS.fleet.view}>
+              <ProcurementPage />
+            </RequirePermission>
+          }
+        />
         <Route
           path="locomotives"
           element={
diff --git a/apps/edr-freight-web/backoffice/src/components/contracts/ContractApprovalStepsCard.tsx b/apps/edr-freight-web/backoffice/src/components/contracts/ContractApprovalStepsCard.tsx
index 0d7adc5be..044c729ee 100644
--- a/apps/edr-freight-web/backoffice/src/components/contracts/ContractApprovalStepsCard.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/contracts/ContractApprovalStepsCard.tsx
@@ -1,5 +1,5 @@
 import { useMemo, useState } from "react";
-import { Check, ShieldCheck } from "lucide-react";
+import { Check, ShieldCheck, X } from "lucide-react";
 import {
   Stack,
   Group,
@@ -8,6 +8,7 @@ import {
   Button,
   Box,
   Modal,
+  Textarea,
 } from "@mantine/core";
 import type { Freight } from "@edr/types";
 
@@ -30,6 +31,10 @@ export function ContractApprovalStepsCard({
   const [confirmOpen, setConfirmOpen] = useState(false);
   const [pendingStep, setPendingStep] =
     useState<Freight.IContractApprovalStep | null>(null);
+  const [rejectOpen, setRejectOpen] = useState(false);
+  const [rejectStepRow, setRejectStepRow] =
+    useState<Freight.IContractApprovalStep | null>(null);
+  const [rejectReason, setRejectReason] = useState("");
 
   const steps = useMemo(
     () =>
@@ -60,6 +65,28 @@ export function ContractApprovalStepsCard({
     );
   };
 
+  const openReject = (step: Freight.IContractApprovalStep) => {
+    setRejectStepRow(step);
+    setRejectReason("");
+    setRejectOpen(true);
+  };
+
+  const closeReject = () => {
+    setRejectOpen(false);
+    setRejectStepRow(null);
+    setRejectReason("");
+  };
+
+  const trimmedReason = rejectReason.trim();
+
+  const runReject = () => {
+    if (!rejectStepRow || !trimmedReason) return;
+    mutations.rejectStep.mutate(
+      { stepId: rejectStepRow.id, reason: trimmedReason },
+      { onSuccess: () => closeReject() },
+    );
+  };
+
   const subtitle =
     summary.detail ||
     (nextPending
@@ -106,8 +133,12 @@ export function ContractApprovalStepsCard({
                 key={step.id}
                 step={step}
                 isNext={nextPending?.id === step.id}
-                isPending={mutations.approveStep.isPending}
+                isPending={
+                  mutations.approveStep.isPending ||
+                  mutations.rejectStep.isPending
+                }
                 onApprove={() => openApprove(step)}
+                onReject={() => openReject(step)}
               />
             ))}
           </Stack>
@@ -149,6 +180,54 @@ export function ContractApprovalStepsCard({
           </Group>
         </Stack>
       </Modal>
+
+      <Modal
+        opened={rejectOpen}
+        onClose={closeReject}
+        title="Reject this step?"
+        radius="md"
+        centered
+      >
+        <Stack gap="md">
+          <Text size="sm" c="dimmed">
+            Rejecting the{" "}
+            <Text span fw={600} c="dark">
+              {rejectStepRow?.requiredRole}
+            </Text>{" "}
+            step rejects contract{" "}
+            <Text span fw={600} c="dark">
+              {contract.reference}
+            </Text>{" "}
+            outright. The customer must create a new contract — this cannot be
+            undone.
+          </Text>
+          <Textarea
+            label="Reason for rejection"
+            description="Shared with the customer and the approval chain."
+            placeholder="Explain why this contract is rejected…"
+            minRows={3}
+            autosize
+            withAsterisk
+            value={rejectReason}
+            onChange={(e) => setRejectReason(e.currentTarget.value)}
+          />
+          <Group justify="flex-end" gap="sm">
+            <Button variant="default" radius="md" onClick={closeReject}>
+              Cancel
+            </Button>
+            <Button
+              color="red"
+              radius="md"
+              leftSection={<X size={16} />}
+              loading={mutations.rejectStep.isPending}
+              disabled={!trimmedReason}
+              onClick={runReject}
+            >
+              Reject contract
+            </Button>
+          </Group>
+        </Stack>
+      </Modal>
     </>
   );
 }
@@ -158,11 +237,13 @@ function StepRow({
   isNext,
   isPending,
   onApprove,
+  onReject,
 }: {
   step: Freight.IContractApprovalStep;
   isNext: boolean;
   isPending: boolean;
   onApprove: () => void;
+  onReject: () => void;
 }) {
   const statusColor =
     step.status === "APPROVED"
@@ -222,15 +303,27 @@ function StepRow({
       </Group>
       <Group gap="xs" wrap="nowrap" style={{ flexShrink: 0 }}>
         {isNext && step.status === "PENDING" && (
-          <Button
-            size="compact-sm"
-            color="edr-green"
-            leftSection={<Check size={14} />}
-            disabled={isPending}
-            onClick={onApprove}
-          >
-            Approve
-          </Button>
+          <>
+            <Button
+              size="compact-sm"
+              color="edr-green"
+              leftSection={<Check size={14} />}
+              disabled={isPending}
+              onClick={onApprove}
+            >
+              Approve
+            </Button>
+            <Button
+              size="compact-sm"
+              variant="light"
+              color="red"
+              leftSection={<X size={14} />}
+              disabled={isPending}
+              onClick={onReject}
+            >
+              Reject
+            </Button>
+          </>
         )}
         <Badge
           variant="light"
diff --git a/apps/edr-freight-web/backoffice/src/components/fleet/FleetFormDialog.tsx b/apps/edr-freight-web/backoffice/src/components/fleet/FleetFormDialog.tsx
index f314ab35e..7262e7927 100644
--- a/apps/edr-freight-web/backoffice/src/components/fleet/FleetFormDialog.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/fleet/FleetFormDialog.tsx
@@ -7,6 +7,7 @@ import {
   Group,
   Modal,
   NumberInput,
+  Radio,
   Select,
   MultiSelect,
   SimpleGrid,
@@ -293,6 +294,26 @@ const FleetFormDialog = ({
     // only by verification and never hand-edited.
     const isDisabled = Boolean(field.disabled || field.faydaLocked);
 
+    if (field.type === "radio") {
+      return (
+        <Radio.Group
+          key={field.name}
+          label={field.label}
+          value={value == null ? "" : String(value)}
+          onChange={(next) =>
+            setValues((current) => ({ ...current, [field.name]: next }))
+          }
+          error={error}
+        >
+          <Group gap="lg" mt={6}>
+            {(field.options ?? []).map((o) => (
+              <Radio key={o.value} value={o.value} label={o.label} disabled={isDisabled} />
+            ))}
+          </Group>
+        </Radio.Group>
+      );
+    }
+
     if (field.type === "select") {
       return (
         <Select
diff --git a/apps/edr-freight-web/backoffice/src/components/operations/TruckDetentionModal.tsx b/apps/edr-freight-web/backoffice/src/components/operations/TruckDetentionModal.tsx
new file mode 100644
index 000000000..1a0d96f96
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/components/operations/TruckDetentionModal.tsx
@@ -0,0 +1,215 @@
+import {
+  Alert,
+  Badge,
+  Button,
+  Divider,
+  Group,
+  Loader,
+  Modal,
+  Paper,
+  Stack,
+  Table,
+  Text,
+} from '@mantine/core';
+import { DateTimePicker } from '@mantine/dates';
+import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
+import { Receipt } from 'lucide-react';
+import { useEffect, useState } from 'react';
+
+import { QUERY_KEYS } from '@/constants/QUERY_KEYS';
+import { useToast } from '@/hooks/use-toast';
+import { lastMileService, type LastMileRecord } from '@/services/last-mile.service';
+
+interface TruckDetentionModalProps {
+  opened: boolean;
+  onClose: () => void;
+  record: LastMileRecord | null;
+}
+
+const money = (amount: number, currency: string) =>
+  `${Number(amount).toLocaleString()} ${currency === 'ETB' ? 'Birr (ETB)' : currency}`;
+
+function Stat({ label, value, strong }: { label: string; value: React.ReactNode; strong?: boolean }) {
+  return (
+    <Paper withBorder p="sm" radius="md" style={{ flex: 1, minWidth: 120 }}>
+      <Text size="xs" c="dimmed" tt="uppercase" fw={600}>
+        {label}
+      </Text>
+      <Text size={strong ? 'lg' : 'md'} fw={strong ? 800 : 600}>
+        {value}
+      </Text>
+    </Paper>
+  );
+}
+
+/**
+ * View/override the detention clock (arrival + delivery/return) for a last-mile
+ * leg, preview the per-truck-per-day charge, and generate the detention invoice.
+ */
+export function TruckDetentionModal({ opened, onClose, record }: TruckDetentionModalProps) {
+  const { toast } = useToast();
+  const qc = useQueryClient();
+  const id = record?.id ?? null;
+  const [arrived, setArrived] = useState<Date | null>(null);
+  const [delivered, setDelivered] = useState<Date | null>(null);
+
+  useEffect(() => {
+    setArrived(record?.arrivedAt ? new Date(record.arrivedAt) : null);
+    setDelivered(record?.deliveredAt ? new Date(record.deliveredAt) : null);
+  }, [record?.id, record?.arrivedAt, record?.deliveredAt, opened]);
+
+  const previewQuery = useQuery({
+    queryKey: ['truck-detention-preview', id],
+    queryFn: async () => (await lastMileService.truckDetentionPreview(id as string)).data,
+    enabled: opened && Boolean(id),
+  });
+  const preview = previewQuery.data;
+
+  const saveTimes = useMutation({
+    mutationFn: () =>
+      lastMileService.update(id as string, {
+        arrivedAt: arrived ? arrived.toISOString() : null,
+        deliveredAt: delivered ? delivered.toISOString() : null,
+      }),
+    onSuccess: () => {
+      void qc.invalidateQueries({ queryKey: QUERY_KEYS.LAST_MILE.ROOT });
+      void previewQuery.refetch();
+      toast({ title: 'Detention times saved' });
+    },
+    onError: () => toast({ title: 'Save failed', variant: 'destructive' }),
+  });
+
+  const generate = useMutation({
+    mutationFn: () => lastMileService.generateTruckDetentionInvoice(id as string),
+    onSuccess: () => {
+      void qc.invalidateQueries({ queryKey: QUERY_KEYS.LAST_MILE.ROOT });
+      toast({ title: 'Truck detention invoice generated' });
+      onClose();
+    },
+    onError: (e: unknown) => {
+      const description = (e as { response?: { data?: { message?: string } } })?.response?.data?.message;
+      toast({ title: 'Detention invoice failed', description, variant: 'destructive' });
+    },
+  });
+
+  return (
+    <Modal
+      opened={opened}
+      onClose={onClose}
+      centered
+      size="lg"
+      title={
+        <Text fw={700}>
+          Truck detention{record?.booking?.reference ? ` · ${record.booking.reference}` : ''}
+        </Text>
+      }
+    >
+      <Stack gap="md">
+        <Group grow align="flex-start">
+          <DateTimePicker
+            label="Arrived at"
+            description="Detention clock start"
+            value={arrived}
+            onChange={(v) => setArrived(v ? new Date(v) : null)}
+            clearable
+          />
+          <DateTimePicker
+            label="Delivered / returned at"
+            description="Clock end (blank = still out)"
+            value={delivered}
+            onChange={(v) => setDelivered(v ? new Date(v) : null)}
+            clearable
+          />
+        </Group>
+        <Group justify="flex-end">
+          <Button variant="light" loading={saveTimes.isPending} onClick={() => saveTimes.mutate()}>
+            Save times
+          </Button>
+        </Group>
+
+        <Divider label="Detention preview" labelPosition="left" />
+
+        {previewQuery.isLoading ? (
+          <Group justify="center" py="md">
+            <Loader />
+          </Group>
+        ) : !preview ? (
+          <Alert color="gray" variant="light">
+            No preview available.
+          </Alert>
+        ) : !preview.ruleId ? (
+          <Alert color="orange" variant="light">
+            No active Truck Detention rule matches this booking. Create one under Warehouse → Fee rules
+            (rule type "Truck Detention Cost").
+          </Alert>
+        ) : (
+          <Stack gap="sm">
+            <Group grow>
+              <Stat label="Chargeable days" value={preview.chargeableDays} />
+              <Stat label="Trucks" value={preview.containerCount} />
+              <Stat label="Amount" value={money(preview.amount, preview.currency)} strong />
+            </Group>
+            {preview.endIsOpen && (
+              <Text size="xs" c="orange">
+                Still accruing — no delivery/return time yet. The amount grows until the vehicle is returned.
+              </Text>
+            )}
+            {preview.tiers && preview.tiers.length > 0 ? (
+              <Table withTableBorder withColumnBorders verticalSpacing="xs" fz="xs">
+                <Table.Thead>
+                  <Table.Tr>
+                    <Table.Th>From day</Table.Th>
+                    <Table.Th>To day</Table.Th>
+                    <Table.Th>Days</Table.Th>
+                    <Table.Th ta="right">Rate / truck / day</Table.Th>
+                    <Table.Th ta="right">Amount</Table.Th>
+                  </Table.Tr>
+                </Table.Thead>
+                <Table.Tbody>
+                  {preview.tiers.map((t, i) => (
+                    <Table.Tr key={i}>
+                      <Table.Td>{t.appliedFromDay}</Table.Td>
+                      <Table.Td>{t.appliedToDay}</Table.Td>
+                      <Table.Td>{t.days}</Table.Td>
+                      <Table.Td ta="right">{money(t.ratePerDay, preview.currency)}</Table.Td>
+                      <Table.Td ta="right">{money(t.amount, preview.currency)}</Table.Td>
+                    </Table.Tr>
+                  ))}
+                </Table.Tbody>
+              </Table>
+            ) : (
+              <Text size="sm" c="dimmed">
+                Flat {money(preview.ratePerDay, preview.currency)} per truck per day after the grace window.
+              </Text>
+            )}
+            <Group gap="xs">
+              <Badge variant="light" color="gray">
+                {preview.ruleName ?? 'Detention rule'}
+              </Badge>
+              {preview.billableUnits > 0 && (
+                <Text size="xs" c="dimmed">
+                  {preview.billableUnits} billable truck-day(s)
+                </Text>
+              )}
+            </Group>
+          </Stack>
+        )}
+
+        <Group justify="flex-end" mt="sm">
+          <Button variant="default" onClick={onClose}>
+            Close
+          </Button>
+          <Button
+            color="edr-green"
+            leftSection={<Receipt size={16} />}
+            disabled={!preview || preview.amount <= 0}
+            loading={generate.isPending}
+            onClick={() => generate.mutate()}
+          >
+            Generate invoice
+          </Button>
+        </Group>
+      </Stack>
+    </Modal>
+  );
+}
diff --git a/apps/edr-freight-web/backoffice/src/components/warehouses/FeePreviewModal.tsx b/apps/edr-freight-web/backoffice/src/components/warehouses/FeePreviewModal.tsx
index 1d192e2b2..78e09a7e0 100644
--- a/apps/edr-freight-web/backoffice/src/components/warehouses/FeePreviewModal.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/warehouses/FeePreviewModal.tsx
@@ -28,6 +28,8 @@ interface FeePreviewModalProps {
 const LABELS: Record<string, { label: string; color: string }> = {
   DEMURRAGE_FEE: { label: 'Demurrage', color: 'orange' },
   STORAGE_FEE: { label: 'Storage', color: 'teal' },
+  DOUBLE_HANDLING_FEE: { label: 'Double Handling', color: 'grape' },
+  TRUCK_DETENTION_FEE: { label: 'Truck Detention Cost', color: 'blue' },
 };
 
 function fmtDate(iso: string | null) {
diff --git a/apps/edr-freight-web/backoffice/src/components/warehouses/ReceiveInventoryModal.tsx b/apps/edr-freight-web/backoffice/src/components/warehouses/ReceiveInventoryModal.tsx
index 83c7fcbcd..3e3877236 100644
--- a/apps/edr-freight-web/backoffice/src/components/warehouses/ReceiveInventoryModal.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/warehouses/ReceiveInventoryModal.tsx
@@ -646,9 +646,15 @@ function TruckEntranceFields({
 function LocationSelects({
   value,
   onChange,
+  allowedYardTypes,
+  allowedZoneTypes,
 }: {
   value: Location;
   onChange: (next: Location) => void;
+  /** When non-empty, only yards of these types are offered (matched to freight). */
+  allowedYardTypes?: string[];
+  /** When non-empty, only zones of these types are offered. */
+  allowedZoneTypes?: string[];
 }) {
   const warehousesQuery = useQuery(
     api.warehouses.list.queryOptions({ input: { filter: { status: 'ACTIVE' } } }),
@@ -674,15 +680,17 @@ function LocationSelects({
     () =>
       (yardsQuery.data ?? [])
         .filter((y) => y.status === 'ACTIVE')
+        .filter((y) => !allowedYardTypes?.length || allowedYardTypes.includes((y as { type?: string }).type ?? ''))
         .map((y) => ({ value: y.id, label: `${y.name} (${y.code})` })),
-    [yardsQuery.data],
+    [yardsQuery.data, allowedYardTypes],
   );
   const zoneOptions = useMemo(
     () =>
       (zonesQuery.data ?? [])
         .filter((z) => z.status === 'ACTIVE')
+        .filter((z) => !allowedZoneTypes?.length || allowedZoneTypes.includes((z as { type?: string }).type ?? ''))
         .map((z) => ({ value: z.id, label: `${z.name} (${z.code})` })),
-    [zonesQuery.data],
+    [zonesQuery.data, allowedZoneTypes],
   );
 
   return (
@@ -1760,6 +1768,29 @@ const importLocationTypesForFreight = (freightType: string | null | undefined) =
 const isImportContainerFreight = (freightType: string | null | undefined) =>
   (freightType ?? '').toUpperCase() === 'CONTAINER';
 
+/**
+ * Yard/zone types valid for the freight being received — used to filter the receive
+ * location pickers so the yard list matches the cargo. Container freight → container
+ * yards only; bulk / break-bulk → bulk, general-cargo, hazardous, or cold-storage.
+ * Union across the given freight types; empty input → no restriction (show all).
+ */
+const yardZoneTypesForFreights = (freightTypes: Array<string | null | undefined>) => {
+  const yardTypes = new Set<string>();
+  const zoneTypes = new Set<string>();
+  for (const freightType of freightTypes) {
+    const normalized = (freightType ?? '').toUpperCase();
+    if (!normalized) continue;
+    if (normalized === 'CONTAINER') {
+      yardTypes.add('CONTAINER_YARD');
+      zoneTypes.add('CONTAINER_ZONE');
+    } else {
+      ['BULK_YARD', 'GENERAL_CARGO_YARD', 'HAZARDOUS_YARD', 'COLD_STORAGE_YARD'].forEach((t) => yardTypes.add(t));
+      ['BULK_ZONE', 'GENERAL_CARGO_ZONE', 'HAZARDOUS_ZONE', 'COLD_STORAGE_ZONE'].forEach((t) => zoneTypes.add(t));
+    }
+  }
+  return { yardTypes: [...yardTypes], zoneTypes: [...zoneTypes] };
+};
+
 const isImportUnloadPending = (item: ImportTrainItem) =>
   !item.currentStatus || item.currentStatus === 'RECEIVED';
 
@@ -2888,6 +2919,24 @@ export function WarehouseFlowWorkbench({
   );
   const activeDirection = direction === 'BOTH' ? tab : direction;
 
+  // Match the yard/zone list to the freight being received (container → container
+  // yards, etc). Same query key as the export tab, so React Query dedupes it.
+  const { data: eligibleForLocation = [] } = useQuery(
+    api.warehouses.eligibleBookings.queryOptions({
+      input: { direction: activeDirection },
+      enabled: enabled && activeDirection === 'EXPORT',
+    }),
+  );
+  const { yardTypes: allowedYardTypes, zoneTypes: allowedZoneTypes } = useMemo(
+    () =>
+      yardZoneTypesForFreights(
+        eligibleForLocation
+          .filter((r) => r.direction === activeDirection)
+          .map((r) => r.freightType),
+      ),
+    [eligibleForLocation, activeDirection],
+  );
+
   useEffect(() => {
     if (enabled) setLocation({ warehouseId: '', yardId: '', zoneId: '' });
   }, [enabled, direction]);
@@ -2895,7 +2944,12 @@ export function WarehouseFlowWorkbench({
   return (
     <Stack gap="md">
       {activeDirection === 'EXPORT' && (
-        <LocationSelects value={location} onChange={setLocation} />
+        <LocationSelects
+          value={location}
+          onChange={setLocation}
+          allowedYardTypes={allowedYardTypes}
+          allowedZoneTypes={allowedZoneTypes}
+        />
       )}
 
       {direction === 'BOTH' ? (
diff --git a/apps/edr-freight-web/backoffice/src/constants/URLS.ts b/apps/edr-freight-web/backoffice/src/constants/URLS.ts
index fce620235..a42c7c01b 100644
--- a/apps/edr-freight-web/backoffice/src/constants/URLS.ts
+++ b/apps/edr-freight-web/backoffice/src/constants/URLS.ts
@@ -162,6 +162,8 @@ export const URL_CONSTANTS = {
     STAFF_REJECT: (id: string) => `/contracts/${id}/staff/reject`,
     APPROVE_STEP: (id: string, stepId: string) =>
       `/contracts/${id}/approval-steps/${stepId}/approve`,
+    REJECT_STEP: (id: string, stepId: string) =>
+      `/contracts/${id}/approval-steps/${stepId}/reject`,
     CONTRACT_GENERATE: (id: string) => `/contracts/${id}/contract/generate`,
     CONTRACT_VIEW: (id: string) => `/contracts/${id}/contract/view`,
     CONTRACT_DOCUMENT: (id: string) => `/contracts/${id}/contract/document`,
diff --git a/apps/edr-freight-web/backoffice/src/features/bookingWindows/useBookingWindowSocket.ts b/apps/edr-freight-web/backoffice/src/features/bookingWindows/useBookingWindowSocket.ts
index 375c12f19..3941c487c 100644
--- a/apps/edr-freight-web/backoffice/src/features/bookingWindows/useBookingWindowSocket.ts
+++ b/apps/edr-freight-web/backoffice/src/features/bookingWindows/useBookingWindowSocket.ts
@@ -35,6 +35,18 @@ export function useBookingWindowSocket(enabled: boolean = true) {
       withCredentials: true,
     });
 
+    // Deliberate console breadcrumbs: "live updates not arriving" is only
+    // diagnosable from the browser when connect/reject outcomes are visible.
+    socket.on("connect", () =>
+      console.debug("[booking-windows] socket connected", socket.id),
+    );
+    socket.on("connect_error", (err) =>
+      console.warn("[booking-windows] socket connect failed:", err.message),
+    );
+    socket.on("disconnect", (reason) =>
+      console.debug("[booking-windows] socket disconnected:", reason),
+    );
+
     socket.on(
       BOOKING_WINDOW_WS_EVENTS.PHASE,
       (_event: BookingWindowPhaseEvent) => {
diff --git a/apps/edr-freight-web/backoffice/src/features/notifications/notificationConfig.tsx b/apps/edr-freight-web/backoffice/src/features/notifications/notificationConfig.tsx
index 9baf4ebf2..1ed61f72b 100644
--- a/apps/edr-freight-web/backoffice/src/features/notifications/notificationConfig.tsx
+++ b/apps/edr-freight-web/backoffice/src/features/notifications/notificationConfig.tsx
@@ -1,6 +1,6 @@
 import { NotificationType } from "@edr/types";
 import type { NotificationItemData, NotificationVisual } from "@edr/ui-common";
-import { Bell, ClipboardCheck, Inbox, Wallet } from "lucide-react";
+import { Bell, ClipboardCheck, FileSignature, Inbox, Wallet } from "lucide-react";
 
 const ICON_SIZE = 17;
 
@@ -19,6 +19,8 @@ export function resolveNotificationVisual(
       return { icon: <Wallet size={ICON_SIZE} />, color: "teal" };
     case NotificationType.CLEARANCE_REVIEW:
       return { icon: <ClipboardCheck size={ICON_SIZE} />, color: "orange" };
+    case NotificationType.CONTRACT_STATUS:
+      return { icon: <FileSignature size={ICON_SIZE} />, color: "indigo" };
     default:
       return { icon: <Bell size={ICON_SIZE} />, color: "edr-green" };
   }
@@ -39,14 +41,32 @@ export function resolveNotificationHref(
   if (item.link) return item.link;
   const data = item.data ?? {};
   switch (item.type) {
-    case NotificationType.REQUEST_SUBMITTED:
+    case NotificationType.REQUEST_SUBMITTED: {
+      const bookingId = asId(data.bookingId);
+      if (bookingId) return `/dashboard/booking-requests/${bookingId}`;
+      const contractId = asId(data.contractId);
+      if (contractId) return `/dashboard/contract-requests/${contractId}`;
       return "/dashboard/booking-requests";
+    }
     case NotificationType.PAYMENT_RECEIVED: {
+      const bookingId = asId(data.bookingId);
+      if (bookingId) return `/dashboard/bookings/${bookingId}/clearance`;
       const id = asId(data.customerId);
       return id ? `/dashboard/customers/${id}` : "/dashboard/customers";
     }
-    case NotificationType.CLEARANCE_REVIEW:
+    case NotificationType.CLEARANCE_REVIEW: {
+      const bookingId = asId(data.bookingId);
+      if (bookingId) return `/dashboard/bookings/${bookingId}/clearance`;
+      const contractId = asId(data.contractId);
+      if (contractId) return `/dashboard/contracts/clearance/${contractId}`;
       return "/dashboard/arrival-queue";
+    }
+    case NotificationType.CONTRACT_STATUS: {
+      const contractId = asId(data.contractId);
+      return contractId
+        ? `/dashboard/contract-requests/${contractId}`
+        : "/dashboard/contract-requests";
+    }
     default:
       return null;
   }
diff --git a/apps/edr-freight-web/backoffice/src/hooks/contracts/useContracts.ts b/apps/edr-freight-web/backoffice/src/hooks/contracts/useContracts.ts
index 04a4720aa..69e4e1739 100644
--- a/apps/edr-freight-web/backoffice/src/hooks/contracts/useContracts.ts
+++ b/apps/edr-freight-web/backoffice/src/hooks/contracts/useContracts.ts
@@ -181,6 +181,15 @@ export function useContractMutations(contractId: string) {
     onError: () => toast.error("Failed to approve step"),
   });
 
+  // Per-step rejection by an approver (line staff / director / CEO). Terminal:
+  // the contract goes to REJECTED and the customer must create a new one.
+  const rejectStep = useMutation({
+    mutationFn: ({ stepId, reason }: { stepId: string; reason: string }) =>
+      contractsService.rejectStep({ id: contractId, stepId, reason }),
+    onSuccess: (data) => onSuccess(data, "Contract rejected"),
+    onError: () => toast.error("Failed to reject step"),
+  });
+
   // Manual fallback generate — used only if auto-generation failed.
   const generateContract = useMutation({
     mutationFn: () => contractsService.generateContract(contractId),
@@ -210,6 +219,7 @@ export function useContractMutations(contractId: string) {
     requestChanges.isPending ||
     reject.isPending ||
     approveStep.isPending ||
+    rejectStep.isPending ||
     generateContract.isPending ||
     signContract.isPending ||
     createBooking.isPending;
@@ -219,6 +229,7 @@ export function useContractMutations(contractId: string) {
     requestChanges,
     reject,
     approveStep,
+    rejectStep,
     generateContract,
     signContract,
     createBooking,
diff --git a/apps/edr-freight-web/backoffice/src/main.tsx b/apps/edr-freight-web/backoffice/src/main.tsx
index 8c467156e..9cf9f6c35 100644
--- a/apps/edr-freight-web/backoffice/src/main.tsx
+++ b/apps/edr-freight-web/backoffice/src/main.tsx
@@ -60,3 +60,5 @@ createRoot(rootElement).render(
     </MantineProvider>
   </QueryClientProvider>
 );
+
+// run
\ No newline at end of file
diff --git a/apps/edr-freight-web/backoffice/src/pages/contracts/ContractClearanceDetailPage.tsx b/apps/edr-freight-web/backoffice/src/pages/contracts/ContractClearanceDetailPage.tsx
index 2c3e6fa9d..7482ca2fb 100644
--- a/apps/edr-freight-web/backoffice/src/pages/contracts/ContractClearanceDetailPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/contracts/ContractClearanceDetailPage.tsx
@@ -90,11 +90,16 @@ export default function ContractClearanceDetailPage() {
       ].includes(contract.status),
   );
   const linkedBookingId = useMemo(() => {
+    // Prefer the clearance view's server-resolved linkedBookingId (same field the
+    // GL Djibouti page uses). The contract's clearanceCycles[cycle].bookingId can
+    // be null/stale for an export FCFS booking, which would disable
+    // useBookingMilestones → empty milestones → the export "Payment & wagon
+    // allocation" step reads FREIGHT_PAYMENT_SETTLED as not-done and stays stuck.
     const cycle = contract?.clearanceCycles?.find(
       (c) => c.cycleNumber === (contract?.clearanceCycleNumber ?? 1),
     );
-    return cycle?.bookingId ?? undefined;
-  }, [contract]);
+    return clearance?.linkedBookingId ?? cycle?.bookingId ?? undefined;
+  }, [clearance, contract]);
   const bookingAlreadyCreated = Boolean(linkedBookingId) || shipmentLocked;
   const canCreateBooking = ready && !bookingAlreadyCreated;
   const reviewReadOnly = shipmentLocked;
diff --git a/apps/edr-freight-web/backoffice/src/pages/fleet/CompliancePage.tsx b/apps/edr-freight-web/backoffice/src/pages/fleet/CompliancePage.tsx
new file mode 100644
index 000000000..008fee25b
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/pages/fleet/CompliancePage.tsx
@@ -0,0 +1,343 @@
+import { useState } from "react";
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import {
+  Badge,
+  Button,
+  Card,
+  Container,
+  Grid,
+  Group,
+  Loader,
+  Modal,
+  Select,
+  Stack,
+  Table,
+  Text,
+  TextInput,
+  Title,
+} from "@mantine/core";
+import { Plus, AlertTriangle } from "lucide-react";
+import Breadcrumbs from "@/components/ui/Breadcrumbs";
+import { useToast } from "@/hooks/use-toast";
+import {
+  complianceService,
+  type ComplianceAlert,
+  type ComplianceRecord,
+  type ComplianceType,
+} from "@/services/compliance.service";
+import { vehiclesService, type Vehicle as VehicleType } from "@/services/vehicles.service";
+
+const COMPLIANCE_TYPES: ComplianceType[] = [
+  "INSPECTION",
+  "INSURANCE",
+  "ROADWORTHINESS",
+  "PERMIT",
+  "TAX",
+];
+
+const severityColor = (severity: ComplianceAlert["severity"]) =>
+  severity === "OVERDUE" ? "red" : "yellow";
+
+const statusColor = (status: ComplianceRecord["status"]) => {
+  if (status === "EXPIRED") return "red";
+  if (status === "EXPIRING") return "yellow";
+  return "green";
+};
+
+const formatDate = (value?: string | null) =>
+  value ? new Date(value).toLocaleDateString() : "—";
+
+const emptyForm = {
+  vehicleId: "",
+  type: "INSPECTION" as ComplianceType,
+  documentNumber: "",
+  issuedDate: "",
+  expiryDate: new Date().toISOString().split("T")[0],
+  notes: "",
+};
+
+export default function CompliancePage() {
+  const { toast } = useToast();
+  const qc = useQueryClient();
+  const [modalOpen, setModalOpen] = useState(false);
+  const [formData, setFormData] = useState(emptyForm);
+
+  const { data: vehiclesData } = useQuery({
+    queryKey: ["vehicles", "compliance-select"],
+    queryFn: async () => {
+      const res = await vehiclesService.getAll({ limit: 1000 });
+      return res.data || [];
+    },
+  });
+
+  const { data: alerts = [], isLoading: isLoadingAlerts } = useQuery({
+    queryKey: ["compliance", "alerts"],
+    queryFn: async () => {
+      const res = await complianceService.getAlerts();
+      return res.data || [];
+    },
+  });
+
+  const { data: records = [], isLoading: isLoadingRecords } = useQuery({
+    queryKey: ["compliance"],
+    queryFn: async () => {
+      const res = await complianceService.list();
+      return res.data || [];
+    },
+  });
+
+  const createMutation = useMutation({
+    mutationFn: async (data: typeof formData) => {
+      const res = await complianceService.create({
+        vehicleId: data.vehicleId,
+        type: data.type,
+        expiryDate: data.expiryDate,
+        documentNumber: data.documentNumber || undefined,
+        issuedDate: data.issuedDate || undefined,
+        notes: data.notes || undefined,
+      });
+      return res.data;
+    },
+    onSuccess: () => {
+      toast({ title: "Compliance record created" });
+      setModalOpen(false);
+      setFormData(emptyForm);
+      qc.invalidateQueries({ queryKey: ["compliance"] });
+      qc.invalidateQueries({ queryKey: ["compliance", "alerts"] });
+    },
+    onError: (error: any) => {
+      toast({
+        title: "Error creating record",
+        description:
+          error?.response?.data?.message || "Failed to create compliance record",
+        variant: "destructive",
+      });
+    },
+  });
+
+  const vehicleOptions =
+    vehiclesData?.map((v: VehicleType) => ({
+      value: v.id,
+      label: `${v.plateNumber ?? v.code ?? v.id} - ${v.manufacturer ?? ""} ${v.model ?? ""}`.trim(),
+    })) || [];
+
+  const vehicleLabel = (record: ComplianceRecord) =>
+    record.vehicle?.plateNumber ||
+    vehiclesData?.find((v) => v.id === record.vehicleId)?.plateNumber ||
+    record.vehicleId;
+
+  const overdueCount = (alerts as ComplianceAlert[]).filter(
+    (a) => a.severity === "OVERDUE",
+  ).length;
+  const dueSoonCount = (alerts as ComplianceAlert[]).filter(
+    (a) => a.severity === "DUE_SOON",
+  ).length;
+
+  return (
+    <Container size="xl" py="xl" px="lg">
+      <Breadcrumbs items={[{ label: "Fleet" }, { label: "Compliance" }]} />
+
+      <Group justify="space-between" mb="lg">
+        <Title order={1}>Compliance & Alerts</Title>
+        <Button
+          leftSection={<Plus size={16} />}
+          onClick={() => setModalOpen(true)}
+          color="edr-green"
+        >
+          New Record
+        </Button>
+      </Group>
+
+      {/* Alerts */}
+      <Group mb="sm" gap="xs">
+        <AlertTriangle size={18} />
+        <Title order={3}>Expiry Alerts</Title>
+        {overdueCount > 0 && (
+          <Badge color="red" variant="light">
+            {overdueCount} overdue
+          </Badge>
+        )}
+        {dueSoonCount > 0 && (
+          <Badge color="yellow" variant="light">
+            {dueSoonCount} due soon
+          </Badge>
+        )}
+      </Group>
+
+      {isLoadingAlerts ? (
+        <Group justify="center" py="md" mb="lg">
+          <Loader size="sm" />
+        </Group>
+      ) : (alerts as ComplianceAlert[]).length === 0 ? (
+        <Card withBorder padding="lg" mb="lg">
+          <Text c="dimmed" ta="center">
+            No compliance items are overdue or due soon. All clear.
+          </Text>
+        </Card>
+      ) : (
+        <Grid mb="lg">
+          {(alerts as ComplianceAlert[]).map((alert, index) => (
+            <Grid.Col
+              key={`${alert.vehicleId}-${alert.kind}-${index}`}
+              span={{ base: 12, sm: 6, md: 4 }}
+            >
+              <Card withBorder padding="md" h="100%">
+                <Group justify="space-between" mb="xs">
+                  <Badge color={severityColor(alert.severity)}>
+                    {alert.severity === "OVERDUE" ? "Overdue" : "Due Soon"}
+                  </Badge>
+                  <Text size="sm" c="dimmed">
+                    {alert.daysUntil < 0
+                      ? `${Math.abs(alert.daysUntil)}d ago`
+                      : `in ${alert.daysUntil}d`}
+                  </Text>
+                </Group>
+                <Text fw={600}>{alert.label}</Text>
+                <Text size="sm" c="dimmed">
+                  {alert.vehiclePlate || alert.vehicleId}
+                </Text>
+                <Text size="sm" mt="xs">
+                  Expires {formatDate(alert.expiryDate)}
+                </Text>
+              </Card>
+            </Grid.Col>
+          ))}
+        </Grid>
+      )}
+
+      {/* Records */}
+      <Title order={3} mb="sm">
+        Compliance Records
+      </Title>
+      <Card withBorder>
+        <Table striped highlightOnHover>
+          <Table.Thead>
+            <Table.Tr>
+              <Table.Th>Vehicle</Table.Th>
+              <Table.Th>Type</Table.Th>
+              <Table.Th>Document #</Table.Th>
+              <Table.Th>Issued</Table.Th>
+              <Table.Th>Expiry</Table.Th>
+              <Table.Th>Status</Table.Th>
+            </Table.Tr>
+          </Table.Thead>
+          <Table.Tbody>
+            {isLoadingRecords ? (
+              <Table.Tr>
+                <Table.Td colSpan={6}>
+                  <Group justify="center" py="md">
+                    <Loader size="sm" />
+                  </Group>
+                </Table.Td>
+              </Table.Tr>
+            ) : (records as ComplianceRecord[]).length === 0 ? (
+              <Table.Tr>
+                <Table.Td colSpan={6}>
+                  <Text c="dimmed" ta="center" py="md">
+                    No compliance records yet.
+                  </Text>
+                </Table.Td>
+              </Table.Tr>
+            ) : null}
+            {(records as ComplianceRecord[]).map((record) => (
+              <Table.Tr key={record.id}>
+                <Table.Td>{vehicleLabel(record)}</Table.Td>
+                <Table.Td>
+                  <Badge variant="light" size="sm">
+                    {record.type}
+                  </Badge>
+                </Table.Td>
+                <Table.Td>{record.documentNumber || "—"}</Table.Td>
+                <Table.Td>{formatDate(record.issuedDate)}</Table.Td>
+                <Table.Td>{formatDate(record.expiryDate)}</Table.Td>
+                <Table.Td>
+                  <Badge color={statusColor(record.status)} size="sm">
+                    {record.status}
+                  </Badge>
+                </Table.Td>
+              </Table.Tr>
+            ))}
+          </Table.Tbody>
+        </Table>
+      </Card>
+
+      {/* Modal */}
+      <Modal
+        opened={modalOpen}
+        onClose={() => setModalOpen(false)}
+        title="New Compliance Record"
+        size="lg"
+      >
+        <Stack gap="md">
+          <Select
+            label="Vehicle"
+            placeholder="Select vehicle"
+            data={vehicleOptions}
+            value={formData.vehicleId}
+            onChange={(val) => setFormData({ ...formData, vehicleId: val || "" })}
+            searchable
+            required
+          />
+
+          <Select
+            label="Type"
+            data={COMPLIANCE_TYPES.map((t) => ({ value: t, label: t }))}
+            value={formData.type}
+            onChange={(val) =>
+              setFormData({ ...formData, type: (val as ComplianceType) || "INSPECTION" })
+            }
+            required
+          />
+
+          <TextInput
+            label="Document Number"
+            placeholder="Optional"
+            value={formData.documentNumber}
+            onChange={(e) =>
+              setFormData({ ...formData, documentNumber: e.currentTarget.value })
+            }
+          />
+
+          <TextInput
+            label="Issued Date"
+            type="date"
+            value={formData.issuedDate}
+            onChange={(e) =>
+              setFormData({ ...formData, issuedDate: e.currentTarget.value })
+            }
+          />
+
+          <TextInput
+            label="Expiry Date"
+            type="date"
+            value={formData.expiryDate}
+            onChange={(e) =>
+              setFormData({ ...formData, expiryDate: e.currentTarget.value })
+            }
+            required
+          />
+
+          <TextInput
+            label="Notes"
+            placeholder="Optional notes"
+            value={formData.notes}
+            onChange={(e) => setFormData({ ...formData, notes: e.currentTarget.value })}
+          />
+
+          <Group justify="flex-end">
+            <Button variant="light" onClick={() => setModalOpen(false)}>
+              Cancel
+            </Button>
+            <Button
+              onClick={() => createMutation.mutate(formData)}
+              loading={createMutation.isPending}
+              disabled={!formData.vehicleId || !formData.expiryDate}
+            >
+              Create Record
+            </Button>
+          </Group>
+        </Stack>
+      </Modal>
+    </Container>
+  );
+}
diff --git a/apps/edr-freight-web/backoffice/src/pages/fleet/DriverDetailPage.tsx b/apps/edr-freight-web/backoffice/src/pages/fleet/DriverDetailPage.tsx
index d5e8655be..c97d7c418 100644
--- a/apps/edr-freight-web/backoffice/src/pages/fleet/DriverDetailPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/fleet/DriverDetailPage.tsx
@@ -1,9 +1,10 @@
-import { useMemo } from "react";
+import { useMemo, useState } from "react";
 import { useParams, useNavigate } from "react-router-dom";
-import { useQuery } from "@tanstack/react-query";
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
 import {
   ActionIcon,
   Badge,
+  Button,
   Card,
   Center,
   Container,
@@ -17,11 +18,18 @@ import {
   Timeline,
   Title,
 } from "@mantine/core";
+import { SmartFileInput } from "@edr/ui-common";
+import type { IFileUploadSetting } from "@edr/types/freight";
 import {
   ArrowLeft,
+  Download,
+  Eye,
+  FileText,
   History,
   Route,
   ShieldCheck,
+  Trash2,
+  Upload,
   Truck,
   User,
 } from "lucide-react";
@@ -29,6 +37,8 @@ import {
 import { driversService } from "@/services/drivers.service";
 import { vehiclesService } from "@/services/vehicles.service";
 import { fleetHistoryService, type FleetHistoryEvent } from "@/services/fleet-history.service";
+import { fileUploadSettingsService } from "@/services/fileUploadSettings.service";
+import { useToast } from "@/hooks/use-toast";
 
 const fmtDate = (iso?: string | null) => {
   if (!iso) return "—";
@@ -55,6 +65,178 @@ const Loading = () => (
   <Center py="xl"><Loader size="sm" /></Center>
 );
 
+const fmtSize = (bytes: number) => {
+  if (!bytes) return "—";
+  const kb = bytes / 1024;
+  return kb < 1024 ? `${kb.toFixed(0)} KB` : `${(kb / 1024).toFixed(1)} MB`;
+};
+
+/** Upload-area setting code configured on the File Settings page. */
+const DRIVER_DOCS_CODE = "driver_docs";
+// Field key the FALLBACK setting is keyed on (used only when the "driver_docs"
+// upload area hasn't been configured in File Settings yet).
+const DRIVER_DOCS_KEY = "driver_docs";
+/** Fallback single-field setting so the dropzone still works before an admin
+ *  configures the "driver_docs" area in File Settings. */
+const DRIVER_DOCS_FALLBACK: IFileUploadSetting = {
+  id: "driver-docs-setting",
+  createdAt: "",
+  updatedAt: "",
+  deletedAt: null,
+  code: "driver_docs",
+  label: "Driver documents",
+  description: null,
+  entity: "other",
+  fields: [
+    {
+      id: "driver-docs-field",
+      createdAt: "",
+      updatedAt: "",
+      deletedAt: null,
+      settingId: "driver-docs-setting",
+      fileKey: DRIVER_DOCS_KEY,
+      fileLabel: "Upload driver document(s)",
+      helpText: "License, national ID, contracts, training certificates, etc.",
+      isRequired: false,
+      isMultiple: true,
+      maxFiles: 20,
+      allowedExtensions: ["pdf", "png", "jpg", "jpeg", "doc", "docx"],
+      maxSizeMb: 10,
+      order: 1,
+    },
+  ],
+};
+
+/** Driver documents upload + view area (files stored under code "driver_docs"). */
+const DriverDocuments = ({ driverId }: { driverId: string }) => {
+  const { toast } = useToast();
+  const qc = useQueryClient();
+  // Files selected per configured field key (SmartFileInput is multi-field).
+  const [selectedMap, setSelectedMap] = useState<Record<string, File | File[] | null>>({});
+  const selectedFiles = Object.values(selectedMap).flatMap((v) =>
+    Array.isArray(v) ? v : v ? [v] : [],
+  );
+
+  // Upload-area configuration from the File Settings page (code "driver_docs").
+  // Falls back to a default field until an admin configures it there.
+  const { data: setting } = useQuery({
+    queryKey: ["file-upload-setting", DRIVER_DOCS_CODE],
+    queryFn: () => fileUploadSettingsService.getByCode(DRIVER_DOCS_CODE),
+    retry: false,
+  });
+  const activeSetting = setting ?? DRIVER_DOCS_FALLBACK;
+
+  const { data: docs = [], isLoading } = useQuery({
+    queryKey: ["driver", driverId, "documents"],
+    queryFn: () => driversService.listDocuments(driverId).then((r) => r.data ?? []),
+    enabled: Boolean(driverId),
+  });
+
+  const uploadMutation = useMutation({
+    mutationFn: (files: File[]) => driversService.uploadDocuments(driverId, files),
+    onSuccess: () => {
+      toast({ title: "Documents uploaded" });
+      void qc.invalidateQueries({ queryKey: ["driver", driverId, "documents"] });
+    },
+    onError: (err: unknown) => {
+      const description =
+        (err as { response?: { data?: { message?: string } } })?.response?.data?.message ??
+        "Upload failed";
+      toast({ title: "Upload failed", description, variant: "destructive" });
+    },
+  });
+
+  const removeMutation = useMutation({
+    mutationFn: (fileId: string) => driversService.removeDocument(driverId, fileId),
+    onSuccess: () => {
+      toast({ title: "Document deleted" });
+      void qc.invalidateQueries({ queryKey: ["driver", driverId, "documents"] });
+    },
+    onError: () => toast({ title: "Delete failed", variant: "destructive" }),
+  });
+
+  // /files/:id is a public inline-serving route; open directly for preview/download.
+  const fileUrl = (fileId: string, download = false) =>
+    `${import.meta.env.VITE_API_URL}/files/${fileId}${download ? "?download=1" : ""}`;
+
+  return (
+    <Card withBorder padding="lg" radius="md">
+      <Stack gap="md" mb="lg">
+        <Text fw={600} size="sm">{activeSetting.label ?? "Upload documents"}</Text>
+        <SmartFileInput
+          file={activeSetting}
+          value={selectedMap}
+          onChange={setSelectedMap}
+        />
+        <Group justify="flex-end">
+          <Button
+            size="xs"
+            leftSection={<Upload size={14} />}
+            loading={uploadMutation.isPending}
+            disabled={selectedFiles.length === 0}
+            onClick={() =>
+              uploadMutation.mutate(selectedFiles, { onSuccess: () => setSelectedMap({}) })
+            }
+          >
+            Upload {selectedFiles.length > 0 ? `(${selectedFiles.length})` : ""}
+          </Button>
+        </Group>
+      </Stack>
+
+      <Text fw={600} size="sm" mb="sm">Uploaded documents ({docs.length})</Text>
+      {isLoading ? (
+        <Loading />
+      ) : docs.length === 0 ? (
+        <Text c="dimmed" size="sm" ta="center" py="md">No documents uploaded yet.</Text>
+      ) : (
+        <Table highlightOnHover>
+          <Table.Thead>
+            <Table.Tr>
+              <Table.Th>Name</Table.Th>
+              <Table.Th>Size</Table.Th>
+              <Table.Th>Uploaded</Table.Th>
+              <Table.Th ta="right">Actions</Table.Th>
+            </Table.Tr>
+          </Table.Thead>
+          <Table.Tbody>
+            {docs.map((doc) => (
+              <Table.Tr key={doc.id}>
+                <Table.Td>
+                  <Group gap="xs" wrap="nowrap">
+                    <FileText size={15} />
+                    <Text size="sm" truncate>{doc.name}</Text>
+                  </Group>
+                </Table.Td>
+                <Table.Td>{fmtSize(doc.size)}</Table.Td>
+                <Table.Td>{fmtDate(doc.createdAt)}</Table.Td>
+                <Table.Td>
+                  <Group gap={4} justify="flex-end" wrap="nowrap">
+                    <ActionIcon variant="subtle" aria-label="View" onClick={() => window.open(fileUrl(doc.id), "_blank")}>
+                      <Eye size={16} />
+                    </ActionIcon>
+                    <ActionIcon variant="subtle" aria-label="Download" onClick={() => window.open(fileUrl(doc.id, true), "_blank")}>
+                      <Download size={16} />
+                    </ActionIcon>
+                    <ActionIcon
+                      variant="subtle"
+                      color="red"
+                      aria-label="Delete"
+                      loading={removeMutation.isPending && removeMutation.variables === doc.id}
+                      onClick={() => removeMutation.mutate(doc.id)}
+                    >
+                      <Trash2 size={16} />
+                    </ActionIcon>
+                  </Group>
+                </Table.Td>
+              </Table.Tr>
+            ))}
+          </Table.Tbody>
+        </Table>
+      )}
+    </Card>
+  );
+};
+
 const DriverDetailPage = () => {
   const { id = "" } = useParams<{ id: string }>();
   const navigate = useNavigate();
@@ -106,6 +288,7 @@ const DriverDetailPage = () => {
             <Tabs.Tab value="vehicles" leftSection={<Truck size={14} />}>Vehicles</Tabs.Tab>
             <Tabs.Tab value="history" leftSection={<History size={14} />}>History</Tabs.Tab>
             <Tabs.Tab value="trips" leftSection={<Route size={14} />}>Trips</Tabs.Tab>
+            <Tabs.Tab value="documents" leftSection={<FileText size={14} />}>Documents</Tabs.Tab>
           </Tabs.List>
 
           <Tabs.Panel value="overview" pt="lg">
@@ -149,6 +332,10 @@ const DriverDetailPage = () => {
           <Tabs.Panel value="trips" pt="lg">
             <TripsTab driverId={id} />
           </Tabs.Panel>
+
+          <Tabs.Panel value="documents" pt="lg">
+            <DriverDocuments driverId={id} />
+          </Tabs.Panel>
         </Tabs>
       )}
     </Container>
diff --git a/apps/edr-freight-web/backoffice/src/pages/fleet/FleetResourcePage.tsx b/apps/edr-freight-web/backoffice/src/pages/fleet/FleetResourcePage.tsx
index f7bee5b41..12dd90b4c 100644
--- a/apps/edr-freight-web/backoffice/src/pages/fleet/FleetResourcePage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/fleet/FleetResourcePage.tsx
@@ -393,7 +393,7 @@ const FleetResourcePage = () => {
                       <Group key={filter.key} gap={4} wrap="wrap">
                         <Text size="xs" fw={500} c="dimmed">{filter.label}:</Text>
                         <Group gap={4} wrap="wrap">
-                          {[{ value: "ALL", label: "All" }, ...filter.data].map((option) => (
+                          {filter.data.map((option) => (
                             <Button
                               key={option.value}
                               size="xs"
diff --git a/apps/edr-freight-web/backoffice/src/pages/fleet/IncidentsPage.tsx b/apps/edr-freight-web/backoffice/src/pages/fleet/IncidentsPage.tsx
new file mode 100644
index 000000000..2d947b73a
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/pages/fleet/IncidentsPage.tsx
@@ -0,0 +1,399 @@
+import { useState } from "react";
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import {
+  Button,
+  Card,
+  Container,
+  Group,
+  Loader,
+  Modal,
+  NumberInput,
+  Select,
+  Stack,
+  Table,
+  Text,
+  Textarea,
+  TextInput,
+  Title,
+  Badge,
+  Grid,
+} from "@mantine/core";
+import { Plus } from "lucide-react";
+import Breadcrumbs from "@/components/ui/Breadcrumbs";
+import { useToast } from "@/hooks/use-toast";
+import {
+  incidentsService,
+  type Incident,
+  type IncidentSeverity,
+  type IncidentStatus,
+  type IncidentType,
+  type SaveIncidentPayload,
+} from "@/services/incidents.service";
+import { vehiclesService, type Vehicle as VehicleType } from "@/services/vehicles.service";
+import { driversService, type Driver as DriverType } from "@/services/drivers.service";
+
+const TYPE_OPTIONS: IncidentType[] = [
+  "ACCIDENT",
+  "BREAKDOWN",
+  "TRAFFIC_VIOLATION",
+  "THEFT",
+  "OTHER",
+];
+const SEVERITY_OPTIONS: IncidentSeverity[] = ["MINOR", "MODERATE", "MAJOR", "CRITICAL"];
+
+const TYPE_COLORS: Record<IncidentType, string> = {
+  ACCIDENT: "red",
+  BREAKDOWN: "orange",
+  TRAFFIC_VIOLATION: "yellow",
+  THEFT: "grape",
+  OTHER: "gray",
+};
+
+const SEVERITY_COLORS: Record<IncidentSeverity, string> = {
+  MINOR: "gray",
+  MODERATE: "yellow",
+  MAJOR: "orange",
+  CRITICAL: "red",
+};
+
+const STATUS_COLORS: Record<IncidentStatus, string> = {
+  REPORTED: "blue",
+  UNDER_REVIEW: "yellow",
+  CLAIM_FILED: "grape",
+  RESOLVED: "teal",
+  CLOSED: "gray",
+};
+
+const OPEN_STATUSES: IncidentStatus[] = ["REPORTED", "UNDER_REVIEW", "CLAIM_FILED"];
+
+const formatMoney = (value: unknown) =>
+  `ETB ${(Number(value) || 0).toLocaleString("en-US", {
+    minimumFractionDigits: 2,
+    maximumFractionDigits: 2,
+  })}`;
+
+const initialForm = {
+  type: "ACCIDENT" as IncidentType,
+  severity: "MINOR" as IncidentSeverity,
+  occurredAt: new Date().toISOString().split("T")[0],
+  vehicleId: "",
+  driverId: "",
+  location: "",
+  description: "",
+  damageEstimate: undefined as number | undefined,
+  reportedBy: "",
+};
+
+export default function IncidentsPage() {
+  const { toast } = useToast();
+  const qc = useQueryClient();
+  const [modalOpen, setModalOpen] = useState(false);
+  const [formData, setFormData] = useState(initialForm);
+
+  // Fetch vehicles
+  const { data: vehiclesData } = useQuery({
+    queryKey: ["vehicles", "incidents-select"],
+    queryFn: async () => {
+      const res = await vehiclesService.getAll({ limit: 1000 });
+      return res.data || [];
+    },
+  });
+
+  // Fetch drivers
+  const { data: driversData } = useQuery({
+    queryKey: ["drivers", "incidents-select"],
+    queryFn: async () => {
+      const res = await driversService.getAll({ limit: 1000 });
+      return res.data || [];
+    },
+  });
+
+  // Fetch incidents
+  const { data: incidentsData = [], isLoading } = useQuery({
+    queryKey: ["incidents"],
+    queryFn: async () => {
+      const res = await incidentsService.getAll();
+      return res.data || [];
+    },
+  });
+
+  const createMutation = useMutation({
+    mutationFn: async (data: typeof formData) => {
+      const payload: SaveIncidentPayload = {
+        type: data.type,
+        severity: data.severity,
+        occurredAt: new Date(data.occurredAt).toISOString(),
+        description: data.description,
+      };
+      if (data.vehicleId) payload.vehicleId = data.vehicleId;
+      if (data.driverId) payload.driverId = data.driverId;
+      if (data.location) payload.location = data.location;
+      if (data.damageEstimate != null) payload.damageEstimate = Number(data.damageEstimate);
+      if (data.reportedBy) payload.reportedBy = data.reportedBy;
+      const res = await incidentsService.create(payload);
+      return res.data;
+    },
+    onSuccess: () => {
+      toast({ title: "Incident reported" });
+      setModalOpen(false);
+      setFormData(initialForm);
+      qc.invalidateQueries({ queryKey: ["incidents"] });
+    },
+    onError: (error: any) => {
+      toast({
+        title: "Error reporting incident",
+        description: error?.response?.data?.message || "Failed to report incident",
+        variant: "destructive",
+      });
+    },
+  });
+
+  const vehicleOptions =
+    vehiclesData?.map((v: VehicleType) => ({
+      value: v.id,
+      label: `${v.plateNumber} - ${v.manufacturer} ${v.model}`,
+    })) || [];
+
+  const driverOptions =
+    driversData?.map((d: DriverType) => ({
+      value: d.id,
+      label: `${d.firstName} ${d.lastName}${d.licenseNumber ? ` (${d.licenseNumber})` : ""}`,
+    })) || [];
+
+  const incidents = incidentsData as Incident[];
+  const totalCount = incidents.length;
+  const openCount = incidents.filter((i) => OPEN_STATUSES.includes(i.status)).length;
+  const underReviewCount = incidents.filter((i) => i.status === "UNDER_REVIEW").length;
+  const resolvedCount = incidents.filter((i) => i.status === "RESOLVED").length;
+
+  const vehicleLabel = (incident: Incident) =>
+    incident.vehicle?.plateNumber ||
+    incident.vehicle?.registrationNumber ||
+    incident.vehicleId ||
+    "—";
+
+  const driverLabel = (incident: Incident) => {
+    if (incident.driver) {
+      const name = `${incident.driver.firstName ?? ""} ${incident.driver.lastName ?? ""}`.trim();
+      if (name) return name;
+    }
+    return incident.driverId || "—";
+  };
+
+  return (
+    <Container size="xl" py="xl" px="lg">
+      <Breadcrumbs items={[{ label: "Fleet" }, { label: "Incidents" }]} />
+
+      <Group justify="space-between" mb="lg">
+        <Title order={1}>Accidents &amp; Incidents</Title>
+        <Button leftSection={<Plus size={16} />} onClick={() => setModalOpen(true)} color="edr-green">
+          Report Incident
+        </Button>
+      </Group>
+
+      {/* Stats Cards */}
+      <Grid mb="lg">
+        <Grid.Col span={{ base: 12, sm: 6, md: 3 }}>
+          <Card withBorder padding="lg">
+            <Text size="sm" c="dimmed" fw={500}>
+              Total Incidents
+            </Text>
+            <Text fw={700} size="lg">
+              {totalCount}
+            </Text>
+          </Card>
+        </Grid.Col>
+        <Grid.Col span={{ base: 12, sm: 6, md: 3 }}>
+          <Card withBorder padding="lg">
+            <Text size="sm" c="dimmed" fw={500}>
+              Open
+            </Text>
+            <Text fw={700} size="lg">
+              {openCount}
+            </Text>
+          </Card>
+        </Grid.Col>
+        <Grid.Col span={{ base: 12, sm: 6, md: 3 }}>
+          <Card withBorder padding="lg">
+            <Text size="sm" c="dimmed" fw={500}>
+              Under Review
+            </Text>
+            <Text fw={700} size="lg">
+              {underReviewCount}
+            </Text>
+          </Card>
+        </Grid.Col>
+        <Grid.Col span={{ base: 12, sm: 6, md: 3 }}>
+          <Card withBorder padding="lg">
+            <Text size="sm" c="dimmed" fw={500}>
+              Resolved
+            </Text>
+            <Text fw={700} size="lg">
+              {resolvedCount}
+            </Text>
+          </Card>
+        </Grid.Col>
+      </Grid>
+
+      {/* Incidents Table */}
+      <Card withBorder>
+        <Table striped highlightOnHover>
+          <Table.Thead>
+            <Table.Tr>
+              <Table.Th>Date</Table.Th>
+              <Table.Th>Type</Table.Th>
+              <Table.Th>Severity</Table.Th>
+              <Table.Th>Vehicle</Table.Th>
+              <Table.Th>Driver</Table.Th>
+              <Table.Th align="right">Damage</Table.Th>
+              <Table.Th>Status</Table.Th>
+            </Table.Tr>
+          </Table.Thead>
+          <Table.Tbody>
+            {isLoading ? (
+              <Table.Tr>
+                <Table.Td colSpan={7}>
+                  <Group justify="center" py="md">
+                    <Loader size="sm" />
+                  </Group>
+                </Table.Td>
+              </Table.Tr>
+            ) : incidents.length === 0 ? (
+              <Table.Tr>
+                <Table.Td colSpan={7}>
+                  <Text c="dimmed" ta="center" py="md">
+                    No incidents recorded yet.
+                  </Text>
+                </Table.Td>
+              </Table.Tr>
+            ) : null}
+            {incidents.map((incident) => (
+              <Table.Tr key={incident.id}>
+                <Table.Td>{new Date(incident.occurredAt).toLocaleDateString()}</Table.Td>
+                <Table.Td>
+                  <Badge size="sm" color={TYPE_COLORS[incident.type]}>
+                    {incident.type.replace(/_/g, " ")}
+                  </Badge>
+                </Table.Td>
+                <Table.Td>
+                  <Badge size="sm" color={SEVERITY_COLORS[incident.severity]}>
+                    {incident.severity}
+                  </Badge>
+                </Table.Td>
+                <Table.Td>{vehicleLabel(incident)}</Table.Td>
+                <Table.Td>{driverLabel(incident)}</Table.Td>
+                <Table.Td align="right">
+                  {incident.damageEstimate != null ? formatMoney(incident.damageEstimate) : "—"}
+                </Table.Td>
+                <Table.Td>
+                  <Badge size="sm" color={STATUS_COLORS[incident.status]} variant="light">
+                    {incident.status.replace(/_/g, " ")}
+                  </Badge>
+                </Table.Td>
+              </Table.Tr>
+            ))}
+          </Table.Tbody>
+        </Table>
+      </Card>
+
+      {/* Modal */}
+      <Modal opened={modalOpen} onClose={() => setModalOpen(false)} title="Report Incident" size="lg">
+        <Stack gap="md">
+          <Select
+            label="Type"
+            data={TYPE_OPTIONS.map((t) => ({ value: t, label: t.replace(/_/g, " ") }))}
+            value={formData.type}
+            onChange={(val) => setFormData({ ...formData, type: (val as IncidentType) || "ACCIDENT" })}
+            required
+          />
+
+          <Select
+            label="Severity"
+            data={SEVERITY_OPTIONS.map((s) => ({ value: s, label: s }))}
+            value={formData.severity}
+            onChange={(val) =>
+              setFormData({ ...formData, severity: (val as IncidentSeverity) || "MINOR" })
+            }
+            required
+          />
+
+          <TextInput
+            label="Occurred At"
+            type="date"
+            value={formData.occurredAt}
+            onChange={(e) => setFormData({ ...formData, occurredAt: e.currentTarget.value })}
+            required
+          />
+
+          <Select
+            label="Vehicle"
+            placeholder="Select vehicle"
+            data={vehicleOptions}
+            value={formData.vehicleId || null}
+            onChange={(val) => setFormData({ ...formData, vehicleId: val || "" })}
+            clearable
+            searchable
+          />
+
+          <Select
+            label="Driver"
+            placeholder="Select driver"
+            data={driverOptions}
+            value={formData.driverId || null}
+            onChange={(val) => setFormData({ ...formData, driverId: val || "" })}
+            clearable
+            searchable
+          />
+
+          <Textarea
+            label="Description"
+            placeholder="What happened?"
+            value={formData.description}
+            onChange={(e) => setFormData({ ...formData, description: e.currentTarget.value })}
+            minRows={3}
+            required
+          />
+
+          <NumberInput
+            label="Damage Estimate (ETB)"
+            placeholder="0.00"
+            value={formData.damageEstimate}
+            onChange={(val) =>
+              setFormData({ ...formData, damageEstimate: val as number | undefined })
+            }
+            decimalScale={2}
+            min={0}
+            thousandSeparator=","
+          />
+
+          <TextInput
+            label="Location"
+            placeholder="Where did it happen?"
+            value={formData.location}
+            onChange={(e) => setFormData({ ...formData, location: e.currentTarget.value })}
+          />
+
+          <TextInput
+            label="Reported By"
+            placeholder="Optional"
+            value={formData.reportedBy}
+            onChange={(e) => setFormData({ ...formData, reportedBy: e.currentTarget.value })}
+          />
+
+          <Group justify="flex-end">
+            <Button variant="light" onClick={() => setModalOpen(false)}>
+              Cancel
+            </Button>
+            <Button
+              onClick={() => createMutation.mutate(formData)}
+              loading={createMutation.isPending}
+              disabled={!formData.description.trim()}
+            >
+              Report Incident
+            </Button>
+          </Group>
+        </Stack>
+      </Modal>
+    </Container>
+  );
+}
diff --git a/apps/edr-freight-web/backoffice/src/pages/fleet/ProcurementPage.tsx b/apps/edr-freight-web/backoffice/src/pages/fleet/ProcurementPage.tsx
new file mode 100644
index 000000000..0c6bbabf0
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/pages/fleet/ProcurementPage.tsx
@@ -0,0 +1,665 @@
+import { useState } from "react";
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import {
+  Badge,
+  Button,
+  Card,
+  Container,
+  Group,
+  Loader,
+  Modal,
+  NumberInput,
+  Select,
+  Stack,
+  Switch,
+  Table,
+  Tabs,
+  Text,
+  TextInput,
+  Title,
+} from "@mantine/core";
+import { Plus } from "lucide-react";
+import Breadcrumbs from "@/components/ui/Breadcrumbs";
+import { useToast } from "@/hooks/use-toast";
+import { vehiclesService, type Vehicle } from "@/services/vehicles.service";
+import {
+  procurementService,
+  type AssetAcquisition,
+  type AssetDisposal,
+  type Vendor,
+  type AcquisitionType,
+  type AcquisitionStatus,
+  type VendorType,
+  type DisposalMethod,
+} from "@/services/procurement.service";
+
+const money = (x: number | null | undefined) =>
+  `ETB ${(Number(x) || 0).toLocaleString("en-US", {
+    minimumFractionDigits: 2,
+    maximumFractionDigits: 2,
+  })}`;
+
+const ACQUISITION_TYPES: AcquisitionType[] = ["PURCHASE", "LEASE", "RENTAL"];
+const ACQUISITION_STATUSES: AcquisitionStatus[] = ["ACTIVE", "LEASE_EXPIRING", "DISPOSED"];
+const VENDOR_TYPES: VendorType[] = ["DEALER", "LEASING", "PARTS", "SERVICE", "OTHER"];
+const DISPOSAL_METHODS: DisposalMethod[] = ["SALE", "SCRAP", "RETURN_LEASE", "TRADE_IN"];
+
+const typeBadgeColor = (t: AcquisitionType) =>
+  t === "PURCHASE" ? "green" : t === "LEASE" ? "blue" : "grape";
+const statusBadgeColor = (s: AcquisitionStatus) =>
+  s === "ACTIVE" ? "green" : s === "LEASE_EXPIRING" ? "yellow" : "gray";
+
+const vehicleLabel = (
+  v?: { plateNumber?: string | null; registrationNumber?: string | null } | null,
+  fallback?: string | null,
+) => v?.plateNumber || v?.registrationNumber || fallback || "—";
+
+// Strip empty strings / null / undefined before sending to the API (ValidationPipe rejects "" for UUID fields).
+const clean = <T extends Record<string, unknown>>(obj: T): Partial<T> =>
+  Object.fromEntries(
+    Object.entries(obj).filter(([, v]) => v !== "" && v !== undefined && v !== null),
+  ) as Partial<T>;
+
+const emptyAcquisition = {
+  vehicleId: "",
+  vendorId: "",
+  acquisitionType: "PURCHASE" as AcquisitionType,
+  acquisitionDate: new Date().toISOString().split("T")[0],
+  cost: undefined as number | undefined,
+  usefulLifeMonths: undefined as number | undefined,
+  salvageValue: undefined as number | undefined,
+  leaseStart: "",
+  leaseEnd: "",
+  monthlyPayment: undefined as number | undefined,
+  status: "ACTIVE" as AcquisitionStatus,
+  notes: "",
+};
+
+const emptyVendor = {
+  name: "",
+  type: "" as VendorType | "",
+  contactPerson: "",
+  phone: "",
+  email: "",
+  address: "",
+  isActive: true,
+};
+
+const emptyDisposal = {
+  vehicleId: "",
+  disposalDate: new Date().toISOString().split("T")[0],
+  method: "SALE" as DisposalMethod,
+  salePrice: undefined as number | undefined,
+  buyer: "",
+  notes: "",
+};
+
+export default function ProcurementPage() {
+  const { toast } = useToast();
+  const qc = useQueryClient();
+
+  const [tab, setTab] = useState<string>("acquisitions");
+  const [acqModalOpen, setAcqModalOpen] = useState(false);
+  const [vendorModalOpen, setVendorModalOpen] = useState(false);
+  const [disposalModalOpen, setDisposalModalOpen] = useState(false);
+
+  const [acqForm, setAcqForm] = useState({ ...emptyAcquisition });
+  const [vendorForm, setVendorForm] = useState({ ...emptyVendor });
+  const [disposalForm, setDisposalForm] = useState({ ...emptyDisposal });
+
+  // ---- Queries ----
+  const { data: vehiclesData } = useQuery({
+    queryKey: ["vehicles", "list"],
+    queryFn: async () => {
+      const res = await vehiclesService.getAll({ limit: 1000 });
+      return res.data || [];
+    },
+  });
+
+  const { data: acquisitions = [], isLoading: loadingAcquisitions } = useQuery({
+    queryKey: ["procurement", "acquisitions"],
+    queryFn: async () => {
+      const res = await procurementService.listAcquisitions();
+      return res.data || [];
+    },
+  });
+
+  const { data: vendors = [], isLoading: loadingVendors } = useQuery({
+    queryKey: ["procurement", "vendors"],
+    queryFn: async () => {
+      const res = await procurementService.listVendors();
+      return res.data || [];
+    },
+  });
+
+  const { data: disposals = [], isLoading: loadingDisposals } = useQuery({
+    queryKey: ["procurement", "disposals"],
+    queryFn: async () => {
+      const res = await procurementService.listDisposals();
+      return res.data || [];
+    },
+  });
+
+  const vehicleOptions =
+    vehiclesData?.map((v: Vehicle) => ({
+      value: v.id,
+      label: `${v.plateNumber} - ${v.manufacturer} ${v.model}`,
+    })) || [];
+
+  const vendorOptions = vendors.map((v: Vendor) => ({ value: v.id, label: v.name }));
+
+  // ---- Mutations ----
+  const createAcquisition = useMutation({
+    mutationFn: async () => {
+      const res = await procurementService.createAcquisition(clean(acqForm) as never);
+      return res.data;
+    },
+    onSuccess: () => {
+      toast({ title: "Acquisition recorded" });
+      setAcqModalOpen(false);
+      setAcqForm({ ...emptyAcquisition });
+      qc.invalidateQueries({ queryKey: ["procurement", "acquisitions"] });
+    },
+    onError: (error: any) => {
+      toast({
+        title: "Error recording acquisition",
+        description: error?.response?.data?.message || "Failed to record acquisition",
+        variant: "destructive",
+      });
+    },
+  });
+
+  const createVendor = useMutation({
+    mutationFn: async () => {
+      const res = await procurementService.createVendor(clean(vendorForm) as never);
+      return res.data;
+    },
+    onSuccess: () => {
+      toast({ title: "Vendor created" });
+      setVendorModalOpen(false);
+      setVendorForm({ ...emptyVendor });
+      qc.invalidateQueries({ queryKey: ["procurement", "vendors"] });
+    },
+    onError: (error: any) => {
+      toast({
+        title: "Error creating vendor",
+        description: error?.response?.data?.message || "Failed to create vendor",
+        variant: "destructive",
+      });
+    },
+  });
+
+  const createDisposal = useMutation({
+    mutationFn: async () => {
+      const res = await procurementService.createDisposal(clean(disposalForm) as never);
+      return res.data;
+    },
+    onSuccess: () => {
+      toast({ title: "Disposal recorded" });
+      setDisposalModalOpen(false);
+      setDisposalForm({ ...emptyDisposal });
+      qc.invalidateQueries({ queryKey: ["procurement", "disposals"] });
+    },
+    onError: (error: any) => {
+      toast({
+        title: "Error recording disposal",
+        description: error?.response?.data?.message || "Failed to record disposal",
+        variant: "destructive",
+      });
+    },
+  });
+
+  return (
+    <Container size="xl" py="xl" px="lg">
+      <Breadcrumbs items={[{ label: "Fleet" }, { label: "Procurement" }]} />
+
+      <Group justify="space-between" mb="lg">
+        <Title order={1}>Procurement & Assets</Title>
+      </Group>
+
+      <Tabs value={tab} onChange={(val) => setTab(val || "acquisitions")}>
+        <Tabs.List mb="lg">
+          <Tabs.Tab value="acquisitions">Acquisitions</Tabs.Tab>
+          <Tabs.Tab value="vendors">Vendors</Tabs.Tab>
+          <Tabs.Tab value="disposals">Disposals</Tabs.Tab>
+        </Tabs.List>
+
+        {/* ---- Acquisitions ---- */}
+        <Tabs.Panel value="acquisitions">
+          <Group justify="flex-end" mb="md">
+            <Button
+              leftSection={<Plus size={16} />}
+              onClick={() => setAcqModalOpen(true)}
+              color="edr-green"
+            >
+              New Acquisition
+            </Button>
+          </Group>
+          <Card withBorder>
+            <Table striped highlightOnHover>
+              <Table.Thead>
+                <Table.Tr>
+                  <Table.Th>Vehicle</Table.Th>
+                  <Table.Th>Type</Table.Th>
+                  <Table.Th>Date</Table.Th>
+                  <Table.Th align="right">Cost</Table.Th>
+                  <Table.Th>Status</Table.Th>
+                </Table.Tr>
+              </Table.Thead>
+              <Table.Tbody>
+                {loadingAcquisitions ? (
+                  <Table.Tr>
+                    <Table.Td colSpan={5}>
+                      <Group justify="center" py="md">
+                        <Loader size="sm" />
+                      </Group>
+                    </Table.Td>
+                  </Table.Tr>
+                ) : acquisitions.length === 0 ? (
+                  <Table.Tr>
+                    <Table.Td colSpan={5}>
+                      <Text c="dimmed" ta="center" py="md">
+                        No acquisitions recorded yet.
+                      </Text>
+                    </Table.Td>
+                  </Table.Tr>
+                ) : null}
+                {acquisitions.map((a: AssetAcquisition) => (
+                  <Table.Tr key={a.id}>
+                    <Table.Td>{vehicleLabel(a.vehicle, a.vehicleId)}</Table.Td>
+                    <Table.Td>
+                      <Badge size="sm" color={typeBadgeColor(a.acquisitionType)}>
+                        {a.acquisitionType}
+                      </Badge>
+                    </Table.Td>
+                    <Table.Td>{new Date(a.acquisitionDate).toLocaleDateString()}</Table.Td>
+                    <Table.Td align="right">{money(a.cost)}</Table.Td>
+                    <Table.Td>
+                      <Badge size="sm" color={statusBadgeColor(a.status)}>
+                        {a.status}
+                      </Badge>
+                    </Table.Td>
+                  </Table.Tr>
+                ))}
+              </Table.Tbody>
+            </Table>
+          </Card>
+        </Tabs.Panel>
+
+        {/* ---- Vendors ---- */}
+        <Tabs.Panel value="vendors">
+          <Group justify="flex-end" mb="md">
+            <Button
+              leftSection={<Plus size={16} />}
+              onClick={() => setVendorModalOpen(true)}
+              color="edr-green"
+            >
+              New Vendor
+            </Button>
+          </Group>
+          <Card withBorder>
+            <Table striped highlightOnHover>
+              <Table.Thead>
+                <Table.Tr>
+                  <Table.Th>Name</Table.Th>
+                  <Table.Th>Type</Table.Th>
+                  <Table.Th>Contact</Table.Th>
+                  <Table.Th>Phone</Table.Th>
+                  <Table.Th>Email</Table.Th>
+                  <Table.Th>Active</Table.Th>
+                </Table.Tr>
+              </Table.Thead>
+              <Table.Tbody>
+                {loadingVendors ? (
+                  <Table.Tr>
+                    <Table.Td colSpan={6}>
+                      <Group justify="center" py="md">
+                        <Loader size="sm" />
+                      </Group>
+                    </Table.Td>
+                  </Table.Tr>
+                ) : vendors.length === 0 ? (
+                  <Table.Tr>
+                    <Table.Td colSpan={6}>
+                      <Text c="dimmed" ta="center" py="md">
+                        No vendors added yet.
+                      </Text>
+                    </Table.Td>
+                  </Table.Tr>
+                ) : null}
+                {vendors.map((v: Vendor) => (
+                  <Table.Tr key={v.id}>
+                    <Table.Td>{v.name}</Table.Td>
+                    <Table.Td>{v.type ? <Badge size="sm">{v.type}</Badge> : "—"}</Table.Td>
+                    <Table.Td>{v.contactPerson || "—"}</Table.Td>
+                    <Table.Td>{v.phone || "—"}</Table.Td>
+                    <Table.Td>{v.email || "—"}</Table.Td>
+                    <Table.Td>
+                      <Badge size="sm" color={v.isActive ? "green" : "gray"}>
+                        {v.isActive ? "Active" : "Inactive"}
+                      </Badge>
+                    </Table.Td>
+                  </Table.Tr>
+                ))}
+              </Table.Tbody>
+            </Table>
+          </Card>
+        </Tabs.Panel>
+
+        {/* ---- Disposals ---- */}
+        <Tabs.Panel value="disposals">
+          <Group justify="flex-end" mb="md">
+            <Button
+              leftSection={<Plus size={16} />}
+              onClick={() => setDisposalModalOpen(true)}
+              color="edr-green"
+            >
+              New Disposal
+            </Button>
+          </Group>
+          <Card withBorder>
+            <Table striped highlightOnHover>
+              <Table.Thead>
+                <Table.Tr>
+                  <Table.Th>Vehicle</Table.Th>
+                  <Table.Th>Method</Table.Th>
+                  <Table.Th>Date</Table.Th>
+                  <Table.Th align="right">Sale Price</Table.Th>
+                  <Table.Th>Buyer</Table.Th>
+                </Table.Tr>
+              </Table.Thead>
+              <Table.Tbody>
+                {loadingDisposals ? (
+                  <Table.Tr>
+                    <Table.Td colSpan={5}>
+                      <Group justify="center" py="md">
+                        <Loader size="sm" />
+                      </Group>
+                    </Table.Td>
+                  </Table.Tr>
+                ) : disposals.length === 0 ? (
+                  <Table.Tr>
+                    <Table.Td colSpan={5}>
+                      <Text c="dimmed" ta="center" py="md">
+                        No disposals recorded yet.
+                      </Text>
+                    </Table.Td>
+                  </Table.Tr>
+                ) : null}
+                {disposals.map((d: AssetDisposal) => (
+                  <Table.Tr key={d.id}>
+                    <Table.Td>{d.vehicleId}</Table.Td>
+                    <Table.Td>
+                      <Badge size="sm">{d.method}</Badge>
+                    </Table.Td>
+                    <Table.Td>{new Date(d.disposalDate).toLocaleDateString()}</Table.Td>
+                    <Table.Td align="right">{money(d.salePrice)}</Table.Td>
+                    <Table.Td>{d.buyer || "—"}</Table.Td>
+                  </Table.Tr>
+                ))}
+              </Table.Tbody>
+            </Table>
+          </Card>
+        </Tabs.Panel>
+      </Tabs>
+
+      {/* ---- Acquisition Modal ---- */}
+      <Modal
+        opened={acqModalOpen}
+        onClose={() => setAcqModalOpen(false)}
+        title="New Acquisition"
+        size="lg"
+      >
+        <Stack gap="md">
+          <Select
+            label="Vehicle"
+            placeholder="Select vehicle"
+            data={vehicleOptions}
+            value={acqForm.vehicleId}
+            onChange={(val) => setAcqForm({ ...acqForm, vehicleId: val || "" })}
+            searchable
+            clearable
+          />
+          <Select
+            label="Vendor"
+            placeholder="Select vendor"
+            data={vendorOptions}
+            value={acqForm.vendorId}
+            onChange={(val) => setAcqForm({ ...acqForm, vendorId: val || "" })}
+            searchable
+            clearable
+          />
+          <Select
+            label="Acquisition Type"
+            data={ACQUISITION_TYPES}
+            value={acqForm.acquisitionType}
+            onChange={(val) =>
+              setAcqForm({ ...acqForm, acquisitionType: (val as AcquisitionType) || "PURCHASE" })
+            }
+            required
+          />
+          <TextInput
+            label="Acquisition Date"
+            type="date"
+            value={acqForm.acquisitionDate}
+            onChange={(e) => setAcqForm({ ...acqForm, acquisitionDate: e.currentTarget.value })}
+            required
+          />
+          <NumberInput
+            label="Cost"
+            placeholder="0.00"
+            value={acqForm.cost}
+            onChange={(val) => setAcqForm({ ...acqForm, cost: val as number | undefined })}
+            decimalScale={2}
+            min={0}
+          />
+          <NumberInput
+            label="Useful Life (months)"
+            placeholder="Optional"
+            value={acqForm.usefulLifeMonths}
+            onChange={(val) =>
+              setAcqForm({ ...acqForm, usefulLifeMonths: val as number | undefined })
+            }
+            decimalScale={0}
+            min={0}
+          />
+          <NumberInput
+            label="Salvage Value"
+            placeholder="0.00"
+            value={acqForm.salvageValue}
+            onChange={(val) => setAcqForm({ ...acqForm, salvageValue: val as number | undefined })}
+            decimalScale={2}
+            min={0}
+          />
+          <TextInput
+            label="Lease Start"
+            type="date"
+            value={acqForm.leaseStart}
+            onChange={(e) => setAcqForm({ ...acqForm, leaseStart: e.currentTarget.value })}
+          />
+          <TextInput
+            label="Lease End"
+            type="date"
+            value={acqForm.leaseEnd}
+            onChange={(e) => setAcqForm({ ...acqForm, leaseEnd: e.currentTarget.value })}
+          />
+          <NumberInput
+            label="Monthly Payment"
+            placeholder="0.00"
+            value={acqForm.monthlyPayment}
+            onChange={(val) =>
+              setAcqForm({ ...acqForm, monthlyPayment: val as number | undefined })
+            }
+            decimalScale={2}
+            min={0}
+          />
+          <Select
+            label="Status"
+            data={ACQUISITION_STATUSES}
+            value={acqForm.status}
+            onChange={(val) =>
+              setAcqForm({ ...acqForm, status: (val as AcquisitionStatus) || "ACTIVE" })
+            }
+          />
+          <TextInput
+            label="Notes"
+            placeholder="Optional notes"
+            value={acqForm.notes}
+            onChange={(e) => setAcqForm({ ...acqForm, notes: e.currentTarget.value })}
+          />
+          <Group justify="flex-end">
+            <Button variant="light" onClick={() => setAcqModalOpen(false)}>
+              Cancel
+            </Button>
+            <Button
+              onClick={() => createAcquisition.mutate()}
+              loading={createAcquisition.isPending}
+              disabled={!acqForm.acquisitionDate}
+            >
+              Save Acquisition
+            </Button>
+          </Group>
+        </Stack>
+      </Modal>
+
+      {/* ---- Vendor Modal ---- */}
+      <Modal
+        opened={vendorModalOpen}
+        onClose={() => setVendorModalOpen(false)}
+        title="New Vendor"
+        size="lg"
+      >
+        <Stack gap="md">
+          <TextInput
+            label="Name"
+            placeholder="Vendor name"
+            value={vendorForm.name}
+            onChange={(e) => setVendorForm({ ...vendorForm, name: e.currentTarget.value })}
+            required
+          />
+          <Select
+            label="Type"
+            placeholder="Select type"
+            data={VENDOR_TYPES}
+            value={vendorForm.type || null}
+            onChange={(val) => setVendorForm({ ...vendorForm, type: (val as VendorType) || "" })}
+            clearable
+          />
+          <TextInput
+            label="Contact Person"
+            placeholder="Optional"
+            value={vendorForm.contactPerson}
+            onChange={(e) => setVendorForm({ ...vendorForm, contactPerson: e.currentTarget.value })}
+          />
+          <TextInput
+            label="Phone"
+            placeholder="Optional"
+            value={vendorForm.phone}
+            onChange={(e) => setVendorForm({ ...vendorForm, phone: e.currentTarget.value })}
+          />
+          <TextInput
+            label="Email"
+            placeholder="Optional"
+            value={vendorForm.email}
+            onChange={(e) => setVendorForm({ ...vendorForm, email: e.currentTarget.value })}
+          />
+          <TextInput
+            label="Address"
+            placeholder="Optional"
+            value={vendorForm.address}
+            onChange={(e) => setVendorForm({ ...vendorForm, address: e.currentTarget.value })}
+          />
+          <Switch
+            label="Active"
+            checked={vendorForm.isActive}
+            onChange={(e) => setVendorForm({ ...vendorForm, isActive: e.currentTarget.checked })}
+          />
+          <Group justify="flex-end">
+            <Button variant="light" onClick={() => setVendorModalOpen(false)}>
+              Cancel
+            </Button>
+            <Button
+              onClick={() => createVendor.mutate()}
+              loading={createVendor.isPending}
+              disabled={!vendorForm.name}
+            >
+              Save Vendor
+            </Button>
+          </Group>
+        </Stack>
+      </Modal>
+
+      {/* ---- Disposal Modal ---- */}
+      <Modal
+        opened={disposalModalOpen}
+        onClose={() => setDisposalModalOpen(false)}
+        title="New Disposal"
+        size="lg"
+      >
+        <Stack gap="md">
+          <Select
+            label="Vehicle"
+            placeholder="Select vehicle"
+            data={vehicleOptions}
+            value={disposalForm.vehicleId}
+            onChange={(val) => setDisposalForm({ ...disposalForm, vehicleId: val || "" })}
+            searchable
+            required
+          />
+          <TextInput
+            label="Disposal Date"
+            type="date"
+            value={disposalForm.disposalDate}
+            onChange={(e) =>
+              setDisposalForm({ ...disposalForm, disposalDate: e.currentTarget.value })
+            }
+            required
+          />
+          <Select
+            label="Method"
+            data={DISPOSAL_METHODS}
+            value={disposalForm.method}
+            onChange={(val) =>
+              setDisposalForm({ ...disposalForm, method: (val as DisposalMethod) || "SALE" })
+            }
+            required
+          />
+          <NumberInput
+            label="Sale Price"
+            placeholder="0.00"
+            value={disposalForm.salePrice}
+            onChange={(val) =>
+              setDisposalForm({ ...disposalForm, salePrice: val as number | undefined })
+            }
+            decimalScale={2}
+            min={0}
+          />
+          <TextInput
+            label="Buyer"
+            placeholder="Optional"
+            value={disposalForm.buyer}
+            onChange={(e) => setDisposalForm({ ...disposalForm, buyer: e.currentTarget.value })}
+          />
+          <TextInput
+            label="Notes"
+            placeholder="Optional notes"
+            value={disposalForm.notes}
+            onChange={(e) => setDisposalForm({ ...disposalForm, notes: e.currentTarget.value })}
+          />
+          <Group justify="flex-end">
+            <Button variant="light" onClick={() => setDisposalModalOpen(false)}>
+              Cancel
+            </Button>
+            <Button
+              onClick={() => createDisposal.mutate()}
+              loading={createDisposal.isPending}
+              disabled={!disposalForm.vehicleId || !disposalForm.disposalDate}
+            >
+              Save Disposal
+            </Button>
+          </Group>
+        </Stack>
+      </Modal>
+    </Container>
+  );
+}
diff --git a/apps/edr-freight-web/backoffice/src/pages/fleet/TrackingPage.tsx b/apps/edr-freight-web/backoffice/src/pages/fleet/TrackingPage.tsx
index f60c7f72b..14bb32d33 100644
--- a/apps/edr-freight-web/backoffice/src/pages/fleet/TrackingPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/fleet/TrackingPage.tsx
@@ -1,368 +1,500 @@
-import { useState, useMemo } from 'react';
-import { useQuery } from '@tanstack/react-query';
-import { Container, Grid, Card, Stack, Group, Select, Text, Badge, Button, Box, Table, SimpleGrid } from '@mantine/core';
-import { MapPin, Navigation, Radio, Activity } from 'lucide-react';
-import Breadcrumbs from '@/components/ui/Breadcrumbs';
-import { QUERY_KEYS } from '@/constants/QUERY_KEYS';
-import { vehiclesService } from '@/services/vehicles.service';
-import { freightBrand } from '@/theme/freight-brand';
+import { useEffect, useMemo, useState } from "react";
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import {
+  ActionIcon,
+  Badge,
+  Box,
+  Button,
+  Card,
+  Container,
+  Grid,
+  Group,
+  Modal,
+  Select,
+  SimpleGrid,
+  Stack,
+  Table,
+  Text,
+  TextInput,
+} from "@mantine/core";
+import {
+  APIProvider,
+  InfoWindow,
+  Map as GoogleMap,
+  Marker,
+  useMap,
+} from "@vis.gl/react-google-maps";
+import { Activity, Pencil, Plus, Radio, Trash2 } from "lucide-react";
+import Breadcrumbs from "@/components/ui/Breadcrumbs";
+import { useToast } from "@/hooks/use-toast";
+import { vehiclesService } from "@/services/vehicles.service";
+import { gpsTrackingService, type GpsDevice } from "@/services/gps-tracking.service";
+import { freightBrand } from "@/theme/freight-brand";
 
-interface Vehicle {
-  id: string;
-  registrationNumber: string;
-  plateNumber: string;
-  manufacturer: string;
-  model: string;
-  status?: string;
+// Same default key + env override the portal's LocationPicker uses.
+const GOOGLE_MAPS_API_KEY =
+  import.meta.env.VITE_GOOGLE_MAPS_API_KEY ||
+  "AIzaSyBg4tN31-fgvH_2Ix_TPo6VSfOA2uA5CCI";
+const DEFAULT_CENTER = { lat: 9.03, lng: 38.74 }; // Addis Ababa
+
+const toNum = (v: number | string | null | undefined): number | null =>
+  v == null || v === "" ? null : Number(v);
+
+const deviceLabel = (d: GpsDevice) =>
+  d.vehicle
+    ? [d.vehicle.code, d.vehicle.plateNumber].filter(Boolean).join(" · ")
+    : d.name || d.imei;
+
+const fmtTime = (iso?: string | null) => {
+  if (!iso) return "—";
+  const d = new Date(iso);
+  return Number.isNaN(d.getTime()) ? "—" : d.toLocaleString();
+};
+
+const StatBox = ({ label, value }: { label: string; value: string }) => (
+  <Box p="sm" style={{ backgroundColor: "#f8f9fa", borderRadius: 8 }}>
+    <Text size="xs" c="dimmed">{label}</Text>
+    <Text fw={600} size="sm">{value}</Text>
+  </Box>
+);
+
+type LatLng = { lat: number; lng: number };
+
+/** Flip a flag once the map (and thus the Maps JS classes) is loaded. */
+function ReadyProbe({ onReady }: { onReady: () => void }) {
+  const map = useMap();
+  useEffect(() => {
+    if (map) onReady();
+  }, [map, onReady]);
+  return null;
 }
 
-interface GPSLocation {
+/** Fit the map to the current markers (or center on a single one). */
+function FitBounds({ points }: { points: LatLng[] }) {
+  const map = useMap();
+  useEffect(() => {
+    if (!map || points.length === 0 || typeof google === "undefined") return;
+    if (points.length === 1) {
+      map.setCenter(points[0]);
+      map.setZoom(14);
+      return;
+    }
+    const b = new google.maps.LatLngBounds();
+    points.forEach((p) => b.extend(p));
+    map.fitBounds(b, 60);
+  }, [map, points]);
+  return null;
+}
+
+/** Lazily reverse-geocode a coordinate to a human address. */
+function useAddress(lat: number, lng: number): string | null {
+  const [addr, setAddr] = useState<string | null>(null);
+  useEffect(() => {
+    if (typeof google === "undefined" || !google.maps?.Geocoder) return;
+    setAddr(null);
+    let cancelled = false;
+    new google.maps.Geocoder().geocode({ location: { lat, lng } }, (res, status) => {
+      if (cancelled) return;
+      setAddr(status === "OK" && res?.[0] ? res[0].formatted_address : "Unknown location");
+    });
+    return () => { cancelled = true; };
+  }, [lat, lng]);
+  return addr;
+}
+
+/** Hover popup: label, coordinates, speed/course, and the reverse-geocoded place. */
+function HoverInfo({
+  device,
+  lat,
+  lng,
+  onClose,
+}: {
+  device: GpsDevice;
   lat: number;
   lng: number;
-  speed?: number;
-  heading?: number;
-  lastUpdate?: string;
+  onClose: () => void;
+}) {
+  const address = useAddress(lat, lng);
+  return (
+    <InfoWindow position={{ lat, lng }} pixelOffset={[0, -46]} onCloseClick={onClose}>
+      <div style={{ minWidth: 190, fontSize: 13 }}>
+        <div style={{ fontWeight: 600, marginBottom: 2 }}>{deviceLabel(device)}</div>
+        <div style={{ fontFamily: "monospace" }}>
+          {lat.toFixed(5)}, {lng.toFixed(5)}
+        </div>
+        <div style={{ color: "#555" }}>
+          {toNum(device.lastSpeed) ?? 0} km/h · {device.lastCourse ?? 0}°
+        </div>
+        <div style={{ color: "#777", marginTop: 4 }}>{address ?? "Locating…"}</div>
+      </div>
+    </InfoWindow>
+  );
 }
 
-// Mock GPS data for demo (no real GPS backend exists — these are simulated values)
-const generateMockGPS = (): GPSLocation => ({
-  lat: 9.0 + Math.random() * 0.5,
-  lng: 38.7 + Math.random() * 0.5,
-  speed: Math.floor(Math.random() * 120),
-  heading: Math.floor(Math.random() * 360),
-  lastUpdate: new Date(Date.now() - Math.random() * 300000).toLocaleTimeString(),
-});
+/** Draw the selected vehicle's recent path as a polyline. */
+function RouteTrail({ path }: { path: LatLng[] }) {
+  const map = useMap();
+  useEffect(() => {
+    if (!map || path.length < 2 || typeof google === "undefined") return;
+    const line = new google.maps.Polyline({
+      path,
+      strokeColor: freightBrand.primary,
+      strokeOpacity: 0.85,
+      strokeWeight: 4,
+    });
+    line.setMap(map);
+    return () => line.setMap(null);
+  }, [map, path]);
+  return null;
+}
 
 export function TrackingPage() {
-  const [selectedVehicleId, setSelectedVehicleId] = useState<string | null>(null);
-  const [mapCenter] = useState({ lat: 9.0, lng: 38.8 });
+  const { toast } = useToast();
+  const qc = useQueryClient();
+  const [selectedId, setSelectedId] = useState<string | null>(null);
+  const [hoverId, setHoverId] = useState<string | null>(null);
+  const [mapsReady, setMapsReady] = useState(false);
+  const [modalOpen, setModalOpen] = useState(false);
+  const [editDevice, setEditDevice] = useState<GpsDevice | null>(null);
+  const [form, setForm] = useState({ imei: "", name: "", vehicleId: "" });
 
-  const { data: vehicles = [] } = useQuery({
-    queryKey: QUERY_KEYS.VEHICLES.list(),
-    queryFn: async () => {
-      const res = await vehiclesService.getAll({ limit: 1000 });
-      return res.data || [];
+  const openRegister = () => {
+    setEditDevice(null);
+    setForm({ imei: "", name: "", vehicleId: "" });
+    setModalOpen(true);
+  };
+  const openEdit = (d: GpsDevice) => {
+    setEditDevice(d);
+    setForm({ imei: d.imei, name: d.name ?? "", vehicleId: d.vehicleId ?? "" });
+    setModalOpen(true);
+  };
+
+  // Poll every 10s so the map tracks live movement.
+  const { data: devices = [] } = useQuery({
+    queryKey: ["gps", "devices"],
+    queryFn: async () => (await gpsTrackingService.listDevices()).data ?? [],
+    refetchInterval: 10_000,
+  });
+
+  const { data: vehiclesData } = useQuery({
+    queryKey: ["vehicles", "all"],
+    queryFn: async () => (await vehiclesService.getAll({ limit: 1000 })).data ?? [],
+  });
+  const vehicleOptions = useMemo(
+    () =>
+      (vehiclesData ?? []).map((v) => ({
+        value: v.id,
+        label: `${v.plateNumber} - ${v.manufacturer} ${v.model}`,
+      })),
+    [vehiclesData],
+  );
+
+  const positioned = useMemo(
+    () =>
+      devices
+        .map((d) => ({ d, lat: toNum(d.lastLat), lng: toNum(d.lastLng) }))
+        .filter((x): x is { d: GpsDevice; lat: number; lng: number } => x.lat != null && x.lng != null),
+    [devices],
+  );
+
+  const selected = devices.find((d) => d.id === selectedId) ?? null;
+  const onlineCount = devices.filter((d) => d.online).length;
+
+  // Route history for the selected device's vehicle (chronological trail).
+  const { data: history = [] } = useQuery({
+    queryKey: ["gps", "history", selected?.vehicleId],
+    queryFn: async () => (await gpsTrackingService.history(selected!.vehicleId!, 300)).data ?? [],
+    enabled: Boolean(selected?.vehicleId),
+  });
+  const trail = useMemo(
+    () => [...history].reverse().map((h) => ({ lat: Number(h.lat), lng: Number(h.lng) })),
+    [history],
+  );
+
+  // Teardrop pin colored by state with a white truck glyph inside.
+  const markerIcon = (d: GpsDevice, selectedFlag: boolean): google.maps.Icon | undefined => {
+    // Maps API loads async — Size/Point classes may not exist yet at first render.
+    if (typeof google === "undefined" || !google.maps?.Size || !mapsReady) return undefined;
+    const color = selectedFlag ? freightBrand.primary : d.online ? "#2f80ed" : "#95a5a6";
+    const svg = `<svg xmlns="http://www.w3.org/2000/svg" width="40" height="48" viewBox="0 0 40 48">
+      <path d="M20 2C10 2 2 10 2 20c0 12 18 26 18 26s18-14 18-26C38 10 30 2 20 2Z" fill="${color}" stroke="#ffffff" stroke-width="1.5"/>
+      <g transform="translate(8,7)" fill="none" stroke="#ffffff" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+        <path d="M14 18V6a1 1 0 0 0-1-1H2a1 1 0 0 0-1 1v11a1 1 0 0 0 1 1h1"/>
+        <path d="M15 18H9"/>
+        <path d="M19 18h2a1 1 0 0 0 1-1v-3.65a1 1 0 0 0-.22-.62l-3.48-4.35A1 1 0 0 0 17.52 8H14"/>
+        <circle cx="7" cy="18" r="2"/>
+        <circle cx="17" cy="18" r="2"/>
+      </g>
+    </svg>`;
+    return {
+      url: `data:image/svg+xml,${encodeURIComponent(svg)}`,
+      scaledSize: new google.maps.Size(40, 48),
+      anchor: new google.maps.Point(20, 48),
+    };
+  };
+
+  const saveMutation = useMutation({
+    mutationFn: () =>
+      editDevice
+        ? gpsTrackingService.update(editDevice.id, {
+            name: form.name.trim() || undefined,
+            vehicleId: form.vehicleId || null,
+          })
+        : gpsTrackingService.register({
+            imei: form.imei.trim(),
+            name: form.name.trim() || undefined,
+            vehicleId: form.vehicleId || null,
+          }),
+    onSuccess: () => {
+      toast({ title: editDevice ? "Tracker updated" : "Tracker registered" });
+      setModalOpen(false);
+      setEditDevice(null);
+      setForm({ imei: "", name: "", vehicleId: "" });
+      void qc.invalidateQueries({ queryKey: ["gps", "devices"] });
+    },
+    onError: (err: unknown) => {
+      const description =
+        (err as { response?: { data?: { message?: string } } })?.response?.data?.message ?? "Failed";
+      toast({ title: editDevice ? "Update failed" : "Registration failed", description, variant: "destructive" });
     },
   });
 
-  // Generate mock GPS data for each vehicle
-  const vehiclesWithGPS = useMemo(() => {
-    return (vehicles as Vehicle[]).map((v) => ({
-      ...v,
-      gps: generateMockGPS(),
-    }));
-  }, [vehicles]);
+  const assignMutation = useMutation({
+    mutationFn: ({ id, vehicleId }: { id: string; vehicleId: string | null }) =>
+      gpsTrackingService.update(id, { vehicleId }),
+    onSuccess: () => {
+      toast({ title: "Tracker updated" });
+      void qc.invalidateQueries({ queryKey: ["gps", "devices"] });
+    },
+    onError: () => toast({ title: "Update failed", variant: "destructive" }),
+  });
 
-  // For demo: show all vehicles as trackable (or filter by ACTIVE if status data available)
-  const trackableVehicles = useMemo(
-    () => vehiclesWithGPS.slice(0, 10), // Limit to first 10 for demo
-    [vehiclesWithGPS]
-  );
-
-  const selectedVehicle = trackableVehicles.find(v => v.id === selectedVehicleId);
-  const vehicleOptions = useMemo(
-    () => trackableVehicles.map(v => ({ label: v.registrationNumber, value: v.id })),
-    [trackableVehicles]
-  );
-
-  // Map dimensions
-  const mapWidth = 800;
-  const mapHeight = 500;
-  const pixelsPerLat = mapHeight / 0.6;
-  const pixelsPerLng = mapWidth / 0.6;
-
-  const getMapCoords = (lat: number, lng: number) => ({
-    x: ((lng - (mapCenter.lng - 0.3)) * pixelsPerLng),
-    y: ((mapCenter.lat + 0.3 - lat) * pixelsPerLat),
+  const deleteMutation = useMutation({
+    mutationFn: (id: string) => gpsTrackingService.remove(id),
+    onSuccess: () => {
+      toast({ title: "Tracker removed" });
+      setSelectedId(null);
+      void qc.invalidateQueries({ queryKey: ["gps", "devices"] });
+    },
+    onError: () => toast({ title: "Delete failed", variant: "destructive" }),
   });
 
   return (
     <Container size="xl" py="xl" px="lg">
-      <Breadcrumbs items={[{ label: 'Fleet' }, { label: 'Vehicle Tracking' }]} />
+      <Breadcrumbs items={[{ label: "Fleet" }, { label: "Vehicle Tracking" }]} />
 
-      <Stack gap="xl">
-        <Group justify="space-between">
-          <div>
-            <Group gap="xs" align="center">
-              <Text fw={700} size="xl">
-                Real-Time Vehicle Tracking
-              </Text>
-              <Badge color="yellow" variant="light">
-                Simulated GPS
-              </Badge>
-            </Group>
-            <Text c="dimmed" size="sm">
-              Monitor vehicle locations, speed, and status
-            </Text>
-          </div>
-        </Group>
+      <Group justify="space-between" mb="xl">
+        <div>
+          <Text fw={700} size="xl">Real-Time Vehicle Tracking</Text>
+          <Text c="dimmed" size="sm">Live GPS positions from GT06 trackers</Text>
+        </div>
+        <Button leftSection={<Plus size={16} />} color="edr-green" onClick={openRegister}>
+          Register tracker
+        </Button>
+      </Group>
 
-        <Grid>
-          {/* Map Section */}
-          <Grid.Col span={{ base: 12, lg: 8 }}>
-            <Card withBorder p="lg">
-              <Card.Section p="md" withBorder>
-                <Group justify="space-between">
-                  <Text fw={500}>Map View</Text>
-                  <Group gap="xs">
-                    <Badge color="edr-green" leftSection={<Radio size={12} />}>
-                      {trackableVehicles.length} Tracked
-                    </Badge>
-                  </Group>
-                </Group>
-              </Card.Section>
-
-              <Card.Section p="md">
-                <Box style={{ overflowX: 'auto', maxWidth: '100%' }}>
-                  <Box
-                    pos="relative"
-                    style={{
-                      width: mapWidth,
-                      height: mapHeight,
-                      backgroundColor: '#f0f8f7',
-                      border: `2px solid ${freightBrand.primary}`,
-                      borderRadius: '8px',
-                      overflow: 'hidden',
-                    }}
+      <Grid>
+        {/* Map */}
+        <Grid.Col span={{ base: 12, lg: 8 }}>
+          <Card withBorder p="lg">
+            <Card.Section p="md" withBorder>
+              <Group justify="space-between">
+                <Text fw={500}>Live Map</Text>
+                <Badge color="edr-green" leftSection={<Radio size={12} />}>
+                  {onlineCount} online · {positioned.length} located
+                </Badge>
+              </Group>
+            </Card.Section>
+            <Card.Section p="md">
+              <Box style={{ height: 500, width: "100%", borderRadius: 8, overflow: "hidden" }}>
+                <APIProvider apiKey={GOOGLE_MAPS_API_KEY}>
+                  <GoogleMap
+                    defaultCenter={DEFAULT_CENTER}
+                    defaultZoom={7}
+                    gestureHandling="greedy"
+                    disableDefaultUI={false}
+                    style={{ width: "100%", height: "100%" }}
                   >
-                  {/* Grid background */}
-                  <svg
-                    width={mapWidth}
-                    height={mapHeight}
-                    style={{ position: 'absolute', top: 0, left: 0 }}
-                  >
-                    {/* Latitude lines */}
-                    {[0, 1, 2, 3, 4, 5, 6].map(i => (
-                      <line
-                        key={`lat-${i}`}
-                        x1={0}
-                        y1={(i / 6) * mapHeight}
-                        x2={mapWidth}
-                        y2={(i / 6) * mapHeight}
-                        stroke="#e0e0e0"
-                        strokeWidth={1}
+                    <ReadyProbe onReady={() => setMapsReady(true)} />
+                    {positioned.map(({ d, lat, lng }) => (
+                      <Marker
+                        key={d.id}
+                        position={{ lat, lng }}
+                        title={`${deviceLabel(d)}\n${lat.toFixed(5)}, ${lng.toFixed(5)}`}
+                        icon={markerIcon(d, d.id === selectedId)}
+                        onClick={() => setSelectedId(d.id)}
+                        onMouseOver={() => setHoverId(d.id)}
                       />
                     ))}
-                    {/* Longitude lines */}
-                    {[0, 1, 2, 3, 4, 5, 6].map(i => (
-                      <line
-                        key={`lng-${i}`}
-                        x1={(i / 6) * mapWidth}
-                        y1={0}
-                        x2={(i / 6) * mapWidth}
-                        y2={mapHeight}
-                        stroke="#e0e0e0"
-                        strokeWidth={1}
-                      />
-                    ))}
-                  </svg>
-
-                  {/* Vehicle markers */}
-                  {trackableVehicles.map((vehicle) => {
-                    const coords = getMapCoords(vehicle.gps.lat, vehicle.gps.lng);
-                    const isSelected = vehicle.id === selectedVehicleId;
-
-                    return (
-                      <Box
-                        key={vehicle.id}
-                        pos="absolute"
-                        style={{
-                          left: coords.x - 15,
-                          top: coords.y - 15,
-                          width: 30,
-                          height: 30,
-                          cursor: 'pointer',
-                          zIndex: isSelected ? 100 : 10,
-                        }}
-                        onClick={() => setSelectedVehicleId(vehicle.id)}
-                        title={vehicle.registrationNumber}
-                      >
-                        <Box
-                          pos="absolute"
-                          inset={0}
-                          style={{
-                            backgroundColor: isSelected ? freightBrand.primary : '#3498db',
-                            borderRadius: '50%',
-                            border: isSelected ? `3px solid ${freightBrand.primaryDark}` : 'none',
-                            display: 'flex',
-                            alignItems: 'center',
-                            justifyContent: 'center',
-                            color: 'white',
-                            fontSize: '16px',
-                            boxShadow: isSelected ? `0 0 0 8px ${freightBrand.ring}` : 'none',
-                          }}
-                        >
-                          <Navigation size={16} />
-                        </Box>
-                      </Box>
-                    );
-                  })}
-
-                  {/* Map labels */}
-                  <Box pos="absolute" bottom={8} left={8} style={{ zIndex: 50 }}>
-                    <Text size="xs" c="dimmed">
-                      📍 Addis Ababa, Ethiopia
-                    </Text>
-                  </Box>
-                  </Box>
-                </Box>
-                <Text size="xs" c="dimmed" mt="xs">
-                  Simulated map — coordinates, speed, and heading are demo values, not live GPS.
+                    {(() => {
+                      const h = positioned.find((p) => p.d.id === hoverId);
+                      return h ? (
+                        <HoverInfo device={h.d} lat={h.lat} lng={h.lng} onClose={() => setHoverId(null)} />
+                      ) : null;
+                    })()}
+                    <FitBounds points={positioned.map((p) => ({ lat: p.lat, lng: p.lng }))} />
+                    {selected?.vehicleId && trail.length > 1 && <RouteTrail path={trail} />}
+                  </GoogleMap>
+                </APIProvider>
+              </Box>
+              {positioned.length === 0 && (
+                <Text size="sm" c="dimmed" ta="center" mt="sm">
+                  No located trackers yet — waiting for GPS fixes.
                 </Text>
-              </Card.Section>
-            </Card>
-          </Grid.Col>
-
-          {/* Sidebar */}
-          <Grid.Col span={{ base: 12, lg: 4 }}>
-            <Stack gap="md">
-              {/* Vehicle Selector */}
-              <Card withBorder p="lg">
-                <Stack gap="md">
-                  <Select
-                    label="Track Vehicle"
-                    placeholder="Select a vehicle to track"
-                    data={vehicleOptions}
-                    value={selectedVehicleId}
-                    onChange={setSelectedVehicleId}
-                    searchable
-                  />
-                  {selectedVehicle && (
-                    <Box p="md" style={{ backgroundColor: freightBrand.mutedBg, borderRadius: '8px' }}>
-                      <Stack gap="sm">
-                        <div>
-                          <Text size="sm" c="dimmed">
-                            Registration
-                          </Text>
-                          <Text fw={600}>{selectedVehicle.registrationNumber}</Text>
-                        </div>
-                        <div>
-                          <Text size="sm" c="dimmed">
-                            Vehicle
-                          </Text>
-                          <Text fw={600}>
-                            {selectedVehicle.manufacturer} {selectedVehicle.model}
-                          </Text>
-                        </div>
-                        <div>
-                          <Text size="sm" c="dimmed">
-                            Status
-                          </Text>
-                          <Badge color={selectedVehicle.status === 'ACTIVE' ? 'edr-green' : 'gray'}>
-                            {selectedVehicle.status || 'Unknown'}
-                          </Badge>
-                        </div>
-                      </Stack>
-                    </Box>
-                  )}
-                </Stack>
-              </Card>
-
-              {/* GPS Details */}
-              {selectedVehicle && (
-                <Card withBorder p="lg">
-                  <Stack gap="md">
-                    <Group justify="space-between">
-                      <Text fw={500}>GPS Location</Text>
-                      <Badge color="edr-green" leftSection={<Activity size={12} />}>
-                        Live
-                      </Badge>
-                    </Group>
-
-                    <SimpleGrid cols={2} spacing="sm">
-                      <Box p="sm" style={{ backgroundColor: '#f8f9fa', borderRadius: '8px' }}>
-                        <Text size="xs" c="dimmed">
-                          Latitude
-                        </Text>
-                        <Text fw={600} size="sm">
-                          {selectedVehicle.gps.lat.toFixed(4)}°
-                        </Text>
-                      </Box>
-                      <Box p="sm" style={{ backgroundColor: '#f8f9fa', borderRadius: '8px' }}>
-                        <Text size="xs" c="dimmed">
-                          Longitude
-                        </Text>
-                        <Text fw={600} size="sm">
-                          {selectedVehicle.gps.lng.toFixed(4)}°
-                        </Text>
-                      </Box>
-                      <Box p="sm" style={{ backgroundColor: '#f8f9fa', borderRadius: '8px' }}>
-                        <Text size="xs" c="dimmed">
-                          Speed
-                        </Text>
-                        <Text fw={600} size="sm">
-                          {selectedVehicle.gps.speed} km/h
-                        </Text>
-                      </Box>
-                      <Box p="sm" style={{ backgroundColor: '#f8f9fa', borderRadius: '8px' }}>
-                        <Text size="xs" c="dimmed">
-                          Heading
-                        </Text>
-                        <Text fw={600} size="sm">
-                          {selectedVehicle.gps.heading}°
-                        </Text>
-                      </Box>
-                    </SimpleGrid>
-
-                    <div>
-                      <Text size="xs" c="dimmed">
-                        Last Update
-                      </Text>
-                      <Text fw={500}>{selectedVehicle.gps.lastUpdate}</Text>
-                    </div>
-
-                    <Button color="edr-green" fullWidth leftSection={<MapPin size={16} />}>
-                      View Full History
-                    </Button>
-                  </Stack>
-                </Card>
               )}
+            </Card.Section>
+          </Card>
+        </Grid.Col>
 
-              {/* Tracked Vehicles List */}
+        {/* Sidebar */}
+        <Grid.Col span={{ base: 12, lg: 4 }}>
+          <Stack gap="md">
+            {selected && (
               <Card withBorder p="lg">
                 <Stack gap="md">
-                  <Text fw={500}>Tracked Vehicles ({trackableVehicles.length})</Text>
-                  <div style={{ maxHeight: '300px', overflowY: 'auto' }}>
-                    <Table>
-                      <Table.Tbody>
-                        {trackableVehicles.map(v => (
-                          <Table.Tr
-                            key={v.id}
-                            style={{
-                              cursor: 'pointer',
-                              backgroundColor: v.id === selectedVehicleId ? freightBrand.mutedBg : 'transparent',
-                            }}
-                            onClick={() => setSelectedVehicleId(v.id)}
-                          >
-                            <Table.Td>
-                              <Stack gap={0}>
-                                <Text size="sm" fw={600}>
-                                  {v.registrationNumber}
-                                </Text>
-                                <Text size="xs" c="dimmed">
-                                  {v.gps.speed} km/h
-                                </Text>
-                              </Stack>
-                            </Table.Td>
-                            <Table.Td align="right">
-                              <Badge
-                                color={v.status === 'ACTIVE' ? 'edr-green' : 'gray'}
-                                size="sm"
-                              >
-                                {v.status || 'N/A'}
-                              </Badge>
-                            </Table.Td>
-                          </Table.Tr>
-                        ))}
-                      </Table.Tbody>
-                    </Table>
+                  <Group justify="space-between">
+                    <Text fw={500}>{deviceLabel(selected)}</Text>
+                    <Group gap="xs">
+                      <Badge color={selected.online ? "edr-green" : "gray"} leftSection={<Activity size={12} />}>
+                        {selected.online ? "Live" : "Offline"}
+                      </Badge>
+                      <ActionIcon variant="subtle" color="red" aria-label="Remove tracker" onClick={() => deleteMutation.mutate(selected.id)}>
+                        <Trash2 size={16} />
+                      </ActionIcon>
+                    </Group>
+                  </Group>
+
+                  <SimpleGrid cols={2} spacing="sm">
+                    <StatBox label="Latitude" value={toNum(selected.lastLat)?.toFixed(5) ?? "—"} />
+                    <StatBox label="Longitude" value={toNum(selected.lastLng)?.toFixed(5) ?? "—"} />
+                    <StatBox label="Speed" value={`${toNum(selected.lastSpeed) ?? 0} km/h`} />
+                    <StatBox label="Course" value={`${selected.lastCourse ?? 0}°`} />
+                    <StatBox label="Voltage" value={selected.voltageLevel != null ? `${selected.voltageLevel}/6` : "—"} />
+                    <StatBox label="GSM" value={selected.gsmLevel != null ? `${selected.gsmLevel}/4` : "—"} />
+                  </SimpleGrid>
+
+                  <div>
+                    <Text size="xs" c="dimmed">IMEI</Text>
+                    <Text fw={500} size="sm">{selected.imei}</Text>
                   </div>
+                  <div>
+                    <Text size="xs" c="dimmed">Last fix</Text>
+                    <Text fw={500} size="sm">{fmtTime(selected.lastFixAt)}</Text>
+                  </div>
+                  {selected.vehicleId && (
+                    <Text size="xs" c="dimmed">
+                      Showing last {trail.length} fixes as a route trail.
+                    </Text>
+                  )}
+
+                  <Select
+                    label="Assigned vehicle"
+                    placeholder="Unassigned"
+                    data={vehicleOptions}
+                    value={selected.vehicleId ?? null}
+                    onChange={(v) => assignMutation.mutate({ id: selected.id, vehicleId: v })}
+                    searchable
+                    clearable
+                  />
                 </Stack>
               </Card>
-            </Stack>
-          </Grid.Col>
-        </Grid>
-      </Stack>
+            )}
+
+            <Card withBorder p="lg">
+              <Stack gap="md">
+                <Text fw={500}>Trackers ({devices.length})</Text>
+                <div style={{ maxHeight: 340, overflowY: "auto" }}>
+                  <Table>
+                    <Table.Tbody>
+                      {devices.map((d) => (
+                        <Table.Tr
+                          key={d.id}
+                          style={{ cursor: "pointer", backgroundColor: d.id === selectedId ? freightBrand.mutedBg : "transparent" }}
+                          onClick={() => setSelectedId(d.id)}
+                        >
+                          <Table.Td>
+                            <Stack gap={0}>
+                              <Text size="sm" fw={600}>{deviceLabel(d)}</Text>
+                              <Text size="xs" c="dimmed">{toNum(d.lastSpeed) ?? 0} km/h · {fmtTime(d.lastFixAt)}</Text>
+                            </Stack>
+                          </Table.Td>
+                          <Table.Td align="right">
+                            <Group gap={6} justify="flex-end" wrap="nowrap">
+                              <Badge color={d.online ? "edr-green" : "gray"} size="sm">{d.online ? "Live" : "Offline"}</Badge>
+                              <ActionIcon
+                                variant="subtle"
+                                size="sm"
+                                aria-label="Edit tracker"
+                                onClick={(e) => { e.stopPropagation(); openEdit(d); }}
+                              >
+                                <Pencil size={15} />
+                              </ActionIcon>
+                            </Group>
+                          </Table.Td>
+                        </Table.Tr>
+                      ))}
+                      {devices.length === 0 && (
+                        <Table.Tr>
+                          <Table.Td colSpan={2}>
+                            <Text size="sm" c="dimmed" ta="center" py="md">No trackers registered yet.</Text>
+                          </Table.Td>
+                        </Table.Tr>
+                      )}
+                    </Table.Tbody>
+                  </Table>
+                </div>
+              </Stack>
+            </Card>
+          </Stack>
+        </Grid.Col>
+      </Grid>
+
+      {/* Register / edit modal */}
+      <Modal
+        opened={modalOpen}
+        onClose={() => setModalOpen(false)}
+        title={editDevice ? "Edit GPS tracker" : "Register GPS tracker"}
+        radius="lg"
+        centered
+      >
+        <Stack gap="md">
+          <TextInput
+            label="IMEI"
+            placeholder="15-digit device IMEI"
+            required
+            disabled={Boolean(editDevice)}
+            value={form.imei}
+            onChange={(e) => setForm({ ...form, imei: e.currentTarget.value })}
+          />
+          <TextInput
+            label="Name"
+            placeholder="Optional label"
+            value={form.name}
+            onChange={(e) => setForm({ ...form, name: e.currentTarget.value })}
+          />
+          <Select
+            label="Vehicle"
+            placeholder="Assign to a vehicle (optional)"
+            data={vehicleOptions}
+            value={form.vehicleId || null}
+            onChange={(v) => setForm({ ...form, vehicleId: v ?? "" })}
+            searchable
+            clearable
+          />
+          <Group justify="flex-end">
+            <Button variant="default" onClick={() => setModalOpen(false)}>Cancel</Button>
+            <Button
+              loading={saveMutation.isPending}
+              disabled={!form.imei.trim()}
+              onClick={() => saveMutation.mutate()}
+            >
+              {editDevice ? "Save" : "Register"}
+            </Button>
+          </Group>
+        </Stack>
+      </Modal>
     </Container>
   );
 }
+
+export default TrackingPage;
diff --git a/apps/edr-freight-web/backoffice/src/pages/fleet/WorkOrdersPage.tsx b/apps/edr-freight-web/backoffice/src/pages/fleet/WorkOrdersPage.tsx
new file mode 100644
index 000000000..71c591bb7
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/pages/fleet/WorkOrdersPage.tsx
@@ -0,0 +1,830 @@
+import { useState } from 'react';
+import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
+import {
+  Card,
+  Button,
+  Modal,
+  Stack,
+  Group,
+  Select,
+  TextInput,
+  Textarea,
+  NumberInput,
+  Table,
+  Badge,
+  Text,
+  Title,
+  Container,
+  Tabs,
+  Loader,
+  Switch,
+  ActionIcon,
+} from '@mantine/core';
+import { Plus, Trash2, Pencil, Wrench, Package, ShieldCheck } from 'lucide-react';
+import Breadcrumbs from '@/components/ui/Breadcrumbs';
+import { useToast } from '@/hooks/use-toast';
+import {
+  maintenanceDepthService,
+  type WorkOrder,
+  type WorkOrderStatus,
+  type WorkOrderPriority,
+  type Part,
+  type Warranty,
+} from '@/services/maintenance-depth.service';
+import { vehiclesService, type Vehicle as VehicleType } from '@/services/vehicles.service';
+
+const WORK_ORDER_STATUSES: WorkOrderStatus[] = ['OPEN', 'IN_PROGRESS', 'COMPLETED', 'CANCELLED'];
+const WORK_ORDER_PRIORITIES: WorkOrderPriority[] = ['LOW', 'MEDIUM', 'HIGH', 'URGENT'];
+const PART_CATEGORIES = ['TIRE', 'ENGINE', 'BRAKE', 'ELECTRICAL', 'FILTER', 'FLUID', 'OTHER'];
+
+const etb = (x: number | string | null | undefined) =>
+  `ETB ${(Number(x) || 0).toLocaleString('en-US', {
+    minimumFractionDigits: 2,
+    maximumFractionDigits: 2,
+  })}`;
+
+const statusColor = (status: string) => {
+  const colors: Record<string, string> = {
+    OPEN: 'edr-blue',
+    IN_PROGRESS: 'edr-amber-soft',
+    COMPLETED: 'edr-green',
+    CANCELLED: 'edr-slate',
+  };
+  return colors[status] || 'edr-slate';
+};
+
+const priorityColor = (priority: string) => {
+  const colors: Record<string, string> = {
+    LOW: 'edr-slate',
+    MEDIUM: 'edr-blue',
+    HIGH: 'edr-amber-soft',
+    URGENT: 'edr-red',
+  };
+  return colors[priority] || 'edr-slate';
+};
+
+const emptyWorkOrder = {
+  vehicleId: '',
+  title: '',
+  description: '',
+  status: 'OPEN' as WorkOrderStatus,
+  priority: 'MEDIUM' as WorkOrderPriority,
+  assignedTo: '',
+  laborCost: 0,
+  partsCost: 0,
+};
+
+const emptyPart = {
+  name: '',
+  sku: '',
+  category: 'TIRE',
+  quantityInStock: 0,
+  reorderLevel: 0,
+  unitCost: 0,
+  location: '',
+};
+
+const emptyWarranty = {
+  vehicleId: '',
+  component: '',
+  provider: '',
+  startDate: '',
+  expiryDate: new Date().toISOString().split('T')[0],
+  coverageNotes: '',
+};
+
+export default function WorkOrdersPage() {
+  const { toast } = useToast();
+  const queryClient = useQueryClient();
+
+  const [activeTab, setActiveTab] = useState<string | null>('work-orders');
+
+  // Work orders
+  const [statusFilter, setStatusFilter] = useState<string | null>(null);
+  const [openWorkOrderModal, setOpenWorkOrderModal] = useState(false);
+  const [workOrderForm, setWorkOrderForm] = useState(emptyWorkOrder);
+
+  // Parts
+  const [lowStockOnly, setLowStockOnly] = useState(false);
+  const [openPartModal, setOpenPartModal] = useState(false);
+  const [editingPartId, setEditingPartId] = useState<string | null>(null);
+  const [partForm, setPartForm] = useState(emptyPart);
+
+  // Warranties
+  const [openWarrantyModal, setOpenWarrantyModal] = useState(false);
+  const [warrantyForm, setWarrantyForm] = useState(emptyWarranty);
+
+  const { data: vehiclesData } = useQuery({
+    queryKey: ['vehicles', 'all-for-maintenance-depth'],
+    queryFn: async () => {
+      const res = await vehiclesService.getAll({ limit: 1000 });
+      return res.data || [];
+    },
+  });
+
+  const vehicleOptions =
+    vehiclesData?.map((v: VehicleType) => ({
+      value: v.id,
+      label: v.plateNumber
+        ? `${v.plateNumber} - ${v.manufacturer} ${v.model}`
+        : v.registrationNumber || v.id,
+    })) || [];
+
+  const vehicleLabel = (vehicleId: string) =>
+    vehicleOptions.find((o) => o.value === vehicleId)?.label || vehicleId;
+
+  // ---- Work orders queries/mutations ----
+  const { data: workOrders, isLoading: workOrdersLoading } = useQuery({
+    queryKey: ['maintenance-work-orders', statusFilter],
+    queryFn: async () => {
+      const res = await maintenanceDepthService.getWorkOrders({
+        status: (statusFilter as WorkOrderStatus) || undefined,
+      });
+      return res.data || [];
+    },
+  });
+  const workOrderList: WorkOrder[] = Array.isArray(workOrders) ? workOrders : [];
+
+  const createWorkOrderMutation = useMutation({
+    mutationFn: async () => {
+      const res = await maintenanceDepthService.createWorkOrder({
+        vehicleId: workOrderForm.vehicleId,
+        title: workOrderForm.title,
+        description: workOrderForm.description || undefined,
+        status: workOrderForm.status,
+        priority: workOrderForm.priority,
+        assignedTo: workOrderForm.assignedTo || undefined,
+        laborCost: Number(workOrderForm.laborCost) || undefined,
+        partsCost: Number(workOrderForm.partsCost) || undefined,
+      });
+      return res.data;
+    },
+    onSuccess: () => {
+      toast({ title: 'Work order created' });
+      queryClient.invalidateQueries({ queryKey: ['maintenance-work-orders'] });
+      setOpenWorkOrderModal(false);
+      setWorkOrderForm(emptyWorkOrder);
+    },
+    onError: (err: any) => {
+      toast({
+        title: 'Error',
+        description: err?.response?.data?.message ?? 'Failed',
+        variant: 'destructive',
+      });
+    },
+  });
+
+  const deleteWorkOrderMutation = useMutation({
+    mutationFn: async (id: string) => {
+      await maintenanceDepthService.deleteWorkOrder(id);
+    },
+    onSuccess: () => {
+      toast({ title: 'Work order deleted' });
+      queryClient.invalidateQueries({ queryKey: ['maintenance-work-orders'] });
+    },
+    onError: (err: any) => {
+      toast({
+        title: 'Error',
+        description: err?.response?.data?.message ?? 'Failed',
+        variant: 'destructive',
+      });
+    },
+  });
+
+  // ---- Parts queries/mutations ----
+  const { data: parts, isLoading: partsLoading } = useQuery({
+    queryKey: ['maintenance-parts', lowStockOnly],
+    queryFn: async () => {
+      const res = await maintenanceDepthService.getParts({ lowStock: lowStockOnly || undefined });
+      return res.data || [];
+    },
+  });
+  const partList: Part[] = Array.isArray(parts) ? parts : [];
+
+  const savePartMutation = useMutation({
+    mutationFn: async () => {
+      const payload = {
+        name: partForm.name,
+        sku: partForm.sku || undefined,
+        category: partForm.category || undefined,
+        quantityInStock: Number(partForm.quantityInStock) || 0,
+        reorderLevel: Number(partForm.reorderLevel) || 0,
+        unitCost: Number(partForm.unitCost) || undefined,
+        location: partForm.location || undefined,
+      };
+      if (editingPartId) {
+        const res = await maintenanceDepthService.updatePart(editingPartId, payload);
+        return res.data;
+      }
+      const res = await maintenanceDepthService.createPart(payload);
+      return res.data;
+    },
+    onSuccess: () => {
+      toast({ title: editingPartId ? 'Part updated' : 'Part created' });
+      queryClient.invalidateQueries({ queryKey: ['maintenance-parts'] });
+      setOpenPartModal(false);
+      setPartForm(emptyPart);
+      setEditingPartId(null);
+    },
+    onError: (err: any) => {
+      toast({
+        title: 'Error',
+        description: err?.response?.data?.message ?? 'Failed',
+        variant: 'destructive',
+      });
+    },
+  });
+
+  const deletePartMutation = useMutation({
+    mutationFn: async (id: string) => {
+      await maintenanceDepthService.deletePart(id);
+    },
+    onSuccess: () => {
+      toast({ title: 'Part deleted' });
+      queryClient.invalidateQueries({ queryKey: ['maintenance-parts'] });
+    },
+    onError: (err: any) => {
+      toast({
+        title: 'Error',
+        description: err?.response?.data?.message ?? 'Failed',
+        variant: 'destructive',
+      });
+    },
+  });
+
+  // ---- Warranties queries/mutations ----
+  const { data: warranties, isLoading: warrantiesLoading } = useQuery({
+    queryKey: ['maintenance-warranties'],
+    queryFn: async () => {
+      const res = await maintenanceDepthService.getWarranties();
+      return res.data || [];
+    },
+  });
+  const warrantyList: Warranty[] = Array.isArray(warranties) ? warranties : [];
+
+  const createWarrantyMutation = useMutation({
+    mutationFn: async () => {
+      const res = await maintenanceDepthService.createWarranty({
+        vehicleId: warrantyForm.vehicleId,
+        component: warrantyForm.component,
+        provider: warrantyForm.provider || undefined,
+        startDate: warrantyForm.startDate || undefined,
+        expiryDate: warrantyForm.expiryDate,
+        coverageNotes: warrantyForm.coverageNotes || undefined,
+      });
+      return res.data;
+    },
+    onSuccess: () => {
+      toast({ title: 'Warranty created' });
+      queryClient.invalidateQueries({ queryKey: ['maintenance-warranties'] });
+      setOpenWarrantyModal(false);
+      setWarrantyForm(emptyWarranty);
+    },
+    onError: (err: any) => {
+      toast({
+        title: 'Error',
+        description: err?.response?.data?.message ?? 'Failed',
+        variant: 'destructive',
+      });
+    },
+  });
+
+  const deleteWarrantyMutation = useMutation({
+    mutationFn: async (id: string) => {
+      await maintenanceDepthService.deleteWarranty(id);
+    },
+    onSuccess: () => {
+      toast({ title: 'Warranty deleted' });
+      queryClient.invalidateQueries({ queryKey: ['maintenance-warranties'] });
+    },
+    onError: (err: any) => {
+      toast({
+        title: 'Error',
+        description: err?.response?.data?.message ?? 'Failed',
+        variant: 'destructive',
+      });
+    },
+  });
+
+  const openPartForEdit = (part: Part) => {
+    setEditingPartId(part.id);
+    setPartForm({
+      name: part.name,
+      sku: part.sku || '',
+      category: part.category || 'OTHER',
+      quantityInStock: part.quantityInStock,
+      reorderLevel: part.reorderLevel,
+      unitCost: Number(part.unitCost) || 0,
+      location: part.location || '',
+    });
+    setOpenPartModal(true);
+  };
+
+  const openPartForCreate = () => {
+    setEditingPartId(null);
+    setPartForm(emptyPart);
+    setOpenPartModal(true);
+  };
+
+  return (
+    <Container size="xl" py="xl" px="lg">
+      <Breadcrumbs items={[{ label: 'Fleet' }, { label: 'Maintenance' }, { label: 'Work Orders' }]} />
+
+      <Group justify="space-between" mb="lg">
+        <Title order={1}>Work Orders &amp; Parts</Title>
+      </Group>
+
+      <Tabs value={activeTab} onChange={setActiveTab}>
+        <Tabs.List>
+          <Tabs.Tab value="work-orders" leftSection={<Wrench size={14} />}>
+            Work Orders
+          </Tabs.Tab>
+          <Tabs.Tab value="parts" leftSection={<Package size={14} />}>
+            Parts / Tires
+          </Tabs.Tab>
+          <Tabs.Tab value="warranties" leftSection={<ShieldCheck size={14} />}>
+            Warranties
+          </Tabs.Tab>
+        </Tabs.List>
+
+        {/* ---- Work Orders tab ---- */}
+        <Tabs.Panel value="work-orders" pt="lg">
+          <Group justify="space-between" mb="md">
+            <Select
+              placeholder="All statuses"
+              data={WORK_ORDER_STATUSES}
+              value={statusFilter}
+              onChange={setStatusFilter}
+              clearable
+              w={220}
+            />
+            <Button
+              onClick={() => setOpenWorkOrderModal(true)}
+              color="edr-green"
+              leftSection={<Plus size={16} />}
+            >
+              New Work Order
+            </Button>
+          </Group>
+
+          <Card withBorder>
+            {workOrdersLoading ? (
+              <Group justify="center" p="xl">
+                <Loader />
+              </Group>
+            ) : workOrderList.length > 0 ? (
+              <Table.ScrollContainer minWidth={800}>
+                <Table striped highlightOnHover>
+                  <Table.Thead>
+                    <Table.Tr>
+                      <Table.Th>Title</Table.Th>
+                      <Table.Th>Vehicle</Table.Th>
+                      <Table.Th>Priority</Table.Th>
+                      <Table.Th>Status</Table.Th>
+                      <Table.Th>Assigned</Table.Th>
+                      <Table.Th>Labor</Table.Th>
+                      <Table.Th>Parts</Table.Th>
+                      <Table.Th>Opened</Table.Th>
+                      <Table.Th />
+                    </Table.Tr>
+                  </Table.Thead>
+                  <Table.Tbody>
+                    {workOrderList.map((wo) => (
+                      <Table.Tr key={wo.id}>
+                        <Table.Td>{wo.title}</Table.Td>
+                        <Table.Td>{vehicleLabel(wo.vehicleId)}</Table.Td>
+                        <Table.Td>
+                          <Badge color={priorityColor(wo.priority)}>{wo.priority}</Badge>
+                        </Table.Td>
+                        <Table.Td>
+                          <Badge color={statusColor(wo.status)}>{wo.status}</Badge>
+                        </Table.Td>
+                        <Table.Td>{wo.assignedTo || '—'}</Table.Td>
+                        <Table.Td>{etb(wo.laborCost)}</Table.Td>
+                        <Table.Td>{etb(wo.partsCost)}</Table.Td>
+                        <Table.Td>{new Date(wo.openedAt).toLocaleDateString()}</Table.Td>
+                        <Table.Td>
+                          <ActionIcon
+                            variant="subtle"
+                            color="edr-red"
+                            onClick={() => deleteWorkOrderMutation.mutate(wo.id)}
+                            aria-label="Delete work order"
+                          >
+                            <Trash2 size={16} />
+                          </ActionIcon>
+                        </Table.Td>
+                      </Table.Tr>
+                    ))}
+                  </Table.Tbody>
+                </Table>
+              </Table.ScrollContainer>
+            ) : (
+              <Text c="dimmed" ta="center" p="xl">
+                No work orders yet
+              </Text>
+            )}
+          </Card>
+        </Tabs.Panel>
+
+        {/* ---- Parts / Tires tab ---- */}
+        <Tabs.Panel value="parts" pt="lg">
+          <Group justify="space-between" mb="md">
+            <Switch
+              label="Low stock only"
+              checked={lowStockOnly}
+              onChange={(e) => setLowStockOnly(e.currentTarget.checked)}
+            />
+            <Button onClick={openPartForCreate} color="edr-green" leftSection={<Plus size={16} />}>
+              New Part
+            </Button>
+          </Group>
+
+          <Card withBorder>
+            {partsLoading ? (
+              <Group justify="center" p="xl">
+                <Loader />
+              </Group>
+            ) : partList.length > 0 ? (
+              <Table.ScrollContainer minWidth={800}>
+                <Table striped highlightOnHover>
+                  <Table.Thead>
+                    <Table.Tr>
+                      <Table.Th>Name</Table.Th>
+                      <Table.Th>SKU</Table.Th>
+                      <Table.Th>Category</Table.Th>
+                      <Table.Th>In Stock</Table.Th>
+                      <Table.Th>Reorder Level</Table.Th>
+                      <Table.Th>Unit Cost</Table.Th>
+                      <Table.Th>Location</Table.Th>
+                      <Table.Th />
+                    </Table.Tr>
+                  </Table.Thead>
+                  <Table.Tbody>
+                    {partList.map((p) => (
+                      <Table.Tr key={p.id}>
+                        <Table.Td>{p.name}</Table.Td>
+                        <Table.Td>{p.sku || '—'}</Table.Td>
+                        <Table.Td>
+                          {p.category ? <Badge variant="light">{p.category}</Badge> : '—'}
+                        </Table.Td>
+                        <Table.Td>
+                          <Group gap="xs">
+                            {p.quantityInStock}
+                            {p.quantityInStock <= p.reorderLevel && (
+                              <Badge color="edr-red" size="sm">
+                                Low stock
+                              </Badge>
+                            )}
+                          </Group>
+                        </Table.Td>
+                        <Table.Td>{p.reorderLevel}</Table.Td>
+                        <Table.Td>{etb(p.unitCost)}</Table.Td>
+                        <Table.Td>{p.location || '—'}</Table.Td>
+                        <Table.Td>
+                          <Group gap={4} wrap="nowrap">
+                            <ActionIcon
+                              variant="subtle"
+                              onClick={() => openPartForEdit(p)}
+                              aria-label="Adjust part"
+                            >
+                              <Pencil size={16} />
+                            </ActionIcon>
+                            <ActionIcon
+                              variant="subtle"
+                              color="edr-red"
+                              onClick={() => deletePartMutation.mutate(p.id)}
+                              aria-label="Delete part"
+                            >
+                              <Trash2 size={16} />
+                            </ActionIcon>
+                          </Group>
+                        </Table.Td>
+                      </Table.Tr>
+                    ))}
+                  </Table.Tbody>
+                </Table>
+              </Table.ScrollContainer>
+            ) : (
+              <Text c="dimmed" ta="center" p="xl">
+                No parts in inventory
+              </Text>
+            )}
+          </Card>
+        </Tabs.Panel>
+
+        {/* ---- Warranties tab ---- */}
+        <Tabs.Panel value="warranties" pt="lg">
+          <Group justify="flex-end" mb="md">
+            <Button
+              onClick={() => setOpenWarrantyModal(true)}
+              color="edr-green"
+              leftSection={<Plus size={16} />}
+            >
+              New Warranty
+            </Button>
+          </Group>
+
+          <Card withBorder>
+            {warrantiesLoading ? (
+              <Group justify="center" p="xl">
+                <Loader />
+              </Group>
+            ) : warrantyList.length > 0 ? (
+              <Table.ScrollContainer minWidth={700}>
+                <Table striped highlightOnHover>
+                  <Table.Thead>
+                    <Table.Tr>
+                      <Table.Th>Component</Table.Th>
+                      <Table.Th>Vehicle</Table.Th>
+                      <Table.Th>Provider</Table.Th>
+                      <Table.Th>Start</Table.Th>
+                      <Table.Th>Expiry</Table.Th>
+                      <Table.Th />
+                    </Table.Tr>
+                  </Table.Thead>
+                  <Table.Tbody>
+                    {warrantyList.map((w) => {
+                      const expired = new Date(w.expiryDate) < new Date();
+                      return (
+                        <Table.Tr key={w.id}>
+                          <Table.Td>{w.component}</Table.Td>
+                          <Table.Td>{vehicleLabel(w.vehicleId)}</Table.Td>
+                          <Table.Td>{w.provider || '—'}</Table.Td>
+                          <Table.Td>
+                            {w.startDate ? new Date(w.startDate).toLocaleDateString() : '—'}
+                          </Table.Td>
+                          <Table.Td>
+                            <Group gap="xs">
+                              {new Date(w.expiryDate).toLocaleDateString()}
+                              <Badge color={expired ? 'edr-red' : 'edr-green'} size="sm">
+                                {expired ? 'Expired' : 'Active'}
+                              </Badge>
+                            </Group>
+                          </Table.Td>
+                          <Table.Td>
+                            <ActionIcon
+                              variant="subtle"
+                              color="edr-red"
+                              onClick={() => deleteWarrantyMutation.mutate(w.id)}
+                              aria-label="Delete warranty"
+                            >
+                              <Trash2 size={16} />
+                            </ActionIcon>
+                          </Table.Td>
+                        </Table.Tr>
+                      );
+                    })}
+                  </Table.Tbody>
+                </Table>
+              </Table.ScrollContainer>
+            ) : (
+              <Text c="dimmed" ta="center" p="xl">
+                No warranties recorded
+              </Text>
+            )}
+          </Card>
+        </Tabs.Panel>
+      </Tabs>
+
+      {/* ---- Work Order modal ---- */}
+      <Modal
+        opened={openWorkOrderModal}
+        onClose={() => setOpenWorkOrderModal(false)}
+        title="New Work Order"
+        size="md"
+      >
+        <Stack gap="md">
+          <Select
+            label="Vehicle"
+            placeholder="Pick a vehicle"
+            data={vehicleOptions}
+            value={workOrderForm.vehicleId || null}
+            onChange={(v) => setWorkOrderForm({ ...workOrderForm, vehicleId: v || '' })}
+            searchable
+            required
+          />
+          <TextInput
+            label="Title"
+            placeholder="e.g., Replace front brake pads"
+            value={workOrderForm.title}
+            onChange={(e) => setWorkOrderForm({ ...workOrderForm, title: e.currentTarget.value })}
+            required
+          />
+          <Textarea
+            label="Description"
+            placeholder="Details of the work needed"
+            value={workOrderForm.description}
+            onChange={(e) =>
+              setWorkOrderForm({ ...workOrderForm, description: e.currentTarget.value })
+            }
+          />
+          <Group grow>
+            <Select
+              label="Priority"
+              data={WORK_ORDER_PRIORITIES}
+              value={workOrderForm.priority}
+              onChange={(v) =>
+                setWorkOrderForm({ ...workOrderForm, priority: (v as WorkOrderPriority) || 'MEDIUM' })
+              }
+            />
+            <Select
+              label="Status"
+              data={WORK_ORDER_STATUSES}
+              value={workOrderForm.status}
+              onChange={(v) =>
+                setWorkOrderForm({ ...workOrderForm, status: (v as WorkOrderStatus) || 'OPEN' })
+              }
+            />
+          </Group>
+          <TextInput
+            label="Assigned To"
+            placeholder="e.g., Mechanic name"
+            value={workOrderForm.assignedTo}
+            onChange={(e) =>
+              setWorkOrderForm({ ...workOrderForm, assignedTo: e.currentTarget.value })
+            }
+          />
+          <Group grow>
+            <NumberInput
+              label="Labor Cost (ETB)"
+              min={0}
+              value={workOrderForm.laborCost}
+              onChange={(v) => setWorkOrderForm({ ...workOrderForm, laborCost: Number(v) || 0 })}
+            />
+            <NumberInput
+              label="Parts Cost (ETB)"
+              min={0}
+              value={workOrderForm.partsCost}
+              onChange={(v) => setWorkOrderForm({ ...workOrderForm, partsCost: Number(v) || 0 })}
+            />
+          </Group>
+          <Group justify="flex-end">
+            <Button variant="light" onClick={() => setOpenWorkOrderModal(false)}>
+              Cancel
+            </Button>
+            <Button
+              onClick={() => createWorkOrderMutation.mutate()}
+              loading={createWorkOrderMutation.isPending}
+              disabled={!workOrderForm.vehicleId || !workOrderForm.title}
+            >
+              Create
+            </Button>
+          </Group>
+        </Stack>
+      </Modal>
+
+      {/* ---- Part modal ---- */}
+      <Modal
+        opened={openPartModal}
+        onClose={() => {
+          setOpenPartModal(false);
+          setEditingPartId(null);
+        }}
+        title={editingPartId ? 'Adjust Part' : 'New Part'}
+        size="md"
+      >
+        <Stack gap="md">
+          <TextInput
+            label="Name"
+            placeholder="e.g., 315/80R22.5 Tire"
+            value={partForm.name}
+            onChange={(e) => setPartForm({ ...partForm, name: e.currentTarget.value })}
+            required
+          />
+          <Group grow>
+            <TextInput
+              label="SKU"
+              placeholder="Optional"
+              value={partForm.sku}
+              onChange={(e) => setPartForm({ ...partForm, sku: e.currentTarget.value })}
+            />
+            <Select
+              label="Category"
+              data={PART_CATEGORIES}
+              value={partForm.category}
+              onChange={(v) => setPartForm({ ...partForm, category: v || 'OTHER' })}
+            />
+          </Group>
+          <Group grow>
+            <NumberInput
+              label="Quantity in Stock"
+              min={0}
+              value={partForm.quantityInStock}
+              onChange={(v) => setPartForm({ ...partForm, quantityInStock: Number(v) || 0 })}
+            />
+            <NumberInput
+              label="Reorder Level"
+              min={0}
+              value={partForm.reorderLevel}
+              onChange={(v) => setPartForm({ ...partForm, reorderLevel: Number(v) || 0 })}
+            />
+          </Group>
+          <Group grow>
+            <NumberInput
+              label="Unit Cost (ETB)"
+              min={0}
+              value={partForm.unitCost}
+              onChange={(v) => setPartForm({ ...partForm, unitCost: Number(v) || 0 })}
+            />
+            <TextInput
+              label="Location"
+              placeholder="e.g., Shelf A3"
+              value={partForm.location}
+              onChange={(e) => setPartForm({ ...partForm, location: e.currentTarget.value })}
+            />
+          </Group>
+          <Group justify="flex-end">
+            <Button
+              variant="light"
+              onClick={() => {
+                setOpenPartModal(false);
+                setEditingPartId(null);
+              }}
+            >
+              Cancel
+            </Button>
+            <Button
+              onClick={() => savePartMutation.mutate()}
+              loading={savePartMutation.isPending}
+              disabled={!partForm.name}
+            >
+              {editingPartId ? 'Save' : 'Create'}
+            </Button>
+          </Group>
+        </Stack>
+      </Modal>
+
+      {/* ---- Warranty modal ---- */}
+      <Modal
+        opened={openWarrantyModal}
+        onClose={() => setOpenWarrantyModal(false)}
+        title="New Warranty"
+        size="md"
+      >
+        <Stack gap="md">
+          <Select
+            label="Vehicle"
+            placeholder="Pick a vehicle"
+            data={vehicleOptions}
+            value={warrantyForm.vehicleId || null}
+            onChange={(v) => setWarrantyForm({ ...warrantyForm, vehicleId: v || '' })}
+            searchable
+            required
+          />
+          <TextInput
+            label="Component"
+            placeholder="e.g., Engine, Transmission"
+            value={warrantyForm.component}
+            onChange={(e) => setWarrantyForm({ ...warrantyForm, component: e.currentTarget.value })}
+            required
+          />
+          <TextInput
+            label="Provider"
+            placeholder="e.g., Manufacturer name"
+            value={warrantyForm.provider}
+            onChange={(e) => setWarrantyForm({ ...warrantyForm, provider: e.currentTarget.value })}
+          />
+          <Group grow>
+            <TextInput
+              label="Start Date"
+              type="date"
+              value={warrantyForm.startDate}
+              onChange={(e) =>
+                setWarrantyForm({ ...warrantyForm, startDate: e.currentTarget.value })
+              }
+            />
+            <TextInput
+              label="Expiry Date"
+              type="date"
+              value={warrantyForm.expiryDate}
+              onChange={(e) =>
+                setWarrantyForm({ ...warrantyForm, expiryDate: e.currentTarget.value })
+              }
+              required
+            />
+          </Group>
+          <Textarea
+            label="Coverage Notes"
+            placeholder="What the warranty covers"
+            value={warrantyForm.coverageNotes}
+            onChange={(e) =>
+              setWarrantyForm({ ...warrantyForm, coverageNotes: e.currentTarget.value })
+            }
+          />
+          <Group justify="flex-end">
+            <Button variant="light" onClick={() => setOpenWarrantyModal(false)}>
+              Cancel
+            </Button>
+            <Button
+              onClick={() => createWarrantyMutation.mutate()}
+              loading={createWarrantyMutation.isPending}
+              disabled={!warrantyForm.vehicleId || !warrantyForm.component || !warrantyForm.expiryDate}
+            >
+              Create
+            </Button>
+          </Group>
+        </Stack>
+      </Modal>
+    </Container>
+  );
+}
diff --git a/apps/edr-freight-web/backoffice/src/pages/fleet/config/vehicles.ts b/apps/edr-freight-web/backoffice/src/pages/fleet/config/vehicles.ts
index 5e76584ed..eb1508601 100644
--- a/apps/edr-freight-web/backoffice/src/pages/fleet/config/vehicles.ts
+++ b/apps/edr-freight-web/backoffice/src/pages/fleet/config/vehicles.ts
@@ -29,6 +29,11 @@ const VEHICLE_AVAILABILITY_OPTIONS = [
   { label: "Busy", value: "BUSY" },
 ];
 
+const CURRENCY_OPTIONS = [
+  { label: "ETB", value: "ETB" },
+  { label: "USD", value: "USD" },
+];
+
 export const vehiclesConfig: FleetResourceConfig = {
   slug: "vehicles",
   label: "Vehicles",
@@ -84,12 +89,14 @@ export const vehiclesConfig: FleetResourceConfig = {
     { name: "locationId", label: "Location", type: "select", dynamicOptions: "yards" },
     { name: "estimatedDistanceKm", label: "Estimated Distance (KM)", type: "number" },
     { name: "actualDistanceKm", label: "Actual Distance (KM)", type: "number" },
+    { name: "pricePerKm", label: "Price per KM", type: "number" },
+    { name: "currency", label: "Currency", type: "radio", options: CURRENCY_OPTIONS },
     { name: "status", label: "Status", type: "select", required: true, options: VEHICLE_STATUS_OPTIONS },
     { name: "availability", label: "Availability", type: "select", required: true, options: VEHICLE_AVAILABILITY_OPTIONS },
     { name: "description", label: "Description", type: "textarea" },
   ],
   emptyValues: {
-    code: "",
+    code: "03-ET",
     plateNumber: "",
     powerPlateNo: "",
     trailerPlateNo: "",
@@ -102,6 +109,8 @@ export const vehiclesConfig: FleetResourceConfig = {
     locationId: null,
     estimatedDistanceKm: "",
     actualDistanceKm: "",
+    pricePerKm: "",
+    currency: "ETB",
     status: "ACTIVE",
     availability: "FREE",
     description: "",
diff --git a/apps/edr-freight-web/backoffice/src/pages/operations/FirstMilePage.tsx b/apps/edr-freight-web/backoffice/src/pages/operations/FirstMilePage.tsx
index 2b130848c..a8c55ecf4 100644
--- a/apps/edr-freight-web/backoffice/src/pages/operations/FirstMilePage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/operations/FirstMilePage.tsx
@@ -20,7 +20,7 @@ import type { ColumnDef } from "@edr/ui-common";
 import { DataTable, DataTableFooter, usePagination } from "@edr/ui-common";
 import {
   ActionIcon,
-  Autocomplete,
+  Alert,
   Badge,
   Box,
   Button,
@@ -54,7 +54,6 @@ import {
 } from "@/services/first-mile.service";
 import { bookingsService } from "@/services/bookings.service";
 import { vehiclesService } from "@/services/vehicles.service";
-import { ratesService } from "@/services/rates.service";
 import type { BookingDetail } from "@/types/booking";
 
 const formatPrice = (amount: number | string | null | undefined, currency = "ETB") =>
@@ -191,7 +190,24 @@ const isPostPaymentPending = (r: FirstMileRecord) =>
 
 // Map API record → display fields used in modals and trip slip
 const bookingRef = (r: FirstMileRecord) => r.booking?.reference ?? r.bookingId;
-const currencyOf = (r: FirstMileRecord) => r.booking?.paymentCurrency ?? "ETB";
+const currencyOf = (r: FirstMileRecord) =>
+  r.vehicle?.currency ??
+  r.vehicleAssignments?.[0]?.vehicle?.currency ??
+  r.booking?.paymentCurrency ??
+  "ETB";
+
+type FmAssignment = NonNullable<FirstMileRecord["vehicleAssignments"]>[number];
+const truckShort = (a: FmAssignment) =>
+  a.vehicle ? [a.vehicle.code, a.vehicle.plateNumber].filter(Boolean).join(" · ") : a.vehicleId;
+/** Billing problems on the trucks that have distance: zero price/km, mixed currency. */
+const billingIssues = (r: FirstMileRecord) => {
+  const trucks = (r.vehicleAssignments ?? []).filter((a) => Number(a.distanceKm) > 0);
+  const zeroPrice = trucks.filter((a) => !(Number(a.vehicle?.pricePerKm) > 0)).map(truckShort);
+  const currencies = [
+    ...new Set(trucks.map((a) => a.vehicle?.currency).filter((c): c is string => Boolean(c))),
+  ];
+  return { zeroPrice, mixedCurrency: currencies.length > 1, currencies };
+};
 const customerName = (r: FirstMileRecord) => r.booking?.company?.name ?? "—";
 const pickupLocation = (r: FirstMileRecord) => r.booking?.firstMilePickupAddress ?? "—";
 const cargoDesc = (r: FirstMileRecord) => {
@@ -480,6 +496,8 @@ const FirstMilePage = () => {
   const [distanceOpen, setDistanceOpen] = useState(false);
   // Per-vehicle actual distance, keyed by vehicleId.
   const [distanceRows, setDistanceRows] = useState<Record<string, string>>({});
+  // Record pending invoice-generation confirmation (shows a summary first).
+  const [invoiceConfirm, setInvoiceConfirm] = useState<FirstMileRecord | null>(null);
   const [warehouseReceiveOpen, setWarehouseReceiveOpen] = useState(false);
   const [warehouseReceiveRecord, setWarehouseReceiveRecord] = useState<FirstMileRecord | null>(null);
 
@@ -500,14 +518,6 @@ const FirstMilePage = () => {
     },
   });
 
-  const { data: ratesData } = useQuery({
-    queryKey: ["rates", "FIRST_MILE"],
-    queryFn: async () => {
-      const res = await ratesService.getByType("FIRST_MILE");
-      return res.data;
-    },
-  });
-
   const { data: paidBookingsData, isLoading: bookingsLoading } = useQuery({
     queryKey: QUERY_KEYS.BOOKINGS.list({ status: "PAID" }),
     queryFn: () => bookingsService.list({ status: "PAID", pageSize: 100 }),
@@ -572,10 +582,17 @@ const FirstMilePage = () => {
       distances: Array<{ vehicleId: string; distanceKm: number }>;
       remainingPayment?: number;
     }) => firstMileService.setDistances(id, distances, remainingPayment),
-    onSuccess: () => {
+    onSuccess: (res) => {
       void qc.invalidateQueries({ queryKey: QUERY_KEYS.FIRST_MILE.list() });
       toast({ title: "Distances saved", description: activeRecord ? bookingRef(activeRecord) : undefined });
+      const updated = res?.data as FirstMileRecord | undefined;
       closeDistance();
+      // Every truck has a distance and it isn't billed yet → offer to invoice now.
+      const trucks = updated?.vehicleAssignments ?? [];
+      const allFilled = trucks.length > 0 && trucks.every((a) => Number(a.distanceKm) > 0);
+      if (updated && allFilled && !updated.invoice) {
+        setInvoiceConfirm(updated);
+      }
     },
     onError: () => {
       toast({ title: "Update failed", variant: "destructive" });
@@ -783,18 +800,9 @@ const FirstMilePage = () => {
       return;
     }
 
-    const total = distances.reduce((s, d) => s + d.distanceKm, 0);
-    let remainingPayment: number | undefined;
-    if (ratesData?.data) {
-      const firstMileRate = ratesData.data.find(
-        (r) => r.rateType === "FIRST_MILE" && (r.status === "LIVE" || r.status === "DRAFT")
-      );
-      if (firstMileRate) {
-        remainingPayment = total * parseFloat(firstMileRate.rateValue);
-      }
-    }
-
-    setDistancesMutation.mutate({ id: activeId, distances, remainingPayment });
+    // Amount is computed server-side per truck (distance × the vehicle's
+    // price/km, in the vehicle's currency) — no flat FIRST_MILE rate.
+    setDistancesMutation.mutate({ id: activeId, distances });
   };
 
   const matchesFilter = (r: FirstMileRecord) => {
@@ -849,6 +857,33 @@ const FirstMilePage = () => {
     return filteredRecords.slice(start, start + pagination.pageSize);
   }, [filteredRecords, pagination]);
 
+  // Billing problems on the leg pending invoice confirmation.
+  const confirmIssues = invoiceConfirm
+    ? billingIssues(invoiceConfirm)
+    : { zeroPrice: [] as string[], mixedCurrency: false, currencies: [] as string[] };
+
+  // Guard invoice generation: block mixed currency, warn (but proceed) on trucks
+  // priced at 0/km.
+  const handleGenerateInvoice = (r: FirstMileRecord) => {
+    const { zeroPrice, mixedCurrency, currencies } = billingIssues(r);
+    if (mixedCurrency) {
+      toast({
+        title: "Mixed truck currencies",
+        description: `Trucks use ${currencies.join(", ")}. Assign trucks that share one currency.`,
+        variant: "destructive",
+      });
+      return;
+    }
+    if (zeroPrice.length) {
+      toast({
+        title: "Truck has no price/km",
+        description: `${zeroPrice.join(", ")} will bill 0 — set Price per KM on the vehicle.`,
+        variant: "destructive",
+      });
+    }
+    generateInvoiceMutation.mutate(r.id);
+  };
+
   const openAssign = (id: string | null) => {
     const resolved = id ?? filteredRecords.find((r) => !isAssigned(r))?.id ?? null;
     const rec = records.find((r) => r.id === resolved);
@@ -1173,7 +1208,7 @@ const FirstMilePage = () => {
                       !(row.original.exactKm != null && row.original.exactKm > 0) ||
                       Boolean(row.original.invoice)
                     }
-                    onClick={() => generateInvoiceMutation.mutate(row.original.id)}
+                    onClick={() => handleGenerateInvoice(row.original)}
                   >
                     {row.original.invoice ? "Invoice generated" : "Generate Invoice"}
                   </Menu.Item>
@@ -1337,21 +1372,29 @@ const FirstMilePage = () => {
                   clearable
                   disabled={assignVehicleOptions.length === 0}
                 />
-                <Autocomplete
+                <Select
                   style={{ flex: 1 }}
                   label={i === 0 ? "Container no." : undefined}
-                  placeholder="Container number"
-                  data={containerOptions.filter(
-                    (n) =>
-                      n === row.containerNumber ||
-                      !vehicleRows.some((r, idx) => idx !== i && r.containerNumber === n),
-                  )}
-                  value={row.containerNumber}
+                  placeholder={containerOptions.length ? "Select container" : "No container numbers"}
+                  data={[
+                    ...containerOptions.filter(
+                      (n) =>
+                        n === row.containerNumber ||
+                        !vehicleRows.some((r, idx) => idx !== i && r.containerNumber === n),
+                    ),
+                    // keep a manual/legacy value selectable even if not in the booking
+                    ...(row.containerNumber && !containerOptions.includes(row.containerNumber)
+                      ? [row.containerNumber]
+                      : []),
+                  ]}
+                  value={row.containerNumber || null}
                   onChange={(value) =>
                     setVehicleRows((prev) =>
-                      prev.map((x, idx) => (idx === i ? { ...x, containerNumber: value } : x)),
+                      prev.map((x, idx) => (idx === i ? { ...x, containerNumber: value ?? "" } : x)),
                     )
                   }
+                  searchable
+                  clearable
                 />
                 {vehicleRows.length > 1 && (
                   <ActionIcon
@@ -1740,6 +1783,77 @@ const FirstMilePage = () => {
           </Group>
         </Stack>
       </Modal>
+
+      {/* Generate Invoice — confirmation summary */}
+      <Modal
+        opened={Boolean(invoiceConfirm)}
+        onClose={() => setInvoiceConfirm(null)}
+        title={<Text fw={600}>Generate Invoice</Text>}
+        size="md"
+        radius="lg"
+        centered
+      >
+        {invoiceConfirm && (
+          <Stack gap="md">
+            <Group justify="space-between">
+              <Text fw={600} size="sm">{bookingRef(invoiceConfirm)}</Text>
+              <Text size="sm" c="dimmed">{customerName(invoiceConfirm)}</Text>
+            </Group>
+            <Card withBorder padding="sm" radius="md" bg="var(--mantine-color-gray-0)">
+              <Stack gap={6}>
+                {(invoiceConfirm.vehicleAssignments ?? []).map((a) => {
+                  const v = a.vehicle;
+                  const label = v ? [v.code, v.plateNumber].filter(Boolean).join(" · ") : a.vehicleId;
+                  return (
+                    <Group key={a.id} justify="space-between" wrap="nowrap">
+                      <Text size="sm">
+                        {label}
+                        {a.containerNumber ? ` · ${a.containerNumber}` : ""}
+                      </Text>
+                      <Text size="sm">{a.distanceKm != null ? `${a.distanceKm} km` : "—"}</Text>
+                    </Group>
+                  );
+                })}
+              </Stack>
+            </Card>
+            <Group justify="space-between">
+              <Text size="sm" c="dimmed">Total distance</Text>
+              <Text size="sm" fw={500}>{invoiceConfirm.exactKm ?? 0} km</Text>
+            </Group>
+            <Group justify="space-between">
+              <Text fw={600}>Invoice amount</Text>
+              <Text fw={700}>{formatPrice(invoiceConfirm.remainingPayment, currencyOf(invoiceConfirm))}</Text>
+            </Group>
+            {confirmIssues.mixedCurrency && (
+              <Alert color="red" variant="light" title="Mixed truck currencies">
+                Trucks use {confirmIssues.currencies.join(", ")}. Assign trucks that share one currency before invoicing.
+              </Alert>
+            )}
+            {confirmIssues.zeroPrice.length > 0 && (
+              <Alert color="yellow" variant="light" title="Truck has no price/km">
+                {confirmIssues.zeroPrice.join(", ")} will bill 0 — set Price per KM on the vehicle.
+              </Alert>
+            )}
+            <Text size="xs" c="dimmed">
+              Generate the delivery-fee invoice now, or close and generate later from the row actions.
+            </Text>
+            <Group justify="flex-end" gap="sm">
+              <Button variant="default" onClick={() => setInvoiceConfirm(null)}>Later</Button>
+              <Button
+                loading={generateInvoiceMutation.isPending}
+                disabled={confirmIssues.mixedCurrency}
+                onClick={() =>
+                  generateInvoiceMutation.mutate(invoiceConfirm.id, {
+                    onSuccess: () => setInvoiceConfirm(null),
+                  })
+                }
+              >
+                Generate Invoice
+              </Button>
+            </Group>
+          </Stack>
+        )}
+      </Modal>
     </Stack>
   );
 };
diff --git a/apps/edr-freight-web/backoffice/src/pages/operations/LastMilePage.tsx b/apps/edr-freight-web/backoffice/src/pages/operations/LastMilePage.tsx
index 4b5cec080..983745705 100644
--- a/apps/edr-freight-web/backoffice/src/pages/operations/LastMilePage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/operations/LastMilePage.tsx
@@ -19,7 +19,6 @@ import { DataTable, DataTableFooter, usePagination } from "@edr/ui-common";
 import {
   ActionIcon,
   Alert,
-  Autocomplete,
   Badge,
   Box,
   Button,
@@ -56,8 +55,8 @@ import {
 } from "@/services/last-mile.service";
 import { vehiclesService } from "@/services/vehicles.service";
 import { driversService, type Driver } from "@/services/drivers.service";
-import { ratesService } from "@/services/rates.service";
 import { ReleaseOrderModal, type ReleaseOrderTruckPrefill } from "@/components/warehouses/ReleaseOrderModal";
+import { TruckDetentionModal } from "@/components/operations/TruckDetentionModal";
 import { LastMileStepper, type LastMileStepState } from "@/components/operations/LastMileSteps";
 
 const formatPrice = (amount: number | string | null | undefined, currency = "ETB") =>
@@ -233,7 +232,24 @@ const computeLastMileSteps = (
 };
 
 const bookingRef = (r: LastMileRecord) => r.booking?.reference ?? r.bookingId;
-const currencyOf = (r: LastMileRecord) => r.booking?.paymentCurrency ?? "ETB";
+const currencyOf = (r: LastMileRecord) =>
+  r.vehicle?.currency ??
+  r.vehicleAssignments?.[0]?.vehicle?.currency ??
+  r.booking?.paymentCurrency ??
+  "ETB";
+
+type LmAssignment = NonNullable<LastMileRecord["vehicleAssignments"]>[number];
+const truckShort = (a: LmAssignment) =>
+  a.vehicle ? [a.vehicle.code, a.vehicle.plateNumber].filter(Boolean).join(" · ") : a.vehicleId;
+/** Billing problems on the trucks that have distance: zero price/km, mixed currency. */
+const billingIssues = (r: LastMileRecord) => {
+  const trucks = (r.vehicleAssignments ?? []).filter((a) => Number(a.distanceKm) > 0);
+  const zeroPrice = trucks.filter((a) => !(Number(a.vehicle?.pricePerKm) > 0)).map(truckShort);
+  const currencies = [
+    ...new Set(trucks.map((a) => a.vehicle?.currency).filter((c): c is string => Boolean(c))),
+  ];
+  return { zeroPrice, mixedCurrency: currencies.length > 1, currencies };
+};
 const customerName = (r: LastMileRecord) => r.booking?.company?.name ?? "—";
 const deliveryLocation = (r: LastMileRecord) => r.booking?.lastMileDeliveryAddress ?? "—";
 const cargoDesc = (r: LastMileRecord) => {
@@ -544,6 +560,7 @@ const LastMilePage = () => {
   const [tripSlipVehicleId, setTripSlipVehicleId] = useState<string | null>(null);
   const [tripSlipSelectOpen, setTripSlipSelectOpen] = useState(false);
   const [activeId, setActiveId] = useState<string | null>(null);
+  const [detentionRecord, setDetentionRecord] = useState<LastMileRecord | null>(null);
   // Multi-vehicle assign: one row per truck — vehicle + the container it carries.
   const [vehicleRows, setVehicleRows] = useState<
     Array<{ vehicleId: string | null; containerNumber: string }>
@@ -581,14 +598,6 @@ const LastMilePage = () => {
     },
   });
 
-  const { data: ratesData } = useQuery({
-    queryKey: ["rates", "LAST_MILE"],
-    queryFn: async () => {
-      const res = await ratesService.getByType("LAST_MILE");
-      return res.data;
-    },
-  });
-
   const records = listData?.data ?? [];
   const existingLastMileBookingIds = useMemo(
     () => new Set(records.map((record) => record.bookingId)),
@@ -667,10 +676,17 @@ const LastMilePage = () => {
       distances: Array<{ vehicleId: string; distanceKm: number }>;
       remainingPayment?: number;
     }) => lastMileService.setDistances(id, distances, remainingPayment),
-    onSuccess: () => {
+    onSuccess: (res) => {
       void qc.invalidateQueries({ queryKey: QUERY_KEYS.LAST_MILE.ROOT });
       toast({ title: "Distances saved", description: activeRecord ? bookingRef(activeRecord) : undefined });
+      const updated = res?.data as LastMileRecord | undefined;
       closeDistance();
+      // Every truck has a distance and it isn't billed yet → offer to invoice now.
+      const trucks = updated?.vehicleAssignments ?? [];
+      const allFilled = trucks.length > 0 && trucks.every((a) => Number(a.distanceKm) > 0);
+      if (updated && allFilled && !updated.invoice) {
+        setInvoiceConfirm(updated);
+      }
     },
     onError: () => {
       toast({ title: "Update failed", variant: "destructive" });
@@ -802,18 +818,9 @@ const LastMilePage = () => {
       return;
     }
 
-    const total = distances.reduce((s, d) => s + d.distanceKm, 0);
-    let remainingPayment: number | undefined;
-    if (ratesData?.data) {
-      const lastMileRate = ratesData.data.find(
-        (r) => r.rateType === "LAST_MILE" && (r.status === "LIVE" || r.status === "DRAFT")
-      );
-      if (lastMileRate) {
-        remainingPayment = total * parseFloat(lastMileRate.rateValue);
-      }
-    }
-
-    distanceMutation.mutate({ id: activeId, distances, remainingPayment });
+    // Amount is computed server-side per truck (distance × the vehicle's
+    // price/km, in the vehicle's currency) — no flat LAST_MILE rate.
+    distanceMutation.mutate({ id: activeId, distances });
   };
 
   const activeRecord = useMemo(
@@ -929,6 +936,11 @@ const LastMilePage = () => {
     [records],
   );
 
+  // Billing problems on the leg pending invoice confirmation.
+  const confirmIssues = invoiceConfirm
+    ? billingIssues(invoiceConfirm)
+    : { zeroPrice: [] as string[], mixedCurrency: false, currencies: [] as string[] };
+
   const filteredRecords = useMemo(() => {
     const term = search.trim().toLowerCase();
     return records.filter((r) => {
@@ -1360,6 +1372,16 @@ const LastMilePage = () => {
                   >
                     {row.original.invoice ? "Invoice generated" : "Generate Invoice"}
                   </Menu.Item>
+                  {/* Truck detention: set/adjust arrival & return times, preview the
+                      per-truck-per-day charge, and generate its invoice. Available
+                      once the vehicle is en route/delivered (clock has a start). */}
+                  <Menu.Item
+                    leftSection={<Receipt size={15} />}
+                    disabled={!pastTransit}
+                    onClick={() => setDetentionRecord(row.original)}
+                  >
+                    Truck detention
+                  </Menu.Item>
                   {canPrint && (
                     <Menu.Item
                       leftSection={<Printer size={15} />}
@@ -1697,21 +1719,29 @@ const LastMilePage = () => {
                   clearable
                   disabled={assignVehicleOptions.length === 0}
                 />
-                <Autocomplete
+                <Select
                   style={{ flex: 1 }}
                   label={i === 0 ? "Container no." : undefined}
-                  placeholder="Container number"
-                  data={containerOptions.filter(
-                    (n) =>
-                      n === row.containerNumber ||
-                      !vehicleRows.some((r, idx) => idx !== i && r.containerNumber === n),
-                  )}
-                  value={row.containerNumber}
+                  placeholder={containerOptions.length ? "Select container" : "No container numbers"}
+                  data={[
+                    ...containerOptions.filter(
+                      (n) =>
+                        n === row.containerNumber ||
+                        !vehicleRows.some((r, idx) => idx !== i && r.containerNumber === n),
+                    ),
+                    // keep a manual/legacy value selectable even if not in the booking
+                    ...(row.containerNumber && !containerOptions.includes(row.containerNumber)
+                      ? [row.containerNumber]
+                      : []),
+                  ]}
+                  value={row.containerNumber || null}
                   onChange={(value) =>
                     setVehicleRows((prev) =>
-                      prev.map((x, idx) => (idx === i ? { ...x, containerNumber: value } : x)),
+                      prev.map((x, idx) => (idx === i ? { ...x, containerNumber: value ?? "" } : x)),
                     )
                   }
+                  searchable
+                  clearable
                 />
                 {vehicleRows.length > 1 && (
                   <ActionIcon
@@ -1993,6 +2023,16 @@ const LastMilePage = () => {
               <Text fw={600}>Invoice amount</Text>
               <Text fw={700}>{formatPrice(invoiceConfirm.remainingPayment, currencyOf(invoiceConfirm))}</Text>
             </Group>
+            {confirmIssues.mixedCurrency && (
+              <Alert color="red" variant="light" title="Mixed truck currencies">
+                Trucks use {confirmIssues.currencies.join(", ")}. Assign trucks that share one currency before invoicing.
+              </Alert>
+            )}
+            {confirmIssues.zeroPrice.length > 0 && (
+              <Alert color="yellow" variant="light" title="Truck has no price/km">
+                {confirmIssues.zeroPrice.join(", ")} will bill 0 — set Price per KM on the vehicle.
+              </Alert>
+            )}
             <Text size="xs" c="dimmed">
               This creates the delivery-fee invoice. Confirm the distances and amount are correct.
             </Text>
@@ -2000,6 +2040,7 @@ const LastMilePage = () => {
               <Button variant="default" onClick={() => setInvoiceConfirm(null)}>Cancel</Button>
               <Button
                 loading={generateInvoiceMutation.isPending}
+                disabled={confirmIssues.mixedCurrency}
                 onClick={() =>
                   generateInvoiceMutation.mutate(invoiceConfirm.id, {
                     onSuccess: () => setInvoiceConfirm(null),
@@ -2019,6 +2060,12 @@ const LastMilePage = () => {
         item={releaseItem}
         truckPrefill={releaseTruckPrefill}
       />
+
+      <TruckDetentionModal
+        opened={Boolean(detentionRecord)}
+        onClose={() => setDetentionRecord(null)}
+        record={detentionRecord}
+      />
     </Stack>
   );
 };
diff --git a/apps/edr-freight-web/backoffice/src/pages/ruleEngine/config/resources.ts b/apps/edr-freight-web/backoffice/src/pages/ruleEngine/config/resources.ts
index 2014f9c65..1bc12b06b 100644
--- a/apps/edr-freight-web/backoffice/src/pages/ruleEngine/config/resources.ts
+++ b/apps/edr-freight-web/backoffice/src/pages/ruleEngine/config/resources.ts
@@ -15,7 +15,7 @@ export type ColumnFormat =
   | "entityLabel"
   | "rateLabel";
 
-export type FormFieldType = "text" | "number" | "boolean" | "date" | "email" | "select" | "multiselect" | "textarea";
+export type FormFieldType = "text" | "number" | "boolean" | "date" | "email" | "select" | "multiselect" | "textarea" | "radio";
 
 export interface ResourceColumn {
   id: string;
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 b5c44e4d4..0e91407dc 100644
--- a/apps/edr-freight-web/backoffice/src/pages/warehouses/WarehouseRulesPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/warehouses/WarehouseRulesPage.tsx
@@ -32,7 +32,21 @@ import {
   useFeeRules,
 } from '@/hooks/useWarehouses';
 import { api } from '@/services/api';
-import { FEE_RULE_TYPES, type FeeRuleType } from '@/types/warehouse';
+import {
+  FEE_RULE_BASES,
+  FEE_RULE_BASIS_LABELS,
+  FEE_RULE_TYPES,
+  FEE_RULE_TYPE_LABELS,
+  type FeeRuleBasis,
+  type FeeRuleType,
+} from '@/types/warehouse';
+
+const RULE_TYPE_COLOR: Record<FeeRuleType, string> = {
+  STORAGE_FEE: 'teal',
+  DEMURRAGE_FEE: 'orange',
+  DOUBLE_HANDLING_FEE: 'grape',
+  TRUCK_DETENTION_FEE: 'blue',
+};
 import { extractErrorMessage, lettersOnly } from '@/components/warehouses/options';
 
 const FREIGHT = [
@@ -353,11 +367,13 @@ function FeeRules() {
   const [form, setForm] = useState({
     name: '',
     ruleType: 'DEMURRAGE_FEE' as FeeRuleType,
+    basis: 'PER_CONTAINER' as FeeRuleBasis,
     freightType: '',
     tradeDirection: '',
     cargoTypeCode: '',
     containerType: '',
     freeDays: 3,
+    freeHours: 3,
     ratePerDay: 0,
     tiers: [] as Array<{ fromDay: number; toDay: number | null; ratePerDay: number }>,
     currency: 'USD',
@@ -367,16 +383,24 @@ function FeeRules() {
   const containerTypeOptions = codeOptions(containerTypes);
   const isBulkRule = form.freightType === 'BULK';
   const isContainerRule = form.freightType === 'CONTAINER';
+  // Double handling is a flat per-unit charge (basis × rate), not day-based:
+  // no free days, no progressive tiers.
+  const isDoubleHandling = form.ruleType === 'DOUBLE_HANDLING_FEE';
+  // Truck detention: per truck per day after an HOURS-based grace (default 3h),
+  // with day tiers. Uses "free hours" instead of "free days".
+  const isTruckDetention = form.ruleType === 'TRUCK_DETENTION_FEE';
 
   const resetForm = () =>
     setForm({
       name: '',
       ruleType: 'DEMURRAGE_FEE',
+      basis: 'PER_CONTAINER',
       freightType: '',
       tradeDirection: '',
       cargoTypeCode: '',
       containerType: '',
       freeDays: 3,
+      freeHours: 3,
       ratePerDay: 0,
       tiers: [],
       currency: 'USD',
@@ -440,10 +464,13 @@ function FeeRules() {
       tradeDirection: clean(form.tradeDirection) ?? null,
       cargoTypeCode: isBulkRule ? (clean(form.cargoTypeCode) ?? null) : null,
       containerType: isContainerRule ? (clean(form.containerType) ?? null) : null,
-      freeDays: form.freeDays,
+      // Double handling: flat basis × rate. Truck detention: HOURS-based grace.
+      freeDays: isDoubleHandling || isTruckDetention ? 0 : form.freeDays,
       ratePerDay: form.ratePerDay,
       currency: form.currency || 'USD',
-      ...(tiers.length ? { tiers } : {}),
+      ...(isDoubleHandling ? { basis: form.basis } : {}),
+      ...(isTruckDetention ? { freeHours: form.freeHours } : {}),
+      ...(!isDoubleHandling && tiers.length ? { tiers } : {}),
     };
 
     try {
@@ -514,8 +541,8 @@ function FeeRules() {
               {rules.map((rule) => (
                 <Table.Tr key={rule.id}>
                   <Table.Td>
-                    <Badge color={rule.ruleType === 'DEMURRAGE_FEE' ? 'orange' : 'teal'} variant="light">
-                      {rule.ruleType === 'DEMURRAGE_FEE' ? 'Demurrage' : 'Storage'}
+                    <Badge color={RULE_TYPE_COLOR[rule.ruleType] ?? 'gray'} variant="light">
+                      {FEE_RULE_TYPE_LABELS[rule.ruleType] ?? rule.ruleType}
                     </Badge>
                   </Table.Td>
                   <Table.Td>{rule.name}</Table.Td>
@@ -577,7 +604,7 @@ function FeeRules() {
               label="Rule type"
               data={FEE_RULE_TYPES.map((type) => ({
                 value: type,
-                label: type === 'DEMURRAGE_FEE' ? 'Demurrage' : 'Storage',
+                label: FEE_RULE_TYPE_LABELS[type],
               }))}
               value={form.ruleType}
               onChange={(value) =>
@@ -637,14 +664,34 @@ function FeeRules() {
             />
           )}
           <Group grow>
+            {isDoubleHandling ? (
+              <Select
+                label="Basis"
+                data={FEE_RULE_BASES.map((b) => ({ value: b, label: FEE_RULE_BASIS_LABELS[b] }))}
+                value={form.basis}
+                onChange={(value) =>
+                  setForm((f) => ({ ...f, basis: selectValue(value, 'PER_CONTAINER') as FeeRuleBasis }))
+                }
+                allowDeselect={false}
+              />
+            ) : isTruckDetention ? (
+              <NumberInput
+                label="Free hours"
+                description="Grace before detention accrues"
+                min={0}
+                value={form.freeHours}
+                onChange={(value) => setForm((f) => ({ ...f, freeHours: numberValue(value) }))}
+              />
+            ) : (
+              <NumberInput
+                label="Free days"
+                min={0}
+                value={form.freeDays}
+                onChange={(value) => setForm((f) => ({ ...f, freeDays: numberValue(value) }))}
+              />
+            )}
             <NumberInput
-              label="Free days"
-              min={0}
-              value={form.freeDays}
-              onChange={(value) => setForm((f) => ({ ...f, freeDays: numberValue(value) }))}
-            />
-            <NumberInput
-              label="Rate / day"
+              label={isDoubleHandling ? 'Rate / unit' : 'Rate / day'}
               min={0}
               value={form.ratePerDay}
               onChange={(value) => setForm((f) => ({ ...f, ratePerDay: numberValue(value) }))}
@@ -657,6 +704,13 @@ function FeeRules() {
               allowDeselect={false}
             />
           </Group>
+          {isDoubleHandling && (
+            <Text size="xs" c="dimmed">
+              Flat charge — the rate is multiplied by the selected basis (
+              {FEE_RULE_BASIS_LABELS[form.basis]}). No free days or progressive tiers.
+            </Text>
+          )}
+          {!isDoubleHandling && (
           <Stack gap="xs">
             <Group justify="space-between">
               <Text size="sm" fw={600}>
@@ -702,6 +756,7 @@ function FeeRules() {
               </Text>
             )}
           </Stack>
+          )}
           <Group justify="flex-end" mt="sm">
             <Button variant="default" onClick={() => setOpen(false)}>
               Cancel
diff --git a/apps/edr-freight-web/backoffice/src/services/compliance.service.ts b/apps/edr-freight-web/backoffice/src/services/compliance.service.ts
new file mode 100644
index 000000000..a73494c2a
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/services/compliance.service.ts
@@ -0,0 +1,73 @@
+import { api as apiClient } from '../auth/http';
+
+export type ComplianceType =
+  | 'INSPECTION'
+  | 'INSURANCE'
+  | 'ROADWORTHINESS'
+  | 'PERMIT'
+  | 'TAX';
+
+export type ComplianceStatus = 'VALID' | 'EXPIRING' | 'EXPIRED';
+
+export type AlertSeverity = 'OVERDUE' | 'DUE_SOON';
+
+export interface ComplianceRecord {
+  id: string;
+  vehicleId: string;
+  vehicle?: {
+    id: string;
+    plateNumber?: string | null;
+    manufacturer?: string | null;
+    model?: string | null;
+  };
+  type: ComplianceType;
+  documentNumber?: string | null;
+  issuedDate?: string | null;
+  expiryDate: string;
+  status: ComplianceStatus;
+  notes?: string | null;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface ComplianceAlert {
+  vehicleId: string;
+  vehiclePlate?: string;
+  kind: string;
+  label: string;
+  expiryDate: string;
+  daysUntil: number;
+  severity: AlertSeverity;
+}
+
+export interface ComplianceListFilters {
+  vehicleId?: string;
+  type?: ComplianceType;
+}
+
+export interface SaveCompliancePayload {
+  vehicleId: string;
+  type: ComplianceType;
+  documentNumber?: string;
+  issuedDate?: string;
+  expiryDate: string;
+  status?: ComplianceStatus;
+  notes?: string;
+}
+
+export const complianceService = {
+  list: (filters: ComplianceListFilters = {}) => {
+    const params = new URLSearchParams();
+    if (filters.vehicleId) params.set('vehicleId', filters.vehicleId);
+    if (filters.type) params.set('type', filters.type);
+    const qs = params.toString();
+    return apiClient.get<ComplianceRecord[]>(`/compliance${qs ? `?${qs}` : ''}`);
+  },
+  getAlerts: () => apiClient.get<ComplianceAlert[]>('/compliance/alerts'),
+  getById: (id: string) => apiClient.get<ComplianceRecord>(`/compliance/${id}`),
+  create: (data: SaveCompliancePayload) =>
+    apiClient.post<ComplianceRecord>('/compliance', data),
+  update: (id: string, data: Partial<SaveCompliancePayload>) =>
+    apiClient.patch<ComplianceRecord>(`/compliance/${id}`, data),
+  remove: (id: string) => apiClient.delete(`/compliance/${id}`),
+};
diff --git a/apps/edr-freight-web/backoffice/src/services/contracts.service.ts b/apps/edr-freight-web/backoffice/src/services/contracts.service.ts
index 7ad051ce7..c23b51df2 100644
--- a/apps/edr-freight-web/backoffice/src/services/contracts.service.ts
+++ b/apps/edr-freight-web/backoffice/src/services/contracts.service.ts
@@ -185,6 +185,16 @@ export const contractsService = {
       requiredRole,
     }),
 
+  rejectStep: ({
+    id,
+    stepId,
+    reason,
+  }: {
+    id: string;
+    stepId: string;
+    reason: string;
+  }) => postContract<Freight.IContract>(C.REJECT_STEP(id, stepId), { reason }),
+
   // ── Contract document ──
   generateContract: (id: string) =>
     postContract<Freight.IContract>(C.CONTRACT_GENERATE(id)),
diff --git a/apps/edr-freight-web/backoffice/src/services/drivers.service.ts b/apps/edr-freight-web/backoffice/src/services/drivers.service.ts
index 79b0f88ef..c16f3b083 100644
--- a/apps/edr-freight-web/backoffice/src/services/drivers.service.ts
+++ b/apps/edr-freight-web/backoffice/src/services/drivers.service.ts
@@ -39,6 +39,17 @@ export type SaveDriverPayload = Omit<
   'id' | 'createdAt' | 'updatedAt' | 'totalTrips' | 'rating'
 >;
 
+/** A stored driver document (code "driver_docs"). */
+export interface DriverDocument {
+  id: string;
+  name: string;
+  url: string;
+  size: number;
+  mimeType: string;
+  code: string;
+  createdAt: string;
+}
+
 export const driversService = {
   getAll: (filters: DriverListFilters = {}) => {
     const params = new URLSearchParams();
@@ -59,4 +70,18 @@ export const driversService = {
   update: (id: string, data: Partial<SaveDriverPayload>) =>
     apiClient.patch(URL_CONSTANTS.DRIVERS.BY_ID(id), data),
   delete: (id: string) => apiClient.delete(URL_CONSTANTS.DRIVERS.BY_ID(id)),
+
+  // ── Driver documents (upload area code "driver_docs") ──
+  listDocuments: (id: string) =>
+    apiClient.get<DriverDocument[]>(`${URL_CONSTANTS.DRIVERS.BY_ID(id)}/documents`),
+  uploadDocuments: (id: string, files: File[]) => {
+    const form = new FormData();
+    for (const f of files) form.append('files', f);
+    return apiClient.post<DriverDocument[]>(
+      `${URL_CONSTANTS.DRIVERS.BY_ID(id)}/documents`,
+      form,
+    );
+  },
+  removeDocument: (id: string, fileId: string) =>
+    apiClient.delete(`${URL_CONSTANTS.DRIVERS.BY_ID(id)}/documents/${fileId}`),
 };
diff --git a/apps/edr-freight-web/backoffice/src/services/first-mile.service.ts b/apps/edr-freight-web/backoffice/src/services/first-mile.service.ts
index 6fc80a282..275bf84ea 100644
--- a/apps/edr-freight-web/backoffice/src/services/first-mile.service.ts
+++ b/apps/edr-freight-web/backoffice/src/services/first-mile.service.ts
@@ -47,6 +47,8 @@ export interface FirstMileVehicle {
   trailerPlateNo?: string | null;
   assignedDriverId?: string | null;
   assignedDriverName?: string | null;
+  pricePerKm?: number | string | null;
+  currency?: string | null;
 }
 
 export interface FirstMileRecord {
diff --git a/apps/edr-freight-web/backoffice/src/services/gps-tracking.service.ts b/apps/edr-freight-web/backoffice/src/services/gps-tracking.service.ts
new file mode 100644
index 000000000..d11898328
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/services/gps-tracking.service.ts
@@ -0,0 +1,48 @@
+import { api } from "@/auth/http";
+
+export interface GpsDevice {
+  id: string;
+  imei: string;
+  name?: string | null;
+  vehicleId?: string | null;
+  vehicle?: {
+    id: string;
+    plateNumber?: string;
+    code?: string | null;
+    manufacturer?: string;
+    model?: string;
+  } | null;
+  status: string;
+  online: boolean;
+  lastSeenAt?: string | null;
+  lastLat?: number | string | null;
+  lastLng?: number | string | null;
+  lastSpeed?: number | string | null;
+  lastCourse?: number | null;
+  lastFixAt?: string | null;
+  voltageLevel?: number | null;
+  gsmLevel?: number | null;
+}
+
+export interface GpsPosition {
+  id: string;
+  lat: number | string;
+  lng: number | string;
+  speed: number | string;
+  course: number;
+  satellites: number;
+  gpsTime: string;
+  alarm: number;
+}
+
+export const gpsTrackingService = {
+  latest: () => api.get<GpsDevice[]>("/gps/positions/latest"),
+  listDevices: () => api.get<GpsDevice[]>("/gps/devices"),
+  history: (vehicleId: string, limit = 200) =>
+    api.get<GpsPosition[]>(`/gps/positions/${vehicleId}/history?limit=${limit}`),
+  register: (data: { imei: string; name?: string; vehicleId?: string | null }) =>
+    api.post<GpsDevice>("/gps/devices", data),
+  update: (id: string, data: { name?: string; vehicleId?: string | null }) =>
+    api.patch<GpsDevice>(`/gps/devices/${id}`, data),
+  remove: (id: string) => api.delete<void>(`/gps/devices/${id}`),
+};
diff --git a/apps/edr-freight-web/backoffice/src/services/incidents.service.ts b/apps/edr-freight-web/backoffice/src/services/incidents.service.ts
new file mode 100644
index 000000000..6e54ec68b
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/services/incidents.service.ts
@@ -0,0 +1,87 @@
+import { api } from '@/auth/http';
+
+export type IncidentType = 'ACCIDENT' | 'BREAKDOWN' | 'TRAFFIC_VIOLATION' | 'THEFT' | 'OTHER';
+export type IncidentSeverity = 'MINOR' | 'MODERATE' | 'MAJOR' | 'CRITICAL';
+export type IncidentStatus =
+  | 'REPORTED'
+  | 'UNDER_REVIEW'
+  | 'CLAIM_FILED'
+  | 'RESOLVED'
+  | 'CLOSED';
+
+export interface Incident {
+  id: string;
+  vehicleId?: string | null;
+  driverId?: string | null;
+  bookingId?: string | null;
+  type: IncidentType;
+  severity: IncidentSeverity;
+  occurredAt: string;
+  location?: string | null;
+  description: string;
+  /** API sends numeric as string; coerce with Number. */
+  damageEstimate?: number | string | null;
+  status: IncidentStatus;
+  insuranceClaimNumber?: string | null;
+  reportedBy?: string | null;
+  vehicle?: {
+    id: string;
+    plateNumber?: string | null;
+    registrationNumber?: string | null;
+  } | null;
+  driver?: {
+    id: string;
+    firstName?: string | null;
+    lastName?: string | null;
+  } | null;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface IncidentFilters {
+  vehicleId?: string;
+  driverId?: string;
+  status?: IncidentStatus;
+  type?: IncidentType;
+}
+
+export interface DriverIncidentStats {
+  total: number;
+  byType: Record<string, number>;
+  lastIncidentAt: string | null;
+}
+
+export interface SaveIncidentPayload {
+  vehicleId?: string;
+  driverId?: string;
+  bookingId?: string;
+  type: IncidentType;
+  severity: IncidentSeverity;
+  occurredAt: string;
+  location?: string;
+  description: string;
+  damageEstimate?: number;
+  status?: IncidentStatus;
+  insuranceClaimNumber?: string;
+  reportedBy?: string;
+}
+
+export const incidentsService = {
+  getAll: (filters: IncidentFilters = {}) => {
+    const params = new URLSearchParams();
+    if (filters.vehicleId) params.set('vehicleId', filters.vehicleId);
+    if (filters.driverId) params.set('driverId', filters.driverId);
+    if (filters.status) params.set('status', filters.status);
+    if (filters.type) params.set('type', filters.type);
+    const qs = params.toString();
+    return api.get<Incident[]>(`/incidents${qs ? `?${qs}` : ''}`);
+  },
+  getByDriver: (driverId: string) => api.get<Incident[]>(`/incidents/driver/${driverId}`),
+  getDriverStats: (driverId: string) =>
+    api.get<DriverIncidentStats>(`/incidents/driver/${driverId}/stats`),
+  getById: (id: string) => api.get<Incident>(`/incidents/${id}`),
+  create: (data: SaveIncidentPayload) => api.post<Incident>('/incidents', data),
+  update: (id: string, data: Partial<SaveIncidentPayload>) =>
+    api.patch<Incident>(`/incidents/${id}`, data),
+  delete: (id: string) => api.delete(`/incidents/${id}`),
+};
diff --git a/apps/edr-freight-web/backoffice/src/services/last-mile.service.ts b/apps/edr-freight-web/backoffice/src/services/last-mile.service.ts
index 88e4bb9c0..4b4133b6a 100644
--- a/apps/edr-freight-web/backoffice/src/services/last-mile.service.ts
+++ b/apps/edr-freight-web/backoffice/src/services/last-mile.service.ts
@@ -1,5 +1,6 @@
 import { api } from '../auth/http';
 import { URL_CONSTANTS } from '@/constants/URLS';
+import type { FeePreview } from '@/types/warehouse';
 
 export const LAST_MILE_STATUSES = [
   'PAYMENT_PENDING',
@@ -47,6 +48,8 @@ export interface LastMileVehicle {
   trailerPlateNo?: string | null;
   assignedDriverId?: string | null;
   assignedDriverName?: string | null;
+  pricePerKm?: number | string | null;
+  currency?: string | null;
 }
 
 export interface LastMileRecord {
@@ -70,6 +73,9 @@ export interface LastMileRecord {
   }>;
   /** Present only when an invoice has actually been generated (not on distance). */
   invoice?: { id: string; number: string; status: string } | null;
+  /** Truck-detention clock: vehicle arrival + delivery/return times. */
+  arrivedAt?: string | null;
+  deliveredAt?: string | null;
   createdAt: string;
   updatedAt: string;
 }
@@ -85,7 +91,7 @@ export const lastMileService = {
   list: (pageSize = 1000) =>
     api.get<LastMileListResponse>(`${LM.BASE}?pageSize=${pageSize}`),
   getById: (id: string) => api.get<LastMileRecord>(LM.BY_ID(id)),
-  update: (id: string, data: { status?: LastMileApiStatus; vehicleId?: string | null; estimatedKm?: number | null; exactKm?: number | null; paid?: boolean }) =>
+  update: (id: string, data: { status?: LastMileApiStatus; vehicleId?: string | null; estimatedKm?: number | null; exactKm?: number | null; paid?: boolean; arrivedAt?: string | null; deliveredAt?: string | null }) =>
     api.patch<LastMileRecord>(LM.BY_ID(id), data),
   accept: (bookingReference: string) =>
     api.post<LastMileRecord>(LM.ACCEPT(encodeURIComponent(bookingReference))),
@@ -102,4 +108,12 @@ export const lastMileService = {
   ) => api.post<LastMileRecord>(`${LM.BASE}/${id}/distances`, { distances, remainingPayment }),
   generateInvoice: (id: string) =>
     api.post<{ id: string; invoiceNumber?: string } | null>(`${LM.BASE}/${id}/invoice`),
+  /** Generate a truck-detention invoice (per truck per day after the grace window). */
+  generateTruckDetentionInvoice: (id: string) =>
+    api.post<{ id: string; invoiceNumber?: string } | null>(
+      `${LM.BASE}/${id}/generate-truck-detention-invoice`,
+    ),
+  /** Preview the truck-detention charge for a last-mile leg. */
+  truckDetentionPreview: (id: string) =>
+    api.get<FeePreview>(`${LM.BASE}/${id}/truck-detention-preview`),
 };
diff --git a/apps/edr-freight-web/backoffice/src/services/maintenance-depth.service.ts b/apps/edr-freight-web/backoffice/src/services/maintenance-depth.service.ts
new file mode 100644
index 000000000..83ae34e67
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/services/maintenance-depth.service.ts
@@ -0,0 +1,130 @@
+import { api } from '@/auth/http';
+
+export type WorkOrderStatus = 'OPEN' | 'IN_PROGRESS' | 'COMPLETED' | 'CANCELLED';
+export type WorkOrderPriority = 'LOW' | 'MEDIUM' | 'HIGH' | 'URGENT';
+
+export interface WorkOrder {
+  id: string;
+  vehicleId: string;
+  title: string;
+  description?: string | null;
+  status: WorkOrderStatus;
+  priority: WorkOrderPriority;
+  assignedTo?: string | null;
+  openedAt: string;
+  closedAt?: string | null;
+  /** API sends numeric as string; coerce with Number. */
+  laborCost?: number | string | null;
+  partsCost?: number | string | null;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface SaveWorkOrderPayload {
+  vehicleId: string;
+  title: string;
+  description?: string;
+  status?: WorkOrderStatus;
+  priority?: WorkOrderPriority;
+  assignedTo?: string;
+  openedAt?: string;
+  closedAt?: string;
+  laborCost?: number;
+  partsCost?: number;
+}
+
+export interface WorkOrderFilters {
+  vehicleId?: string;
+  status?: WorkOrderStatus;
+}
+
+export interface Part {
+  id: string;
+  name: string;
+  sku?: string | null;
+  category?: string | null;
+  quantityInStock: number;
+  reorderLevel: number;
+  /** API sends numeric as string; coerce with Number. */
+  unitCost?: number | string | null;
+  location?: string | null;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface SavePartPayload {
+  name: string;
+  sku?: string;
+  category?: string;
+  quantityInStock?: number;
+  reorderLevel?: number;
+  unitCost?: number;
+  location?: string;
+}
+
+export interface PartFilters {
+  category?: string;
+  lowStock?: boolean;
+}
+
+export interface Warranty {
+  id: string;
+  vehicleId: string;
+  component: string;
+  provider?: string | null;
+  startDate?: string | null;
+  expiryDate: string;
+  coverageNotes?: string | null;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface SaveWarrantyPayload {
+  vehicleId: string;
+  component: string;
+  provider?: string;
+  startDate?: string;
+  expiryDate: string;
+  coverageNotes?: string;
+}
+
+export const maintenanceDepthService = {
+  // Work Orders
+  getWorkOrders: (filters: WorkOrderFilters = {}) => {
+    const params = new URLSearchParams();
+    if (filters.vehicleId) params.set('vehicleId', filters.vehicleId);
+    if (filters.status) params.set('status', filters.status);
+    const qs = params.toString();
+    return api.get<WorkOrder[]>(`/maintenance/work-orders${qs ? `?${qs}` : ''}`);
+  },
+  getWorkOrder: (id: string) => api.get<WorkOrder>(`/maintenance/work-orders/${id}`),
+  createWorkOrder: (data: SaveWorkOrderPayload) =>
+    api.post<WorkOrder>('/maintenance/work-orders', data),
+  updateWorkOrder: (id: string, data: Partial<SaveWorkOrderPayload>) =>
+    api.patch<WorkOrder>(`/maintenance/work-orders/${id}`, data),
+  deleteWorkOrder: (id: string) => api.delete(`/maintenance/work-orders/${id}`),
+
+  // Parts / Tires
+  getParts: (filters: PartFilters = {}) => {
+    const params = new URLSearchParams();
+    if (filters.category) params.set('category', filters.category);
+    if (filters.lowStock) params.set('lowStock', 'true');
+    const qs = params.toString();
+    return api.get<Part[]>(`/maintenance/parts${qs ? `?${qs}` : ''}`);
+  },
+  createPart: (data: SavePartPayload) => api.post<Part>('/maintenance/parts', data),
+  updatePart: (id: string, data: Partial<SavePartPayload>) =>
+    api.patch<Part>(`/maintenance/parts/${id}`, data),
+  deletePart: (id: string) => api.delete(`/maintenance/parts/${id}`),
+
+  // Warranties
+  getWarranties: (vehicleId?: string) => {
+    const params = new URLSearchParams();
+    if (vehicleId) params.set('vehicleId', vehicleId);
+    const qs = params.toString();
+    return api.get<Warranty[]>(`/maintenance/warranties${qs ? `?${qs}` : ''}`);
+  },
+  createWarranty: (data: SaveWarrantyPayload) =>
+    api.post<Warranty>('/maintenance/warranties', data),
+  deleteWarranty: (id: string) => api.delete(`/maintenance/warranties/${id}`),
+};
diff --git a/apps/edr-freight-web/backoffice/src/services/procurement.service.ts b/apps/edr-freight-web/backoffice/src/services/procurement.service.ts
new file mode 100644
index 000000000..684dcd37f
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/services/procurement.service.ts
@@ -0,0 +1,138 @@
+import { api } from "@/auth/http";
+
+export type VendorType = "DEALER" | "LEASING" | "PARTS" | "SERVICE" | "OTHER";
+export type AcquisitionType = "PURCHASE" | "LEASE" | "RENTAL";
+export type AcquisitionStatus = "ACTIVE" | "LEASE_EXPIRING" | "DISPOSED";
+export type DisposalMethod = "SALE" | "SCRAP" | "RETURN_LEASE" | "TRADE_IN";
+
+export interface Vendor {
+  id: string;
+  name: string;
+  type?: VendorType | null;
+  contactPerson?: string | null;
+  phone?: string | null;
+  email?: string | null;
+  address?: string | null;
+  isActive: boolean;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface AssetAcquisition {
+  id: string;
+  vehicleId?: string | null;
+  vendorId?: string | null;
+  acquisitionType: AcquisitionType;
+  acquisitionDate: string;
+  cost?: number | null;
+  usefulLifeMonths?: number | null;
+  salvageValue?: number | null;
+  leaseStart?: string | null;
+  leaseEnd?: string | null;
+  monthlyPayment?: number | null;
+  status: AcquisitionStatus;
+  notes?: string | null;
+  vehicle?: {
+    id: string;
+    plateNumber?: string | null;
+    registrationNumber?: string | null;
+    manufacturer?: string | null;
+    model?: string | null;
+  } | null;
+  vendor?: Vendor | null;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface AssetDisposal {
+  id: string;
+  vehicleId: string;
+  disposalDate: string;
+  method: DisposalMethod;
+  salePrice?: number | null;
+  buyer?: string | null;
+  notes?: string | null;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface DepreciationResult {
+  method: "STRAIGHT_LINE";
+  cost: number;
+  salvageValue: number;
+  usefulLifeMonths: number;
+  monthsElapsed: number;
+  monthlyDepreciation: number;
+  bookValue: number;
+}
+
+export interface LifecycleResult {
+  vehicleId: string;
+  acquisition: AssetAcquisition | null;
+  disposal: AssetDisposal | null;
+  depreciation: DepreciationResult | null;
+}
+
+export interface CreateVendorPayload {
+  name: string;
+  type?: VendorType;
+  contactPerson?: string;
+  phone?: string;
+  email?: string;
+  address?: string;
+  isActive?: boolean;
+}
+
+export interface CreateAcquisitionPayload {
+  vehicleId?: string;
+  vendorId?: string;
+  acquisitionType: AcquisitionType;
+  acquisitionDate: string;
+  cost?: number;
+  usefulLifeMonths?: number;
+  salvageValue?: number;
+  leaseStart?: string;
+  leaseEnd?: string;
+  monthlyPayment?: number;
+  status?: AcquisitionStatus;
+  notes?: string;
+}
+
+export interface CreateDisposalPayload {
+  vehicleId: string;
+  disposalDate: string;
+  method: DisposalMethod;
+  salePrice?: number;
+  buyer?: string;
+  notes?: string;
+}
+
+export const procurementService = {
+  // Vendors
+  listVendors: () => api.get<Vendor[]>("/procurement/vendors"),
+  createVendor: (data: CreateVendorPayload) => api.post("/procurement/vendors", data),
+  updateVendor: (id: string, data: Partial<CreateVendorPayload>) =>
+    api.patch(`/procurement/vendors/${id}`, data),
+  deleteVendor: (id: string) => api.delete(`/procurement/vendors/${id}`),
+
+  // Acquisitions
+  listAcquisitions: (vehicleId?: string) =>
+    api.get<AssetAcquisition[]>(
+      `/procurement/acquisitions${vehicleId ? `?vehicleId=${vehicleId}` : ""}`,
+    ),
+  getAcquisition: (id: string) => api.get<AssetAcquisition>(`/procurement/acquisitions/${id}`),
+  createAcquisition: (data: CreateAcquisitionPayload) =>
+    api.post("/procurement/acquisitions", data),
+  updateAcquisition: (id: string, data: Partial<CreateAcquisitionPayload>) =>
+    api.patch(`/procurement/acquisitions/${id}`, data),
+  deleteAcquisition: (id: string) => api.delete(`/procurement/acquisitions/${id}`),
+
+  // Disposals
+  listDisposals: () => api.get<AssetDisposal[]>("/procurement/disposals"),
+  createDisposal: (data: CreateDisposalPayload) => api.post("/procurement/disposals", data),
+  deleteDisposal: (id: string) => api.delete(`/procurement/disposals/${id}`),
+
+  // Lifecycle
+  lifecycle: (vehicleId: string) =>
+    api.get<LifecycleResult>(`/procurement/lifecycle/${vehicleId}`),
+};
diff --git a/apps/edr-freight-web/backoffice/src/services/vehicles.service.ts b/apps/edr-freight-web/backoffice/src/services/vehicles.service.ts
index 6b48ed801..749e7656c 100644
--- a/apps/edr-freight-web/backoffice/src/services/vehicles.service.ts
+++ b/apps/edr-freight-web/backoffice/src/services/vehicles.service.ts
@@ -38,6 +38,9 @@ export interface Vehicle {
   /** Odometer-derived distances (API sends numeric strings; coerce with Number). */
   estimatedDistanceKm?: number | null;
   actualDistanceKm?: number | null;
+  /** Haulage rate per km + its currency (ETB | USD). */
+  pricePerKm?: number | null;
+  currency?: string | null;
   createdAt: string;
   updatedAt: string;
 }
diff --git a/apps/edr-freight-web/backoffice/src/types/warehouse.ts b/apps/edr-freight-web/backoffice/src/types/warehouse.ts
index 5e116d1ca..9ac2c2efd 100644
--- a/apps/edr-freight-web/backoffice/src/types/warehouse.ts
+++ b/apps/edr-freight-web/backoffice/src/types/warehouse.ts
@@ -737,13 +737,38 @@ export interface AllocationRule {
 }
 export type SaveAllocationRulePayload = Omit<AllocationRule, 'id'>;
 
-export const FEE_RULE_TYPES = ['STORAGE_FEE', 'DEMURRAGE_FEE'] as const;
+export const FEE_RULE_TYPES = [
+  'STORAGE_FEE',
+  'DEMURRAGE_FEE',
+  'DOUBLE_HANDLING_FEE',
+  'TRUCK_DETENTION_FEE',
+] as const;
 export type FeeRuleType = (typeof FEE_RULE_TYPES)[number];
 
+/** Human labels for each fee rule type (dropdowns, badges). */
+export const FEE_RULE_TYPE_LABELS: Record<FeeRuleType, string> = {
+  STORAGE_FEE: 'Storage',
+  DEMURRAGE_FEE: 'Demurrage',
+  DOUBLE_HANDLING_FEE: 'Double Handling',
+  TRUCK_DETENTION_FEE: 'Truck Detention Cost',
+};
+
+/** Charge basis for a Double Handling rule (flat rate × the chosen quantity). */
+export const FEE_RULE_BASES = ['PER_CONTAINER', 'PER_TON', 'PER_ITEM'] as const;
+export type FeeRuleBasis = (typeof FEE_RULE_BASES)[number];
+
+export const FEE_RULE_BASIS_LABELS: Record<FeeRuleBasis, string> = {
+  PER_CONTAINER: 'Per Container',
+  PER_TON: 'Per Ton',
+  PER_ITEM: 'Per Item',
+};
+
 export interface FeeRule {
   id: string;
   name: string;
   ruleType: FeeRuleType;
+  /** Double-handling charge basis; null for day-based fee types. */
+  basis?: FeeRuleBasis | null;
   priority: number;
   freightType?: string | null;
   tradeDirection?: string | null;
@@ -754,6 +779,8 @@ export interface FeeRule {
   yardId?: string | null;
   zoneId?: string | null;
   freeDays: number;
+  /** Truck detention only: grace window in hours (default 3). */
+  freeHours?: number | null;
   ratePerDay: number;
   tiers?: FeeRuleTier[];
   currency: string;
@@ -776,6 +803,7 @@ export interface FeePreviewTier extends FeeRuleTier {
 
 export interface FeePreview {
   ruleType: FeeRuleType;
+  basis?: FeeRuleBasis | null;
   ruleId: string | null;
   ruleName: string | null;
   freeDays: number;
diff --git a/apps/edr-freight-web/portal/src/components/customer-actions/deriveContractCustomerAction.ts b/apps/edr-freight-web/portal/src/components/customer-actions/deriveContractCustomerAction.ts
index 4de7d2545..5d9a53c91 100644
--- a/apps/edr-freight-web/portal/src/components/customer-actions/deriveContractCustomerAction.ts
+++ b/apps/edr-freight-web/portal/src/components/customer-actions/deriveContractCustomerAction.ts
@@ -117,6 +117,18 @@ export function deriveContractCustomerAction(
     };
   }
 
+  // Saved-but-not-submitted contract — send the customer back into the wizard to
+  // finish editing and submit it for review.
+  if (contract.status === "DRAFT" || contract.status === "RENEWAL_DRAFT") {
+    return {
+      type: "navigate",
+      label: "Continue draft",
+      to: `/contracts/${id}/edit`,
+      primary: true,
+      icon: PencilLine,
+    };
+  }
+
   const payable = findPayableBookingForContract(id, bookings);
   if (payable) {
     return {
diff --git a/apps/edr-freight-web/portal/src/features/bookingWindows/useBookingWindowSocket.ts b/apps/edr-freight-web/portal/src/features/bookingWindows/useBookingWindowSocket.ts
index 17f6174b3..5b91af82e 100644
--- a/apps/edr-freight-web/portal/src/features/bookingWindows/useBookingWindowSocket.ts
+++ b/apps/edr-freight-web/portal/src/features/bookingWindows/useBookingWindowSocket.ts
@@ -40,6 +40,18 @@ export function useBookingWindowSocket(enabled: boolean) {
       withCredentials: true,
     });
 
+    // Deliberate console breadcrumbs: "live updates not arriving" is only
+    // diagnosable from the browser when connect/reject outcomes are visible.
+    socket.on("connect", () =>
+      console.debug("[booking-windows] socket connected", socket.id),
+    );
+    socket.on("connect_error", (err) =>
+      console.warn("[booking-windows] socket connect failed:", err.message),
+    );
+    socket.on("disconnect", (reason) =>
+      console.debug("[booking-windows] socket disconnected:", reason),
+    );
+
     socket.on(
       BOOKING_WINDOW_WS_EVENTS.PHASE,
       (_event: BookingWindowPhaseEvent) => {
diff --git a/apps/edr-freight-web/portal/src/features/notifications/notificationConfig.tsx b/apps/edr-freight-web/portal/src/features/notifications/notificationConfig.tsx
index 42f3294f7..9cde29f77 100644
--- a/apps/edr-freight-web/portal/src/features/notifications/notificationConfig.tsx
+++ b/apps/edr-freight-web/portal/src/features/notifications/notificationConfig.tsx
@@ -3,6 +3,8 @@ import type { NotificationItemData, NotificationVisual } from "@edr/ui-common";
 import {
   BadgeCheck,
   Bell,
+  CalendarClock,
+  FileSignature,
   FileWarning,
   Package,
   Receipt,
@@ -25,6 +27,10 @@ export function resolveNotificationVisual(
       return { icon: <FileWarning size={ICON_SIZE} />, color: "orange" };
     case NotificationType.BOOKING_STATUS:
       return { icon: <Package size={ICON_SIZE} />, color: "blue" };
+    case NotificationType.CONTRACT_STATUS:
+      return { icon: <FileSignature size={ICON_SIZE} />, color: "indigo" };
+    case NotificationType.SCHEDULE_UPDATE:
+      return { icon: <CalendarClock size={ICON_SIZE} />, color: "cyan" };
     case NotificationType.INVOICE_ISSUED:
       return { icon: <Receipt size={ICON_SIZE} />, color: "violet" };
     default:
@@ -55,8 +61,18 @@ export function resolveNotificationHref(
       const id = asId(data.bookingId);
       return id ? `/bookings/${id}` : null;
     }
+    case NotificationType.CONTRACT_STATUS: {
+      const id = asId(data.contractId);
+      return id ? `/contracts/${id}` : "/contracts";
+    }
+    case NotificationType.SCHEDULE_UPDATE: {
+      const id = asId(data.bookingId);
+      return id ? `/bookings/${id}` : "/bookings/new";
+    }
     case NotificationType.CLEARANCE_DECISION:
     case NotificationType.DOCUMENT_ACTION: {
+      const bookingId = asId(data.bookingId);
+      if (bookingId) return `/bookings/${bookingId}`;
       const id = asId(data.contractId);
       return id ? `/contracts/${id}` : "/contracts";
     }
diff --git a/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/components/StatusHero.tsx b/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/components/StatusHero.tsx
index ac9352653..127901186 100644
--- a/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/components/StatusHero.tsx
+++ b/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/components/StatusHero.tsx
@@ -3,7 +3,7 @@ import { Check, MoveRight } from "lucide-react";
 
 import type { Freight } from "@edr/types";
 
-import { PROGRESS_STAGES, STATUS_MAP } from "../constants";
+import { ARRIVAL_STAGE, PROGRESS_STAGES, STATUS_MAP, resolveStage } from "../constants";
 import { fmtDate, isDraftLike, isNegative, yardLabel } from "../utils";
 import { SectionCard } from "./layout";
 
@@ -65,7 +65,18 @@ export function StatusHero({
   children?: React.ReactNode;
 }) {
   const status = booking.status;
-  const cfg = STATUS_MAP[status] ?? STATUS_MAP.DRAFT;
+  const stage = resolveStage(booking);
+  // The Arrival stage has no booking status of its own — it lights up from the
+  // train's ARRIVED state, so the headline is overridden here.
+  const cfg =
+    stage === ARRIVAL_STAGE
+      ? {
+          title: "Train arrived at destination",
+          description:
+            "Your shipment reached its destination yard and is being unloaded and prepared for release.",
+          stage,
+        }
+      : (STATUS_MAP[status] ?? STATUS_MAP.DRAFT);
   const negative = isNegative(status);
   const draft = isDraftLike(status);
 
@@ -107,7 +118,7 @@ export function StatusHero({
 
       {children ?? (
         <ProgressTracker
-          current={cfg.stage}
+          current={stage}
           tone={draft ? "ink" : "green"}
           negative={negative}
         />
@@ -139,7 +150,7 @@ function ProgressTracker({
         } as React.CSSProperties
       }
     >
-      <div className="flex items-start" style={{ minWidth: 440 }}>
+      <div className="flex items-start" style={{ minWidth: 520 }}>
         {PROGRESS_STAGES.map((stage, idx) => {
           const state =
             idx < current ? "done" : idx === current ? "active" : "idle";
diff --git a/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/constants.ts b/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/constants.ts
index 67be567db..2a41a6fa3 100644
--- a/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/constants.ts
+++ b/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/constants.ts
@@ -1,6 +1,7 @@
 import {
   ClipboardCheck,
   FileText,
+  MapPin,
   PackageCheck,
   ShieldCheck,
   Ship,
@@ -52,6 +53,14 @@ export const PROGRESS_STAGES = [
     icon: Train,
     statuses: ["EXPIRED", "IN_TRANSIT"],
   },
+  {
+    // No booking status maps here: the booking stays IN_TRANSIT until
+    // delivery, so this stage lights up from the assigned train's own status
+    // (trainScheduleStatus === "ARRIVED") — see resolveStage.
+    label: "Arrival",
+    icon: MapPin,
+    statuses: [],
+  },
   {
     label: "Complete",
     icon: PackageCheck,
@@ -59,6 +68,30 @@ export const PROGRESS_STAGES = [
   },
 ];
 
+/** Stage index of the Arrival step (train ARRIVED, cargo not yet delivered). */
+export const ARRIVAL_STAGE = PROGRESS_STAGES.findIndex(
+  (s) => s.label === "Arrival",
+);
+
+/**
+ * Stage for a booking, factoring in the assigned train's operational status:
+ * a booking is stuck at IN_TRANSIT between dispatch and delivery, so once its
+ * train has ARRIVED the tracker advances to the Arrival stage.
+ */
+export function resolveStage(booking: {
+  status: string;
+  trainScheduleStatus?: string | null;
+}): number {
+  const base = STATUS_MAP[booking.status]?.stage ?? 0;
+  if (
+    booking.status === "IN_TRANSIT" &&
+    booking.trainScheduleStatus === "ARRIVED"
+  ) {
+    return ARRIVAL_STAGE;
+  }
+  return base;
+}
+
 export const STATUS_MAP: Record<
   string,
   { title: string; description: string; stage: number }
@@ -209,7 +242,7 @@ export const STATUS_MAP: Record<
     title: "Contract closed",
     description:
       "This general contract is closed — its reserved quantity has been used or its window has elapsed.",
-    stage: 7,
+    stage: 8,
   },
   PRICE_CHANGED_PENDING_CONFIRM: {
     title: "Price changed — confirm to proceed",
@@ -235,12 +268,12 @@ export const STATUS_MAP: Record<
   COMPLETED: {
     title: "Service complete",
     description: "Cargo delivered and service successfully terminated.",
-    stage: 7,
+    stage: 8,
   },
   DELIVERED: {
     title: "Service complete",
     description: "Cargo delivered and service successfully terminated.",
-    stage: 7,
+    stage: 8,
   },
   REJECTED: {
     title: "Booking rejected",
diff --git a/apps/edr-freight-web/portal/src/pages/contracts/ContractDetailPage.tsx b/apps/edr-freight-web/portal/src/pages/contracts/ContractDetailPage.tsx
index 16225cd02..560d7b11e 100644
--- a/apps/edr-freight-web/portal/src/pages/contracts/ContractDetailPage.tsx
+++ b/apps/edr-freight-web/portal/src/pages/contracts/ContractDetailPage.tsx
@@ -73,10 +73,6 @@ import {
   MUTED,
 } from "./contract-ui";
 
-// Statuses where a customer may create a shipment booking themselves. Reached
-// only after self-clearance is approved by Operations (Path A) or, for DOMESTIC,
-// directly at counter-sign.
-const PATH_A_BOOKABLE = ["FULLY_EXECUTED", "CONTRACT_ACTIVE"];
 // Statuses where the customer uploads clearance documents on the contract. Used
 // by both paths: Path B (customs, GL-reviewed) and Path A self-clearance
 // (non-customs IMPORT/EXPORT, Operations-reviewed).
@@ -263,10 +259,14 @@ export default function ContractDetailPage() {
     );
   }
 
-  // Staff returned the contract for changes — send the customer to the full edit
-  // wizard (edit any term + replace documents → resubmit) rather than the
-  // read-only detail.
-  if (contract.status === "CHANGES_REQUESTED") {
+  // Not yet submitted (customer saved a draft) or staff returned the contract for
+  // changes — send the customer to the full edit wizard (edit any term + replace
+  // documents → submit) rather than the read-only detail.
+  if (
+    contract.status === "DRAFT" ||
+    contract.status === "RENEWAL_DRAFT" ||
+    contract.status === "CHANGES_REQUESTED"
+  ) {
     return <Navigate to={`/contracts/${contract.id}/edit`} replace />;
   }
 
@@ -305,9 +305,13 @@ export default function ContractDetailPage() {
   const clearanceFinalized =
     contract.clearanceStatus === "CLEARANCE_READY_FOR_BOOKING" ||
     contract.status === "CLEARANCE_READY_FOR_BOOKING";
-  const canBookShipment =
-    !customsPath && PATH_A_BOOKABLE.includes(contract.status);
   const bookingAction = getContractBookingAction(contract, contractBookings);
+  // Whether the customer may open a new self-service booking. Derived from the
+  // shared booking-action helper so it honours the ONE_TIME single-slot rule:
+  // once a non-terminal booking exists on a ONE_TIME contract there is no free
+  // slot, so the action is "none" and no booking button is shown.
+  const canBookShipment =
+    bookingAction.kind === "book" || bookingAction.kind === "rebook";
   const canRequestShipment = bookingAction.kind === "request";
   // Customs + clearance finalized: GL is preparing the booking — surface a
   // status notice instead of any action.
diff --git a/apps/edr-freight-web/portal/src/pages/contracts/ContractsList.tsx b/apps/edr-freight-web/portal/src/pages/contracts/ContractsList.tsx
index 41e77625b..d2bd8b88f 100644
--- a/apps/edr-freight-web/portal/src/pages/contracts/ContractsList.tsx
+++ b/apps/edr-freight-web/portal/src/pages/contracts/ContractsList.tsx
@@ -2,6 +2,7 @@ import { Fragment, useMemo, useState } from "react";
 import { useNavigate } from "react-router-dom";
 import { useQuery } from "@tanstack/react-query";
 import {
+  Badge,
   Box,
   Button,
   Center,
@@ -339,6 +340,7 @@ export default function ContractsList() {
                 <Table.Tr>
                   <Table.Th style={{ width: 44 }} aria-label="Expand" />
                   <Table.Th>Contract</Table.Th>
+                  <Table.Th>Type</Table.Th>
                   <Table.Th>Cargo</Table.Th>
                   <Table.Th>Route</Table.Th>
                   <Table.Th>Trade</Table.Th>
@@ -352,7 +354,7 @@ export default function ContractsList() {
               <Table.Tbody>
                 {isLoading && (
                   <Table.Tr>
-                    <Table.Td colSpan={10}>
+                    <Table.Td colSpan={11}>
                       <Center py={48}>
                         <Loader color="edr-green" size="sm" />
                       </Center>
@@ -362,7 +364,7 @@ export default function ContractsList() {
 
                 {!isLoading && isError && (
                   <Table.Tr>
-                    <Table.Td colSpan={10}>
+                    <Table.Td colSpan={11}>
                       <Center py={48}>
                         <Text fz={13} c="red">
                           Failed to load contracts. Please try again.
@@ -374,7 +376,7 @@ export default function ContractsList() {
 
                 {!isLoading && !isError && rows.length === 0 && (
                   <Table.Tr>
-                    <Table.Td colSpan={10}>
+                    <Table.Td colSpan={11}>
                       <Stack align="center" gap={8} py={48}>
                         <Inbox size={26} color={MUTED} style={{ opacity: 0.5 }} />
                         <Text fz={13} c="dimmed">
@@ -442,10 +444,18 @@ export default function ContractsList() {
                             {c.reference}
                           </Text>
                           <Text fz={12} c="dimmed">
-                            {isGeneral ? "General" : "One-Time"} ·{" "}
                             {isContainer ? "Containerised" : "Bulk"}
                           </Text>
                         </Table.Td>
+                        <Table.Td>
+                          <Badge
+                            variant="light"
+                            color={isGeneral ? "edr-green" : "gray"}
+                            radius="sm"
+                          >
+                            {isGeneral ? "General" : "One-Time"}
+                          </Badge>
+                        </Table.Td>
                         <Table.Td>
                           <Group gap={7} wrap="nowrap" align="center">
                             {isContainer ? (
@@ -533,7 +543,7 @@ export default function ContractsList() {
                       </Table.Tr>
                       {isOpen && (
                         <Table.Tr style={{ background: "#F4FBF8" }}>
-                          <Table.Td colSpan={10} style={{ padding: "6px 20px 18px" }}>
+                          <Table.Td colSpan={11} style={{ padding: "6px 20px 18px" }}>
                             <ContractStepBanner contract={c} />
                           </Table.Td>
                         </Table.Tr>
diff --git a/apps/edr-freight-web/portal/src/pages/contracts/NewContractPage.tsx b/apps/edr-freight-web/portal/src/pages/contracts/NewContractPage.tsx
index 6bd6994f6..613d3dcc6 100644
--- a/apps/edr-freight-web/portal/src/pages/contracts/NewContractPage.tsx
+++ b/apps/edr-freight-web/portal/src/pages/contracts/NewContractPage.tsx
@@ -81,9 +81,10 @@ type PriceModalMode = "submit" | "draft";
 
 /**
  * The contract wizard, used both to create a new contract and — in `edit` mode —
- * to edit & resubmit a contract staff returned with CHANGES_REQUESTED. Edit mode
- * hydrates the form from the saved contract, lets the customer change any term
- * and replace documents, then runs the same update → price → submit flow.
+ * to continue an unsubmitted DRAFT or edit & resubmit a contract staff returned
+ * with CHANGES_REQUESTED. Edit mode hydrates the form from the saved contract,
+ * lets the customer change any term and replace documents, then runs the same
+ * update → price → submit flow.
  */
 export default function NewContractPage({
   mode = "create",
@@ -693,8 +694,25 @@ export default function NewContractPage({
               title="A reviewer asked for changes"
               mb="lg"
             >
-              Update any contract detail or document that needs to change, then
-              resubmit the contract for review.
+              {editContract?.latestChangeRequestNote ? (
+                <Stack gap={6}>
+                  <Text size="sm" fw={600}>
+                    What the reviewer asked for:
+                  </Text>
+                  <Text
+                    size="sm"
+                    style={{ whiteSpace: "pre-wrap" }}
+                  >
+                    {editContract.latestChangeRequestNote}
+                  </Text>
+                  <Text size="sm" c="dimmed" mt={2}>
+                    Update the details or documents below, then resubmit the
+                    contract for review.
+                  </Text>
+                </Stack>
+              ) : (
+                "Update any contract detail or document that needs to change, then resubmit the contract for review."
+              )}
             </Alert>
           )}
 
diff --git a/docker-compose.yaml b/docker-compose.yaml
index cc6dcd1e3..863c1b5e2 100644
--- a/docker-compose.yaml
+++ b/docker-compose.yaml
@@ -16,6 +16,8 @@ services:
         - npmrc
     ports:
       - "${FREIGHT_API_PORT:-3001}:${FREIGHT_API_PORT:-3001}"
+      # GT06 GPS tracker TCP ingestion (raw TCP — must be reachable by tracker SIMs).
+      - "${GT06_TCP_PORT:-5023}:${GT06_TCP_PORT:-5023}"
     env_file:
       - apps/edr-freight-api/.env
     extra_hosts:
@@ -52,6 +54,7 @@ services:
         VITE_API_URL: ${VITE_API_URL:-}
         VITE_BASE_API_URL: ${VITE_BASE_API_URL:-}
         VITE_USER_MANAGEMENT_BASE: ${VITE_USER_MANAGEMENT_BASE:-}
+        VITE_GOOGLE_MAPS_API_KEY: ${VITE_GOOGLE_MAPS_API_KEY:-}
       secrets:
         - npmrc
     ports:
@@ -66,6 +69,7 @@ services:
         VITE_API_URL: ${VITE_API_URL:-}
         VITE_BASE_API_URL: ${VITE_BASE_API_URL:-}
         VITE_USER_MANAGEMENT_BASE: ${VITE_USER_MANAGEMENT_BASE:-}
+        VITE_GOOGLE_MAPS_API_KEY: ${VITE_GOOGLE_MAPS_API_KEY:-}
       secrets:
         - npmrc
     ports:
diff --git a/infrastructure/docker/Dockerfile.web b/infrastructure/docker/Dockerfile.web
index d5f77061e..6ef9231f0 100644
--- a/infrastructure/docker/Dockerfile.web
+++ b/infrastructure/docker/Dockerfile.web
@@ -27,10 +27,12 @@ ARG VITE_API_URL
 ARG VITE_BASE_API_URL
 ARG VITE_USER_MANAGEMENT_BASE
 ARG NEXT_PUBLIC_API_URL
+ARG VITE_GOOGLE_MAPS_API_KEY
 ENV VITE_API_URL=${VITE_API_URL}
 ENV VITE_BASE_API_URL=${VITE_BASE_API_URL}
 ENV VITE_USER_MANAGEMENT_BASE=${VITE_USER_MANAGEMENT_BASE}
 ENV NEXT_PUBLIC_API_URL=${NEXT_PUBLIC_API_URL}
+ENV VITE_GOOGLE_MAPS_API_KEY=${VITE_GOOGLE_MAPS_API_KEY}
 
 RUN if [ -z "$VITE_API_URL" ] || [ -z "$VITE_BASE_API_URL" ] || [ -z "$VITE_USER_MANAGEMENT_BASE" ]; then \
       echo "ERROR: VITE_API_URL, VITE_BASE_API_URL, and VITE_USER_MANAGEMENT_BASE must all be set" && \
diff --git a/packages/types/src/freight/contracts.ts b/packages/types/src/freight/contracts.ts
index bf2778575..c6b97fab1 100644
--- a/packages/types/src/freight/contracts.ts
+++ b/packages/types/src/freight/contracts.ts
@@ -561,6 +561,12 @@ export interface IContract extends BaseEntity {
   expiresAt?: string | null;
 
   status: ContractStatus;
+  /**
+   * Body of the latest staff CHANGES_REQUESTED review note (detail response
+   * only, when status is CHANGES_REQUESTED). Lets the portal show the customer
+   * exactly what to fix before resubmitting.
+   */
+  latestChangeRequestNote?: string | null;
   clearanceStatus: ContractClearanceStatus;
   clearanceCycleNumber: number;
   /**
diff --git a/packages/types/src/freight/index.ts b/packages/types/src/freight/index.ts
index 0b5752265..c51d838e1 100644
--- a/packages/types/src/freight/index.ts
+++ b/packages/types/src/freight/index.ts
@@ -438,6 +438,13 @@ export interface IBooking extends BaseEntity {
   contractReference?: string | null;
   trainId?: string | null;
   status: BookingStatus;
+  /**
+   * Operational status of the assigned train (DRAFT/SCHEDULED/DISPATCHED/
+   * ARRIVED), joined on booking detail. The booking status stays IN_TRANSIT
+   * from dispatch until delivery, so the portal stepper reads arrival from
+   * here.
+   */
+  trainScheduleStatus?: TrainScheduleStatus | string | null;
   /** ONE_TIME for normal bookings; GENERAL_CONTRACT for umbrella contracts. */
   bookingType?: BookingType;
   /** General contracts only: when ordering closes (null until active / for one-time). */
diff --git a/packages/types/src/freight/notifications.ts b/packages/types/src/freight/notifications.ts
index bdf83a719..75513dcb9 100644
--- a/packages/types/src/freight/notifications.ts
+++ b/packages/types/src/freight/notifications.ts
@@ -33,6 +33,8 @@ export enum NotificationType {
   CLEARANCE_DECISION = "CLEARANCE_DECISION",
   DOCUMENT_ACTION = "DOCUMENT_ACTION",
   BOOKING_STATUS = "BOOKING_STATUS",
+  CONTRACT_STATUS = "CONTRACT_STATUS",
+  SCHEDULE_UPDATE = "SCHEDULE_UPDATE",
   INVOICE_ISSUED = "INVOICE_ISSUED",
   // Backoffice-facing (staff)
   REQUEST_SUBMITTED = "REQUEST_SUBMITTED",
@@ -87,6 +89,8 @@ export interface NotificationRecipients {
   companyProfileId?: string;
   /** Backoffice: all current employees of this organization. */
   organizationId?: string;
+  /** Backoffice: every current employee across all organizations. */
+  allBackoffice?: boolean;
 }
 
 /** Input any subsystem passes to `NotificationInboxService.notify(...)`. */
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index fadeaca56..6c7c60f4c 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -193,6 +193,9 @@ importers:
       jest:
         specifier: ^29.7.0
         version: 29.7.0(@types/node@20.19.42)(babel-plugin-macros@3.1.0)(ts-node@10.9.2(@types/node@20.19.42)(typescript@5.9.3))
+      socket.io-client:
+        specifier: ^4.8.3
+        version: 4.8.3
       supertest:
         specifier: ^7.0.0
         version: 7.2.2
@@ -244,6 +247,9 @@ importers:
       '@tria-plc/iamui':
         specifier: file:../../../local-packages/tria-plc-iamui-0.1.1.tgz
         version: file:local-packages/tria-plc-iamui-0.1.1.tgz(0ce39b7e349029277dcd938d06eeb0f7)
+      '@vis.gl/react-google-maps':
+        specifier: ^1.8.3
+        version: 1.8.3(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
       axios:
         specifier: ^1.7.7
         version: 1.17.0
@@ -305,6 +311,9 @@ importers:
       '@tailwindcss/vite':
         specifier: ^4.3.0
         version: 4.3.0(vite@5.4.21(@types/node@24.13.1)(lightningcss@1.32.0)(terser@5.48.0))
+      '@types/google.maps':
+        specifier: ^3.65.2
+        version: 3.65.2
       '@types/react':
         specifier: ^18.3.11
         version: 18.3.31