diff --git a/.gitignore b/.gitignore
index ca2a5b7af..21edddcd0 100644
--- a/.gitignore
+++ b/.gitignore
@@ -29,3 +29,11 @@ coverage/
 \#*\#
 .\#*
 docker-compose.override.yml
+
+# cypress e2e artifacts
+e2e/**/cypress/videos/
+e2e/**/cypress/screenshots/
+e2e/**/cypress/downloads/
+
+# e2e launcher state (ports of the running stack)
+e2e/freight/.e2e-ports.json
diff --git a/apps/edr-freight-api/src/common/booking-guards.ts b/apps/edr-freight-api/src/common/booking-guards.ts
index 9769a7f18..d478da8f3 100644
--- a/apps/edr-freight-api/src/common/booking-guards.ts
+++ b/apps/edr-freight-api/src/common/booking-guards.ts
@@ -14,6 +14,13 @@ export const BookingStaff = (permission: string | string[]) =>
     ),
   );
 
+/**
+ * Read-only reference data (yard dropdowns, search filters): any signed-in
+ * staff. Menu/page visibility stays permission-gated in the frontend — this
+ * only lets forms populate their lookups.
+ */
+export const StaffReference = () => applyDecorators(UseGuards(JwtGuard));
+
 export const BookingView = () => BookingStaff(FREIGHT_PERMS.bookings.view);
 
 export const TrainSchedulingView = () =>
diff --git a/apps/edr-freight-api/src/common/export-received-gate.spec.ts b/apps/edr-freight-api/src/common/export-received-gate.spec.ts
new file mode 100644
index 000000000..6aaa24a26
--- /dev/null
+++ b/apps/edr-freight-api/src/common/export-received-gate.spec.ts
@@ -0,0 +1,39 @@
+import { BadRequestException } from '@nestjs/common';
+import type { DataSource } from 'typeorm';
+
+import { assertExportReceivedWithGrn } from './export-received-gate';
+
+const db = (rows: unknown[]) =>
+  ({ query: jest.fn().mockResolvedValue(rows) }) as unknown as DataSource;
+
+describe('assertExportReceivedWithGrn', () => {
+  it('passes when the export booking has a received row with a GRN', async () => {
+    await expect(
+      assertExportReceivedWithGrn(db([{ '?column?': 1 }]), {
+        id: 'b-1',
+        tradeDirection: 'EXPORT',
+      }),
+    ).resolves.toBeUndefined();
+  });
+
+  it('rejects an export booking with nothing received', async () => {
+    await expect(
+      assertExportReceivedWithGrn(db([]), { id: 'b-1', tradeDirection: 'EXPORT' }),
+    ).rejects.toBeInstanceOf(BadRequestException);
+  });
+
+  it('never blocks import — it loads off a train, not out of the warehouse', async () => {
+    const source = db([]);
+    await expect(
+      assertExportReceivedWithGrn(source, { id: 'b-1', tradeDirection: 'IMPORT' }),
+    ).resolves.toBeUndefined();
+    // Import short-circuits before querying.
+    expect((source.query as jest.Mock)).not.toHaveBeenCalled();
+  });
+
+  it('does not block intercity cargo', async () => {
+    await expect(
+      assertExportReceivedWithGrn(db([]), { id: 'b-1', tradeDirection: 'DOMESTIC' }),
+    ).resolves.toBeUndefined();
+  });
+});
diff --git a/apps/edr-freight-api/src/common/export-received-gate.ts b/apps/edr-freight-api/src/common/export-received-gate.ts
new file mode 100644
index 000000000..0e1728800
--- /dev/null
+++ b/apps/edr-freight-api/src/common/export-received-gate.ts
@@ -0,0 +1,50 @@
+import { BadRequestException } from '@nestjs/common';
+import type { DataSource, EntityManager } from 'typeorm';
+
+/** The booking fields the gate needs. */
+export interface ExportLoadGateBooking {
+  id: string;
+  tradeDirection?: string | null;
+}
+
+/**
+ * Export cargo may not be loaded onto its train until it has physically reached
+ * the warehouse and been issued a GRN — whether it got there by first-mile or by
+ * the customer's own truck, and even though a wagon is already allocated. An
+ * allocation is a plan; the GRN is the proof the goods are actually in hand.
+ *
+ * Several loading paths (per-yard load, workspace confirm-loaded) marked cargo
+ * loaded straight off the allocation, skipping the warehouse, so a booking could
+ * ride the train with nothing ever received. This closes that for export; import
+ * loads off a train and is unaffected.
+ *
+ * "Received with a GRN" = an inventory row that has reached the warehouse
+ * (RECEIVED or any later stage) and carries a GRN, in the column or the notes
+ * fallback older rows use.
+ */
+export async function assertExportReceivedWithGrn(
+  db: DataSource | EntityManager,
+  booking: ExportLoadGateBooking,
+): Promise<void> {
+  if (booking.tradeDirection !== 'EXPORT') return;
+
+  const [row] = await db.query(
+    `SELECT 1
+       FROM freight.warehouse_inventory inv
+      WHERE inv.booking_id = $1
+        AND inv.deleted_at IS NULL
+        AND inv.status IN ('RECEIVED', 'STORED', 'RESERVED', 'READY_FOR_LOADING', 'LOADED', 'DISPATCHED')
+        AND COALESCE(
+              NULLIF(TRIM(inv.grn_number), ''),
+              substring(inv.notes FROM 'GRN Number: ([^\\n\\r]+)')
+            ) IS NOT NULL
+      LIMIT 1`,
+    [booking.id],
+  );
+
+  if (!row) {
+    throw new BadRequestException(
+      'This export booking has not been received at the warehouse yet — receive its cargo and generate a GRN before loading it onto the train.',
+    );
+  }
+}
diff --git a/apps/edr-freight-api/src/common/mile-financials.util.ts b/apps/edr-freight-api/src/common/mile-financials.util.ts
new file mode 100644
index 000000000..2f5288048
--- /dev/null
+++ b/apps/edr-freight-api/src/common/mile-financials.util.ts
@@ -0,0 +1,61 @@
+import { DataSource } from 'typeorm';
+
+type MileRecord = {
+  bookingId?: string | null;
+  advancedPayment?: number | string | null;
+  booking?: {
+    cargoTotalWeightVgm?: number | string | null;
+    bookingContainers?: Array<{
+      units?: Array<{ vgmTons?: number | string | null }> | null;
+    }> | null;
+  } | null;
+};
+
+/**
+ * Display enrichment for first/last-mile lists (Assign Vehicle modal etc.):
+ *  - Advance payment: mile records are created with advanced_payment 0 — the
+ *    real advance is the FIRST_MILE/LAST_MILE line the customer already paid
+ *    on the booking invoice.
+ *  - Cargo tons: container bookings often carry tonnage on the per-unit VGMs
+ *    while cargo_total_weight_vgm stays 0 — fall back to the summed units.
+ * Fills both in-memory on the loaded records; nothing is persisted.
+ */
+export async function attachMileFinancials(
+  dataSource: DataSource,
+  records: MileRecord[],
+  chargeType: 'FIRST_MILE' | 'LAST_MILE',
+): Promise<void> {
+  for (const r of records) {
+    const b = r.booking;
+    if (!b || Number(b.cargoTotalWeightVgm) > 0) continue;
+    const unitTons = (b.bookingContainers ?? []).reduce(
+      (sum, bc) =>
+        sum + (bc.units ?? []).reduce((s, u) => s + (Number(u.vgmTons) || 0), 0),
+      0,
+    );
+    if (unitTons > 0) b.cargoTotalWeightVgm = Number(unitTons.toFixed(3));
+  }
+
+  const needAdvance = records.filter(
+    (r) => r.bookingId && !(Number(r.advancedPayment) > 0),
+  );
+  if (!needAdvance.length) return;
+
+  const rows: Array<{ bookingId: string; amount: string }> = await dataSource.query(
+    `SELECT i.source_id AS "bookingId", SUM(il.amount) AS amount
+       FROM freight.invoice_lines il
+       JOIN freight.invoices i ON i.id = il.invoice_id AND i.deleted_at IS NULL
+      WHERE i.source = 'booking'
+        AND i.status = 'PAID'
+        AND i.source_id = ANY($1::text[])
+        AND il.charge_type = $2
+        AND il.deleted_at IS NULL
+      GROUP BY i.source_id`,
+    [needAdvance.map((r) => r.bookingId), chargeType],
+  );
+  const byBooking = new Map(rows.map((r) => [r.bookingId, Number(r.amount)]));
+  for (const r of needAdvance) {
+    const paid = byBooking.get(r.bookingId as string);
+    if (paid) r.advancedPayment = paid;
+  }
+}
diff --git a/apps/edr-freight-api/src/migrations/2060000000000-CreateYardDistances.ts b/apps/edr-freight-api/src/migrations/2060000000000-CreateYardDistances.ts
new file mode 100644
index 000000000..42352237d
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/2060000000000-CreateYardDistances.ts
@@ -0,0 +1,66 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+/**
+ * Configured rail distance between two yards (Configuration → Yard Distances).
+ * Route creation resolves each segment's km from here (symmetric lookup:
+ * one A↔B row serves both directions) instead of accepting free-text km,
+ * and snapshots the value onto route_milestones.distance_km.
+ *
+ * Uniqueness is a partial index (deleted_at IS NULL) so a soft-deleted pair
+ * can be re-created.
+ */
+export class CreateYardDistances2060000000000 implements MigrationInterface {
+  name = 'CreateYardDistances2060000000000';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      CREATE TABLE IF NOT EXISTS freight.yard_distances (
+        id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+        from_yard_id uuid NOT NULL REFERENCES freight.yards(id),
+        to_yard_id uuid NOT NULL REFERENCES freight.yards(id),
+        distance_km numeric(10,2) NOT NULL,
+        created_at timestamptz NOT NULL DEFAULT now(),
+        updated_at timestamptz NOT NULL DEFAULT now(),
+        deleted_at timestamptz
+      );
+    `);
+    await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS idx_yard_distances_from_yard
+        ON freight.yard_distances (from_yard_id);
+    `);
+    await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS idx_yard_distances_to_yard
+        ON freight.yard_distances (to_yard_id);
+    `);
+    await queryRunner.query(`
+      CREATE UNIQUE INDEX IF NOT EXISTS uq_yard_distances_pair
+        ON freight.yard_distances (from_yard_id, to_yard_id)
+        WHERE deleted_at IS NULL;
+    `);
+    // Backfill from segments already stored on existing routes so editing them
+    // does not immediately fail the "pair not configured" check. One row per
+    // unordered pair; where routes disagree the longest segment wins.
+    await queryRunner.query(`
+      INSERT INTO freight.yard_distances (from_yard_id, to_yard_id, distance_km)
+      SELECT DISTINCT ON (LEAST(prev_yard_id, yard_id), GREATEST(prev_yard_id, yard_id))
+        prev_yard_id, yard_id, distance_km
+      FROM (
+        SELECT
+          yard_id,
+          distance_km,
+          LAG(yard_id) OVER (PARTITION BY route_id ORDER BY sequence_no) AS prev_yard_id
+        FROM freight.route_milestones
+        WHERE deleted_at IS NULL
+      ) segments
+      WHERE prev_yard_id IS NOT NULL
+        AND distance_km IS NOT NULL
+        AND distance_km > 0
+      ORDER BY LEAST(prev_yard_id, yard_id), GREATEST(prev_yard_id, yard_id), distance_km DESC
+      ON CONFLICT DO NOTHING;
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`DROP TABLE IF EXISTS freight.yard_distances;`);
+  }
+}
diff --git a/apps/edr-freight-api/src/migrations/2440000000000-AddHandoverEdrAssignment.ts b/apps/edr-freight-api/src/migrations/2440000000000-AddHandoverEdrAssignment.ts
new file mode 100644
index 000000000..c8f48af05
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/2440000000000-AddHandoverEdrAssignment.ts
@@ -0,0 +1,35 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+/**
+ * Per-truck EDR last-mile handovers. `truck_assignment_id` FKs
+ * customer_truck_assignments (self-haul only), so EDR trucks need their own
+ * link to the last-mile vehicle assignment that hauled the goods. Generated
+ * when the EDR truck exits the warehouse (with its exit paper) and signed by
+ * the customer in the portal — one per truck, or booking-level (both ids null)
+ * when the truck cannot be resolved.
+ */
+export class AddHandoverEdrAssignment2440000000000 implements MigrationInterface {
+  name = 'AddHandoverEdrAssignment2440000000000';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      ALTER TABLE freight.booking_handovers
+        ADD COLUMN IF NOT EXISTS edr_assignment_id uuid
+          REFERENCES freight.last_mile_vehicle_assignments(id) ON DELETE SET NULL;
+    `);
+    await queryRunner.query(`
+      CREATE UNIQUE INDEX IF NOT EXISTS "UQ_booking_handovers_booking_edr_truck"
+      ON freight.booking_handovers (booking_id, edr_assignment_id)
+      WHERE deleted_at IS NULL AND edr_assignment_id IS NOT NULL;
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `DROP INDEX IF EXISTS freight."UQ_booking_handovers_booking_edr_truck";`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE freight.booking_handovers DROP COLUMN IF EXISTS edr_assignment_id;`,
+    );
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/auth/freight-me.service.ts b/apps/edr-freight-api/src/modules/auth/freight-me.service.ts
index 50c90213b..006b482f4 100644
--- a/apps/edr-freight-api/src/modules/auth/freight-me.service.ts
+++ b/apps/edr-freight-api/src/modules/auth/freight-me.service.ts
@@ -1,5 +1,7 @@
 import { Injectable } from '@nestjs/common';
+import { InjectDataSource } from '@nestjs/typeorm';
 import type { TCurrentUser } from '@tria-plc/api-common/modules/auth/types/current-user.type';
+import { DataSource } from 'typeorm';
 
 import {
   collectPermissionKeys,
@@ -9,7 +11,35 @@ import { PERMISSIONS_CATALOG } from '../../seed/freight-permissions.registry';
 
 @Injectable()
 export class FreightMeService {
-  getEnrichedProfile(user: TCurrentUser) {
+  constructor(@InjectDataSource() private readonly dataSource: DataSource) {}
+
+  /**
+   * The JWT session snapshot has no position TYPE, but the backoffice needs it
+   * (GL sub-positions are identified by type key). Resolved live from IAM.
+   */
+  private async lookupPositionType(
+    positionId: string | undefined,
+  ): Promise<{ key: string; name: unknown } | null> {
+    if (!positionId) return null;
+    try {
+      const rows: { key: string; name: unknown }[] = await this.dataSource.query(
+        `SELECT pt.key, pt.name
+           FROM iam.positions p
+           JOIN iam.position_types pt ON pt.id = p.position_type_id
+          WHERE p.id = $1`,
+        [positionId],
+      );
+      return rows[0] ?? null;
+    } catch {
+      return null; // iam schema unreachable — degrade to the old payload shape
+    }
+  }
+
+  async getEnrichedProfile(user: TCurrentUser) {
+    const positionType = await this.lookupPositionType(
+      user.employee?.position?.id,
+    );
+
     const employee = user.employee
       ? [
           {
@@ -27,6 +57,7 @@ export class FreightMeService {
                     isDelegate: user.employee.position.isDelegate,
                     parentPositionId: user.employee.position.parentPositionId,
                     permissions: user.employee.position.permissions ?? [],
+                    positionType,
                   },
                 ]
               : [],
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
index 1bdde71be..caa41f5e9 100644
--- 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
@@ -168,6 +168,17 @@ export class BookingLifecycleNotifierService {
     });
   }
 
+  /** Intercity documents approved → booking waits in the ride-along pool. */
+  intercityDocumentsApproved(b: Booking): void {
+    const msg =
+      `Documents for intercity booking ${b.reference} are approved. ` +
+      `Operations will assign your shipment to a passing train; payment opens once it is accepted.`;
+    void this.notifyContact(b, msg, 'DOCUMENTS APPROVED');
+    this.inApp(b, 'Documents approved', msg, {
+      type: NotificationType.CLEARANCE_DECISION,
+    });
+  }
+
   /** Operations returned the operation request for changes. */
   operationChangesRequested(b: Booking, note: string): void {
     const msg =
diff --git a/apps/edr-freight-api/src/modules/bookings/booking-pricing.service.spec.ts b/apps/edr-freight-api/src/modules/bookings/booking-pricing.service.spec.ts
index 3f4f64186..fecd9111a 100644
--- a/apps/edr-freight-api/src/modules/bookings/booking-pricing.service.spec.ts
+++ b/apps/edr-freight-api/src/modules/bookings/booking-pricing.service.spec.ts
@@ -163,11 +163,12 @@ describe('BookingPricingService — domestic corridor', () => {
         computeBaseRailLinesWithRates: (
           b: Booking,
           input: { containers: [] },
-        ) => Promise<{ lineItems: Array<{ amount: number }> }>;
+        ) => Promise<{ lineItems: Array<{ amount: number }>; blocked: string[] }>;
       }
     ).computeBaseRailLinesWithRates(booking, { containers: [] });
 
     expect(result.lineItems).toHaveLength(0);
+    expect(result.blocked).toHaveLength(1);
   });
 
   it('does not price containers off a rate configured for a different leg', async () => {
@@ -197,4 +198,45 @@ describe('BookingPricingService — domestic corridor', () => {
 
     expect(result.lineItems).toHaveLength(0);
   });
+
+  // A mixed booking where only one container size has a configured rate must
+  // hard-block, not silently carry the unconfigured size for free.
+  it('blocks the unconfigured container size and prices the configured one', async () => {
+    const fortyOnly: Rate = {
+      ...intercityContainerUsd,
+      id: 'rate-ct-40-only',
+      containerTypeId: 'ct-40',
+    } as Rate;
+    ratesService.findLiveRates.mockResolvedValue([fortyOnly]);
+
+    const booking = {
+      id: 'b-5',
+      freightType: 'CONTAINER',
+      tradeDirection: 'DOMESTIC',
+      paymentCurrency: 'USD',
+      originYardId: MOJO,
+      destinationYardId: DIRE,
+      bookingContainers: [],
+    } as unknown as Booking;
+
+    const result = await (
+      service as unknown as {
+        computeBaseRailLinesWithRates: (
+          b: Booking,
+          input: {
+            containers: Array<{ containerTypeId: string; quantity: number }>;
+          },
+        ) => Promise<{ lineItems: Array<{ code: string }>; blocked: string[] }>;
+      }
+    ).computeBaseRailLinesWithRates(booking, {
+      containers: [
+        { containerTypeId: 'ct-40', quantity: 2 },
+        { containerTypeId: 'ct-20', quantity: 3 },
+      ],
+    });
+
+    expect(result.lineItems).toHaveLength(1);
+    expect(result.blocked).toHaveLength(1);
+    expect(result.blocked[0]).toContain('rate is configured');
+  });
 });
diff --git a/apps/edr-freight-api/src/modules/bookings/booking-pricing.service.ts b/apps/edr-freight-api/src/modules/bookings/booking-pricing.service.ts
index cbb630794..32aa1a880 100644
--- a/apps/edr-freight-api/src/modules/bookings/booking-pricing.service.ts
+++ b/apps/edr-freight-api/src/modules/bookings/booking-pricing.service.ts
@@ -137,8 +137,12 @@ export class BookingPricingService {
     const lineItems: PriceLineItemDto[] = [];
     let total = 0;
 
-    const { lineItems: baseLines, usedRates: baseRates } =
-      await this.computeBaseRailLinesWithRates(booking, evalInput, frozenRates);
+    const {
+      lineItems: baseLines,
+      usedRates: baseRates,
+      warnings: baseWarnings,
+      blocked: baseBlocked,
+    } = await this.computeBaseRailLinesWithRates(booking, evalInput, frozenRates);
     for (const line of baseLines) {
       lineItems.push(line);
       total += line.amount;
@@ -247,8 +251,8 @@ export class BookingPricingService {
       usedRates: [...usedRatesMap.values()],
       appliedModifiers: ruleResult.appliedModifiers,
       priorityScore: ruleResult.priorityScore,
-      warnings: ruleResult.warnings,
-      hardBlocked: ruleResult.hardBlocked,
+      warnings: [...ruleResult.warnings, ...baseWarnings],
+      hardBlocked: [...ruleResult.hardBlocked, ...baseBlocked],
       overweightLines,
     };
   }
@@ -454,7 +458,12 @@ export class BookingPricingService {
     booking: Booking,
     evalInput: BookingEvaluationInput,
     frozenRates: Map<string, ContractRateSnapshot> | null = null,
-  ): Promise<{ lineItems: PriceLineItemDto[]; usedRates: Rate[] }> {
+  ): Promise<{
+    lineItems: PriceLineItemDto[];
+    usedRates: Rate[];
+    warnings: string[];
+    blocked: string[];
+  }> {
     const liveRates = await this.ratesService.findLiveRates();
     const paymentCurrency = booking.paymentCurrency;
     const isEtbBooking = paymentCurrency === 'ETB';
@@ -476,6 +485,8 @@ export class BookingPricingService {
 
     const lines: PriceLineItemDto[] = [];
     const usedRatesMap = new Map<string, Rate>();
+    const warnings: string[] = [];
+    const blocked: string[] = [];
     const wagonCount = await this.resolveWagonCount(booking);
 
     for (const container of evalInput.containers) {
@@ -487,47 +498,66 @@ export class BookingPricingService {
         booking.originYardId,
         booking.destinationYardId,
       );
-      if (!rate) continue;
-
-      usedRatesMap.set(rate.id, rate);
-      const unitUsd = Number(rate.rateValue);
       // H15: frozen contract rate for this container size, when present — its
       // unitPrice is already in the booking currency (no USD→currency convert).
+      // It also stands on its own: a contract line prices off the agreed rate
+      // even when nobody configured a live rate for this leg + type yet.
       const frozen = await this.frozenRateForContainer(
         frozenRates,
         container.containerTypeId,
         paymentCurrency,
       );
+      const label = await this.containerTypeLabel(container.containerTypeId);
+      if (!rate && !frozen) {
+        // Never price this line off another container type's (or another
+        // route's) rate, and never let an unpriced line through: a booking
+        // that ships a container type nobody configured a rate for would be
+        // carried for free. Hard-block instead — the customer drops the line
+        // or EDR configures the rate.
+        blocked.push(
+          `No ${rateType} rate is configured for ${label} on this route — ` +
+            `the booking cannot be priced. Remove the ${label} line or ask EDR ` +
+            'to configure its rate for this origin → destination.',
+        );
+        continue;
+      }
+
+      const rateUnit = rate?.rateUnit ?? 'PER_CONTAINER';
       let amount: number;
       let unitAmount: number;
       if (frozen) {
         unitAmount = Number(frozen.unitPrice);
         amount = this.amountForUnit(
-          rate.rateUnit,
+          rateUnit,
           unitAmount,
           container.quantity,
           wagonCount,
         );
       } else {
-        const usdAmount = this.amountForRate(rate, container.quantity, wagonCount);
+        const unitUsd = Number(rate!.rateValue);
+        const usdAmount = this.amountForRate(rate!, container.quantity, wagonCount);
         amount = isEtbBooking ? Math.round(usdAmount * usdToEtb) : usdAmount;
         unitAmount = isEtbBooking ? Math.round(unitUsd * usdToEtb) : unitUsd;
       }
-      const label = await this.containerTypeLabel(container.containerTypeId);
+      if (rate) usedRatesMap.set(rate.id, rate);
       lines.push({
         code: rateType,
         description: `${label} rail freight`,
         amount,
         unitAmount,
-        unit: rate.rateUnit,
-        quantity: this.effectiveUnitQuantity(rate.rateUnit, container.quantity, wagonCount),
+        unit: rateUnit,
+        quantity: this.effectiveUnitQuantity(rateUnit, container.quantity, wagonCount),
         currency: paymentCurrency,
       });
     }
 
-    if (lines.length === 0) {
+    if (lines.length === 0 && evalInput.containers.length === 0) {
       // Bulk (and any booking with no container lines) still has to price off a
       // rate configured for this leg — never one belonging to another route.
+      // Container bookings never reach this fallback: their lines price per
+      // container type above or stay unpriced with a warning — falling back to
+      // a corridor rate of a DIFFERENT container type billed once (qty 1) is
+      // how a 38-container booking was invoiced 40 USD instead of 1900.
       const fallback = liveRates.find(
         (r) =>
           r.rateType === rateType &&
@@ -570,10 +600,18 @@ export class BookingPricingService {
           quantity: this.effectiveUnitQuantity(fallback.rateUnit, quantity, wagonCount),
           currency: paymentCurrency,
         });
+      } else if (isBulk) {
+        // Same rule as container lines: bulk freight with no rate on this leg
+        // must not proceed unpriced.
+        blocked.push(
+          `No ${rateType} rate is configured for this route — the booking ` +
+            'cannot be priced. Ask EDR to configure the rate for this ' +
+            'origin → destination.',
+        );
       }
     }
 
-    return { lineItems: lines, usedRates: [...usedRatesMap.values()] };
+    return { lineItems: lines, usedRates: [...usedRatesMap.values()], warnings, blocked };
   }
 
   /**
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 29fec7997..36705daa0 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
@@ -7,6 +7,7 @@ import {
   Logger,
   Optional,
 } from "@nestjs/common";
+import { OnEvent } from "@nestjs/event-emitter";
 
 import { BookingBatchService } from '../train-scheduling/booking-batch.service';
 import { eatDay } from '../train-scheduling/batch-window.util';
@@ -349,6 +350,22 @@ export class BookingTransitionService {
     return fresh;
   }
 
+  /**
+   * Import EDR last-mile: every handover signed + every truck departed ⇒ the
+   * warehouses module delivered the goods and asks the booking to complete.
+   * Best-effort — a booking already COMPLETED (or not yet in transit) just logs.
+   */
+  @OnEvent('import.handover.completed')
+  async onImportHandoverCompleted(payload: { bookingId: string }): Promise<void> {
+    try {
+      await this.complete(payload.bookingId);
+    } catch (err) {
+      this.logger.log(
+        `Booking ${payload.bookingId} not auto-completed on handover sign: ${(err as Error).message}`,
+      );
+    }
+  }
+
   async complete(bookingId: string): Promise<Booking> {
     const booking = await this.bookingsService.findById(bookingId);
     assertBookingStatus(booking, ["IN_TRANSIT", "ARRIVED"]);
@@ -840,6 +857,22 @@ export class BookingTransitionService {
       }
     }
 
+    // Intercity: there is no shipment-day request step — an approved booking
+    // goes straight to FULLY_EXECUTED, which is what the intercity ride-along
+    // pool keys on. Staff then accept it onto a passing train (that accept
+    // opens the pay window).
+    if (booking.tradeDirection === "DOMESTIC") {
+      const now = new Date();
+      await this.bookingsRepository.update(bookingId, {
+        status: "FULLY_EXECUTED",
+        fullyExecutedAt: now,
+        lockedAt: booking.lockedAt ?? now,
+      } as never);
+      const fresh = await this.bookingsService.findById(bookingId);
+      this.notifier.intercityDocumentsApproved(fresh);
+      return fresh;
+    }
+
     await this.bookingsRepository.update(bookingId, {
       status: "CLEARANCE_READY",
     } as never);
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 7f8718480..e95cd65c9 100644
--- a/apps/edr-freight-api/src/modules/bookings/bookings.service.ts
+++ b/apps/edr-freight-api/src/modules/bookings/bookings.service.ts
@@ -1213,9 +1213,9 @@ export class BookingsService {
 
   /**
    * Batched version of the findById flag: marks each page item whose booking
-   * has a generated-but-unsigned SELF_HAUL handover, so list rows (portal
-   * dashboard) can show "Approve delivery" for exactly the generated→signed
-   * window. One query for the whole page.
+   * has a generated-but-unsigned handover (self-haul or EDR last-mile), so list
+   * rows (portal dashboard) can show "Approve delivery" for exactly the
+   * generated→signed window. One query for the whole page.
    */
   private async attachHandoverFlags(bookings: Booking[]): Promise<void> {
     const ids = bookings.map((b) => b.id);
@@ -1224,8 +1224,7 @@ export class BookingsService {
       `SELECT DISTINCT booking_id AS "bookingId"
          FROM freight.booking_handovers
         WHERE booking_id = ANY($1::uuid[])
-          AND signed_at IS NULL AND deleted_at IS NULL
-          AND mile_type = 'SELF_HAUL'`,
+          AND signed_at IS NULL AND deleted_at IS NULL`,
       [ids],
     );
     const pending = new Set(rows.map((r) => r.bookingId));
@@ -1559,14 +1558,12 @@ export class BookingsService {
         schedule?.status ?? null;
     }
 
-    // A generated-but-unsigned SELF_HAUL handover means the customer must approve
-    // delivery from the portal (booking-based, one per booking). EDR last-mile
-    // handovers are per delivering truck and signed by the receiver at the door,
-    // so they never surface the portal "Approve delivery" action.
+    // A generated-but-unsigned handover means the customer must approve delivery
+    // from the portal. Self-haul: booking-based, one per booking. EDR last-mile:
+    // per delivering truck (generated on truck exit), signed one by one.
     const [pendingHandover] = await this.dataSource.query(
       `SELECT 1 FROM freight.booking_handovers
         WHERE booking_id = $1 AND signed_at IS NULL AND deleted_at IS NULL
-          AND mile_type = 'SELF_HAUL'
         LIMIT 1`,
       [id],
     );
diff --git a/apps/edr-freight-api/src/modules/bookings/clearance.util.spec.ts b/apps/edr-freight-api/src/modules/bookings/clearance.util.spec.ts
index 969de5583..0e858e702 100644
--- a/apps/edr-freight-api/src/modules/bookings/clearance.util.spec.ts
+++ b/apps/edr-freight-api/src/modules/bookings/clearance.util.spec.ts
@@ -1,7 +1,10 @@
 import {
   clearanceSettingCode,
   clearanceOutputSettingCode,
+  clearanceCodesForBooking,
+  INTERCITY_DOCUMENTS_SETTING_CODE,
 } from './clearance.util';
+import type { Booking } from './entities/booking.entity';
 
 describe('clearance.util — clearanceSettingCode', () => {
   it('resolves import container with/without customs', () => {
@@ -24,9 +27,49 @@ describe('clearance.util — clearanceSettingCode', () => {
     );
   });
 
-  it('returns null for DOMESTIC (no clearance gate)', () => {
-    expect(clearanceSettingCode('DOMESTIC', 'CONTAINER', true)).toBeNull();
-    expect(clearanceSettingCode('DOMESTIC', 'BULK', false)).toBeNull();
+  it('resolves the intercity document set for DOMESTIC regardless of customs/freight', () => {
+    expect(clearanceSettingCode('DOMESTIC', 'CONTAINER', true)).toBe(
+      INTERCITY_DOCUMENTS_SETTING_CODE,
+    );
+    expect(clearanceSettingCode('DOMESTIC', 'BULK', false)).toBe(
+      INTERCITY_DOCUMENTS_SETTING_CODE,
+    );
+  });
+});
+
+describe('clearance.util — clearanceCodesForBooking (intercity)', () => {
+  const base = {
+    tradeDirection: 'DOMESTIC',
+    freightType: 'CONTAINER',
+    serviceType: null,
+    customsClearingEnabled: false,
+  };
+
+  it('GENERAL drawdowns and direct bookings carry the per-booking intercity set', () => {
+    const general = clearanceCodesForBooking({
+      ...base,
+      contractId: 'c1',
+      contractKind: 'GENERAL',
+    } as unknown as Booking);
+    expect(general.inputCode).toBe(INTERCITY_DOCUMENTS_SETTING_CODE);
+    expect(general.outputCode).toBeNull();
+
+    const direct = clearanceCodesForBooking({
+      ...base,
+      contractId: null,
+      contractKind: null,
+    } as unknown as Booking);
+    expect(direct.inputCode).toBe(INTERCITY_DOCUMENTS_SETTING_CODE);
+  });
+
+  it('ONE_TIME contract drawdowns skip the per-booking set (contract collected it)', () => {
+    const drawdown = clearanceCodesForBooking({
+      ...base,
+      contractId: 'c1',
+      contractKind: 'ONE_TIME',
+    } as unknown as Booking);
+    expect(drawdown.inputCode).toBeNull();
+    expect(drawdown.outputCode).toBeNull();
   });
 });
 
diff --git a/apps/edr-freight-api/src/modules/bookings/clearance.util.ts b/apps/edr-freight-api/src/modules/bookings/clearance.util.ts
index 1cc6503df..5a63beca6 100644
--- a/apps/edr-freight-api/src/modules/bookings/clearance.util.ts
+++ b/apps/edr-freight-api/src/modules/bookings/clearance.util.ts
@@ -9,11 +9,19 @@ import { Booking } from './entities/booking.entity';
 type Op = 'import' | 'export';
 type Freight = 'container' | 'bulk';
 
+/**
+ * The single (admin-configured) document set intercity shipments upload.
+ * DOMESTIC has no customs, so one shared set serves contracts and bookings:
+ * ONE_TIME collects it at contract level, GENERAL per booking — Operations
+ * reviews either way.
+ */
+export const INTERCITY_DOCUMENTS_SETTING_CODE = 'intercity_documents';
+
 /** Trade direction → clearance operation. DOMESTIC has no customs clearance. */
 function operationFor(tradeDirection: string): Op | null {
   if (tradeDirection === 'IMPORT') return 'import';
   if (tradeDirection === 'EXPORT') return 'export';
-  return null; // DOMESTIC / intercity — no clearance gate
+  return null; // DOMESTIC / intercity — no customs operation
 }
 
 function freightFor(freightType: string): Freight {
@@ -26,6 +34,9 @@ export function clearanceSettingCode(
   freightType: string,
   includesCustoms: boolean,
 ): string | null {
+  // Intercity: no customs, but the admin-configured intercity document set is
+  // still collected and ops-reviewed before the shipment may board a train.
+  if (tradeDirection === 'DOMESTIC') return INTERCITY_DOCUMENTS_SETTING_CODE;
   const op = operationFor(tradeDirection);
   if (!op) return null;
   const freight = freightFor(freightType);
@@ -66,6 +77,16 @@ export function clearanceCodesForBooking(booking: Booking): {
   const includesCustoms =
     Boolean(booking.serviceType?.includesCustoms) ||
     Boolean(booking.customsClearingEnabled);
+  // Intercity drawdowns under a ONE_TIME contract already cleared the intercity
+  // document set on the CONTRACT (post-signature); only GENERAL drawdowns and
+  // direct (contract-less) bookings carry the per-booking set.
+  if (
+    booking.tradeDirection === 'DOMESTIC' &&
+    booking.contractId &&
+    booking.contractKind === 'ONE_TIME'
+  ) {
+    return { inputCode: null, outputCode: null, includesCustoms: false };
+  }
   return {
     inputCode: clearanceSettingCode(
       booking.tradeDirection,
diff --git a/apps/edr-freight-api/src/modules/contracts/contract-booking.service.ts b/apps/edr-freight-api/src/modules/contracts/contract-booking.service.ts
index e230380f0..a4360447d 100644
--- a/apps/edr-freight-api/src/modules/contracts/contract-booking.service.ts
+++ b/apps/edr-freight-api/src/modules/contracts/contract-booking.service.ts
@@ -198,11 +198,12 @@ export class ContractBookingService {
     // GENERAL without customs (Path A) ALSO clears per booking: the customer
     // uploads his own clearance proof on each booking and Operations reviews it
     // (legacy AWAITING_DOCUMENTS → DOCUMENTS_UNDER_REVIEW → CLEARANCE_READY →
-    // requestOperation machine). DOMESTIC has no border, so no gate.
+    // requestOperation machine). GENERAL intercity (DOMESTIC) follows the same
+    // per-booking gate with the intercity document set — ops finalize then puts
+    // the booking straight into the ride-along pool (FULLY_EXECUTED), since
+    // intercity has no shipment-day request step.
     const generalSelfClear =
-      contract.contractKind === 'GENERAL' &&
-      !contract.customsClearingEnabled &&
-      contract.tradeDirection !== 'DOMESTIC';
+      contract.contractKind === 'GENERAL' && !contract.customsClearingEnabled;
 
     // Intercity (DOMESTIC) bookings ride on a passing import/export train:
     // there is no window and no date — staff accept them onto a train at
@@ -300,48 +301,63 @@ export class ContractBookingService {
         } as never),
     );
 
-    // Persist container lines + per-unit container numbers (container freight only).
-    if (freightType === 'CONTAINER') {
-      await this.persistContainers(booking.id, contract, dto);
-    }
-
-    // Reload with containers to compute the total from contract unit rates × qty.
-    const loaded = await this.bookingsRepository.findByIdWithFiles(booking.id);
-    if (loaded) {
+    // Everything between the insert and the priced update must be all-or-nothing:
+    // a throw part-way (container persist, weight rules, pricing) would otherwise
+    // leave a 0-price, container-less row in OPERATION_REQUEST_PENDING that
+    // occupies the one-time contract's single active-booking slot until the
+    // doc-review sweep expires it — and the clearance cycle still points at the
+    // previous booking, so the hub keeps offering "Rebook" against a dead draft.
+    try {
+      // Persist container lines + per-unit container numbers (container freight only).
       if (freightType === 'CONTAINER') {
-        await this.applyWeightResults(loaded);
+        await this.persistContainers(booking.id, contract, dto);
       }
-      const computed = await this.bookingPricingService.computePriceForBooking(loaded);
-      // Reject a zero-price booking outright. A total of 0 means no contract rate
-      // matched the route/container (or the rate is unset), so the booking is not
-      // valid to ship or invoice. Roll back the just-inserted row + its lines so it
-      // does NOT occupy the one-time contract's single active-booking slot — else
-      // the customer's retry hits "already has an active booking" against a broken
-      // draft. The customer must fix the contract's rates, then rebook.
-      if (!(computed.totalAmount > 0)) {
-        await this.bookingsRepository.deleteContainers(booking.id);
-        await this.bookingsRepository.hardDelete(booking.id);
-        throw new BadRequestException(
-          'Booking price came out as 0 — no contract rate matches this ' +
-            'route/cargo. Set the contract rate and try again.',
-        );
-      }
-      await this.bookingsRepository.update(booking.id, {
-        totalAmount: computed.totalAmount,
-        priorityScore: computed.priorityScore,
-        pricingBreakdown: {
-          lineItems: computed.lineItems,
+
+      // Reload with containers to compute the total from contract unit rates × qty.
+      const loaded = await this.bookingsRepository.findByIdWithFiles(booking.id);
+      if (loaded) {
+        if (freightType === 'CONTAINER') {
+          await this.applyWeightResults(loaded);
+        }
+        const computed = await this.bookingPricingService.computePriceForBooking(loaded);
+        // A partially-priced booking (e.g. 40ft has a rate, 20ft has none) has
+        // a positive total, so the zero-price gate below misses it — enforce
+        // the pricing hard blocks first. The catch below rolls everything back.
+        if (computed.hardBlocked.length > 0) {
+          throw new BadRequestException(computed.hardBlocked.join('; '));
+        }
+        // Reject a zero-price booking outright. A total of 0 means no contract rate
+        // matched the route/container (or the rate is unset), so the booking is not
+        // valid to ship or invoice. The catch below rolls back the row + its lines.
+        if (!(computed.totalAmount > 0)) {
+          throw new BadRequestException(
+            'Booking price came out as 0 — no contract rate matches this ' +
+              'route/cargo. Set the contract rate and try again.',
+          );
+        }
+        await this.bookingsRepository.update(booking.id, {
           totalAmount: computed.totalAmount,
-          currency: computed.currency,
-          generatedAt: new Date().toISOString(),
-        },
-      } as never);
-      await this.bookingPricingService.createPricingSnapshots(
-        booking.id,
-        computed.usedRates,
-        computed.appliedModifiers,
-      );
-      warnings.push(...computed.warnings);
+          priorityScore: computed.priorityScore,
+          pricingBreakdown: {
+            lineItems: computed.lineItems,
+            totalAmount: computed.totalAmount,
+            currency: computed.currency,
+            generatedAt: new Date().toISOString(),
+          },
+        } as never);
+        await this.bookingPricingService.createPricingSnapshots(
+          booking.id,
+          computed.usedRates,
+          computed.appliedModifiers,
+        );
+        warnings.push(...computed.warnings);
+      }
+    } catch (err) {
+      await this.bookingsRepository
+        .deleteContainers(booking.id)
+        .catch(() => undefined);
+      await this.bookingsRepository.hardDelete(booking.id).catch(() => undefined);
+      throw err;
     }
 
     // Wagon consolidation gate. A container drawdown whose lines leave a partial
@@ -734,15 +750,20 @@ export class ContractBookingService {
         const computed = await this.bookingPricingService.computePriceForBooking(loaded);
         // A zero price means no contract rate matches — roll the cargo back so
         // the instance stays CLEARANCE_READY and can be completed again once
-        // the contract rates are fixed (the clearance work is not lost).
-        if (!(computed.totalAmount > 0)) {
+        // the contract rates are fixed (the clearance work is not lost). A
+        // pricing hard block (e.g. one of two container sizes has no rate)
+        // rolls back the same way: a partially-priced total is positive but
+        // the booking must not proceed.
+        if (!(computed.totalAmount > 0) || computed.hardBlocked.length > 0) {
           await this.bookingsRepository.deleteContainers(booking.id);
           await this.bookingsRepository.update(booking.id, {
             cargoTotalWeightVgm: 0,
           } as never);
           throw new BadRequestException(
-            'Booking price came out as 0 — no contract rate matches this ' +
-              'route/cargo. Set the contract rate and try again.',
+            computed.hardBlocked.length > 0
+              ? computed.hardBlocked.join('; ')
+              : 'Booking price came out as 0 — no contract rate matches this ' +
+                'route/cargo. Set the contract rate and try again.',
           );
         }
         await this.bookingsRepository.update(booking.id, {
@@ -1599,17 +1620,23 @@ export class ContractBookingService {
       throw new BadRequestException('At least one container line is required.');
     }
 
-    const allowedSizes = new Set(
+    // Size strings arrive in mixed formats ("20ft" from the contract scope,
+    // bare "20" from the rebook seed) — compare numerically so format never
+    // fails a size that IS in scope.
+    const allowedSizesFt = new Set(
       (contract.cargoScope ?? [])
-        .map((c) => c.containerSize)
-        .filter((s): s is string => !!s),
+        .map((c) => parseInt(c.containerSize ?? '', 10))
+        .filter((n) => Number.isFinite(n)),
     );
 
     const containerRepo = this.dataSource.getRepository(BookingContainer);
     const unitRepo = this.dataSource.getRepository(BookingContainerUnit);
 
     for (const line of lines) {
-      if (allowedSizes.size && !allowedSizes.has(line.containerSize)) {
+      if (
+        allowedSizesFt.size &&
+        !allowedSizesFt.has(parseInt(line.containerSize, 10))
+      ) {
         throw new BadRequestException(
           `Container size ${line.containerSize} is outside the contract scope.`,
         );
@@ -1746,11 +1773,33 @@ export class ContractBookingService {
       }),
     );
 
+    // Same size-scope gate persistContainers enforces at create, surfaced as a
+    // blocking preview error so the form can't confirm a size the contract does
+    // not cover. Numeric compare — "20" and "20ft" are the same size.
+    const allowedSizesFt = new Set(
+      (contract.cargoScope ?? [])
+        .map((c) => parseInt(c.containerSize ?? '', 10))
+        .filter((n) => Number.isFinite(n)),
+    );
+    const scopeErrors = allowedSizesFt.size
+      ? [
+          ...new Set(
+            lines
+              .map((l) => l.containerSize)
+              .filter((s) => !allowedSizesFt.has(parseInt(s, 10))),
+          ),
+        ].map((s) => `Container size ${s} is outside the contract scope.`)
+      : [];
+
     // The unsaved twin of the booking createUnderContract would write: same
     // denormalized contract fields, same container-line math. No id → the
     // pricing service derives wagon counts from the in-memory lines.
     const route = await this.resolveRoute(contract, dto.contractRouteId);
     const previewBooking = Object.assign(new Booking(), {
+      // contractId makes the preview price off the contract's frozen rate
+      // snapshots exactly like the persisted booking will — without it the
+      // preview total is 0 on a leg with no live rate and the form blocks.
+      contractId: contract.id,
       freightType: contract.freightType,
       tradeDirection: contract.tradeDirection,
       paymentCurrency: contract.paymentCurrency,
@@ -1858,7 +1907,10 @@ export class ContractBookingService {
       overweightSurchargeAmount,
       currency: computed.currency,
       pairingErrors,
-      capacityErrors,
+      // Pricing hard blocks (missing rate for a container size / requested
+      // service) ride the capacity-errors channel so the form hard-blocks in
+      // the preview instead of failing at the create call.
+      capacityErrors: [...scopeErrors, ...capacityErrors, ...computed.hardBlocked],
       containerClashErrors,
       spaceErrors,
       lineItems: computed.lineItems,
diff --git a/apps/edr-freight-api/src/modules/contracts/contract-clearance.util.ts b/apps/edr-freight-api/src/modules/contracts/contract-clearance.util.ts
index bc1b4ad49..2d26f51dc 100644
--- a/apps/edr-freight-api/src/modules/contracts/contract-clearance.util.ts
+++ b/apps/edr-freight-api/src/modules/contracts/contract-clearance.util.ts
@@ -1,4 +1,5 @@
 import { Contract } from './entities/contract.entity';
+import { INTERCITY_DOCUMENTS_SETTING_CODE } from '../bookings/clearance.util';
 
 /**
  * Resolves which seeded clearance FileUploadSetting applies to a contract during
@@ -29,13 +30,17 @@ function freightFor(freightType: string): Freight {
  *   own (smaller) clearance proof set → `contract_clearance_selfclear_{op}_{freight}`,
  *   reviewed by Operations rather than GL.
  *
- * DOMESTIC/intercity has no border, so no clearance gate applies on either path.
+ * DOMESTIC/intercity has no border, but a ONE_TIME intercity contract still
+ * collects the admin-configured intercity document set after both signatures
+ * (ops-reviewed, like Path A). GENERAL intercity contracts skip the contract
+ * gate and collect the same set per booking instead.
  */
 export function contractClearanceSettingCode(
   tradeDirection: string,
   freightType: string,
   includesCustoms: boolean,
 ): string | null {
+  if (tradeDirection === 'DOMESTIC') return INTERCITY_DOCUMENTS_SETTING_CODE;
   const op = operationFor(tradeDirection);
   if (!op) return null;
   const freight = freightFor(freightType);
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
index e35bd2bf5..ac4fe2a0f 100644
--- a/apps/edr-freight-api/src/modules/contracts/contract-notifier.service.ts
+++ b/apps/edr-freight-api/src/modules/contracts/contract-notifier.service.ts
@@ -143,6 +143,19 @@ export class ContractNotifierService {
     this.inApp(c, 'Contract rejected', msg);
   }
 
+  /**
+   * A later approver sent the contract back to an earlier stage of the chain.
+   * Staff-only: the customer is not involved in an internal send-back — their
+   * contract simply stays "under approval".
+   */
+  sentBackToStep(c: Contract, targetRole: string, reason: string): void {
+    this.inAppStaff(
+      c,
+      'Contract returned in approval chain',
+      `Contract ${c.reference} was sent back to the ${targetRole} step. Reason: ${reason}`,
+    );
+  }
+
   /** Staff requested changes before approval. */
   changesRequested(c: Contract, note: string): void {
     const msg =
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 ba825dfaa..ba4fe442f 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
@@ -41,6 +41,7 @@ import {
   ContractDocumentSnapshotInput,
 } from './entities/contract.entity';
 import { ContractSignerRole } from './entities/contract-signature.entity';
+import { ContractApprovalStep } from './entities/contract-approval-step.entity';
 import { SignContractDto } from './dto/sign-contract.dto';
 
 /** The editable contract-document draft returned for the accept/edit dialog. */
@@ -576,17 +577,24 @@ export class ContractTransitionService {
 
   /**
    * 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.
+   * approver must supply a reason, and picks where the rejection lands:
+   *
+   * - **To the customer** (`returnToStepId` omitted — the only option for the
+   *   first approver): terminal. The whole contract moves to REJECTED with a
+   *   REJECTION review note visible to the customer, who must resubmit.
+   * - **To an earlier approver** (`returnToStepId` = an already-APPROVED
+   *   earlier step): internal send-back. That step and everything after it
+   *   reset to PENDING and the chain re-runs from there; the contract stays
+   *   PENDING_APPROVAL and the customer never sees it. E.g. the director can
+   *   return a contract to line staff, who fix it and approve again, after
+   *   which every later stage re-approves in order.
    */
   async rejectStep(
     contractId: string,
     stepId: string,
     actorId: string,
     reason: string,
+    returnToStepId?: string,
   ): Promise<Contract> {
     const contract = await this.contractsService.findById(contractId);
     assertContractStatus(contract, ['PENDING_APPROVAL', 'APPROVED_PENDING_SIGNATURE']);
@@ -594,6 +602,20 @@ export class ContractTransitionService {
     const step = await this.contractsRepository.findApprovalStepById(contractId, stepId);
     if (!step) throw new BadRequestException('Approval step not found');
 
+    // Only the approver whose turn it is may reject — same ordering rule as
+    // approveStep. Without this, an already-actioned or future step could be
+    // "rejected" and wipe chain state it never owned.
+    const next = await this.contractsRepository.findNextPendingApprovalStep(contractId);
+    if (!next || next.id !== step.id) {
+      throw new BadRequestException(
+        'Only the current pending approval step can be rejected',
+      );
+    }
+
+    if (returnToStepId) {
+      return this.sendBackToStep(contract, step, actorId, reason, returnToStepId);
+    }
+
     await this.contractsRepository.completeApprovalStep(step.id, actorId, 'REJECTED', reason);
 
     await this.contractsRepository.createReviewNote(
@@ -616,6 +638,67 @@ export class ContractTransitionService {
     return updated;
   }
 
+  /**
+   * Internal send-back branch of rejectStep: return the contract to an earlier,
+   * already-approved stage of the chain instead of rejecting it outright.
+   * Deliberately NOT the terminal path: no clearance-fee expiry (the contract
+   * is still alive) and no customer-facing REJECTION note — the trail is a
+   * staff note plus a backoffice inbox ping.
+   */
+  private async sendBackToStep(
+    contract: Contract,
+    rejectingStep: ContractApprovalStep,
+    actorId: string,
+    reason: string,
+    returnToStepId: string,
+  ): Promise<Contract> {
+    const target = await this.contractsRepository.findApprovalStepById(
+      contract.id,
+      returnToStepId,
+    );
+    if (!target) throw new BadRequestException('Return-to approval step not found');
+    if (target.stepOrder >= rejectingStep.stepOrder) {
+      throw new BadRequestException(
+        'A rejection can only be returned to an EARLIER step in the chain — to reject to the customer, omit returnToStepId',
+      );
+    }
+    if (target.status !== 'APPROVED') {
+      throw new BadRequestException(
+        `Return-to step ${target.requiredRole} has not approved yet (status ${target.status})`,
+      );
+    }
+
+    // Staff-visible trail. Written before the reset so the reason survives the
+    // wipe of per-step notes.
+    await this.contractsRepository.createReviewNote(
+      contract.id,
+      `Returned to ${target.requiredRole} (step ${target.stepOrder}) by ${rejectingStep.requiredRole}: ${reason}`,
+      'STAFF_NOTE',
+      actorId,
+      'STAFF',
+    );
+
+    // Chain re-runs from the target stage: it and every later step (including
+    // the rejecting one) go back to PENDING. Legacy approved-by columns are
+    // left stale on purpose — approval steps are the source of truth and the
+    // columns get re-stamped on re-approval.
+    await this.contractsRepository.resetApprovalStepsFrom(
+      contract.id,
+      target.stepOrder,
+    );
+
+    // A send-back can only happen mid-chain, so the contract must remain (or
+    // return to) PENDING_APPROVAL — relevant when rejecting from
+    // APPROVED_PENDING_SIGNATURE.
+    await this.contractsRepository.update(contract.id, {
+      status: 'PENDING_APPROVAL',
+    } as never);
+
+    const updated = await this.contractsService.findById(contract.id);
+    this.notifier.sentBackToStep(updated, target.requiredRole, reason);
+    return updated;
+  }
+
   /** Approve one approval step in sequence; → APPROVED when all complete. */
   async approveStep(
     contractId: string,
@@ -1035,8 +1118,8 @@ export class ContractTransitionService {
     };
 
     // A clearance gate applies whenever a clearance doc set resolves — Path B
-    // (customs) or Path A self-clearance (IMPORT/EXPORT without customs). DOMESTIC
-    // resolves to null on both paths and skips straight to executed.
+    // (customs), Path A self-clearance (IMPORT/EXPORT without customs), or the
+    // intercity document set (DOMESTIC, ops-reviewed like Path A).
     const clearanceCode = contractClearanceSettingCode(
       contract.tradeDirection,
       contract.freightType,
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 249568046..6ca4473cd 100644
--- a/apps/edr-freight-api/src/modules/contracts/contracts.controller.ts
+++ b/apps/edr-freight-api/src/modules/contracts/contracts.controller.ts
@@ -442,7 +442,10 @@ export class ContractsController {
     FREIGHT_PERMS.contracts.approveDirector,
     FREIGHT_PERMS.contracts.approveCeo,
   ])
-  @ApiOperation({ summary: 'Reject one approval step (terminal → REJECTED)' })
+  @ApiOperation({
+    summary:
+      'Reject one approval step — to the customer (terminal → REJECTED) or, via returnToStepId, back to an earlier approver (chain re-runs from there)',
+  })
   rejectStep(
     @Param('id', ParseUUIDPipe) id: string,
     @Param('stepId', ParseUUIDPipe) stepId: string,
@@ -454,6 +457,7 @@ export class ContractsController {
       stepId,
       resolveAuthUserId(user),
       dto.reason,
+      dto.returnToStepId,
     );
   }
 
diff --git a/apps/edr-freight-api/src/modules/contracts/contracts.repository.ts b/apps/edr-freight-api/src/modules/contracts/contracts.repository.ts
index 533b51b3b..67a3bd101 100644
--- a/apps/edr-freight-api/src/modules/contracts/contracts.repository.ts
+++ b/apps/edr-freight-api/src/modules/contracts/contracts.repository.ts
@@ -156,6 +156,7 @@ export class ContractsRepository extends BaseRepository<Contract> {
     // direct download. Loaded separately to keep pagination counts correct.
     await this.attachContractFiles(items);
     await this.attachClearancePhases(items);
+    await this.attachRejectionNotes(items);
 
     const totalPages = pageSize > 0 ? Math.ceil(total / pageSize) : 0;
     return {
@@ -228,6 +229,31 @@ export class ContractsRepository extends BaseRepository<Contract> {
     }
   }
 
+  /**
+   * Attach the latest REJECTION review-note body to each REJECTED contract so
+   * list consumers (portal rows, backoffice queues) can show why without a
+   * per-contract detail fetch. One query per page, like `attachContractFiles`.
+   */
+  private async attachRejectionNotes(contracts: Contract[]): Promise<void> {
+    const rejected = contracts.filter((c) => c.status === 'REJECTED');
+    if (rejected.length === 0) return;
+    const ids = rejected.map((c) => c.id);
+    const rows: Array<{ contract_id: string; body: string }> =
+      await this.dataSource.query(
+        `SELECT DISTINCT ON (contract_id) contract_id, body
+           FROM freight.contract_review_notes
+          WHERE contract_id = ANY($1)
+            AND note_type = 'REJECTION'
+            AND deleted_at IS NULL
+          ORDER BY contract_id, created_at DESC`,
+        [ids],
+      );
+    const byContract = new Map(rows.map((r) => [r.contract_id, r.body]));
+    for (const contract of rejected) {
+      contract.latestRejectionNote = byContract.get(contract.id) ?? null;
+    }
+  }
+
   async getStatusCounts(): Promise<Record<string, number>> {
     const rows = await this.repository
       .createQueryBuilder('contract')
@@ -368,6 +394,25 @@ export class ContractsRepository extends BaseRepository<Contract> {
     });
   }
 
+  /**
+   * Send-back reset: every step at or after `fromStepOrder` returns to PENDING
+   * with its actor/verdict cleared, so the chain re-runs from that stage. The
+   * send-back reason lives in the review-note trail, not on the wiped steps.
+   */
+  async resetApprovalStepsFrom(
+    contractId: string,
+    fromStepOrder: number,
+  ): Promise<void> {
+    await this.dataSource
+      .getRepository(ContractApprovalStep)
+      .createQueryBuilder()
+      .update()
+      .set({ status: 'PENDING', actedByStaffId: null, actedAt: null, note: null })
+      .where('contract_id = :contractId', { contractId })
+      .andWhere('step_order >= :fromStepOrder', { fromStepOrder })
+      .execute();
+  }
+
   /** Check if all approval steps are approved. */
   async allApprovalStepsComplete(contractId: string): Promise<boolean> {
     const pending = await this.dataSource.getRepository(ContractApprovalStep).count({
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 b51403991..65f0637f0 100644
--- a/apps/edr-freight-api/src/modules/contracts/contracts.service.ts
+++ b/apps/edr-freight-api/src/modules/contracts/contracts.service.ts
@@ -636,6 +636,47 @@ export class ContractsService {
       }
     }
 
+    // Surface the rejection reason. The approval-step note is wiped on
+    // send-back resets, so the review-note trail is the only durable source.
+    if (contract.status === 'REJECTED') {
+      try {
+        const note = await this.contractsRepository.findLatestReviewNote(
+          contract.id,
+          'REJECTION',
+        );
+        contract.latestRejectionNote = note?.body ?? null;
+      } catch {
+        contract.latestRejectionNote = null;
+      }
+    }
+
+    // Surface the send-back reason to the returned-to approver, but only while
+    // it is still actionable: once any step acts after the send-back the note
+    // is stale and stays out of the response (the trail keeps it in the DB).
+    if (contract.status === 'PENDING_APPROVAL') {
+      try {
+        const note = await this.contractsRepository.findLatestReviewNote(
+          contract.id,
+          'STAFF_NOTE',
+        );
+        // Stale when any step acted after it (send-back resolved) or when the
+        // chain itself is newer than the note (fresh cycle after a resubmit).
+        const staleAfter = Math.max(
+          0,
+          ...(contract.approvalSteps ?? []).flatMap((s) => [
+            s.actedAt ? new Date(s.actedAt).getTime() : 0,
+            s.createdAt ? new Date(s.createdAt).getTime() : 0,
+          ]),
+        );
+        contract.latestSendBackNote =
+          note && new Date(note.createdAt).getTime() > staleAfter
+            ? note.body
+            : null;
+      } catch {
+        contract.latestSendBackNote = null;
+      }
+    }
+
     return contract;
   }
 
diff --git a/apps/edr-freight-api/src/modules/contracts/dto/approve-step.dto.ts b/apps/edr-freight-api/src/modules/contracts/dto/approve-step.dto.ts
index 173857159..9a86a5b4e 100644
--- a/apps/edr-freight-api/src/modules/contracts/dto/approve-step.dto.ts
+++ b/apps/edr-freight-api/src/modules/contracts/dto/approve-step.dto.ts
@@ -1,5 +1,5 @@
 import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
-import { IsOptional, IsString, MinLength } from 'class-validator';
+import { IsOptional, IsString, IsUUID, MinLength } from 'class-validator';
 
 export class ApproveStepDto {
   @ApiProperty({ description: 'LINE_STAFF | DIRECTOR | CEO' })
@@ -26,6 +26,22 @@ export class RejectStepDto {
   @IsString()
   @MinLength(1)
   reason!: string;
+
+  /**
+   * Where the rejection lands. Omitted → the customer: the contract goes to
+   * REJECTED and the customer must resubmit (unchanged legacy behaviour, and
+   * the only option for the first approver in the chain). Set to an EARLIER
+   * approved step's id → send-back: that step and everything after it reset to
+   * PENDING and the chain re-runs from there; the contract never leaves
+   * PENDING_APPROVAL and the customer is not involved.
+   */
+  @ApiPropertyOptional({
+    description:
+      'Id of an earlier approval step to send the contract back to. Omit to reject to the customer.',
+  })
+  @IsOptional()
+  @IsUUID()
+  returnToStepId?: string;
 }
 
 export class CancelContractDto {
diff --git a/apps/edr-freight-api/src/modules/contracts/entities/clearance-incident.entity.ts b/apps/edr-freight-api/src/modules/contracts/entities/clearance-incident.entity.ts
index 6d2afce3c..2ece44f12 100644
--- a/apps/edr-freight-api/src/modules/contracts/entities/clearance-incident.entity.ts
+++ b/apps/edr-freight-api/src/modules/contracts/entities/clearance-incident.entity.ts
@@ -13,6 +13,7 @@ export const INCIDENT_TYPES = [
   'CONTAINER_OPENED',
   'CONTAINER_DAMAGED',
   'FLUID_LEAKING',
+  'OTHER',
 ] as const;
 export type IncidentType = (typeof INCIDENT_TYPES)[number];
 
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 b5e0b8fb1..4838d3f52 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
@@ -326,4 +326,19 @@ export class Contract extends BaseEntity {
    * asked them to fix. Lives in contract_review_notes, not a column here.
    */
   latestChangeRequestNote?: string | null;
+
+  /**
+   * Body of the most recent REJECTION review note, attached by
+   * ContractsService.findById when status is REJECTED so both backoffice and
+   * portal can show why. Lives in contract_review_notes, not a column here.
+   */
+  latestRejectionNote?: string | null;
+
+  /**
+   * Body of the most recent send-back STAFF_NOTE, attached by
+   * ContractsService.findById while the contract is PENDING_APPROVAL and no
+   * approval step has acted since the send-back. Lives in
+   * contract_review_notes, not a column here.
+   */
+  latestSendBackNote?: string | null;
 }
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 0143f0796..948853e22 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
@@ -2,6 +2,7 @@ import { BadRequestException, Injectable, Logger, NotFoundException } from '@nes
 import { FindOptionsWhere, In, IsNull, Not } from 'typeorm';
 import { InjectDataSource } from '@nestjs/typeorm';
 import { DataSource } from 'typeorm';
+import { attachMileFinancials } from '../../common/mile-financials.util';
 import { VehicleAvailability } from '../vehicles/entities/vehicle.entity';
 import { BookingsRepository } from "../bookings/bookings.repository";
 import { DriversService } from "../drivers/drivers.service";
@@ -66,6 +67,7 @@ export class FirstMileService {
     for (const r of records) {
       (r as FirstMile & { invoice?: unknown }).invoice = byId.get(r.id) ?? null;
     }
+    await attachMileFinancials(this.dataSource, records, 'FIRST_MILE');
   }
 
   /** Resolve a vehicle's driver + human labels, for stamping mile events onto
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 b31a2ecbb..601e03aec 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
@@ -12,6 +12,7 @@ import {
   SELF_HAUL_CONFLICT_MESSAGE,
   usesEdrMileService,
 } from '../../common/mile-haulage.util';
+import { attachMileFinancials } from '../../common/mile-financials.util';
 import {
   assertBulkTonnageRemains,
   assertTruckCountWithinContainers,
@@ -88,6 +89,7 @@ export class LastMileService {
     for (const r of records) {
       (r as LastMile & { invoice?: unknown }).invoice = byId.get(r.id) ?? null;
     }
+    await attachMileFinancials(this.dataSource, records, 'LAST_MILE');
   }
 
   /** Resolve a vehicle's driver + human labels, for stamping mile events onto
@@ -333,6 +335,8 @@ export class LastMileService {
       driverPhone: string | null;
       truckType: string | null;
       containerNumber: string | null;
+      arrivedAt: string | null;
+      departedAt: string | null;
     }>
   > {
     const [lm] = await this.lastMileRepository.findAll({
@@ -347,9 +351,11 @@ export class LastMileService {
       ? lm.vehicleAssignments.map((va) => ({
           vehicle: va.vehicle,
           containerNumber: va.containerNumber ?? null,
+          arrivedAt: va.arrivedAt ?? null,
+          departedAt: va.departedAt ?? null,
         }))
       : lm.vehicle
-        ? [{ vehicle: lm.vehicle, containerNumber: null }]
+        ? [{ vehicle: lm.vehicle, containerNumber: null, arrivedAt: null, departedAt: null }]
         : [];
 
     const out: Array<{
@@ -361,8 +367,10 @@ export class LastMileService {
       driverPhone: string | null;
       truckType: string | null;
       containerNumber: string | null;
+      arrivedAt: string | null;
+      departedAt: string | null;
     }> = [];
-    for (const { vehicle, containerNumber } of sources) {
+    for (const { vehicle, containerNumber, arrivedAt, departedAt } of sources) {
       if (!vehicle) continue;
       let driverName = vehicle.assignedDriverName ?? null;
       let driverLicense: string | null = null;
@@ -386,6 +394,8 @@ export class LastMileService {
         driverPhone,
         truckType: vehicle.vehicleType || null,
         containerNumber,
+        arrivedAt: arrivedAt ? new Date(arrivedAt).toISOString() : null,
+        departedAt: departedAt ? new Date(departedAt).toISOString() : null,
       });
     }
     return out;
diff --git a/apps/edr-freight-api/src/modules/locomotives/dto/filter-locomotives.dto.ts b/apps/edr-freight-api/src/modules/locomotives/dto/filter-locomotives.dto.ts
index c634d5efb..a42dcd220 100644
--- a/apps/edr-freight-api/src/modules/locomotives/dto/filter-locomotives.dto.ts
+++ b/apps/edr-freight-api/src/modules/locomotives/dto/filter-locomotives.dto.ts
@@ -1,5 +1,6 @@
 import { ApiPropertyOptional } from '@nestjs/swagger';
-import { IsIn, IsOptional, IsUUID } from 'class-validator';
+import { Transform } from 'class-transformer';
+import { IsBoolean, IsIn, IsOptional, IsUUID } from 'class-validator';
 
 import {
   LOCOMOTIVE_STATUSES,
@@ -21,4 +22,29 @@ export class FilterLocomotivesDto {
   @IsOptional()
   @IsUUID()
   currentYardId?: string;
+
+  /**
+   * Drop locomotives already coupled to a built train — the train-builder
+   * "change locomotives" picker uses this so a loco that belongs to another
+   * train is never offered (the backend would 409 on save anyway). Combine with
+   * `excludeTrainId` to keep the CURRENT train's own locos in the list.
+   */
+  @ApiPropertyOptional({
+    description: 'Exclude locomotives already coupled to any built train',
+  })
+  @IsOptional()
+  @Transform(({ value }) => value === true || value === 'true')
+  @IsBoolean()
+  excludeCoupled?: boolean;
+
+  /**
+   * When `excludeCoupled` is set, locos coupled to THIS train are still kept
+   * (they are valid picks — you are editing that train's consist).
+   */
+  @ApiPropertyOptional({
+    description: 'Train id whose own coupled locomotives are NOT excluded',
+  })
+  @IsOptional()
+  @IsUUID()
+  excludeTrainId?: string;
 }
diff --git a/apps/edr-freight-api/src/modules/locomotives/locomotives.repository.ts b/apps/edr-freight-api/src/modules/locomotives/locomotives.repository.ts
index 18a42205e..3ad5b3650 100644
--- a/apps/edr-freight-api/src/modules/locomotives/locomotives.repository.ts
+++ b/apps/edr-freight-api/src/modules/locomotives/locomotives.repository.ts
@@ -3,7 +3,8 @@ import { Injectable } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
 import { Repository } from 'typeorm';
 
-import { Locomotive } from './entities/locomotive.entity';
+import { Locomotive, type LocomotiveStatus, type LocomotiveType } from './entities/locomotive.entity';
+import { TrainLocomotive } from '../trains/entities/train-locomotive.entity';
 
 @Injectable()
 export class LocomotivesRepository extends BaseRepository<Locomotive> {
@@ -14,6 +15,47 @@ export class LocomotivesRepository extends BaseRepository<Locomotive> {
     super(repository);
   }
 
+  /**
+   * List locomotives for the train-builder coupling picker: the usual
+   * status/type/yard filters, plus optional exclusion of any loco already
+   * coupled to a built train. `keepTrainId` spares that one train's own locos
+   * from the exclusion so they stay selectable while editing its consist.
+   */
+  findForCoupling(opts: {
+    status?: LocomotiveStatus;
+    locomotiveType?: LocomotiveType;
+    currentYardId?: string;
+    excludeCoupled?: boolean;
+    keepTrainId?: string;
+  }): Promise<Locomotive[]> {
+    const qb = this.repository
+      .createQueryBuilder('locomotive')
+      .leftJoinAndSelect('locomotive.currentYard', 'currentYard')
+      .orderBy('locomotive.code', 'ASC');
+
+    if (opts.status) qb.andWhere('locomotive.status = :status', { status: opts.status });
+    if (opts.locomotiveType)
+      qb.andWhere('locomotive.locomotiveType = :type', { type: opts.locomotiveType });
+    if (opts.currentYardId)
+      qb.andWhere('locomotive.currentYardId = :yardId', { yardId: opts.currentYardId });
+
+    if (opts.excludeCoupled) {
+      // NOT EXISTS a link to a DIFFERENT train. Own-train links are kept so the
+      // consist being edited still lists its current locomotives.
+      const sub = this.repository.manager
+        .getRepository(TrainLocomotive)
+        .createQueryBuilder('tl')
+        .select('1')
+        .where('tl.locomotiveId = locomotive.id');
+      if (opts.keepTrainId) {
+        sub.andWhere('tl.trainId != :keepTrainId', { keepTrainId: opts.keepTrainId });
+      }
+      qb.andWhere(`NOT EXISTS (${sub.getQuery()})`).setParameters(sub.getParameters());
+    }
+
+    return qb.getMany();
+  }
+
   /**
    * A live locomotive already holding this name, compared the same way the
    * `UQ_locomotives_name_active` index compares: case- and whitespace-
diff --git a/apps/edr-freight-api/src/modules/locomotives/locomotives.service.ts b/apps/edr-freight-api/src/modules/locomotives/locomotives.service.ts
index cbf9dfc0c..46e0ae415 100644
--- a/apps/edr-freight-api/src/modules/locomotives/locomotives.service.ts
+++ b/apps/edr-freight-api/src/modules/locomotives/locomotives.service.ts
@@ -29,6 +29,17 @@ export class LocomotivesService {
   }
 
   findAll(filter: FilterLocomotivesDto): Promise<Locomotive[]> {
+    // The coupling picker needs a NOT-EXISTS against the train link table, so it
+    // takes the query-builder path; the plain list keeps the simple where.
+    if (filter.excludeCoupled) {
+      return this.locomotivesRepository.findForCoupling({
+        status: filter.status as LocomotiveStatus | undefined,
+        locomotiveType: filter.locomotiveType as LocomotiveType | undefined,
+        currentYardId: filter.currentYardId,
+        excludeCoupled: true,
+        keepTrainId: filter.excludeTrainId,
+      });
+    }
     return this.locomotivesRepository.findAll({
       where: {
         ...(filter.status ? { status: filter.status as LocomotiveStatus } : {}),
diff --git a/apps/edr-freight-api/src/modules/routes/dto/create-route.dto.ts b/apps/edr-freight-api/src/modules/routes/dto/create-route.dto.ts
index 3f4d2e4ff..3de24835a 100644
--- a/apps/edr-freight-api/src/modules/routes/dto/create-route.dto.ts
+++ b/apps/edr-freight-api/src/modules/routes/dto/create-route.dto.ts
@@ -4,25 +4,22 @@ import {
   ArrayMinSize,
   IsArray,
   IsEnum,
-  IsNumber,
   IsOptional,
   IsUUID,
-  Min,
   ValidateNested,
 } from 'class-validator';
 
 import { RouteStatus } from '../entities/route.entity';
 
+/**
+ * Segment distances are no longer part of the payload — they are resolved
+ * from the configured yard_distances table (Configuration → Yard Distances)
+ * and snapshotted onto route_milestones at create/update.
+ */
 export class CreateRouteMilestoneDto {
   @ApiProperty({ format: 'uuid' })
   @IsUUID()
   yardId!: string;
-
-  @ApiPropertyOptional({ description: 'Km from the previous stop (0 for origin)' })
-  @IsOptional()
-  @IsNumber()
-  @Min(0)
-  distanceKm?: number;
 }
 
 export class CreateRouteDto {
diff --git a/apps/edr-freight-api/src/modules/routes/routes.service.ts b/apps/edr-freight-api/src/modules/routes/routes.service.ts
index 4b1bfd08a..96e6c7fd1 100644
--- a/apps/edr-freight-api/src/modules/routes/routes.service.ts
+++ b/apps/edr-freight-api/src/modules/routes/routes.service.ts
@@ -9,6 +9,7 @@ import { DataSource, In } from 'typeorm';
 
 import { deriveTradeDirection } from '../../common/derive-trade-direction.util';
 import { Yard } from '../rule-engine/entities/yard.entity';
+import { YardDistance } from '../rule-engine/entities/yard-distance.entity';
 import { TrainSchedule } from '../train-schedules/entities/train-schedule.entity';
 import { CreateRouteDto } from './dto/create-route.dto';
 import { FilterRoutesDto } from './dto/filter-routes.dto';
@@ -17,6 +18,9 @@ import { RouteMilestone } from './entities/route-milestone.entity';
 import { formatRouteLabel, Route } from './entities/route.entity';
 import { RoutesRepository } from './routes.repository';
 
+/** Order-insensitive key: distances are symmetric. */
+const pairKey = (a: string, b: string): string => (a < b ? `${a}|${b}` : `${b}|${a}`);
+
 @Injectable()
 export class RoutesService {
   constructor(
@@ -183,47 +187,63 @@ export class RoutesService {
     return this.findById(id);
   }
 
-  private async validateMilestones(
-    milestones: Array<{ yardId: string; distanceKm?: number }>,
-  ) {
+  private async validateMilestones(milestones: Array<{ yardId: string }>) {
     if (milestones.length < 2) {
       throw new BadRequestException('A route requires at least two yards');
     }
 
-    const normalized = milestones.map((milestone, index) => {
-      const distanceKm =
-        index === 0 ? 0 : milestone.distanceKm != null ? milestone.distanceKm : null;
-      if (index > 0 && (distanceKm == null || distanceKm < 0)) {
-        throw new BadRequestException(
-          `Enter segment KM for stop ${index + 1} (from previous yard).`,
-        );
-      }
-      return {
-        yardId: milestone.yardId,
-        sequenceNo: index + 1,
-        distanceKm,
-      };
-    });
-
-    const uniqueYardIds = [...new Set(normalized.map((milestone) => milestone.yardId))];
+    const uniqueYardIds = [...new Set(milestones.map((milestone) => milestone.yardId))];
     const yards = await this.dataSource
       .getRepository(Yard)
       .find({ where: uniqueYardIds.map((id) => ({ id })) });
     const yardIds = new Set(yards.map((yard) => yard.id));
 
-    for (const milestone of normalized) {
+    for (const milestone of milestones) {
       if (!yardIds.has(milestone.yardId)) {
         throw new BadRequestException(`Yard ${milestone.yardId} does not exist`);
       }
     }
 
-    if (normalized[0].yardId === normalized[normalized.length - 1].yardId) {
+    if (milestones[0].yardId === milestones[milestones.length - 1].yardId) {
       throw new BadRequestException('Origin and destination yards must be different');
     }
 
-    const originYardId = normalized[0].yardId;
-    const destinationYardId = normalized[normalized.length - 1].yardId;
     const yardById = new Map(yards.map((yard) => [yard.id, yard]));
+    const distanceByPair = await this.loadDistanceLookup(uniqueYardIds);
+
+    // Segment km come from the configured yard-distance table, not the payload
+    // — a route can only be built over pairs an admin has entered. Distances
+    // are symmetric, so an A→B row also serves B→A.
+    const missingPairs: string[] = [];
+    const normalized = milestones.map((milestone, index) => {
+      if (index === 0) {
+        return { yardId: milestone.yardId, sequenceNo: 1, distanceKm: 0 };
+      }
+      const previousYardId = milestones[index - 1].yardId;
+      const distanceKm = distanceByPair.get(pairKey(previousYardId, milestone.yardId));
+      if (distanceKm == null) {
+        const from = yardById.get(previousYardId);
+        const to = yardById.get(milestone.yardId);
+        missingPairs.push(
+          `${from?.label ?? previousYardId} ↔ ${to?.label ?? milestone.yardId}`,
+        );
+      }
+      return {
+        yardId: milestone.yardId,
+        sequenceNo: index + 1,
+        distanceKm: distanceKm ?? null,
+      };
+    });
+
+    if (missingPairs.length > 0) {
+      throw new BadRequestException(
+        `No distance configured for: ${missingPairs.join(', ')}. ` +
+          'Add the missing yard distances in Configuration → Yard Distances first.',
+      );
+    }
+
+    const originYardId = milestones[0].yardId;
+    const destinationYardId = milestones[milestones.length - 1].yardId;
     const direction = deriveTradeDirection(
       yardById.get(originYardId) ?? { country: null },
       yardById.get(destinationYardId) ?? { country: null },
@@ -236,4 +256,17 @@ export class RoutesService {
       milestones: normalized,
     };
   }
+
+  /** Order-insensitive pair → km map over every configured distance touching the yards. */
+  private async loadDistanceLookup(yardIds: string[]): Promise<Map<string, number>> {
+    const rows = await this.dataSource
+      .getRepository(YardDistance)
+      .find({ where: [{ fromYardId: In(yardIds) }, { toYardId: In(yardIds) }] });
+
+    const lookup = new Map<string, number>();
+    for (const row of rows) {
+      lookup.set(pairKey(row.fromYardId, row.toYardId), Number(row.distanceKm));
+    }
+    return lookup;
+  }
 }
diff --git a/apps/edr-freight-api/src/modules/rule-engine/controllers/cargo-types.controller.ts b/apps/edr-freight-api/src/modules/rule-engine/controllers/cargo-types.controller.ts
index 421e49165..3b1bf6ce1 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/controllers/cargo-types.controller.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/controllers/cargo-types.controller.ts
@@ -3,7 +3,8 @@ import {
   Param, ParseUUIDPipe, Patch, Post, Query,
 } from '@nestjs/common';
 import { ApiBearerAuth, ApiOperation, ApiTags } from '@nestjs/swagger';
-import { RuleEngineManage, RuleEngineView } from '../../../common/rule-engine-guards';
+import { RuleEngineManage } from '../../../common/rule-engine-guards';
+import { StaffReference } from '../../../common/booking-guards';
 import { CreateCargoTypeDto } from '../dto/create-cargo-type.dto';
 import { ListCargoTypesQueryDto } from '../dto/list-rule-engine-query.dto';
 import { MoveOrderDto } from '../dto/move-order.dto';
@@ -18,7 +19,7 @@ export class CargoTypesController {
   constructor(private readonly service: CargoTypesService) {}
 
   @Get()
-  @RuleEngineView('cargo-types')
+  @StaffReference()
   @ApiOperation({ summary: 'List cargo types' })
   findAll(@Query() query: ListCargoTypesQueryDto) {
     return this.service.findAll(query);
@@ -41,7 +42,7 @@ export class CargoTypesController {
   }
 
   @Get(':id')
-  @RuleEngineView('cargo-types')
+  @StaffReference()
   @ApiOperation({ summary: 'Get a cargo type by ID' })
   findOne(@Param('id', ParseUUIDPipe) id: string) {
     return this.service.findById(id);
diff --git a/apps/edr-freight-api/src/modules/rule-engine/controllers/container-types.controller.ts b/apps/edr-freight-api/src/modules/rule-engine/controllers/container-types.controller.ts
index 3c1c27c7c..9ae96af9b 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/controllers/container-types.controller.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/controllers/container-types.controller.ts
@@ -3,7 +3,8 @@ import {
   Param, ParseUUIDPipe, Patch, Post, Query,
 } from '@nestjs/common';
 import { ApiBearerAuth, ApiOperation, ApiTags } from '@nestjs/swagger';
-import { RuleEngineManage, RuleEngineView } from '../../../common/rule-engine-guards';
+import { RuleEngineManage } from '../../../common/rule-engine-guards';
+import { StaffReference } from '../../../common/booking-guards';
 import { CreateContainerTypeDto } from '../dto/create-container-type.dto';
 import { ListContainerTypesQueryDto } from '../dto/list-rule-engine-query.dto';
 import { MoveOrderDto } from '../dto/move-order.dto';
@@ -18,7 +19,7 @@ export class ContainerTypesController {
   constructor(private readonly service: ContainerTypesService) {}
 
   @Get()
-  @RuleEngineView('container-types')
+  @StaffReference()
   @ApiOperation({ summary: 'List container types' })
   findAll(@Query() query: ListContainerTypesQueryDto) {
     return this.service.findAll(query);
@@ -41,7 +42,7 @@ export class ContainerTypesController {
   }
 
   @Get(':id')
-  @RuleEngineView('container-types')
+  @StaffReference()
   @ApiOperation({ summary: 'Get a container type by ID' })
   findOne(@Param('id', ParseUUIDPipe) id: string) {
     return this.service.findById(id);
diff --git a/apps/edr-freight-api/src/modules/rule-engine/controllers/service-types.controller.ts b/apps/edr-freight-api/src/modules/rule-engine/controllers/service-types.controller.ts
index c36d4fd79..85d76b326 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/controllers/service-types.controller.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/controllers/service-types.controller.ts
@@ -2,7 +2,8 @@ import {
   Body, Controller, Delete, Get, HttpCode, HttpStatus,
   Param, ParseUUIDPipe, Patch, Post, Query,
 } from '@nestjs/common';
-import { RuleEngineManage, RuleEngineView } from '../../../common/rule-engine-guards';
+import { RuleEngineManage } from '../../../common/rule-engine-guards';
+import { StaffReference } from '../../../common/booking-guards';
 import { ApiBearerAuth, ApiOperation, ApiTags } from '@nestjs/swagger';
 import { CreateServiceTypeDto } from '../dto/create-service-type.dto';
 import { ListServiceTypesQueryDto } from '../dto/list-rule-engine-query.dto';
@@ -18,7 +19,7 @@ export class ServiceTypesController {
   constructor(private readonly service: ServiceTypesService) {}
 
   @Get()
-  @RuleEngineView('service-types')
+  @StaffReference()
   @ApiOperation({ summary: 'List service types' })
   findAll(@Query() query: ListServiceTypesQueryDto) {
     return this.service.findAll(query);
@@ -41,7 +42,7 @@ export class ServiceTypesController {
   }
 
   @Get(':id')
-  @RuleEngineView('service-types')
+  @StaffReference()
   @ApiOperation({ summary: 'Get a service type by ID' })
   findOne(@Param('id', ParseUUIDPipe) id: string) {
     return this.service.findById(id);
diff --git a/apps/edr-freight-api/src/modules/rule-engine/controllers/shipping-lines.controller.ts b/apps/edr-freight-api/src/modules/rule-engine/controllers/shipping-lines.controller.ts
index baec6b785..f078624eb 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/controllers/shipping-lines.controller.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/controllers/shipping-lines.controller.ts
@@ -2,7 +2,8 @@ import {
   Body, Controller, Delete, Get, HttpCode, HttpStatus,
   Param, ParseUUIDPipe, Patch, Post, Query,
 } from '@nestjs/common';
-import { RuleEngineManage, RuleEngineView } from '../../../common/rule-engine-guards';
+import { RuleEngineManage } from '../../../common/rule-engine-guards';
+import { StaffReference } from '../../../common/booking-guards';
 import { ApiBearerAuth, ApiOperation, ApiTags } from '@nestjs/swagger';
 import { CreateShippingLineDto } from '../dto/create-shipping-line.dto';
 import { ListRuleEngineQueryDto } from '../dto/list-rule-engine-query.dto';
@@ -16,14 +17,14 @@ export class ShippingLinesController {
   constructor(private readonly service: ShippingLinesService) {}
 
   @Get()
-  @RuleEngineView('shipping-lines')
+  @StaffReference()
   @ApiOperation({ summary: 'List shipping lines' })
   findAll(@Query() query: ListRuleEngineQueryDto) {
     return this.service.findAll(query);
   }
 
   @Get(':id')
-  @RuleEngineView('shipping-lines')
+  @StaffReference()
   @ApiOperation({ summary: 'Get a shipping line by ID' })
   findOne(@Param('id', ParseUUIDPipe) id: string) {
     return this.service.findById(id);
diff --git a/apps/edr-freight-api/src/modules/rule-engine/controllers/yard-distances.controller.ts b/apps/edr-freight-api/src/modules/rule-engine/controllers/yard-distances.controller.ts
new file mode 100644
index 000000000..b0ba2c8d5
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/rule-engine/controllers/yard-distances.controller.ts
@@ -0,0 +1,63 @@
+import {
+  Body,
+  Controller,
+  Delete,
+  Get,
+  HttpCode,
+  HttpStatus,
+  Param,
+  ParseUUIDPipe,
+  Patch,
+  Post,
+  Query,
+} from '@nestjs/common';
+import { ApiBearerAuth, ApiOperation, ApiTags } from '@nestjs/swagger';
+import { RuleEngineManage } from '../../../common/rule-engine-guards';
+import { StaffReference } from '../../../common/booking-guards';
+import { CreateYardDistanceDto } from '../dto/create-yard-distance.dto';
+import { ListYardDistancesQueryDto } from '../dto/list-rule-engine-query.dto';
+import { UpdateYardDistanceDto } from '../dto/update-yard-distance.dto';
+import { YardDistancesService } from '../services/yard-distances.service';
+
+@ApiTags('yard-distances')
+@Controller('yard-distances')
+@ApiBearerAuth()
+export class YardDistancesController {
+  constructor(private readonly service: YardDistancesService) {}
+
+  @Get()
+  @StaffReference()
+  @ApiOperation({ summary: 'List yard distances' })
+  findAll(@Query() query: ListYardDistancesQueryDto) {
+    return this.service.findAll(query);
+  }
+
+  @Get(':id')
+  @StaffReference()
+  @ApiOperation({ summary: 'Get a yard distance by ID' })
+  findOne(@Param('id', ParseUUIDPipe) id: string) {
+    return this.service.findById(id);
+  }
+
+  @Post()
+  @RuleEngineManage('yard-distances')
+  @ApiOperation({ summary: 'Create a yard distance' })
+  create(@Body() dto: CreateYardDistanceDto) {
+    return this.service.create(dto);
+  }
+
+  @Patch(':id')
+  @RuleEngineManage('yard-distances')
+  @ApiOperation({ summary: 'Update a yard distance' })
+  update(@Param('id', ParseUUIDPipe) id: string, @Body() dto: UpdateYardDistanceDto) {
+    return this.service.update(id, dto);
+  }
+
+  @Delete(':id')
+  @RuleEngineManage('yard-distances')
+  @HttpCode(HttpStatus.NO_CONTENT)
+  @ApiOperation({ summary: 'Soft-delete a yard distance' })
+  remove(@Param('id', ParseUUIDPipe) id: string) {
+    return this.service.remove(id);
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/rule-engine/controllers/yards.controller.ts b/apps/edr-freight-api/src/modules/rule-engine/controllers/yards.controller.ts
index 40b2764bf..b8f88b6b3 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/controllers/yards.controller.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/controllers/yards.controller.ts
@@ -2,7 +2,8 @@ import {
   Body, Controller, Delete, Get, HttpCode, HttpStatus,
   Param, ParseUUIDPipe, Patch, Post, Query,
 } from '@nestjs/common';
-import { RuleEngineManage, RuleEngineView } from '../../../common/rule-engine-guards';
+import { RuleEngineManage } from '../../../common/rule-engine-guards';
+import { StaffReference } from '../../../common/booking-guards';
 import { ApiBearerAuth, ApiOperation, ApiTags } from '@nestjs/swagger';
 import { CreateYardDto } from '../dto/create-yard.dto';
 import { ListYardsQueryDto } from '../dto/list-rule-engine-query.dto';
@@ -18,7 +19,9 @@ export class YardsController {
   constructor(private readonly service: YardsService) {}
 
   @Get()
-  @RuleEngineView('yards')
+  // Reference read: every staff form/search needs the yard list (origin /
+  // destination pickers), so login is the only requirement.
+  @StaffReference()
   @ApiOperation({ summary: 'List yards' })
   findAll(@Query() query: ListYardsQueryDto) {
     return this.service.findAll(query);
@@ -41,7 +44,7 @@ export class YardsController {
   }
 
   @Get(':id')
-  @RuleEngineView('yards')
+  @StaffReference()
   @ApiOperation({ summary: 'Get a yard by ID' })
   findOne(@Param('id', ParseUUIDPipe) id: string) {
     return this.service.findById(id);
diff --git a/apps/edr-freight-api/src/modules/rule-engine/dto/create-yard-distance.dto.ts b/apps/edr-freight-api/src/modules/rule-engine/dto/create-yard-distance.dto.ts
new file mode 100644
index 000000000..0615debdc
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/rule-engine/dto/create-yard-distance.dto.ts
@@ -0,0 +1,22 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { Transform } from 'class-transformer';
+import { IsNumber, IsUUID, Min } from 'class-validator';
+
+const toNumber = ({ value }: { value: unknown }) =>
+  value === '' || value == null ? value : Number(value);
+
+export class CreateYardDistanceDto {
+  @ApiProperty({ format: 'uuid' })
+  @IsUUID()
+  fromYardId!: string;
+
+  @ApiProperty({ format: 'uuid' })
+  @IsUUID()
+  toYardId!: string;
+
+  @ApiProperty({ description: 'Rail distance between the two yards in kilometres', example: 445 })
+  @Transform(toNumber)
+  @IsNumber()
+  @Min(0.01)
+  distanceKm!: number;
+}
diff --git a/apps/edr-freight-api/src/modules/rule-engine/dto/list-rule-engine-query.dto.ts b/apps/edr-freight-api/src/modules/rule-engine/dto/list-rule-engine-query.dto.ts
index 5718b0531..30241ddaa 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/dto/list-rule-engine-query.dto.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/dto/list-rule-engine-query.dto.ts
@@ -88,6 +88,18 @@ export class ListYardsQueryDto extends ListRuleEngineQueryDto {
   sortBy?: string;
 }
 
+export class ListYardDistancesQueryDto extends PaginationQueryDto {
+  @ApiPropertyOptional({ description: 'Return only distances touching this yard.' })
+  @IsOptional()
+  @IsUUID()
+  yardId?: string;
+
+  @ApiPropertyOptional({ enum: ['createdAt', 'distanceKm'], default: 'createdAt' })
+  @IsOptional()
+  @IsIn(['createdAt', 'distanceKm'])
+  sortBy?: string;
+}
+
 export class ListApprovalRulesQueryDto extends PaginationQueryDto {
   @ApiPropertyOptional({ description: 'Filter by approval chain (director vs standard).' })
   @IsOptional()
diff --git a/apps/edr-freight-api/src/modules/rule-engine/dto/update-yard-distance.dto.ts b/apps/edr-freight-api/src/modules/rule-engine/dto/update-yard-distance.dto.ts
new file mode 100644
index 000000000..8c40876ec
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/rule-engine/dto/update-yard-distance.dto.ts
@@ -0,0 +1,5 @@
+import { PartialType } from '@nestjs/mapped-types';
+
+import { CreateYardDistanceDto } from './create-yard-distance.dto';
+
+export class UpdateYardDistanceDto extends PartialType(CreateYardDistanceDto) {}
diff --git a/apps/edr-freight-api/src/modules/rule-engine/entities/yard-distance.entity.ts b/apps/edr-freight-api/src/modules/rule-engine/entities/yard-distance.entity.ts
new file mode 100644
index 000000000..982079f47
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/rule-engine/entities/yard-distance.entity.ts
@@ -0,0 +1,35 @@
+import { BaseEntity } from '@edr/api-common';
+import { Column, Entity, Index, JoinColumn, ManyToOne } from 'typeorm';
+
+import { Yard } from './yard.entity';
+
+/**
+ * Configured rail distance between two yards. Route creation reads segment
+ * kilometres from here (symmetric: A→B serves B→A too) instead of taking
+ * them as free-text input — see RoutesService.validateMilestones.
+ *
+ * Uniqueness on (from_yard_id, to_yard_id) is a partial index in the DB
+ * (WHERE deleted_at IS NULL) rather than a @Unique decorator, so a
+ * soft-deleted pair can be re-created.
+ */
+@Entity({ schema: 'freight', name: 'yard_distances' })
+@Index(['fromYardId'])
+@Index(['toYardId'])
+export class YardDistance extends BaseEntity {
+  @Column({ name: 'from_yard_id', type: 'uuid' })
+  fromYardId!: string;
+
+  @ManyToOne(() => Yard)
+  @JoinColumn({ name: 'from_yard_id' })
+  fromYard?: Yard;
+
+  @Column({ name: 'to_yard_id', type: 'uuid' })
+  toYardId!: string;
+
+  @ManyToOne(() => Yard)
+  @JoinColumn({ name: 'to_yard_id' })
+  toYard?: Yard;
+
+  @Column({ name: 'distance_km', type: 'decimal', precision: 10, scale: 2 })
+  distanceKm!: string; // decimal columns come back as string in typeorm/pg — keep consistent with RouteMilestone.distanceKm
+}
diff --git a/apps/edr-freight-api/src/modules/rule-engine/interfaces/yard-distances.repository.interface.ts b/apps/edr-freight-api/src/modules/rule-engine/interfaces/yard-distances.repository.interface.ts
new file mode 100644
index 000000000..ca88ae048
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/rule-engine/interfaces/yard-distances.repository.interface.ts
@@ -0,0 +1,17 @@
+import { PaginatedResponse } from '@edr/types';
+import { ListYardDistancesQueryDto } from '../dto/list-rule-engine-query.dto';
+import { YardDistance } from '../entities/yard-distance.entity';
+
+export interface IYardDistancesRepository {
+  findById(id: string): Promise<YardDistance | null>;
+  /** Exact or reverse pair — distances are symmetric (A→B serves B→A). */
+  findBetween(fromYardId: string, toYardId: string): Promise<YardDistance | null>;
+  /** All rows touching any of the given yards, for batch segment lookups. */
+  findTouchingYards(yardIds: string[]): Promise<YardDistance[]>;
+  findPaged(query: ListYardDistancesQueryDto): Promise<PaginatedResponse<YardDistance>>;
+  create(data: Partial<YardDistance>): Promise<YardDistance>;
+  update(id: string, data: Partial<YardDistance>): Promise<YardDistance | null>;
+  softDelete(id: string): Promise<void>;
+}
+
+export const YARD_DISTANCES_REPOSITORY = Symbol('YARD_DISTANCES_REPOSITORY');
diff --git a/apps/edr-freight-api/src/modules/rule-engine/repositories/yard-distances.repository.ts b/apps/edr-freight-api/src/modules/rule-engine/repositories/yard-distances.repository.ts
new file mode 100644
index 000000000..379c92c7d
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/rule-engine/repositories/yard-distances.repository.ts
@@ -0,0 +1,87 @@
+import { PaginatedResponse } from '@edr/types';
+import { Injectable } from '@nestjs/common';
+import { Brackets, DataSource, In, Repository } from 'typeorm';
+import { paginateQuery } from '../../../common/utils/pagination.util';
+import { ListYardDistancesQueryDto } from '../dto/list-rule-engine-query.dto';
+import { YardDistance } from '../entities/yard-distance.entity';
+import { IYardDistancesRepository } from '../interfaces/yard-distances.repository.interface';
+
+@Injectable()
+export class YardDistancesRepository implements IYardDistancesRepository {
+  private readonly repo: Repository<YardDistance>;
+
+  constructor(private readonly dataSource: DataSource) {
+    this.repo = this.dataSource.getRepository(YardDistance);
+  }
+
+  findById(id: string): Promise<YardDistance | null> {
+    return this.repo.findOne({
+      where: { id },
+      relations: { fromYard: true, toYard: true },
+    });
+  }
+
+  findBetween(fromYardId: string, toYardId: string): Promise<YardDistance | null> {
+    return this.repo.findOne({
+      where: [
+        { fromYardId, toYardId },
+        { fromYardId: toYardId, toYardId: fromYardId },
+      ],
+    });
+  }
+
+  findTouchingYards(yardIds: string[]): Promise<YardDistance[]> {
+    if (!yardIds.length) return Promise.resolve([]);
+    return this.repo.find({
+      where: [{ fromYardId: In(yardIds) }, { toYardId: In(yardIds) }],
+    });
+  }
+
+  /** Paged list with server-side search on either yard's label/code. */
+  findPaged(query: ListYardDistancesQueryDto): Promise<PaginatedResponse<YardDistance>> {
+    const qb = this.repo
+      .createQueryBuilder('yardDistance')
+      .leftJoinAndSelect('yardDistance.fromYard', 'fromYard')
+      .leftJoinAndSelect('yardDistance.toYard', 'toYard')
+      .orderBy(`yardDistance.${query.sortBy ?? 'createdAt'}`, query.sortOrder ?? 'ASC')
+      .addOrderBy('fromYard.label', 'ASC');
+
+    if (query.yardId) {
+      qb.andWhere(
+        new Brackets((w) =>
+          w
+            .where('yardDistance.fromYardId = :yardId', { yardId: query.yardId })
+            .orWhere('yardDistance.toYardId = :yardId', { yardId: query.yardId }),
+        ),
+      );
+    }
+    if (query.search) {
+      qb.andWhere(
+        new Brackets((w) =>
+          w
+            .where('fromYard.label ILIKE :search', { search: `%${query.search}%` })
+            .orWhere('fromYard.code ILIKE :search', { search: `%${query.search}%` })
+            .orWhere('toYard.label ILIKE :search', { search: `%${query.search}%` })
+            .orWhere('toYard.code ILIKE :search', { search: `%${query.search}%` }),
+        ),
+      );
+    }
+
+    return paginateQuery(qb, query);
+  }
+
+  async create(data: Partial<YardDistance>): Promise<YardDistance> {
+    const entity = this.repo.create(data);
+    const saved = await this.repo.save(entity);
+    return (await this.findById(saved.id)) ?? saved;
+  }
+
+  async update(id: string, data: Partial<YardDistance>): Promise<YardDistance | null> {
+    await this.repo.update(id, data);
+    return this.findById(id);
+  }
+
+  async softDelete(id: string): Promise<void> {
+    await this.repo.softDelete(id);
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/rule-engine/rule-engine.module.ts b/apps/edr-freight-api/src/modules/rule-engine/rule-engine.module.ts
index 95b5e381d..691992c54 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/rule-engine.module.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/rule-engine.module.ts
@@ -11,6 +11,7 @@ import { RatesController } from './controllers/rates.controller';
 import { ServiceTypesController } from './controllers/service-types.controller';
 import { ShippingLinesController } from './controllers/shipping-lines.controller';
 import { WeightLimitRulesController } from './controllers/weight-limit-rules.controller';
+import { YardDistancesController } from './controllers/yard-distances.controller';
 import { YardsController } from './controllers/yards.controller';
 
 import { ApprovalRule } from './entities/approval-rule.entity';
@@ -24,6 +25,7 @@ import { ServiceType } from './entities/service-type.entity';
 import { ShippingLine } from './entities/shipping-line.entity';
 import { WeightLimitRule } from './entities/weight-limit-rule.entity';
 import { Yard } from './entities/yard.entity';
+import { YardDistance } from './entities/yard-distance.entity';
 import { YardFacility } from './entities/yard-facility.entity';
 
 import { APPROVAL_RULES_REPOSITORY } from './interfaces/approval-rules.repository.interface';
@@ -34,6 +36,7 @@ import { RATES_REPOSITORY } from './interfaces/rates.repository.interface';
 import { SERVICE_TYPES_REPOSITORY } from './interfaces/service-types.repository.interface';
 import { SHIPPING_LINES_REPOSITORY } from './interfaces/shipping-lines.repository.interface';
 import { WEIGHT_LIMIT_RULES_REPOSITORY } from './interfaces/weight-limit-rules.repository.interface';
+import { YARD_DISTANCES_REPOSITORY } from './interfaces/yard-distances.repository.interface';
 import { YARDS_REPOSITORY } from './interfaces/yards.repository.interface';
 
 import { ApprovalRulesRepository } from './repositories/approval-rules.repository';
@@ -44,6 +47,7 @@ import { RatesRepository } from './repositories/rates.repository';
 import { ServiceTypesRepository } from './repositories/service-types.repository';
 import { ShippingLinesRepository } from './repositories/shipping-lines.repository';
 import { WeightLimitRulesRepository } from './repositories/weight-limit-rules.repository';
+import { YardDistancesRepository } from './repositories/yard-distances.repository';
 import { YardsRepository } from './repositories/yards.repository';
 
 import { ApprovalRulesService } from './services/approval-rules.service';
@@ -58,6 +62,7 @@ import { ServiceTypesService } from './services/service-types.service';
 import { ShippingLinesService } from './services/shipping-lines.service';
 import { WeightLimitRulesService } from './services/weight-limit-rules.service';
 import { YardsService } from './services/yards.service';
+import { YardDistancesService } from './services/yard-distances.service';
 import { YardFacilitiesService } from './services/yard-facilities.service';
 
 import { RuleEngineService } from './rule-engine.service';
@@ -80,6 +85,7 @@ import { BookingRateSnapshot } from '../bookings/entities/booking-rate-snapshot.
       ServiceType,
       WeightLimitRule,
       Yard,
+      YardDistance,
       YardFacility,
       ShippingLine,
       Rate,
@@ -100,6 +106,7 @@ import { BookingRateSnapshot } from '../bookings/entities/booking-rate-snapshot.
     ServiceTypesController,
     WeightLimitRulesController,
     YardsController,
+    YardDistancesController,
     ShippingLinesController,
     RatesController,
     ApprovalRulesController,
@@ -117,6 +124,8 @@ import { BookingRateSnapshot } from '../bookings/entities/booking-rate-snapshot.
     { provide: WEIGHT_LIMIT_RULES_REPOSITORY, useExisting: WeightLimitRulesRepository },
     YardsRepository,
     { provide: YARDS_REPOSITORY, useExisting: YardsRepository },
+    YardDistancesRepository,
+    { provide: YARD_DISTANCES_REPOSITORY, useExisting: YardDistancesRepository },
     ShippingLinesRepository,
     { provide: SHIPPING_LINES_REPOSITORY, useExisting: ShippingLinesRepository },
     RatesRepository,
@@ -131,6 +140,7 @@ import { BookingRateSnapshot } from '../bookings/entities/booking-rate-snapshot.
     ServiceTypesService,
     WeightLimitRulesService,
     YardsService,
+    YardDistancesService,
     YardFacilitiesService,
     ShippingLinesService,
     RatesService,
@@ -146,6 +156,7 @@ import { BookingRateSnapshot } from '../bookings/entities/booking-rate-snapshot.
     WeightLimitRulesService,
     PriorityConfigsService,
     YardsService,
+    YardDistancesService,
     YardFacilitiesService,
     ShippingLinesService,
     RatesService,
@@ -155,6 +166,7 @@ import { BookingRateSnapshot } from '../bookings/entities/booking-rate-snapshot.
     SERVICE_TYPES_REPOSITORY,
     SHIPPING_LINES_REPOSITORY,
     YARDS_REPOSITORY,
+    YARD_DISTANCES_REPOSITORY,
   ],
 })
 export class RuleEngineModule {}
diff --git a/apps/edr-freight-api/src/modules/rule-engine/rule-engine.service.spec.ts b/apps/edr-freight-api/src/modules/rule-engine/rule-engine.service.spec.ts
new file mode 100644
index 000000000..85c7db4a0
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/rule-engine/rule-engine.service.spec.ts
@@ -0,0 +1,78 @@
+import { RuleEngineService } from './rule-engine.service';
+import type { BookingEvaluationInput } from './rule-engine.service';
+import type { Rate } from './entities/rate.entity';
+
+describe('RuleEngineService — requested service without a configured surcharge rate', () => {
+  const hazardRate: Rate = {
+    id: 'rate-hazard',
+    rateType: 'HAZARD_SURCHARGE',
+    trigger: 'HAZARDOUS',
+    rateValue: 50,
+    rateUnit: 'PER_CONTAINER',
+    currency: 'USD',
+    status: 'LIVE',
+    containerTypeId: null,
+    cargoTypeId: null,
+  } as Rate;
+
+  let ratesRepo: { findLiveRates: jest.Mock };
+  let service: RuleEngineService;
+
+  beforeEach(() => {
+    ratesRepo = { findLiveRates: jest.fn().mockResolvedValue([]) };
+    service = new RuleEngineService(
+      { findById: jest.fn().mockResolvedValue(null) } as never, // cargoTypes
+      { findById: jest.fn().mockResolvedValue(null) } as never, // serviceTypes
+      { findActiveByContainerTypeId: jest.fn().mockResolvedValue([]) } as never, // weightLimits
+      { findAllActive: jest.fn().mockResolvedValue([]) } as never, // priorityConfigs
+      ratesRepo as never,
+      { findById: jest.fn().mockResolvedValue(null) } as never, // shippingLines
+      {} as never, // dataSource (unused by evaluate)
+    );
+  });
+
+  const input = (overrides: Partial<BookingEvaluationInput>): BookingEvaluationInput => ({
+    serviceTypeId: 'svc-1',
+    paymentCurrency: 'USD',
+    tradeDirection: 'IMPORT',
+    isHazardous: false,
+    totalWagons: 1,
+    containers: [],
+    ...overrides,
+  });
+
+  it('hard-blocks a hazardous booking when no HAZARDOUS surcharge rate is LIVE', async () => {
+    const result = await service.evaluate(input({ isHazardous: true }));
+    expect(result.hardBlocked).toHaveLength(1);
+    expect(result.hardBlocked[0]).toContain('hazardous');
+  });
+
+  it('passes a hazardous booking when a HAZARDOUS surcharge rate is LIVE', async () => {
+    ratesRepo.findLiveRates.mockResolvedValue([hazardRate]);
+    const result = await service.evaluate(input({ isHazardous: true }));
+    expect(result.hardBlocked).toHaveLength(0);
+  });
+
+  it('does not block a non-hazardous booking when no surcharge rates exist', async () => {
+    const result = await service.evaluate(input({}));
+    expect(result.hardBlocked).toHaveLength(0);
+  });
+
+  it('hard-blocks on per-container opt-in counts even without the booking-level flag', async () => {
+    const result = await service.evaluate(
+      input({
+        containers: [
+          {
+            containerTypeId: 'ct-20',
+            quantity: 2,
+            vgmPerUnitTons: 10,
+            totalVgmTons: 20,
+            reeferQuantity: 1,
+          },
+        ],
+      }),
+    );
+    expect(result.hardBlocked).toHaveLength(1);
+    expect(result.hardBlocked[0]).toContain('reefer');
+  });
+});
diff --git a/apps/edr-freight-api/src/modules/rule-engine/rule-engine.service.ts b/apps/edr-freight-api/src/modules/rule-engine/rule-engine.service.ts
index 9d7aa6ba9..3a4c4b778 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/rule-engine.service.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/rule-engine.service.ts
@@ -28,6 +28,10 @@ import {
 } from './interfaces/shipping-lines.repository.interface';
 import { GOVERNMENT_PRIORITY_BONUS } from './government-priority.constants';
 
+// Coerce defensively: a flag may arrive as the string "true"/"false" (e.g.
+// from multipart form-data) and a non-empty "false" string is truthy.
+const truthy = (v: unknown): boolean => v === true || v === 'true';
+
 export interface BookingContainerEvalInput {
   containerTypeId: string;
   quantity: number;
@@ -245,6 +249,48 @@ export class RuleEngineService {
       liveRates.filter((r) => r.trigger && r.trigger !== 'ALWAYS'),
     );
 
+    // A handling service the booking asks for (booking-level flag OR any
+    // per-container opt-in count) with no LIVE surcharge rate configured is a
+    // hard block — pricing would otherwise ship the service for free. System-
+    // derived charges (consolidation, overweight, shipping line, lashing) stay
+    // exempt: the customer never opted into those, so they must not block.
+    const requestedServices: Array<{
+      trigger: RateTrigger;
+      wanted: boolean;
+      label: string;
+    }> = [
+      {
+        trigger: 'HAZARDOUS',
+        wanted:
+          truthy(input.isHazardous) ||
+          input.containers.some((c) => Number(c.hazardousQuantity ?? 0) > 0),
+        label: 'hazardous cargo',
+      },
+      {
+        trigger: 'REEFER',
+        wanted:
+          hasReefer ||
+          input.containers.some((c) => Number(c.reeferQuantity ?? 0) > 0),
+        label: 'refrigerated (reefer) cargo',
+      },
+      {
+        trigger: 'WITH_RETURN',
+        wanted:
+          truthy(input.withReturn) ||
+          input.containers.some((c) => Number(c.returnQuantity ?? 0) > 0),
+        label: 'empty-container return',
+      },
+    ];
+    for (const svc of requestedServices) {
+      if (svc.wanted && !surchargeRates.some((r) => r.trigger === svc.trigger)) {
+        hardBlocked.push(
+          `No ${svc.label} surcharge rate is configured — the booking cannot ` +
+            `be priced with this service. Remove the ${svc.label} option or ` +
+            'ask EDR to configure its rate.',
+        );
+      }
+    }
+
     for (const rate of surchargeRates) {
       const triggered = this.matchesTrigger(rate.trigger, {
         isHazardous: input.isHazardous,
@@ -438,9 +484,6 @@ export class RuleEngineService {
       hasLashing: boolean;
     },
   ): boolean {
-    // Coerce defensively: a flag may arrive as the string "true"/"false" (e.g.
-    // from multipart form-data) and a non-empty "false" string is truthy.
-    const truthy = (v: unknown): boolean => v === true || v === 'true';
     switch (trigger) {
       case 'HAZARDOUS':
         return truthy(state.isHazardous);
diff --git a/apps/edr-freight-api/src/modules/rule-engine/services/yard-distances.service.ts b/apps/edr-freight-api/src/modules/rule-engine/services/yard-distances.service.ts
new file mode 100644
index 000000000..a41e593e2
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/rule-engine/services/yard-distances.service.ts
@@ -0,0 +1,119 @@
+import { PaginatedResponse } from '@edr/types';
+import {
+  BadRequestException,
+  ConflictException,
+  Inject,
+  Injectable,
+  NotFoundException,
+} from '@nestjs/common';
+import { CreateYardDistanceDto } from '../dto/create-yard-distance.dto';
+import { ListYardDistancesQueryDto } from '../dto/list-rule-engine-query.dto';
+import { UpdateYardDistanceDto } from '../dto/update-yard-distance.dto';
+import { YardDistance } from '../entities/yard-distance.entity';
+import {
+  IYardDistancesRepository,
+  YARD_DISTANCES_REPOSITORY,
+} from '../interfaces/yard-distances.repository.interface';
+import { IYardsRepository, YARDS_REPOSITORY } from '../interfaces/yards.repository.interface';
+
+/**
+ * Flat row shape for the backoffice config table: the yard relations stay for
+ * API consumers, plus label fields the generic rule-engine grid can render.
+ */
+export type YardDistanceRow = YardDistance & {
+  fromYardLabel: string;
+  toYardLabel: string;
+};
+
+const yardDisplay = (yard?: { label?: string; code?: string } | null): string =>
+  yard?.label ?? yard?.code ?? '—';
+
+const toRow = (entity: YardDistance): YardDistanceRow =>
+  Object.assign(entity, {
+    fromYardLabel: yardDisplay(entity.fromYard),
+    toYardLabel: yardDisplay(entity.toYard),
+  });
+
+@Injectable()
+export class YardDistancesService {
+  constructor(
+    @Inject(YARD_DISTANCES_REPOSITORY)
+    private readonly repository: IYardDistancesRepository,
+    @Inject(YARDS_REPOSITORY)
+    private readonly yardsRepository: IYardsRepository,
+  ) {}
+
+  async findAll(query: ListYardDistancesQueryDto): Promise<PaginatedResponse<YardDistanceRow>> {
+    const page = await this.repository.findPaged(query);
+    return { ...page, items: page.items.map(toRow) };
+  }
+
+  async findById(id: string): Promise<YardDistanceRow> {
+    const entity = await this.repository.findById(id);
+    if (!entity) throw new NotFoundException(`Yard distance ${id} not found`);
+    return toRow(entity);
+  }
+
+  async create(dto: CreateYardDistanceDto): Promise<YardDistanceRow> {
+    await this.assertValidPair(dto.fromYardId, dto.toYardId);
+
+    const created = await this.repository.create({
+      fromYardId: dto.fromYardId,
+      toYardId: dto.toYardId,
+      distanceKm: dto.distanceKm.toFixed(2),
+    });
+    return toRow(created);
+  }
+
+  async update(id: string, dto: UpdateYardDistanceDto): Promise<YardDistanceRow> {
+    const existing = await this.findById(id);
+
+    const fromYardId = dto.fromYardId ?? existing.fromYardId;
+    const toYardId = dto.toYardId ?? existing.toYardId;
+    if (fromYardId !== existing.fromYardId || toYardId !== existing.toYardId) {
+      await this.assertValidPair(fromYardId, toYardId, id);
+    }
+
+    const updated = await this.repository.update(id, {
+      fromYardId,
+      toYardId,
+      ...(dto.distanceKm != null ? { distanceKm: dto.distanceKm.toFixed(2) } : {}),
+    });
+    if (!updated) throw new NotFoundException(`Yard distance ${id} not found`);
+    return toRow(updated);
+  }
+
+  async remove(id: string): Promise<void> {
+    await this.findById(id);
+    await this.repository.softDelete(id);
+  }
+
+  /**
+   * Both yards must exist and differ, and the pair must not already be
+   * configured in either direction — distances are symmetric, so an A→B row
+   * already covers B→A.
+   */
+  private async assertValidPair(
+    fromYardId: string,
+    toYardId: string,
+    ignoreId?: string,
+  ): Promise<void> {
+    if (fromYardId === toYardId) {
+      throw new BadRequestException('From and to yards must be different');
+    }
+
+    const [fromYard, toYard] = await Promise.all([
+      this.yardsRepository.findById(fromYardId),
+      this.yardsRepository.findById(toYardId),
+    ]);
+    if (!fromYard) throw new BadRequestException(`Yard ${fromYardId} does not exist`);
+    if (!toYard) throw new BadRequestException(`Yard ${toYardId} does not exist`);
+
+    const existing = await this.repository.findBetween(fromYardId, toYardId);
+    if (existing && existing.id !== ignoreId) {
+      throw new ConflictException(
+        `A distance between ${fromYard.label} and ${toYard.label} is already configured`,
+      );
+    }
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/train-scheduling/booking-batch.service.spec.ts b/apps/edr-freight-api/src/modules/train-scheduling/booking-batch.service.spec.ts
index fc97f772b..bafc7a13e 100644
--- a/apps/edr-freight-api/src/modules/train-scheduling/booking-batch.service.spec.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/booking-batch.service.spec.ts
@@ -570,6 +570,104 @@ describe('BookingBatchService — PAID reconcile', () => {
     });
   });
 
+  describe('expireLeftoverExportDay — export day sweep', () => {
+    const exportSchedule = {
+      id: scheduleId,
+      direction: 'EXPORT',
+      originStationId: 'yard-origin',
+      destinationStationId: 'yard-dest',
+      scheduledDepartureDate: new Date('2026-06-20T06:00:00.000Z'),
+      windowPhase: 'DONE',
+      bookingWindowStatus: 'CLOSED',
+    };
+    let unacceptedSpy: jest.SpyInstance;
+    let poolSpy: jest.SpyInstance;
+
+    beforeEach(() => {
+      unacceptedSpy = jest
+        .spyOn(service, 'expireUnacceptedForRouteDay')
+        .mockResolvedValue(undefined);
+      poolSpy = jest.spyOn(service, 'expireLeftoverDayPool').mockResolvedValue(0);
+    });
+
+    it('ignores non-export schedules', async () => {
+      trainSchedulesRepository.findById.mockResolvedValue({
+        ...exportSchedule,
+        direction: 'IMPORT',
+      });
+
+      await service.expireLeftoverExportDay(scheduleId);
+
+      expect(unacceptedSpy).not.toHaveBeenCalled();
+      expect(poolSpy).not.toHaveBeenCalled();
+    });
+
+    it('defers while another export train on the day can still take bookings', async () => {
+      trainSchedulesRepository.findById.mockResolvedValue(exportSchedule);
+      trainSchedulesRepository.findAll.mockResolvedValue([
+        exportSchedule,
+        {
+          ...exportSchedule,
+          id: 'sched-2',
+          windowPhase: 'OPEN',
+          bookingWindowStatus: 'OPEN',
+        },
+      ]);
+
+      await service.expireLeftoverExportDay(scheduleId);
+
+      expect(unacceptedSpy).not.toHaveBeenCalled();
+      expect(poolSpy).not.toHaveBeenCalled();
+    });
+
+    it('defers while a FULL train still has live pay windows', async () => {
+      trainSchedulesRepository.findById.mockResolvedValue(exportSchedule);
+      trainSchedulesRepository.findAll.mockResolvedValue([
+        exportSchedule,
+        {
+          ...exportSchedule,
+          id: 'sched-2',
+          windowPhase: 'OPEN',
+          bookingWindowStatus: 'FULL',
+        },
+      ]);
+      bookingsRepository.findReservedForSchedule.mockResolvedValue([
+        {
+          paymentStatus: 'PENDING',
+          status: 'AWAITING_PAYMENT',
+          paymentDeadline: new Date(Date.now() + 60_000),
+        },
+      ]);
+
+      await service.expireLeftoverExportDay(scheduleId);
+
+      expect(unacceptedSpy).not.toHaveBeenCalled();
+      expect(poolSpy).not.toHaveBeenCalled();
+    });
+
+    it('sweeps un-accepted + waiting bookings once every train on the day is shut', async () => {
+      trainSchedulesRepository.findById.mockResolvedValue(exportSchedule);
+      trainSchedulesRepository.findAll.mockResolvedValue([
+        exportSchedule,
+        {
+          ...exportSchedule,
+          id: 'sched-2',
+          windowPhase: 'OPEN',
+          bookingWindowStatus: 'FULL',
+        },
+      ]);
+
+      await service.expireLeftoverExportDay(scheduleId);
+
+      expect(unacceptedSpy).toHaveBeenCalledWith({
+        originYardId: 'yard-origin',
+        destinationYardId: 'yard-dest',
+        day: '2026-06-20',
+      });
+      expect(poolSpy).toHaveBeenCalledWith(scheduleId);
+    });
+  });
+
   describe('maybeOfferPartial — split-eligibility gate', () => {
     const importGeneral = {
       id: 'b1',
@@ -817,6 +915,122 @@ describe('BookingBatchService — PAID reconcile', () => {
       );
     });
   });
+
+  describe('acceptIntercity — export pay window expires at window close', () => {
+    const exportScheduleId = 'export-train';
+    // Window closes in 30 minutes; the configured pay window is 60 minutes.
+    const closesAt = new Date(Date.now() + 30 * 60_000);
+
+    const waiting = {
+      id: 'ic-1',
+      reference: 'IC-1',
+      isGovernment: false,
+      status: 'FULLY_EXECUTED',
+      trainScheduleId: null,
+      freightType: 'CONTAINER',
+      cargoTotalWeightVgm: 10,
+      bookingContainers: [],
+    } as unknown as Booking;
+
+    let scheduleRepo: { findOne: jest.Mock };
+    let bookingRepo: { findOne: jest.Mock; update: jest.Mock; find: jest.Mock };
+
+    beforeEach(() => {
+      bookingRepo = dataSource.getRepository();
+      bookingRepo.findOne.mockResolvedValue(waiting);
+      scheduleRepo = { findOne: jest.fn() };
+      // reserve() reads the target schedule to clamp export deadlines — route
+      // TrainSchedule reads to their own repo, everything else stays as before.
+      dataSource.getRepository.mockImplementation((entity?: { name?: string }) =>
+        entity?.name === 'TrainSchedule' ? scheduleRepo : bookingRepo,
+      );
+    });
+
+    it('clamps the intercity pay deadline to the export window close', async () => {
+      scheduleRepo.findOne.mockResolvedValue({
+        id: exportScheduleId,
+        direction: 'EXPORT',
+        windowClosesAt: closesAt,
+        scheduledDepartureDate: new Date(closesAt.getTime() + 2 * 3_600_000),
+      });
+
+      await service.acceptIntercity(waiting, exportScheduleId);
+
+      expect(bookingsRepository.update).toHaveBeenCalledWith(
+        'ic-1',
+        expect.objectContaining({
+          status: 'SELECTED_FOR_BATCH',
+          paymentDeadline: closesAt,
+        }),
+      );
+      expect(notifier.payNow).toHaveBeenCalledTimes(1);
+    });
+
+    it('keeps the plain payment window on import trains', async () => {
+      scheduleRepo.findOne.mockResolvedValue({
+        id: 'import-train',
+        direction: 'IMPORT',
+        windowClosesAt: closesAt,
+      });
+
+      await service.acceptIntercity(waiting, 'import-train');
+
+      const deadline = (
+        bookingsRepository.update.mock.calls[0][1] as { paymentDeadline: Date }
+      ).paymentDeadline;
+      // 60-minute pay window runs past the 30-minutes-out close: no clamp.
+      expect(deadline.getTime()).toBeGreaterThan(closesAt.getTime());
+    });
+
+    it('rejects an accept after the export window closed — no pay window opens', async () => {
+      scheduleRepo.findOne.mockResolvedValue({
+        id: exportScheduleId,
+        direction: 'EXPORT',
+        windowClosesAt: new Date(Date.now() - 60_000),
+      });
+
+      await expect(
+        service.acceptIntercity(waiting, exportScheduleId),
+      ).rejects.toThrow(/window has closed/);
+      expect(bookingsRepository.update).not.toHaveBeenCalled();
+      expect(notifier.payNow).not.toHaveBeenCalled();
+    });
+
+    it('expires an unpaid export ride-along at close and frees the train', async () => {
+      const lapsed = {
+        ...(waiting as unknown as Record<string, unknown>),
+        status: 'SELECTED_FOR_BATCH',
+        trainScheduleId: exportScheduleId,
+        paymentDeadline: new Date(Date.now() - 1_000),
+        originYardId: 'yard-a',
+        destinationYardId: 'yard-b',
+        priorityScore: 0,
+        wagonsRequired: 1,
+      } as unknown as Booking;
+      bookingsRepository.findReservedForSchedule
+        .mockResolvedValueOnce([lapsed])
+        .mockResolvedValue([]);
+      bookingsRepository.findBatchPoolByCorridorDay.mockResolvedValue([]);
+      // expire()'s paid-guard re-reads the booking fresh — still unpaid.
+      bookingRepo.findOne.mockResolvedValue(lapsed);
+      trainSchedulesRepository.findById.mockResolvedValue({
+        id: exportScheduleId,
+        bookingWindowStatus: 'CLOSED',
+        windowPhase: 'DONE',
+        scheduledDepartureDate: new Date(Date.now() + 3_600_000),
+        originStationId: 'yard-a',
+        destinationStationId: 'yard-b',
+      });
+
+      await service.settleDueReservations(exportScheduleId);
+
+      expect(notifier.expired).toHaveBeenCalledTimes(1);
+      expect(bookingsRepository.update).toHaveBeenCalledWith(
+        'ic-1',
+        expect.objectContaining({ status: 'EXPIRED', trainScheduleId: null }),
+      );
+    });
+  });
 });
 
 describe('BookingBatchService — wagonsFor', () => {
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 415b5df97..03a125aef 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
@@ -570,6 +570,10 @@ export class BookingBatchService implements OnModuleInit {
     );
     if (schedule && (await this.isTrainFull(schedule))) {
       await this.setWindow(booking.trainScheduleId, "FULL");
+      // This payment may have been the last live pay window on a now-full
+      // export day — the settle that normally re-runs the sweep finds nothing
+      // left to settle, so trigger it here.
+      void this.expireLeftoverExportDay(booking.trainScheduleId);
     }
 
     const result = await this.trainSchedulingService.tryAutoWagonAllocation(
@@ -2254,6 +2258,11 @@ export class BookingBatchService implements OnModuleInit {
           `— payment phase extended for them`,
       );
     }
+    // The settle may have resolved the last pay window on a full export day
+    // (paid → allocated, and the top-up found nothing else that fits) — sweep
+    // the date's leftover bookings. Self-guarded: no-op for import/domestic
+    // and while any train on the day can still take bookings.
+    await this.expireLeftoverExportDay(scheduleId);
     // Emitted here (not in settleDueReservations/settleBatch, which both wrap
     // this) so one settle produces one push, after every allocation/expiry/
     // top-up extension for this schedule has been persisted.
@@ -2350,6 +2359,9 @@ export class BookingBatchService implements OnModuleInit {
     );
     if (schedule && (await this.isTrainFull(schedule))) {
       await this.setWindow(booking.trainScheduleId, "FULL");
+      // Same as the webhook path: a staff mark-paid can settle the last live
+      // pay window on a now-full export day — sweep the date's leftovers.
+      void this.expireLeftoverExportDay(booking.trainScheduleId);
     }
     void this.triggerWagonAllocation(booking.trainScheduleId!);
     this.notifyBoardChanged(booking.trainScheduleId, "booking_marked_paid");
@@ -2461,13 +2473,13 @@ export class BookingBatchService implements OnModuleInit {
     if (!schedule || !locomotive) return null;
     const wagonDims = await this.loadWagonDims();
     const limits = await this.capacityLimits(locomotive);
-    // Built trains: collapse to a single train-wide pool so the freed capacity of
-    // a booking that alights mid-corridor is NOT re-offered on the pass-through
-    // leg (see remainingBudget). Keeps intercity accept consistent with the
-    // train-wide isTrainFull / committedWagons finalize signal.
-    const budget = await this.remainingBudget(schedule, limits, wagonDims, {
-      collapseForBuiltTrain: true,
-    });
+    // Built trains use the leg-aware corridor budget too: the wagon planner
+    // consumes stock PER EDGE (planWagonsWithStock legs), so a consist wagon
+    // that runs empty Gelan→Adama genuinely can carry an intercity booking
+    // there before its export cargo boards at Adama. A train full on one leg
+    // still accepts ride-alongs on its empty legs — that is the whole point
+    // of the ride-along flow.
+    const budget = await this.remainingBudget(schedule, limits, wagonDims);
     return { budget, needFor: (booking) => this.needFor(booking, wagonDims) };
   }
 
@@ -2526,7 +2538,26 @@ export class BookingBatchService implements OnModuleInit {
       return;
     }
     const now = new Date();
-    const deadline = new Date(now.getTime() + (await this.paymentWindowMs()));
+    let deadline = new Date(now.getTime() + (await this.paymentWindowMs()));
+    // EXPORT parity: pay windows on an export train never outlive its booking
+    // window — export bookings expire at close, so anything reserved onto the
+    // same train (FCFS export or an intercity ride-along) must too. Import
+    // keeps the plain payment window; its cycles re-fill after settle.
+    const targetSchedule = await this.dataSource
+      .getRepository(TrainSchedule)
+      .findOne({ where: { id: scheduleId } });
+    if (targetSchedule?.direction === "EXPORT") {
+      const cutoff =
+        targetSchedule.windowClosesAt ?? targetSchedule.scheduledDepartureDate;
+      if (cutoff && cutoff.getTime() <= now.getTime()) {
+        throw new BadRequestException(
+          "Export booking window has closed — cannot open a pay window on this train",
+        );
+      }
+      if (cutoff && cutoff.getTime() < deadline.getTime()) {
+        deadline = new Date(cutoff);
+      }
+    }
     await this.bookingsRepository.update(booking.id, {
       trainScheduleId: scheduleId,
       status: "SELECTED_FOR_BATCH",
@@ -2822,6 +2853,60 @@ export class BookingBatchService implements OnModuleInit {
     return leftovers.length;
   }
 
+  /**
+   * EXPORT counterpart of the conclude-time sweep. Export has no batch cycle,
+   * so nothing ever concluded its day: bookings still waiting when the trains
+   * filled up or the window closed stayed pending forever. Once every export
+   * train on this route-day is shut — window DONE, or FULL with no pay window
+   * still live that could lapse and free space — the date is dead: expire the
+   * un-accepted bookings staff can no longer accept AND the ready
+   * (FULLY_EXECUTED) bookings that never got a reservation (consolidation
+   * waiters). Runs at export window close and whenever an export train's
+   * fullness settles.
+   */
+  async expireLeftoverExportDay(scheduleId: string): Promise<void> {
+    const schedule = await this.trainSchedulesRepository.findById(scheduleId);
+    if (schedule?.direction !== "EXPORT" || !schedule.scheduledDepartureDate) {
+      return;
+    }
+    const day = eatDay(schedule.scheduledDepartureDate);
+    const trains = (
+      await this.trainSchedulesRepository.findAll({
+        where: [
+          {
+            originStationId: schedule.originStationId,
+            destinationStationId: schedule.destinationStationId,
+            status: TrainScheduleStatusEnum.Draft,
+          },
+          {
+            originStationId: schedule.originStationId,
+            destinationStationId: schedule.destinationStationId,
+            status: TrainScheduleStatusEnum.Scheduled,
+          },
+        ],
+      })
+    ).filter(
+      (s) =>
+        s.scheduledDepartureDate != null &&
+        eatDay(s.scheduledDepartureDate) === day,
+    );
+    for (const s of trains) {
+      // Any train still taking bookings keeps the date alive.
+      if (s.windowPhase !== "DONE" && s.bookingWindowStatus !== "FULL") return;
+      // A FULL train whose reservations are still inside their pay windows can
+      // reopen when one lapses unpaid — defer; the settle re-runs this sweep.
+      if (s.windowPhase !== "DONE" && (await this.hasLiveReservations(s.id))) {
+        return;
+      }
+    }
+    await this.expireUnacceptedForRouteDay({
+      originYardId: schedule.originStationId,
+      destinationYardId: schedule.destinationStationId,
+      day,
+    });
+    await this.expireLeftoverDayPool(scheduleId);
+  }
+
   /**
    * Union of stop yards across the day's fillable schedules on this corridor —
    * the same pool scope fillRouteDay uses, so full-route AND sub-corridor bookings
@@ -3398,7 +3483,6 @@ export class BookingBatchService implements OnModuleInit {
     schedule: TrainSchedule,
     limits: TrainLimits,
     wagonDims: WagonDims,
-    opts?: { collapseForBuiltTrain?: boolean },
   ): Promise<CorridorBudget> {
     const physicalWagons = await this.builtTrainWagonCount(schedule);
     if (physicalWagons != null) {
@@ -3411,21 +3495,10 @@ export class BookingBatchService implements OnModuleInit {
         tolerance: { weightTons: 0, lengthMeters: 0 },
       };
     }
-    // A built train's wagons are coupled for the WHOLE trip, and the allocator
-    // commits each booking to a wagon for the entire route — it never reloads a
-    // wagon at a mid-corridor alight yard. So a built train has no leg concept:
-    // its capacity is one train-wide pool, exactly as isTrainFull /
-    // committedWagons already count it. When a caller opts in, collapse the
-    // corridor to a single whole-route edge so every booking (full-route OR
-    // mid-corridor) draws from that one pool — a train full of import-to-DireDawa
-    // then correctly shows NO room for a DireDawa->Addis intercity booking on the
-    // leg it merely passes through, instead of over-promising the freed slots.
-    // Locomotive-derived schedules keep the leg-aware multi-edge corridor: their
-    // abstract slot/weight/length budget genuinely frees past an alight yard.
-    const stops =
-      physicalWagons != null && opts?.collapseForBuiltTrain
-        ? [schedule.originStationId, schedule.destinationStationId]
-        : await this.stopsForSchedule(schedule);
+    // Built trains keep the leg-aware multi-edge corridor too: the wagon
+    // planner consumes stock per edge (planWagonsWithStock legs), so a consist
+    // wagon serves disjoint legs — capacity freed past an alight yard is real.
+    const stops = await this.stopsForSchedule(schedule);
     const budget = new CorridorBudget(stops, limits.base, limits.tolerance);
     const allocated = (schedule.scheduleBookings ?? [])
       .map((sb) => sb.booking)
diff --git a/apps/edr-freight-api/src/modules/train-scheduling/booking-journey.service.ts b/apps/edr-freight-api/src/modules/train-scheduling/booking-journey.service.ts
index fb140158c..db18d6804 100644
--- a/apps/edr-freight-api/src/modules/train-scheduling/booking-journey.service.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/booking-journey.service.ts
@@ -21,6 +21,7 @@ import { WagonBookingAllocation } from '../train-schedules/entities/wagon-bookin
 import { Wagon } from '../wagons/entities/wagon.entity';
 import { WagonMovement } from '../wagons/entities/wagon-movement.entity';
 import { TrainCheckpointEvent } from './entities/train-checkpoint-event.entity';
+import { assertExportReceivedWithGrn } from '../../common/export-received-gate';
 
 /**
  * Per-booking journey along a train's corridor — for EVERY trade direction.
@@ -68,6 +69,9 @@ export class BookingJourneyService {
     }
     await this.assertTrainAtYard(schedule, booking.originYardId, 'origin');
     await this.assertYardCanHandleCargo(booking, booking.originYardId, 'origin');
+    // Export cargo must be in the warehouse with a GRN before it can be loaded,
+    // however it arrived and whatever it is allocated to.
+    await assertExportReceivedWithGrn(this.dataSource, booking);
 
     const now = new Date();
     await this.dataSource.transaction(async (manager) => {
diff --git a/apps/edr-freight-api/src/modules/train-scheduling/booking-window.service.spec.ts b/apps/edr-freight-api/src/modules/train-scheduling/booking-window.service.spec.ts
index 9393c520f..abd07c129 100644
--- a/apps/edr-freight-api/src/modules/train-scheduling/booking-window.service.spec.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/booking-window.service.spec.ts
@@ -20,6 +20,7 @@ describe('BookingWindowService — window state machine', () => {
     hasLiveReservations: jest.Mock;
     refreshWindowStatus: jest.Mock;
     expireLeftoverDayPool: jest.Mock;
+    expireLeftoverExportDay: jest.Mock;
     fillFromWaitingList: jest.Mock;
   };
   let trainSchedulesRepository: { findById: jest.Mock; findAll: jest.Mock };
@@ -75,6 +76,7 @@ describe('BookingWindowService — window state machine', () => {
       hasLiveReservations: jest.fn().mockResolvedValue(false),
       refreshWindowStatus: jest.fn().mockResolvedValue(undefined),
       expireLeftoverDayPool: jest.fn().mockResolvedValue(0),
+      expireLeftoverExportDay: jest.fn().mockResolvedValue(undefined),
       // No waiting booking fits by default, so conclude proceeds to reopen/DONE.
       fillFromWaitingList: jest.fn().mockResolvedValue(0),
     };
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 02c5fb993..3b9bb25d3 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
@@ -229,6 +229,11 @@ export class BookingWindowService implements OnModuleInit {
         await this.bookingBatchService.setWindow(schedule.id, 'CLOSED');
         schedule.bookingWindowStatus = 'CLOSED';
       }
+      // Export has no conclude step: this close is the last moment the day's
+      // bookings could have boarded. Once every train on the route-day is
+      // shut, expire what is still waiting for this date (the sweep defers
+      // while a sibling train stays open).
+      await this.bookingBatchService.expireLeftoverExportDay(schedule.id);
       return true;
     }
     return false;
diff --git a/apps/edr-freight-api/src/modules/train-scheduling/dto/move-wagon-load.dto.ts b/apps/edr-freight-api/src/modules/train-scheduling/dto/move-wagon-load.dto.ts
new file mode 100644
index 000000000..a93a8afc6
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/train-scheduling/dto/move-wagon-load.dto.ts
@@ -0,0 +1,11 @@
+import { IsUUID } from 'class-validator';
+
+export class MoveWagonLoadDto {
+  /**
+   * Where the source wagon's whole load goes: a train-set wagon slot (empty →
+   * move, loaded → swap the two loads) or an empty consist-only physical wagon
+   * of the built train (→ the slot repins onto it).
+   */
+  @IsUUID()
+  targetWagonId!: string;
+}
diff --git a/apps/edr-freight-api/src/modules/train-scheduling/intercity.service.ts b/apps/edr-freight-api/src/modules/train-scheduling/intercity.service.ts
index b35650e16..293fc8801 100644
--- a/apps/edr-freight-api/src/modules/train-scheduling/intercity.service.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/intercity.service.ts
@@ -146,10 +146,8 @@ export class IntercityService {
       remaining: capacity?.budget.maxRemaining() ?? null,
       candidates: waiting.map((booking) => {
         const need = capacity?.needFor(booking) ?? null;
-        // legForYards, not legOf: on a built train the budget is a single
-        // whole-route edge (see intercityCapacity), so a mid-corridor booking
-        // must draw from that one pool via the whole-route fallback. On a
-        // locomotive-derived schedule it still resolves to the booking's own leg.
+        // legForYards: the booking draws only from ITS OWN leg's edges, with a
+        // whole-route fallback when its yards aren't on the budget's stop list.
         const leg = capacity?.budget.legForYards(
           booking.originYardId,
           booking.destinationYardId,
@@ -215,11 +213,8 @@ export class IntercityService {
         continue;
       }
       const need = capacity.needFor(booking);
-      // legForYards, not legOf: a built train's budget is a single whole-route
-      // pool (mid-corridor wagons are committed for the whole trip and never
-      // reloaded), so the booking draws from that pool via the whole-route
-      // fallback; a locomotive-derived schedule still gets the booking's own
-      // leg, so it can still board a train that is full only on other legs.
+      // legForYards: charge only the edges this booking rides, so it can still
+      // board a train that is full only on other legs.
       const leg = budget.legForYards(booking.originYardId, booking.destinationYardId);
       if (!budget.fits(need, leg)) {
         rejected.push({
diff --git a/apps/edr-freight-api/src/modules/train-scheduling/train-scheduling.controller.ts b/apps/edr-freight-api/src/modules/train-scheduling/train-scheduling.controller.ts
index 3e142f778..b1f79733e 100644
--- a/apps/edr-freight-api/src/modules/train-scheduling/train-scheduling.controller.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/train-scheduling.controller.ts
@@ -28,6 +28,7 @@ import { GetEligibleBookingsDto } from "./dto/get-eligible-bookings.dto";
 import { GetEligibleBulkBookingsDto } from "./dto/get-eligible-bulk-bookings.dto";
 import { GetEligibleContainerBookingsDto } from "./dto/get-eligible-container-bookings.dto";
 import { PinWagonsDto } from "./dto/pin-wagons.dto";
+import { MoveWagonLoadDto } from "./dto/move-wagon-load.dto";
 import { UpdateContainerItemDto } from "./dto/update-container-item.dto";
 import { UpdateImportLoadingStatusDto } from "./dto/update-import-loading-status.dto";
 import { PreviewBulkTrainScheduleDto } from "./dto/preview-bulk-train-schedule.dto";
@@ -374,6 +375,20 @@ export class TrainSchedulingController {
     return this.trainSchedulingService.updateContainerItem(id, itemId, dto);
   }
 
+  @Post("schedules/:id/wagons/:wagonId/move-load")
+  @TrainSchedulingManage()
+  @ApiOperation({
+    summary:
+      "Move a wagon's whole load to another wagon (empty → move/repin, loaded → swap loads)",
+  })
+  moveWagonLoad(
+    @Param("id", ParseUUIDPipe) id: string,
+    @Param("wagonId", ParseUUIDPipe) wagonId: string,
+    @Body() dto: MoveWagonLoadDto,
+  ) {
+    return this.trainSchedulingService.moveWagonLoad(id, wagonId, dto);
+  }
+
   @Get("schedules/:id/unassigned-bookings")
   @TrainSchedulingView()
   @ApiOperation({ summary: "Get unassigned bookings for a schedule" })
diff --git a/apps/edr-freight-api/src/modules/train-scheduling/train-scheduling.service.spec.ts b/apps/edr-freight-api/src/modules/train-scheduling/train-scheduling.service.spec.ts
index af1a9eb45..b6410d0cf 100644
--- a/apps/edr-freight-api/src/modules/train-scheduling/train-scheduling.service.spec.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/train-scheduling.service.spec.ts
@@ -1081,4 +1081,172 @@ describe('TrainSchedulingService', () => {
       expect(html).not.toContain('EMPTY');
     });
   });
+
+  describe('moveWagonLoad — staff rearrange', () => {
+    const containerType = {
+      code: 'NX70',
+      supportedLoadTypes: ['CONTAINER'],
+      supportsContainer: true,
+    };
+    let slotA: Record<string, unknown>;
+    let slotB: Record<string, unknown>;
+    let allocsByWagon: Record<string, Array<Record<string, unknown>>>;
+    let allocRepo: { find: jest.Mock; update: jest.Mock };
+    let slotRepo: { update: jest.Mock };
+    let wagonRepo: { findOne: jest.Mock };
+
+    const makeSchedule = (over: Record<string, unknown> = {}) => ({
+      id: 'sched-1',
+      status: 'SCHEDULED',
+      trainSetId: 'ts-1',
+      trainSet: { trainId: 'train-1', wagons: [slotA, slotB] },
+      ...over,
+    });
+
+    beforeEach(() => {
+      slotA = {
+        id: 'wA',
+        sequenceNo: 1,
+        capacityTons: 61,
+        lengthMeters: 14,
+        assignedWeightTons: 40,
+        status: 'RESERVED',
+        boardYardId: 'yard-1',
+        alightYardId: null,
+        wagonType: containerType,
+      };
+      slotB = {
+        id: 'wB',
+        sequenceNo: 2,
+        capacityTons: 61,
+        lengthMeters: 14,
+        assignedWeightTons: 25,
+        status: 'RESERVED',
+        boardYardId: null,
+        alightYardId: null,
+        wagonType: containerType,
+      };
+      allocsByWagon = {
+        // 20ft pair (two allocations sharing wagon A) — must travel together.
+        wA: [
+          { id: 'alloc-a1', trainSetWagonId: 'wA', bookingId: 'b1', allocatedWeightTons: 20, loadType: 'CONTAINER' },
+          { id: 'alloc-a2', trainSetWagonId: 'wA', bookingId: 'b2', allocatedWeightTons: 20, loadType: 'CONTAINER' },
+        ],
+        // one 40ft on wagon B.
+        wB: [
+          { id: 'alloc-b1', trainSetWagonId: 'wB', bookingId: 'b3', allocatedWeightTons: 25, loadType: 'CONTAINER' },
+        ],
+      };
+
+      trainSchedulesRepository.findByIdWithFullGraph.mockResolvedValue(makeSchedule());
+      allocRepo = {
+        find: jest.fn().mockImplementation(({ where }: { where: { trainSetWagonId: string } }) =>
+          Promise.resolve(allocsByWagon[where.trainSetWagonId] ?? []),
+        ),
+        update: jest.fn().mockResolvedValue(undefined),
+      };
+      slotRepo = { update: jest.fn().mockResolvedValue(undefined) };
+      wagonRepo = { findOne: jest.fn().mockResolvedValue(null) };
+      dataSource.getRepository.mockImplementation((entity: unknown) => {
+        if (entity === WagonBookingAllocation) return allocRepo;
+        if (entity === TrainSetWagon) return slotRepo;
+        if (entity === Wagon) return wagonRepo;
+        return { find: jest.fn().mockResolvedValue([]) };
+      });
+      dataSource.transaction.mockImplementation(
+        async (fn: (m: unknown) => Promise<void>) =>
+          fn({ getRepository: dataSource.getRepository }),
+      );
+      jest
+        .spyOn(
+          service as never as { getTrainScheduleById: (id: string) => Promise<unknown> },
+          'getTrainScheduleById' as never,
+        )
+        .mockResolvedValue({ id: 'sched-1' } as never);
+    });
+
+    it('rejects moves on a dispatched train', async () => {
+      trainSchedulesRepository.findByIdWithFullGraph.mockResolvedValue(
+        makeSchedule({ status: 'DISPATCHED' }),
+      );
+      await expect(
+        service.moveWagonLoad('sched-1', 'wA', { targetWagonId: 'wB' }),
+      ).rejects.toThrow(BadRequestException);
+      expect(dataSource.transaction).not.toHaveBeenCalled();
+    });
+
+    it('404s when the target is neither a slot nor a consist wagon of this train', async () => {
+      await expect(
+        service.moveWagonLoad('sched-1', 'wA', { targetWagonId: 'nope' }),
+      ).rejects.toThrow(/not part of this schedule/);
+    });
+
+    it('swaps two loaded wagons: every allocation crosses over, load fields swap', async () => {
+      await service.moveWagonLoad('sched-1', 'wA', { targetWagonId: 'wB' });
+
+      // The 20ft pair moved together onto wagon B…
+      expect(allocRepo.update).toHaveBeenCalledWith('alloc-a1', { trainSetWagonId: 'wB' });
+      expect(allocRepo.update).toHaveBeenCalledWith('alloc-a2', { trainSetWagonId: 'wB' });
+      // …and the 40ft came back to wagon A.
+      expect(allocRepo.update).toHaveBeenCalledWith('alloc-b1', { trainSetWagonId: 'wA' });
+      // Load-coupled slot fields follow their loads.
+      expect(slotRepo.update).toHaveBeenCalledWith('wB', {
+        assignedWeightTons: 40,
+        status: 'RESERVED',
+        boardYardId: 'yard-1',
+        alightYardId: null,
+      });
+      expect(slotRepo.update).toHaveBeenCalledWith('wA', {
+        assignedWeightTons: 25,
+        status: 'RESERVED',
+        boardYardId: null,
+        alightYardId: null,
+      });
+    });
+
+    it('repins the slot onto an empty consist-only wagon (the 404 case)', async () => {
+      wagonRepo.findOne.mockResolvedValue({
+        id: 'phys-9',
+        wagonTypeId: 'wt-1',
+        wagonNumber: 'WGN-9',
+        wagonType: { ...containerType, capacityTons: 70, lengthMeters: 14 },
+      });
+
+      await service.moveWagonLoad('sched-1', 'wA', { targetWagonId: 'phys-9' });
+
+      expect(wagonRepo.findOne).toHaveBeenCalledWith(
+        expect.objectContaining({ where: { id: 'phys-9', trainId: 'train-1' } }),
+      );
+      // Repin: wagon identity moves onto the slot; allocations stay put.
+      expect(slotRepo.update).toHaveBeenCalledWith('wA', {
+        physicalWagonId: 'phys-9',
+        wagonTypeId: 'wt-1',
+        capacityTons: 70,
+        lengthMeters: 14,
+      });
+      expect(allocRepo.update).not.toHaveBeenCalled();
+    });
+
+    it('rejects a bulk load onto a wagon whose type only supports containers', async () => {
+      allocsByWagon.wA = [
+        { id: 'alloc-bulk', trainSetWagonId: 'wA', bookingId: 'b9', allocatedWeightTons: 50, loadType: 'BULK' },
+      ];
+      allocsByWagon.wB = [];
+
+      await expect(
+        service.moveWagonLoad('sched-1', 'wA', { targetWagonId: 'wB' }),
+      ).rejects.toThrow(/cannot carry a bulk load/);
+    });
+
+    it('rejects when the incoming load exceeds the receiving wagon payload', async () => {
+      allocsByWagon.wA = [
+        { id: 'alloc-heavy', trainSetWagonId: 'wA', bookingId: 'b9', allocatedWeightTons: 70, loadType: 'CONTAINER' },
+      ];
+      allocsByWagon.wB = [];
+
+      await expect(
+        service.moveWagonLoad('sched-1', 'wA', { targetWagonId: 'wB' }),
+      ).rejects.toThrow(/over its/);
+    });
+  });
 });
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 2f7ca0776..13624691a 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
@@ -77,6 +77,7 @@ import {
   TrainScheduleFreightType,
 } from './dto/list-train-schedules-query.dto';
 import { PinWagonsDto } from './dto/pin-wagons.dto';
+import { MoveWagonLoadDto } from './dto/move-wagon-load.dto';
 import { UpdateContainerItemDto } from './dto/update-container-item.dto';
 import { UpdateImportLoadingStatusDto } from './dto/update-import-loading-status.dto';
 import { PreviewBulkTrainScheduleDto } from './dto/preview-bulk-train-schedule.dto';
@@ -122,7 +123,7 @@ import {
   sumWagonsRequired,
   type TrainLimitConfig,
   validateContainerPlacements,
-  validateMixedTrainLimits,
+  validateMixedTrainLimitsPerEdge,
   type ContainerPlacementInput,
   type WagonPlanSlot,
 } from './wagon-plan.util';
@@ -1538,8 +1539,21 @@ export class TrainSchedulingService {
       }
     }
 
+    // The rebuild below deletes EVERY schedule↔booking link row and recreates
+    // only what makes the new plan. Ride-along (intercity) bookings are linked
+    // OUTSIDE this flow — by acceptIntercity/allocate — and never appear in the
+    // workspace's picked ids, so planning from dto.bookingIds alone silently
+    // orphans them: PAID + SCHEDULED with no link and no wagon, invisible in
+    // every list. Every (re)assignment therefore re-plans the WHOLE train:
+    // the requested ids plus everything currently linked.
+    const linkedRows =
+      await this.trainScheduleBookingsRepository.findByScheduleId(scheduleId);
+    const allBookingIds = [
+      ...new Set([...dto.bookingIds, ...linkedRows.map((row) => row.bookingId)]),
+    ];
+
     const previewDto = {
-      bookingIds: dto.bookingIds,
+      bookingIds: allBookingIds,
       scheduleDate: schedule.scheduledDepartureDate.toISOString(),
       originStationId: schedule.originStationId,
       destinationStationId: schedule.destinationStationId,
@@ -1562,8 +1576,13 @@ export class TrainSchedulingService {
     // preview the wagon plan first, then lay containers into the plan's slots.
     // Without this the placement validator rejects container bookings outright
     // ("Container placements are required for container bookings").
+    // Callers hand-pick placements only for the bookings they know about; the
+    // union above may have folded in linked ride-alongs those placements never
+    // covered. Auto-fill whatever units are missing (all of them when no
+    // placements were sent at all) so the placement validator doesn't reject
+    // container bookings the caller couldn't have placed.
     let containerPlacements = dto.containerPlacements;
-    if (!containerPlacements?.length) {
+    {
       const preview = await this.validateBookingsForScheduling(
         previewDto,
         freightType ?? null,
@@ -1578,18 +1597,28 @@ export class TrainSchedulingService {
       );
       if (containerBookings.length) {
         const units = expandBookingContainerUnits(containerBookings);
-        const slots = getContainerSlotSequenceNos(preview.wagonPlan);
-        const generated = autoFillPlacements(units, slots);
-        const missing = findMissingContainerNumberIssues(units, generated);
-        if (missing.length) {
-          throw new BadRequestException({
-            message: `Booking validation failed: ${missing
-              .map((m) => m.issue)
-              .join('; ')}`,
-            violations: missing.map((m) => m.issue),
-          });
+        const providedKeys = new Set(
+          (containerPlacements ?? []).map(
+            (p) => `${p.bookingContainerId}:${p.unitIndex}`,
+          ),
+        );
+        const unplacedUnits = units.filter(
+          (u) => !providedKeys.has(`${u.bookingContainerId}:${u.unitIndex}`),
+        );
+        if (unplacedUnits.length) {
+          const slots = getContainerSlotSequenceNos(preview.wagonPlan);
+          const generated = autoFillPlacements(unplacedUnits, slots);
+          const missing = findMissingContainerNumberIssues(unplacedUnits, generated);
+          if (missing.length) {
+            throw new BadRequestException({
+              message: `Booking validation failed: ${missing
+                .map((m) => m.issue)
+                .join('; ')}`,
+              violations: missing.map((m) => m.issue),
+            });
+          }
+          containerPlacements = [...(containerPlacements ?? []), ...generated];
         }
-        containerPlacements = generated;
       }
     }
 
@@ -1632,8 +1661,10 @@ export class TrainSchedulingService {
     // NW5 free) — the caller saw HTTP 200 and a green toast over a no-op.
     // A stock shortage is a physical impossibility, so forceAssign cannot
     // override it either.
+    // Linked ride-alongs count as requested too: silently dropping one here is
+    // exactly the delete-and-recreate orphan this method must never produce.
     const plannedIds = new Set(validation.bookings.map((b) => b.id));
-    const droppedRequested = dto.bookingIds.filter((id) => !plannedIds.has(id));
+    const droppedRequested = allBookingIds.filter((id) => !plannedIds.has(id));
     if (droppedRequested.length) {
       const reasonById = new Map(
         validation.deferredBookings.map((d) => [d.id, `${d.reference}: ${d.reason}`]),
@@ -2632,6 +2663,11 @@ export class TrainSchedulingService {
     // dispatch pre-check keeps reporting these bookings as unloaded).
     const wagonAssignedIds = await this.getWagonAssignedBookingIds(scheduleId);
     if (wagonAssignedIds.size) {
+      // Export cargo must be received at the warehouse with a GRN before it can
+      // be confirmed loaded — an allocation is not proof the goods are in hand.
+      if (this.isExportSchedule(schedule)) {
+        await this.assertExportBookingsReceived([...wagonAssignedIds]);
+      }
       await this.trainScheduleBookingsRepository.updateLoadingStatusMany(
         scheduleId,
         [...wagonAssignedIds],
@@ -2909,6 +2945,38 @@ export class TrainSchedulingService {
     return direction === 'EXPORT';
   }
 
+  /**
+   * Every export booking being confirmed loaded must already be received at the
+   * warehouse with a GRN. An allocation puts a booking on a wagon on paper; this
+   * is the check that the cargo is physically in the yard before we call it loaded.
+   */
+  private async assertExportBookingsReceived(bookingIds: string[]): Promise<void> {
+    if (!bookingIds.length) return;
+    const rows: Array<{ reference: string | null }> = await this.dataSource.query(
+      `SELECT b.reference
+         FROM freight.bookings b
+        WHERE b.id = ANY($1)
+          AND b.deleted_at IS NULL
+          AND NOT EXISTS (
+            SELECT 1 FROM freight.warehouse_inventory inv
+             WHERE inv.booking_id = b.id
+               AND inv.deleted_at IS NULL
+               AND inv.status IN ('RECEIVED','STORED','RESERVED','READY_FOR_LOADING','LOADED','DISPATCHED')
+               AND COALESCE(
+                     NULLIF(TRIM(inv.grn_number), ''),
+                     substring(inv.notes FROM 'GRN Number: ([^\\n\\r]+)')
+                   ) IS NOT NULL
+          )`,
+      [bookingIds],
+    );
+    if (rows.length) {
+      const refs = rows.map((r) => r.reference ?? '(unknown)').join(', ');
+      throw new BadRequestException(
+        `These export bookings are not received at the warehouse yet — receive their cargo and generate a GRN before loading: ${refs}.`,
+      );
+    }
+  }
+
   private buildImportLoadListHtml(loadList: Awaited<ReturnType<TrainSchedulingService['generateImportLoadList']>>): string {
     const esc = (value: unknown) =>
       String(value ?? '-')
@@ -3815,25 +3883,24 @@ export class TrainSchedulingService {
       );
     }
 
+    // Corridor-aware: a booking belongs on this train when its origin and
+    // destination lie on the schedule's stop list in order — sub-corridor
+    // bookings (Dire→Djibouti on an Addis→…→Djibouti train) are valid. The
+    // stop list is also what makes the wagon plan leg-aware below.
+    let stops = [dto.originStationId, dto.destinationStationId];
+    if (targetScheduleId) {
+      const target = await this.trainSchedulesRepository.findById(targetScheduleId);
+      if (target) stops = await this.stopYardsForSchedule(target);
+    }
     if (
-      await (async () => {
-        // Corridor-aware: a booking belongs on this train when its origin and
-        // destination lie on the schedule's stop list in order — sub-corridor
-        // bookings (Dire→Djibouti on an Addis→…→Djibouti train) are valid.
-        let stops = [dto.originStationId, dto.destinationStationId];
-        if (targetScheduleId) {
-          const target = await this.trainSchedulesRepository.findById(targetScheduleId);
-          if (target) stops = await this.stopYardsForSchedule(target);
+      bookings.some((b) => {
+        if (targetScheduleId && b.trainScheduleId === targetScheduleId) {
+          return false;
         }
-        return bookings.some((b) => {
-          if (targetScheduleId && b.trainScheduleId === targetScheduleId) {
-            return false;
-          }
-          const fromIdx = stops.indexOf(b.originYardId);
-          const toIdx = stops.indexOf(b.destinationYardId);
-          return fromIdx < 0 || toIdx < 0 || fromIdx >= toIdx;
-        });
-      })()
+        const fromIdx = stops.indexOf(b.originYardId);
+        const toIdx = stops.indexOf(b.destinationYardId);
+        return fromIdx < 0 || toIdx < 0 || fromIdx >= toIdx;
+      })
     ) {
       violations.push('Selected bookings must lie on the schedule route (origin before destination)');
     }
@@ -3919,7 +3986,22 @@ export class TrainSchedulingService {
       stock = { mode: 'YARD', remainingByTypeId, codesByTypeId };
     }
 
-    const planned = planWagonsWithStock({ bookings, allowed, stock });
+    // Leg-aware stock: each booking consumes wagons only on the edges it rides,
+    // so a ride-along on an empty leg never competes with cargo on a full one.
+    const legByBookingId = new Map(
+      bookings.flatMap((b) => {
+        const from = stops.indexOf(b.originYardId);
+        const to = stops.indexOf(b.destinationYardId);
+        return from >= 0 && to > from ? [[b.id, { from, to }] as const] : [];
+      }),
+    );
+    const planned = planWagonsWithStock({
+      bookings,
+      allowed,
+      stock,
+      legs: legByBookingId,
+      edgeCount: Math.max(1, stops.length - 1),
+    });
     violations.push(...planned.configIssues);
     const fittingBookings = planned.fitting;
     const deferredBookings: DeferredBookingRow[] = planned.deferred;
@@ -3981,10 +4063,11 @@ export class TrainSchedulingService {
       ).values(),
     ];
     pushLimit(
-      validateMixedTrainLimits(
+      validateMixedTrainLimitsPerEdge(
         wagonPlan,
         plannedWagonTypes.length ? plannedWagonTypes : [{ lengthMeters: 14 }],
         trainLimits,
+        stops,
       ),
     );
     if (requireContainerPlacements && resolvedMode !== 'BULK') {
@@ -6773,12 +6856,33 @@ export class TrainSchedulingService {
           status: sb.booking?.status ?? null,
           schedulingStatus: sb.booking?.schedulingStatus ?? null,
           freightType: sb.booking?.freightType ?? null,
+          // Which leg of the corridor this booking rides — the workspace can't
+          // tell a ride-along (intercity) or sub-corridor booking from through
+          // cargo without it.
+          tradeDirection: sb.booking?.tradeDirection ?? null,
+          originYardId: sb.booking?.originYardId ?? null,
+          destinationYardId: sb.booking?.destinationYardId ?? null,
+          origin:
+            sb.booking?.originYard?.label ?? sb.booking?.originYard?.code ?? null,
+          destination:
+            sb.booking?.destinationYard?.label ??
+            sb.booking?.destinationYard?.code ??
+            null,
+          wagonsRequired:
+            sb.booking?.wagonsRequired != null
+              ? Number(sb.booking.wagonsRequired)
+              : null,
+          loadedAt: sb.booking?.loadedAt?.toISOString() ?? null,
+          arrivedAt: sb.booking?.arrivedAt?.toISOString() ?? null,
           // Loaded/unloaded is tracked on the schedule↔booking link, not the
           // booking itself — staff flip it per booking in the workspace before
           // dispatch. Defaults UNLOADED for links written before the column.
           loadingStatus: sb.loadingStatus ?? LoadingStatus.Unloaded,
           wagonAssigned: allocatedBookingIds.has(sb.booking?.id ?? sb.bookingId),
         })) ?? [],
+      // Ordered corridor stops (route milestones; falls back to the two
+      // endpoints) — lets the UI draw per-segment occupancy and label legs.
+      stops: this.mapScheduleStops(schedule),
       // True when the wagon plan above is served from the frozen snapshot (schedule
       // is dispatched/arrived/cancelled) rather than the live joins — the UI can badge
       // it "historical" and skip re-pin affordances.
@@ -6787,6 +6891,42 @@ export class TrainSchedulingService {
     };
   }
 
+  /** Ordered corridor stops with labels, from the loaded route graph (no extra query). */
+  private mapScheduleStops(
+    schedule: TrainSchedule,
+  ): Array<{ yardId: string; label: string }> {
+    const milestones = [...(schedule.route?.milestones ?? [])].sort(
+      (a, b) => a.sequenceNo - b.sequenceNo,
+    );
+    const raw = milestones.length >= 2
+      ? milestones.map((m) => ({
+          yardId: m.yardId,
+          label: m.yard?.label ?? m.yard?.code ?? m.yardId,
+        }))
+      : [
+          {
+            yardId: schedule.originStationId,
+            label:
+              schedule.originStation?.label ??
+              schedule.originStation?.code ??
+              schedule.originStationId,
+          },
+          {
+            yardId: schedule.destinationStationId,
+            label:
+              schedule.destinationStation?.label ??
+              schedule.destinationStation?.code ??
+              schedule.destinationStationId,
+          },
+        ];
+    const seen = new Set<string>();
+    return raw.filter((stop) => {
+      if (!stop.yardId || seen.has(stop.yardId)) return false;
+      seen.add(stop.yardId);
+      return true;
+    });
+  }
+
   private isHoldActive(booking: Booking): boolean {
     if (!booking.holdExpiresAt) return false;
     return booking.holdExpiresAt.getTime() > Date.now();
@@ -7195,6 +7335,171 @@ export class TrainSchedulingService {
     return { id: itemId, containerNumber: dto.containerNumber ?? null };
   }
 
+  /**
+   * Staff rearrange: relocate a wagon's ENTIRE load (all its allocations —
+   * a 40ft, a 20ft pair, or a bulk load) to another wagon of the same train.
+   * Whole-load moves keep every packing rule intact by construction (a valid
+   * load stays valid on any wagon whose type supports it), which is what lets
+   * a 20ft pair travel together and swap places with a 40ft, and lets bulk
+   * swap with containers.
+   *
+   * Three shapes, picked from the target:
+   * - target is an empty consist-only wagon (coupled on the built train, no
+   *   slot row): REPIN — the source slot simply points at that physical wagon
+   *   (type/capacity/length follow), and the wagon it left shows as empty.
+   * - target is an empty slot: allocations repoint to it and the load-coupled
+   *   slot fields (assigned weight, status, board/alight leg) move across.
+   * - target is a loaded slot: the two loads swap wagons the same way.
+   *
+   * Validated per direction: the receiving wagon's type must support the
+   * incoming load type, and the incoming cargo must fit its rated payload.
+   */
+  async moveWagonLoad(
+    scheduleId: string,
+    sourceWagonId: string,
+    dto: MoveWagonLoadDto,
+  ): Promise<any> {
+    const schedule = await this.trainSchedulesRepository.findByIdWithFullGraph(scheduleId);
+    if (!schedule) {
+      throw new NotFoundException(`Train schedule ${scheduleId} not found`);
+    }
+    if (['DISPATCHED', 'ARRIVED'].includes(schedule.status)) {
+      throw new BadRequestException('Cannot rearrange loads on a dispatched train');
+    }
+    if (sourceWagonId === dto.targetWagonId) {
+      return this.getTrainScheduleById(scheduleId);
+    }
+
+    const slots = schedule.trainSet?.wagons ?? [];
+    const source = slots.find((w) => w.id === sourceWagonId);
+    if (!source) {
+      throw new NotFoundException('Source wagon is not part of this schedule');
+    }
+
+    const allocRepo = this.dataSource.getRepository(WagonBookingAllocation);
+    const loadAllocations = (trainSetWagonId: string) =>
+      allocRepo.find({ where: { trainSetWagonId } });
+    const sourceAllocs = await loadAllocations(source.id);
+    if (!sourceAllocs.length) {
+      throw new BadRequestException('Source wagon has no load to move');
+    }
+
+    // Target: a slot of this train set, or an empty consist-only wagon of the
+    // built train (physical wagon with no slot row yet).
+    const targetSlot = slots.find((w) => w.id === dto.targetWagonId) ?? null;
+    const consistWagon = targetSlot
+      ? null
+      : schedule.trainSet?.trainId
+        ? await this.dataSource.getRepository(Wagon).findOne({
+            where: { id: dto.targetWagonId, trainId: schedule.trainSet.trainId },
+            relations: { wagonType: true },
+          })
+        : null;
+    if (!targetSlot && !consistWagon) {
+      throw new NotFoundException('Target wagon is not part of this schedule');
+    }
+    const targetAllocs = targetSlot ? await loadAllocations(targetSlot.id) : [];
+
+    const loadTypesOf = (allocs: WagonBookingAllocation[]) => [
+      ...new Set(allocs.map((a) => (a.loadType ?? 'CONTAINER').toUpperCase())),
+    ];
+    const cargoOf = (allocs: WagonBookingAllocation[]) =>
+      allocs.reduce((sum, a) => sum + Number(a.allocatedWeightTons || 0), 0);
+    const wagonLabel = (slot: { sequenceNo: number } | null, wagon: Wagon | null) =>
+      slot ? `#${slot.sequenceNo}` : (wagon?.wagonNumber ?? 'the target wagon');
+    const checkReceives = (
+      allocs: WagonBookingAllocation[],
+      label: string,
+      wagonType: { code?: string; supportedLoadTypes?: string[]; supportsContainer?: boolean } | null | undefined,
+      capacityTons: number,
+    ) => {
+      const incoming = loadTypesOf(allocs);
+      // Unknown type or no declared support list → staff decides; don't block.
+      if (wagonType) {
+        const supported = (wagonType.supportedLoadTypes ?? []).map((t) => t.toUpperCase());
+        for (const loadType of incoming) {
+          const ok =
+            supported.includes(loadType) ||
+            (loadType === 'CONTAINER' && wagonType.supportsContainer) ||
+            supported.length === 0;
+          if (!ok) {
+            throw new BadRequestException(
+              `Wagon ${label} (${wagonType.code ?? 'unknown type'}) cannot carry a ${loadType.toLowerCase()} load`,
+            );
+          }
+        }
+      }
+      const cargo = cargoOf(allocs);
+      if (capacityTons > 0 && cargo > capacityTons + 0.001) {
+        throw new BadRequestException(
+          `Wagon ${label} would carry ${roundTons(cargo)}T — over its ${roundTons(capacityTons)}T payload`,
+        );
+      }
+    };
+
+    // What the target must be able to receive…
+    checkReceives(
+      sourceAllocs,
+      wagonLabel(targetSlot, consistWagon),
+      targetSlot ? targetSlot.wagonType : consistWagon?.wagonType,
+      Number(targetSlot ? targetSlot.capacityTons : (consistWagon?.wagonType?.capacityTons ?? 0)),
+    );
+    // …and, on a swap, what comes back to the source.
+    if (targetAllocs.length) {
+      checkReceives(
+        targetAllocs,
+        `#${source.sequenceNo}`,
+        source.wagonType,
+        Number(source.capacityTons),
+      );
+    }
+
+    await this.dataSource.transaction(async (manager) => {
+      const slotRepo = manager.getRepository(TrainSetWagon);
+      const allocs = manager.getRepository(WagonBookingAllocation);
+
+      // Empty consist wagon: repin the loaded slot onto that physical wagon.
+      // Allocations and load fields stay put; only the wagon identity changes.
+      if (consistWagon) {
+        await slotRepo.update(source.id, {
+          physicalWagonId: consistWagon.id,
+          wagonTypeId: consistWagon.wagonTypeId,
+          capacityTons: roundTons(Number(consistWagon.wagonType?.capacityTons ?? source.capacityTons)),
+          lengthMeters: roundTons(Number(consistWagon.wagonType?.lengthMeters ?? source.lengthMeters)),
+        });
+        return;
+      }
+
+      const target = targetSlot as TrainSetWagon;
+      // Load-coupled slot fields travel with the load; wagon identity stays.
+      const loadFieldsOf = (slot: TrainSetWagon) => ({
+        assignedWeightTons: slot.assignedWeightTons,
+        status: slot.status,
+        boardYardId: slot.boardYardId ?? null,
+        alightYardId: slot.alightYardId ?? null,
+      });
+      const emptyLoadFields = {
+        assignedWeightTons: 0,
+        status: 'PLANNED',
+        boardYardId: null,
+        alightYardId: null,
+      };
+      const sourceLoadFields = loadFieldsOf(source);
+      const targetLoadFields = targetAllocs.length ? loadFieldsOf(target) : emptyLoadFields;
+
+      for (const alloc of sourceAllocs) {
+        await allocs.update(alloc.id, { trainSetWagonId: target.id });
+      }
+      for (const alloc of targetAllocs) {
+        await allocs.update(alloc.id, { trainSetWagonId: source.id });
+      }
+      await slotRepo.update(target.id, sourceLoadFields);
+      await slotRepo.update(source.id, targetLoadFields);
+    });
+
+    return this.getTrainScheduleById(scheduleId);
+  }
+
   async getUnassignedBookings(scheduleId: string): Promise<UnassignedBookingsResponse> {
     const schedule = await this.trainSchedulesRepository.findByIdWithFullGraph(scheduleId);
     if (!schedule) {
diff --git a/apps/edr-freight-api/src/modules/train-scheduling/wagon-plan-flex.util.spec.ts b/apps/edr-freight-api/src/modules/train-scheduling/wagon-plan-flex.util.spec.ts
index 5870d3785..778dc70dd 100644
--- a/apps/edr-freight-api/src/modules/train-scheduling/wagon-plan-flex.util.spec.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/wagon-plan-flex.util.spec.ts
@@ -187,3 +187,115 @@ describe('applyWagonOrderReversal', () => {
     expect(plan.map((s) => s.wagonTypeId)).toEqual(['wt-a', 'wt-b', 'wt-c']);
   });
 });
+
+describe('planWagonsWithStock — leg-aware stock (intercity ride-along)', () => {
+  const allowed = {
+    byContainerTypeId: new Map([['ct-1', [nw6]]]),
+    byCargoTypeId: new Map(),
+  };
+  // Corridor Gelan(0) → Adama(1) → Doraleh(2): edges 0 and 1.
+  const legs = (entries: Array<[string, { from: number; to: number }]>) =>
+    new Map(entries);
+
+  it('lets an intercity booking ride the empty leg of a train that is full on the other leg', () => {
+    // 1 wagon in stock. Export rides edge 1 only; intercity rides edge 0 only.
+    const result = planWagonsWithStock({
+      bookings: [
+        containerBooking('EXPORT-1', 1, 1),
+        containerBooking('INTERCITY-1', 1, 1),
+      ],
+      allowed,
+      stock: {
+        mode: 'TRAIN',
+        remainingByTypeId: new Map([[nw6.id, 1]]),
+        codesByTypeId: new Map([[nw6.id, nw6.code]]),
+      },
+      legs: legs([
+        ['EXPORT-1', { from: 1, to: 2 }],
+        ['INTERCITY-1', { from: 0, to: 1 }],
+      ]),
+      edgeCount: 2,
+    });
+
+    expect(result.deferred).toHaveLength(0);
+    expect(result.fitting.map((b) => b.id).sort()).toEqual([
+      'EXPORT-1',
+      'INTERCITY-1',
+    ]);
+    // Two slots planned, but both drawn from the single physical wagon.
+    expect(result.plan).toHaveLength(2);
+  });
+
+  it('still defers when the legs overlap and stock is exhausted', () => {
+    const result = planWagonsWithStock({
+      bookings: [
+        containerBooking('EXPORT-1', 1, 1),
+        containerBooking('INTERCITY-1', 1, 1),
+      ],
+      allowed,
+      stock: {
+        mode: 'TRAIN',
+        remainingByTypeId: new Map([[nw6.id, 1]]),
+        codesByTypeId: new Map([[nw6.id, nw6.code]]),
+      },
+      legs: legs([
+        // Both ride edge 0 — they compete for the one wagon.
+        ['EXPORT-1', { from: 0, to: 2 }],
+        ['INTERCITY-1', { from: 0, to: 1 }],
+      ]),
+      edgeCount: 2,
+    });
+
+    expect(result.fitting.map((b) => b.id)).toEqual(['EXPORT-1']);
+    expect(result.deferred).toHaveLength(1);
+    expect(result.deferred[0]!.reference).toBe('INTERCITY-1');
+    expect(result.deferred[0]!.reason).toContain('Train has no free NW6 wagon left');
+  });
+
+  it('never packs bookings with different legs into the same wagon slot', () => {
+    // Two 20ft units with room to share one wagon by TEU — but disjoint legs
+    // must open separate slots (each with its own leg), not one mixed slot.
+    const result = planWagonsWithStock({
+      bookings: [
+        containerBooking('EXPORT-1', 1, 1),
+        containerBooking('INTERCITY-1', 1, 1),
+      ],
+      allowed,
+      stock: {
+        mode: 'TRAIN',
+        remainingByTypeId: new Map([[nw6.id, 2]]),
+        codesByTypeId: new Map([[nw6.id, nw6.code]]),
+      },
+      legs: legs([
+        ['EXPORT-1', { from: 1, to: 2 }],
+        ['INTERCITY-1', { from: 0, to: 1 }],
+      ]),
+      edgeCount: 2,
+    });
+
+    expect(result.plan).toHaveLength(2);
+    const bookingsPerSlot = result.plan.map((s) =>
+      [...new Set(s.allocations.map((a) => a.bookingId))].sort(),
+    );
+    expect(bookingsPerSlot).toEqual([['EXPORT-1'], ['INTERCITY-1']]);
+  });
+
+  it('behaves exactly like the whole-route planner when no legs are given', () => {
+    const result = planWagonsWithStock({
+      bookings: [
+        containerBooking('EXPORT-1', 1, 1),
+        containerBooking('INTERCITY-1', 1, 1),
+      ],
+      allowed,
+      stock: {
+        mode: 'TRAIN',
+        remainingByTypeId: new Map([[nw6.id, 1]]),
+        codesByTypeId: new Map([[nw6.id, nw6.code]]),
+      },
+    });
+
+    // One wagon, two 20ft bookings: they TEU-share the single slot (legacy).
+    expect(result.deferred).toHaveLength(0);
+    expect(result.plan).toHaveLength(1);
+  });
+});
diff --git a/apps/edr-freight-api/src/modules/train-scheduling/wagon-plan-flex.util.ts b/apps/edr-freight-api/src/modules/train-scheduling/wagon-plan-flex.util.ts
index 6a3c1c49f..699d7a432 100644
--- a/apps/edr-freight-api/src/modules/train-scheduling/wagon-plan-flex.util.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/wagon-plan-flex.util.ts
@@ -58,8 +58,18 @@ type OpenSlot = {
   /** Kind purity: a bulk wagon carries ONE cargo type at a time. */
   cargoTypeId: string | null;
   freeCapacityTons: number;
+  /**
+   * Corridor leg this slot rides (`"from-to"` stop indexes). Bookings only
+   * share a slot when their legs are identical — mixing corridors in one slot
+   * would degrade it to a whole-route slot (see stampSlotLegs) and silently
+   * re-occupy edges the cargo never rides.
+   */
+  legKey: string;
 };
 
+/** Stop-index range a booking occupies: edges `from..to-1` of the corridor. */
+export type BookingLeg = { from: number; to: number };
+
 type PlacementProblem = {
   kind: 'config' | 'stock';
   message: string;
@@ -87,7 +97,7 @@ const slotFromWagonType = (wagonType: WagonType, kind: SlotLoadType): WagonPlanS
 const shortageFor = (
   booking: Booking,
   candidates: WagonType[],
-  remaining: Map<string, number>,
+  availableOf: (wagonTypeId: string) => number,
 ): BookingWagonShortage => {
   const wagonsNeeded =
     booking.freightType === 'BULK'
@@ -100,7 +110,7 @@ const shortageFor = (
         )
       : Math.max(1, containerWagonsForLines(booking.bookingContainers ?? []));
   const wagonsAvailable = candidates.reduce(
-    (sum, wt) => sum + (remaining.get(wt.id) ?? 0),
+    (sum, wt) => sum + availableOf(wt.id),
     0,
   );
   return {
@@ -140,14 +150,53 @@ export function planWagonsWithStock(params: {
   bookings: Booking[];
   allowed: AllowedWagonTypeMap;
   stock: WagonStock;
+  /**
+   * Leg-aware stock: booking id → the stop-index range it rides. When given
+   * (with `edgeCount`), a wagon type's stock is consumed PER CORRIDOR EDGE, so
+   * the same physical wagon can serve an intercity booking on Gelan→Adama and
+   * an export booking on Adama→Doraleh — disjoint legs never compete for
+   * stock. Omitted → one edge, byte-identical to the old whole-route behavior.
+   */
+  legs?: Map<string, BookingLeg>;
+  edgeCount?: number;
 }): FlexPlanResult {
-  const { bookings, allowed, stock } = params;
-  const remaining = new Map(stock.remainingByTypeId);
+  const { bookings, allowed, stock, legs } = params;
+  const edgeCount = Math.max(1, params.edgeCount ?? 1);
   const openSlots: OpenSlot[] = [];
   const fitting: Booking[] = [];
   const deferred: DeferredBookingRow[] = [];
   const configIssues = new Set<string>();
 
+  const legFor = (booking: Booking): BookingLeg => {
+    const leg = legs?.get(booking.id);
+    if (!leg || leg.from < 0 || leg.to > edgeCount || leg.from >= leg.to) {
+      return { from: 0, to: edgeCount };
+    }
+    return leg;
+  };
+  const legKeyOf = (leg: BookingLeg) => `${leg.from}-${leg.to}`;
+
+  // Wagons of a type in use per corridor edge. A type is available for a leg
+  // when its busiest edge WITHIN that leg still has stock spare — the max over
+  // edges is the number of physical wagons the type needs simultaneously.
+  const usedPerEdge = new Map<string, number[]>();
+  const usedRow = (wagonTypeId: string): number[] => {
+    let row = usedPerEdge.get(wagonTypeId);
+    if (!row) {
+      row = new Array<number>(edgeCount).fill(0);
+      usedPerEdge.set(wagonTypeId, row);
+    }
+    return row;
+  };
+  const availableFor = (wagonTypeId: string, leg: BookingLeg): number => {
+    const total = stock.remainingByTypeId.get(wagonTypeId) ?? 0;
+    const row = usedPerEdge.get(wagonTypeId);
+    if (!row) return total;
+    let busiest = 0;
+    for (let e = leg.from; e < leg.to; e += 1) busiest = Math.max(busiest, row[e] ?? 0);
+    return total - busiest;
+  };
+
   const noStockMessage = (candidates: WagonType[]): string => {
     const codes = candidates.map((wt) => wt.code).join('/');
     return stock.mode === 'TRAIN'
@@ -155,13 +204,14 @@ export function planWagonsWithStock(params: {
       : `No available ${codes} wagon at the yard`;
   };
 
-  /** Open a new wagon of one of the candidate types, consuming stock. */
+  /** Open a new wagon of one of the candidate types, consuming stock on the leg's edges. */
   const openSlot = (
     candidates: WagonType[],
     kind: SlotLoadType,
     cargoTypeId: string | null,
+    leg: BookingLeg,
   ): OpenSlot | PlacementProblem => {
-    const inStock = candidates.filter((wt) => (remaining.get(wt.id) ?? 0) > 0);
+    const inStock = candidates.filter((wt) => availableFor(wt.id, leg) > 0);
     if (!inStock.length) {
       return { kind: 'stock', message: noStockMessage(candidates), candidates };
     }
@@ -170,22 +220,26 @@ export function planWagonsWithStock(params: {
     const chosen = [...inStock].sort((a, b) =>
       kind === 'BULK'
         ? Number(b.capacityTons) - Number(a.capacityTons) ||
-          (remaining.get(b.id) ?? 0) - (remaining.get(a.id) ?? 0)
-        : (remaining.get(b.id) ?? 0) - (remaining.get(a.id) ?? 0),
+          availableFor(b.id, leg) - availableFor(a.id, leg)
+        : availableFor(b.id, leg) - availableFor(a.id, leg),
     )[0];
-    remaining.set(chosen.id, (remaining.get(chosen.id) ?? 0) - 1);
+    const row = usedRow(chosen.id);
+    for (let e = leg.from; e < leg.to; e += 1) row[e] = (row[e] ?? 0) + 1;
     const open: OpenSlot = {
       slot: slotFromWagonType(chosen, kind),
       teuUsed: 0,
       kind,
       cargoTypeId,
       freeCapacityTons: Number(chosen.capacityTons),
+      legKey: legKeyOf(leg),
     };
     openSlots.push(open);
     return open;
   };
 
   const tryPlaceBooking = (booking: Booking): PlacementProblem | null => {
+    const leg = legFor(booking);
+    const legKey = legKeyOf(leg);
     if (booking.freightType === 'CONTAINER') {
       const units = expandBookingContainerUnits([booking]);
       if (!units.length) {
@@ -209,11 +263,12 @@ export function planWagonsWithStock(params: {
         let target = openSlots.find(
           (open) =>
             open.kind === 'CONTAINER' &&
+            open.legKey === legKey &&
             allowedIds.has(open.slot.wagonTypeId) &&
             open.teuUsed + teu <= MAX_TEU_SLOTS_PER_WAGON,
         );
         if (!target) {
-          const openedSlot = openSlot(candidates, 'CONTAINER', null);
+          const openedSlot = openSlot(candidates, 'CONTAINER', null, leg);
           if ('message' in openedSlot) return openedSlot;
           target = openedSlot;
         }
@@ -246,6 +301,7 @@ export function planWagonsWithStock(params: {
     for (const open of openSlots) {
       if (remainingWeight <= 0) break;
       if (open.kind !== 'BULK') continue;
+      if (open.legKey !== legKey) continue;
       if (open.cargoTypeId !== cargoTypeId) continue;
       if (!allowedIds.has(open.slot.wagonTypeId)) continue;
       if (open.freeCapacityTons <= 0) continue;
@@ -263,7 +319,7 @@ export function planWagonsWithStock(params: {
     }
 
     while (remainingWeight > 0 || !placedAnywhere) {
-      const openedSlot = openSlot(candidates, 'BULK', cargoTypeId);
+      const openedSlot = openSlot(candidates, 'BULK', cargoTypeId, leg);
       if ('message' in openedSlot) return openedSlot;
       const take = roundTons(Math.min(openedSlot.freeCapacityTons, remainingWeight));
       addAllocation(
@@ -282,7 +338,9 @@ export function planWagonsWithStock(params: {
 
   for (const booking of sortBookingsForScheduling(bookings)) {
     // Snapshot so a booking that doesn't fully fit leaves no half-placed wagons.
-    const remainingSnapshot = new Map(remaining);
+    const usedSnapshot = new Map(
+      [...usedPerEdge.entries()].map(([typeId, row]) => [typeId, [...row]]),
+    );
     const slotCountSnapshot = openSlots.length;
     const slotStateSnapshot = openSlots.map((open) => ({
       teuUsed: open.teuUsed,
@@ -299,8 +357,8 @@ export function planWagonsWithStock(params: {
     }
 
     // Roll back this booking's partial placements.
-    remaining.clear();
-    for (const [key, value] of remainingSnapshot) remaining.set(key, value);
+    usedPerEdge.clear();
+    for (const [key, value] of usedSnapshot) usedPerEdge.set(key, value);
     openSlots.length = slotCountSnapshot;
     openSlots.forEach((open, index) => {
       const snap = slotStateSnapshot[index];
@@ -315,11 +373,14 @@ export function planWagonsWithStock(params: {
     });
 
     if (problem.kind === 'config') configIssues.add(problem.message);
-    // remaining is rolled back here, so the shortage counts the stock this
+    // Usage is rolled back here, so the shortage counts the stock this
     // booking actually saw — not what its own partial placement consumed.
+    const bookingLeg = legFor(booking);
     const shortage =
       problem.kind === 'stock' && problem.candidates?.length
-        ? shortageFor(booking, problem.candidates, remaining)
+        ? shortageFor(booking, problem.candidates, (wagonTypeId) =>
+            Math.max(0, availableFor(wagonTypeId, bookingLeg)),
+          )
         : null;
     deferred.push({
       id: booking.id,
diff --git a/apps/edr-freight-api/src/modules/train-scheduling/wagon-plan.util.ts b/apps/edr-freight-api/src/modules/train-scheduling/wagon-plan.util.ts
index bb5ce890c..1aa555531 100644
--- a/apps/edr-freight-api/src/modules/train-scheduling/wagon-plan.util.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/wagon-plan.util.ts
@@ -525,6 +525,40 @@ export function validateMixedTrainLimits(
   );
 }
 
+/**
+ * Leg-aware limit check: with a real stop list, a slot only counts on the
+ * edges it actually rides (boardYardId→alightYardId; null = the schedule's
+ * own endpoint). Each edge is validated as its own consist, so an intercity
+ * wagon on Gelan→Adama never counts against a train that is full only on
+ * Adama→Doraleh. Two stops (or fewer) degrade to the whole-train check.
+ */
+export function validateMixedTrainLimitsPerEdge(
+  wagonPlan: WagonPlanSlot[],
+  wagonTypes: Array<Pick<WagonType, 'lengthMeters'>>,
+  limits: TrainLimitConfig | undefined,
+  stops: string[],
+): string[] {
+  if (stops.length <= 2) return validateMixedTrainLimits(wagonPlan, wagonTypes, limits);
+  const lastIdx = stops.length - 1;
+  const spans = wagonPlan.map((slot) => {
+    const from = slot.boardYardId ? stops.indexOf(slot.boardYardId) : 0;
+    const to = slot.alightYardId ? stops.indexOf(slot.alightYardId) : lastIdx;
+    // A yard missing from the stop list keeps the slot on the whole route.
+    return { from: from >= 0 ? from : 0, to: to > 0 ? to : lastIdx };
+  });
+  const violations = new Set<string>();
+  for (let edge = 0; edge < lastIdx; edge += 1) {
+    const active = wagonPlan.filter(
+      (_, i) => spans[i].from <= edge && edge < spans[i].to,
+    );
+    if (!active.length) continue;
+    for (const violation of validateMixedTrainLimits(active, wagonTypes, limits)) {
+      violations.add(violation);
+    }
+  }
+  return [...violations];
+}
+
 export function validate20ftContainerRules(
   units: ContainerUnitRow[],
   placements: ContainerPlacementInput[],
diff --git a/apps/edr-freight-api/src/modules/trains/train-builder.service.ts b/apps/edr-freight-api/src/modules/trains/train-builder.service.ts
index 3658f4f37..662b83534 100644
--- a/apps/edr-freight-api/src/modules/trains/train-builder.service.ts
+++ b/apps/edr-freight-api/src/modules/trains/train-builder.service.ts
@@ -29,6 +29,9 @@ import {
 
 const round = (value: unknown) => Math.round((Number(value) || 0) * 100) / 100;
 
+/** Locomotive statuses that block a train from reactivating. */
+const UNFIT_FOR_REACTIVATION = new Set(['MAINTENANCE', 'OUT_OF_SERVICE', 'UNAVAILABLE']);
+
 /** The one active (DRAFT/SCHEDULED/DISPATCHED) schedule surfaced per built train. */
 export interface ActiveScheduleRef {
   id: string;
@@ -596,11 +599,30 @@ export class TrainBuilderService {
     return this.getComposition(id);
   }
 
-  /** Reactivate a DEACTIVATED train back to AVAILABLE so it can be scheduled again. */
+  /**
+   * Reactivate a DEACTIVATED train back to AVAILABLE so it can be scheduled
+   * again. Blocked if any coupled locomotive is unfit for service — a
+   * deactivated train can sit parked for a while and its locomotives may have
+   * since been sent to maintenance independently; reactivating must not wave
+   * a down locomotive back onto the schedule board.
+   */
   async activate(id: string) {
     const train = await this.dataSource.getRepository(Train).findOne({ where: { id } });
     if (!train) throw new NotFoundException(`Train ${id} not found`);
     if (train.status === Freight.TrainStatus.Deactivated) {
+      const links = await this.dataSource
+        .getRepository(TrainLocomotive)
+        .find({ where: { trainId: id }, relations: { locomotive: true } });
+      const unfit = links
+        .map((link) => link.locomotive)
+        .filter((loco): loco is Locomotive => Boolean(loco))
+        .filter((loco) => UNFIT_FOR_REACTIVATION.has(loco.status));
+      if (unfit.length) {
+        const names = unfit.map((l) => `${l.code} (${l.status})`).join(', ');
+        throw new ConflictException(
+          `Train cannot be reactivated: ${names} ${unfit.length > 1 ? 'are' : 'is'} not fit for service. Detach and replace before reactivating.`,
+        );
+      }
       await this.dataSource
         .getRepository(Train)
         .update(id, { status: Freight.TrainStatus.Available });
diff --git a/apps/edr-freight-api/src/modules/vehicles/dto/create-vehicle.dto.spec.ts b/apps/edr-freight-api/src/modules/vehicles/dto/create-vehicle.dto.spec.ts
new file mode 100644
index 000000000..5696f00cb
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/vehicles/dto/create-vehicle.dto.spec.ts
@@ -0,0 +1,61 @@
+import { plainToInstance } from 'class-transformer';
+import { validate } from 'class-validator';
+
+import { CreateVehicleDto } from './create-vehicle.dto';
+
+const base = {
+  vehicleType: 'TRUCK',
+  manufacturer: 'IVECO',
+  model: 'HYT',
+  year: 2020,
+  fuelType: 'DIESEL',
+  capacity: 0,
+  status: 'ACTIVE',
+};
+
+const errorsFor = (over: Record<string, unknown>) =>
+  validate(plainToInstance(CreateVehicleDto, { ...base, ...over }));
+
+const plateErrors = (
+  errors: Awaited<ReturnType<typeof errorsFor>>,
+  property: string,
+) => errors.find((e) => e.property === property && e.constraints?.matches);
+
+describe('CreateVehicleDto — plate format', () => {
+  it('accepts a plate like ET-9875', async () => {
+    expect(plateErrors(await errorsFor({ plateNumber: 'ET-9875' }), 'plateNumber')).toBeUndefined();
+  });
+
+  it('accepts a plate like AA-8642', async () => {
+    expect(plateErrors(await errorsFor({ plateNumber: 'AA-8642' }), 'plateNumber')).toBeUndefined();
+  });
+
+  it('upper-cases a lower-case plate before validating', async () => {
+    const dto = plainToInstance(CreateVehicleDto, { ...base, plateNumber: 'et-9875' });
+    expect(dto.plateNumber).toBe('ET-9875');
+    expect(plateErrors(await validate(dto), 'plateNumber')).toBeUndefined();
+  });
+
+  it('rejects a free-text plate like assadasd', async () => {
+    expect(plateErrors(await errorsFor({ plateNumber: 'assadasd' }), 'plateNumber')).toBeDefined();
+  });
+
+  it('rejects a plate with no letters or no digits', async () => {
+    expect(plateErrors(await errorsFor({ plateNumber: '1234' }), 'plateNumber')).toBeDefined();
+    expect(plateErrors(await errorsFor({ plateNumber: 'ABCD' }), 'plateNumber')).toBeDefined();
+  });
+
+  it('rejects a bad trailer plate but allows a valid one', async () => {
+    expect(
+      plateErrors(await errorsFor({ plateNumber: 'ET-1', trailerPlateNo: 'asdasdasda' }), 'trailerPlateNo'),
+    ).toBeDefined();
+    expect(
+      plateErrors(await errorsFor({ plateNumber: 'ET-1', trailerPlateNo: 'AA-8642' }), 'trailerPlateNo'),
+    ).toBeUndefined();
+  });
+
+  it('allows an empty trailer plate (optional)', async () => {
+    const errors = await errorsFor({ plateNumber: 'ET-1', trailerPlateNo: '' });
+    expect(plateErrors(errors, 'trailerPlateNo')).toBeUndefined();
+  });
+});
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 33d441ecb..4dda3c053 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
@@ -1,7 +1,30 @@
-import { IsString, IsEnum, IsNumber, IsOptional, IsUUID } from 'class-validator';
+import { IsString, IsEnum, IsNumber, IsOptional, IsUUID, Matches } from 'class-validator';
+import { Transform } from 'class-transformer';
 import { VehicleType, FuelType, VehicleStatus, VehicleAvailability } from '../entities/vehicle.entity';
 
+/**
+ * A vehicle plate is two or three letters, a hyphen, then two to six digits —
+ * e.g. ET-9875 or AA-8642. Kept in one place so plate, power-plate and trailer
+ * all match and the message stays consistent.
+ */
+export const VEHICLE_PLATE_REGEX = /^[A-Z]{2,3}-\d{2,6}$/;
+export const VEHICLE_PLATE_MESSAGE =
+  'must be letters and numbers like ET-9875 or AA-8642';
+
+/**
+ * Trim and upper-case a plate before validating, so "et-9875" is accepted. An
+ * empty optional plate (trailer/power) becomes undefined so @IsOptional skips it
+ * rather than failing the pattern.
+ */
+const normalizePlate = ({ value }: { value: unknown }) => {
+  if (typeof value !== 'string') return value;
+  const trimmed = value.trim().toUpperCase();
+  return trimmed === '' ? undefined : trimmed;
+};
+
 export class CreateVehicleDto {
+  @Transform(normalizePlate)
+  @Matches(VEHICLE_PLATE_REGEX, { message: `Plate number ${VEHICLE_PLATE_MESSAGE}` })
   @IsString()
   plateNumber!: string;
 
@@ -47,10 +70,14 @@ export class CreateVehicleDto {
   code?: string;
 
   @IsOptional()
+  @Transform(normalizePlate)
+  @Matches(VEHICLE_PLATE_REGEX, { message: `Power plate number ${VEHICLE_PLATE_MESSAGE}` })
   @IsString()
   powerPlateNo?: string;
 
   @IsOptional()
+  @Transform(normalizePlate)
+  @Matches(VEHICLE_PLATE_REGEX, { message: `Trailer plate number ${VEHICLE_PLATE_MESSAGE}` })
   @IsString()
   trailerPlateNo?: string;
 
diff --git a/apps/edr-freight-api/src/modules/vehicles/vehicles.driver-guard.spec.ts b/apps/edr-freight-api/src/modules/vehicles/vehicles.driver-guard.spec.ts
new file mode 100644
index 000000000..cb810abaf
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/vehicles/vehicles.driver-guard.spec.ts
@@ -0,0 +1,44 @@
+import { ConflictException } from '@nestjs/common';
+
+import { VehiclesService } from './vehicles.service';
+
+// One driver ⇒ one truck: create/update must refuse a driver already assigned
+// to another (non-deleted) vehicle until they are detached.
+describe('VehiclesService driver assignment guard', () => {
+  const otherTruck = { id: 'v2', plateNumber: '3-11111', assignedDriverId: 'd1' };
+
+  const makeService = (findOne: jest.Mock) =>
+    new VehiclesService(
+      { findOne, create: jest.fn((x) => x), save: jest.fn(async (x) => x) } as any,
+      { record: jest.fn() } as any,
+    );
+
+  it('rejects create when the driver is on another truck', async () => {
+    // First findOne = plate uniqueness (null), second = driver holder.
+    const findOne = jest.fn().mockResolvedValueOnce(null).mockResolvedValueOnce(otherTruck);
+    const svc = makeService(findOne);
+    await expect(
+      svc.create({ plateNumber: '3-22222', vehicleType: 'TRUCK', assignedDriverId: 'd1' } as any),
+    ).rejects.toThrow(ConflictException);
+  });
+
+  it('rejects update when reassigning a driver still attached elsewhere', async () => {
+    const findOne = jest
+      .fn()
+      .mockResolvedValueOnce({ id: 'v1', plateNumber: '3-22222', assignedDriverId: null }) // findById
+      .mockResolvedValueOnce(otherTruck); // driver holder
+    const svc = makeService(findOne);
+    await expect(svc.update('v1', { assignedDriverId: 'd1' } as any)).rejects.toThrow(
+      ConflictException,
+    );
+  });
+
+  it('allows update that keeps the same driver on the same truck', async () => {
+    const findOne = jest
+      .fn()
+      .mockResolvedValueOnce({ id: 'v1', plateNumber: '3-22222', assignedDriverId: 'd1' });
+    const svc = makeService(findOne);
+    await expect(svc.update('v1', { assignedDriverId: 'd1' } as any)).resolves.toBeDefined();
+    expect(findOne).toHaveBeenCalledTimes(1); // guard skipped — no holder lookup
+  });
+});
diff --git a/apps/edr-freight-api/src/modules/vehicles/vehicles.service.ts b/apps/edr-freight-api/src/modules/vehicles/vehicles.service.ts
index 25260e86f..98d38cbce 100644
--- a/apps/edr-freight-api/src/modules/vehicles/vehicles.service.ts
+++ b/apps/edr-freight-api/src/modules/vehicles/vehicles.service.ts
@@ -20,6 +20,25 @@ export class VehiclesService {
     private readonly history: FleetHistoryService,
   ) {}
 
+  /**
+   * A driver holds one truck at a time — reassignment requires detaching them
+   * from their current truck first.
+   * ponytail: app-level guard only (race window); add a partial unique index on
+   * assigned_driver_id if concurrent fleet edits ever become real.
+   */
+  private async assertDriverUnassigned(driverId: string, exceptVehicleId?: string): Promise<void> {
+    const holder = await this.vehicleRepo.findOne({
+      where: exceptVehicleId
+        ? { assignedDriverId: driverId, id: Not(exceptVehicleId) }
+        : { assignedDriverId: driverId },
+    });
+    if (holder) {
+      throw new ConflictException(
+        `This driver is already assigned to truck ${holder.plateNumber ?? holder.code ?? holder.id} — detach the driver from that truck first`,
+      );
+    }
+  }
+
   async create(dto: CreateVehicleDto): Promise<Vehicle> {
     const existing = await this.vehicleRepo.findOne({
       where: { plateNumber: dto.plateNumber },
@@ -31,6 +50,10 @@ export class VehiclesService {
       );
     }
 
+    if (dto.assignedDriverId) {
+      await this.assertDriverUnassigned(dto.assignedDriverId);
+    }
+
     const registrationNumber = `REG-${dto.vehicleType}-${Date.now()}`;
     const vehicle = this.vehicleRepo.create({
       ...dto,
@@ -121,6 +144,10 @@ export class VehiclesService {
       }
     }
 
+    if (dto.assignedDriverId && dto.assignedDriverId !== vehicle.assignedDriverId) {
+      await this.assertDriverUnassigned(dto.assignedDriverId, id);
+    }
+
     const prev = {
       assignedDriverId: vehicle.assignedDriverId,
       assignedDriverName: vehicle.assignedDriverName,
diff --git a/apps/edr-freight-api/src/modules/warehouses/dto/filter-inventory.dto.ts b/apps/edr-freight-api/src/modules/warehouses/dto/filter-inventory.dto.ts
index 49fb22fde..f86261d3c 100644
--- a/apps/edr-freight-api/src/modules/warehouses/dto/filter-inventory.dto.ts
+++ b/apps/edr-freight-api/src/modules/warehouses/dto/filter-inventory.dto.ts
@@ -1,5 +1,6 @@
 import { ApiPropertyOptional } from '@nestjs/swagger';
-import { IsEnum, IsOptional, IsString, IsUUID } from 'class-validator';
+import { Transform } from 'class-transformer';
+import { IsBoolean, IsEnum, IsInt, IsOptional, IsString, IsUUID, Min } from 'class-validator';
 
 import {
   WAREHOUSE_INVENTORY_STATUSES,
@@ -71,4 +72,27 @@ export class FilterWarehouseInventoryDto {
   @IsOptional()
   @IsString()
   dateTo?: string;
+
+  // ── KPI drill-down filters ──────────────────────────────────────────────
+  // Each mirrors one opsStats() counter so a dashboard card's count always
+  // equals the length of the list it opens.
+
+  @ApiPropertyOptional({ type: Boolean, description: 'Only items received (created) today' })
+  @IsOptional()
+  @Transform(({ value }) => (value == null ? undefined : value === true || value === 'true' || value === '1'))
+  @IsBoolean()
+  receivedToday?: boolean;
+
+  @ApiPropertyOptional({ type: Boolean, description: 'Only RECEIVED items with no inspection yet' })
+  @IsOptional()
+  @Transform(({ value }) => (value == null ? undefined : value === true || value === 'true' || value === '1'))
+  @IsBoolean()
+  pendingInspection?: boolean;
+
+  @ApiPropertyOptional({ type: Number, minimum: 1, description: 'Only in-warehouse items older than N days' })
+  @IsOptional()
+  @Transform(({ value }) => (value === '' || value == null ? undefined : Number(value)))
+  @IsInt()
+  @Min(1)
+  agingOverDays?: number;
 }
diff --git a/apps/edr-freight-api/src/modules/warehouses/entities/booking-handover.entity.ts b/apps/edr-freight-api/src/modules/warehouses/entities/booking-handover.entity.ts
index a0a7ad70f..c90fb5a16 100644
--- a/apps/edr-freight-api/src/modules/warehouses/entities/booking-handover.entity.ts
+++ b/apps/edr-freight-api/src/modules/warehouses/entities/booking-handover.entity.ts
@@ -8,8 +8,9 @@ export type HandoverMileType = (typeof HANDOVER_MILE_TYPES)[number];
  * One import handover. A booking has a single handover when one truck takes the
  * whole booking (`truckAssignmentId` null = per-booking), or one per truck when
  * multiple trucks are used. Self-haul handovers are generated on truck arrival
- * and signed before the truck leaves; EDR last-mile handovers are generated at
- * delivery (after exit).
+ * and signed before the truck leaves; EDR last-mile handovers are generated
+ * when the EDR truck exits the warehouse (with its exit paper) and signed by
+ * the customer in the portal on delivery — one signature per truck.
  */
 @Entity({ schema: 'freight', name: 'booking_handovers' })
 @Index(['bookingId'])
@@ -21,6 +22,10 @@ export class BookingHandover extends BaseEntity {
   @Column({ name: 'truck_assignment_id', type: 'uuid', nullable: true })
   truckAssignmentId?: string | null;
 
+  /** EDR last-mile vehicle assignment this handover belongs to; null = per-booking. */
+  @Column({ name: 'edr_assignment_id', type: 'uuid', nullable: true })
+  edrAssignmentId?: string | null;
+
   /** Denormalised plate for display / EDR trucks (which aren't customer trucks). */
   @Column({ name: 'truck_plate', type: 'varchar', length: 32, nullable: true })
   truckPlate?: string | null;
diff --git a/apps/edr-freight-api/src/modules/warehouses/exit-inspection-blocks.spec.ts b/apps/edr-freight-api/src/modules/warehouses/exit-inspection-blocks.spec.ts
new file mode 100644
index 000000000..f89d987ce
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/warehouses/exit-inspection-blocks.spec.ts
@@ -0,0 +1,66 @@
+import { WarehouseInventoryService } from './warehouse-inventory.service';
+
+// Exercises the per-truck [Exit Inspection] block helpers directly (no DI).
+const svc = Object.create(WarehouseInventoryService.prototype) as any;
+
+const arrivalA =
+  '[Exit Inspection]\nTruck Plate: 3-15288/56858\nDriver: Abebe Lemeno\nGate In Time: 2026-07-21T08:00:00.000Z\nTare Weight: 12 t';
+const arrivalB =
+  '[Exit Inspection]\nTruck Plate: 3-85957/48562\nDriver: Suleman Tamrat\nGate In Time: 2026-07-21T09:00:00.000Z\nWeighing: SKIPPED';
+
+describe('per-truck exit inspection blocks', () => {
+  it('keeps truck A intact when truck B arrives', () => {
+    const afterA = svc.replaceExitInspectionNote('Receive note', arrivalA, '3-15288/56858');
+    const afterB = svc.replaceExitInspectionNote(afterA, arrivalB, '3-85957/48562');
+    expect(afterB).toContain('Abebe Lemeno');
+    expect(afterB).toContain('Suleman Tamrat');
+    expect(afterB.match(/\[Exit Inspection\]/g)).toHaveLength(2);
+    expect(afterB.startsWith('Receive note')).toBe(true);
+  });
+
+  it("exit for truck A updates only A's block and preserves arrival data", () => {
+    const notes = svc.replaceExitInspectionNote(
+      svc.replaceExitInspectionNote(null, arrivalA, '3-15288/56858'),
+      arrivalB,
+      '3-85957/48562',
+    );
+    const dto = svc.preserveTruckArrivalForExit(
+      { truckPlateNumber: '3-15288/56858', grossWeight: 40, gateOutTime: '2026-07-21T12:00:00.000Z' },
+      notes,
+    );
+    expect(dto.driverName).toBe('Abebe Lemeno');
+    expect(dto.tareWeight).toBe(12);
+    expect(dto.weighingSkipped).toBeUndefined();
+    const exitNote = svc.buildExitInspectionNote(dto);
+    const replaced = svc.replaceExitInspectionNote(notes, exitNote, dto.truckPlateNumber);
+    expect(replaced).toContain('Gross Weight: 40 t');
+    expect(replaced).toContain('Net Weight: 28 t');
+    expect(replaced).toContain('Suleman Tamrat'); // B untouched
+    expect(replaced.match(/\[Exit Inspection\]/g)).toHaveLength(2);
+  });
+
+  it('skipped weighing records the container-derived net in the note', () => {
+    const dto = {
+      truckPlateNumber: '3-85957/48562',
+      driverName: 'Suleman Tamrat',
+      weighingSkipped: true,
+      netWeight: 27.5,
+      gateInTime: '2026-07-21T09:00:00.000Z',
+      gateOutTime: '2026-07-21T13:00:00.000Z',
+    };
+    const note = svc.buildExitInspectionNote(dto);
+    expect(note).toContain('Weighing: SKIPPED');
+    expect(note).toContain('Net Weight: 27.5 t');
+  });
+
+  it('matches a legacy comma-joined plate list and keeps foreign notes', () => {
+    const legacy =
+      'Receive note\n\n[Exit Inspection]\nTruck Plate: 3-15288/56858, 3-85957/48562\nDriver: Abebe Lemeno\nTare Weight: 12 t\nCUSTOMER_DELIVERY_APPROVAL:{"ok":true}';
+    const block = svc.extractExitInspectionForPlate(legacy, '3-15288/56858');
+    expect(block).toContain('Abebe Lemeno');
+    const replaced = svc.replaceExitInspectionNote(legacy, arrivalA, '3-15288/56858');
+    expect(replaced.match(/\[Exit Inspection\]/g)).toHaveLength(1);
+    expect(replaced).toContain('CUSTOMER_DELIVERY_APPROVAL:{"ok":true}');
+    expect(replaced).toContain('Receive note');
+  });
+});
diff --git a/apps/edr-freight-api/src/modules/warehouses/handover.service.ts b/apps/edr-freight-api/src/modules/warehouses/handover.service.ts
index d50b27150..81f83a57a 100644
--- a/apps/edr-freight-api/src/modules/warehouses/handover.service.ts
+++ b/apps/edr-freight-api/src/modules/warehouses/handover.service.ts
@@ -1,9 +1,9 @@
-import { Injectable, Logger } from '@nestjs/common';
+import { Injectable, Logger, NotFoundException } from '@nestjs/common';
 import { Cron, CronExpression } from '@nestjs/schedule';
 import { NotificationAudience, NotificationType } from '@edr/types';
-import { DataSource, EntityManager, IsNull } from 'typeorm';
+import { DataSource, EntityManager, IsNull, Repository } from 'typeorm';
 
-import { BookingHandover } from './entities/booking-handover.entity';
+import { BookingHandover, HandoverMileType } from './entities/booking-handover.entity';
 import { NotificationInboxService } from '../notification-inbox/notification-inbox.service';
 import { NotificationsService } from '../notifications/notifications.service';
 import { sendCompanyChannels } from '../notifications/notify-company.util';
@@ -12,7 +12,10 @@ import { sendCompanyChannels } from '../notifications/notify-company.util';
  * Import handover records. A booking has one handover per truck (single truck ⇒
  * one, effectively per-booking; multiple trucks ⇒ one each). Timing by mile type:
  *  - SELF_HAUL: generated when the customer truck arrives, signed before it leaves.
- *  - EDR_LAST_MILE: generated at delivery (after exit).
+ *  - EDR_LAST_MILE: generated when the EDR truck exits the warehouse (with its
+ *    exit paper), signed by the customer in the portal per truck; once every
+ *    handover is signed the delivery auto-completes (inventory / cargo /
+ *    booking → delivered).
  */
 @Injectable()
 export class HandoverService {
@@ -25,14 +28,22 @@ export class HandoverService {
   ) {}
 
   /** Tell the customer a handover is ready and needs their signature. */
-  private async notifySignNeeded(bookingId: string, reference: string): Promise<void> {
+  private async notifySignNeeded(
+    bookingId: string,
+    reference: string,
+    opts: { mileType?: HandoverMileType; truckPlate?: string | null } = {},
+  ): Promise<void> {
     try {
       const [b]: Array<{ companyId: string | null; reference: string }> = await this.dataSource.query(
         `SELECT company_id AS "companyId", reference FROM freight.bookings WHERE id = $1 AND deleted_at IS NULL`,
         [bookingId],
       );
       if (!b?.companyId) return;
-      const body = `Your import handover ${reference} for booking ${b.reference} is ready. Please review and sign it from the portal before the truck leaves.`;
+      const truck = opts.truckPlate ? ` (truck ${opts.truckPlate})` : '';
+      const body =
+        opts.mileType === 'EDR_LAST_MILE'
+          ? `Your goods for booking ${b.reference} are on their way${truck}. Please review and sign handover ${reference} from the portal to confirm receipt of the delivery.`
+          : `Your import handover ${reference} for booking ${b.reference} is ready. Please review and sign it from the portal before the truck leaves.`;
       await this.inbox.notify({
         recipients: { companyId: b.companyId },
         audience: NotificationAudience.PORTAL,
@@ -117,31 +128,98 @@ export class HandoverService {
     return saved;
   }
 
-  /**
-   * EDR last-mile: generate a handover at delivery (after exit). One per EDR
-   * truck (by plate) or per booking. Idempotent by (booking, plate).
-   */
-  async ensureAtDelivery(
+  /** Find an existing EDR handover by assignment, else by plate, else booking-level. */
+  private async findEdrHandover(
+    repo: Repository<BookingHandover>,
     bookingId: string,
-    opts: { truckPlate?: string | null; truckAssignmentId?: string | null },
+    opts: { truckPlate?: string | null; edrAssignmentId?: string | null },
+  ): Promise<BookingHandover | null> {
+    if (opts.edrAssignmentId) {
+      const byAssignment = await repo.findOne({
+        where: { bookingId, edrAssignmentId: opts.edrAssignmentId },
+      });
+      if (byAssignment) return byAssignment;
+    }
+    if (opts.truckPlate) {
+      return repo.findOne({
+        where: { bookingId, mileType: 'EDR_LAST_MILE', truckPlate: opts.truckPlate },
+      });
+    }
+    return repo.findOne({
+      where: {
+        bookingId,
+        mileType: 'EDR_LAST_MILE',
+        truckPlate: IsNull(),
+        edrAssignmentId: IsNull(),
+      },
+    });
+  }
+
+  /**
+   * EDR last-mile: generate the handover when the EDR truck exits the warehouse
+   * (alongside its exit paper) and ask the customer to sign it from the portal.
+   * One per truck (multiple trucks ⇒ one each) or booking-level when the truck
+   * cannot be resolved. Idempotent by (booking, assignment) / (booking, plate).
+   */
+  async ensureForDepartedEdrTruck(
+    bookingId: string,
+    opts: { truckPlate?: string | null; edrAssignmentId?: string | null },
     manager?: EntityManager,
   ): Promise<BookingHandover> {
     const m = manager ?? this.dataSource.manager;
     const repo = m.getRepository(BookingHandover);
-    const existing = await repo.findOne({
-      where: {
-        bookingId,
-        truckPlate: opts.truckPlate ?? IsNull(),
-        truckAssignmentId: opts.truckAssignmentId ?? IsNull(),
-      },
-    });
+    const existing = await this.findEdrHandover(repo, bookingId, opts);
     if (existing) return existing;
 
     const reference = await this.generateReference(bookingId, m);
-    return repo.save(
+    const saved = await repo.save(
       repo.create({
         bookingId,
-        truckAssignmentId: opts.truckAssignmentId ?? null,
+        edrAssignmentId: opts.edrAssignmentId ?? null,
+        truckPlate: opts.truckPlate ?? null,
+        mileType: 'EDR_LAST_MILE',
+        reference,
+        generatedAt: new Date(),
+      }),
+    );
+    this.logger.log(
+      `EDR handover ${reference} generated on truck exit for booking ${bookingId}` +
+        (opts.truckPlate ? ` (truck ${opts.truckPlate})` : ''),
+    );
+    void this.notifySignNeeded(bookingId, reference, {
+      mileType: 'EDR_LAST_MILE',
+      truckPlate: opts.truckPlate,
+    });
+    return saved;
+  }
+
+  /**
+   * EDR last-mile: ensure a handover exists at delivery and stamp delivered_at.
+   * Normally the handover was already generated on truck exit — this only fills
+   * the delivery timestamp; a handover is created here only for legacy flows
+   * where the exit was recorded before this feature existed.
+   */
+  async ensureAtDelivery(
+    bookingId: string,
+    opts: { truckPlate?: string | null; edrAssignmentId?: string | null },
+    manager?: EntityManager,
+  ): Promise<BookingHandover> {
+    const m = manager ?? this.dataSource.manager;
+    const repo = m.getRepository(BookingHandover);
+    const existing = await this.findEdrHandover(repo, bookingId, opts);
+    if (existing) {
+      if (!existing.deliveredAt) {
+        existing.deliveredAt = new Date();
+        await repo.save(existing);
+      }
+      return existing;
+    }
+
+    const reference = await this.generateReference(bookingId, m);
+    const saved = await repo.save(
+      repo.create({
+        bookingId,
+        edrAssignmentId: opts.edrAssignmentId ?? null,
         truckPlate: opts.truckPlate ?? null,
         mileType: 'EDR_LAST_MILE',
         reference,
@@ -149,6 +227,25 @@ export class HandoverService {
         deliveredAt: new Date(),
       }),
     );
+    void this.notifySignNeeded(bookingId, reference, {
+      mileType: 'EDR_LAST_MILE',
+      truckPlate: opts.truckPlate,
+    });
+    return saved;
+  }
+
+  /** Re-send the sign notification for every unsigned handover on the booking. */
+  async notifyUnsignedForBooking(bookingId: string): Promise<void> {
+    const unsigned = await this.dataSource.getRepository(BookingHandover).find({
+      where: { bookingId, signedAt: IsNull() },
+      order: { generatedAt: 'ASC' },
+    });
+    for (const h of unsigned) {
+      await this.notifySignNeeded(bookingId, h.reference, {
+        mileType: h.mileType,
+        truckPlate: h.truckPlate,
+      });
+    }
   }
 
   /**
@@ -182,6 +279,27 @@ export class HandoverService {
     }
   }
 
+  /**
+   * Sign one handover (EDR last-mile: the customer signs per truck). Returns the
+   * fresh handover; idempotent — an already-signed handover is returned as-is.
+   */
+  async sign(
+    handoverId: string,
+    userId?: string | null,
+    signerName?: string | null,
+  ): Promise<BookingHandover> {
+    const repo = this.dataSource.getRepository(BookingHandover);
+    const handover = await repo.findOne({ where: { id: handoverId } });
+    if (!handover) {
+      throw new NotFoundException(`Handover ${handoverId} not found`);
+    }
+    if (handover.signedAt) return handover;
+    handover.signedAt = new Date();
+    handover.signedByUserId = userId ?? null;
+    handover.signerName = signerName?.trim() || null;
+    return repo.save(handover);
+  }
+
   /** Sign all unsigned handovers on a booking (self-haul: before the truck leaves). */
   async signForBooking(
     bookingId: string,
diff --git a/apps/edr-freight-api/src/modules/warehouses/receive-export-paid.spec.ts b/apps/edr-freight-api/src/modules/warehouses/receive-export-paid.spec.ts
new file mode 100644
index 000000000..38268af11
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/warehouses/receive-export-paid.spec.ts
@@ -0,0 +1,55 @@
+import { BadRequestException } from '@nestjs/common';
+
+import { WarehouseInventoryService } from './warehouse-inventory.service';
+
+/**
+ * Export cargo is received into the warehouse to wait for its train, and only a
+ * paid booking may be received — otherwise storage and a GRN would start against
+ * cargo the customer has not settled. Import is never blocked: it arrives OFF a
+ * train and its receive is the unload.
+ *
+ * The guard touches only the DataSource, so the instance is built off the
+ * prototype rather than stubbing all 20-odd collaborators.
+ */
+type Guard = (
+  bookingId: string | null | undefined,
+  direction: string | null,
+) => Promise<void>;
+
+function makeGuard(paymentStatus: string | null) {
+  const query = jest.fn().mockResolvedValue([{ paymentStatus }]);
+  const service = Object.create(WarehouseInventoryService.prototype) as Record<string, unknown>;
+  service.dataSource = { query };
+  const guard = (
+    service as unknown as { assertExportBookingPaid: Guard }
+  ).assertExportBookingPaid.bind(service);
+  return { guard, query };
+}
+
+describe('receive() — export paid gate', () => {
+  it('rejects an unpaid export booking', async () => {
+    const { guard } = makeGuard('PENDING');
+
+    await expect(guard('b-1', 'EXPORT')).rejects.toBeInstanceOf(BadRequestException);
+  });
+
+  it('allows a paid export booking', async () => {
+    const { guard } = makeGuard('PAID');
+
+    await expect(guard('b-1', 'EXPORT')).resolves.toBeUndefined();
+  });
+
+  it('never blocks import, paid or not', async () => {
+    const { guard, query } = makeGuard('PENDING');
+
+    await expect(guard('b-1', 'IMPORT')).resolves.toBeUndefined();
+    expect(query).not.toHaveBeenCalled();
+  });
+
+  it('ignores a receive with no booking attached', async () => {
+    const { guard, query } = makeGuard('PENDING');
+
+    await expect(guard(null, 'EXPORT')).resolves.toBeUndefined();
+    expect(query).not.toHaveBeenCalled();
+  });
+});
diff --git a/apps/edr-freight-api/src/modules/warehouses/warehouse-inventory.controller.ts b/apps/edr-freight-api/src/modules/warehouses/warehouse-inventory.controller.ts
index 2373cb6d8..0174ef3e9 100644
--- a/apps/edr-freight-api/src/modules/warehouses/warehouse-inventory.controller.ts
+++ b/apps/edr-freight-api/src/modules/warehouses/warehouse-inventory.controller.ts
@@ -486,6 +486,21 @@ export class WarehouseInventoryController {
     return this.handoverService.list(bookingId);
   }
 
+  @Post('handovers/:handoverId/sign')
+  @ApiOperation({ summary: 'Customer signs one handover (EDR last-mile: one signature per truck)' })
+  signHandover(
+    @Param('handoverId', ParseUUIDPipe) handoverId: string,
+    @Body() dto: ApproveDeliveryDto,
+    @Request() req: { user?: { id?: string; sub?: string } },
+    @CurrentUser() user: TCurrentUser,
+  ) {
+    return this.inventoryService.signHandover(
+      handoverId,
+      user?.id ?? req.user?.id ?? req.user?.sub,
+      dto.signerName,
+    );
+  }
+
   @Post('bookings/:bookingId/request-handover-signature')
   @ApiOperation({ summary: 'Ask the customer to sign the handover (creates one if none, then notifies)' })
   requestHandoverSignature(@Param('bookingId', ParseUUIDPipe) bookingId: string) {
@@ -513,9 +528,16 @@ export class WarehouseInventoryController {
   }
 
   @Get('bookings/:bookingId/handover-document')
-  @ApiOperation({ summary: 'View import goods handover document PDF (resolved by booking)' })
-  async bookingHandoverDocument(@Param('bookingId', ParseUUIDPipe) bookingId: string, @Res() res: Response) {
-    const { filename, buffer } = await this.inventoryService.handoverDocumentForBooking(bookingId);
+  @ApiOperation({ summary: 'View import goods handover document PDF (resolved by booking; ?handoverId= for the per-truck variant)' })
+  async bookingHandoverDocument(
+    @Param('bookingId', ParseUUIDPipe) bookingId: string,
+    @Res() res: Response,
+    @Query('handoverId') handoverId?: string,
+  ) {
+    const { filename, buffer } = await this.inventoryService.handoverDocumentForBooking(
+      bookingId,
+      handoverId || undefined,
+    );
     res.setHeader('Content-Type', 'application/pdf');
     res.setHeader('Content-Disposition', `inline; filename="${filename}"`);
     res.setHeader('Content-Length', buffer.length);
@@ -534,6 +556,12 @@ export class WarehouseInventoryController {
     return this.inventoryService.bookingContainerWeights(bookingId);
   }
 
+  @Get('bookings/:bookingId/location')
+  @ApiOperation({ summary: "Warehouse location of a booking's inventory (customer portal)" })
+  bookingLocation(@Param('bookingId', ParseUUIDPipe) bookingId: string) {
+    return this.inventoryService.bookingLocation(bookingId);
+  }
+
   @Post(':id/deliver')
   @BookingStaff(FREIGHT_PERMS.warehouseInventory.deliver)
   @ApiOperation({ summary: 'Deliver import goods to the customer + capture proof of delivery' })
diff --git a/apps/edr-freight-api/src/modules/warehouses/warehouse-inventory.service.ts b/apps/edr-freight-api/src/modules/warehouses/warehouse-inventory.service.ts
index d05007d8c..b5df563d9 100644
--- a/apps/edr-freight-api/src/modules/warehouses/warehouse-inventory.service.ts
+++ b/apps/edr-freight-api/src/modules/warehouses/warehouse-inventory.service.ts
@@ -1,6 +1,19 @@
 import { BadRequestException, Injectable, Logger, NotFoundException } from '@nestjs/common';
+import { EventEmitter2 } from '@nestjs/event-emitter';
 import { Cron, CronExpression } from '@nestjs/schedule';
-import { Between, DataSource, EntityManager, FindManyOptions, ILike, LessThanOrEqual, MoreThanOrEqual } from 'typeorm';
+import {
+  Between,
+  DataSource,
+  EntityManager,
+  FindManyOptions,
+  FindOptionsWhere,
+  ILike,
+  In,
+  IsNull,
+  LessThanOrEqual,
+  MoreThanOrEqual,
+  Raw,
+} from 'typeorm';
 
 import { deriveTradeDirection } from '../../common/derive-trade-direction.util';
 import { generateGrnNumber } from '../../common/grn.util';
@@ -13,6 +26,7 @@ import { CargoType } from '../rule-engine/entities/cargo-type.entity';
 import { InterchangeDocumentsService } from '../interchange-documents/interchange-documents.service';
 import type { InterchangeDocument } from '../interchange-documents/entities/interchange-document.entity';
 import { LastMileService } from '../last-mile/last-mile.service';
+import { UpdateLastMileDto } from '../last-mile/dto/update-last-mile.dto';
 import { NotificationsService } from '../notifications/notifications.service';
 import { sendCompanyChannels } from '../notifications/notify-company.util';
 import {
@@ -68,6 +82,7 @@ const isLoadableWagonStatus = (status: string | null | undefined) =>
 
 const CUSTOMER_DELIVERY_APPROVAL_PREFIX = 'CUSTOMER_DELIVERY_APPROVAL:';
 const HANDOVER_DOCUMENT_MARKER = '[Handover Document]';
+const EXIT_INSPECTION_MARKER = '[Exit Inspection]';
 
 export interface InventoryInquiryResult {
   id: string;
@@ -396,6 +411,7 @@ export class WarehouseInventoryService {
     private readonly signatures: SignaturesService,
     private readonly handover: HandoverService,
     private readonly inbox: NotificationInboxService,
+    private readonly events: EventEmitter2,
   ) {}
 
   /**
@@ -417,12 +433,16 @@ export class WarehouseInventoryService {
    *
    * Covers both haulage paths because the gate does: a customer's own truck and
    * an EDR last-mile truck arrive at the same barrier and need the same paper.
-   * "On site" means arrived and not yet departed.
+   * Includes trucks assigned but not yet arrived, flagged INBOUND, so staff see
+   * what is coming as well as what is here — an assigned truck only stamps
+   * `arrived_at` when it reaches the warehouse. A truck drops off the list once
+   * it departs.
    */
   async trucksOnSite(): Promise<
     Array<{
       source: 'CUSTOMER' | 'EDR';
       assignmentId: string;
+      status: 'INBOUND' | 'ON_SITE';
       plateNumber: string | null;
       driverName: string | null;
       truckType: string | null;
@@ -436,6 +456,7 @@ export class WarehouseInventoryService {
     return this.dataSource.query(
       `SELECT 'CUSTOMER'      AS "source",
               a.id            AS "assignmentId",
+              CASE WHEN a.arrived_at IS NULL THEN 'INBOUND' ELSE 'ON_SITE' END AS "status",
               a.plate_number  AS "plateNumber",
               a.driver_name   AS "driverName",
               a.truck_type    AS "truckType",
@@ -450,13 +471,13 @@ export class WarehouseInventoryService {
          JOIN freight.bookings b ON b.id = a.booking_id AND b.deleted_at IS NULL
          LEFT JOIN freight.companies company ON company.id = b.company_id
         WHERE a.deleted_at IS NULL
-          AND a.arrived_at IS NOT NULL
           AND a.departed_at IS NULL
 
         UNION ALL
 
        SELECT 'EDR'           AS "source",
               va.id           AS "assignmentId",
+              CASE WHEN va.arrived_at IS NULL THEN 'INBOUND' ELSE 'ON_SITE' END AS "status",
               COALESCE(v.plate_number, v.power_plate_no) AS "plateNumber",
               NULLIF(TRIM(CONCAT_WS(' ', d.first_name, d.last_name)), '') AS "driverName",
               v.vehicle_type  AS "truckType",
@@ -474,10 +495,11 @@ export class WarehouseInventoryService {
          LEFT JOIN freight.drivers d ON d.id = v.assigned_driver_id
          LEFT JOIN freight.companies company ON company.id = b.company_id
         WHERE va.deleted_at IS NULL
-          AND va.arrived_at IS NOT NULL
           AND va.departed_at IS NULL
 
-        ORDER BY "arrivedAt" ASC`,
+        -- On-site trucks first, each group oldest-arrival first; inbound trucks
+        -- (null arrival) sort to the end.
+        ORDER BY "arrivedAt" ASC NULLS LAST`,
     );
   }
 
@@ -502,12 +524,20 @@ export class WarehouseInventoryService {
            WHERE deleted_at IS NULL AND created_at::date = CURRENT_DATE - 1) AS "receivedYesterday",
          (SELECT count(*)::int FROM freight.warehouse_inventory
            WHERE deleted_at IS NULL AND status = 'RECEIVED' AND inspection_status IS NULL) AS "pendingInspection",
-         (SELECT count(*)::int FROM freight.customer_truck_assignments
-           WHERE deleted_at IS NULL AND arrived_at IS NOT NULL AND departed_at IS NULL) AS "trucksOnSite",
+         -- Both haulage paths, mirroring the ON_SITE rows of trucksOnSite()
+         ((SELECT count(*)::int FROM freight.customer_truck_assignments a
+             JOIN freight.bookings b ON b.id = a.booking_id AND b.deleted_at IS NULL
+            WHERE a.deleted_at IS NULL AND a.arrived_at IS NOT NULL AND a.departed_at IS NULL)
+          +
+          (SELECT count(*)::int FROM freight.last_mile_vehicle_assignments va
+             JOIN freight.last_mile lm ON lm.id = va.last_mile_id AND lm.deleted_at IS NULL
+             JOIN freight.bookings b ON b.id = lm.booking_id AND b.deleted_at IS NULL
+            WHERE va.deleted_at IS NULL AND va.arrived_at IS NOT NULL AND va.departed_at IS NULL)) AS "trucksOnSite",
          (SELECT count(*)::int FROM freight.warehouse_inventory
            WHERE deleted_at IS NULL
-             AND status IN ('RECEIVED', 'STORED', 'READY_FOR_LOADING', 'READY_FOR_PICKUP', 'RESERVED')
+             AND status = ANY($1)
              AND created_at < now() - interval '7 days') AS "itemsAging"`,
+      [this.IN_WAREHOUSE_STATUSES],
     );
     return {
       receivedToday: row?.receivedToday ?? 0,
@@ -519,7 +549,7 @@ export class WarehouseInventoryService {
   }
 
   /** In-warehouse statuses used by the dwell / aging metrics. */
-  private readonly IN_WAREHOUSE_STATUSES = [
+  private readonly IN_WAREHOUSE_STATUSES: WarehouseInventoryStatus[] = [
     'RECEIVED',
     'UNLOADED',
     'STORED',
@@ -947,7 +977,7 @@ export class WarehouseInventoryService {
             ? LessThanOrEqual(new Date(filter.dateTo))
             : undefined;
 
-    const base = {
+    const base: FindOptionsWhere<WarehouseInventory> = {
       ...(filter.warehouseId ? { warehouseId: filter.warehouseId } : {}),
       ...(filter.yardId ? { yardId: filter.yardId } : {}),
       ...(filter.zoneId ? { zoneId: filter.zoneId } : {}),
@@ -961,6 +991,24 @@ export class WarehouseInventoryService {
       ...(filter.direction ? { booking: { tradeDirection: filter.direction } } : {}),
     };
 
+    // KPI drill-down filters — predicates mirror opsStats() exactly so the
+    // dashboard card's count equals the length of the list it opens.
+    if (filter.receivedToday) {
+      base.createdAt = Raw((alias) => `${alias}::date = CURRENT_DATE`);
+    }
+    if (filter.pendingInspection) {
+      base.status = 'RECEIVED';
+      base.inspectionStatus = IsNull();
+    }
+    if (filter.agingOverDays) {
+      if (!filter.status && !filter.pendingInspection) {
+        base.status = In(this.IN_WAREHOUSE_STATUSES);
+      }
+      base.createdAt = Raw((alias) => `${alias} < now() - make_interval(days => :days)`, {
+        days: filter.agingOverDays,
+      });
+    }
+
     const search = filter.search?.trim();
     const where: FindManyOptions<WarehouseInventory>['where'] = search
       ? [
@@ -982,6 +1030,28 @@ export class WarehouseInventoryService {
     return this.findAll({ ...filter, status: 'READY_FOR_LOADING' });
   }
 
+  /**
+   * Warehouse location rows for one booking, trimmed for the customer portal:
+   * no staff guard on the route, so only location fields leave the API —
+   * never notes, fees or inspection internals.
+   */
+  async bookingLocation(bookingId: string) {
+    const items = await this.inventoryRepository.findAll({
+      where: { bookingId },
+      relations: { warehouse: true, yard: true, zone: true },
+      order: { createdAt: 'DESC' },
+    });
+    return items.map((i) => ({
+      id: i.id,
+      bookingId: i.bookingId,
+      status: i.status,
+      arrivedAt: i.arrivedAt ?? null,
+      warehouse: i.warehouse ? { id: i.warehouse.id, name: i.warehouse.name, code: i.warehouse.code } : null,
+      yard: i.yard ? { id: i.yard.id, name: i.yard.name, code: i.yard.code } : null,
+      zone: i.zone ? { id: i.zone.id, name: i.zone.name, code: i.zone.code } : null,
+    }));
+  }
+
   async findById(id: string): Promise<WarehouseInventory> {
     const item = await this.inventoryRepository.findById(id, {
       relations: { warehouse: { facility: true }, yard: true, zone: true },
@@ -2550,6 +2620,7 @@ export class WarehouseInventoryService {
 
   async receive(dto: ReceiveWarehouseInventoryDto): Promise<WarehouseInventory> {
     const bookingDirection = dto.bookingId ? await this.getBookingDirection(dto.bookingId) : null;
+    await this.assertExportBookingPaid(dto.bookingId, bookingDirection);
 
     const id = await this.dataSource.transaction(async (manager) => {
       const { warehouse, yard, zone } = await this.validateLocation(manager, dto);
@@ -2965,12 +3036,29 @@ export class WarehouseInventoryService {
     const releaseDate = isTruckLeaving
       ? dto.releaseDate ? new Date(dto.releaseDate) : new Date()
       : item.releaseDate ?? null;
-    const reference = isTruckLeaving
-      ? item.releaseOrderReference || dto.reference?.trim() || (await this.generateReleaseReference(item))
-      : dto.reference?.trim() || (await this.generateReleaseReference(item));
-    const exitInspectionDto = isTruckLeaving
-      ? this.preserveTruckArrivalForExit(dto, item.notes)
-      : dto;
+    // One reference per item — the first truck's arrival mints it, later trucks
+    // (arrival or exit) reuse it so all exit papers share the release order.
+    const reference =
+      item.releaseOrderReference || dto.reference?.trim() || (await this.generateReleaseReference(item));
+    const exitInspectionDto = {
+      ...(isTruckLeaving ? this.preserveTruckArrivalForExit(dto, item.notes) : dto),
+    };
+    // Weighbridge skipped on exit: the recorded net still comes from what the
+    // truck is holding — the summed cargo weight of its selected containers.
+    if (isTruckLeaving && exitInspectionDto.weighingSkipped && item.bookingId) {
+      const selected = (exitInspectionDto.containerNumber ?? '')
+        .split(/[,;\n]+/)
+        .map((n) => n.trim())
+        .filter(Boolean);
+      if (selected.length) {
+        const weights = await this.bookingContainerWeights(item.bookingId);
+        const byNumber = new Map(weights.map((w) => [w.containerNumber.toUpperCase(), w.weightTons]));
+        const heldTons = Number(
+          selected.reduce((sum, n) => sum + (byNumber.get(n.toUpperCase()) ?? 0), 0).toFixed(3),
+        );
+        if (heldTons > 0) exitInspectionDto.netWeight = heldTons;
+      }
+    }
     const exitInspectionNote = this.buildExitInspectionNote(exitInspectionDto);
 
     // The load actually leaving on this truck, in TONNES (the weighing UI is in
@@ -2983,12 +3071,46 @@ export class WarehouseInventoryService {
         ? Math.round((grossTons - tareTons) * 1000) / 1000
         : (exitInspectionDto.netWeight ?? null);
 
+    // The weight to record on the inventory when this truck leaves: prefer the
+    // item's own container cargo weight (a truck may carry other items too);
+    // fall back to the truck's recorded net. Fills an empty weight only.
+    let recordedItemTons: number | null = null;
+    if (isTruckLeaving && netTons != null) {
+      recordedItemTons = netTons;
+      if (item.containerId && item.bookingId) {
+        const [cont]: Array<{ containerNumber: string | null }> = await this.dataSource.query(
+          `SELECT container_number AS "containerNumber" FROM freight.containers WHERE id = $1`,
+          [item.containerId],
+        );
+        const ownNumber = cont?.containerNumber?.trim().toUpperCase();
+        if (ownNumber) {
+          const weights = await this.bookingContainerWeights(item.bookingId);
+          const own = weights.find((w) => w.containerNumber.toUpperCase() === ownNumber);
+          if (own && own.weightTons > 0) recordedItemTons = own.weightTons;
+        }
+      }
+    }
+
     await this.dataSource.transaction(async (manager) => {
       await manager.getRepository(WarehouseInventory).update(id, {
         releaseDate,
         releaseOrderReference: reference,
-        notes: this.replaceExitInspectionNote(item.notes, exitInspectionNote),
+        notes: this.replaceExitInspectionNote(
+          item.notes,
+          exitInspectionNote,
+          exitInspectionDto.truckPlateNumber,
+        ),
       });
+      // Even an unweighed truck records the inventory weight it is holding —
+      // without this the handover/exit papers print "0 t" for skipped weighings.
+      if (recordedItemTons != null) {
+        await manager.query(
+          `UPDATE freight.warehouse_inventory
+              SET weight = $2, updated_at = NOW()
+            WHERE id = $1 AND COALESCE(weight, 0) = 0`,
+          [id, recordedItemTons],
+        );
+      }
       if (!isTruckLeaving && item.bookingId) {
         // Per-truck arrival: mark the customer truck carrying THIS item's
         // container as arrived (matched via the physical container number).
@@ -3051,7 +3173,7 @@ export class WarehouseInventoryService {
         // EDR last-mile: this truck is leaving — record its exit and the load it
         // actually took. net_weight_tons drives the bulk drawdown (booking VGM
         // minus everything already hauled away).
-        await manager.query(
+        const [edrDeparted] = (await manager.query(
           `UPDATE freight.last_mile_vehicle_assignments va
               SET departed_at = COALESCE($3::timestamptz, NOW()),
                   arrived_at = COALESCE(va.arrived_at, NOW()),
@@ -3065,7 +3187,8 @@ export class WarehouseInventoryService {
               AND v.id = va.vehicle_id
               AND (UPPER(v.power_plate_no) = UPPER($2) OR UPPER(v.plate_number) = UPPER($2))
               AND va.departed_at IS NULL
-              AND va.deleted_at IS NULL`,
+              AND va.deleted_at IS NULL
+            RETURNING va.id`,
           [
             item.bookingId,
             dto.truckPlateNumber.trim(),
@@ -3073,7 +3196,31 @@ export class WarehouseInventoryService {
             grossTons,
             netTons,
           ],
-        );
+        )) as [Array<{ id: string }>, unknown];
+        // EDR last-mile: the handover is generated the moment the truck exits
+        // (with its exit paper) — one per truck — and the customer is asked to
+        // sign it from the portal. Booking-level fallback when the plate matched
+        // no live assignment (e.g. exit re-recorded) but the booking is EDR-hauled.
+        for (const row of edrDeparted) {
+          await this.handover.ensureForDepartedEdrTruck(
+            item.bookingId,
+            { truckPlate: dto.truckPlateNumber.trim(), edrAssignmentId: row.id },
+            manager,
+          );
+        }
+        if (!edrDeparted.length) {
+          const [lm]: Array<{ id: string }> = await manager.query(
+            `SELECT id FROM freight.last_mile WHERE booking_id = $1 AND deleted_at IS NULL LIMIT 1`,
+            [item.bookingId],
+          );
+          if (lm) {
+            await this.handover.ensureForDepartedEdrTruck(
+              item.bookingId,
+              { truckPlate: dto.truckPlateNumber.trim() },
+              manager,
+            );
+          }
+        }
         // Customer self-haul: the same exit record on the customer's own truck.
         // Without it a self-haul bulk booking never draws down — hauled tonnage
         // summed to zero and the booking could take unlimited trucks. Matched by
@@ -3123,11 +3270,43 @@ export class WarehouseInventoryService {
     // the transaction and fire-and-forget: notifying must never fail the exit.
     if (isTruckLeaving && item.bookingId) {
       void this.notifyTruckDeparture(item.bookingId, dto.truckPlateNumber?.trim() ?? null, netTons);
+    } else if (item.bookingId) {
+      // Gate-in: same single-path hook for the arrival side (self-haul + EDR).
+      void this.notifyTruckArrival(item.bookingId, dto.truckPlateNumber?.trim() ?? null);
     }
 
     return this.findById(id);
   }
 
+  /** Best-effort truck-arrival notification (gate-in), mirror of the departure one. */
+  private async notifyTruckArrival(bookingId: string, plateNumber: string | null): Promise<void> {
+    try {
+      const [booking]: Array<{ companyId: string | null; reference: string | null }> =
+        await this.dataSource.query(
+          `SELECT company_id AS "companyId", reference
+             FROM freight.bookings
+            WHERE id = $1 AND deleted_at IS NULL`,
+          [bookingId],
+        );
+      if (!booking?.companyId) return;
+      const ref = booking.reference ?? bookingId;
+      const truck = plateNumber ? `Truck ${plateNumber}` : 'A truck';
+      const body = `${truck} has arrived at the warehouse for booking ${ref}.`;
+      await this.inbox.notify({
+        recipients: { companyId: booking.companyId },
+        audience: NotificationAudience.PORTAL,
+        type: NotificationType.BOOKING_STATUS,
+        title: 'Truck arrived at the warehouse',
+        body,
+        link: `/bookings/${bookingId}`,
+        data: { bookingId, plateNumber, action: 'TRUCK_ARRIVED' },
+      });
+      await sendCompanyChannels(this.dataSource, this.notifications, booking.companyId, body);
+    } catch (err) {
+      this.logger.warn(`Truck-arrival notify failed for ${bookingId}: ${(err as Error).message}`);
+    }
+  }
+
   /**
    * Best-effort truck-departure notification to the booking's company across
    * every channel: in-app (portal inbox) + SMS + email. Never throws — a missing
@@ -3809,8 +3988,213 @@ export class WarehouseInventoryService {
     };
   }
 
-  /** Handover PDF resolved by booking (for the portal, which only has bookingId). */
-  async handoverDocumentForBooking(bookingId: string): Promise<{ filename: string; buffer: Buffer }> {
+  /**
+   * Customer signs ONE handover from the portal (EDR last-mile: one per truck).
+   * When the last one is signed — and every EDR truck has left the warehouse —
+   * the delivery completes automatically: inventory + cargo delivered, last-mile
+   * leg DELIVERED (trucks freed), booking completed ("shipment delivered").
+   */
+  async signHandover(
+    handoverId: string,
+    userId?: string,
+    signerName?: string,
+  ): Promise<{
+    handoverId: string;
+    bookingId: string;
+    signedAt: string | null;
+    signerDisplayName: string;
+    allSigned: boolean;
+  }> {
+    if (!userId) {
+      throw new BadRequestException('Authentication is required to sign the handover');
+    }
+    const name = signerName?.trim();
+    if (!name) {
+      throw new BadRequestException('Please enter your full name to sign the handover');
+    }
+
+    const [h]: Array<{
+      bookingId: string;
+      reference: string;
+      truckPlate: string | null;
+      mileType: string;
+      edrAssignmentId: string | null;
+    }> = await this.dataSource.query(
+      `SELECT booking_id AS "bookingId", reference, truck_plate AS "truckPlate",
+              mile_type AS "mileType", edr_assignment_id AS "edrAssignmentId"
+         FROM freight.booking_handovers
+        WHERE id = $1 AND deleted_at IS NULL`,
+      [handoverId],
+    );
+    if (!h) throw new NotFoundException(`Handover ${handoverId} not found`);
+    // Self-haul stays a single booking-level signature via approve-delivery,
+    // which also enforces inspection-passed + truck-arrived. Per-truck signing
+    // is an EDR last-mile flow only.
+    if (h.mileType !== 'EDR_LAST_MILE') {
+      throw new BadRequestException(
+        'This handover is signed through Approve delivery, not per truck',
+      );
+    }
+
+    // Same gate as approve-delivery: storage/demurrage must be settled first.
+    const [inv]: Array<{ id: string; warehouseId: string | null }> = await this.dataSource.query(
+      `SELECT id, warehouse_id AS "warehouseId" FROM freight.warehouse_inventory
+        WHERE booking_id = $1 AND deleted_at IS NULL
+        ORDER BY updated_at DESC NULLS LAST, created_at DESC LIMIT 1`,
+      [h.bookingId],
+    );
+    if (inv) await this.invoices.assertClearanceAllowed(inv.id);
+
+    const signed = await this.handover.sign(handoverId, userId, name);
+    const allSigned = await this.handover.isFullySigned(h.bookingId);
+
+    if (inv) {
+      await this.activityLog.record({
+        activityType: 'INVENTORY_RELEASED',
+        inventoryId: inv.id,
+        warehouseId: inv.warehouseId,
+        description: `Customer signed handover ${h.reference}${h.truckPlate ? ` (truck ${h.truckPlate})` : ''} as ${name}`,
+        performedBy: name,
+      });
+    }
+
+    // EDR last-mile delivers PER TRUCK: this signature confirms receipt of the
+    // goods THIS truck carried, so only its containers become DELIVERED now.
+    // (Self-haul keeps the single booking-level handover + manual Deliver.)
+    if (h.mileType === 'EDR_LAST_MILE') {
+      try {
+        await this.deliverEdrTruckContainers(h, name);
+      } catch (err) {
+        this.logger.warn(
+          `Per-truck auto-deliver after handover sign failed for ${h.bookingId}: ${(err as Error).message}`,
+        );
+      }
+    }
+
+    if (allSigned) {
+      void this.completeEdrDeliveryIfReady(h.bookingId, name).catch((err: Error) =>
+        this.logger.warn(`Auto-complete after handover sign failed for ${h.bookingId}: ${err.message}`),
+      );
+    }
+
+    return {
+      handoverId,
+      bookingId: h.bookingId,
+      signedAt: signed.signedAt ? new Date(signed.signedAt).toISOString() : null,
+      signerDisplayName: name,
+      allSigned,
+    };
+  }
+
+  /**
+   * EDR last-mile auto-completion: once every handover is signed and every EDR
+   * truck has departed, deliver the remaining inventory, mark the last-mile leg
+   * DELIVERED and complete the booking. Self-haul bookings keep their manual
+   * Deliver flow (no last_mile record ⇒ no-op).
+   */
+  private async completeEdrDeliveryIfReady(bookingId: string, signerName: string): Promise<void> {
+    const [lm]: Array<{ id: string; status: string }> = await this.dataSource.query(
+      `SELECT id, status FROM freight.last_mile
+        WHERE booking_id = $1 AND deleted_at IS NULL LIMIT 1`,
+      [bookingId],
+    );
+    if (!lm) return;
+
+    const [pending]: Array<{ notDeparted: string }> = await this.dataSource.query(
+      `SELECT COUNT(*) FILTER (WHERE va.departed_at IS NULL) AS "notDeparted"
+         FROM freight.last_mile_vehicle_assignments va
+         JOIN freight.last_mile l ON l.id = va.last_mile_id AND l.deleted_at IS NULL
+        WHERE l.booking_id = $1 AND va.deleted_at IS NULL`,
+      [bookingId],
+    );
+    if (Number(pending?.notDeparted ?? 0) > 0) return;
+    if (!(await this.handover.isFullySigned(bookingId))) return;
+
+    const items: Array<{ id: string }> = await this.dataSource.query(
+      `SELECT id FROM freight.warehouse_inventory
+        WHERE booking_id = $1 AND status = 'READY_FOR_PICKUP' AND deleted_at IS NULL`,
+      [bookingId],
+    );
+    for (const it of items) {
+      try {
+        await this.deliver(it.id, {
+          receiverName: signerName,
+          remarks: 'Auto-delivered on customer handover signature',
+          performedBy: signerName,
+        } as DeliverInventoryDto);
+      } catch (err) {
+        this.logger.warn(`Auto-deliver of inventory ${it.id} failed: ${(err as Error).message}`);
+      }
+    }
+
+    if (lm.status !== 'DELIVERED') {
+      try {
+        await this.lastMileService.update(lm.id, { status: 'DELIVERED' } as UpdateLastMileDto);
+      } catch (err) {
+        this.logger.warn(`Auto-deliver of last-mile ${lm.id} failed: ${(err as Error).message}`);
+      }
+    }
+
+    // Booking → COMPLETED ("shipment delivered" notification) — owned by the
+    // bookings module; evented to avoid a warehouses→bookings service dependency.
+    this.events.emit('import.handover.completed', { bookingId });
+  }
+
+  /**
+   * EDR last-mile per-truck delivery: the customer signed THIS truck's handover,
+   * so only the container items that truck carried become DELIVERED. Bulk cargo
+   * (no container rows) is delivered by completeEdrDeliveryIfReady once every
+   * truck is signed off.
+   */
+  private async deliverEdrTruckContainers(
+    h: { bookingId: string; edrAssignmentId: string | null; truckPlate: string | null },
+    signerName: string,
+  ): Promise<void> {
+    if (!h.edrAssignmentId && !h.truckPlate) return;
+    const items: Array<{ id: string }> = await this.dataSource.query(
+      `SELECT DISTINCT inv.id
+         FROM freight.last_mile_vehicle_assignments va
+         JOIN freight.last_mile l ON l.id = va.last_mile_id AND l.deleted_at IS NULL
+         LEFT JOIN freight.last_mile_vehicle_containers vc
+           ON vc.assignment_id = va.id AND vc.deleted_at IS NULL
+         LEFT JOIN freight.vehicles v ON v.id = va.vehicle_id
+         JOIN freight.containers c
+           ON c.container_number = COALESCE(vc.container_number, va.container_number)
+          AND c.deleted_at IS NULL
+         JOIN freight.warehouse_inventory inv
+           ON inv.container_id = c.id AND inv.booking_id = l.booking_id AND inv.deleted_at IS NULL
+        WHERE l.booking_id = $1
+          AND va.deleted_at IS NULL
+          AND inv.status = 'READY_FOR_PICKUP'
+          AND (va.id = $2::uuid
+               OR ($2::uuid IS NULL
+                   AND (UPPER(v.power_plate_no) = UPPER($3) OR UPPER(v.plate_number) = UPPER($3))))`,
+      [h.bookingId, h.edrAssignmentId, h.truckPlate ?? ''],
+    );
+    for (const it of items) {
+      try {
+        await this.deliver(it.id, {
+          receiverName: signerName,
+          remarks: `Auto-delivered on customer handover signature${h.truckPlate ? ` (truck ${h.truckPlate})` : ''}`,
+          performedBy: signerName,
+        } as DeliverInventoryDto);
+      } catch (err) {
+        this.logger.warn(
+          `Per-truck auto-deliver of inventory ${it.id} failed: ${(err as Error).message}`,
+        );
+      }
+    }
+  }
+
+  /**
+   * Handover PDF resolved by booking (for the portal, which only has bookingId).
+   * With `handoverId` the document is rendered for that specific handover — the
+   * per-truck EDR last-mile variant (truck plate + that truck's signature state).
+   */
+  async handoverDocumentForBooking(
+    bookingId: string,
+    handoverId?: string,
+  ): Promise<{ filename: string; buffer: Buffer }> {
     const [inv]: Array<{ id: string }> = await this.dataSource.query(
       `SELECT id FROM freight.warehouse_inventory
         WHERE booking_id = $1 AND deleted_at IS NULL
@@ -3821,7 +4205,29 @@ export class WarehouseInventoryService {
     if (!inv) {
       throw new NotFoundException(`No warehouse inventory found for booking ${bookingId}`);
     }
-    return this.handoverDocument(inv.id);
+    if (!handoverId) return this.handoverDocument(inv.id);
+
+    const [h]: Array<{
+      reference: string;
+      truckPlate: string | null;
+      signedAt: string | null;
+      signerName: string | null;
+    }> = await this.dataSource.query(
+      `SELECT reference, truck_plate AS "truckPlate",
+              signed_at AS "signedAt", signer_name AS "signerName"
+         FROM freight.booking_handovers
+        WHERE id = $1 AND booking_id = $2 AND deleted_at IS NULL`,
+      [handoverId, bookingId],
+    );
+    if (!h) {
+      throw new NotFoundException(`Handover ${handoverId} not found for booking ${bookingId}`);
+    }
+    return this.handoverDocument(inv.id, {
+      reference: h.reference,
+      truckPlate: h.truckPlate,
+      signedAt: h.signedAt ? new Date(h.signedAt) : null,
+      signerName: h.signerName,
+    });
   }
 
   /** Resolve the primary warehouse-inventory item for a booking (most recent). */
@@ -3849,12 +4255,22 @@ export class WarehouseInventoryService {
     return this.releaseDocument(await this.primaryInventoryIdForBooking(bookingId));
   }
 
-  async handoverDocument(id: string): Promise<{ filename: string; buffer: Buffer }> {
+  async handoverDocument(
+    id: string,
+    perTruck?: {
+      reference: string;
+      truckPlate: string | null;
+      signedAt: Date | null;
+      signerName: string | null;
+    },
+  ): Promise<{ filename: string; buffer: Buffer }> {
     const [row] = await this.dataSource.query(
       `SELECT inv.id,
               inv.booking_id AS "bookingId",
               inv.quantity,
-              inv.weight,
+              -- An unweighed item still reports the cargo weight it holds: fall
+              -- back to the item's container VGM when no weight was recorded.
+              COALESCE(NULLIF(inv.weight, 0), item_vgm.tons, 0) AS weight,
               inv.status,
               inv.notes,
               inv.inspection_status AS "inspectionStatus",
@@ -3906,6 +4322,16 @@ export class WarehouseInventoryService {
             WHERE bc.booking_id = b.id
               AND bc.deleted_at IS NULL
          ) booking_container ON true
+         LEFT JOIN LATERAL (
+           SELECT SUM(bcu.vgm_tons) AS tons
+             FROM freight.booking_container_units bcu
+             JOIN freight.booking_container bc2
+               ON bc2.id = bcu.booking_container_id AND bc2.deleted_at IS NULL
+            WHERE bc2.booking_id = b.id
+              AND bcu.deleted_at IS NULL
+              AND (container.container_number IS NULL
+                   OR bcu.container_number = container.container_number)
+         ) item_vgm ON true
          LEFT JOIN freight.cargoes cargo ON cargo.id = inv.cargo_id AND cargo.deleted_at IS NULL
          LEFT JOIN freight.cargo_types cargo_type ON cargo_type.id = COALESCE(cargo.cargo_type_id, b.cargo_type_id)
          LEFT JOIN freight.train_schedule_bookings tsb ON tsb.booking_id = b.id AND tsb.deleted_at IS NULL
@@ -3924,12 +4350,14 @@ export class WarehouseInventoryService {
 
     const bookingReference = row.bookingReference || row.bookingId || 'N/A';
     const reference =
+      perTruck?.reference ||
       this.extractHandoverDocumentLine(row.notes, 'Handover Reference') ||
       `HND-${String(bookingReference).replace(/[^a-zA-Z0-9_-]+/g, '-')}`;
     const generatedAtValue = this.extractHandoverDocumentLine(row.notes, 'Generated At');
     const generatedAt = generatedAtValue ? new Date(generatedAtValue) : new Date();
     const handedOverAt = Number.isNaN(generatedAt.getTime()) ? new Date() : generatedAt;
-    if (!generatedAtValue) {
+    // Per-truck renders must not stamp their reference into the shared item notes.
+    if (!generatedAtValue && !perTruck) {
       await this.inventoryRepository.update(id, {
         notes: this.replaceHandoverDocumentNote(row.notes, this.buildHandoverDocumentNote(reference, handedOverAt)),
       });
@@ -3963,7 +4391,16 @@ export class WarehouseInventoryService {
       releaseDate: row.releaseDate ? new Date(row.releaseDate) : null,
       trainSchedule: row.trainSchedule ?? null,
       lastMileDeliveryAddress: row.lastMileDeliveryAddress ?? null,
-      customerApproval: this.extractCustomerDeliveryApproval(row.notes),
+      truckPlate: perTruck?.truckPlate ?? null,
+      customerApproval: perTruck
+        ? perTruck.signedAt
+          ? {
+              approvedAt: perTruck.signedAt.toISOString(),
+              signerDisplayName: perTruck.signerName ?? '-',
+              signatureImageUrl: null,
+            }
+          : null
+        : this.extractCustomerDeliveryApproval(row.notes),
     });
 
     return {
@@ -4002,14 +4439,61 @@ export class WarehouseInventoryService {
         if (!(await this.handover.isFullySigned(item.bookingId))) {
           throw new BadRequestException('Handover must be signed before delivery');
         }
-        const [left]: Array<{ n: string }> = await this.dataSource.query(
-          `SELECT COUNT(*) AS n FROM freight.customer_truck_assignments
-            WHERE booking_id = $1 AND departed_at IS NOT NULL AND deleted_at IS NULL`,
+        const [trucks]: Array<{ total: string; left: string }> = await this.dataSource.query(
+          `SELECT COUNT(*) AS total,
+                  COUNT(*) FILTER (WHERE departed_at IS NOT NULL) AS "left"
+             FROM freight.customer_truck_assignments
+            WHERE booking_id = $1 AND deleted_at IS NULL`,
           [item.bookingId],
         );
-        if (Number(left?.n ?? 0) === 0) {
+        const totalTrucks = Number(trucks?.total ?? 0);
+        const leftTrucks = Number(trucks?.left ?? 0);
+        if (leftTrucks === 0) {
           throw new BadRequestException('Deliver is available only after the customer truck has left');
         }
+        // Multi-truck booking: every assigned truck must arrive and leave —
+        // each is weighed out separately before the goods count as delivered.
+        if (leftTrucks < totalTrucks) {
+          throw new BadRequestException(
+            `Deliver is available only after every assigned truck has left (${leftTrucks} of ${totalTrucks} so far)`,
+          );
+        }
+      }
+      // EDR last-mile delivers per truck: a container item only needs the truck
+      // CARRYING IT to have left; bulk (no container) waits for every truck.
+      if (item.containerId) {
+        const [own]: Array<{ pending: string }> = await this.dataSource.query(
+          `SELECT COUNT(*) FILTER (WHERE va.departed_at IS NULL) AS pending
+             FROM freight.last_mile_vehicle_assignments va
+             JOIN freight.last_mile l ON l.id = va.last_mile_id AND l.deleted_at IS NULL
+             LEFT JOIN freight.last_mile_vehicle_containers vc
+               ON vc.assignment_id = va.id AND vc.deleted_at IS NULL
+             JOIN freight.containers c ON c.id = $2 AND c.deleted_at IS NULL
+            WHERE l.booking_id = $1 AND va.deleted_at IS NULL
+              AND COALESCE(vc.container_number, va.container_number) = c.container_number`,
+          [item.bookingId, item.containerId],
+        );
+        if (Number(own?.pending ?? 0) > 0) {
+          throw new BadRequestException(
+            'Deliver is available only after the EDR truck carrying this container has left',
+          );
+        }
+      } else {
+        const [lm]: Array<{ total: string; left: string }> = await this.dataSource.query(
+          `SELECT COUNT(*) AS total,
+                  COUNT(*) FILTER (WHERE va.departed_at IS NOT NULL) AS "left"
+             FROM freight.last_mile_vehicle_assignments va
+             JOIN freight.last_mile l ON l.id = va.last_mile_id AND l.deleted_at IS NULL
+            WHERE l.booking_id = $1 AND va.deleted_at IS NULL`,
+          [item.bookingId],
+        );
+        const lmTotal = Number(lm?.total ?? 0);
+        const lmLeft = Number(lm?.left ?? 0);
+        if (lmTotal > 0 && lmLeft < lmTotal) {
+          throw new BadRequestException(
+            `Deliver is available only after every assigned EDR truck has left (${lmLeft} of ${lmTotal} so far)`,
+          );
+        }
       }
     }
 
@@ -4105,6 +4589,12 @@ export class WarehouseInventoryService {
       }
     });
 
+    // "Approve delivery" nudge: on Deliver the customer is reminded to sign any
+    // handover still unsigned (per truck for EDR last-mile). Fire-and-forget.
+    if (item.bookingId) {
+      void this.handover.notifyUnsignedForBooking(item.bookingId).catch(() => undefined);
+    }
+
     return this.findById(id);
   }
 
@@ -4832,10 +5322,11 @@ export class WarehouseInventoryService {
     releaseDate: Date | null;
     trainSchedule: string | null;
     lastMileDeliveryAddress: string | null;
+    truckPlate?: string | null;
     customerApproval: {
       approvedAt: string;
       signerDisplayName: string;
-      signatureImageUrl: string;
+      signatureImageUrl: string | null;
     } | null;
   }): string {
     const esc = (value: unknown) =>
@@ -4881,6 +5372,7 @@ export class WarehouseInventoryService {
       ['Release Order', data.releaseOrderReference],
       ['Release Date', fmt(data.releaseDate)],
       ['Last-mile Delivery Address', data.lastMileDeliveryAddress],
+      ...(data.truckPlate ? [['Delivering Truck Plate', data.truckPlate]] : []),
     ];
     const approval = data.customerApproval;
 
@@ -5290,7 +5782,11 @@ export class WarehouseInventoryService {
       weighingSkipped ? 'Weighing: SKIPPED' : null,
       tareWeight == null ? null : `Tare Weight: ${tareWeight} t`,
       grossWeight == null ? null : `Gross Weight: ${grossWeight} t`,
-      computedNetWeight == null ? null : `Net Weight: ${computedNetWeight} t`,
+      // Skipped weighing still records a net — the cargo weight of the
+      // containers the truck is holding, resolved by the caller.
+      (computedNetWeight ?? (weighingSkipped ? dto.netWeight : null)) == null
+        ? null
+        : `Net Weight: ${computedNetWeight ?? Number(dto.netWeight)} t`,
       dto.gateOutTime ? `Gate Out Time: ${dto.gateOutTime}` : null,
     ];
 
@@ -5298,12 +5794,14 @@ export class WarehouseInventoryService {
   }
 
   private preserveTruckArrivalForExit(dto: ReleaseOrderDto, notes: string | null | undefined): ReleaseOrderDto {
-    const inspection = this.extractExitInspectionNote(notes);
+    const inspection = this.extractExitInspectionForPlate(notes, dto.truckPlateNumber);
     if (!inspection) return dto;
 
     return {
       ...dto,
-      truckPlateNumber: this.extractExitInspectionLine(inspection, 'Truck Plate') || dto.truckPlateNumber,
+      // The submitted plate wins: a legacy block may store a comma-joined list
+      // of plates, and the exit must be recorded against the ONE truck leaving.
+      truckPlateNumber: dto.truckPlateNumber?.trim() || this.extractExitInspectionLine(inspection, 'Truck Plate') || dto.truckPlateNumber,
       trailerPlateNumber: this.extractExitInspectionLine(inspection, 'Trailer Plate') || dto.trailerPlateNumber,
       driverName: this.extractExitInspectionLine(inspection, 'Driver') || dto.driverName,
       driverLicense: this.extractExitInspectionLine(inspection, 'Driver License') || dto.driverLicense,
@@ -5317,25 +5815,94 @@ export class WarehouseInventoryService {
     };
   }
 
-  private replaceExitInspectionNote(notes: string | null | undefined, exitInspectionNote: string | null): string | null {
+  /**
+   * Split notes into exit-inspection blocks (one per truck, in order) and
+   * everything else. A block ends at the first line that isn't one of the
+   * known inspection labels, so appended notes (delivery approval, handover
+   * marker) are preserved as "other" content instead of being swallowed by
+   * the block they happen to follow.
+   */
+  private splitExitInspectionSections(notes?: string | null): { others: string[]; blocks: string[] } {
     const trimmed = notes?.trim();
-    if (!exitInspectionNote) return trimmed || null;
-    if (!trimmed) return exitInspectionNote;
-
-    const marker = '[Exit Inspection]';
-    const index = trimmed.lastIndexOf(marker);
-    if (index < 0) {
-      return `${trimmed}\n\n${exitInspectionNote}`;
+    if (!trimmed) return { others: [], blocks: [] };
+    const labelPattern =
+      /^(Booking ID|Customer ID|Truck Plate|Trailer Plate|Driver|Driver License|Driver Phone|Truck Type|Container Number|Gate In Time|Weighing|Tare Weight|Gross Weight|Net Weight|Gate Out Time):/i;
+    const parts = trimmed.split(EXIT_INSPECTION_MARKER);
+    const others: string[] = [];
+    const blocks: string[] = [];
+    if (parts[0]?.trim()) others.push(parts[0].trim());
+    for (const part of parts.slice(1)) {
+      const lines = part.split('\n');
+      const kept: string[] = [];
+      let i = 0;
+      while (i < lines.length && !lines[i].trim()) i += 1;
+      for (; i < lines.length; i += 1) {
+        const line = lines[i].trim();
+        if (!line || !labelPattern.test(line)) break;
+        kept.push(line);
+      }
+      if (kept.length) blocks.push(kept.join('\n'));
+      const tail = lines.slice(i).join('\n').trim();
+      if (tail) others.push(tail);
     }
-    return [trimmed.slice(0, index).trim(), exitInspectionNote].filter(Boolean).join('\n\n');
+    return { others, blocks };
   }
 
+  /**
+   * A block belongs to a plate when its stored `Truck Plate` equals it, or is a
+   * legacy comma-joined list ("P1, P2") containing it.
+   */
+  private blockMatchesPlate(block: string, plateNumber?: string | null): boolean {
+    const plate = plateNumber?.trim().toUpperCase();
+    if (!plate) return false;
+    const stored = this.extractExitInspectionLine(block, 'Truck Plate')?.toUpperCase();
+    if (!stored) return false;
+    if (stored === plate) return true;
+    return stored.split(/[,;]+/).map((p) => p.trim()).includes(plate);
+  }
+
+  /**
+   * Replace THIS truck's inspection block (matched by plate), keeping every
+   * other truck's block untouched; append when the plate has no block yet.
+   * A single legacy block (comma-joined plates or plate-less caller) is
+   * replaced in place so old single-truck items keep their behaviour.
+   */
+  private replaceExitInspectionNote(
+    notes: string | null | undefined,
+    exitInspectionNote: string | null,
+    plateNumber?: string | null,
+  ): string | null {
+    const { others, blocks } = this.splitExitInspectionSections(notes);
+    if (exitInspectionNote) {
+      const content = exitInspectionNote.replace(EXIT_INSPECTION_MARKER, '').trim();
+      const index = plateNumber
+        ? blocks.findIndex((b) => this.blockMatchesPlate(b, plateNumber))
+        : blocks.length - 1;
+      if (index >= 0) blocks[index] = content;
+      else blocks.push(content);
+    }
+    const sections = [...others, ...blocks.map((b) => `${EXIT_INSPECTION_MARKER}\n${b}`)];
+    return sections.join('\n\n') || null;
+  }
+
+  /** Latest truck's inspection block — legacy summary for documents. */
   private extractExitInspectionNote(notes?: string | null): string | null {
-    if (!notes) return null;
-    const marker = '[Exit Inspection]';
-    const index = notes.lastIndexOf(marker);
-    if (index < 0) return null;
-    return notes.slice(index + marker.length).trim() || null;
+    const { blocks } = this.splitExitInspectionSections(notes);
+    return blocks.length ? blocks[blocks.length - 1] : null;
+  }
+
+  /**
+   * The inspection block for one truck. Falls back to a lone existing block so
+   * legacy single-truck items (saved before per-plate blocks) keep working.
+   */
+  private extractExitInspectionForPlate(
+    notes: string | null | undefined,
+    plateNumber?: string | null,
+  ): string | null {
+    const { blocks } = this.splitExitInspectionSections(notes);
+    const match = blocks.find((b) => this.blockMatchesPlate(b, plateNumber));
+    if (match) return match;
+    return blocks.length === 1 ? blocks[0] : null;
   }
 
   private extractExitInspectionLine(note: string | null | undefined, label: string): string | null {
@@ -5648,6 +6215,31 @@ export class WarehouseInventoryService {
     );
   }
 
+  /**
+   * Export cargo is received into the warehouse to wait for its train, and it is
+   * received only once the booking is paid — receiving an unpaid export booking
+   * would start storage and mint a GRN against cargo the customer has not settled.
+   *
+   * Export only: import cargo arrives OFF a train and its receive is the unload,
+   * so gating that on payment would strand cargo already at the yard.
+   */
+  private async assertExportBookingPaid(
+    bookingId: string | null | undefined,
+    direction: string | null,
+  ): Promise<void> {
+    if (!bookingId || direction !== 'EXPORT') return;
+    const [row]: Array<{ paymentStatus: string | null }> = await this.dataSource.query(
+      `SELECT payment_status AS "paymentStatus"
+         FROM freight.bookings WHERE id = $1 AND deleted_at IS NULL`,
+      [bookingId],
+    );
+    if ((row?.paymentStatus ?? '').toUpperCase() !== 'PAID') {
+      throw new BadRequestException(
+        'This export booking is not paid yet — its cargo cannot be received at the warehouse until payment is settled.',
+      );
+    }
+  }
+
   private assertCapacity(
     label: string,
     node: LocationNode,
diff --git a/apps/edr-freight-api/src/modules/warehouses/warehouse-yards.controller.ts b/apps/edr-freight-api/src/modules/warehouses/warehouse-yards.controller.ts
index fdfbc36be..5f4205815 100644
--- a/apps/edr-freight-api/src/modules/warehouses/warehouse-yards.controller.ts
+++ b/apps/edr-freight-api/src/modules/warehouses/warehouse-yards.controller.ts
@@ -1,7 +1,7 @@
 import { Body, Controller, Get, Param, ParseUUIDPipe, Patch, Post } from '@nestjs/common';
 import { ApiBearerAuth, ApiOperation, ApiTags } from '@nestjs/swagger';
 
-import { BookingStaff } from '../../common/booking-guards';
+import { BookingStaff, StaffReference } from '../../common/booking-guards';
 import { FREIGHT_PERMS } from '../../seed/freight-permissions.registry';
 import { CreateWarehouseZoneDto } from './dto/create-warehouse-zone.dto';
 import { UpdateWarehouseYardDto } from './dto/update-warehouse-yard.dto';
@@ -10,8 +10,9 @@ import { WarehouseZonesService } from './warehouse-zones.service';
 
 @ApiTags('warehouse-yards')
 @ApiBearerAuth()
+// No class-level guard: the two reference GETs are open to any signed-in
+// staff (StaffReference), every other route carries its own permission.
 @Controller('warehouse-yards')
-@BookingStaff(FREIGHT_PERMS.warehouseYards.view)
 export class WarehouseYardsController {
   constructor(
     private readonly yardsService: WarehouseYardsService,
@@ -19,12 +20,14 @@ export class WarehouseYardsController {
   ) {}
 
   @Get()
+  @StaffReference()
   @ApiOperation({ summary: 'List all warehouse yards' })
   findAll() {
     return this.yardsService.findAll();
   }
 
   @Get(':id')
+  @StaffReference()
   @ApiOperation({ summary: 'Get warehouse yard by ID' })
   findOne(@Param('id', ParseUUIDPipe) id: string) {
     return this.yardsService.findById(id);
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 d65b2e2d8..03908b62b 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
@@ -568,6 +568,20 @@ const DRIVER_DOCUMENT_SETTINGS: OnboardingDocumentSetting[] = [
   },
 ];
 
+// ── Intercity documents ─────────────────────────────────────────────────────
+// One shared set for DOMESTIC (intercity) shipments, reviewed by Operations.
+// ONE_TIME contracts collect it at contract level after both signatures;
+// GENERAL contracts collect it per booking right after the booking is created.
+// Fields start empty and are configured in the backoffice file-settings editor.
+const INTERCITY_DOCUMENT_SETTINGS: OnboardingDocumentSetting[] = [
+  {
+    code: "intercity_documents",
+    label: "Intercity documents",
+    entity: "booking",
+    fields: [],
+  },
+];
+
 @Injectable()
 export class FileUploadSettingsSeeder {
   private readonly logger = new Logger(FileUploadSettingsSeeder.name);
@@ -619,6 +633,11 @@ export class FileUploadSettingsSeeder {
           description:
             "Documents uploaded against a driver profile (license, ID, contracts, etc.).",
         })),
+        ...INTERCITY_DOCUMENT_SETTINGS.map((s) => ({
+          ...s,
+          description:
+            "Intercity shipment documents — contract-level for ONE_TIME (after both signatures), per booking for GENERAL; reviewed by Operations.",
+        })),
       ];
 
     // Insert setting rows only — no FileUploadField rows. Fields start empty
diff --git a/apps/edr-freight-api/src/seed/freight-permissions.registry.ts b/apps/edr-freight-api/src/seed/freight-permissions.registry.ts
index d3b5bbb00..396ac95db 100644
--- a/apps/edr-freight-api/src/seed/freight-permissions.registry.ts
+++ b/apps/edr-freight-api/src/seed/freight-permissions.registry.ts
@@ -18,6 +18,7 @@ export const RULE_ENGINE_RESOURCE_SLUGS = [
   'priority-configs',
   'rates',
   'approval-rules',
+  'yard-distances',
 ] as const;
 
 export type RuleEngineResourceSlug = (typeof RULE_ENGINE_RESOURCE_SLUGS)[number];
@@ -97,6 +98,7 @@ const RULE_ENGINE_PERMISSION_IDS: Record<RuleEngineResourceSlug, { view: string;
   'priority-configs': { view: 'b2000001-0001-4000-8000-00000000000f', manage: 'b2000001-0001-4000-8000-000000000010' },
   rates: { view: 'b2000001-0001-4000-8000-000000000011', manage: 'b2000001-0001-4000-8000-000000000012' },
   'approval-rules': { view: 'b2000001-0001-4000-8000-000000000013', manage: 'b2000001-0001-4000-8000-000000000014' },
+  'yard-distances': { view: 'b2000001-0001-4000-8000-000000000018', manage: 'b2000001-0001-4000-8000-000000000019' },
 };
 
 /**
diff --git a/apps/edr-freight-web/backoffice/package.json b/apps/edr-freight-web/backoffice/package.json
index 9f7fd27bf..04fc14a77 100644
--- a/apps/edr-freight-web/backoffice/package.json
+++ b/apps/edr-freight-web/backoffice/package.json
@@ -4,7 +4,7 @@
   "private": true,
   "type": "module",
   "scripts": {
-    "dev": "vite --port 5183 --clearScreen false",
+    "dev": "vite --port 5283 --clearScreen false",
     "prebuild": "node -e \"const fs=require('fs'); fs.rmSync('dist',{recursive:true,force:true});\"",
     "build": "vite build",
     "preview": "vite preview --port 5183",
diff --git a/apps/edr-freight-web/backoffice/src/App.tsx b/apps/edr-freight-web/backoffice/src/App.tsx
index 86f5bf6e6..aed710e2e 100644
--- a/apps/edr-freight-web/backoffice/src/App.tsx
+++ b/apps/edr-freight-web/backoffice/src/App.tsx
@@ -151,6 +151,7 @@ const buildSidebarSections = (demoItems: SidebarItem[]): SidebarSection[] => [
         label: "Customers",
         href: "/dashboard/customers",
         icon: <Building2 />,
+        permission: FREIGHT_PERMS.customers.view,
       },
       {
         label: "Contracts",
@@ -162,6 +163,7 @@ const buildSidebarSections = (demoItems: SidebarItem[]): SidebarSection[] => [
         label: "Bookings",
         href: "/dashboard/booking-requests",
         icon: <FileText />,
+        permission: FREIGHT_PERMS.bookings.view,
       },
       // Operations hub: clearance-document review for contracts WITHOUT
       // customs clearing (contract-level for one-time, per-booking for general).
@@ -375,6 +377,7 @@ const buildSidebarSections = (demoItems: SidebarItem[]): SidebarSection[] => [
         label: "Imports",
         href: "/dashboard/import-warehouse",
         icon: <PackageOpen />,
+        permission: FREIGHT_PERMS.warehouseInventory.view,
         children: [
           {
             label: "Import Overview",
@@ -407,6 +410,7 @@ const buildSidebarSections = (demoItems: SidebarItem[]): SidebarSection[] => [
         label: "Exports",
         href: "/dashboard/export-warehouse",
         icon: <Truck />,
+        permission: FREIGHT_PERMS.warehouseInventory.view,
         children: [
           {
             label: "Export Overview",
@@ -449,6 +453,7 @@ const buildSidebarSections = (demoItems: SidebarItem[]): SidebarSection[] => [
         label: "Intercity",
         href: "/dashboard/intercity",
         icon: <TrainFront />,
+        permission: FREIGHT_PERMS.trainScheduling.view,
         children: [
           {
             label: "Intercity Cargo",
@@ -465,6 +470,7 @@ const buildSidebarSections = (demoItems: SidebarItem[]): SidebarSection[] => [
             label: "Warehouse Dashboard",
             href: "/dashboard/warehouse-dashboard",
             icon: <LayoutDashboard />,
+            permission: FREIGHT_PERMS.warehouseDashboard.view,
           },
           {
             // Yard-wide, not per-direction: the gate sees import and export
@@ -472,21 +478,25 @@ const buildSidebarSections = (demoItems: SidebarItem[]): SidebarSection[] => [
             label: "Trucks on Site",
             href: "/dashboard/trucks-on-site",
             icon: <Truck />,
+            permission: FREIGHT_PERMS.warehouseInventory.view,
           },
           {
             label: "Warehouses",
             href: "/dashboard/warehouses",
             icon: <Container />,
+            permission: FREIGHT_PERMS.warehouses.view,
           },
           {
             label: "Allocation & Fees",
             href: "/dashboard/warehouse-rules",
             icon: <SlidersHorizontal />,
+            permission: FREIGHT_PERMS.warehouseAllocationRules.view,
           },
           {
             label: "Fee Invoices",
             href: "/dashboard/warehouse-fee-invoices",
             icon: <Wallet />,
+            permission: FREIGHT_PERMS.warehouseFeeInvoices.view,
           },
         ],
       },
@@ -523,10 +533,12 @@ const buildSidebarSections = (demoItems: SidebarItem[]): SidebarSection[] => [
           {
             label: "Contract validity",
             href: "/dashboard/configuration/contract-validity-periods",
+            permission: FREIGHT_PERMS.config.contractValidity.view,
           },
           {
             label: "Train scheduling rules",
             href: "/dashboard/configuration/train-scheduling-rules",
+            permission: FREIGHT_PERMS.trainScheduling.rulesManage,
           },
         ],
       },
@@ -541,6 +553,7 @@ const buildSidebarSections = (demoItems: SidebarItem[]): SidebarSection[] => [
         label: "Staff",
         href: "/user-management",
         icon: <Users />,
+        permission: FREIGHT_PERMS.admin,
       },
     ],
   },
@@ -596,10 +609,22 @@ const filterSidebarByPermission = (
     return permissionAllowed(item);
   };
 
+  // Recursive: a group's own permission gates the whole subtree, leaves are
+  // checked individually, and a group with no surviving children disappears.
+  const filterItems = (items: SidebarItem[]): SidebarItem[] =>
+    items.flatMap((item) => {
+      if (item.children?.length) {
+        if (item.permission && !permissionAllowed(item)) return [];
+        const children = filterItems(item.children);
+        return children.length ? [{ ...item, children }] : [];
+      }
+      return itemAllowed(item) ? [item] : [];
+    });
+
   return sections
     .map((section) => ({
       ...section,
-      items: section.items.filter(itemAllowed),
+      items: filterItems(section.items),
     }))
     .filter((section) => section.items.length > 0);
 };
@@ -708,7 +733,7 @@ const App = () => {
         <Route path="/forgot-password" element={<ForgotPasswordPage />} />
         {/* <Route path="/um/*" element={<UserManagementHostPage />} /> */}
         <Route path="um/set-password" element={<SetPassword />} />
-        <Route path="/callback" element={<FaydaCallbackPage />} />
+        <Route path="/fayda/callback" element={<FaydaCallbackPage />} />
         <Route path="*" element={<Navigate to="/auth" replace />} />
       </Routes>
     );
diff --git a/apps/edr-freight-web/backoffice/src/auth/http.ts b/apps/edr-freight-web/backoffice/src/auth/http.ts
index b31fd836a..82ae8e808 100644
--- a/apps/edr-freight-web/backoffice/src/auth/http.ts
+++ b/apps/edr-freight-web/backoffice/src/auth/http.ts
@@ -1,4 +1,5 @@
 import axios from "axios";
+import toast from "react-hot-toast";
 
 import { API_BASE_URL } from "@/constants/apiConfig";
 import { captureApiError } from "@/lib/posthog";
@@ -10,14 +11,16 @@ import {
   setCookie,
 } from "./cookies";
 import type { AuthTokens } from "./types";
+import { extractApiErrorPayload } from "@/components/errors/ApiErrorModal";
 
 declare module "axios" {
   export interface AxiosRequestConfig {
     /**
-     * When true, the response interceptor does NOT raise the global error modal
-     * for this request's failure. For calls the caller handles itself — e.g. a
-     * probe that is expected to 404 before falling back (GL clearance detail
-     * tries /contracts/:id then /bookings/:id). The rejection still propagates.
+     * When true, the response interceptor does NOT raise the global error
+     * toast for this request's failure. For calls the caller handles itself —
+     * e.g. a probe that is expected to 404 before falling back (GL clearance
+     * detail tries /contracts/:id then /bookings/:id). The rejection still
+     * propagates.
      */
     suppressErrorModal?: boolean;
   }
@@ -92,9 +95,8 @@ api.interceptors.response.use(
   async (error) => {
     const originalRequest = error.config as RetriableRequest | undefined;
 
-    // Report the failure to PostHog. Hooked here rather than inside
-    // `emitApiError`, which stays silent on suppressed paths (warehouse /
-    // mile / onboarding) — those failures still need reporting.
+    // Report the failure to PostHog, including on suppressErrorModal paths —
+    // those opt out of the user-facing toast, not of reporting.
     // 401s are skipped: an expired session is refreshed below, not a defect.
     if (!error.response || error.response.status !== 401) {
       captureApiError(error);
@@ -108,16 +110,25 @@ api.interceptors.response.use(
       originalRequest.url?.includes("/auth/mfa-verify") ||
       originalRequest.url?.includes("/auth/refresh-token")
     ) {
-      // Surface the server's actual error message in the global error modal
-      // (401s are handled by the session-refresh flow, so skip them). A request
-      // may opt out via `suppressErrorModal` when it handles the failure itself.
-      if (
-        error.response &&
-        error.response.status !== 401 &&
-        !originalRequest?.suppressErrorModal
-      ) {
-        // const payload = extractApiErrorPayload(error);
-        // if (payload) emitApiError(payload);
+      // Surface the server's actual error message in a global toast — never
+      // the error modal (401s are handled by the session-refresh flow, so skip
+      // them). A request may opt out via `suppressErrorModal` when it handles
+      // the failure itself.
+      if (error.response && error.response.status !== 401) {
+        const payload = extractApiErrorPayload(error);
+        // Normalize the error's own `message` to the SERVER's actual message so
+        // every downstream `toast.error(err.message)` handler shows the real
+        // cause instead of "Request failed with status code NNN". Applies even
+        // on suppressErrorModal paths — only the toast is opted out.
+        if (payload?.messages.length) {
+          const message = payload.messages.join("\n");
+          (error as { message?: string }).message = message;
+          // Keyed by message so a retried request replaces its toast instead
+          // of stacking duplicates.
+          if (!originalRequest?.suppressErrorModal) {
+            toast.error(message, { id: message });
+          }
+        }
       }
       return Promise.reject(error);
     }
diff --git a/apps/edr-freight-web/backoffice/src/auth/types.ts b/apps/edr-freight-web/backoffice/src/auth/types.ts
index 2dac243b4..a361c2abc 100644
--- a/apps/edr-freight-web/backoffice/src/auth/types.ts
+++ b/apps/edr-freight-web/backoffice/src/auth/types.ts
@@ -23,6 +23,7 @@ interface AuthEmployeePosition {
   permissions?: AuthPermission[];
   /** Some IAM payloads nest the position record instead of flattening its key. */
   position?: { id?: string; key?: string; name?: LocaleText };
+  positionType?: { id?: string; key?: string; name?: LocaleText } | null;
 }
 
 interface AuthEmployeeRecord {
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 97573410f..dcdfe6e39 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 { AlertTriangle, Check, ShieldCheck, X } from "lucide-react";
+import { Check, ShieldCheck, X } from "lucide-react";
 import {
   Stack,
   Group,
@@ -8,6 +8,7 @@ import {
   Button,
   Box,
   Modal,
+  Select,
   Textarea,
 } from "@mantine/core";
 import type { Freight } from "@edr/types";
@@ -35,6 +36,10 @@ export function ContractApprovalStepsCard({
   const [rejectStepRow, setRejectStepRow] =
     useState<Freight.IContractApprovalStep | null>(null);
   const [rejectReason, setRejectReason] = useState("");
+  // Where the rejection lands: "CUSTOMER" (terminal, resubmit) or the id of an
+  // earlier APPROVED step to send the chain back to. First approver has no
+  // choice — customer only.
+  const [rejectTarget, setRejectTarget] = useState<string>("CUSTOMER");
 
   const steps = useMemo(
     () =>
@@ -46,6 +51,11 @@ export function ContractApprovalStepsCard({
 
   const nextPending = steps.find((s) => s.status === "PENDING");
   const summary = formatContractApprovalProgress(contract.status, steps);
+  // The card also renders read-only trails (e.g. a REJECTED contract) — only
+  // offer approve/reject while the backend accepts step actions.
+  const actionable =
+    contract.status === "PENDING_APPROVAL" ||
+    contract.status === "APPROVED_PENDING_SIGNATURE";
 
   // Approvers review a live preview of the document; there is no PDF to
   // generate first — the final approval is what produces it.
@@ -70,6 +80,7 @@ export function ContractApprovalStepsCard({
   const openReject = (step: Freight.IContractApprovalStep) => {
     setRejectStepRow(step);
     setRejectReason("");
+    setRejectTarget("CUSTOMER");
     setRejectOpen(true);
   };
 
@@ -77,14 +88,34 @@ export function ContractApprovalStepsCard({
     setRejectOpen(false);
     setRejectStepRow(null);
     setRejectReason("");
+    setRejectTarget("CUSTOMER");
   };
 
   const trimmedReason = rejectReason.trim();
 
+  // Earlier stages this rejection can be returned to — only stages that have
+  // already approved. Empty for the first approver, whose only target is the
+  // customer.
+  const returnableSteps = rejectStepRow
+    ? steps.filter(
+        (s) =>
+          s.stepOrder < rejectStepRow.stepOrder && s.status === "APPROVED",
+      )
+    : [];
+
+  const sendBack = rejectTarget !== "CUSTOMER";
+  const targetStep = sendBack
+    ? returnableSteps.find((s) => s.id === rejectTarget)
+    : undefined;
+
   const runReject = () => {
     if (!rejectStepRow || !trimmedReason) return;
     mutations.rejectStep.mutate(
-      { stepId: rejectStepRow.id, reason: trimmedReason },
+      {
+        stepId: rejectStepRow.id,
+        reason: trimmedReason,
+        returnToStepId: sendBack ? rejectTarget : undefined,
+      },
       { onSuccess: () => closeReject() },
     );
   };
@@ -134,7 +165,7 @@ export function ContractApprovalStepsCard({
               <StepRow
                 key={step.id}
                 step={step}
-                isNext={nextPending?.id === step.id}
+                isNext={actionable && nextPending?.id === step.id}
                 isPending={
                   mutations.approveStep.isPending ||
                   mutations.rejectStep.isPending
@@ -192,21 +223,56 @@ export function ContractApprovalStepsCard({
         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>
+          {returnableSteps.length > 0 && (
+            <Select
+              label="Send rejection to"
+              description="Return the contract to an earlier approver to fix and re-approve, or reject it to the customer."
+              allowDeselect={false}
+              value={rejectTarget}
+              onChange={(v) => setRejectTarget(v ?? "CUSTOMER")}
+              data={[
+                { value: "CUSTOMER", label: "Customer — must resubmit" },
+                ...returnableSteps.map((s) => ({
+                  value: s.id,
+                  label: `${s.requiredRole} — step ${s.stepOrder} re-approves`,
+                })),
+              ]}
+            />
+          )}
+          {sendBack ? (
+            <Text size="sm" c="dimmed">
+              Contract{" "}
+              <Text span fw={600} c="dark">
+                {contract.reference}
+              </Text>{" "}
+              will go back to the{" "}
+              <Text span fw={600} c="dark">
+                {targetStep?.requiredRole}
+              </Text>{" "}
+              step. That approver fixes the contract and approves again, and
+              every later step re-approves in order. The customer is not
+              notified.
+            </Text>
+          ) : (
+            <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 resubmit — this cannot be undone.
+            </Text>
+          )}
           <Textarea
             label="Reason for rejection"
-            description="Shared with the customer and the approval chain."
+            description={
+              sendBack
+                ? "Shared with the approval chain (not the customer)."
+                : "Shared with the customer and the approval chain."
+            }
             placeholder="Explain why this contract is rejected…"
             minRows={3}
             autosize
@@ -219,14 +285,16 @@ export function ContractApprovalStepsCard({
               Cancel
             </Button>
             <Button
-              color="red"
+              color={sendBack ? "orange" : "red"}
               radius="md"
               leftSection={<X size={16} />}
               loading={mutations.rejectStep.isPending}
               disabled={!trimmedReason}
               onClick={runReject}
             >
-              Reject contract
+              {sendBack
+                ? `Send back to ${targetStep?.requiredRole ?? "step"}`
+                : "Reject contract"}
             </Button>
           </Group>
         </Stack>
diff --git a/apps/edr-freight-web/backoffice/src/components/contracts/GlCreateBookingForm.tsx b/apps/edr-freight-web/backoffice/src/components/contracts/GlCreateBookingForm.tsx
index 97199afc3..bc9521dd3 100644
--- a/apps/edr-freight-web/backoffice/src/components/contracts/GlCreateBookingForm.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/contracts/GlCreateBookingForm.tsx
@@ -447,6 +447,17 @@ export default function GlCreateBookingForm() {
     if (!copyFromBooking || prefilled) return;
     const lines = copyFromBooking.bookingContainers ?? [];
     if (!lines.length) return;
+    // The booking stores a numeric sizeFt (20) but the contract scope — and the
+    // create payload the server validates — uses its own size strings ("20ft").
+    // Seed with the scope's string so the rebook payload matches what a fresh
+    // form entry would send.
+    const scopeSizeForFt = (sizeFt: number | null | undefined): string => {
+      if (sizeFt == null) return "";
+      return (
+        containerSizes.find((s) => parseInt(s, 10) === Number(sizeFt)) ??
+        `${sizeFt}ft`
+      );
+    };
     setPrefilled(true);
     setContainerLines(
       lines.map((c) => {
@@ -466,7 +477,7 @@ export default function GlCreateBookingForm() {
               }))
             : Array.from({ length: qty }, emptyUnit);
         return {
-          containerSize: String(c.containerType?.sizeFt ?? ""),
+          containerSize: scopeSizeForFt(c.containerType?.sizeFt),
           quantity: String(qty),
           hazardousQuantity: String(units.filter((u) => u.isHazardous).length),
           reeferQuantity: String(units.filter((u) => u.isReefer).length),
@@ -475,7 +486,7 @@ export default function GlCreateBookingForm() {
         };
       }),
     );
-  }, [copyFromBooking, prefilled]);
+  }, [copyFromBooking, prefilled, containerSizes]);
 
   // Seed one shipment line per contracted size exactly once — same seeding the
   // portal form does. Subsequent renders reuse the lines.
diff --git a/apps/edr-freight-web/backoffice/src/components/contracts/gl-actions/IncidentReportCard.tsx b/apps/edr-freight-web/backoffice/src/components/contracts/gl-actions/IncidentReportCard.tsx
index 35a75d66c..088f65ba9 100644
--- a/apps/edr-freight-web/backoffice/src/components/contracts/gl-actions/IncidentReportCard.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/contracts/gl-actions/IncidentReportCard.tsx
@@ -23,6 +23,7 @@ const INCIDENT_OPTIONS: { value: Freight.IncidentType; label: string }[] = [
   { value: "CONTAINER_OPENED", label: "Container opened" },
   { value: "CONTAINER_DAMAGED", label: "Container damaged" },
   { value: "FLUID_LEAKING", label: "Fluid leaking" },
+  { value: "OTHER", label: "Other" },
 ];
 
 const LABEL: Record<Freight.IncidentType, string> = {
@@ -30,6 +31,7 @@ const LABEL: Record<Freight.IncidentType, string> = {
   CONTAINER_OPENED: "Container opened",
   CONTAINER_DAMAGED: "Container damaged",
   FLUID_LEAKING: "Fluid leaking",
+  OTHER: "Other",
 };
 
 export function IncidentReportCard({ bookingId }: { bookingId: string }) {
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 8686f9cdf..5d1247358 100644
--- a/apps/edr-freight-web/backoffice/src/components/fleet/FleetFormDialog.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/fleet/FleetFormDialog.tsx
@@ -249,6 +249,16 @@ const FleetFormDialog = ({
           }
         }
       }
+
+      // Format check (e.g. plate numbers). Skipped for an empty optional field —
+      // "required" above already owns the empty case. Upper-cased to match the
+      // server, which stores plates upper-case.
+      if (field.pattern && stringValue && stringValue !== FLEET_SELECT_NONE) {
+        const candidate = field.pattern.uppercase === false ? stringValue : stringValue.toUpperCase();
+        if (!field.pattern.regex.test(candidate)) {
+          next[field.name] = field.pattern.message;
+        }
+      }
     });
     setErrors(next);
     return Object.keys(next).length === 0;
diff --git a/apps/edr-freight-web/backoffice/src/components/page/KpiStrip.tsx b/apps/edr-freight-web/backoffice/src/components/page/KpiStrip.tsx
index 4dfd39b0c..6b90d6c8a 100644
--- a/apps/edr-freight-web/backoffice/src/components/page/KpiStrip.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/page/KpiStrip.tsx
@@ -1,6 +1,7 @@
 import { Card, Skeleton, Text } from "@mantine/core";
 import type { LucideIcon } from "lucide-react";
-import type { ReactNode } from "react";
+import type { ElementType, ReactNode } from "react";
+import { Link } from "react-router-dom";
 
 import { cn } from "@/lib/utils";
 
@@ -22,6 +23,11 @@ export interface KpiItem {
    * (green up, red down, muted zero). E.g. today's count minus yesterday's.
    */
   delta?: number;
+  /**
+   * Optional route the cell links to — its detail view. When set the cell
+   * becomes clickable (pointer, hover tint); when absent it stays static.
+   */
+  href?: string;
 }
 
 export interface KpiStripProps {
@@ -47,13 +53,22 @@ export function KpiStrip({ items, loading = false }: KpiStripProps) {
         {cells.map((item, index) => {
           const Icon = item.icon;
           const color = item.color ?? "edr-green";
+          // A cell with an href becomes a link to its detail; without one it
+          // stays a plain div. Same layout classes either way.
+          const Cell: ElementType = item.href ? Link : "div";
+          const linkProps = item.href
+            ? { to: item.href, "aria-label": `${item.label} — view detail` }
+            : {};
           return (
-            <div
+            <Cell
               key={item.label}
+              {...(linkProps as Record<string, unknown>)}
               className={cn(
                 "flex flex-1 items-center gap-3 px-5 py-4",
                 index > 0 &&
                   "border-t border-edr-border sm:border-l sm:border-t-0",
+                item.href &&
+                  "cursor-pointer no-underline transition-colors hover:bg-gray-50 focus-visible:bg-gray-50",
               )}
             >
               {Icon ? (
@@ -102,7 +117,7 @@ export function KpiStrip({ items, loading = false }: KpiStripProps) {
                   {item.hint ? ` · ${item.hint}` : ""}
                 </Text>
               </div>
-            </div>
+            </Cell>
           );
         })}
       </div>
diff --git a/apps/edr-freight-web/backoffice/src/components/trainBuilder/BuildTrainModal.tsx b/apps/edr-freight-web/backoffice/src/components/trainBuilder/BuildTrainModal.tsx
index 925ff528d..810bdc721 100644
--- a/apps/edr-freight-web/backoffice/src/components/trainBuilder/BuildTrainModal.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/trainBuilder/BuildTrainModal.tsx
@@ -46,10 +46,18 @@ export default function BuildTrainModal({ opened, onClose, onBuilt }: BuildTrain
   // Admin-managed run list (dropdown settings); numbers already on a train
   // come back disabled so they cannot be picked twice.
   const importNumbers = useImportTrainNumberOptions();
-  // Only serviceable locomotives standing in the selected yard can be coupled.
+  // Only serviceable locomotives standing in the selected yard, and not already
+  // coupled to another built train, can be picked. A new train owns none yet, so
+  // no train to keep-exclude.
   const locomotivesQuery = useQuery(
     api.locomotives.listFiltered.queryOptions({
-      input: { filters: { status: "AVAILABLE", currentYardId: yardId } },
+      input: {
+        filters: {
+          status: "AVAILABLE",
+          currentYardId: yardId,
+          excludeCoupled: true,
+        },
+      },
       enabled: Boolean(yardId),
     }),
   );
diff --git a/apps/edr-freight-web/backoffice/src/components/trainBuilder/ChangeLocomotivesModal.tsx b/apps/edr-freight-web/backoffice/src/components/trainBuilder/ChangeLocomotivesModal.tsx
index 24ec8ed8b..ef7135bcc 100644
--- a/apps/edr-freight-web/backoffice/src/components/trainBuilder/ChangeLocomotivesModal.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/trainBuilder/ChangeLocomotivesModal.tsx
@@ -26,9 +26,19 @@ export default function ChangeLocomotivesModal({
   const [locomotiveIds, setLocomotiveIds] = useState<string[]>([]);
 
   const yardId = composition?.currentYard?.id ?? "";
+  // A locomotive already coupled to ANOTHER built train is not a valid pick —
+  // the API rejects it on save. Exclude those here (keeping this train's own
+  // ones, which are re-listed below as "(coupled)").
   const availableQuery = useQuery(
     api.locomotives.listFiltered.queryOptions({
-      input: { filters: { status: "AVAILABLE", currentYardId: yardId } },
+      input: {
+        filters: {
+          status: "AVAILABLE",
+          currentYardId: yardId,
+          excludeCoupled: true,
+          excludeTrainId: composition?.id,
+        },
+      },
       enabled: opened && Boolean(yardId),
     }),
   );
diff --git a/apps/edr-freight-web/backoffice/src/components/trainBuilder/trainStatus.ts b/apps/edr-freight-web/backoffice/src/components/trainBuilder/trainStatus.ts
index ef5a661e8..83efa8ff2 100644
--- a/apps/edr-freight-web/backoffice/src/components/trainBuilder/trainStatus.ts
+++ b/apps/edr-freight-web/backoffice/src/components/trainBuilder/trainStatus.ts
@@ -28,6 +28,34 @@ export const trainStatusLabel = (status: BuiltTrainStatus | string): string =>
     .replace(/_/g, " ")
     .replace(/^\w/, (c) => c.toUpperCase());
 
+/** Statuses that block a deactivated train from reactivating (mirrors the API gate). */
+export const UNFIT_LOCOMOTIVE_STATUSES = new Set(["MAINTENANCE", "OUT_OF_SERVICE", "UNAVAILABLE"]);
+
+/** Badge color per locomotive status (Mantine palette keys). */
+export const locomotiveStatusColor = (status: string): string => {
+  switch (status) {
+    case "AVAILABLE":
+    case "IMPORT_READY":
+    case "EXPORT_READY":
+      return "edr-green";
+    case "ASSIGNED":
+      return "blue";
+    case "MAINTENANCE":
+      return "yellow";
+    case "OUT_OF_SERVICE":
+    case "UNAVAILABLE":
+      return "red";
+    default:
+      return "gray";
+  }
+};
+
+export const locomotiveStatusLabel = (status: string): string =>
+  String(status)
+    .toLowerCase()
+    .replace(/_/g, " ")
+    .replace(/^\w/, (c) => c.toUpperCase());
+
 /** Badge color per trade direction (Mantine palette keys). */
 export const directionColor = (direction?: string | null): string =>
   direction === "IMPORT" ? "blue" : direction === "EXPORT" ? "orange" : "gray";
diff --git a/apps/edr-freight-web/backoffice/src/components/trainScheduling/IntercityRideAlongPanel.tsx b/apps/edr-freight-web/backoffice/src/components/trainScheduling/IntercityRideAlongPanel.tsx
index e4512e42a..1f872d1bb 100644
--- a/apps/edr-freight-web/backoffice/src/components/trainScheduling/IntercityRideAlongPanel.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/trainScheduling/IntercityRideAlongPanel.tsx
@@ -97,6 +97,15 @@ function CorridorCell({ row }: { row: IntercityBookingRow }) {
  * confirmed manually when the train is physically at the booking's origin /
  * destination yard (the server validates against recorded checkpoints).
  */
+/** Plain-language journey states for the accepted ride-along table. */
+const INTERCITY_STATUS_META: Record<string, { label: string; color: string }> = {
+  SELECTED_FOR_BATCH: { label: "Awaiting payment", color: "yellow" },
+  APPROVED: { label: "Ready to load (gov)", color: "edr-green" },
+  PAID: { label: "Paid — ready to load", color: "edr-green" },
+  IN_TRANSIT: { label: "Loaded — in transit", color: "indigo" },
+  COMPLETED: { label: "Delivered", color: "teal" },
+};
+
 export function IntercityRideAlongPanel({
   scheduleId,
   direction,
@@ -115,10 +124,20 @@ export function IntercityRideAlongPanel({
     }),
   );
 
-  const invalidate = () =>
-    queryClient.invalidateQueries({
+  // Accepting/loading/unloading a ride-along changes the schedule's booking
+  // list, the yard worklists AND this panel — refresh all three so the
+  // workspace board and yard-work tables never show a stale picture.
+  const invalidate = () => {
+    void queryClient.invalidateQueries({
       queryKey: api.trainScheduling.intercityCandidates.queryKey({ scheduleId }),
     });
+    void queryClient.invalidateQueries({
+      queryKey: api.trainScheduling.yardWork.queryKey({ scheduleId }),
+    });
+    void queryClient.invalidateQueries({
+      queryKey: api.trainScheduling.scheduleDetail.queryKey({ id: scheduleId }),
+    });
+  };
 
   const accept = useMutation(
     api.trainScheduling.acceptIntercityBookings.mutationOptions({
@@ -330,8 +349,14 @@ export function IntercityRideAlongPanel({
                         <CorridorCell row={row} />
                       </Table.Td>
                       <Table.Td>
-                        <Badge size="sm" variant="light">
-                          {row.status}
+                        <Badge
+                          size="sm"
+                          variant="light"
+                          color={
+                            INTERCITY_STATUS_META[row.status ?? ""]?.color ?? "gray"
+                          }
+                        >
+                          {INTERCITY_STATUS_META[row.status ?? ""]?.label ?? row.status}
                         </Badge>
                       </Table.Td>
                       <Table.Td>
diff --git a/apps/edr-freight-web/backoffice/src/components/trainScheduling/ScheduleWorkspacePanel.tsx b/apps/edr-freight-web/backoffice/src/components/trainScheduling/ScheduleWorkspacePanel.tsx
index c7fc49b18..02475214e 100644
--- a/apps/edr-freight-web/backoffice/src/components/trainScheduling/ScheduleWorkspacePanel.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/trainScheduling/ScheduleWorkspacePanel.tsx
@@ -584,6 +584,15 @@ export function ScheduleWorkspacePanel({
                 customer={b.customer}
                 weightTons={b.weightTons}
                 status={b.status}
+                intercity={b.tradeDirection === "DOMESTIC"}
+                leg={
+                  b.origin &&
+                  b.destination &&
+                  (b.originYardId !== schedule.originStation?.id ||
+                    b.destinationYardId !== schedule.destinationStation?.id)
+                    ? `${b.origin} → ${b.destination}`
+                    : null
+                }
                 loadingStatus={b.wagonAssigned ? b.loadingStatus ?? "UNLOADED" : undefined}
                 right={
                   canManage ? (
@@ -840,6 +849,8 @@ function BookingCard({
   status,
   loadingStatus,
   waitingForWagon,
+  intercity,
+  leg,
   right,
 }: {
   reference: string;
@@ -849,6 +860,10 @@ function BookingCard({
   loadingStatus?: "LOADED" | "UNLOADED";
   /** Paid, but no wagon of the required type was free — waiting for one. */
   waitingForWagon?: boolean;
+  /** DOMESTIC ride-along riding only part of this train's corridor. */
+  intercity?: boolean;
+  /** "Origin → Destination" when the booking rides a sub-corridor leg. */
+  leg?: string | null;
   right?: React.ReactNode;
 }) {
   return (
@@ -874,6 +889,16 @@ function BookingCard({
               {reference}
             </Text>
             {status ? <BookingStatusBadge status={status} /> : null}
+            {intercity ? (
+              <Tooltip
+                label="Intercity ride-along — rides only its own leg of this train's corridor"
+                withArrow
+              >
+                <Badge size="sm" radius="sm" variant="filled" color="indigo">
+                  Intercity
+                </Badge>
+              </Tooltip>
+            ) : null}
             {waitingForWagon ? (
               <Tooltip
                 label="Paid, but no wagon of the required type was free. Free a wagon or assign it to a same-day train that has one."
@@ -907,6 +932,11 @@ function BookingCard({
                 </Text>
               </Group>
             ) : null}
+            {leg ? (
+              <Text size="xs" c="indigo.7" fw={600} style={{ whiteSpace: "nowrap" }}>
+                {leg}
+              </Text>
+            ) : null}
           </Group>
         </Stack>
         {right ? <Box style={{ flexShrink: 0 }}>{right}</Box> : null}
diff --git a/apps/edr-freight-web/backoffice/src/components/trainScheduling/WagonPlanGrid.tsx b/apps/edr-freight-web/backoffice/src/components/trainScheduling/WagonPlanGrid.tsx
index e5b63ea24..73297884d 100644
--- a/apps/edr-freight-web/backoffice/src/components/trainScheduling/WagonPlanGrid.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/trainScheduling/WagonPlanGrid.tsx
@@ -2,7 +2,10 @@ import { Badge, Card, Group, Progress, SimpleGrid, Stack, Text, ThemeIcon } from
 import { Box, Package } from "lucide-react";
 import type { TrainScheduleWagonAllocation, WagonPlanRow } from "@/types/trainScheduling";
 
-type WagonSlot = (WagonPlanRow & { physicalWagonNumber?: string | null }) | {
+type WagonSlot = (WagonPlanRow & {
+  physicalWagonNumber?: string | null;
+  tareWeightTons?: number | null;
+}) | {
   sequenceNo: number;
   capacityTons: number;
   assignedWeightTons: number;
diff --git a/apps/edr-freight-web/backoffice/src/components/trainScheduling/YardWorkPanel.tsx b/apps/edr-freight-web/backoffice/src/components/trainScheduling/YardWorkPanel.tsx
index 76ccdfde2..4c649edf8 100644
--- a/apps/edr-freight-web/backoffice/src/components/trainScheduling/YardWorkPanel.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/trainScheduling/YardWorkPanel.tsx
@@ -201,10 +201,19 @@ export function YardWorkPanel({ scheduleId }: { scheduleId: string }) {
     }),
   );
 
-  const invalidate = () =>
-    queryClient.invalidateQueries({
+  // Loading/unloading changes booking status on the schedule detail and the
+  // intercity panel too — refresh all three so no surface shows a stale state.
+  const invalidate = () => {
+    void queryClient.invalidateQueries({
       queryKey: api.trainScheduling.yardWork.queryKey({ scheduleId }),
     });
+    void queryClient.invalidateQueries({
+      queryKey: api.trainScheduling.intercityCandidates.queryKey({ scheduleId }),
+    });
+    void queryClient.invalidateQueries({
+      queryKey: api.trainScheduling.scheduleDetail.queryKey({ id: scheduleId }),
+    });
+  };
 
   const load = useMutation(
     api.trainScheduling.loadScheduleBooking.mutationOptions({
diff --git a/apps/edr-freight-web/backoffice/src/components/trainScheduling/compositionEditor/InteractiveTrainConsist.tsx b/apps/edr-freight-web/backoffice/src/components/trainScheduling/compositionEditor/InteractiveTrainConsist.tsx
index 8ac374c1a..1e1bb706e 100644
--- a/apps/edr-freight-web/backoffice/src/components/trainScheduling/compositionEditor/InteractiveTrainConsist.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/trainScheduling/compositionEditor/InteractiveTrainConsist.tsx
@@ -1,3 +1,4 @@
+import { useState } from "react";
 import { Badge, Box, Group, HoverCard, Stack, Text } from "@mantine/core";
 import {
   Building2,
@@ -14,6 +15,13 @@ import { freightBrand } from "@/theme/freight-brand";
 type Wagon = NonNullable<TrainScheduleDetail["trainSet"]>["wagons"][number];
 type Locomotive = NonNullable<TrainScheduleDetail["trainSet"]>["locomotive"];
 
+export interface WagonLoadMove {
+  sourceWagonId: string;
+  targetWagonId: string;
+}
+
+type DragState = { sourceWagonId: string } | null;
+
 interface InteractiveTrainConsistProps {
   wagons: Wagon[];
   locomotive: Locomotive | null | undefined;
@@ -23,8 +31,16 @@ interface InteractiveTrainConsistProps {
   onSelectWagon: (wagon: Wagon) => void;
   /** Booking id to highlight across the train (e.g. selected in the side panel). */
   highlightBookingId?: string | null;
+  /** Wagon loads become draggable: drop on an empty wagon to move, a loaded one to swap. */
+  canRearrange?: boolean;
+  onMoveLoad?: (move: WagonLoadMove) => void;
 }
 
+const wagonItems = (wagon: Wagon) =>
+  (wagon.allocations ?? [])
+    .flatMap((a) => a.containerItems ?? [])
+    .sort((a, b) => (a.positionOnWagon ?? 99) - (b.positionOnWagon ?? 99));
+
 const CONTAINER_GRADIENTS = [
   "linear-gradient(180deg, var(--mantine-color-cyan-5), var(--mantine-color-cyan-7))",
   "linear-gradient(180deg, var(--mantine-color-blue-5), var(--mantine-color-blue-7))",
@@ -151,16 +167,27 @@ function WagonCar({
   selected,
   highlighted,
   onSelect,
+  drag,
+  onDragChange,
+  onMoveLoad,
+  canRearrange,
 }: {
   wagon: Wagon;
   company: string | null;
   selected: boolean;
   highlighted: boolean;
   onSelect: () => void;
+  drag: DragState;
+  onDragChange: (drag: DragState) => void;
+  onMoveLoad?: (move: WagonLoadMove) => void;
+  canRearrange: boolean;
 }) {
+  const [dropHover, setDropHover] = useState(false);
   const allocation = wagon.allocations?.[0];
   const isEmpty = !allocation;
-  const isBulk = (allocation?.loadType ?? "").toUpperCase().includes("BULK");
+  const isBulk = (wagon.allocations ?? []).some((a) =>
+    (a.loadType ?? "").toUpperCase().includes("BULK"),
+  );
   // GROSS on both sides: cargo + tare vs rated payload + tare.
   const tare = wagon.tareWeightTons ?? 0;
   const assigned =
@@ -170,10 +197,20 @@ function WagonCar({
   const accent = isEmpty ? "gray" : isBulk ? "orange" : "cyan";
   const accentVar = `var(--mantine-color-${accent}-6)`;
 
-  const containerNumbers = (allocation?.containerItems ?? []).map(
-    (c) => c.containerNumber?.trim() || "—",
-  );
-  const blocks = containerNumbers.slice(0, 2);
+  const items = wagonItems(wagon);
+  const blocks = items.slice(0, 2);
+  const containerNumbers = items.map((c) => c.containerNumber?.trim() || "—");
+
+  // The whole load drags as one unit (a 20ft pair never splits). Any OTHER
+  // wagon is a drop target: empty → move (a consist-only wagon repins), loaded
+  // → the two loads swap. The API validates wagon type + payload weight.
+  const draggable = canRearrange && !isEmpty;
+  const beingDragged = drag?.sourceWagonId === wagon.id;
+  const dropEligible = Boolean(drag && !beingDragged);
+  const endDrag = () => {
+    onDragChange(null);
+    setDropHover(false);
+  };
 
   const ringColor = selected
     ? freightBrand.primary
@@ -189,6 +226,21 @@ function WagonCar({
           style={{ width: 120, flexShrink: 0, cursor: "pointer" }}
         >
           <Box
+            onDragOver={(e) => {
+              if (dropEligible) {
+                e.preventDefault();
+                e.dataTransfer.dropEffect = "move";
+                setDropHover(true);
+              }
+            }}
+            onDragLeave={() => setDropHover(false)}
+            onDrop={(e) => {
+              if (dropEligible && drag) {
+                e.preventDefault();
+                onMoveLoad?.({ sourceWagonId: drag.sourceWagonId, targetWagonId: wagon.id });
+              }
+              endDrag();
+            }}
             style={{
               position: "relative",
               height: 70,
@@ -205,10 +257,16 @@ function WagonCar({
                   : isEmpty
                     ? "none"
                     : "0 3px 10px rgba(15,41,27,0.08)",
+              outline: dropHover
+                ? "2px solid var(--mantine-color-cyan-6)"
+                : dropEligible
+                  ? "2px dashed var(--mantine-color-cyan-4)"
+                  : "none",
+              outlineOffset: 2,
               overflow: "hidden",
               display: "flex",
               flexDirection: "column",
-              transition: "box-shadow 120ms ease",
+              transition: "box-shadow 120ms ease, outline-color 120ms ease",
             }}
           >
             {/* top accent strip */}
@@ -243,8 +301,27 @@ function WagonCar({
               )}
             </Group>
 
-            {/* body */}
-            <Box style={{ flex: 1, padding: "3px 7px", display: "flex", alignItems: "center" }}>
+            {/* body — the cargo area is the drag handle for the wagon's whole load */}
+            <Box
+              draggable={draggable}
+              onDragStart={(e) => {
+                e.stopPropagation();
+                e.dataTransfer.effectAllowed = "move";
+                // Firefox needs data set for the drag to start.
+                e.dataTransfer.setData("text/plain", wagon.id);
+                onDragChange({ sourceWagonId: wagon.id });
+              }}
+              onDragEnd={endDrag}
+              style={{
+                flex: 1,
+                padding: "3px 7px",
+                display: "flex",
+                alignItems: "center",
+                cursor: draggable ? "grab" : undefined,
+                opacity: beingDragged ? 0.35 : 1,
+                transition: "opacity 120ms ease",
+              }}
+            >
               {isEmpty ? (
                 <Text size="9px" c="dimmed" ta="center" style={{ width: "100%" }}>
                   Available
@@ -274,28 +351,30 @@ function WagonCar({
                 </Stack>
               ) : (
                 <Group gap={3} justify="center" wrap="nowrap" style={{ width: "100%" }}>
-                  {(blocks.length ? blocks : ["—"]).map((cn, i) => (
-                    <Box
-                      key={i}
-                      style={{
-                        flex: 1,
-                        minWidth: 0,
-                        height: 26,
-                        borderRadius: 4,
-                        background: CONTAINER_GRADIENTS[i % CONTAINER_GRADIENTS.length],
-                        border: `1px solid ${CONTAINER_BORDERS[i % CONTAINER_BORDERS.length]}`,
-                        boxShadow: "inset 0 1px 0 rgba(255,255,255,0.3)",
-                        display: "flex",
-                        alignItems: "center",
-                        justifyContent: "center",
-                        padding: "0 2px",
-                      }}
-                    >
-                      <Text size="8px" fw={700} c="white" truncate style={{ maxWidth: "100%" }}>
-                        {cn}
-                      </Text>
-                    </Box>
-                  ))}
+                  {(blocks.length ? blocks.map((c) => c.containerNumber?.trim() || "—") : ["—"]).map(
+                    (cn, i) => (
+                      <Box
+                        key={i}
+                        style={{
+                          flex: 1,
+                          minWidth: 0,
+                          height: 26,
+                          borderRadius: 4,
+                          background: CONTAINER_GRADIENTS[i % CONTAINER_GRADIENTS.length],
+                          border: `1px solid ${CONTAINER_BORDERS[i % CONTAINER_BORDERS.length]}`,
+                          boxShadow: "inset 0 1px 0 rgba(255,255,255,0.3)",
+                          display: "flex",
+                          alignItems: "center",
+                          justifyContent: "center",
+                          padding: "0 2px",
+                        }}
+                      >
+                        <Text size="8px" fw={700} c="white" truncate style={{ maxWidth: "100%" }}>
+                          {cn}
+                        </Text>
+                      </Box>
+                    ),
+                  )}
                 </Group>
               )}
             </Box>
@@ -447,7 +526,10 @@ export const InteractiveTrainConsist = ({
   selectedWagonId,
   onSelectWagon,
   highlightBookingId,
+  canRearrange = false,
+  onMoveLoad,
 }: InteractiveTrainConsistProps) => {
+  const [drag, setDrag] = useState<DragState>(null);
   return (
     <Box
       style={{
@@ -477,6 +559,10 @@ export const InteractiveTrainConsist = ({
                   selected={selectedWagonId === wagon.id}
                   highlighted={Boolean(highlightBookingId && bookingId === highlightBookingId)}
                   onSelect={() => onSelectWagon(wagon)}
+                  drag={drag}
+                  onDragChange={setDrag}
+                  onMoveLoad={onMoveLoad}
+                  canRearrange={canRearrange}
                 />
               </Group>
             );
diff --git a/apps/edr-freight-web/backoffice/src/components/trainScheduling/compositionEditor/TrainConsistView.tsx b/apps/edr-freight-web/backoffice/src/components/trainScheduling/compositionEditor/TrainConsistView.tsx
index e5b12fe1c..5dd55680b 100644
--- a/apps/edr-freight-web/backoffice/src/components/trainScheduling/compositionEditor/TrainConsistView.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/trainScheduling/compositionEditor/TrainConsistView.tsx
@@ -1,13 +1,15 @@
 import { useMemo, useState } from "react";
 import { Badge, Box, Group, Paper, Stack, Text, ThemeIcon } from "@mantine/core";
-import { MousePointerClick, TrainFront } from "lucide-react";
+import { isAxiosError } from "axios";
+import { Hand, MousePointerClick, TrainFront } from "lucide-react";
 import type { TrainScheduleDetail } from "@/types/trainScheduling";
 import { TrainStatsBar } from "./TrainStatsBar";
 import { WagonCard } from "./WagonCard";
-import { InteractiveTrainConsist } from "./InteractiveTrainConsist";
+import { InteractiveTrainConsist, type WagonLoadMove } from "./InteractiveTrainConsist";
 import { RemoveBookingModal } from "./RemoveBookingModal";
 import { useMutation } from "@tanstack/react-query";
 import { api } from "@/services/api";
+import { useToast } from "@/hooks/use-toast";
 import { freightBrand } from "@/theme/freight-brand";
 
 type Wagon = NonNullable<TrainScheduleDetail["trainSet"]>["wagons"][number];
@@ -47,6 +49,7 @@ export const TrainConsistView = ({
 }: TrainConsistViewProps) => {
   const [selectedWagonId, setSelectedWagonId] = useState<string | null>(null);
   const [removeModalOpen, setRemoveModalOpen] = useState(false);
+  const { toast } = useToast();
 
   const unassignMutation = useMutation(
     api.trainScheduling.unassignBooking.mutationOptions(),
@@ -54,9 +57,38 @@ export const TrainConsistView = ({
   const removeWagonMutation = useMutation(
     api.trainScheduling.removeWagonSlot.mutationOptions(),
   );
+  const moveLoadMutation = useMutation(
+    api.trainScheduling.moveWagonLoad.mutationOptions(),
+  );
 
   const trainSet = scheduleDetail.trainSet;
   const wagons = trainSet?.wagons ?? [];
+  const canRearrange = !["DISPATCHED", "ARRIVED"].includes(scheduleDetail.status);
+
+  const handleMoveLoad = async (move: WagonLoadMove) => {
+    if (moveLoadMutation.isPending) return;
+    const targetLoaded =
+      (wagons.find((w) => w.id === move.targetWagonId)?.allocations?.length ?? 0) > 0;
+    try {
+      await moveLoadMutation.mutateAsync({
+        scheduleId,
+        wagonId: move.sourceWagonId,
+        targetWagonId: move.targetWagonId,
+      });
+      toast({ title: targetLoaded ? "Wagon loads swapped" : "Load moved" });
+    } catch (error) {
+      const message = isAxiosError(error)
+        ? ((error.response?.data as { message?: string | string[] } | undefined)?.message ?? null)
+        : null;
+      toast({
+        title: "Could not move the load",
+        description: Array.isArray(message)
+          ? message.join(", ")
+          : (message ?? "The move was rejected — check the wagon's type and payload."),
+        variant: "destructive",
+      });
+    }
+  };
 
   // Join company/customer name from schedule bookings by booking id.
   const companyByBooking = useMemo(() => {
@@ -152,13 +184,21 @@ export const TrainConsistView = ({
             </div>
           </Group>
           <Group gap="md" wrap="nowrap" visibleFrom="sm">
+            {canRearrange ? (
+              <Group gap={5} wrap="nowrap">
+                <Hand size={12} color="var(--mantine-color-cyan-7)" />
+                <Text size="xs" c="dimmed">
+                  Drag a wagon's cargo onto an empty wagon to move it — onto a loaded one to swap
+                </Text>
+              </Group>
+            ) : null}
             <LegendDot color="cyan" label="Container" />
             <LegendDot color="orange" label="Bulk" />
             <LegendDot color="gray" label="Empty" dashed />
           </Group>
         </Group>
 
-        <Box p="md">
+        <Box p="md" style={{ opacity: moveLoadMutation.isPending ? 0.6 : 1 }}>
           <InteractiveTrainConsist
             wagons={wagons}
             locomotive={trainSet?.locomotive}
@@ -166,6 +206,8 @@ export const TrainConsistView = ({
             selectedWagonId={selectedWagonId}
             onSelectWagon={(w) => setSelectedWagonId((prev) => (prev === w.id ? null : w.id))}
             highlightBookingId={highlightBookingId}
+            canRearrange={canRearrange && !moveLoadMutation.isPending}
+            onMoveLoad={(move) => void handleMoveLoad(move)}
           />
         </Box>
       </Paper>
@@ -178,7 +220,7 @@ export const TrainConsistView = ({
               Editing wagon #{selectedWagon.sequenceNo}
             </Badge>
             <Text size="xs" c="dimmed">
-              Update container numbers or remove the booking
+              Update container numbers, move containers to another wagon, or remove the booking
             </Text>
           </Group>
           <WagonCard
@@ -192,6 +234,8 @@ export const TrainConsistView = ({
             scheduleStatus={scheduleDetail.status}
             onRemoveBooking={handleRemoveBooking}
             onRemoveWagon={handleRemoveWagon}
+            wagons={wagons}
+            onMoveLoad={canRearrange ? (move) => void handleMoveLoad(move) : undefined}
           />
         </Box>
       ) : wagons.length ? (
@@ -209,7 +253,8 @@ export const TrainConsistView = ({
               <MousePointerClick size={13} />
             </ThemeIcon>
             <Text size="xs" c="dimmed">
-              Click a wagon in the train to edit container numbers or remove its booking.
+              Click a wagon to edit its containers — or drag a container between wagons to
+              rearrange the load.
             </Text>
           </Group>
         </Paper>
diff --git a/apps/edr-freight-web/backoffice/src/components/trainScheduling/compositionEditor/WagonCard.tsx b/apps/edr-freight-web/backoffice/src/components/trainScheduling/compositionEditor/WagonCard.tsx
index 915cfa629..d1d1e8d0b 100644
--- a/apps/edr-freight-web/backoffice/src/components/trainScheduling/compositionEditor/WagonCard.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/trainScheduling/compositionEditor/WagonCard.tsx
@@ -1,5 +1,17 @@
-import { Badge, Box, Button, Card, Group, Progress, Stack, Text, ThemeIcon } from "@mantine/core";
 import {
+  Badge,
+  Box,
+  Button,
+  Card,
+  Group,
+  Menu,
+  Progress,
+  Stack,
+  Text,
+  ThemeIcon,
+} from "@mantine/core";
+import {
+  ArrowLeftRight,
   Building2,
   Container as ContainerIcon,
   Fuel,
@@ -10,6 +22,7 @@ import {
 } from "lucide-react";
 import type { TrainScheduleDetail } from "@/types/trainScheduling";
 import { ContainerNumberInput } from "./ContainerNumberInput";
+import type { WagonLoadMove } from "./InteractiveTrainConsist";
 import { freightBrand } from "@/theme/freight-brand";
 
 type Wagon = NonNullable<TrainScheduleDetail["trainSet"]>["wagons"][number];
@@ -21,8 +34,16 @@ interface WagonCardProps {
   scheduleStatus?: string;
   onRemoveBooking: (wagon: Wagon) => void;
   onRemoveWagon: (wagonId: string) => void;
+  /** All wagons of the consist — targets for the move-load menu. */
+  wagons?: Wagon[];
+  onMoveLoad?: (move: WagonLoadMove) => void;
 }
 
+const itemAllocCount = (w: Wagon) => w.allocations?.length ?? 0;
+
+const isBulkWagon = (w: Wagon) =>
+  (w.allocations ?? []).some((a) => (a.loadType ?? "").toUpperCase().includes("BULK"));
+
 export const WagonCard = ({
   wagon,
   company,
@@ -30,6 +51,8 @@ export const WagonCard = ({
   scheduleStatus,
   onRemoveBooking,
   onRemoveWagon,
+  wagons,
+  onMoveLoad,
 }: WagonCardProps) => {
   const isDispatched = scheduleStatus === "DISPATCHED";
   const allocation = wagon.allocations?.[0];
@@ -153,16 +176,62 @@ export const WagonCard = ({
             </Box>
 
             {!isDispatched ? (
-              <Button
-                variant="light"
-                color="red"
-                size="xs"
-                leftSection={<X size={14} />}
-                onClick={() => onRemoveBooking(wagon)}
-                fullWidth
-              >
-                Remove booking
-              </Button>
+              <Group gap="xs" grow>
+                {onMoveLoad ? (
+                  <Menu shadow="md" width={240} position="bottom" withinPortal>
+                    <Menu.Target>
+                      <Button
+                        variant="light"
+                        color="cyan"
+                        size="xs"
+                        leftSection={<ArrowLeftRight size={14} />}
+                      >
+                        Move load
+                      </Button>
+                    </Menu.Target>
+                    <Menu.Dropdown>
+                      <Menu.Label>Move this wagon's load to</Menu.Label>
+                      {(wagons ?? [])
+                        .filter((w) => w.id !== wagon.id)
+                        .sort((a, b) => itemAllocCount(a) - itemAllocCount(b))
+                        .map((w) => {
+                          const loaded = itemAllocCount(w) > 0;
+                          return (
+                            <Menu.Item
+                              key={w.id}
+                              onClick={() =>
+                                onMoveLoad({ sourceWagonId: wagon.id, targetWagonId: w.id })
+                              }
+                            >
+                              <Group gap={6} wrap="nowrap" justify="space-between">
+                                <Text size="xs" fw={600} truncate>
+                                  #{w.sequenceNo} ·{" "}
+                                  {w.physicalWagonNumber ?? w.wagonType?.code ?? "Wagon"}
+                                </Text>
+                                <Badge
+                                  size="xs"
+                                  variant="light"
+                                  color={loaded ? (isBulkWagon(w) ? "orange" : "cyan") : "gray"}
+                                >
+                                  {loaded ? "swap" : "empty"}
+                                </Badge>
+                              </Group>
+                            </Menu.Item>
+                          );
+                        })}
+                    </Menu.Dropdown>
+                  </Menu>
+                ) : null}
+                <Button
+                  variant="light"
+                  color="red"
+                  size="xs"
+                  leftSection={<X size={14} />}
+                  onClick={() => onRemoveBooking(wagon)}
+                >
+                  Remove booking
+                </Button>
+              </Group>
             ) : null}
           </>
         ) : (
diff --git a/apps/edr-freight-web/backoffice/src/components/trainScheduling/scheduleVisuals.tsx b/apps/edr-freight-web/backoffice/src/components/trainScheduling/scheduleVisuals.tsx
index a495a5529..f6bc9b387 100644
--- a/apps/edr-freight-web/backoffice/src/components/trainScheduling/scheduleVisuals.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/trainScheduling/scheduleVisuals.tsx
@@ -280,3 +280,135 @@ export function RouteCorridor({
     </Group>
   );
 }
+
+/** Minimal booking shape the occupancy strip needs from TrainScheduleDetail. */
+export type SegmentStripBooking = {
+  originYardId?: string | null;
+  destinationYardId?: string | null;
+  tradeDirection?: string | null;
+  wagonsRequired?: number | null;
+};
+
+/**
+ * Per-segment wagon occupancy along the corridor: which legs are full and
+ * which still run empty. Through cargo (unknown/off-route yards) occupies the
+ * whole corridor; a ride-along counts only on its own leg — this is what makes
+ * "export full Adama→Doraleh, intercity riding Gelan→Adama" legible at a
+ * glance instead of two disconnected booking lists.
+ */
+export function SegmentOccupancyStrip({
+  stops,
+  bookings,
+  maxWagons,
+}: {
+  stops: Array<{ yardId: string; label: string }>;
+  bookings: SegmentStripBooking[];
+  maxWagons?: number | null;
+}) {
+  if (stops.length < 2) return null;
+  const lastIdx = stops.length - 1;
+  const indexOf = new Map(stops.map((s, i) => [s.yardId, i]));
+
+  const segments = stops.slice(0, -1).map((stop, edge) => {
+    let cargo = 0;
+    let intercity = 0;
+    for (const b of bookings) {
+      const from = (b.originYardId ? indexOf.get(b.originYardId) : undefined) ?? 0;
+      const to =
+        (b.destinationYardId ? indexOf.get(b.destinationYardId) : undefined) ??
+        lastIdx;
+      const rides = from <= edge && edge < (to > from ? to : lastIdx);
+      if (!rides) continue;
+      const wagons = Number(b.wagonsRequired) || 1;
+      if (b.tradeDirection === "DOMESTIC") intercity += wagons;
+      else cargo += wagons;
+    }
+    return { from: stop, to: stops[edge + 1], cargo, intercity };
+  });
+
+  const cap = Number(maxWagons) || null;
+
+  return (
+    <Group gap={0} wrap="nowrap" align="stretch" style={{ overflowX: "auto", paddingBottom: 4 }}>
+      {segments.map((seg, i) => {
+        const used = seg.cargo + seg.intercity;
+        const pct = cap ? Math.min(100, Math.round((used / cap) * 100)) : null;
+        const full = cap != null && used >= cap;
+        return (
+          <Group key={seg.from.yardId} gap={0} wrap="nowrap" align="stretch">
+            <Stack gap={2} align="center" justify="flex-end" style={{ minWidth: 0 }}>
+              <Box
+                w={9}
+                h={9}
+                style={{
+                  borderRadius: 999,
+                  border: `2px solid ${freightBrand.primary}`,
+                  background: i === 0 ? "white" : freightBrand.primary,
+                }}
+              />
+              <Text size="xs" fw={600} style={{ whiteSpace: "nowrap" }}>
+                {seg.from.label}
+              </Text>
+            </Stack>
+            <Stack gap={3} px={10} pb={16} justify="flex-end" style={{ minWidth: 130 }}>
+              <Text size="xs" ta="center" fw={600} c={full ? "orange.8" : "dimmed"}>
+                {used}
+                {cap ? `/${cap}` : ""} wagons
+                {full ? " · full" : ""}
+              </Text>
+              <Box
+                style={{
+                  height: 6,
+                  borderRadius: 999,
+                  background: "var(--mantine-color-gray-2)",
+                  overflow: "hidden",
+                  display: "flex",
+                }}
+              >
+                {cap ? (
+                  <>
+                    <Box
+                      style={{
+                        width: `${Math.min(100, (seg.cargo / cap) * 100)}%`,
+                        background: freightBrand.primary,
+                      }}
+                    />
+                    <Box
+                      style={{
+                        width: `${Math.min(100, (seg.intercity / cap) * 100)}%`,
+                        background: "var(--mantine-color-indigo-6)",
+                      }}
+                    />
+                  </>
+                ) : (
+                  <Box style={{ width: pct ? `${pct}%` : 0 }} />
+                )}
+              </Box>
+              <Text size="xs" ta="center" c="dimmed" style={{ whiteSpace: "nowrap" }}>
+                {seg.cargo} cargo
+                {seg.intercity > 0 ? (
+                  <Text span size="xs" fw={700} c="indigo.7">
+                    {" "}
+                    · {seg.intercity} intercity
+                  </Text>
+                ) : null}
+              </Text>
+            </Stack>
+            {i === segments.length - 1 ? (
+              <Stack gap={2} align="center" justify="flex-end" style={{ minWidth: 0 }}>
+                <Box
+                  w={9}
+                  h={9}
+                  style={{ borderRadius: 999, background: freightBrand.primary }}
+                />
+                <Text size="xs" fw={600} style={{ whiteSpace: "nowrap" }}>
+                  {seg.to.label}
+                </Text>
+              </Stack>
+            ) : null}
+          </Group>
+        );
+      })}
+    </Group>
+  );
+}
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 93c3bf64e..41e5fcc81 100644
--- a/apps/edr-freight-web/backoffice/src/components/warehouses/ReceiveInventoryModal.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/warehouses/ReceiveInventoryModal.tsx
@@ -2647,7 +2647,9 @@ function ImportUnloadedQueueTab({ enabled }: { enabled: boolean }) {
                         </ActionIcon>
                       </Tooltip>
                       {/* Primary stage action stays visible; the rest live under the kebab. */}
-                      {r.currentStatus === 'READY_FOR_PICKUP' && !r.releaseDate && r.hasAssignedTruck && (
+                      {/* Stays visible after the first exit — multi-truck bookings
+                          weigh each truck in and out until all have left. */}
+                      {r.currentStatus === 'READY_FOR_PICKUP' && r.hasAssignedTruck && (
                         <Button
                           size="compact-xs"
                           variant="light"
@@ -2655,7 +2657,7 @@ function ImportUnloadedQueueTab({ enabled }: { enabled: boolean }) {
                           leftSection={<Truck size={14} />}
                           onClick={() => setReleaseItem(toInventoryItem(r))}
                         >
-                          {r.releaseOrderReference ? 'Truck Leaving' : 'Truck Arrival'}
+                          {r.releaseOrderReference ? 'Truck Arrival / Leaving' : 'Truck Arrival'}
                         </Button>
                       )}
                       {r.currentStatus === 'READY_FOR_PICKUP' && r.releaseDate && (
@@ -2692,7 +2694,7 @@ function ImportUnloadedQueueTab({ enabled }: { enabled: boolean }) {
                               Ready for pickup
                             </Menu.Item>
                           )}
-                          {r.currentStatus === 'READY_FOR_PICKUP' && !r.releaseDate && (
+                          {r.currentStatus === 'READY_FOR_PICKUP' && (
                             <Menu.Item
                               leftSection={<Truck size={14} />}
                               disabled={!r.hasAssignedTruck}
@@ -2700,7 +2702,7 @@ function ImportUnloadedQueueTab({ enabled }: { enabled: boolean }) {
                             >
                               {r.hasAssignedTruck
                                 ? r.releaseOrderReference
-                                  ? 'Truck leaving'
+                                  ? 'Truck arrival / leaving'
                                   : 'Truck arrival'
                                 : 'Truck arrival — assign a truck first'}
                             </Menu.Item>
diff --git a/apps/edr-freight-web/backoffice/src/components/warehouses/ReleaseOrderModal.tsx b/apps/edr-freight-web/backoffice/src/components/warehouses/ReleaseOrderModal.tsx
index 5f0a8a092..fcced78d9 100644
--- a/apps/edr-freight-web/backoffice/src/components/warehouses/ReleaseOrderModal.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/warehouses/ReleaseOrderModal.tsx
@@ -1,8 +1,8 @@
-import { useEffect, useState } from 'react';
-import { Alert, Button, Group, Modal, MultiSelect, NumberInput, SegmentedControl, Select, SimpleGrid, Stack, Text, TextInput } from '@mantine/core';
-import { Info, Scale } from 'lucide-react';
+import { useEffect, useRef, useState } from 'react';
+import { Alert, Badge, Button, Group, Modal, MultiSelect, NumberInput, SegmentedControl, Select, SimpleGrid, Stack, Text, TextInput } from '@mantine/core';
+import { Info, Scale, Truck } from 'lucide-react';
 
-import { useMutation, useQuery } from '@tanstack/react-query';
+import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
 
 import { api } from '@/services/api';
 import { useToast } from '@/hooks/use-toast';
@@ -28,6 +28,8 @@ export interface ReleaseOrderTruckPrefill {
   containerNumber?: string | null;
 }
 
+const EXIT_INSPECTION_MARKER = '[Exit Inspection]';
+
 const toIsoDateTime = (value: string) => {
   if (!value) return undefined;
   const date = new Date(value);
@@ -70,9 +72,6 @@ const splitContainerNumbers = (value: string | null | undefined) =>
 const getItemContainerNumber = (item: WarehouseInventoryItem | null) =>
   (item as (WarehouseInventoryItem & { containerNumber?: string | null }) | null)?.containerNumber ?? '';
 
-const assignedTruckValue = (item: WarehouseInventoryItem | null, key: keyof NonNullable<WarehouseInventoryItem['booking']>) =>
-  item?.booking?.[key] == null ? '' : String(item.booking[key]);
-
 const isContainerInventory = (item: WarehouseInventoryItem | null, containerCount: number) => {
   const freightType = (item as (WarehouseInventoryItem & { booking?: { freightType?: string | null } | null }) | null)
     ?.booking?.freightType;
@@ -88,29 +87,66 @@ const initialContainerNumbers = (item: WarehouseInventoryItem | null, savedConta
   return Array.from({ length: expectedCount }, (_, index) => sourceNumbers[index] ?? '');
 };
 
-const parseInspectionNote = (notes: string | null | undefined) => {
-  const marker = '[Exit Inspection]';
-  const index = notes?.lastIndexOf(marker) ?? -1;
-  const note = index >= 0 ? notes?.slice(index + marker.length) : notes;
-  return {
-    truckPlateNumber: lineValue(note, 'Truck Plate'),
-    trailerPlateNumber: lineValue(note, 'Trailer Plate'),
-    driverName: lineValue(note, 'Driver'),
-    driverLicense: lineValue(note, 'Driver License'),
-    driverPhone: lineValue(note, 'Driver Phone'),
-    truckType: lineValue(note, 'Truck Type'),
-    containerNumber: lineValue(note, 'Container Number'),
-    gateInTime: toLocalDateTimeInput(lineValue(note, 'Gate In Time')),
-    tareWeight: lineNumber(note, 'Tare Weight'),
-    grossWeight: lineNumber(note, 'Gross Weight'),
-    netWeight: lineNumber(note, 'Net Weight'),
-    gateOutTime: toLocalDateTimeInput(lineValue(note, 'Gate Out Time')),
-    weighingSkipped: /^Weighing:\s*SKIPPED/im.test(note ?? ''),
-  };
+/** One truck's saved arrival/exit weighing, parsed from its inspection block. */
+interface InspectionBlock {
+  truckPlateNumber: string;
+  trailerPlateNumber: string;
+  driverName: string;
+  driverLicense: string;
+  driverPhone: string;
+  truckType: string;
+  containerNumber: string;
+  gateInTime: string;
+  tareWeight: number | '';
+  grossWeight: number | '';
+  netWeight: number | '';
+  gateOutTime: string;
+  weighingSkipped: boolean;
+}
+
+const parseInspectionSection = (note: string): InspectionBlock => ({
+  truckPlateNumber: lineValue(note, 'Truck Plate'),
+  trailerPlateNumber: lineValue(note, 'Trailer Plate'),
+  driverName: lineValue(note, 'Driver'),
+  driverLicense: lineValue(note, 'Driver License'),
+  driverPhone: lineValue(note, 'Driver Phone'),
+  truckType: lineValue(note, 'Truck Type'),
+  containerNumber: lineValue(note, 'Container Number'),
+  gateInTime: toLocalDateTimeInput(lineValue(note, 'Gate In Time')),
+  tareWeight: lineNumber(note, 'Tare Weight'),
+  grossWeight: lineNumber(note, 'Gross Weight'),
+  netWeight: lineNumber(note, 'Net Weight'),
+  gateOutTime: toLocalDateTimeInput(lineValue(note, 'Gate Out Time')),
+  weighingSkipped: /^Weighing:\s*SKIPPED/im.test(note),
+});
+
+/** Every truck's saved block — multi-truck bookings weigh each truck separately. */
+const parseInspectionBlocks = (notes: string | null | undefined): InspectionBlock[] =>
+  (notes ?? '')
+    .split(EXIT_INSPECTION_MARKER)
+    .slice(1)
+    .map(parseInspectionSection)
+    .filter((block) => block.truckPlateNumber);
+
+/** Match by plate; a legacy block may hold a comma-joined plate list. */
+const blockForPlate = (blocks: InspectionBlock[], plate: string): InspectionBlock | undefined => {
+  const key = plate.trim().toUpperCase();
+  if (!key) return undefined;
+  return blocks.find((block) => {
+    const stored = block.truckPlateNumber.toUpperCase();
+    return stored === key || stored.split(/[,;]+/).map((p) => p.trim()).includes(key);
+  });
 };
 
+const blockArrived = (block: InspectionBlock | undefined) =>
+  Boolean(block && (block.tareWeight !== '' || block.weighingSkipped));
+
+const blockLeft = (block: InspectionBlock | undefined) =>
+  Boolean(block?.gateOutTime && (block.grossWeight !== '' || block.weighingSkipped));
+
 export function ReleaseOrderModal({ opened, onClose, item, truckPrefill }: ReleaseOrderModalProps) {
   const { toast } = useToast();
+  const queryClient = useQueryClient();
   const releaseMutation = useMutation(api.warehouses.release.mutationOptions());
   // Some openers (inventory workbench) supply bookingId without the booking
   // relation — fall back to it, or the truck/container-weight queries never run.
@@ -152,78 +188,16 @@ export function ReleaseOrderModal({ opened, onClose, item, truckPrefill }: Relea
   const [netWeight, setNetWeight] = useState<number | ''>('');
   const [gateOutTime, setGateOutTime] = useState('');
   const [downloading, setDownloading] = useState(false);
+  // Plate whose saved block was last loaded into the form — stops the
+  // per-plate loader effect from clobbering operator edits in a loop.
+  const loadedPlateRef = useRef<string | null>(null);
 
-  useEffect(() => {
-    if (opened) {
-      const inspection = parseInspectionNote(item?.notes);
-      const assignedTruckPlate = assignedTruckValue(item, 'customerTruckPlateNumber');
-      const assignedDriverName = assignedTruckValue(item, 'customerTruckDriverName');
-      const assignedTruckType = assignedTruckValue(item, 'customerTruckType');
-      const assignedContainerNumber = assignedTruckValue(item, 'customerTruckContainerNumber');
-      const prefillContainerNumber = truckPrefill?.containerNumber ?? '';
-      setReference(item?.releaseOrderReference ?? generateReleaseReference(item));
-      setTruckPlateNumber(inspection.truckPlateNumber || truckPrefill?.truckPlateNumber || assignedTruckPlate || '');
-      setTrailerPlateNumber(inspection.trailerPlateNumber || truckPrefill?.trailerPlateNumber || '');
-      setDriverName(inspection.driverName || truckPrefill?.driverName || assignedDriverName || '');
-      setDriverLicense(inspection.driverLicense || truckPrefill?.driverLicense || '');
-      setDriverPhone(inspection.driverPhone || truckPrefill?.driverPhone || '');
-      setTruckType(inspection.truckType || truckPrefill?.truckType || assignedTruckType || '');
-      setContainerNumbers(initialContainerNumbers(item, inspection.containerNumber || prefillContainerNumber || assignedContainerNumber));
-      setGateInTime(inspection.gateInTime);
-      setTareWeight(inspection.tareWeight);
-      setWeighTruck(inspection.weighingSkipped ? 'no' : 'yes');
-      setGrossWeight(inspection.grossWeight);
-      setNetWeight(item?.weight == null ? inspection.netWeight : Number(item.weight));
-      setGateOutTime(inspection.gateOutTime);
-    }
-  }, [opened, item, truckPrefill]);
-
-  const savedInspection = parseInspectionNote(item?.notes);
-  const isExitStep = savedInspection.tareWeight !== '' || savedInspection.weighingSkipped;
-  const isEntranceLocked = isExitStep;
-  const isCustomerAssignedTruck = Boolean(item?.booking?.customerTruckAssignedAt);
-  const hasLastMileTruckPrefill = Boolean(truckPrefill?.truckPlateNumber || truckPrefill?.trailerPlateNumber);
-
-  // Opened from the warehouse flow (no truckPrefill prop): once the last-mile
-  // truck query resolves, auto-fill the first assigned EDR truck — without
-  // overwriting anything the operator typed or the locked exit-step values.
-  useEffect(() => {
-    if (!opened || truckPrefill || isExitStep) return;
-    const first = lastMileTrucks[0];
-    if (!first) return;
-    setTruckPlateNumber((p) => p || first.truckPlateNumber || '');
-    setTrailerPlateNumber((p) => p || first.trailerPlateNumber || '');
-    setDriverName((p) => p || first.driverName || '');
-    setDriverLicense((p) => p || first.driverLicense || '');
-    setDriverPhone((p) => p || first.driverPhone || '');
-    setTruckType((p) => p || first.truckType || '');
-    setContainerNumbers((prev) =>
-      prev.length === 1 && !prev[0] && first.containerNumber ? [first.containerNumber] : prev,
-    );
-  }, [opened, truckPrefill, isExitStep, lastMileTrucks]);
-
-  // The same for a customer self-haul truck. The prefill above reads the
-  // booking.customer_truck_* columns, but multi-truck self-haul writes the plate
-  // and driver to customer_truck_assignments and leaves those columns null — so
-  // a booking with a truck on file still opened this form blank. Only auto-fills
-  // a single truck: with several, the operator picks which one is at the gate.
-  useEffect(() => {
-    if (!opened || truckPrefill || isExitStep) return;
-    if (customerTrucks.length !== 1) return;
-    const [truck] = customerTrucks;
-    setTruckPlateNumber((p) => p || truck.plateNumber || '');
-    setDriverName((p) => p || truck.driverName || '');
-    setTruckType((p) => p || truck.truckType || '');
-    setContainerNumbers((prev) => {
-      const loaded = (truck.containers ?? []).map((c) => c.containerNumber).filter(Boolean);
-      return prev.every((n) => !n) && loaded.length ? loaded : prev;
-    });
-  }, [opened, truckPrefill, isExitStep, customerTrucks]);
+  const savedBlocks = parseInspectionBlocks(item?.notes);
 
   // Registered trucks for THIS booking, from both sources: EDR last-mile
   // (truckPrefill) and the customer portal (customer_truck_assignments).
   const assignedTruckOptions = [
-    ...(truckPrefill?.truckPlateNumber
+    ...(truckPrefill?.truckPlateNumber && !truckPrefill.truckPlateNumber.includes(',')
       ? [
           {
             value: truckPrefill.truckPlateNumber,
@@ -232,6 +206,9 @@ export function ReleaseOrderModal({ opened, onClose, item, truckPrefill }: Relea
             driverName: truckPrefill.driverName ?? '',
             driverPhone: truckPrefill.driverPhone ?? '',
             truckType: truckPrefill.truckType ?? '',
+            containerNumbers: splitContainerNumbers(truckPrefill.containerNumber),
+            arrived: false,
+            left: false,
           },
         ]
       : []),
@@ -242,6 +219,9 @@ export function ReleaseOrderModal({ opened, onClose, item, truckPrefill }: Relea
       driverName: t.driverName,
       driverPhone: '',
       truckType: t.truckType,
+      containerNumbers: (t.containers ?? []).map((c) => c.containerNumber).filter(Boolean),
+      arrived: Boolean(t.arrivedAt),
+      left: Boolean(t.departedAt),
     })),
     ...lastMileTrucks
       .filter((t) => t.truckPlateNumber || t.vehicleId)
@@ -252,6 +232,9 @@ export function ReleaseOrderModal({ opened, onClose, item, truckPrefill }: Relea
         driverName: t.driverName ?? '',
         driverPhone: t.driverPhone ?? '',
         truckType: t.truckType ?? '',
+        containerNumbers: splitContainerNumbers(t.containerNumber),
+        arrived: Boolean(t.arrivedAt),
+        left: Boolean(t.departedAt),
       })),
   ];
   // Only trucks actually assigned to THIS booking (last-mile prefill or customer
@@ -261,10 +244,132 @@ export function ReleaseOrderModal({ opened, onClose, item, truckPrefill }: Relea
   const truckSelectOptions = [
     ...new Map(assignedTruckOptions.map((t) => [t.value, t])).values(),
   ];
+  const isCustomerAssignedTruck = Boolean(item?.booking?.customerTruckAssignedAt);
   // Neither a last-mile truck nor a customer truck has been assigned yet.
   const noTruckAssigned = assignedTruckOptions.length === 0 && !isCustomerAssignedTruck;
-  const isTruckIdentityLocked = isEntranceLocked || isCustomerAssignedTruck || hasLastMileTruckPrefill;
-  const isDriverNameLocked = isEntranceLocked || isCustomerAssignedTruck || Boolean(truckPrefill?.driverName);
+
+  // Per-truck progress: every truck is weighed in and out on its own; the saved
+  // blocks also cover walk-in trucks that were never formally assigned.
+  const truckProgress = new Map<string, { arrived: boolean; left: boolean }>();
+  for (const option of truckSelectOptions) {
+    truckProgress.set(option.value.trim().toUpperCase(), { arrived: option.arrived, left: option.left });
+  }
+  for (const block of savedBlocks) {
+    const key = block.truckPlateNumber.trim().toUpperCase();
+    const prior = truckProgress.get(key);
+    truckProgress.set(key, {
+      arrived: Boolean(prior?.arrived) || blockArrived(block),
+      left: Boolean(prior?.left) || blockLeft(block),
+    });
+  }
+  const totalTrucks = truckProgress.size;
+  const arrivedTrucks = [...truckProgress.values()].filter((t) => t.arrived).length;
+  const leftTrucks = [...truckProgress.values()].filter((t) => t.left).length;
+
+  // The step is decided PER TRUCK: the selected plate's saved block. A new plate
+  // (or a truck without a saved arrival) starts at the arrival step even when
+  // other trucks of the booking are already mid-flow or gone.
+  const selectedBlock = blockForPlate(savedBlocks, truckPlateNumber);
+  const isExitStep = blockArrived(selectedBlock);
+  const hasTruckLeft = blockLeft(selectedBlock);
+  const isEntranceLocked = isExitStep;
+  const selectedOption = truckSelectOptions.find(
+    (option) => option.value.trim().toUpperCase() === truckPlateNumber.trim().toUpperCase(),
+  );
+  // Identity comes from the arrival record or the assignment — locked either
+  // way. A walk-in truck (typed plate, no assignment) stays editable at arrival.
+  const isTruckIdentityLocked = isEntranceLocked || Boolean(selectedOption);
+  const isDriverNameLocked = isEntranceLocked || Boolean(selectedOption?.driverName);
+  const referenceLocked = Boolean(item?.releaseOrderReference) || savedBlocks.length > 0;
+
+  /** Load a truck into the form: its saved block if any, else its assignment. */
+  const applyTruckSelection = (plate: string) => {
+    const block = blockForPlate(savedBlocks, plate);
+    const option = truckSelectOptions.find(
+      (o) => o.value.trim().toUpperCase() === plate.trim().toUpperCase(),
+    );
+    loadedPlateRef.current = plate.trim().toUpperCase();
+    setTruckPlateNumber(plate);
+    setTrailerPlateNumber(block?.trailerPlateNumber || option?.trailerPlate || '');
+    setDriverName(block?.driverName || option?.driverName || '');
+    setDriverLicense(block?.driverLicense || '');
+    setDriverPhone(block?.driverPhone || option?.driverPhone || '');
+    setTruckType(block?.truckType || option?.truckType || '');
+    const loaded = block
+      ? splitContainerNumbers(block.containerNumber)
+      : (option?.containerNumbers ?? []);
+    setContainerNumbers(loaded.length ? loaded : initialContainerNumbers(item, ''));
+    setGateInTime(block?.gateInTime ?? '');
+    setTareWeight(block?.tareWeight ?? '');
+    setWeighTruck(block?.weighingSkipped ? 'no' : 'yes');
+    setGrossWeight(block?.grossWeight ?? '');
+    setNetWeight(block?.netWeight ?? (item?.weight == null ? '' : Number(item.weight)));
+    setGateOutTime(block?.gateOutTime ?? '');
+  };
+
+  useEffect(() => {
+    if (opened) {
+      loadedPlateRef.current = null;
+      setReference(item?.releaseOrderReference ?? generateReleaseReference(item));
+      // Initial truck: the caller's prefill, else the first truck still mid-flow
+      // (arrived but not left) — the operator can switch trucks in the select.
+      const prefillPlate =
+        truckPrefill?.truckPlateNumber && !truckPrefill.truckPlateNumber.includes(',')
+          ? truckPrefill.truckPlateNumber
+          : '';
+      const blocks = parseInspectionBlocks(item?.notes);
+      const inProgress = blocks.find((block) => blockArrived(block) && !blockLeft(block));
+      // Legacy single-truck bookings stored the truck on the booking columns; a
+      // comma-joined value means several trucks, so the operator picks instead.
+      const bookingPlate = item?.booking?.customerTruckPlateNumber ?? '';
+      const legacyPlate = bookingPlate && !bookingPlate.includes(',') ? bookingPlate : '';
+      const initialPlate = prefillPlate || inProgress?.truckPlateNumber || legacyPlate || '';
+      const block = blockForPlate(blocks, initialPlate);
+      loadedPlateRef.current = initialPlate ? initialPlate.trim().toUpperCase() : null;
+      setTruckPlateNumber(initialPlate);
+      setTrailerPlateNumber(block?.trailerPlateNumber || truckPrefill?.trailerPlateNumber || '');
+      setDriverName(
+        block?.driverName ||
+          truckPrefill?.driverName ||
+          (legacyPlate && initialPlate === legacyPlate ? (item?.booking?.customerTruckDriverName ?? '') : ''),
+      );
+      setDriverLicense(block?.driverLicense || truckPrefill?.driverLicense || '');
+      setDriverPhone(block?.driverPhone || truckPrefill?.driverPhone || '');
+      setTruckType(
+        block?.truckType ||
+          truckPrefill?.truckType ||
+          (legacyPlate && initialPlate === legacyPlate ? (item?.booking?.customerTruckType ?? '') : ''),
+      );
+      setContainerNumbers(
+        initialContainerNumbers(item, block?.containerNumber || truckPrefill?.containerNumber || ''),
+      );
+      setGateInTime(block?.gateInTime ?? '');
+      setTareWeight(block?.tareWeight ?? '');
+      setWeighTruck(block?.weighingSkipped ? 'no' : 'yes');
+      setGrossWeight(block?.grossWeight ?? '');
+      setNetWeight(block?.netWeight ?? (item?.weight == null ? '' : Number(item.weight)));
+      setGateOutTime(block?.gateOutTime ?? '');
+    }
+  }, [opened, item, truckPrefill]);
+
+  // No truck chosen yet and exactly one is assigned — load it. With several
+  // trucks the operator picks which one is at the gate.
+  useEffect(() => {
+    if (!opened || truckPlateNumber || loadedPlateRef.current) return;
+    if (truckSelectOptions.length !== 1) return;
+    applyTruckSelection(truckSelectOptions[0].value);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [opened, truckPlateNumber, customerTrucks, lastMileTrucks]);
+
+  // A typed plate that matches a saved arrival reloads that truck's record, so
+  // the exit step opens with the weigh-in data instead of blank fields.
+  useEffect(() => {
+    if (!opened) return;
+    const key = truckPlateNumber.trim().toUpperCase();
+    if (!key || loadedPlateRef.current === key) return;
+    if (blockForPlate(savedBlocks, truckPlateNumber)) applyTruckSelection(truckPlateNumber);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [opened, truckPlateNumber]);
 
   // Which containers ride this truck, and their combined cargo weight. When the
   // booking has container weights, that sum is the authoritative net; the
@@ -294,7 +399,9 @@ export function ReleaseOrderModal({ opened, onClose, item, truckPrefill }: Relea
   );
   // Skip is only offered for container bookings; bulk always weighs.
   const skipWeighing = hasContainerWeights && weighTruck === 'no';
-  const useContainerNet = hasContainerWeights && selectedContainerNumbers.length > 0 && !skipWeighing;
+  // Even an unweighed truck records the cargo weight it is holding — the
+  // selected containers' sum is the net that goes on the exit record.
+  const useContainerNet = hasContainerWeights && selectedContainerNumbers.length > 0;
 
   const systemNetWeight = useContainerNet
     ? selectedCargoWeight
@@ -314,6 +421,10 @@ export function ReleaseOrderModal({ opened, onClose, item, truckPrefill }: Relea
       toast({ variant: 'destructive', title: 'Truck plate and driver name are required' });
       return;
     }
+    if (hasTruckLeft) {
+      toast({ variant: 'destructive', title: `Truck ${truckPlateNumber} has already left — its exit record is locked` });
+      return;
+    }
     if (!gateInTime || (!skipWeighing && tareWeight === '')) {
       toast({
         variant: 'destructive',
@@ -363,13 +474,17 @@ export function ReleaseOrderModal({ opened, onClose, item, truckPrefill }: Relea
           weighingSkipped: skipWeighing || undefined,
           tareWeight: skipWeighing ? undefined : Number(tareWeight),
           grossWeight: skipWeighing || grossWeight === '' ? undefined : Number(grossWeight),
-          netWeight: !skipWeighing && isExitStep && systemNetWeight !== '' ? Number(systemNetWeight) : undefined,
+          // Skipped weighing still records the net from what the truck holds.
+          netWeight: isExitStep && systemNetWeight !== '' ? Number(systemNetWeight) : undefined,
           gateOutTime: isExitStep ? toIsoDateTime(gateOutTime) : undefined,
         },
       });
+      await queryClient.invalidateQueries({ queryKey: ['release-customer-trucks', bookingId] });
+      await queryClient.invalidateQueries({ queryKey: ['release-last-mile-trucks', bookingId] });
       if (!isExitStep) {
+        const remaining = totalTrucks > 1 ? ` (${Math.min(arrivedTrucks + 1, totalTrucks)} of ${totalTrucks} trucks arrived)` : '';
         toast({
-          title: 'Truck arrival saved',
+          title: `Truck ${truckPlateNumber.trim()} arrival saved${remaining}`,
           description: `${released.releaseOrderReference ?? reference} is ready for exit weighing.`,
         });
         onClose();
@@ -380,11 +495,12 @@ export function ReleaseOrderModal({ opened, onClose, item, truckPrefill }: Relea
       const blob = response.data;
       const filename = `release-${released.booking?.reference ?? released.bookingId ?? item.id}.pdf`;
       const opened = openPdfBlob(blob, filename, pdfWindow);
+      const remainingExit = totalTrucks > 1 ? ` ${Math.min(leftTrucks + 1, totalTrucks)} of ${totalTrucks} trucks have left.` : '';
       toast({
         title: 'Release exit paper issued',
-        description: opened
+        description: (opened
           ? 'The PDF opened in a browser tab for printing or saving.'
-          : 'The browser blocked the preview tab, so the PDF was downloaded.',
+          : 'The browser blocked the preview tab, so the PDF was downloaded.') + remainingExit,
       });
       onClose();
     } catch (error) {
@@ -411,12 +527,35 @@ export function ReleaseOrderModal({ opened, onClose, item, truckPrefill }: Relea
             </Text>
           )}
         </Alert>
+        {totalTrucks > 1 && (
+          <Alert icon={<Truck size={16} />} color="blue" variant="light">
+            <Group gap="xs">
+              <Text size="sm">
+                {totalTrucks} trucks on this booking — each is weighed in and out separately.
+              </Text>
+              <Badge size="sm" variant="light" color={arrivedTrucks === totalTrucks ? 'green' : 'blue'}>
+                {arrivedTrucks}/{totalTrucks} arrived
+              </Badge>
+              <Badge size="sm" variant="light" color={leftTrucks === totalTrucks ? 'green' : 'gray'}>
+                {leftTrucks}/{totalTrucks} left
+              </Badge>
+            </Group>
+          </Alert>
+        )}
+        {hasTruckLeft && (
+          <Alert icon={<Info size={16} />} color="green" variant="light">
+            <Text size="sm">
+              Truck {truckPlateNumber} has already left — its exit record is locked. Pick another
+              truck to continue the remaining arrivals and exits.
+            </Text>
+          </Alert>
+        )}
         <TextInput
           label="Release document reference"
           placeholder="e.g. REL-2026-001"
           value={reference}
           onChange={(e) => setReference(e.currentTarget.value)}
-          readOnly={isEntranceLocked}
+          readOnly={referenceLocked}
         />
         {noTruckAssigned && (
           <Alert color="orange" variant="light" icon={<Info size={16} />}>
@@ -425,22 +564,19 @@ export function ReleaseOrderModal({ opened, onClose, item, truckPrefill }: Relea
         )}
         {truckSelectOptions.length > 0 && (
           <Select
-            label="Assigned first / last-mile truck"
+            label="Truck at the gate"
+            description="Pick which assigned truck is being processed — switching trucks loads that truck's own arrival/exit record."
             placeholder="Select the assigned truck"
             searchable
             clearable
-            // Enabled at arrival so the operator picks which assigned truck came;
-            // only locked on the exit (leaving) step once identity is captured.
-            disabled={isEntranceLocked}
-            data={truckSelectOptions}
+            disabled={releaseMutation.isPending || downloading}
+            data={truckSelectOptions.map(({ value, label, arrived, left }) => ({
+              value,
+              label: `${label}${left ? ' · LEFT' : arrived ? ' · ON SITE' : ''}`,
+            }))}
             value={truckSelectOptions.some((truck) => truck.value === truckPlateNumber) ? truckPlateNumber : null}
             onChange={(value) => {
-              const truck = truckSelectOptions.find((row) => row.value === value);
-              setTruckPlateNumber(truck?.value ?? '');
-              setTrailerPlateNumber(truck?.trailerPlate ?? '');
-              if (truck?.driverName) setDriverName(truck.driverName);
-              if (truck?.driverPhone) setDriverPhone(truck.driverPhone);
-              if (truck?.truckType) setTruckType(truck.truckType);
+              if (value) applyTruckSelection(value);
             }}
           />
         )}
@@ -481,6 +617,7 @@ export function ReleaseOrderModal({ opened, onClose, item, truckPrefill }: Relea
               data={containerSelectData}
               value={selectedContainerNumbers}
               onChange={(values) => setContainerNumbers(values.length ? values : [''])}
+              disabled={hasTruckLeft}
             />
           ) : (
             <Stack gap={6}>
@@ -514,13 +651,15 @@ export function ReleaseOrderModal({ opened, onClose, item, truckPrefill }: Relea
               disabled={isEntranceLocked}
             />
             {skipWeighing && (
-              <Text size="xs" c="dimmed">Weighbridge skipped — container passes without tare/gross.</Text>
+              <Text size="xs" c="dimmed">
+                Weighbridge skipped — the selected containers' cargo weight is recorded as the net.
+              </Text>
             )}
           </Group>
         )}
         <Group grow>
           <NumberInput label="Tare weight (t)" required={!skipWeighing} min={0} value={tareWeight} onChange={(v) => setTareWeight(v === '' ? '' : Number(v))} readOnly={isEntranceLocked} disabled={skipWeighing} />
-          <NumberInput label="Gross weight (t)" required={isExitStep && !skipWeighing} min={0} value={grossWeight} onChange={(v) => setGrossWeight(v === '' ? '' : Number(v))} disabled={!isExitStep || skipWeighing} />
+          <NumberInput label="Gross weight (t)" required={isExitStep && !skipWeighing} min={0} value={grossWeight} onChange={(v) => setGrossWeight(v === '' ? '' : Number(v))} disabled={!isExitStep || skipWeighing || hasTruckLeft} />
           <NumberInput
             label={useContainerNet ? 'Selected cargo net (t)' : 'Recorded net weight (system t)'}
             min={0}
@@ -532,7 +671,7 @@ export function ReleaseOrderModal({ opened, onClose, item, truckPrefill }: Relea
           <Text size="sm" c={weightMismatch ? 'red' : 'dimmed'}>
             Computed net: <b>{computedNetWeight == null ? '-' : `${computedNetWeight.toLocaleString()} t`}</b>
           </Text>
-          <TextInput label="Gate out time" type="datetime-local" value={gateOutTime} onChange={(e) => setGateOutTime(e.currentTarget.value)} disabled={!isExitStep} />
+          <TextInput label="Gate out time" type="datetime-local" value={gateOutTime} onChange={(e) => setGateOutTime(e.currentTarget.value)} disabled={!isExitStep || hasTruckLeft} />
         </Group>
         {weightMismatch && (
           <Alert icon={<Scale size={16} />} color="red" variant="light">
@@ -546,7 +685,7 @@ export function ReleaseOrderModal({ opened, onClose, item, truckPrefill }: Relea
           <Button variant="default" onClick={onClose} disabled={releaseMutation.isPending || downloading}>
             Cancel
           </Button>
-          <Button color="orange" onClick={handleSubmit} loading={releaseMutation.isPending || downloading}>
+          <Button color="orange" onClick={handleSubmit} loading={releaseMutation.isPending || downloading} disabled={hasTruckLeft}>
             {isExitStep ? 'Save Truck Leaving & View Exit Paper' : 'Save Truck Arrival'}
           </Button>
         </Group>
diff --git a/apps/edr-freight-web/backoffice/src/components/warehouses/WarehouseInventoryTable.tsx b/apps/edr-freight-web/backoffice/src/components/warehouses/WarehouseInventoryTable.tsx
index 48ce59c78..5eacf7fc1 100644
--- a/apps/edr-freight-web/backoffice/src/components/warehouses/WarehouseInventoryTable.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/warehouses/WarehouseInventoryTable.tsx
@@ -51,8 +51,10 @@ const actionColor: Record<InventoryAction, string> = {
   deliver: 'green',
 };
 
+// After the first truck registers, the modal decides per truck whether it is
+// arriving or leaving — the item-level label covers both for multi-truck.
 const releaseActionLabel = (item: WarehouseInventoryItem) =>
-  item.releaseOrderReference ? 'Truck Leaving' : 'Truck Arrival';
+  item.releaseOrderReference ? 'Truck Arrival / Leaving' : 'Truck Arrival';
 
 const noteLineValue = (notes: string | null | undefined, label: string) => {
   const match = notes?.match(new RegExp(`^${label}:\\s*(.+)$`, 'im'));
@@ -276,6 +278,19 @@ export function WarehouseInventoryTable({
                         {nextAction === 'release' ? releaseActionLabel(item) : humanizeEnum(nextAction.replace(/-/g, '_'))}
                       </Button>
                     )}
+                    {/* After the first exit the primary action flips to Deliver, but a
+                        multi-truck booking still weighs its remaining trucks in and out. */}
+                    {item.status === 'READY_FOR_PICKUP' && item.releaseDate && nextAction !== 'release' && (
+                      <Button
+                        size="compact-xs"
+                        variant="light"
+                        color="yellow"
+                        loading={busy}
+                        onClick={() => onAdvance(item, 'release')}
+                      >
+                        Truck Arrival / Leaving
+                      </Button>
+                    )}
                     {item.status === 'READY_FOR_PICKUP' && (
                       <Button
                         size="compact-xs"
diff --git a/apps/edr-freight-web/backoffice/src/components/warehouses/WarehouseOpsKpiStrip.tsx b/apps/edr-freight-web/backoffice/src/components/warehouses/WarehouseOpsKpiStrip.tsx
index 88a60bbb4..c24eb1259 100644
--- a/apps/edr-freight-web/backoffice/src/components/warehouses/WarehouseOpsKpiStrip.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/warehouses/WarehouseOpsKpiStrip.tsx
@@ -23,18 +23,24 @@ export function WarehouseOpsKpiStrip() {
           delta:
             data != null ? data.receivedToday - data.receivedYesterday : undefined,
           hint: "vs yesterday",
+          // Exactly the items behind the counter: received today.
+          href: "/dashboard/warehouse-inventory?receivedToday=1",
         },
         {
           label: "Pending inspection",
           value: data?.pendingInspection ?? 0,
           icon: ClipboardCheck,
           color: "yellow",
+          // RECEIVED items with no inspection recorded yet.
+          href: "/dashboard/warehouse-inventory?pendingInspection=1",
         },
         {
           label: "Trucks on-site",
           value: data?.trucksOnSite ?? 0,
           icon: Truck,
           color: "blue",
+          // Land on the On-site tab — the counter excludes inbound trucks.
+          href: "/dashboard/trucks-on-site?scope=ON_SITE",
         },
         {
           label: "Items aging (>7d)",
@@ -42,6 +48,7 @@ export function WarehouseOpsKpiStrip() {
           icon: AlertTriangle,
           color: (data?.itemsAging ?? 0) > 0 ? "red" : "edr-green",
           hint: "In warehouse over 7 days",
+          href: "/dashboard/warehouse-inventory?agingOverDays=7",
         },
       ]}
     />
diff --git a/apps/edr-freight-web/backoffice/src/constants/URLS.ts b/apps/edr-freight-web/backoffice/src/constants/URLS.ts
index 50497471d..ade491a7b 100644
--- a/apps/edr-freight-web/backoffice/src/constants/URLS.ts
+++ b/apps/edr-freight-web/backoffice/src/constants/URLS.ts
@@ -399,6 +399,8 @@ export const URL_CONSTANTS = {
       `/train-scheduling/schedules/${scheduleId}/wagons/${wagonId}`,
     UPDATE_CONTAINER_ITEM: (scheduleId: string, itemId: string) =>
       `/train-scheduling/schedules/${scheduleId}/container-items/${itemId}`,
+    MOVE_WAGON_LOAD: (scheduleId: string, wagonId: string) =>
+      `/train-scheduling/schedules/${scheduleId}/wagons/${wagonId}/move-load`,
     UNASSIGNED_BOOKINGS: (scheduleId: string) =>
       `/train-scheduling/schedules/${scheduleId}/unassigned-bookings`,
     COMPOSITION_REMOVALS: (scheduleId: string) =>
@@ -427,6 +429,9 @@ export const URL_CONSTANTS = {
     YARDS: "/yards",
     YARD_BY_ID: (id: string) => `/yards/${id}`,
 
+    YARD_DISTANCES: "/yard-distances",
+    YARD_DISTANCE_BY_ID: (id: string) => `/yard-distances/${id}`,
+
     SHIPPING_LINES: "/shipping-lines",
     SHIPPING_LINE_BY_ID: (id: string) => `/shipping-lines/${id}`,
 
diff --git a/apps/edr-freight-web/backoffice/src/hooks/bookings/useBookings.ts b/apps/edr-freight-web/backoffice/src/hooks/bookings/useBookings.ts
index 0a9efccee..2fce8aa8f 100644
--- a/apps/edr-freight-web/backoffice/src/hooks/bookings/useBookings.ts
+++ b/apps/edr-freight-web/backoffice/src/hooks/bookings/useBookings.ts
@@ -1,5 +1,4 @@
 import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
-import { isAxiosError } from "axios";
 import toast from "react-hot-toast";
 
 import { QUERY_KEYS } from "@/constants/QUERY_KEYS";
@@ -9,16 +8,9 @@ import {
   type BookingListFilter,
 } from "@/services/bookings.service";
 import { invalidateBookingDetail } from "@/utils/queryInvalidation";
+import { extractErrorMessage } from "@/utils/errorExtractor";
 
-const parseApiError = (error: unknown, fallback: string) => {
-  if (isAxiosError(error)) {
-    const message = error.response?.data?.message;
-    if (Array.isArray(message)) return message.join(", ");
-    if (typeof message === "string") return message;
-  }
-  if (error instanceof Error && error.message) return error.message;
-  return fallback;
-};
+const parseApiError = extractErrorMessage;
 
 export function useBookingList(filter?: BookingListFilter, enabled = true) {
   return useQuery({
@@ -55,21 +47,21 @@ export function useBookingMutations(bookingId: string) {
     mutationFn: (validityDays: number) =>
       api.bookings.staffAccept.call({ id: bookingId, validityDays }),
     onSuccess: (data) => onSuccess(data, "Booking accepted for approval"),
-    onError: () => toast.error("Failed to accept booking"),
+    onError: (error) => toast.error(parseApiError(error, "Failed to accept booking")),
   });
 
   const requestChanges = useMutation({
     mutationFn: (note: string) =>
       api.bookings.requestChanges.call({ id: bookingId, note }),
     onSuccess: (data) => onSuccess(data, "Changes requested from customer"),
-    onError: () => toast.error("Failed to request changes"),
+    onError: (error) => toast.error(parseApiError(error, "Failed to request changes")),
   });
 
   const staffReject = useMutation({
     mutationFn: (reason: string) =>
       api.bookings.staffReject.call({ id: bookingId, reason }),
     onSuccess: (data) => onSuccess(data, "Booking rejected"),
-    onError: () => toast.error("Failed to reject booking"),
+    onError: (error) => toast.error(parseApiError(error, "Failed to reject booking")),
   });
 
   const reviewOperation = useMutation({
@@ -90,7 +82,7 @@ export function useBookingMutations(bookingId: string) {
   const generateContract = useMutation({
     mutationFn: () => api.bookings.generateContract.call({ id: bookingId }),
     onSuccess: (data) => onSuccess(data, "Contract generated"),
-    onError: () => toast.error("Failed to generate contract"),
+    onError: (error) => toast.error(parseApiError(error, "Failed to generate contract")),
   });
 
   const signContract = useMutation({
@@ -101,32 +93,32 @@ export function useBookingMutations(bookingId: string) {
       consentText?: string;
     }) => bookingsService.signContract(bookingId, payload),
     onSuccess: (data) => onSuccess(data, "Contract signed"),
-    onError: () => toast.error("Failed to sign contract"),
+    onError: (error) => toast.error(parseApiError(error, "Failed to sign contract")),
   });
 
   const payBooking = useMutation({
     mutationFn: () => api.bookings.payBooking.call({ id: bookingId }),
     onSuccess: (data) => onSuccess(data, "Payment completed"),
-    onError: () => toast.error("Failed to complete payment"),
+    onError: (error) => toast.error(parseApiError(error, "Failed to complete payment")),
   });
 
   const startTransit = useMutation({
     mutationFn: () => api.bookings.startTransit.call({ id: bookingId }),
     onSuccess: (data) => onSuccess(data, "Marked in transit"),
-    onError: () => toast.error("Failed to start transit"),
+    onError: (error) => toast.error(parseApiError(error, "Failed to start transit")),
   });
 
   const complete = useMutation({
     mutationFn: () => api.bookings.complete.call({ id: bookingId }),
     onSuccess: (data) => onSuccess(data, "Booking completed"),
-    onError: () => toast.error("Failed to complete booking"),
+    onError: (error) => toast.error(parseApiError(error, "Failed to complete booking")),
   });
 
   const cancel = useMutation({
     mutationFn: (reason: string) =>
       api.bookings.cancel.call({ id: bookingId, reason }),
     onSuccess: (data) => onSuccess(data, "Booking cancelled"),
-    onError: () => toast.error("Failed to cancel booking"),
+    onError: (error) => toast.error(parseApiError(error, "Failed to cancel booking")),
   });
 
   const isPending =
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 6be5865f2..afbb6f627 100644
--- a/apps/edr-freight-web/backoffice/src/hooks/contracts/useContracts.ts
+++ b/apps/edr-freight-web/backoffice/src/hooks/contracts/useContracts.ts
@@ -9,6 +9,7 @@ import {
   type ContractListFilter,
   type SignContractPayload,
 } from "@/services/contracts.service";
+import { extractErrorMessage } from "@/utils/errorExtractor";
 
 function invalidateContractDetail(qc: QueryClient, id: string): Promise<void> {
   return Promise.all([
@@ -144,7 +145,7 @@ export function useContractMutations(contractId: string) {
         payload.documentSnapshot,
       ),
     onSuccess: (data) => onSuccess(data, "Contract accepted for approval"),
-    onError: () => toast.error("Failed to accept contract"),
+    onError: (error) => toast.error(extractErrorMessage(error, "Failed to accept contract")),
   });
 
   // Edit THIS contract's document articles (per-contract; never the templates).
@@ -152,20 +153,20 @@ export function useContractMutations(contractId: string) {
     mutationFn: (snapshot: Freight.IContractDocumentSnapshot) =>
       contractsService.updateContractDocument(contractId, snapshot),
     onSuccess: (data) => onSuccess(data, "Contract document updated"),
-    onError: () => toast.error("Failed to update contract document"),
+    onError: (error) => toast.error(extractErrorMessage(error, "Failed to update contract document")),
   });
 
   const requestChanges = useMutation({
     mutationFn: (note: string) =>
       contractsService.requestChanges(contractId, note),
     onSuccess: (data) => onSuccess(data, "Changes requested from customer"),
-    onError: () => toast.error("Failed to request changes"),
+    onError: (error) => toast.error(extractErrorMessage(error, "Failed to request changes")),
   });
 
   const reject = useMutation({
     mutationFn: (reason: string) => contractsService.reject(contractId, reason),
     onSuccess: (data) => onSuccess(data, "Contract rejected"),
-    onError: () => toast.error("Failed to reject contract"),
+    onError: (error) => toast.error(extractErrorMessage(error, "Failed to reject contract")),
   });
 
   const approveStep = useMutation({
@@ -182,30 +183,46 @@ export function useContractMutations(contractId: string) {
           : "Approval step completed";
       onSuccess(data, message);
     },
-    onError: () => toast.error("Failed to approve step"),
+    onError: (error) => toast.error(extractErrorMessage(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.
+  // Per-step rejection by an approver (line staff / director / CEO). Two
+  // flavours: without returnToStepId it is terminal (REJECTED, customer must
+  // resubmit); with it the contract is sent back to that earlier approver and
+  // the chain re-runs from there.
   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"),
+    mutationFn: ({
+      stepId,
+      reason,
+      returnToStepId,
+    }: {
+      stepId: string;
+      reason: string;
+      returnToStepId?: string;
+    }) =>
+      contractsService.rejectStep({ id: contractId, stepId, reason, returnToStepId }),
+    onSuccess: (data, variables) =>
+      onSuccess(
+        data,
+        variables.returnToStepId
+          ? "Contract sent back in the approval chain"
+          : "Contract rejected",
+      ),
+    onError: (error) => toast.error(extractErrorMessage(error, "Failed to reject step")),
   });
 
   // Manual fallback generate — used only if auto-generation failed.
   const generateContract = useMutation({
     mutationFn: () => contractsService.generateContract(contractId),
     onSuccess: (data) => onSuccess(data, "Contract generated"),
-    onError: () => toast.error("Failed to generate contract"),
+    onError: (error) => toast.error(extractErrorMessage(error, "Failed to generate contract")),
   });
 
   const signContract = useMutation({
     mutationFn: (payload: SignContractPayload) =>
       contractsService.signContract(contractId, payload),
     onSuccess: (data) => onSuccess(data, "Contract signed"),
-    onError: () => toast.error("Failed to sign contract"),
+    onError: (error) => toast.error(extractErrorMessage(error, "Failed to sign contract")),
   });
 
   const createBooking = useMutation({
@@ -331,7 +348,7 @@ export function useContractClearanceMutations(
       );
       refresh();
     },
-    onError: () => toast.error("Could not approve all documents"),
+    onError: (error) => toast.error(extractErrorMessage(error, "Could not approve all documents")),
   });
 
   const uploadOutputDocuments = useMutation({
@@ -341,7 +358,7 @@ export function useContractClearanceMutations(
       toast.success("Output documents uploaded");
       refresh();
     },
-    onError: () => toast.error("Upload failed"),
+    onError: (error) => toast.error(extractErrorMessage(error, "Upload failed")),
   });
 
   const finalizeClearance = useMutation({
@@ -380,7 +397,7 @@ export function useCompleteMilestone(bookingId: string) {
         queryKey: QUERY_KEYS.CONTRACTS.bookingMilestones(bookingId),
       });
     },
-    onError: () => toast.error("Failed to complete milestone"),
+    onError: (error) => toast.error(extractErrorMessage(error, "Failed to complete milestone")),
   });
 }
 
@@ -402,7 +419,7 @@ export function useAssignRisk(bookingId: string) {
       toast.success("Customs risk assigned");
       invalidateMilestones(qc, bookingId);
     },
-    onError: () => toast.error("Failed to assign risk"),
+    onError: (error) => toast.error(extractErrorMessage(error, "Failed to assign risk")),
   });
 }
 
@@ -420,7 +437,7 @@ export function useAdviseDuty(bookingId: string) {
       toast.success("Duty & tax advised to customer");
       invalidateMilestones(qc, bookingId);
     },
-    onError: () => toast.error("Failed to advise duty & tax"),
+    onError: (error) => toast.error(extractErrorMessage(error, "Failed to advise duty & tax")),
   });
 }
 
@@ -436,7 +453,7 @@ export function useAssignStation(bookingId: string) {
         queryKey: QUERY_KEYS.BOOKINGS.byId(bookingId),
       });
     },
-    onError: () => toast.error("Failed to assign station"),
+    onError: (error) => toast.error(extractErrorMessage(error, "Failed to assign station")),
   });
 }
 
@@ -455,7 +472,7 @@ export function useUploadGlDocuments(bookingId: string) {
       );
       invalidateMilestones(qc, bookingId);
     },
-    onError: () => toast.error("Failed to upload documents"),
+    onError: (error) => toast.error(extractErrorMessage(error, "Failed to upload documents")),
   });
 }
 
@@ -483,6 +500,6 @@ export function useReportIncident(bookingId: string) {
         queryKey: QUERY_KEYS.CONTRACTS.bookingIncidents(bookingId),
       });
     },
-    onError: () => toast.error("Failed to report incident"),
+    onError: (error) => toast.error(extractErrorMessage(error, "Failed to report incident")),
   });
 }
diff --git a/apps/edr-freight-web/backoffice/src/hooks/rule-engine/useRuleEngine.ts b/apps/edr-freight-web/backoffice/src/hooks/rule-engine/useRuleEngine.ts
index 24fc26726..ae3b9d4b8 100644
--- a/apps/edr-freight-web/backoffice/src/hooks/rule-engine/useRuleEngine.ts
+++ b/apps/edr-freight-web/backoffice/src/hooks/rule-engine/useRuleEngine.ts
@@ -21,6 +21,7 @@ import {
   invalidateRuleEngineList,
   patchRuleEngineListRecord,
 } from "@/utils/queryInvalidation";
+import { extractErrorMessage } from "@/utils/errorExtractor";
 
 export const useRuleEngineList = (
   resource: RuleEngineResourceSlug,
@@ -58,7 +59,7 @@ export const useRuleEngineOrderMutations = (resource: RuleEngineResourceSlug) =>
       await invalidateRuleEngineList(qc, resource);
       await qc.invalidateQueries({ queryKey: QUERY_KEYS.RULE_ENGINE.orderList(resource) });
     },
-    onError: () => toast.error("Failed to update order"),
+    onError: (err) => toast.error(extractErrorMessage(err, "Failed to update order")),
   });
 
   const moveOrder = useMutation({
@@ -273,7 +274,8 @@ export const useRuleEngineMutations = (resource: RuleEngineResourceSlug) => {
       patchRuleEngineListRecord(qc, resource, created);
       await invalidateRuleEngineList(qc, resource);
     },
-    onError: () => toast.error("Failed to create record"),
+    onError: (err) =>
+      toast.error(extractErrorMessage(err, "Failed to create record")),
   });
 
   const update = useMutation({
@@ -289,7 +291,8 @@ export const useRuleEngineMutations = (resource: RuleEngineResourceSlug) => {
       patchRuleEngineListRecord(qc, resource, updated);
       await invalidateRuleEngineList(qc, resource);
     },
-    onError: () => toast.error("Failed to update record"),
+    onError: (err) =>
+      toast.error(extractErrorMessage(err, "Failed to update record")),
   });
 
   const remove = useMutation({
@@ -299,7 +302,8 @@ export const useRuleEngineMutations = (resource: RuleEngineResourceSlug) => {
       toast.success("Deleted successfully");
       await invalidateRuleEngineList(qc, resource);
     },
-    onError: () => toast.error("Failed to delete record"),
+    onError: (err) =>
+      toast.error(extractErrorMessage(err, "Failed to delete record")),
   });
 
   return { create, update, remove };
@@ -455,7 +459,7 @@ export const useRateWorkflow = () => {
       patchRuleEngineListRecord(qc, "rates", updated);
       await invalidateRuleEngineList(qc, "rates");
     },
-    onError: () => toast.error("Failed to submit rate"),
+    onError: (err) => toast.error(extractErrorMessage(err, "Failed to submit rate")),
   });
 
   const approve = useMutation({
@@ -465,7 +469,7 @@ export const useRateWorkflow = () => {
       patchRuleEngineListRecord(qc, "rates", updated);
       await invalidateRuleEngineList(qc, "rates");
     },
-    onError: () => toast.error("Failed to approve rate"),
+    onError: (err) => toast.error(extractErrorMessage(err, "Failed to approve rate")),
   });
 
   return { submit, approve };
diff --git a/apps/edr-freight-web/backoffice/src/lib/permissions.ts b/apps/edr-freight-web/backoffice/src/lib/permissions.ts
index 98f998bc0..b11d7bffa 100644
--- a/apps/edr-freight-web/backoffice/src/lib/permissions.ts
+++ b/apps/edr-freight-web/backoffice/src/lib/permissions.ts
@@ -353,12 +353,38 @@ export const POSITION_KEYS = {
   djiboutiGl: "djibouti_gl",
 } as const;
 
+/** Position-type keys held by the user (e.g. "djibouti-gl-officer"). */
+export function getPositionTypeKeys(
+  user: AuthUser | null | undefined,
+): string[] {
+  if (!user) return [];
+  const keys = new Set<string>();
+  for (const emp of user.employee ?? []) {
+    for (const pos of emp.positions ?? []) {
+      if (pos.positionType?.key) keys.add(pos.positionType.key);
+    }
+  }
+  return [...keys];
+}
+
+// GL staff are identified by the root position key (department heads) OR by
+// their position-type key (sub-positions: director/chief/officer) — both
+// forms get the clearance-only locked view.
+const ET_GL_TYPE_PREFIX = "commercial-global-logistics-(et)";
+const DJ_GL_TYPE_PREFIX = "djibouti-gl";
+
 export function isEthiopianGl(user: AuthUser | null | undefined): boolean {
-  return hasPosition(user, POSITION_KEYS.ethiopianGl);
+  return (
+    hasPosition(user, POSITION_KEYS.ethiopianGl) ||
+    getPositionTypeKeys(user).some((k) => k.startsWith(ET_GL_TYPE_PREFIX))
+  );
 }
 
 export function isDjiboutiGl(user: AuthUser | null | undefined): boolean {
-  return hasPosition(user, POSITION_KEYS.djiboutiGl);
+  return (
+    hasPosition(user, POSITION_KEYS.djiboutiGl) ||
+    getPositionTypeKeys(user).some((k) => k.startsWith(DJ_GL_TYPE_PREFIX))
+  );
 }
 
 export function isSuperAdmin(user: AuthUser | null | undefined): boolean {
diff --git a/apps/edr-freight-web/backoffice/src/lib/queryClient.ts b/apps/edr-freight-web/backoffice/src/lib/queryClient.ts
index 0a270372e..ee072b330 100644
--- a/apps/edr-freight-web/backoffice/src/lib/queryClient.ts
+++ b/apps/edr-freight-web/backoffice/src/lib/queryClient.ts
@@ -23,6 +23,9 @@ export const queryClient = new QueryClient({
         void queryClient.invalidateQueries({ queryKey });
       }
     },
+    // Mutation failures are surfaced globally by the axios interceptor in
+    // auth/http.ts (server-message toast on every non-401 failure), so no
+    // onError toast here — it would double up.
   }),
   defaultOptions: {
     queries: {
diff --git a/apps/edr-freight-web/backoffice/src/lib/utils.ts b/apps/edr-freight-web/backoffice/src/lib/utils.ts
index a5ef19350..54bb0325d 100644
--- a/apps/edr-freight-web/backoffice/src/lib/utils.ts
+++ b/apps/edr-freight-web/backoffice/src/lib/utils.ts
@@ -4,3 +4,17 @@ import { twMerge } from "tailwind-merge";
 export function cn(...inputs: ClassValue[]) {
   return twMerge(clsx(inputs));
 }
+
+/** Human label for a trade direction — DOMESTIC reads "Intercity" everywhere. */
+export function directionLabel(direction?: string | null): string {
+  switch (direction) {
+    case "IMPORT":
+      return "Import";
+    case "EXPORT":
+      return "Export";
+    case "DOMESTIC":
+      return "Intercity";
+    default:
+      return direction || "—";
+  }
+}
diff --git a/apps/edr-freight-web/backoffice/src/pages/contracts/ClearanceDocumentsPage.tsx b/apps/edr-freight-web/backoffice/src/pages/contracts/ClearanceDocumentsPage.tsx
index 945d142df..60d5a56f8 100644
--- a/apps/edr-freight-web/backoffice/src/pages/contracts/ClearanceDocumentsPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/contracts/ClearanceDocumentsPage.tsx
@@ -1,3 +1,4 @@
+import { directionLabel } from "@/lib/utils";
 import {
   ActionIcon,
   Box,
@@ -199,7 +200,7 @@ export default function ClearanceDocumentsPage() {
                   variant="outline"
                   className="h-5 border-border/50 bg-background/50 px-1.5 text-[10px] font-medium uppercase backdrop-blur-sm"
                 >
-                  {c.tradeDirection}
+                  {directionLabel(c.tradeDirection)}
                 </Badge>
                 <Badge
                   variant="secondary"
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 63dbb5d0b..5ac798250 100644
--- a/apps/edr-freight-web/backoffice/src/pages/contracts/ContractClearanceDetailPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/contracts/ContractClearanceDetailPage.tsx
@@ -1,3 +1,4 @@
+import { directionLabel } from "@/lib/utils";
 import { useMemo } from "react";
 import { useQuery } from "@tanstack/react-query";
 import { useLocation, useParams } from "react-router-dom";
@@ -468,7 +469,7 @@ function ClearanceHero({
                 color={direction === "IMPORT" ? "edr-green" : "gray"}
                 radius="sm"
               >
-                {direction}
+                {directionLabel(direction)}
               </Badge>
               {customs ? (
                 <Badge
diff --git a/apps/edr-freight-web/backoffice/src/pages/contracts/ContractClearanceListPage.tsx b/apps/edr-freight-web/backoffice/src/pages/contracts/ContractClearanceListPage.tsx
index 328736f3d..86aea96ee 100644
--- a/apps/edr-freight-web/backoffice/src/pages/contracts/ContractClearanceListPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/contracts/ContractClearanceListPage.tsx
@@ -1,3 +1,4 @@
+import { directionLabel } from "@/lib/utils";
 import {
   Fragment,
   useCallback,
@@ -180,7 +181,7 @@ function CustomsBadge({ customs }: { customs: boolean }) {
 function DirectionIcon({ direction }: { direction: string }) {
   const isImport = direction === "IMPORT";
   const Icon = isImport ? Truck : ShipWheel;
-  const label = isImport ? "Import" : direction === "EXPORT" ? "Export" : "—";
+  const label = directionLabel(direction);
   return (
     <Tooltip label={label} withArrow>
       <ThemeIcon
diff --git a/apps/edr-freight-web/backoffice/src/pages/contracts/ContractRequestDetailPage.tsx b/apps/edr-freight-web/backoffice/src/pages/contracts/ContractRequestDetailPage.tsx
index 9ee458588..958cc684e 100644
--- a/apps/edr-freight-web/backoffice/src/pages/contracts/ContractRequestDetailPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/contracts/ContractRequestDetailPage.tsx
@@ -1,6 +1,8 @@
+import { directionLabel } from "@/lib/utils";
 import { useNavigate, useParams, useSearchParams } from "react-router-dom";
 import { useQuery } from "@tanstack/react-query";
 import {
+  AlertTriangle,
   ArrowLeft,
   ArrowRight,
   Box as BoxIcon,
@@ -22,6 +24,7 @@ import {
   Users,
 } from "lucide-react";
 import {
+  Alert,
   Badge,
   Box,
   Button,
@@ -264,7 +267,8 @@ export default function ContractRequestDetailPage() {
   const showApprovalCard =
     contract.status === "PENDING_APPROVAL" ||
     contract.status === "APPROVED" ||
-    contract.status === "APPROVED_PENDING_SIGNATURE";
+    contract.status === "APPROVED_PENDING_SIGNATURE" ||
+    contract.status === "REJECTED";
 
   const showClearanceTab = CLEARANCE_REVIEW_STATUSES.includes(contract.status);
   const phasedCustoms =
@@ -428,6 +432,32 @@ export default function ContractRequestDetailPage() {
           description={statusMeta.description}
         />
 
+        {contract.status === "REJECTED" && contract.latestRejectionNote ? (
+          <Alert
+            color="red"
+            radius="md"
+            icon={<AlertTriangle size={18} />}
+            title="Rejection reason"
+          >
+            <Text size="sm" style={{ whiteSpace: "pre-wrap" }}>
+              {contract.latestRejectionNote}
+            </Text>
+          </Alert>
+        ) : null}
+
+        {contract.status === "PENDING_APPROVAL" && contract.latestSendBackNote ? (
+          <Alert
+            color="orange"
+            radius="md"
+            icon={<AlertTriangle size={18} />}
+            title="Sent back in the approval chain"
+          >
+            <Text size="sm" style={{ whiteSpace: "pre-wrap" }}>
+              {contract.latestSendBackNote}
+            </Text>
+          </Alert>
+        ) : null}
+
         <Tabs
           value={currentTab}
           onChange={(v) => setTab(v ?? "details")}
@@ -568,7 +598,7 @@ export default function ContractRequestDetailPage() {
               <SectionCard icon={Package} title="Cargo scope">
                 <Group gap="sm" mb="md">
                   <Badge variant="light" color="gray" radius="sm" tt="uppercase">
-                    {contract.tradeDirection}
+                    {directionLabel(contract.tradeDirection)}
                   </Badge>
                   <Badge variant="light" color="gray" radius="sm" tt="uppercase">
                     {contract.freightType}
diff --git a/apps/edr-freight-web/backoffice/src/pages/contracts/ContractRequestsPage.tsx b/apps/edr-freight-web/backoffice/src/pages/contracts/ContractRequestsPage.tsx
index 1752aa7c0..7687b62f0 100644
--- a/apps/edr-freight-web/backoffice/src/pages/contracts/ContractRequestsPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/contracts/ContractRequestsPage.tsx
@@ -1,3 +1,4 @@
+import { directionLabel } from "@/lib/utils";
 import {
   ActionIcon,
   Box,
@@ -299,7 +300,7 @@ export default function ContractRequestsPage() {
                 variant="outline"
                 className="h-5 border-border/50 bg-background/50 px-1.5 text-[10px] font-medium uppercase backdrop-blur-sm"
               >
-                {c.tradeDirection}
+                {directionLabel(c.tradeDirection)}
               </Badge>
               <Badge
                 variant="secondary"
diff --git a/apps/edr-freight-web/backoffice/src/pages/contracts/GlClearanceDetailPage.tsx b/apps/edr-freight-web/backoffice/src/pages/contracts/GlClearanceDetailPage.tsx
index f68d6562b..108e4f461 100644
--- a/apps/edr-freight-web/backoffice/src/pages/contracts/GlClearanceDetailPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/contracts/GlClearanceDetailPage.tsx
@@ -1,3 +1,4 @@
+import { directionLabel } from "@/lib/utils";
 import { useState } from "react";
 import { useQuery } from "@tanstack/react-query";
 import { useParams } from "react-router-dom";
@@ -16,6 +17,7 @@ import {
 } from "@mantine/core";
 import {
   AlertCircle,
+  AlertTriangle,
   ClipboardList,
   FileText,
   Upload,
@@ -36,6 +38,8 @@ import {
   type GlClearanceUploadKind,
 } from "@/components/contracts/GlClearanceUploadModal";
 import { PhasedClearanceActionPanel } from "@/components/contracts/PhasedClearanceActionPanel";
+import { SectionCard } from "@/components/bookings/detail/SectionCard";
+import { IncidentReportCard } from "@/components/contracts/gl-actions/IncidentReportCard";
 import { findWorkflowFile } from "@/components/contracts/PhasedUploadedFileRow";
 import { useFileViewer } from "@/hooks/useFileViewer";
 import { useBookingMilestones } from "@/hooks/contracts/useContracts";
@@ -146,6 +150,9 @@ export default function GlClearanceDetailPage() {
     "vesselDepartureDate" in data.clearance
       ? (data.clearance.vesselDepartureDate ?? null)
       : null;
+  // Incident reporting attaches to a booking; a contract-level clearance can
+  // only report against its linked booking once one exists.
+  const incidentBookingId = data.kind === "booking" ? id : linkedBookingId;
 
   // The shipment booking instance backing this clearance (per-booking GENERAL
   // customs). Bare until GL completes it: no cargo, no price.
@@ -173,7 +180,7 @@ export default function GlClearanceDetailPage() {
           ]}
           meta={
             <Badge variant="light" color={isImport ? "edr-green" : "gray"} radius="sm">
-              {data.tradeDirection}
+              {directionLabel(data.tradeDirection)}
             </Badge>
           }
           action={
@@ -220,6 +227,11 @@ export default function GlClearanceDetailPage() {
             >
               Customs documents (all steps)
             </Tabs.Tab>
+            {incidentBookingId ? (
+              <Tabs.Tab value="incidents" leftSection={<AlertTriangle size={14} />}>
+                Incidents
+              </Tabs.Tab>
+            ) : null}
           </Tabs.List>
 
           <Tabs.Panel value="workflow">
@@ -309,6 +321,19 @@ export default function GlClearanceDetailPage() {
               </Box>
             )}
           </Tabs.Panel>
+
+          {incidentBookingId ? (
+            <Tabs.Panel value="incidents">
+              <SectionCard icon={AlertTriangle} title="Incident reports" accent="edr-green">
+                <Stack gap="sm">
+                  <Text size="sm" c="dimmed">
+                    Log container or seal issues discovered during clearance handling.
+                  </Text>
+                  <IncidentReportCard bookingId={incidentBookingId} />
+                </Stack>
+              </SectionCard>
+            </Tabs.Panel>
+          ) : null}
         </Tabs>
       </Stack>
 
diff --git a/apps/edr-freight-web/backoffice/src/pages/contracts/GlDjiboutiClearanceListPage.tsx b/apps/edr-freight-web/backoffice/src/pages/contracts/GlDjiboutiClearanceListPage.tsx
index a43a6ff55..c5c424e9a 100644
--- a/apps/edr-freight-web/backoffice/src/pages/contracts/GlDjiboutiClearanceListPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/contracts/GlDjiboutiClearanceListPage.tsx
@@ -1,3 +1,4 @@
+import { directionLabel } from "@/lib/utils";
 import { useCallback, useMemo, useState } from "react";
 import { useNavigate } from "react-router-dom";
 import {
@@ -249,7 +250,7 @@ function toContractRow(c: Freight.IContract): ContractRow {
 function DirectionIcon({ direction }: { direction: string }) {
   const isImport = direction === "IMPORT";
   const Icon = isImport ? Truck : ShipWheel;
-  const label = isImport ? "Import" : direction === "EXPORT" ? "Export" : "—";
+  const label = directionLabel(direction);
   return (
     <Tooltip label={label} withArrow>
       <ThemeIcon
diff --git a/apps/edr-freight-web/backoffice/src/pages/fleet/FleetDashboard.tsx b/apps/edr-freight-web/backoffice/src/pages/fleet/FleetDashboard.tsx
index 32341505a..beb16406a 100644
--- a/apps/edr-freight-web/backoffice/src/pages/fleet/FleetDashboard.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/fleet/FleetDashboard.tsx
@@ -3,6 +3,7 @@ import { useQuery } from '@tanstack/react-query';
 import { Card, Stack, Group, Grid, Text, ThemeIcon, Progress, Badge, Table, RingProgress, Container, Title, Box, Tabs } from '@mantine/core';
 import { Truck, Fuel, Wrench, AlertCircle, Users, User, MapPin } from 'lucide-react';
 import type { LucideIcon } from 'lucide-react';
+import { Link } from 'react-router-dom';
 import Breadcrumbs from '@/components/ui/Breadcrumbs';
 import { QUERY_KEYS } from '@/constants/QUERY_KEYS';
 import { api } from '@/auth/http';
@@ -51,28 +52,46 @@ interface StatCardProps {
   value: string | number;
   color?: string;
   change?: number;
+  /** Detail route the card opens. When set the card is a link; otherwise static. */
+  href?: string;
 }
 
-const StatCard = ({ icon: Icon, label, value, color = 'edr-green', change }: StatCardProps) => (
-  <Card withBorder p="lg" style={{ borderTop: `3px solid ${freightBrand.primary}` }}>
-    <Group justify="space-between" mb="sm">
-      <ThemeIcon size="xl" radius="md" color={color} variant="light">
-        <Icon size={28} />
-      </ThemeIcon>
-    </Group>
-    <Stack gap="xs">
-      <Text size="xs" c="dimmed" fw={500} tt="uppercase">
-        {label}
-      </Text>
-      <Group justify="space-between">
-        <Text fw={700} size="xl" c="edr-ink">
-          {value}
-        </Text>
-        {change && <Badge color={change > 0 ? 'edr-green' : 'edr-red'} size="lg">{change > 0 ? '+' : ''}{change}%</Badge>}
+const StatCard = ({ icon: Icon, label, value, color = 'edr-green', change, href }: StatCardProps) => {
+  const card = (
+    <Card withBorder p="lg" style={{ borderTop: `3px solid ${freightBrand.primary}`, height: '100%' }}>
+      <Group justify="space-between" mb="sm">
+        <ThemeIcon size="xl" radius="md" color={color} variant="light">
+          <Icon size={28} />
+        </ThemeIcon>
       </Group>
-    </Stack>
-  </Card>
-);
+      <Stack gap="xs">
+        <Text size="xs" c="dimmed" fw={500} tt="uppercase">
+          {label}
+        </Text>
+        <Group justify="space-between">
+          <Text fw={700} size="xl" c="edr-ink">
+            {value}
+          </Text>
+          {change && <Badge color={change > 0 ? 'edr-green' : 'edr-red'} size="lg">{change > 0 ? '+' : ''}{change}%</Badge>}
+        </Group>
+      </Stack>
+    </Card>
+  );
+
+  // Wrap in a link to the detail view rather than morphing the Card itself —
+  // keeps Mantine's Card typing clean. Static when no href.
+  return href ? (
+    <Link
+      to={href}
+      aria-label={`${label} — view detail`}
+      className="block h-full cursor-pointer no-underline transition-opacity hover:opacity-90"
+    >
+      {card}
+    </Link>
+  ) : (
+    card
+  );
+};
 
 export function FleetDashboard() {
   const { data: vehicles = [] } = useQuery({
@@ -160,16 +179,16 @@ export function FleetDashboard() {
       {/* Primary Metrics */}
       <Grid mb="xl">
         <Grid.Col span={{ base: 12, sm: 6, md: 3 }}>
-          <StatCard icon={Truck} label="Total Vehicles" value={metrics.totalVehicles} color="edr-green" />
+          <StatCard icon={Truck} label="Total Vehicles" value={metrics.totalVehicles} color="edr-green" href="/dashboard/vehicles" />
         </Grid.Col>
         <Grid.Col span={{ base: 12, sm: 6, md: 3 }}>
-          <StatCard icon={Users} label="Total Drivers" value={metrics.totalDrivers} color="edr-blue" />
+          <StatCard icon={Users} label="Total Drivers" value={metrics.totalDrivers} color="edr-blue" href="/dashboard/drivers" />
         </Grid.Col>
         <Grid.Col span={{ base: 12, sm: 6, md: 3 }}>
-          <StatCard icon={Fuel} label="Fuel Spend" value={etb(metrics.totalFuelSpend)} color="edr-accent" />
+          <StatCard icon={Fuel} label="Fuel Spend" value={etb(metrics.totalFuelSpend)} color="edr-accent" href="/dashboard/fuel-purchases" />
         </Grid.Col>
         <Grid.Col span={{ base: 12, sm: 6, md: 3 }}>
-          <StatCard icon={Wrench} label="Maintenance" value={etb(metrics.totalMaintenanceSpend)} color="edr-red" />
+          <StatCard icon={Wrench} label="Maintenance" value={etb(metrics.totalMaintenanceSpend)} color="edr-red" href="/dashboard/maintenance" />
         </Grid.Col>
       </Grid>
 
diff --git a/apps/edr-freight-web/backoffice/src/pages/fleet/RoutesPage.tsx b/apps/edr-freight-web/backoffice/src/pages/fleet/RoutesPage.tsx
index bdba6dc97..3ea10df7d 100644
--- a/apps/edr-freight-web/backoffice/src/pages/fleet/RoutesPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/fleet/RoutesPage.tsx
@@ -19,7 +19,6 @@ import {
   Divider,
   Group,
   Modal,
-  NumberInput,
   Select,
   SimpleGrid,
   Stack,
@@ -36,6 +35,7 @@ import { useFleetViewMode } from "@/components/fleet/useFleetViewMode";
 import RuleEngineListFooter from "@/components/ruleEngine/RuleEngineListFooter";
 import { ruleEngineTable } from "@/components/ruleEngine/ruleEngineStyles";
 import { api } from "@/services/api";
+import { ruleEngineService } from "@/services/ruleEngine/ruleEngine.service";
 import { useToast } from "@/hooks/use-toast";
 import {
   formatRouteLabel,
@@ -47,7 +47,7 @@ import {
 } from "@/services/routes.service";
 import { DataTable, DataTableFooter, usePagination } from "@edr/ui-common";
 
-type MilestoneFormRow = { yardId: string; distanceKm: string };
+type MilestoneFormRow = { yardId: string };
 
 type RouteFormState = {
   status: RouteStatus;
@@ -56,12 +56,12 @@ type RouteFormState = {
 
 const emptyForm = (): RouteFormState => ({
   status: "AVAILABLE",
-  milestones: [
-    { yardId: "", distanceKm: "0" },
-    { yardId: "", distanceKm: "" },
-  ],
+  milestones: [{ yardId: "" }, { yardId: "" }],
 });
 
+/** Order-insensitive pair key — yard distances are symmetric. */
+const pairKey = (a: string, b: string) => (a < b ? `${a}|${b}` : `${b}|${a}`);
+
 const yardLabel = (yard?: YardRef | null) =>
   yard ? `${yard.label} (${yard.code})` : "—";
 
@@ -163,6 +163,15 @@ export default function RoutesPage() {
 
   const routesQuery = useQuery(api.routes.list.queryOptions());
   const yardsQuery = useQuery(api.routes.yards.queryOptions());
+  // Segment km are configured in Configuration → Yard Distances and resolved
+  // by the API on save; this fetch is only to preview them in the form.
+  const yardDistancesQuery = useQuery({
+    queryKey: ["yard-distances", "all"],
+    queryFn: () =>
+      ruleEngineService.listAll<{ id: string; fromYardId: string; toYardId: string; distanceKm: string }>(
+        "yard-distances",
+      ),
+  });
   const createMutation = useMutation(api.routes.create.mutationOptions());
   const updateMutation = useMutation(api.routes.update.mutationOptions());
   const deactivateMutation = useMutation(api.routes.deactivate.mutationOptions());
@@ -206,15 +215,33 @@ export default function RoutesPage() {
     [yardsQuery.data],
   );
 
-  const formTotalKm = useMemo(
-    () =>
-      form.milestones.reduce(
-        (sum, row, index) =>
-          index === 0 ? sum : sum + Number(row.distanceKm || 0),
-        0,
-      ),
-    [form.milestones],
-  );
+  const distanceByPair = useMemo(() => {
+    const map = new Map<string, number>();
+    for (const row of yardDistancesQuery.data ?? []) {
+      map.set(pairKey(row.fromYardId, row.toYardId), Number(row.distanceKm));
+    }
+    return map;
+  }, [yardDistancesQuery.data]);
+
+  /** Configured km for the segment ending at `index` (undefined = pair not configured yet). */
+  const segmentKm = (index: number): number | undefined => {
+    if (index === 0) return 0;
+    const from = form.milestones[index - 1]?.yardId;
+    const to = form.milestones[index]?.yardId;
+    if (!from || !to) return undefined;
+    return distanceByPair.get(pairKey(from, to));
+  };
+
+  const formTotalKm = useMemo(() => {
+    let total = 0;
+    for (let i = 1; i < form.milestones.length; i++) {
+      const from = form.milestones[i - 1]?.yardId;
+      const to = form.milestones[i]?.yardId;
+      if (!from || !to) continue;
+      total += distanceByPair.get(pairKey(from, to)) ?? 0;
+    }
+    return total;
+  }, [form.milestones, distanceByPair]);
 
   const resetForm = () => {
     setFormOpen(false);
@@ -234,10 +261,7 @@ export default function RoutesPage() {
       status: route.status,
       milestones: [...(route.milestones ?? [])]
         .sort((a, b) => a.sequenceNo - b.sequenceNo)
-        .map((m, index) => ({
-          yardId: m.yardId,
-          distanceKm: String(index === 0 ? 0 : (m.distanceKm ?? "")),
-        })),
+        .map((m) => ({ yardId: m.yardId })),
     });
     setFormOpen(true);
   };
@@ -254,7 +278,7 @@ export default function RoutesPage() {
   const addMilestone = () => {
     setForm((current) => ({
       ...current,
-      milestones: [...current.milestones, { yardId: "", distanceKm: "" }],
+      milestones: [...current.milestones, { yardId: "" }],
     }));
   };
 
@@ -267,11 +291,7 @@ export default function RoutesPage() {
 
   const buildPayload = () => ({
     status: form.status,
-    milestones: form.milestones.map((row, index) => ({
-      yardId: row.yardId,
-      distanceKm:
-        index === 0 ? 0 : row.distanceKm ? Number(row.distanceKm) : undefined,
-    })),
+    milestones: form.milestones.map((row) => ({ yardId: row.yardId })),
   });
 
   const handleSubmit = async (event: FormEvent) => {
@@ -284,12 +304,23 @@ export default function RoutesPage() {
       });
       return;
     }
-    for (let i = 1; i < form.milestones.length; i++) {
-      const km = Number(form.milestones[i].distanceKm);
-      if (!form.milestones[i].distanceKm || Number.isNaN(km) || km < 0) {
+    // Pre-empt the API's missing-pair rejection with a readable message; if the
+    // distance list failed to load, skip and let the API validate.
+    if (yardDistancesQuery.data) {
+      const missing: string[] = [];
+      for (let i = 1; i < form.milestones.length; i++) {
+        const from = form.milestones[i - 1].yardId;
+        const to = form.milestones[i].yardId;
+        if (!distanceByPair.has(pairKey(from, to))) {
+          const label = (id: string) =>
+            yardOptions.find((o) => o.value === id)?.label ?? id;
+          missing.push(`${label(from)} ↔ ${label(to)}`);
+        }
+      }
+      if (missing.length > 0) {
         toast({
           title: "Save failed",
-          description: `Enter segment KM for stop ${i + 1}`,
+          description: `No distance configured for: ${missing.join(", ")}. Add it under Configuration → Yard Distances first.`,
           variant: "destructive",
         });
         return;
@@ -580,8 +611,11 @@ export default function RoutesPage() {
                   : index === form.milestones.length - 1
                     ? "Destination"
                     : "Milestone";
+              const km = segmentKm(index);
+              const bothSelected =
+                index > 0 && Boolean(row.yardId && form.milestones[index - 1]?.yardId);
               return (
-                <Group key={`${role}-${index}`} align="flex-end" wrap="nowrap" gap="sm">
+                <Group key={`${role}-${index}`} align="center" wrap="nowrap" gap="sm">
                   <Text w={90} size="sm" fw={500}>
                     {role}
                   </Text>
@@ -594,16 +628,25 @@ export default function RoutesPage() {
                     searchable
                   />
                   {index > 0 ? (
-                    <NumberInput
-                      w={120}
-                      label="KM"
-                      min={0}
-                      decimalScale={2}
-                      value={row.distanceKm ? Number(row.distanceKm) : ""}
-                      onChange={(value) =>
-                        setMilestone(index, { distanceKm: String(value ?? "") })
-                      }
-                    />
+                    <Box w={120}>
+                      {bothSelected ? (
+                        km != null ? (
+                          <Text size="sm" fw={600} ta="right">
+                            {km} km
+                          </Text>
+                        ) : (
+                          <Tooltip label="No distance configured for this yard pair — add it under Configuration → Yard Distances">
+                            <Text size="xs" c="red.7" fw={600} ta="right">
+                              Not configured
+                            </Text>
+                          </Tooltip>
+                        )
+                      ) : (
+                        <Text size="xs" c="dimmed" ta="right">
+                          — km
+                        </Text>
+                      )}
+                    </Box>
                   ) : (
                     <Box w={120} />
                   )}
@@ -619,7 +662,8 @@ export default function RoutesPage() {
               );
             })}
             <Text size="sm" c="dimmed">
-              Total route distance: <strong>{formTotalKm} km</strong>
+              Total route distance: <strong>{formTotalKm} km</strong> — segment
+              distances come from Configuration → Yard Distances
             </Text>
             <Group justify="flex-end">
               <Button variant="default" type="button" onClick={resetForm}>
diff --git a/apps/edr-freight-web/backoffice/src/pages/fleet/config/resources.ts b/apps/edr-freight-web/backoffice/src/pages/fleet/config/resources.ts
index 3487cbed8..0e6633eab 100644
--- a/apps/edr-freight-web/backoffice/src/pages/fleet/config/resources.ts
+++ b/apps/edr-freight-web/backoffice/src/pages/fleet/config/resources.ts
@@ -69,6 +69,11 @@ export interface FleetFormFieldDef extends FormFieldDef {
    * (e.g. a license expiry); "past" (default) = cannot be in the future.
    */
   dateBound?: "past" | "future";
+  /**
+   * Format the value must match, checked on submit. The value is upper-cased and
+   * trimmed before the test, matching the server. Empty optional fields skip it.
+   */
+  pattern?: { regex: RegExp; message: string; uppercase?: boolean };
 }
 
 export interface FleetListFilterDef {
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 eb1508601..f25be0ff7 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
@@ -1,5 +1,15 @@
 import type { FleetResourceConfig } from "./resources";
 
+/**
+ * A plate is two or three letters, a hyphen, then two to six digits — ET-9875,
+ * AA-8642. Mirrors VEHICLE_PLATE_REGEX on the API so the form and the server
+ * agree on what a plate looks like.
+ */
+const PLATE_PATTERN = {
+  regex: /^[A-Z]{2,3}-\d{2,6}$/,
+  message: "Use letters and numbers like ET-9875 or AA-8642",
+};
+
 const VEHICLE_TYPE_OPTIONS = [
   { label: "Truck", value: "TRUCK" },
   { label: "Van", value: "VAN" },
@@ -77,9 +87,9 @@ export const vehiclesConfig: FleetResourceConfig = {
   ],
   formFields: [
     { name: "code", label: "Code", type: "text" },
-    { name: "plateNumber", label: "Power Plate No", type: "text", required: true },
+    { name: "plateNumber", label: "Power Plate No", type: "text", required: true, pattern: PLATE_PATTERN },
     // { name: "powerPlateNo", label: "Power Plate No", type: "text" },
-    { name: "trailerPlateNo", label: "Trailer Plate No", type: "text" },
+    { name: "trailerPlateNo", label: "Trailer Plate No", type: "text", pattern: PLATE_PATTERN },
     { name: "vehicleType", label: "Vehicle Type", type: "select", required: true, options: VEHICLE_TYPE_OPTIONS },
     { name: "manufacturer", label: "Manufacturer", type: "text", required: true },
     { name: "model", label: "Model", type: "text", required: true },
diff --git a/apps/edr-freight-web/backoffice/src/pages/ruleEngine/RuleEngineResourcePage.tsx b/apps/edr-freight-web/backoffice/src/pages/ruleEngine/RuleEngineResourcePage.tsx
index bbc2d75a9..3057f9c11 100644
--- a/apps/edr-freight-web/backoffice/src/pages/ruleEngine/RuleEngineResourcePage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/ruleEngine/RuleEngineResourcePage.tsx
@@ -244,7 +244,12 @@ const RuleEngineResourcePage = () => {
   const { data: wagonTypeOptions, isLoading: wagonTypeOptionsLoading } =
     useWagonTypeOptions(usesWagonTypeField);
   const usesYardField = Boolean(
-    config?.formFields.some((f) => f.name === "originYardId"),
+    config?.formFields.some(
+      (f) =>
+        f.name === "originYardId" ||
+        f.name === "fromYardId" ||
+        f.name === "toYardId",
+    ),
   );
   const { data: yardOptions, isLoading: yardOptionsLoading } =
     useYardOptions(usesYardField);
@@ -347,6 +352,19 @@ const RuleEngineResourcePage = () => {
       // trade actually sits in, so an import can't be configured as if it
       // started inland. Resolved per keystroke because the legal set changes
       // with the direction the admin picks.
+      // Yard-distance endpoints have no country restriction — any yard can pair
+      // with any other; the other end is just excluded so A↔A can't be entered.
+      if (field.name === "fromYardId" || field.name === "toYardId") {
+        const otherEnd = field.name === "fromYardId" ? "toYardId" : "fromYardId";
+        return {
+          ...field,
+          type: "select" as const,
+          optionsFromValues: (values: Record<string, unknown>) =>
+            (yardOptions ?? [])
+              .filter(({ value }) => value !== String(values[otherEnd] ?? ""))
+              .map(({ label, value }) => ({ label, value })),
+        };
+      }
       if (field.name === "originYardId" || field.name === "destinationYardId") {
         const end = field.name === "originYardId" ? "origin" : "destination";
         return {
@@ -604,7 +622,7 @@ const RuleEngineResourcePage = () => {
         title={config.label}
         subtitle={config.subtitle}
         action={
-          canManage ? (
+          canManage && config.slug !== "container-types" ? (
             <Button leftSection={<Plus size={18} />} onClick={openCreate}>
               {addLabel}
             </Button>
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 4cf0f623d..2543addc0 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
@@ -1,4 +1,5 @@
 import type { SidebarItem } from "@/components/layout/types";
+import { ruleEngineViewKey } from "@/lib/permissions";
 import type { RuleEngineResourceSlug } from "@/types/rule-engine";
 
 export type RuleEngineNavCategory = "configuration" | "rules";
@@ -348,6 +349,7 @@ export const RULE_ENGINE_RESOURCES: RuleEngineResourceConfig[] = [
       activeColumn,
     ],
     formFields: [
+      { name: "code", label: "Code", type: "text", required: true },
       { name: "name", label: "Name", type: "text", required: true },
       { name: "capacityTons", label: "Capacity (tons)", type: "number", required: true },
       { name: "lengthMeters", label: "Length (meters)", type: "number", required: true },
@@ -370,6 +372,34 @@ export const RULE_ENGINE_RESOURCES: RuleEngineResourceConfig[] = [
       { name: "isActive", label: "Active", type: "boolean" },
     ],
   },
+  {
+    slug: "yard-distances",
+    label: "Yard Distances",
+    category: "configuration",
+    subtitle: "Rail distance between yard pairs — routes read their segment km from here",
+    searchPlaceholder: "Search by yard name or code...",
+    supportsSearch: true,
+    cardTitleKey: "fromYardLabel",
+    cardSubtitleKey: "toYardLabel",
+    columns: [
+      { id: "fromYardLabel", header: "From yard", accessorKey: "fromYardLabel" },
+      { id: "toYardLabel", header: "To yard", accessorKey: "toYardLabel" },
+      { id: "distanceKm", header: "Distance (km)", accessorKey: "distanceKm", format: "number" },
+    ],
+    formFields: [
+      // Options injected at render from useYardOptions (RuleEngineResourcePage).
+      { name: "fromYardId", label: "From yard", type: "select", required: true, placeholder: "Select yard" },
+      { name: "toYardId", label: "To yard", type: "select", required: true, placeholder: "Select yard" },
+      {
+        name: "distanceKm",
+        label: "Distance (km)",
+        type: "number",
+        required: true,
+        description:
+          "Symmetric — one entry covers both directions. Route segments between these yards use this value.",
+      },
+    ],
+  },
   {
     slug: "priority-configs",
     label: "Priority Rules",
@@ -758,6 +788,7 @@ export const getCategorySidebarChildren = (
   RULE_ENGINE_RESOURCES.filter((r) => r.category === category).map((r) => ({
     label: r.label,
     href: ruleEngineResourcePath(r.slug),
+    permission: ruleEngineViewKey(r.slug),
   }));
 
 export const DEFAULT_CONFIGURATION_SLUG: RuleEngineResourceSlug = "cargo-types";
diff --git a/apps/edr-freight-web/backoffice/src/pages/trainBuilder/TrainBuilderDetailPage.tsx b/apps/edr-freight-web/backoffice/src/pages/trainBuilder/TrainBuilderDetailPage.tsx
index 16f55cf00..3841bc989 100644
--- a/apps/edr-freight-web/backoffice/src/pages/trainBuilder/TrainBuilderDetailPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/trainBuilder/TrainBuilderDetailPage.tsx
@@ -36,8 +36,11 @@ import ChangeYardModal from "@/components/trainBuilder/ChangeYardModal";
 import ConsistWagonList from "@/components/trainBuilder/ConsistWagonList";
 import {
   directionColor,
+  locomotiveStatusColor,
+  locomotiveStatusLabel,
   trainStatusColor,
   trainStatusLabel,
+  UNFIT_LOCOMOTIVE_STATUSES,
 } from "@/components/trainBuilder/trainStatus";
 import { TrainCompositionDiagram } from "@/components/trainScheduling/TrainCompositionDiagram";
 import { KpiStrip, PageContainer, PageHeader } from "@/components/page";
@@ -131,6 +134,9 @@ export default function TrainBuilderDetailPage() {
 
   const { totals } = composition;
   const yard = composition.currentYard;
+  const blockingLocomotives = composition.locomotives.filter((loco) =>
+    UNFIT_LOCOMOTIVE_STATUSES.has(loco.status),
+  );
 
   return (
     <PageContainer>
@@ -180,6 +186,7 @@ export default function TrainBuilderDetailPage() {
               {composition.status === "DEACTIVATED" ? (
                 <Menu.Item
                   leftSection={<Power size={15} />}
+                  disabled={blockingLocomotives.length > 0}
                   onClick={() =>
                     void withToast(async () => {
                       await activate.mutateAsync(composition.id);
@@ -234,6 +241,59 @@ export default function TrainBuilderDetailPage() {
         </Alert>
       ) : null}
 
+      {composition.status === "DEACTIVATED" && blockingLocomotives.length > 0 ? (
+        <Alert color="red" icon={<AlertTriangle size={16} />}>
+          <Stack gap="xs">
+            <Text size="sm">
+              Cannot reactivate — {blockingLocomotives.length > 1 ? "these locomotives are" : "this locomotive is"}{" "}
+              not fit for service:{" "}
+              {blockingLocomotives.map((loco, i) => (
+                <span key={loco.id}>
+                  {i > 0 ? ", " : ""}
+                  <Text span fw={600} ff="monospace">
+                    {loco.code}
+                  </Text>{" "}
+                  ({locomotiveStatusLabel(loco.status)})
+                </span>
+              ))}
+              .
+            </Text>
+            <Group gap="xs">
+              <Button
+                size="compact-sm"
+                variant="light"
+                color="red"
+                leftSection={<Replace size={14} />}
+                disabled={!composition.editable}
+                onClick={() => setLocoModalOpen(true)}
+              >
+                Detach & replace locomotives
+              </Button>
+              <Button
+                size="compact-sm"
+                variant="subtle"
+                onClick={() => navigate(`/dashboard/locomotives`)}
+              >
+                Go to locomotives
+              </Button>
+            </Group>
+          </Stack>
+        </Alert>
+      ) : null}
+
+      <Group gap="xs">
+        {composition.locomotives.map((loco) => (
+          <Badge
+            key={loco.id}
+            variant="light"
+            color={locomotiveStatusColor(loco.status)}
+            leftSection={<TrainFront size={12} />}
+          >
+            {loco.code} · {locomotiveStatusLabel(loco.status)}
+          </Badge>
+        ))}
+      </Group>
+
       <Stack gap="sm">
         <TrainCompositionDiagram
           locomotives={composition.locomotives.map((loco) => ({
diff --git a/apps/edr-freight-web/backoffice/src/pages/trainScheduling/BatchScheduleDetailPage.tsx b/apps/edr-freight-web/backoffice/src/pages/trainScheduling/BatchScheduleDetailPage.tsx
index 58d027c8c..1e3735961 100644
--- a/apps/edr-freight-web/backoffice/src/pages/trainScheduling/BatchScheduleDetailPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/trainScheduling/BatchScheduleDetailPage.tsx
@@ -866,7 +866,7 @@ export default function BatchScheduleDetailPage() {
                 >
                   Refresh
                 </Button>
-                {data.train && ["DRAFT", "SCHEDULED"].includes(data.status) ? (
+                {/* {data.train && ["DRAFT", "SCHEDULED"].includes(data.status) ? (
                   <Button
                     variant="light"
                     color="edr-green"
@@ -876,7 +876,7 @@ export default function BatchScheduleDetailPage() {
                   >
                     Adjust consist
                   </Button>
-                ) : null}
+                ) : null} */}
                 {data.windowPhase === "DOC_REVIEW" ? (
                   <Button
                     color="yellow"
diff --git a/apps/edr-freight-web/backoffice/src/pages/trainScheduling/TrainScheduleV2DetailPage.tsx b/apps/edr-freight-web/backoffice/src/pages/trainScheduling/TrainScheduleV2DetailPage.tsx
index 2d7e69cc1..ddd01a11f 100644
--- a/apps/edr-freight-web/backoffice/src/pages/trainScheduling/TrainScheduleV2DetailPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/trainScheduling/TrainScheduleV2DetailPage.tsx
@@ -59,6 +59,7 @@ import { ScheduleWorkspacePanel } from "@/components/trainScheduling/ScheduleWor
 import { FreightTypeBadge } from "@/components/trainScheduling/ScheduleStatusBadge";
 import {
   RouteCorridor,
+  SegmentOccupancyStrip,
   StatusPill,
   scheduleBrand,
 } from "@/components/trainScheduling/scheduleVisuals";
@@ -388,12 +389,22 @@ export default function TrainScheduleV2DetailPage() {
   const unloadedCount = dispatchBookings.filter(
     (b) => b.wagonAssigned && (b.loadingStatus ?? "UNLOADED") !== "LOADED",
   ).length;
+  // Intercity ride-alongs load through the journey flow (Load at their origin
+  // yard), not the workspace toggle — dispatching before that leaves paid cargo
+  // stranded on the platform while its train departs.
+  const intercityNotLoadedCount = dispatchBookings.filter(
+    (b) =>
+      b.tradeDirection === "DOMESTIC" &&
+      !b.loadedAt &&
+      !["IN_TRANSIT", "COMPLETED"].includes(b.status ?? ""),
+  ).length;
   // Import-Djibouti trains are HARD-blocked from dispatch until loading is
   // confirmed in the workspace — surface it as a blocker, not just a warning.
   const loadingBlocksDispatch =
     schedule.requiresLoadingConfirmation === true &&
     schedule.loadingConfirmed !== true;
-  const hasDispatchWarnings = unassignedCount > 0 || unloadedCount > 0;
+  const hasDispatchWarnings =
+    unassignedCount > 0 || unloadedCount > 0 || intercityNotLoadedCount > 0;
 
   const finalizeStep = hasContainerStep ? 3 : 2;
   const canModifyBookings = canEditBookings && !["DISPATCHED", "ARRIVED"].includes(schedule.status);
@@ -916,17 +927,28 @@ export default function TrainScheduleV2DetailPage() {
                     </Text>
                   ) : null}
                 </Group>
-                <Box maw={340}>
-                  <RouteCorridor
-                    origin={
-                      schedule.originStation?.label ?? schedule.originStation?.code
-                    }
-                    destination={
-                      schedule.destinationStation?.label ??
-                      schedule.destinationStation?.code
-                    }
+                {(schedule.stops?.length ?? 0) >= 3 ||
+                (schedule.bookings ?? []).some(
+                  (b) => b.tradeDirection === "DOMESTIC",
+                ) ? (
+                  <SegmentOccupancyStrip
+                    stops={schedule.stops ?? []}
+                    bookings={schedule.bookings ?? []}
+                    maxWagons={schedule.maxWagons}
                   />
-                </Box>
+                ) : (
+                  <Box maw={340}>
+                    <RouteCorridor
+                      origin={
+                        schedule.originStation?.label ?? schedule.originStation?.code
+                      }
+                      destination={
+                        schedule.destinationStation?.label ??
+                        schedule.destinationStation?.code
+                      }
+                    />
+                  </Box>
+                )}
                 <Group gap="sm" align="center">
                   <FreightTypeBadge freightType={schedule.freightType} />
                   <StatusPill status={schedule.status} />
@@ -1059,6 +1081,14 @@ export default function TrainScheduleV2DetailPage() {
           {
             label: "Bookings",
             value: schedule.bookings?.length ?? 0,
+            hint: (() => {
+              const intercity = (schedule.bookings ?? []).filter(
+                (b) => b.tradeDirection === "DOMESTIC",
+              ).length;
+              return intercity > 0
+                ? `${intercity} intercity ride-along${intercity === 1 ? "" : "s"}`
+                : undefined;
+            })(),
             icon: Package,
           },
           {
@@ -1282,6 +1312,16 @@ export default function TrainScheduleV2DetailPage() {
                     unloaded
                   </List.Item>
                 ) : null}
+                {intercityNotLoadedCount > 0 ? (
+                  <List.Item>
+                    <Text span fw={700}>
+                      {intercityNotLoadedCount}
+                    </Text>{" "}
+                    intercity ride-along{intercityNotLoadedCount === 1 ? "" : "s"} not
+                    loaded yet — load them from the Workspace tab (Yard work) before
+                    the train leaves their origin yard
+                  </List.Item>
+                ) : null}
               </List>
               <Text size="xs" c="dimmed" mt={6}>
                 You can still dispatch — confirm to proceed.
diff --git a/apps/edr-freight-web/backoffice/src/pages/warehouses/TrucksOnSitePage.tsx b/apps/edr-freight-web/backoffice/src/pages/warehouses/TrucksOnSitePage.tsx
index 9d2ae0e63..8210d7784 100644
--- a/apps/edr-freight-web/backoffice/src/pages/warehouses/TrucksOnSitePage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/warehouses/TrucksOnSitePage.tsx
@@ -1,4 +1,5 @@
 import { useMemo, useState } from "react";
+import { useSearchParams } from "react-router-dom";
 import {
   Alert,
   Badge,
@@ -47,15 +48,16 @@ function Rows({ rows }: { rows: TruckOnSite[] }) {
   if (rows.length === 0) {
     return (
       <Alert variant="light" color="gray">
-        No trucks on site.
+        No trucks assigned or on site.
       </Alert>
     );
   }
   return (
-    <Table.ScrollContainer minWidth={980}>
+    <Table.ScrollContainer minWidth={1040}>
       <Table striped highlightOnHover verticalSpacing="xs">
         <Table.Thead>
           <Table.Tr>
+            <Table.Th>Status</Table.Th>
             <Table.Th>Plate</Table.Th>
             <Table.Th>Haulage</Table.Th>
             <Table.Th>Driver</Table.Th>
@@ -69,6 +71,16 @@ function Rows({ rows }: { rows: TruckOnSite[] }) {
         <Table.Tbody>
           {rows.map((row) => (
             <Table.Tr key={`${row.source}-${row.assignmentId}`}>
+              <Table.Td>
+                <Badge
+                  size="sm"
+                  radius="sm"
+                  variant={row.status === "ON_SITE" ? "filled" : "light"}
+                  color={row.status === "ON_SITE" ? "edr-green" : "gray"}
+                >
+                  {row.status === "ON_SITE" ? "On site" : "Inbound"}
+                </Badge>
+              </Table.Td>
               <Table.Td>
                 <Text size="sm" fw={600}>
                   {row.plateNumber ?? "—"}
@@ -101,9 +113,13 @@ function Rows({ rows }: { rows: TruckOnSite[] }) {
                 <Text size="sm">{row.containers ?? "Bulk"}</Text>
               </Table.Td>
               <Table.Td>
-                {isLongDwell(row.arrivedAt) ? (
+                {row.arrivedAt == null ? (
+                  <Text size="sm" c="dimmed">
+                    —
+                  </Text>
+                ) : isLongDwell(row.arrivedAt) ? (
                   <Tooltip
-                    label={`On site over ${LONG_DWELL_HOURS}h — arrived ${new Date(row.arrivedAt as string).toLocaleString()}`}
+                    label={`On site over ${LONG_DWELL_HOURS}h — arrived ${new Date(row.arrivedAt).toLocaleString()}`}
                     withArrow
                   >
                     <Text size="sm" c="red" fw={600}>
@@ -124,12 +140,20 @@ function Rows({ rows }: { rows: TruckOnSite[] }) {
 
 export default function TrucksOnSitePage() {
   const { data: trucks = [], isLoading } = useTrucksOnSite();
+  // The dashboard's "Trucks on-site" card counts only arrived trucks, so it
+  // deep-links here with ?scope=ON_SITE to land on the matching tab.
+  const [searchParams] = useSearchParams();
+  const scopeParam = searchParams.get("scope");
+  const [scope, setScope] = useState<"ALL" | "ON_SITE" | "INBOUND">(
+    scopeParam === "ON_SITE" || scopeParam === "INBOUND" ? scopeParam : "ALL",
+  );
   const [source, setSource] = useState<"ALL" | "CUSTOMER" | "EDR">("ALL");
   const [search, setSearch] = useState("");
 
   const rows = useMemo(() => {
     const term = search.trim().toLowerCase();
     return trucks
+      .filter((t) => scope === "ALL" || t.status === scope)
       .filter((t) => source === "ALL" || t.source === source)
       .filter((t) =>
         !term
@@ -137,8 +161,10 @@ export default function TrucksOnSitePage() {
           : [t.plateNumber, t.driverName, t.bookingReference, t.customerName, t.containers]
               .some((field) => field?.toLowerCase().includes(term)),
       );
-  }, [trucks, source, search]);
+  }, [trucks, scope, source, search]);
 
+  const onSiteCount = trucks.filter((t) => t.status === "ON_SITE").length;
+  const inboundCount = trucks.length - onSiteCount;
   const customerCount = trucks.filter((t) => t.source === "CUSTOMER").length;
   const edrCount = trucks.length - customerCount;
 
@@ -146,20 +172,32 @@ export default function TrucksOnSitePage() {
     <PageContainer>
       <PageHeader
         title="Trucks on site"
-        subtitle="Arrived at the yard and not yet left — customer self-haul and EDR last-mile."
+        subtitle="Customer self-haul and EDR last-mile trucks — assigned (inbound) or arrived, until they leave the yard."
       />
 
       <Group justify="space-between" mb="md" wrap="wrap" gap="sm">
-        <SegmentedControl
-          size="xs"
-          value={source}
-          onChange={(v) => setSource(v as typeof source)}
-          data={[
-            { label: `All (${trucks.length})`, value: "ALL" },
-            { label: `Customer (${customerCount})`, value: "CUSTOMER" },
-            { label: `EDR (${edrCount})`, value: "EDR" },
-          ]}
-        />
+        <Group gap="sm" wrap="wrap">
+          <SegmentedControl
+            size="xs"
+            value={scope}
+            onChange={(v) => setScope(v as typeof scope)}
+            data={[
+              { label: `All (${trucks.length})`, value: "ALL" },
+              { label: `On site (${onSiteCount})`, value: "ON_SITE" },
+              { label: `Inbound (${inboundCount})`, value: "INBOUND" },
+            ]}
+          />
+          <SegmentedControl
+            size="xs"
+            value={source}
+            onChange={(v) => setSource(v as typeof source)}
+            data={[
+              { label: "All", value: "ALL" },
+              { label: `Customer (${customerCount})`, value: "CUSTOMER" },
+              { label: `EDR (${edrCount})`, value: "EDR" },
+            ]}
+          />
+        </Group>
         <TextInput
           size="xs"
           w={280}
diff --git a/apps/edr-freight-web/backoffice/src/pages/warehouses/WarehouseInventoryPage.tsx b/apps/edr-freight-web/backoffice/src/pages/warehouses/WarehouseInventoryPage.tsx
index 6f0d27580..be33c30f5 100644
--- a/apps/edr-freight-web/backoffice/src/pages/warehouses/WarehouseInventoryPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/warehouses/WarehouseInventoryPage.tsx
@@ -2,7 +2,7 @@ import { useMemo, useState } from 'react';
 import { useNavigate, useSearchParams } from 'react-router-dom';
 import { Button, Card, Group, Select, Stack, TextInput } from '@mantine/core';
 import { useDebouncedValue } from '@mantine/hooks';
-import { PackageOpen, Search, Truck } from 'lucide-react';
+import { PackageOpen, Search, Truck, X } from 'lucide-react';
 
 import { PageContainer, PageHeader } from '@/components/page';
 import {
@@ -25,14 +25,36 @@ export default function WarehouseInventoryPage() {
   const [filter, setFilter] = useState<InventoryFilter>(
     initialStatus ? { status: initialStatus } : {},
   );
+  // KPI drill-downs arriving from the ops dashboard cards; each shows as a
+  // dismissible chip so the list can be widened back out in place.
+  const [quick, setQuick] = useState<
+    Pick<InventoryFilter, 'receivedToday' | 'pendingInspection' | 'agingOverDays'>
+  >(() => {
+    const aging = Number(searchParams.get('agingOverDays'));
+    return {
+      receivedToday: searchParams.get('receivedToday') ? true : undefined,
+      pendingInspection: searchParams.get('pendingInspection') ? true : undefined,
+      agingOverDays: Number.isFinite(aging) && aging > 0 ? aging : undefined,
+    };
+  });
   const [search, setSearch] = useState('');
 
   const [debouncedSearch] = useDebouncedValue(search, 300);
   const queryFilter = useMemo<InventoryFilter>(
-    () => ({ ...filter, direction, search: debouncedSearch || undefined }),
-    [filter, direction, debouncedSearch],
+    () => ({ ...filter, ...quick, direction, search: debouncedSearch || undefined }),
+    [filter, quick, direction, debouncedSearch],
   );
 
+  const quickChips: Array<{ key: keyof typeof quick; label: string }> = [
+    ...(quick.receivedToday ? [{ key: 'receivedToday' as const, label: 'Received today' }] : []),
+    ...(quick.pendingInspection
+      ? [{ key: 'pendingInspection' as const, label: 'Pending inspection' }]
+      : []),
+    ...(quick.agingOverDays
+      ? [{ key: 'agingOverDays' as const, label: `In warehouse >${quick.agingOverDays}d` }]
+      : []),
+  ];
+
   const warehousesQuery = useWarehouses();
   const yardsQuery = useWarehouseYards(filter.warehouseId);
   const zonesQuery = useWarehouseZones(filter.yardId);
@@ -136,6 +158,17 @@ export default function WarehouseInventoryPage() {
               }
               w={200}
             />
+            {quickChips.map((chip) => (
+              <Button
+                key={chip.key}
+                size="compact-xs"
+                variant="light"
+                rightSection={<X size={12} />}
+                onClick={() => setQuick((q) => ({ ...q, [chip.key]: undefined }))}
+              >
+                {chip.label}
+              </Button>
+            ))}
           </Group>
 
           <InventoryWorkbench items={inventoryQuery.data ?? []} isLoading={inventoryQuery.isLoading} />
diff --git a/apps/edr-freight-web/backoffice/src/services/api.ts b/apps/edr-freight-web/backoffice/src/services/api.ts
index 911dde587..71005f6a1 100644
--- a/apps/edr-freight-web/backoffice/src/services/api.ts
+++ b/apps/edr-freight-web/backoffice/src/services/api.ts
@@ -814,6 +814,20 @@ export const api = {
       undefined,
       () => [QUERY_KEYS.TRAIN_SCHEDULING.ROOT],
     ),
+
+    moveWagonLoad: endpoint<
+      { scheduleId: string; wagonId: string; targetWagonId: string },
+      TrainScheduleDetail
+    >(
+      "train-scheduling",
+      "move-wagon-load",
+      ({ scheduleId, wagonId, targetWagonId }) =>
+        trainSchedulingService.moveWagonLoad(scheduleId, wagonId, {
+          targetWagonId,
+        }),
+      undefined,
+      () => [QUERY_KEYS.TRAIN_SCHEDULING.ROOT],
+    ),
   },
 
   warehouses: {
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 19f1d3b96..3fe815139 100644
--- a/apps/edr-freight-web/backoffice/src/services/contracts.service.ts
+++ b/apps/edr-freight-web/backoffice/src/services/contracts.service.ts
@@ -229,15 +229,26 @@ export const contractsService = {
   approveStep: ({ id, stepId }: { id: string; stepId: string }) =>
     postContract<Freight.IContract>(C.APPROVE_STEP(id, stepId)),
 
+  /**
+   * Reject the current step. Without `returnToStepId` the contract is rejected
+   * to the customer (terminal). With it, the contract is sent back to that
+   * earlier approved step and the chain re-runs from there.
+   */
   rejectStep: ({
     id,
     stepId,
     reason,
+    returnToStepId,
   }: {
     id: string;
     stepId: string;
     reason: string;
-  }) => postContract<Freight.IContract>(C.REJECT_STEP(id, stepId), { reason }),
+    returnToStepId?: string;
+  }) =>
+    postContract<Freight.IContract>(C.REJECT_STEP(id, stepId), {
+      reason,
+      ...(returnToStepId ? { returnToStepId } : {}),
+    }),
 
   // ── Contract document ──
   generateContract: (id: string) =>
diff --git a/apps/edr-freight-web/backoffice/src/services/locomotives.service.ts b/apps/edr-freight-web/backoffice/src/services/locomotives.service.ts
index 3c96b3cfb..be8a37719 100644
--- a/apps/edr-freight-web/backoffice/src/services/locomotives.service.ts
+++ b/apps/edr-freight-web/backoffice/src/services/locomotives.service.ts
@@ -15,6 +15,10 @@ export type LocomotiveStatus =
 export interface LocomotiveListFilters {
   status?: LocomotiveStatus;
   currentYardId?: string;
+  /** Drop locos already coupled to a built train (train-builder picker). */
+  excludeCoupled?: boolean;
+  /** With excludeCoupled: keep THIS train's own coupled locos in the list. */
+  excludeTrainId?: string;
 }
 
 export interface Locomotive {
@@ -48,6 +52,8 @@ export const locomotivesService = {
     const params = new URLSearchParams();
     if (filters.status) params.set('status', filters.status);
     if (filters.currentYardId) params.set('currentYardId', filters.currentYardId);
+    if (filters.excludeCoupled) params.set('excludeCoupled', 'true');
+    if (filters.excludeTrainId) params.set('excludeTrainId', filters.excludeTrainId);
     const qs = params.toString();
     return apiClient.get<Locomotive[]>(
       `${URL_CONSTANTS.LOCOMOTIVES.BASE}${qs ? `?${qs}` : ''}`,
diff --git a/apps/edr-freight-web/backoffice/src/services/routes.service.ts b/apps/edr-freight-web/backoffice/src/services/routes.service.ts
index 5fda0c7b2..f279f3f1e 100644
--- a/apps/edr-freight-web/backoffice/src/services/routes.service.ts
+++ b/apps/edr-freight-web/backoffice/src/services/routes.service.ts
@@ -35,8 +35,9 @@ export interface RouteRecord {
   milestones?: RouteMilestone[];
 }
 
+/** Segment km are resolved server-side from configured yard distances. */
 export interface SaveRoutePayload {
-  milestones: Array<{ yardId: string; distanceKm?: number }>;
+  milestones: Array<{ yardId: string }>;
   status?: RouteStatus;
 }
 
diff --git a/apps/edr-freight-web/backoffice/src/services/ruleEngine/ruleEngine.service.ts b/apps/edr-freight-web/backoffice/src/services/ruleEngine/ruleEngine.service.ts
index 2ba9de2af..a1e36ce0a 100644
--- a/apps/edr-freight-web/backoffice/src/services/ruleEngine/ruleEngine.service.ts
+++ b/apps/edr-freight-web/backoffice/src/services/ruleEngine/ruleEngine.service.ts
@@ -86,6 +86,7 @@ const RESOURCE_BASE: Record<RuleEngineResourceSlug, string> = {
   "service-types": URL_CONSTANTS.RULE_ENGINE.SERVICE_TYPES,
   "weight-limit-rules": URL_CONSTANTS.RULE_ENGINE.WEIGHT_LIMIT_RULES,
   yards: URL_CONSTANTS.RULE_ENGINE.YARDS,
+  "yard-distances": URL_CONSTANTS.RULE_ENGINE.YARD_DISTANCES,
   "shipping-lines": URL_CONSTANTS.RULE_ENGINE.SHIPPING_LINES,
   rates: URL_CONSTANTS.RULE_ENGINE.RATES,
   "approval-rules": URL_CONSTANTS.RULE_ENGINE.APPROVAL_RULES,
@@ -107,6 +108,8 @@ const byIdPath = (resource: RuleEngineResourceSlug, id: string): string => {
       return URL_CONSTANTS.RULE_ENGINE.WEIGHT_LIMIT_RULE_BY_ID(id);
     case "yards":
       return URL_CONSTANTS.RULE_ENGINE.YARD_BY_ID(id);
+    case "yard-distances":
+      return URL_CONSTANTS.RULE_ENGINE.YARD_DISTANCE_BY_ID(id);
     case "shipping-lines":
       return URL_CONSTANTS.RULE_ENGINE.SHIPPING_LINE_BY_ID(id);
     case "rates":
diff --git a/apps/edr-freight-web/backoffice/src/services/trainScheduling.service.ts b/apps/edr-freight-web/backoffice/src/services/trainScheduling.service.ts
index 1eb43a048..5f9071eb8 100644
--- a/apps/edr-freight-web/backoffice/src/services/trainScheduling.service.ts
+++ b/apps/edr-freight-web/backoffice/src/services/trainScheduling.service.ts
@@ -757,6 +757,18 @@ export const trainSchedulingService = {
     return unwrap(response.data);
   },
 
+  moveWagonLoad: async (
+    scheduleId: string,
+    wagonId: string,
+    payload: { targetWagonId: string },
+  ): Promise<TrainScheduleDetail> => {
+    const response = await client.post<TrainScheduleDetail>(
+      URL_CONSTANTS.TRAIN_SCHEDULING.MOVE_WAGON_LOAD(scheduleId, wagonId),
+      payload,
+    );
+    return unwrap(response.data);
+  },
+
   getUnassignedBookings: async (
     scheduleId: string,
   ): Promise<UnassignedBookingsResponse> => {
diff --git a/apps/edr-freight-web/backoffice/src/services/warehouse.service.ts b/apps/edr-freight-web/backoffice/src/services/warehouse.service.ts
index 9eb089f19..0d1d01c3d 100644
--- a/apps/edr-freight-web/backoffice/src/services/warehouse.service.ts
+++ b/apps/edr-freight-web/backoffice/src/services/warehouse.service.ts
@@ -144,6 +144,8 @@ export interface LastMileArrivalTruck {
   driverPhone: string | null;
   truckType: string | null;
   containerNumber: string | null;
+  arrivedAt: string | null;
+  departedAt: string | null;
 }
 
 export const warehouseService = {
diff --git a/apps/edr-freight-web/backoffice/src/types/rule-engine/index.ts b/apps/edr-freight-web/backoffice/src/types/rule-engine/index.ts
index 3a55880d3..da454e55c 100644
--- a/apps/edr-freight-web/backoffice/src/types/rule-engine/index.ts
+++ b/apps/edr-freight-web/backoffice/src/types/rule-engine/index.ts
@@ -6,6 +6,7 @@ export type RuleEngineResourceSlug =
   | "service-types"
   | "weight-limit-rules"
   | "yards"
+  | "yard-distances"
   | "shipping-lines"
   | "rates"
   | "approval-rules";
diff --git a/apps/edr-freight-web/backoffice/src/types/trainScheduling.ts b/apps/edr-freight-web/backoffice/src/types/trainScheduling.ts
index 99cc613a1..04bb30fc4 100644
--- a/apps/edr-freight-web/backoffice/src/types/trainScheduling.ts
+++ b/apps/edr-freight-web/backoffice/src/types/trainScheduling.ts
@@ -626,9 +626,20 @@ export interface TrainScheduleDetail {
     status: string | null;
     schedulingStatus?: SchedulingStatus | null;
     freightType?: FreightType | string | null;
+    /** DOMESTIC = intercity ride-along; rides only its own leg below. */
+    tradeDirection?: string | null;
+    originYardId?: string | null;
+    destinationYardId?: string | null;
+    origin?: string | null;
+    destination?: string | null;
+    wagonsRequired?: number | null;
+    loadedAt?: string | null;
+    arrivedAt?: string | null;
     loadingStatus?: "LOADED" | "UNLOADED";
     wagonAssigned?: boolean;
   }>;
+  /** Ordered corridor stops (route milestones) — for per-segment occupancy. */
+  stops?: Array<{ yardId: string; label: string }>;
   warnings?: string[];
 }
 
diff --git a/apps/edr-freight-web/backoffice/src/types/warehouse.ts b/apps/edr-freight-web/backoffice/src/types/warehouse.ts
index b9c4a6a88..1ca31e886 100644
--- a/apps/edr-freight-web/backoffice/src/types/warehouse.ts
+++ b/apps/edr-freight-web/backoffice/src/types/warehouse.ts
@@ -1083,6 +1083,10 @@ export interface InventoryFilter {
   search?: string;
   dateFrom?: string;
   dateTo?: string;
+  /** KPI drill-downs — mirror the ops-stats counters exactly. */
+  receivedToday?: boolean;
+  pendingInspection?: boolean;
+  agingOverDays?: number;
 }
 
 export interface InventoryInquiryFilter {
@@ -1128,6 +1132,8 @@ export interface WarehouseOpsStats {
 export interface TruckOnSite {
   source: "CUSTOMER" | "EDR";
   assignmentId: string;
+  /** INBOUND = assigned, not yet arrived; ON_SITE = arrived, not yet departed. */
+  status: "INBOUND" | "ON_SITE";
   plateNumber: string | null;
   driverName: string | null;
   truckType: string | null;
diff --git a/apps/edr-freight-web/backoffice/src/utils/errorExtractor.ts b/apps/edr-freight-web/backoffice/src/utils/errorExtractor.ts
new file mode 100644
index 000000000..c4e7dcb14
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/utils/errorExtractor.ts
@@ -0,0 +1,17 @@
+/**
+ * Pull the SERVER's actual error message out of a failed request.
+ *
+ * NestJS returns `{ message: string | string[] }`; a class-validator failure is
+ * the array form (joined here). Falls back to the error's own `.message` — the
+ * axios response interceptor (see `auth/http.ts`) already rewrites that to the
+ * server message, so even code paths that never see the raw response body get
+ * the real cause — then to the caller's fallback string.
+ */
+export const extractErrorMessage = (err: unknown, fallback: string): string => {
+  const msg = (err as { response?: { data?: { message?: string | string[] } } })
+    ?.response?.data?.message;
+  if (Array.isArray(msg)) return msg.filter(Boolean).join(", ");
+  if (typeof msg === "string" && msg) return msg;
+  if (err instanceof Error && err.message) return err.message;
+  return fallback;
+};
diff --git a/apps/edr-freight-web/portal/package.json b/apps/edr-freight-web/portal/package.json
index 1e7b7155d..8fce928f5 100644
--- a/apps/edr-freight-web/portal/package.json
+++ b/apps/edr-freight-web/portal/package.json
@@ -4,7 +4,7 @@
   "private": true,
   "type": "module",
   "scripts": {
-    "dev": "vite --port 5173 --clearScreen false",
+    "dev": "vite --port 5273 --clearScreen false",
     "build": "tsc -b && vite build",
     "preview": "vite preview --port 5173",
     "lint": "eslint src",
diff --git a/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/ReadonlyBookingView.tsx b/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/ReadonlyBookingView.tsx
index fc701b924..ce218f84b 100644
--- a/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/ReadonlyBookingView.tsx
+++ b/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/ReadonlyBookingView.tsx
@@ -34,6 +34,7 @@ import { HeaderButton, PageHeader } from "./components/PageHeader";
 import { PaymentMethodModal } from "./components/PaymentMethodModal";
 import { ScheduleCard } from "./components/ScheduleCard";
 import { WarehousePaymentsSection } from "./components/WarehousePaymentsSection";
+import { WarehouseLocationCard } from "./components/WarehouseLocationCard";
 import { ShipmentDetailsCard } from "./components/ShipmentDetailsCard";
 import { ShipmentTrackingCard } from "./components/ShipmentTrackingCard";
 import { StatusHero } from "./components/StatusHero";
@@ -273,6 +274,8 @@ export function ReadonlyBookingView({
 
                   <ContainersCard booking={booking} />
 
+                  <WarehouseLocationCard bookingId={booking.id} />
+
                   <ContractInfoCard booking={booking} />
 
                   <ShipmentTrackingCard bookingId={booking.id} />
diff --git a/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/components/WarehouseLocationCard.tsx b/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/components/WarehouseLocationCard.tsx
new file mode 100644
index 000000000..799059451
--- /dev/null
+++ b/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/components/WarehouseLocationCard.tsx
@@ -0,0 +1,71 @@
+import { Group, Paper, Stack, Text, Divider } from "@mantine/core";
+import { useQuery } from "@tanstack/react-query";
+import { Warehouse as WarehouseIcon } from "lucide-react";
+
+import { warehouseService } from "@/services/warehouse.service";
+
+interface WarehouseLocationCardProps {
+  bookingId: string;
+}
+
+function Row({ label, value }: { label: string; value: React.ReactNode }) {
+  return (
+    <Group justify="space-between" wrap="nowrap">
+      <Text size="sm" c="dimmed">
+        {label}
+      </Text>
+      <Text size="sm" fw={500} ta="right">
+        {value}
+      </Text>
+    </Group>
+  );
+}
+
+export function WarehouseLocationCard({ bookingId }: WarehouseLocationCardProps) {
+  const { data, isLoading } = useQuery({
+    queryKey: ["warehouse-inventory", "booking-location", bookingId],
+    queryFn: () => warehouseService.bookingLocation(bookingId),
+  });
+
+  const items = data ?? [];
+  const latest = items[0];
+
+  return (
+    <Paper withBorder radius="md" p="lg">
+      <Stack gap="md">
+        <Group gap="xs">
+          <WarehouseIcon size={18} />
+          <Text fw={700}>Warehouse Location</Text>
+        </Group>
+
+        <Divider />
+
+        {isLoading ? (
+          <Text size="sm" c="dimmed">
+            Loading…
+          </Text>
+        ) : !latest ? (
+          <Text size="sm" c="dimmed">
+            Your cargo will appear here once it arrives at the warehouse.
+          </Text>
+        ) : (
+          <Stack gap="xs">
+            <Row
+              label="Warehouse"
+              value={latest.warehouse ? `${latest.warehouse.name} (${latest.warehouse.code})` : "—"}
+            />
+            <Row
+              label="Yard"
+              value={latest.yard ? `${latest.yard.name} (${latest.yard.code})` : "—"}
+            />
+            <Row
+              label="Zone"
+              value={latest.zone ? `${latest.zone.name} (${latest.zone.code})` : "—"}
+            />
+            <Row label="Arrived At" value={latest.arrivedAt ? new Date(latest.arrivedAt).toLocaleString() : "—"} />
+          </Stack>
+        )}
+      </Stack>
+    </Paper>
+  );
+}
diff --git a/apps/edr-freight-web/portal/src/pages/bookings/delivery/ApproveDeliveryModal.tsx b/apps/edr-freight-web/portal/src/pages/bookings/delivery/ApproveDeliveryModal.tsx
index 90e95369f..9be64aad4 100644
--- a/apps/edr-freight-web/portal/src/pages/bookings/delivery/ApproveDeliveryModal.tsx
+++ b/apps/edr-freight-web/portal/src/pages/bookings/delivery/ApproveDeliveryModal.tsx
@@ -1,4 +1,15 @@
-import { Alert, Button, Group, Loader, Modal, Stack, Text, TextInput } from "@mantine/core";
+import {
+  Alert,
+  Badge,
+  Button,
+  Group,
+  Loader,
+  Modal,
+  Stack,
+  Text,
+  TextInput,
+  UnstyledButton,
+} from "@mantine/core";
 import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
 import { CheckCircle2, Info } from "lucide-react";
 import { useEffect, useState } from "react";
@@ -36,7 +47,10 @@ const downloadBlob = (blob: Blob, filename: string) => {
 
 /**
  * Approve-delivery flow: open the handover document for the customer to review,
- * then apply their saved signature (approve) and hand back the signed PDF.
+ * then sign it with their typed full name (saved signature applied when present).
+ * Self-haul: one booking-level handover, signed once. EDR last-mile: one
+ * handover per delivering truck — the customer signs each; when the last one is
+ * signed the delivery completes automatically.
  */
 export function ApproveDeliveryModal({
   bookingId,
@@ -48,15 +62,33 @@ export function ApproveDeliveryModal({
   const queryClient = useQueryClient();
   const [pdfUrl, setPdfUrl] = useState<string | null>(null);
   const [signerName, setSignerName] = useState("");
+  const [selectedId, setSelectedId] = useState<string | null>(null);
+
+  const { data: handovers } = useQuery({
+    queryKey: ["booking-handovers", bookingId],
+    queryFn: () => bookingsService.listBookingHandovers(bookingId),
+    enabled: opened && Boolean(bookingId),
+    staleTime: 0,
+  });
+
+  // Per-truck mode: any EDR last-mile handover means one signature per truck.
+  const edrMode = (handovers ?? []).some((h) => h.mileType === "EDR_LAST_MILE");
+  const unsigned = (handovers ?? []).filter((h) => !h.signedAt);
+  const selected =
+    (handovers ?? []).find((h) => h.id === selectedId && !h.signedAt) ?? unsigned[0] ?? null;
 
   const {
     data: docBlob,
     isLoading,
     isError,
   } = useQuery({
-    queryKey: ["booking-handover-doc", bookingId],
-    queryFn: () => bookingsService.downloadBookingHandoverDocument(bookingId),
-    enabled: opened && Boolean(bookingId),
+    queryKey: ["booking-handover-doc", bookingId, edrMode ? selected?.id : "booking"],
+    queryFn: () =>
+      bookingsService.downloadBookingHandoverDocument(
+        bookingId,
+        edrMode ? selected?.id : undefined,
+      ),
+    enabled: opened && Boolean(bookingId) && (!edrMode || Boolean(selected)),
     staleTime: 0,
   });
 
@@ -70,10 +102,32 @@ export function ApproveDeliveryModal({
     return () => URL.revokeObjectURL(url);
   }, [docBlob]);
 
+  const invalidateBooking = () =>
+    Promise.all([
+      queryClient.invalidateQueries({
+        queryKey: api.bookings.get.queryKey({ id: bookingId }),
+      }),
+      queryClient.invalidateQueries({ queryKey: api.bookings.list.queryKey() }),
+      queryClient.invalidateQueries({ queryKey: ["companies", "getDashboard"] }),
+    ]);
+
+  const onSignError = (error: unknown) => {
+    const message = errorMessage(error);
+    toast.error(message);
+    if (message.toLowerCase().includes("save your signature")) {
+      onClose();
+      navigate("/signature");
+    } else if (/demurrage|storage|warehouse invoice|fully paid/i.test(message)) {
+      onClose();
+      navigate("/billing");
+    }
+  };
+
   const handoverMutation = useMutation(
     api.bookings.downloadHandoverDocument.mutationOptions(),
   );
 
+  // Booking-level (self-haul) approval — signs every handover at once.
   const approve = useMutation({
     ...api.bookings.approveDelivery.mutationOptions(),
     onSuccess: async (result) => {
@@ -87,30 +141,35 @@ export function ApproveDeliveryModal({
         toast.success("Delivery approved and handover signed");
         toast.error("Signed handover document could not be downloaded");
       }
-      await Promise.all([
-        queryClient.invalidateQueries({
-          queryKey: api.bookings.get.queryKey({ id: bookingId }),
-        }),
-        queryClient.invalidateQueries({ queryKey: api.bookings.list.queryKey() }),
-        queryClient.invalidateQueries({ queryKey: ["companies", "getDashboard"] }),
-      ]);
+      await invalidateBooking();
       onApproved?.();
       onClose();
     },
-    onError: (error) => {
-      const message = errorMessage(error);
-      toast.error(message);
-      if (message.toLowerCase().includes("save your signature")) {
-        onClose();
-        navigate("/signature");
-      } else if (/demurrage|storage|warehouse invoice|fully paid/i.test(message)) {
-        onClose();
-        navigate("/billing");
-      }
-    },
+    onError: onSignError,
   });
 
-  const busy = approve.isPending || handoverMutation.isPending;
+  // Per-truck (EDR last-mile) signature — one handover at a time.
+  const signOne = useMutation({
+    mutationFn: ({ handoverId, name }: { handoverId: string; name: string }) =>
+      bookingsService.signHandover(handoverId, name),
+    onSuccess: async (result) => {
+      await queryClient.invalidateQueries({
+        queryKey: ["booking-handovers", bookingId],
+      });
+      setSelectedId(null);
+      if (result.allSigned) {
+        toast.success("All handovers signed — delivery confirmed");
+        await invalidateBooking();
+        onApproved?.();
+        onClose();
+      } else {
+        toast.success("Handover signed — please sign the remaining truck(s)");
+      }
+    },
+    onError: onSignError,
+  });
+
+  const busy = approve.isPending || handoverMutation.isPending || signOne.isPending;
 
   return (
     <Modal
@@ -123,12 +182,42 @@ export function ApproveDeliveryModal({
       <Stack gap="md">
         <Alert color="blue" variant="light" icon={<Info size={16} />}>
           <Text size="sm">
-            Review the handover document below, then type your full name to sign and
-            confirm you received the goods. Your saved signature is applied automatically
-            if you have one.
+            {edrMode
+              ? "Your goods were delivered by EDR truck(s). Review and sign the handover for each truck to confirm you received the goods — delivery completes once every truck is signed."
+              : "Review the handover document below, then type your full name to sign and confirm you received the goods. Your saved signature is applied automatically if you have one."}
           </Text>
         </Alert>
 
+        {edrMode && (handovers?.length ?? 0) > 0 && (
+          <Stack gap={4}>
+            {handovers!.map((h) => (
+              <UnstyledButton
+                key={h.id}
+                onClick={() => !h.signedAt && setSelectedId(h.id)}
+                style={{
+                  padding: "8px 12px",
+                  borderRadius: 8,
+                  border:
+                    selected?.id === h.id
+                      ? "1px solid var(--mantine-color-edr-green-6)"
+                      : "1px solid var(--mantine-color-gray-3)",
+                  cursor: h.signedAt ? "default" : "pointer",
+                }}
+              >
+                <Group justify="space-between" wrap="nowrap">
+                  <Text size="sm" fw={600}>
+                    {h.truckPlate ? `Truck ${h.truckPlate}` : "Booking handover"} —{" "}
+                    {h.reference}
+                  </Text>
+                  <Badge color={h.signedAt ? "green" : "yellow"} variant="light">
+                    {h.signedAt ? `Signed${h.signerName ? ` — ${h.signerName}` : ""}` : "Awaiting signature"}
+                  </Badge>
+                </Group>
+              </UnstyledButton>
+            ))}
+          </Stack>
+        )}
+
         {isLoading ? (
           <Group justify="center" py="xl">
             <Loader size="sm" />
@@ -170,10 +259,21 @@ export function ApproveDeliveryModal({
             color="edr-green"
             leftSection={<CheckCircle2 size={16} />}
             loading={busy}
-            disabled={isLoading || isError || !signerName.trim()}
-            onClick={() => approve.mutate({ id: bookingId, signerName: signerName.trim() })}
+            disabled={
+              isLoading ||
+              isError ||
+              !signerName.trim() ||
+              (edrMode && !selected)
+            }
+            onClick={() =>
+              edrMode && selected
+                ? signOne.mutate({ handoverId: selected.id, name: signerName.trim() })
+                : approve.mutate({ id: bookingId, signerName: signerName.trim() })
+            }
           >
-            Approve &amp; sign delivery
+            {edrMode && selected?.truckPlate
+              ? `Sign for truck ${selected.truckPlate}`
+              : "Approve & sign delivery"}
           </Button>
         </Group>
       </Stack>
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 89870ee93..f6c3098a0 100644
--- a/apps/edr-freight-web/portal/src/pages/contracts/ContractDetailPage.tsx
+++ b/apps/edr-freight-web/portal/src/pages/contracts/ContractDetailPage.tsx
@@ -409,6 +409,10 @@ export default function ContractDetailPage() {
 
   const canSign = contract.status === "CONTRACT_READY";
   const customsPath = contract.customsClearingEnabled;
+  // Intercity (DOMESTIC) has no customs — the document gate collects the
+  // admin-configured intercity set, reviewed by Operations.
+  const isIntercity = contract.tradeDirection === "DOMESTIC";
+  const docNoun = isIntercity ? "intercity documents" : "clearance documents";
   // Only the NON-customs (Path A) customer books himself — once the contract is
   // executed after self-clearance. Customs (Path B) bookings are created by
   // Global Logistics on the customer's behalf, so the customer gets no booking
@@ -586,8 +590,8 @@ export default function ContractDetailPage() {
                 onClick={clearanceModal.open}
               >
                 {contract.status === "CLEARANCE_UNDER_REVIEW"
-                  ? "Manage clearance documents"
-                  : "Upload clearance documents"}
+                  ? `Manage ${docNoun}`
+                  : `Upload ${docNoun}`}
               </Button>
             )}
           </Group>
@@ -852,7 +856,9 @@ export default function ContractDetailPage() {
               <Text fw={700} fz={15} c={INK}>
                 {customsPath
                   ? "Customs clearance shipment"
-                  : "Customs clearance required"}
+                  : isIntercity
+                    ? "Intercity documents required"
+                    : "Customs clearance required"}
               </Text>
             </Group>
             <Text fz={13} c="dimmed">
@@ -862,11 +868,17 @@ export default function ContractDetailPage() {
                   : contract.status === "CLEARANCE_UNDER_REVIEW"
                     ? "Global Logistics is reviewing your clearance documents. Re-upload any queried documents to proceed."
                     : "Your documents are cleared. You can now create a shipment booking under this contract."
-                : contract.status === "AWAITING_CLEARANCE_DOCUMENTS"
-                  ? "This service does not include EDR customs clearance. Clear the cargo yourself and upload your clearance documents so the Operations team can review them before you book a shipment."
-                  : contract.status === "CLEARANCE_UNDER_REVIEW"
-                    ? "The Operations team is reviewing your clearance documents. Re-upload any queried documents to proceed."
-                    : "Your clearance documents are approved. You can now create a shipment booking under this contract."}
+                : isIntercity
+                  ? contract.status === "AWAITING_CLEARANCE_DOCUMENTS"
+                    ? "Upload the required intercity documents so the Operations team can review them before you book a shipment."
+                    : contract.status === "CLEARANCE_UNDER_REVIEW"
+                      ? "The Operations team is reviewing your intercity documents. Re-upload any queried documents to proceed."
+                      : "Your intercity documents are approved. You can now create a shipment booking under this contract."
+                  : contract.status === "AWAITING_CLEARANCE_DOCUMENTS"
+                    ? "This service does not include EDR customs clearance. Clear the cargo yourself and upload your clearance documents so the Operations team can review them before you book a shipment."
+                    : contract.status === "CLEARANCE_UNDER_REVIEW"
+                      ? "The Operations team is reviewing your clearance documents. Re-upload any queried documents to proceed."
+                      : "Your clearance documents are approved. You can now create a shipment booking under this contract."}
             </Text>
             {contract.status !== "CLEARANCE_READY_FOR_BOOKING" && (
               <Button
@@ -1581,7 +1593,7 @@ export default function ContractDetailPage() {
         onClose={clearanceModal.close}
         title={
           <Text fw={700} fz={16}>
-            Clearance documents
+            {isIntercity ? "Intercity documents" : "Clearance documents"}
           </Text>
         }
         size="xl"
diff --git a/apps/edr-freight-web/portal/src/pages/contracts/ContractStepBanner.tsx b/apps/edr-freight-web/portal/src/pages/contracts/ContractStepBanner.tsx
index a339c214a..3278e34e1 100644
--- a/apps/edr-freight-web/portal/src/pages/contracts/ContractStepBanner.tsx
+++ b/apps/edr-freight-web/portal/src/pages/contracts/ContractStepBanner.tsx
@@ -254,6 +254,14 @@ export function ContractStepBanner({ contract }: ContractStepBannerProps) {
               </Text>
             </Group>
           )}
+          {contract.status === "REJECTED" && contract.latestRejectionNote && (
+            <Text
+              fz={12.5}
+              style={{ color: "#B42318", whiteSpace: "pre-wrap", width: "100%" }}
+            >
+              Reason: {contract.latestRejectionNote}
+            </Text>
+          )}
           {expirySoon && (
             <Group gap={6} wrap="nowrap" align="center">
               <AlertTriangle size={14} color="#9A6700" />
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 11cb955e0..1074ccd0d 100644
--- a/apps/edr-freight-web/portal/src/pages/contracts/NewContractPage.tsx
+++ b/apps/edr-freight-web/portal/src/pages/contracts/NewContractPage.tsx
@@ -626,12 +626,15 @@ export default function NewContractPage({
           lastMileDeliveryLng: data.lastMile.lng ?? undefined,
         }
         : {}),
-      ...(serviceType?.includesCustoms && data.customsClearingEnabled
-        ? {
-          customsClearingEnabled: true,
-          customsClearingAgent: data.customsClearingAgent || undefined,
-        }
-        : { customsClearingEnabled: false }),
+      // Customs bundling is a property of the chosen service, not of a stored
+      // form flag — derive it here so stale drafts can't misreport it. A
+      // non-bundled contract still records the customer's own clearing agent.
+      ...(serviceType?.includesCustoms
+        ? { customsClearingEnabled: true }
+        : {
+          customsClearingEnabled: false,
+          customsClearingAgent: data.customsClearingAgent?.trim() || undefined,
+        }),
       cargoScope,
       routes,
     };
@@ -833,7 +836,6 @@ export default function NewContractPage({
               setStep={setStep}
               direction={direction!}
               referenceData={referenceData}
-              onboardingDocs={onboardingDocs}
               pricing={
                 pricingData
                   ? {
diff --git a/apps/edr-freight-web/portal/src/pages/contracts/new-contract-form/step2-service-type.tsx b/apps/edr-freight-web/portal/src/pages/contracts/new-contract-form/step2-service-type.tsx
index 1c7dfdc7a..f5dff9be0 100644
--- a/apps/edr-freight-web/portal/src/pages/contracts/new-contract-form/step2-service-type.tsx
+++ b/apps/edr-freight-web/portal/src/pages/contracts/new-contract-form/step2-service-type.tsx
@@ -289,16 +289,22 @@ export function Step2ServiceType({
       );
     }
 
-    // Customs clearance bundling is driven by the service: includesCustoms → the
-    // contract follows Path B (clearance docs after sign); otherwise Path A.
-    if (includesCustoms) {
-      form.setValue("customsClearingEnabled", true, { shouldDirty: true });
-      form.setValue("customsClearingAgent", "", { shouldDirty: true });
-    } else {
-      form.setValue("customsClearingEnabled", false, { shouldDirty: true });
+  }, [serviceType, includesFirstMile, includesLastMile, form]);
+
+  // Customs clearance bundling is driven by the service: includesCustoms → the
+  // contract follows Path B (clearance docs after sign); otherwise Path A.
+  // Synced unconditionally — the prev-service guard above skips the very first
+  // selection and restored drafts, which left customsClearingEnabled stale.
+  useEffect(() => {
+    const desired = Boolean(includesCustoms);
+    if (form.getValues("customsClearingEnabled") !== desired) {
+      form.setValue("customsClearingEnabled", desired, { shouldDirty: true });
+    }
+    // A bundled-customs service never carries a customer-named agent.
+    if (desired && form.getValues("customsClearingAgent")) {
       form.setValue("customsClearingAgent", "", { shouldDirty: true });
     }
-  }, [serviceType, includesFirstMile, includesLastMile, includesCustoms, form]);
+  }, [includesCustoms, form]);
 
   // A hidden mile must not leak a stale enabled=true into the payload. The
   // effect above only fires on service change; switching operation type (import
diff --git a/apps/edr-freight-web/portal/src/pages/contracts/new-contract-form/step8-review.tsx b/apps/edr-freight-web/portal/src/pages/contracts/new-contract-form/step8-review.tsx
index 27b2108a9..11a96b4b9 100644
--- a/apps/edr-freight-web/portal/src/pages/contracts/new-contract-form/step8-review.tsx
+++ b/apps/edr-freight-web/portal/src/pages/contracts/new-contract-form/step8-review.tsx
@@ -17,6 +17,7 @@ import {
   FileText,
   MapPin,
   Package,
+  RotateCcw,
   Route,
   Send,
   Truck,
@@ -180,7 +181,6 @@ export function Step8Review({
   form,
   direction,
   referenceData,
-  onboardingDocs = [],
   pricing,
   onSaveDraft,
   onSubmit,
@@ -194,7 +194,6 @@ export function Step8Review({
   setStep?: (step: number) => void;
   direction: Freight.ScheduleTradeDirection;
   referenceData?: Freight.BookingReferenceData;
-  onboardingDocs?: Array<{ name: string; size?: number }>;
   /** Unit-rate quotation, if the customer has already generated price. */
   pricing?: { currency: string; lineItems: Freight.ContractUnitRateLineItem[] } | null;
   onSaveDraft?: () => void;
@@ -216,15 +215,46 @@ export function Step8Review({
   );
 
   const isGeneralContract = values.contractKind === "general_contract";
+  const isIntercity = values.operationType === "intercity";
 
-  const attachedDocs = Object.entries(
-    (values.documents ?? {}) as Record<string, File | File[] | null>,
-  )
-    .filter(([, v]) => (Array.isArray(v) ? v.length > 0 : Boolean(v)))
-    .map(([key, v]) => ({
-      name: Array.isArray(v) ? (v[0]?.name ?? key) : ((v as File).name ?? key),
-    }));
-  const onboardingDocsCount = attachedDocs.length || onboardingDocs.length;
+  // Customs is a property of the chosen service (bundled → Global Logistics),
+  // not of the stored form flag — a stale draft flag must not misreport it.
+  // Without bundling, the customer may still name their own clearing agent.
+  const ownAgent = values.customsClearingAgent?.trim();
+  const customsValue = isIntercity
+    ? "Not applicable — domestic transport"
+    : serviceType?.includesCustoms || values.customsClearingEnabled
+      ? "Included — Global Logistics"
+      : ownAgent
+        ? `Own agent — ${ownAgent}`
+        : "Not requested";
+
+  // Mirror the step-2 gating: imports never truck the first mile, exports never
+  // truck the last mile, and a service that doesn't bundle a mile can't have it.
+  const firstMileValue =
+    direction === "IMPORT"
+      ? "Not applicable for import"
+      : serviceType && !serviceType.includesFirstMile
+        ? "Not included in service"
+        : values.firstMile.enabled
+          ? `${values.firstMile.pickUpAddress || "Pinned"}${
+              values.firstMile.exactLocation
+                ? ` · ${values.firstMile.exactLocation}`
+                : ""
+            }`
+          : "Not requested";
+  const lastMileValue =
+    direction === "EXPORT"
+      ? "Not applicable for export"
+      : serviceType && !serviceType.includesLastMile
+        ? "Not included in service"
+        : values.lastMile.enabled
+          ? `${values.lastMile.deliveryAddress || "Pinned"}${
+              values.lastMile.exactLocation
+                ? ` · ${values.lastMile.exactLocation}`
+                : ""
+            }`
+          : "Not requested";
 
   const cargoValue = (() => {
     if (values.cargoType === "container") {
@@ -372,39 +402,17 @@ export function Step8Review({
               <SummaryItem
                 icon={<Truck size={18} />}
                 label="First mile — pick-up"
-                value={
-                  values.firstMile.enabled
-                    ? `${values.firstMile.pickUpAddress || "Pinned"}${
-                        values.firstMile.exactLocation
-                          ? ` · ${values.firstMile.exactLocation}`
-                          : ""
-                      }`
-                    : "Not requested"
-                }
+                value={firstMileValue}
               />
               <SummaryItem
                 icon={<Truck size={18} />}
                 label="Last mile — delivery"
-                value={
-                  values.lastMile.enabled
-                    ? `${values.lastMile.deliveryAddress || "Pinned"}${
-                        values.lastMile.exactLocation
-                          ? ` · ${values.lastMile.exactLocation}`
-                          : ""
-                      }`
-                    : "Not requested"
-                }
+                value={lastMileValue}
               />
               <SummaryItem
                 icon={<FileText size={18} />}
                 label="Customs clearing"
-                value={
-                  values.customsClearingEnabled
-                    ? values.customsClearingAgent
-                      ? `Agent: ${values.customsClearingAgent}`
-                      : "Global Logistics"
-                    : "Not requested"
-                }
+                value={customsValue}
               />
               <SummaryItem
                 icon={<Package size={18} />}
@@ -416,15 +424,17 @@ export function Step8Review({
                 label="Refrigerated"
                 value={values.isRefrigerated ? "Yes" : "No"}
               />
-              <SummaryItem
-                icon={<FileText size={18} />}
-                label="Documents"
-                value={
-                  onboardingDocsCount > 0
-                    ? `${onboardingDocsCount} attached`
-                    : "None attached"
-                }
-              />
+              {values.cargoType === "container" && (
+                <SummaryItem
+                  icon={<RotateCcw size={18} />}
+                  label="Empty-container return"
+                  value={
+                    values.equipmentReturn === "with_return"
+                      ? "With return"
+                      : "Without return"
+                  }
+                />
+              )}
             </Box>
           </Paper>
 
@@ -489,10 +499,6 @@ export function Step8Review({
                   }
                   label="Cargo scope complete"
                 />
-                <ReadinessItem
-                  done={onboardingDocsCount > 0}
-                  label="Documents attached"
-                />
               </Stack>
             </Paper>
 
diff --git a/apps/edr-freight-web/portal/src/services/bookings.service.ts b/apps/edr-freight-web/portal/src/services/bookings.service.ts
index 51e87c024..fbb84e1c0 100644
--- a/apps/edr-freight-web/portal/src/services/bookings.service.ts
+++ b/apps/edr-freight-web/portal/src/services/bookings.service.ts
@@ -137,6 +137,26 @@ export interface ApproveDeliveryResponse {
   signerDisplayName: string;
 }
 
+/** One import handover record — booking-level or per truck (EDR last-mile). */
+export interface BookingHandoverRecord {
+  id: string;
+  reference: string;
+  truckPlate: string | null;
+  mileType: "SELF_HAUL" | "EDR_LAST_MILE";
+  generatedAt: string;
+  signedAt: string | null;
+  signerName: string | null;
+  deliveredAt: string | null;
+}
+
+export interface SignHandoverResponse {
+  handoverId: string;
+  bookingId: string;
+  signedAt: string | null;
+  signerDisplayName: string;
+  allSigned: boolean;
+}
+
 export interface CustomerTruckAssignmentPayload {
   truckPlateNumber: string;
   driverName: string;
@@ -206,13 +226,36 @@ export const bookingsService = {
     );
     return data;
   },
-  downloadBookingHandoverDocument: async (bookingId: string): Promise<Blob> => {
+  downloadBookingHandoverDocument: async (
+    bookingId: string,
+    handoverId?: string,
+  ): Promise<Blob> => {
     const { data } = await client.get(
       `/api/warehouse-inventory/bookings/${bookingId}/handover-document`,
-      { responseType: "blob" },
+      { responseType: "blob", params: handoverId ? { handoverId } : undefined },
     );
     return data;
   },
+
+  listBookingHandovers: async (
+    bookingId: string,
+  ): Promise<BookingHandoverRecord[]> => {
+    const { data } = await client.get(
+      `/api/warehouse-inventory/bookings/${bookingId}/handovers`,
+    );
+    return data.data ?? data;
+  },
+
+  signHandover: async (
+    handoverId: string,
+    signerName: string,
+  ): Promise<SignHandoverResponse> => {
+    const { data } = await client.post(
+      `/api/warehouse-inventory/handovers/${handoverId}/sign`,
+      { signerName },
+    );
+    return data.data ?? data;
+  },
   downloadBookingGrnDocument: async (bookingId: string): Promise<Blob> => {
     const { data } = await client.get(
       `/api/warehouse-inventory/bookings/${bookingId}/grn-document`,
diff --git a/apps/edr-freight-web/portal/src/services/warehouse.service.ts b/apps/edr-freight-web/portal/src/services/warehouse.service.ts
new file mode 100644
index 000000000..b641a8809
--- /dev/null
+++ b/apps/edr-freight-web/portal/src/services/warehouse.service.ts
@@ -0,0 +1,62 @@
+import { client } from "@/utils/api";
+
+export interface InventoryFilter {
+  bookingId?: string;
+}
+
+export interface WarehouseInventoryItem {
+  id: string;
+  bookingId: string | null;
+  warehouseId: string;
+  yardId: string;
+  zoneId: string;
+  status: string;
+  arrivedAt: string | null;
+  warehouse?: {
+    id: string;
+    name: string;
+    code: string;
+  } | null;
+  yard?: {
+    id: string;
+    name: string;
+    code: string;
+  } | null;
+  zone?: {
+    id: string;
+    name: string;
+    code: string;
+  } | null;
+}
+
+export interface BookingScheduleView {
+  schedule: {
+    status: string;
+    scheduledDepartureDate: string | null;
+    scheduledArrivalDate: string | null;
+  } | null;
+  wagon?: {
+    wagonNumber: string | null;
+    sequenceNo: number | null;
+  } | null;
+}
+
+export const warehouseService = {
+  listInventory: async (filter?: InventoryFilter): Promise<WarehouseInventoryItem[]> => {
+    const { data } = await client.get("/warehouse-inventory", {
+      params: filter,
+    });
+    return data?.data ?? data ?? [];
+  },
+
+  /** Customer-safe location endpoint — the plain list is staff-only (403 for portal users). */
+  bookingLocation: async (bookingId: string): Promise<WarehouseInventoryItem[]> => {
+    const { data } = await client.get(`/warehouse-inventory/bookings/${bookingId}/location`);
+    return data?.data ?? data ?? [];
+  },
+
+  bookingSchedule: async (bookingId: string): Promise<BookingScheduleView> => {
+    const { data } = await client.get(`/warehouse-inventory/booking-schedule/${bookingId}`);
+    return data?.data ?? data ?? { schedule: null, wagon: null };
+  },
+};
diff --git a/apps/edr-passenger-api/Dockerfile b/apps/edr-passenger-api/Dockerfile
index 45b365496..bd06feb8b 100644
--- a/apps/edr-passenger-api/Dockerfile
+++ b/apps/edr-passenger-api/Dockerfile
@@ -57,4 +57,7 @@ RUN addgroup --system --gid 1001 nodejs \
 COPY --from=deployer --chown=nestjs:nodejs /deploy .
 USER nestjs
 EXPOSE 4000
-CMD ["node", "dist/main.js"]
+# --enable-source-maps: translate stack-trace frames from dist/*.js back to
+# src/*.ts using the .js.map files nest build emits (tsconfig sourceMap:true).
+# Without it Node reports compiled JS line numbers, not TypeScript source.
+CMD ["node", "--enable-source-maps", "dist/main.js"]
diff --git a/apps/edr-passenger-api/prisma/schema.prisma b/apps/edr-passenger-api/prisma/schema.prisma
index b58356365..db46df025 100644
--- a/apps/edr-passenger-api/prisma/schema.prisma
+++ b/apps/edr-passenger-api/prisma/schema.prisma
@@ -580,7 +580,7 @@ model BookingSeat {
   bookingId         String
   seatId            String
   leg               Int               @default(1) // 1=outbound/leg-1, 2=return/leg-2
-  scheduleId        String            // which schedule this seat belongs to
+  scheduleId        String?            // which schedule this seat belongs to
   passengerName     String
   dateOfBirth       DateTime?
   passengerCategory PassengerCategory @default(ADULT)
diff --git a/apps/edr-passenger-api/src/modules/payments/payments.service.ts b/apps/edr-passenger-api/src/modules/payments/payments.service.ts
index ac8c7ef66..e9e4d2636 100644
--- a/apps/edr-passenger-api/src/modules/payments/payments.service.ts
+++ b/apps/edr-passenger-api/src/modules/payments/payments.service.ts
@@ -826,6 +826,27 @@ export class PaymentsService {
     });
     if (!intent) throw new NotFoundException("PaymentIntent not found");
     if (intent.status === PaymentIntentStatus.SUCCEEDED) {
+      // Idempotency guard — but still repair missing tickets. They can be absent
+      // when the first finalization threw from generate() after the transaction
+      // committed: the caller got a 500, retried, and now hits this early-return.
+      const ticketCount = await this.prisma.ticket.count({ where: { bookingId: intent.bookingId } });
+      if (ticketCount === 0) {
+        try {
+          await this.ticketsService.generate(intent.bookingId);
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          this.logger.warn(
+            `Ticket generation failed on idempotency retry for booking ${intent.bookingId}: ${msg}. Attempting smart seat reassignment.`,
+          );
+          try {
+            await this.ticketsService.smartAssignAndGenerate(intent.bookingId);
+          } catch (retryErr) {
+            this.logger.error(
+              `Error generating ticket on idempotency retry for booking ${intent.bookingId}: ${retryErr instanceof Error ? retryErr.message : String(retryErr)}`,
+            );
+          }
+        }
+      }
       return { alreadyFinalized: true };
     }
     if (intent.status === PaymentIntentStatus.CANCELLED) {
@@ -877,9 +898,8 @@ export class PaymentsService {
       await this.ticketsService.generate(booking.id);
     } catch (err) {
       this.logger.error(
-        `Error generating ticket: ${err instanceof Error ? err.message : String(err)}`,
+        `Error generating ticket for booking ${booking.id}: ${err instanceof Error ? err.message : String(err)}`,
       );
-      throw err;
     }
 
     try {
diff --git a/apps/edr-passenger-api/src/modules/reports/reports.controller.ts b/apps/edr-passenger-api/src/modules/reports/reports.controller.ts
index 7df394090..6f91de06f 100644
--- a/apps/edr-passenger-api/src/modules/reports/reports.controller.ts
+++ b/apps/edr-passenger-api/src/modules/reports/reports.controller.ts
@@ -18,10 +18,10 @@ export class ReportsController {
     return this.service.generateReport(dto);
   }
 
-  @Get("schedules")
-  @ApiOperation({ summary: "List schedules for the passengers report picker" })
-  listSchedulesForPicker() {
-    return this.service.listSchedulesForPicker();
+  @Get('schedules')
+  @ApiOperation({ summary: 'List schedules for the passengers report picker' })
+  listSchedulesForPicker(@Query('all') all?: string) {
+    return this.service.listSchedulesForPicker(all === 'true');
   }
 
   @Get("passengers/list")
@@ -47,6 +47,12 @@ export class ReportsController {
     return this.service.getPaymentDiscrepancyReport({ from, to, sortBy, search });
   }
 
+  @Get("seat-status")
+  @ApiOperation({ summary: "Seat status breakdown for a schedule (paid, unpaid, expired holds, blocked)" })
+  getSeatStatusReport(@Query('scheduleId') scheduleId: string) {
+    return this.service.getSeatStatusReport(scheduleId);
+  }
+
   @Get("payments")
   @ApiOperation({ summary: "Payments collected for a schedule" })
   getPaymentsReport(@Query('scheduleId') scheduleId: string) {
diff --git a/apps/edr-passenger-api/src/modules/reports/reports.service.ts b/apps/edr-passenger-api/src/modules/reports/reports.service.ts
index 9460aa5a9..2d41c6bda 100644
--- a/apps/edr-passenger-api/src/modules/reports/reports.service.ts
+++ b/apps/edr-passenger-api/src/modules/reports/reports.service.ts
@@ -263,141 +263,85 @@ export class ReportsService {
           },
         },
         bookings: {
-          where: { status: { in: ["CONFIRMED", "BOARDED"] } },
-          include: {
-            seats: {
-              where: { leg: 1 },
-              include: {
-                seat: { include: { coach: { include: { coachType: true } } } },
-              },
-            },
-          },
+          where: { status: { in: ['CONFIRMED', 'BOARDED'] } },
+          select: { id: true, originStationId: true, destinationStationId: true },
         },
-        stopTimes: { include: { station: true }, orderBy: { sequence: "asc" } },
+        stopTimes: { include: { station: true }, orderBy: { sequence: 'asc' } },
       },
     });
 
     if (!schedule) return null;
 
-    const totalSeats = (schedule as any).coachAssignments.reduce(
-      (s: number, a: any) => s + a.coach.seats.length,
-      0,
-    );
-    const allBookingSeats = (schedule as any).bookings.flatMap(
-      (b: any) => b.seats,
-    );
+    // Fetch booking seats for this schedule — covers:
+    //   • outbound seats (leg=1, scheduleId=scheduleId)
+    //   • return seats (leg=2, booking.returnScheduleId=scheduleId)
+    //   • legacy rows where scheduleId is null but booking.scheduleId matches
+    const allBookingSeats = await this.prisma.bookingSeat.findMany({
+      where: {
+        OR: [
+          { scheduleId, booking: { status: { in: ['CONFIRMED', 'BOARDED'] } } },
+          { leg: 2, booking: { returnScheduleId: scheduleId, status: { in: ['CONFIRMED', 'BOARDED'] } } },
+          { scheduleId: null, leg: 1, booking: { scheduleId, status: { in: ['CONFIRMED', 'BOARDED'] } } },
+        ],
+      },
+      select: {
+        bookingId: true,
+        seat: { select: { coachId: true, coach: { select: { coachType: { select: { name: true } } } } } },
+      },
+    });
+
+    const totalSeats = schedule.coachAssignments.reduce((s, a) => s + a.coach.seats.length, 0);
     const totalPassengers = allBookingSeats.length;
-    const occupancyRate =
-      totalSeats > 0 ? +((totalPassengers / totalSeats) * 100).toFixed(1) : 0;
+    const occupancyRate = totalSeats > 0 ? +((totalPassengers / totalSeats) * 100).toFixed(1) : 0;
 
     // Per-coach breakdown
-    const coachMap = new Map<
-      string,
-      {
-        coachNumber: string;
-        coachType: string;
-        totalSeats: number;
-        booked: number;
-      }
-    >();
-    for (const assignment of (schedule as any).coachAssignments) {
+    const coachMap = new Map<string, { coachNumber: string; coachType: string; totalSeats: number; booked: number }>();
+    for (const assignment of schedule.coachAssignments) {
       const c = assignment.coach;
-      coachMap.set(c.id, {
-        coachNumber: c.number,
-        coachType: (c as any).coachType?.name ?? "Unknown",
-        totalSeats: c.seats.length,
-        booked: 0,
-      });
+      coachMap.set(c.id, { coachNumber: c.number, coachType: (c as any).coachType?.name ?? 'Unknown', totalSeats: c.seats.length, booked: 0 });
     }
     for (const bs of allBookingSeats) {
       const coachId = bs.seat?.coachId;
       if (coachId && coachMap.has(coachId)) coachMap.get(coachId)!.booked++;
     }
-    const byCoach = [...coachMap.values()].map((c) => ({
-      ...c,
-      occupancyRate:
-        c.totalSeats > 0 ? +((c.booked / c.totalSeats) * 100).toFixed(1) : 0,
-    }));
-
-    // Per-origin station breakdown (using booking's originStationId)
-    const originMap = new Map<
-      string,
-      { stationName: string; passengers: number }
-    >();
-    for (const booking of (schedule as any).bookings) {
-      const stationId = booking.originStationId ?? schedule.originStationId;
-      const stationName =
-        (schedule as any).stopTimes.find(
-          (st: any) => st.stationId === stationId,
-        )?.station?.name ??
-        (schedule as any).originStation?.name ??
-        stationId;
-      if (!originMap.has(stationId))
-        originMap.set(stationId, { stationName, passengers: 0 });
-      originMap.get(stationId)!.passengers += booking.seats.length;
-    }
-    const byOrigin = [...originMap.values()].sort(
-      (a, b) => b.passengers - a.passengers,
-    );
-
-    // Per-destination station breakdown
-    const destMap = new Map<
-      string,
-      { stationName: string; passengers: number }
-    >();
-    for (const booking of (schedule as any).bookings) {
-      const stationId =
-        booking.destinationStationId ?? schedule.destinationStationId;
-      const stationName =
-        (schedule as any).stopTimes.find(
-          (st: any) => st.stationId === stationId,
-        )?.station?.name ??
-        (schedule as any).destinationStation?.name ??
-        stationId;
-      if (!destMap.has(stationId))
-        destMap.set(stationId, { stationName, passengers: 0 });
-      destMap.get(stationId)!.passengers += booking.seats.length;
-    }
-    const byDestination = [...destMap.values()].sort(
-      (a, b) => b.passengers - a.passengers,
-    );
+    const byCoach = [...coachMap.values()].map(c => ({ ...c, occupancyRate: c.totalSeats > 0 ? +((c.booked / c.totalSeats) * 100).toFixed(1) : 0 }));
 
     // Per-class breakdown
-    const classMap = new Map<
-      string,
-      { className: string; totalSeats: number; booked: number }
-    >();
-    for (const assignment of (schedule as any).coachAssignments) {
-      const typeName = (assignment.coach as any).coachType?.name ?? "Unknown";
-      if (!classMap.has(typeName))
-        classMap.set(typeName, {
-          className: typeName,
-          totalSeats: 0,
-          booked: 0,
-        });
+    const classMap = new Map<string, { className: string; totalSeats: number; booked: number }>();
+    for (const assignment of schedule.coachAssignments) {
+      const typeName = (assignment.coach as any).coachType?.name ?? 'Unknown';
+      if (!classMap.has(typeName)) classMap.set(typeName, { className: typeName, totalSeats: 0, booked: 0 });
       classMap.get(typeName)!.totalSeats += assignment.coach.seats.length;
     }
     for (const bs of allBookingSeats) {
-      const typeName = bs.seat?.coach?.coachType?.name ?? "Unknown";
-      if (!classMap.has(typeName))
-        classMap.set(typeName, {
-          className: typeName,
-          totalSeats: 0,
-          booked: 0,
-        });
+      const typeName = bs.seat?.coach?.coachType?.name ?? 'Unknown';
+      if (!classMap.has(typeName)) classMap.set(typeName, { className: typeName, totalSeats: 0, booked: 0 });
       classMap.get(typeName)!.booked++;
     }
-    const byClass = [...classMap.values()].map((c) => ({
-      ...c,
-      occupancyRate:
-        c.totalSeats > 0 ? +((c.booked / c.totalSeats) * 100).toFixed(1) : 0,
-    }));
+    const byClass = [...classMap.values()].map(c => ({ ...c, occupancyRate: c.totalSeats > 0 ? +((c.booked / c.totalSeats) * 100).toFixed(1) : 0 }));
+
+    // Per-origin / per-destination — count actual seats per booking from allBookingSeats
+    const seatCountByBooking = allBookingSeats.reduce((acc, bs) => { acc[bs.bookingId] = (acc[bs.bookingId] ?? 0) + 1; return acc; }, {} as Record<string, number>);
+    const originMap = new Map<string, { stationName: string; passengers: number }>();
+    const destMap = new Map<string, { stationName: string; passengers: number }>();
+    for (const booking of schedule.bookings) {
+      const count = seatCountByBooking[booking.id] ?? 0;
+      const oId = booking.originStationId ?? schedule.originStationId;
+      const dId = booking.destinationStationId ?? schedule.destinationStationId;
+      const oName = schedule.stopTimes.find(st => st.stationId === oId)?.station?.name ?? (schedule as any).originStation?.name ?? oId;
+      const dName = schedule.stopTimes.find(st => st.stationId === dId)?.station?.name ?? (schedule as any).destinationStation?.name ?? dId;
+      if (!originMap.has(oId)) originMap.set(oId, { stationName: oName, passengers: 0 });
+      originMap.get(oId)!.passengers += count;
+      if (!destMap.has(dId)) destMap.set(dId, { stationName: dName, passengers: 0 });
+      destMap.get(dId)!.passengers += count;
+    }
+    const byOrigin = [...originMap.values()].sort((a, b) => b.passengers - a.passengers);
+    const byDestination = [...destMap.values()].sort((a, b) => b.passengers - a.passengers);
 
     return {
       schedule: {
         id: schedule.id,
-        trainName:
-          (schedule as any).train?.name ?? (schedule as any).train?.number,
+        trainName: (schedule as any).train?.name ?? (schedule as any).train?.number,
         origin: (schedule as any).originStation?.name,
         destination: (schedule as any).destinationStation?.name,
         departureAt: schedule.departureAt,
@@ -411,10 +355,10 @@ export class ReportsService {
     };
   }
 
-  async listSchedulesForPicker() {
+  async listSchedulesForPicker(all = false) {
     const now = new Date();
     const schedules = await this.prisma.trainSchedule.findMany({
-      where: { departureAt: { gte: now } },
+      where: all ? undefined : { departureAt: { gte: now } },
       select: {
         id: true,
         departureAt: true,
@@ -423,7 +367,7 @@ export class ReportsService {
         originStation: { select: { name: true } },
         destinationStation: { select: { name: true } },
       },
-      orderBy: { departureAt: 'asc' },
+      orderBy: { departureAt: all ? 'desc' : 'asc' },
       take: 200,
     });
     return schedules.map((s) => ({
@@ -439,8 +383,11 @@ export class ReportsService {
   async getPassengerList(scheduleId: string) {
     const seats = await this.prisma.bookingSeat.findMany({
       where: {
-        leg: 1,
-        booking: { scheduleId, status: { in: ["CONFIRMED", "BOARDED"] } },
+        OR: [
+          { scheduleId, booking: { status: { in: ['CONFIRMED', 'BOARDED'] } } },
+          { leg: 2, booking: { returnScheduleId: scheduleId, status: { in: ['CONFIRMED', 'BOARDED'] } } },
+          { scheduleId: null, leg: 1, booking: { scheduleId, status: { in: ['CONFIRMED', 'BOARDED'] } } },
+        ],
       },
       include: {
         booking: {
@@ -504,11 +451,14 @@ export class ReportsService {
   }
 
   async getSeatStatusReport(scheduleId: string) {
-    // Booked seats — exclude dining coaches
+    // Confirmed/boarded seats — exclude dining coaches
     const bookingSeats = await this.prisma.bookingSeat.findMany({
       where: {
-        leg: 1,
-        booking: { scheduleId, status: { in: ['CONFIRMED', 'BOARDED', 'PENDING_PAYMENT'] } },
+        OR: [
+          { scheduleId, booking: { status: { in: ['CONFIRMED', 'BOARDED', 'PENDING_PAYMENT'] } } },
+          { leg: 2, booking: { returnScheduleId: scheduleId, status: { in: ['CONFIRMED', 'BOARDED', 'PENDING_PAYMENT'] } } },
+          { scheduleId: null, leg: 1, booking: { scheduleId, status: { in: ['CONFIRMED', 'BOARDED', 'PENDING_PAYMENT'] } } },
+        ],
         seat: { coach: { coachType: { type: { not: 'dining' } } } },
       },
       include: {
@@ -538,11 +488,34 @@ export class ReportsService {
       orderBy: [{ seat: { coach: { number: 'asc' } } }, { seat: { seatNumber: 'asc' } }],
     });
 
-    // Manually blocked seats for this schedule — exclude MAINTENANCE entries
-    const blocks = await this.prisma.seatBlock.findMany({
+    // Active seat holds for this schedule
+    const activeHolds = await this.prisma.seatHold.findMany({
+      where: { scheduleId },
+      orderBy: { createdAt: 'desc' },
+    });
+
+    // Expired holds (last 24h) — held but never converted to a booking
+    const since24h = new Date(Date.now() - 24 * 60 * 60 * 1000);
+    const expiredHolds = await this.prisma.seatHold.findMany({
       where: {
         scheduleId,
-        NOT: { reason: { startsWith: 'MAINTENANCE:' } },
+        expiresAt: { lt: new Date(), gte: since24h },
+      },
+      orderBy: { expiresAt: 'desc' },
+    });
+
+    // Manually blocked seats — schedule-scoped blocks for this schedule OR global blocks (scheduleId null)
+    // Exclude MAINTENANCE and booking-system-created blocks
+    const blocks = await this.prisma.seatBlock.findMany({
+      where: {
+        OR: [
+          { scheduleId },
+          { scheduleId: null },
+        ],
+        NOT: [
+          { reason: { startsWith: 'MAINTENANCE:' } },
+          { reason: { startsWith: 'Booked in tickets' } },
+        ],
       },
       include: {
         seat: {
@@ -569,19 +542,41 @@ export class ReportsService {
       return (matched ?? classes[0])?.name ?? seat?.coach?.coachType?.name ?? null;
     };
 
+    const paidSeats = bookingSeats.filter(bs =>
+      bs.booking.status === 'CONFIRMED' || bs.booking.status === 'BOARDED'
+    );
+    const unpaidSeats = bookingSeats.filter(bs =>
+      bs.booking.status === 'PENDING_PAYMENT'
+    );
+
+    const mapSeat = (bs: any) => ({
+      bookingRef: bs.booking.bookingRef,
+      passengerName: bs.passengerName,
+      passengerCategory: bs.passengerCategory,
+      coachNumber: bs.seat?.coach?.number ?? null,
+      seatNumber: bs.seat?.seatNumber ?? null,
+      seatClassName: resolveSeatClass(bs.seat),
+      fareMinor: bs.fareMinor,
+      currency: bs.booking.currency ?? 'ETB',
+      bookingStatus: bs.booking.status,
+      paymentStatus: bs.booking.paymentIntent?.status ?? 'PENDING',
+      bookedAt: bs.booking.createdAt,
+    });
+
     return {
-      bookedSeats: bookingSeats.map(bs => ({
-        bookingRef: bs.booking.bookingRef,
-        passengerName: bs.passengerName,
-        passengerCategory: bs.passengerCategory,
-        coachNumber: bs.seat?.coach?.number ?? null,
-        seatNumber: bs.seat?.seatNumber ?? null,
-        seatClassName: resolveSeatClass(bs.seat),
-        fareMinor: bs.fareMinor,
-        currency: bs.booking.currency ?? 'ETB',
-        bookingStatus: bs.booking.status,
-        paymentStatus: bs.booking.paymentIntent?.status ?? 'PENDING',
-        bookedAt: bs.booking.createdAt,
+      summary: {
+        paidCount: paidSeats.length,
+        unpaidCount: unpaidSeats.length,
+        expiredHoldCount: expiredHolds.length,
+        blockedCount: blocks.filter(b => b.seat?.coach?.coachType?.type !== 'dining').length,
+      },
+      paidSeats: paidSeats.map(mapSeat),
+      unpaidSeats: unpaidSeats.map(mapSeat),
+      expiredHolds: expiredHolds.map(h => ({
+        holdId: h.id,
+        seatIds: h.seatIds,
+        expiresAt: h.expiresAt,
+        createdAt: h.createdAt,
       })),
       blockedSeats: blocks
         .filter(b => b.seat?.coach?.coachType?.type !== 'dining')
diff --git a/apps/edr-passenger-api/src/modules/seats/seats.service.ts b/apps/edr-passenger-api/src/modules/seats/seats.service.ts
index abb747710..bd73c10f5 100644
--- a/apps/edr-passenger-api/src/modules/seats/seats.service.ts
+++ b/apps/edr-passenger-api/src/modules/seats/seats.service.ts
@@ -1069,6 +1069,7 @@ export class SeatsService {
           booking: {
             select: {
               id: true, bookingRef: true, scheduleId: true,
+              originStationId: true, destinationStationId: true,
               createdAt: true, contactPhone: true,
             },
           },
@@ -1086,7 +1087,8 @@ export class SeatsService {
       });
       const occupiedIds = new Set(journeySegments.map(js => js.seatId!));
 
-      // Group BookingSeat rows by (seatId::leg) to detect duplicates
+      // Group BookingSeat rows by seatId::leg to find candidate duplicates,
+      // then filter to only those whose booking segments actually overlap.
       type BS = (typeof bookingSeats)[number];
       const groups = new Map<string, BS[]>();
       for (const bs of bookingSeats) {
@@ -1095,6 +1097,59 @@ export class SeatsService {
         groups.get(key)!.push(bs);
       }
 
+      // Build stop-sequence map for this schedule once
+      const stopTimes = await this.prisma.tripStopTime.findMany({
+        where: { scheduleId: schedule.id },
+        select: { stationId: true, sequence: true },
+      });
+      const seqOf = (stationId: string | null | undefined): number | undefined =>
+        stationId ? stopTimes.find(s => s.stationId === stationId)?.sequence : undefined;
+
+      // Fetch JourneySegment ranges for all booking IDs in candidate groups
+      const candidateBookingIds = [...new Set(
+        [...groups.values()].filter(g => g.length > 1).flatMap(g => g.map(bs => bs.booking.id)),
+      )];
+      const candidateSegments = candidateBookingIds.length > 0
+        ? await this.prisma.journeySegment.findMany({
+            where: {
+              scheduleId: schedule.id,
+              journey: { bookingId: { in: candidateBookingIds }, status: { in: ['CONFIRMED', 'PENDING_PAYMENT'] } },
+            },
+            select: { departureStationId: true, arrivalStationId: true, journey: { select: { bookingId: true } } },
+          })
+        : [];
+
+      // Collapse per-booking segments into a single [from, to) range
+      const rangeByBookingId = new Map<string, { from: number; to: number }>();
+      for (const seg of candidateSegments) {
+        const bookingId = seg.journey.bookingId;
+        if (!bookingId) continue;
+        const depSeq = seqOf(seg.departureStationId);
+        const arrSeq = seqOf(seg.arrivalStationId);
+        if (depSeq === undefined || arrSeq === undefined) continue;
+        const existing = rangeByBookingId.get(bookingId);
+        rangeByBookingId.set(bookingId, existing
+          ? { from: Math.min(existing.from, depSeq), to: Math.max(existing.to, arrSeq) }
+          : { from: depSeq, to: arrSeq });
+      }
+
+      // Fall back to booking-level origin/destination when JourneySegments are missing
+      const rangeForBooking = (bs: BS): { from: number; to: number } | null => {
+        const fromSegments = rangeByBookingId.get(bs.booking.id);
+        if (fromSegments) return fromSegments;
+        // BookingSeat.scheduleId tells us which leg this seat belongs to
+        const bsScheduleId = bs.scheduleId ?? bs.booking.scheduleId;
+        if (bsScheduleId !== schedule.id) return null;
+        const from = seqOf(bs.booking.originStationId);
+        const to = seqOf(bs.booking.destinationStationId);
+        if (from === undefined || to === undefined) return null;
+        return { from, to };
+      };
+
+      // Two bookings are true duplicates only if their segments overlap
+      const segmentsOverlap = (a: { from: number; to: number }, b: { from: number; to: number }) =>
+        a.from < b.to && b.from < a.to;
+
       // All seats held by any confirmed BookingSeat — union of JourneySegment-based
       // occupancy AND BookingSeat-based occupancy so that seats whose JourneySegments
       // are missing (e.g. created via enhanced-seats path without bookingId) are still
@@ -1114,13 +1169,30 @@ export class SeatsService {
         for (const [key, group] of groups) {
           if (group.length <= 1) continue;
           if (group[0].seat.coachId !== coach.id) continue;
+
+          // Filter to bookings that actually have overlapping segments
+          const overlapping: BS[] = [];
+          for (let i = 0; i < group.length; i++) {
+            const rangeA = rangeForBooking(group[i]);
+            for (let j = i + 1; j < group.length; j++) {
+              const rangeB = rangeForBooking(group[j]);
+              // If either range is unknown, conservatively treat as overlap
+              const isOverlap = !rangeA || !rangeB || segmentsOverlap(rangeA, rangeB);
+              if (isOverlap) {
+                if (!overlapping.includes(group[i])) overlapping.push(group[i]);
+                if (!overlapping.includes(group[j])) overlapping.push(group[j]);
+              }
+            }
+          }
+          if (overlapping.length <= 1) continue;
+
           const [seatId] = key.split('::');
           const seat = coach.seats.find(s => s.id === seatId);
           duplicates.push({
             seatId,
             seatNumber: seat?.seatNumber ?? seatId,
-            leg: group[0].leg,
-            bookings: group.map(bs => ({
+            leg: overlapping[0].leg,
+            bookings: overlapping.map(bs => ({
               bookingSeatId:  bs.id,
               bookingId:      bs.booking.id,
               bookingRef:     bs.booking.bookingRef,
diff --git a/apps/edr-passenger-web/backoffice/src/app/agents/page.tsx b/apps/edr-passenger-web/backoffice/src/app/agents/page.tsx
index 9efd7ab19..b2967c58d 100644
--- a/apps/edr-passenger-web/backoffice/src/app/agents/page.tsx
+++ b/apps/edr-passenger-web/backoffice/src/app/agents/page.tsx
@@ -9,6 +9,8 @@ import Badge from '@/components/ui/Badge';
 import Modal from '@/components/ui/Modal';
 import ConfirmDialog from '@/components/ui/ConfirmDialog';
 import { agentsApi, apiClient } from '@/lib/api';
+import Pagination from '@/components/ui/Pagination';
+import { usePagination } from '@/lib/use-pagination';
 import { formatCurrency, formatDateTime } from '@/lib/utils';
 import { useAuthStore } from '@/lib/auth-store';
 
@@ -90,6 +92,9 @@ export default function AgentsPage() {
     queryFn: () => agentsApi.getAll(filters),
   });
 
+  const allAgents = data?.items || [];
+  const { paged: pagedAgents, page, totalPages, setPage } = usePagination(allAgents, 20);
+
   const columns = [
     {
       key: 'agentCode',
@@ -182,12 +187,13 @@ export default function AgentsPage() {
       </div>
 
       <DataTable
-        data={data?.items || []}
+        data={pagedAgents}
         columns={columns}
         actions={actions}
         loading={isLoading}
         emptyMessage="No agents found"
       />
+      <Pagination currentPage={page} totalPages={totalPages} onPageChange={setPage} />
 
       <ConfirmDialog
         isOpen={deleteConfirm.isOpen}
diff --git a/apps/edr-passenger-web/backoffice/src/app/coaches/page.tsx b/apps/edr-passenger-web/backoffice/src/app/coaches/page.tsx
index eb8ebf036..acb0deefa 100644
--- a/apps/edr-passenger-web/backoffice/src/app/coaches/page.tsx
+++ b/apps/edr-passenger-web/backoffice/src/app/coaches/page.tsx
@@ -8,6 +8,8 @@ import ActionButton from '@/components/ui/ActionButton';
 import Modal from '@/components/ui/Modal';
 import ConfirmDialog from '@/components/ui/ConfirmDialog';
 import { fleetApi, apiClient } from '@/lib/api';
+import Pagination from '@/components/ui/Pagination';
+import { usePagination } from '@/lib/use-pagination';
 
 type Tab = 'types' | 'coaches' | 'utilization';
 
@@ -315,6 +317,9 @@ export default function CoachesPage() {
     );
   });
 
+  const { paged: pagedCoachTypes, page: typesPage, totalPages: typesTotalPages, setPage: setTypesPage } = usePagination(filteredCoachTypes as any[], 20);
+  const { paged: pagedCoaches, page: coachesPage, totalPages: coachesTotalPages, setPage: setCoachesPage } = usePagination(filteredCoaches as any[], 20);
+
   const typeColorMap: Record<string, string> = {
     passenger: 'edr-badge-info',
     sleeper: 'edr-badge-warning',
@@ -551,11 +556,12 @@ export default function CoachesPage() {
             </div>
             <DataTable
               columns={coachTypeColumns}
-              data={filteredCoachTypes}
+              data={pagedCoachTypes}
               actions={coachTypeActions}
               loading={typesLoading}
               emptyMessage={search ? "No coach types match your search" : "No coach types found. Create one to get started."}
             />
+            <Pagination currentPage={typesPage} totalPages={typesTotalPages} onPageChange={setTypesPage} />
           </div>
         )}
 
@@ -574,11 +580,12 @@ export default function CoachesPage() {
             </div>
             <DataTable
               columns={coachColumns}
-              data={filteredCoaches}
+              data={pagedCoaches}
               actions={coachActions}
               loading={coachesLoading}
               emptyMessage={search ? "No coaches match your search" : "No coaches found. Create one to get started."}
             />
+            <Pagination currentPage={coachesPage} totalPages={coachesTotalPages} onPageChange={setCoachesPage} />
           </div>
         )}
 
diff --git a/apps/edr-passenger-web/backoffice/src/app/payments/page.tsx b/apps/edr-passenger-web/backoffice/src/app/payments/page.tsx
index b9c81a183..9cbfdd4e3 100644
--- a/apps/edr-passenger-web/backoffice/src/app/payments/page.tsx
+++ b/apps/edr-passenger-web/backoffice/src/app/payments/page.tsx
@@ -9,6 +9,8 @@ import ActionButton from '@/components/ui/ActionButton';
 import Modal from '@/components/ui/Modal';
 import ConfirmDialog from '@/components/ui/ConfirmDialog';
 import { paymentsApi, apiClient } from '@/lib/api';
+import Pagination from '@/components/ui/Pagination';
+import { usePagination } from '@/lib/use-pagination';
 import { formatDateTime, formatCurrency } from '@/lib/utils';
 import SupplementaryChargesModal from './SupplementaryChargesModal';
 import {
@@ -109,6 +111,9 @@ export default function PaymentsPage() {
     }),
   });
 
+  const allPayments = (data as any)?.items || (Array.isArray(data) ? data : []);
+  const { paged: pagedPayments, page: paymentsPage, totalPages: paymentsTotalPages, setPage: setPaymentsPage } = usePagination(allPayments, 20);
+
   const PAYMENT_COLS = [
     { key: 'reference', label: 'Reference' },
     { key: 'booking',   label: 'Booking Reference' },
@@ -311,12 +316,13 @@ export default function PaymentsPage() {
       </div>
 
       <DataTable
-        data={(data as any)?.items || (Array.isArray(data) ? data : [])}
+        data={pagedPayments}
         columns={columns}
         actions={paymentActions}
         loading={isLoading}
         emptyMessage="No payments found"
       />
+      <Pagination currentPage={paymentsPage} totalPages={paymentsTotalPages} onPageChange={setPaymentsPage} />
 
       {/* Payment Details Modal */}
       <Modal isOpen={!!selectedPayment} onClose={() => setSelectedPayment(null)} title="Payment Details" size="xl">
diff --git a/apps/edr-passenger-web/backoffice/src/app/reports/passengers/page.tsx b/apps/edr-passenger-web/backoffice/src/app/reports/passengers/page.tsx
index a028faa8c..35b6d6cc7 100644
--- a/apps/edr-passenger-web/backoffice/src/app/reports/passengers/page.tsx
+++ b/apps/edr-passenger-web/backoffice/src/app/reports/passengers/page.tsx
@@ -6,6 +6,8 @@ import { Users, Armchair, BarChart3, Train, Download } from "lucide-react";
 import { apiClient } from "@/lib/api-client";
 import { formatDateTime } from "@/lib/utils";
 import ActionButton from "@/components/ui/ActionButton";
+import Pagination from "@/components/ui/Pagination";
+import { usePagination } from "@/lib/use-pagination";
 
 interface ScheduleOption {
   id: string;
@@ -56,11 +58,9 @@ interface PassengerRow {
   seatClassName: string | null;
   coachNumber: string | null;
   coachType: string | null;
-  coachSeat: string | null;
   nationality: string | null;
   origin: string | null;
   destination: string | null;
-  departureAt: string | null;
   amountPaidMinor: number;
   currency: string;
   isGroupBooking: boolean;
@@ -73,7 +73,6 @@ export default function PassengersReportPage() {
   const [scheduleId, setScheduleId] = useState("");
   const [tab, setTab] = useState<Tab>("occupancy");
   const [listSearch, setListSearch] = useState("");
-  const [filterCoach, setFilterCoach] = useState("");
   const [filterOrigin, setFilterOrigin] = useState("");
   const [filterSeatClass, setFilterSeatClass] = useState("");
   const [filterCoachNumber, setFilterCoachNumber] = useState("");
@@ -81,8 +80,8 @@ export default function PassengersReportPage() {
   const { data: schedulesRaw, isLoading: loadingSchedules } = useQuery<
     ScheduleOption[]
   >({
-    queryKey: ["report-schedules"],
-    queryFn: () => apiClient.get("/reports/schedules"),
+    queryKey: ["report-schedules-all"],
+    queryFn: () => apiClient.get("/reports/schedules?all=true"),
   });
   const schedules = schedulesRaw ?? [];
 
@@ -102,7 +101,7 @@ export default function PassengersReportPage() {
     enabled: !!scheduleId,
   });
 
-  const coachOptions = [
+  const coachNumberOptions = [
     ...new Set(passengerList.map((p) => p.coachNumber).filter(Boolean)),
   ].sort() as string[];
   const seatClassOptions = [
@@ -111,11 +110,9 @@ export default function PassengersReportPage() {
   const originOptions = [
     ...new Set(passengerList.map((p) => p.origin).filter(Boolean)),
   ].sort() as string[];
-  const coachNumberOptions = coachOptions;
 
   const filteredList = passengerList
     .filter((p) => {
-      if (filterCoach && p.coachNumber !== filterCoach) return false;
       if (filterCoachNumber && p.coachNumber !== filterCoachNumber) return false;
       if (filterOrigin && p.origin !== filterOrigin) return false;
       if (filterSeatClass && p.seatClassName !== filterSeatClass) return false;
@@ -132,6 +129,8 @@ export default function PassengersReportPage() {
     })
     .sort((a, b) => a.bookingRef.localeCompare(b.bookingRef));
 
+  const { paged: pagedList, page: listPage, totalPages: listTotalPages, setPage: setListPage, reset: resetListPage } = usePagination(filteredList, 50);
+
   const downloadCsv = (csv: string, filename: string) => {
     const blob = new Blob([csv], { type: "text/csv" });
     const url = URL.createObjectURL(blob);
@@ -161,29 +160,24 @@ export default function PassengersReportPage() {
   };
 
   const doExportList = () => {
-    if (!passengerList.length) return;
-    const headers = [
-      "#",
-      "Name",
-      "Coach·Seat",
-      "Origin",
-      "Destination",
-      "Date",
-      "Booking Ref",
-    ];
-    const rows = passengerList.map((p, i) =>
+    if (!filteredList.length) return;
+    const headers = ['Name', 'Nationality', 'Passport Number', 'Seat Class', 'Coach', 'Seat', 'Origin', 'Destination', 'Amount Paid (ETB)', 'Booking Ref'];
+    const rows = filteredList.map((p) =>
       [
-        String(i + 1),
         p.passengerName,
-        p.coachSeat,
-        p.origin,
-        p.destination,
-        p.departureAt ? formatDateTime(p.departureAt) : "—",
+        p.nationality ?? '—',
+        p.passportNumber ?? '—',
+        p.seatClassName ?? '—',
+        p.coachNumber ?? '—',
+        p.seatNumber ?? '—',
+        p.origin ?? '—',
+        p.destination ?? '—',
+        (p.amountPaidMinor / 100).toFixed(2),
         p.bookingRef,
       ].map((v) => `"${String(v).replace(/"/g, '""')}"`),
     );
     downloadCsv(
-      [headers.join(","), ...rows.map((r) => r.join(","))].join("\n"),
+      [headers.join(','), ...rows.map((r) => r.join(','))].join('\n'),
       `passengers-${scheduleId}.csv`,
     );
   };
@@ -211,7 +205,6 @@ export default function PassengersReportPage() {
                 setScheduleId(e.target.value);
                 setTab("occupancy");
                 setListSearch("");
-                setFilterCoach("");
                 setFilterCoachNumber("");
                 setFilterOrigin("");
                 setFilterSeatClass("");
@@ -468,12 +461,12 @@ export default function PassengersReportPage() {
                   className="input max-w-sm flex-1"
                   placeholder="Search by name or booking ref…"
                   value={listSearch}
-                  onChange={(e) => setListSearch(e.target.value)}
+                  onChange={(e) => { setListSearch(e.target.value); resetListPage(); }}
                 />
                 <select
                   className="input w-40"
                   value={filterSeatClass}
-                  onChange={(e) => setFilterSeatClass(e.target.value)}
+                  onChange={(e) => { setFilterSeatClass(e.target.value); resetListPage(); }}
                 >
                   <option value="">All classes</option>
                   {seatClassOptions.map((c) => (
@@ -485,7 +478,7 @@ export default function PassengersReportPage() {
                 <select
                   className="input w-36"
                   value={filterCoachNumber}
-                  onChange={(e) => setFilterCoachNumber(e.target.value)}
+                  onChange={(e) => { setFilterCoachNumber(e.target.value); resetListPage(); }}
                 >
                   <option value="">All coaches</option>
                   {coachNumberOptions.map((c) => (
@@ -497,7 +490,7 @@ export default function PassengersReportPage() {
                 <select
                   className="input w-36"
                   value={filterOrigin}
-                  onChange={(e) => setFilterOrigin(e.target.value)}
+                  onChange={(e) => { setFilterOrigin(e.target.value); resetListPage(); }}
                 >
                   <option value="">All origins</option>
                   {originOptions.map((o) => (
@@ -520,99 +513,47 @@ export default function PassengersReportPage() {
                 <table className="w-full text-sm">
                   <thead>
                     <tr className="border-b border-border text-left text-xs text-muted-foreground uppercase tracking-wider">
-                      <th className="pb-2 pr-4">Name</th>
-                      <th className="pb-2 pr-4">Nationality</th>
-                      <th className="pb-2 pr-4">Passport</th>
-                      <th className="pb-2 pr-4">Coach</th>
-                      <th className="pb-2 pr-4">Seat</th>
-                      <th className="pb-2 pr-4">Class</th>
-                      <th className="pb-2 pr-4">Origin</th>
-                      <th className="pb-2 pr-4">Destination</th>
-                      <th className="pb-2 pr-4">Amount Paid</th>
-                      <th className="pb-2">Booking Ref</th>
+                      <th className="pb-2 pr-4 whitespace-nowrap">Name</th>
+                      <th className="pb-2 pr-4 whitespace-nowrap">Nationality</th>
+                      <th className="pb-2 pr-4 whitespace-nowrap">Seat Class · Coach · Seat</th>
+                      <th className="pb-2 pr-4 whitespace-nowrap">Route</th>
+                      <th className="pb-2 pr-4 whitespace-nowrap">Amount Paid</th>
+                      <th className="pb-2 whitespace-nowrap">Booking Ref</th>
                     </tr>
                   </thead>
                   <tbody className="divide-y divide-border">
-                    {filteredList.map((p, i) => (
-                      <tr
-                        key={`${p.bookingRef}-${i}`}
-                        className="hover:bg-muted/30"
-                      >
-                        <td className="py-2 pr-4 font-medium">
-                          {p.passengerName}
-                        </td>
+                    {pagedList.map((p, i) => (
+                      <tr key={`${p.bookingRef}-${i}`} className="hover:bg-muted/30">
+                        <td className="py-2 pr-4 font-medium whitespace-nowrap">{p.passengerName}</td>
                         <td className="py-2 pr-4 text-xs">
-                          {p.passportNumber ? (
-                            <>
-                              <span className="text-muted-foreground">
-                                {p.passportCountry ?? "Intl"}
-                              </span>
-                              <span className="ml-1 font-mono">
-                                {p.passportNumber}
-                              </span>
-                            </>
-                          ) : (
-                            <span className="text-muted-foreground">
-                              {p.idDocumentNumber ?? "—"}
-                            </span>
+                          <span className="text-muted-foreground">{p.nationality ?? '—'}</span>
+                          {p.passportNumber && (
+                            <span className="ml-1.5 font-mono text-foreground">{p.passportNumber}</span>
                           )}
                         </td>
-                        <td className="py-2 pr-4 font-mono text-xs">
-                          {p.coachNumber && p.seatLabel ? (
-                            <>
-                              {p.coachNumber} · {p.seatLabel}
-                              {p.coachType && (
-                                <span className="font-sans text-muted-foreground ml-1">
-                                  ({p.coachType})
-                                </span>
-                              )}
-                            </>
-                          ) : (
-                            (p.coachNumber ?? p.seatLabel ?? "—")
-                          )}
-                        </td>
-                        <td className="py-2 pr-4 text-muted-foreground text-xs">
-                          {p.origin && p.destination
-                            ? `${p.origin} → ${p.destination}`
-                            : (p.origin ?? p.destination ?? "—")}
-                        </td>
                         <td className="py-2 pr-4 text-xs">
-                          <div className="flex items-center gap-1.5">
-                            <span className="tabular-nums font-medium">
-                              {(p.amountPaidMinor / 100).toLocaleString(
-                                "en-US",
-                                {
-                                  minimumFractionDigits: 2,
-                                  maximumFractionDigits: 2,
-                                },
-                              )}{" "}
-                              {p.currency}
-                            </span>
-                            {p.isGroupBooking && (
-                              <span className="inline-flex items-center rounded px-1.5 py-0.5 text-[10px] font-semibold bg-blue-100 text-blue-700 dark:bg-blue-900/40 dark:text-blue-300">
-                                Group
-                              </span>
-                            )}
-                          </div>
+                          <span className="font-medium">{p.seatClassName ?? '—'}</span>
+                          {p.coachNumber && <span className="text-muted-foreground"> · {p.coachNumber}</span>}
+                          {p.seatNumber && <span className="text-muted-foreground"> · #{p.seatNumber}</span>}
                         </td>
-                        <td className="py-2 font-mono text-xs">
-                          {p.bookingRef}
+                        <td className="py-2 pr-4 text-xs text-muted-foreground whitespace-nowrap">
+                          {p.origin && p.destination ? `${p.origin} → ${p.destination}` : (p.origin ?? p.destination ?? '—')}
                         </td>
+                        <td className="py-2 pr-4 tabular-nums text-xs">
+                          {(p.amountPaidMinor / 100).toLocaleString('en-US', { minimumFractionDigits: 2 })} {p.currency}
+                        </td>
+                        <td className="py-2 font-mono text-xs">{p.bookingRef}</td>
                       </tr>
                     ))}
                     {filteredList.length === 0 && (
                       <tr>
-                        <td
-                          colSpan={6}
-                          className="py-8 text-center text-sm text-muted-foreground"
-                        >
-                          No passengers found
-                        </td>
+                        <td colSpan={6} className="py-8 text-center text-sm text-muted-foreground">No passengers found</td>
                       </tr>
                     )}
                   </tbody>
                 </table>
               </div>
+              <Pagination currentPage={listPage} totalPages={listTotalPages} onPageChange={setListPage} />
             </div>
           )}
         </>
diff --git a/apps/edr-passenger-web/backoffice/src/app/reports/payment-discrepancy/page.tsx b/apps/edr-passenger-web/backoffice/src/app/reports/payment-discrepancy/page.tsx
index 35f0a62d0..0a7ba04eb 100644
--- a/apps/edr-passenger-web/backoffice/src/app/reports/payment-discrepancy/page.tsx
+++ b/apps/edr-passenger-web/backoffice/src/app/reports/payment-discrepancy/page.tsx
@@ -9,6 +9,8 @@ import {
 import { apiClient } from '@/lib/api-client';
 import DatePicker from '@/components/ui/DatePicker';
 import { parse, isValid } from 'date-fns';
+import Pagination from '@/components/ui/Pagination';
+import { usePagination } from '@/lib/use-pagination';
 
 // ── Types ─────────────────────────────────────────────────────────────────────
 
@@ -158,6 +160,8 @@ export default function PaymentDiscrepancyPage() {
 
   const rows = data?.rows ?? [];
 
+  const { paged: pagedRows, page: discPage, totalPages: discTotalPages, setPage: setDiscPage } = usePagination(rows.filter(r => r.balanceMinor > 0), 20);
+
   const parsedFrom = from ? parse(from, 'yyyy-MM-dd', new Date()) : undefined;
   const fromDate = parsedFrom && isValid(parsedFrom) ? parsedFrom : undefined;
 
@@ -316,7 +320,7 @@ export default function PaymentDiscrepancyPage() {
                 </tr>
               </thead>
               <tbody className="divide-y divide-gray-100 dark:divide-gray-800">
-                {rows.filter(row => row.balanceMinor > 0).map((row, i) => {
+                {pagedRows.map((row, i) => {
                   const isExpanded = expandedPnr === row.pnr;
                   const hasMultiple = row.passengerCount > 1;
                   return (
@@ -447,8 +451,11 @@ export default function PaymentDiscrepancyPage() {
             </table>
           </div>
           {!isSearchMode && (
-            <div className="px-4 py-3 border-t border-gray-100 dark:border-gray-800 text-xs text-gray-400 dark:text-gray-500">
-              {rows.filter(r => r.balanceMinor > 0).length} record{rows.filter(r => r.balanceMinor > 0).length !== 1 ? 's' : ''} — click a phone number to call directly, or export CSV for bulk follow-up
+            <div className="px-4 py-3 border-t border-gray-100 dark:border-gray-800 flex items-center justify-between">
+              <span className="text-xs text-gray-400 dark:text-gray-500">
+                {rows.filter(r => r.balanceMinor > 0).length} record{rows.filter(r => r.balanceMinor > 0).length !== 1 ? 's' : ''} — click a phone number to call directly, or export CSV for bulk follow-up
+              </span>
+              <Pagination currentPage={discPage} totalPages={discTotalPages} onPageChange={setDiscPage} />
             </div>
           )}
         </div>
diff --git a/apps/edr-passenger-web/backoffice/src/app/reports/seats/page.tsx b/apps/edr-passenger-web/backoffice/src/app/reports/seats/page.tsx
index 92e18b919..2f5611f80 100644
--- a/apps/edr-passenger-web/backoffice/src/app/reports/seats/page.tsx
+++ b/apps/edr-passenger-web/backoffice/src/app/reports/seats/page.tsx
@@ -1,161 +1,126 @@
 "use client";
 
-import { useState, useMemo } from "react";
+import { useState } from "react";
 import { useQuery } from "@tanstack/react-query";
-import {
-  Download,
-  CheckCircle,
-  Clock,
-  AlertCircle,
-} from "lucide-react";
-import { bookingsApi, seatsApi } from "@/lib/api";
+import { CheckCircle, Clock, AlertCircle, Ban, Armchair, Download } from "lucide-react";
+import { apiClient } from "@/lib/api-client";
 import Badge from "@/components/ui/Badge";
 import ActionButton from "@/components/ui/ActionButton";
 import { formatDateTime, formatCurrency } from "@/lib/utils";
+import Pagination from "@/components/ui/Pagination";
+import { usePagination } from "@/lib/use-pagination";
 
-const HOLD_DURATION_MS = 15 * 60 * 1000;
-
-function isExpired(releaseAt: string | null): boolean {
-  if (!releaseAt) return false;
-  return new Date(releaseAt) < new Date();
+interface ScheduleOption {
+  id: string;
+  label: string;
 }
 
-interface BookedSeatRow {
+interface SeatRow {
   bookingRef: string;
   passengerName: string;
-  coachNumber: string;
-  seatNumber: string;
+  passengerCategory: string;
+  coachNumber: string | null;
+  seatNumber: string | null;
+  seatClassName: string | null;
   fareMinor: number;
   currency: string;
   bookingStatus: string;
   paymentStatus: string;
   bookedAt: string;
-  releaseAt: string | null;
-  scheduleOrigin: string;
-  scheduleDestination: string;
-  scheduleDeparture: string;
 }
 
-function getReleaseAt(booking: any, seat: any): string | null {
-  const paymentStatus = booking.paymentIntent?.status || "PENDING";
-  if (paymentStatus === "SUCCEEDED" || paymentStatus === "COMPLETED") return null;
-  if (booking.status === "CONFIRMED") return null;
-  if (seat?.holdExpiresAt) return seat.holdExpiresAt;
-  if (booking.createdAt) {
-    return new Date(
-      new Date(booking.createdAt).getTime() + HOLD_DURATION_MS,
-    ).toISOString();
-  }
-  return null;
+interface BlockedRow {
+  id: string;
+  coachNumber: string | null;
+  seatNumber: string | null;
+  seatClassName: string | null;
+  reason: string;
+  blockedBy: string;
+  blockedAt: string;
+  unblockAt: string | null;
 }
 
+interface SeatStatusReport {
+  summary: {
+    paidCount: number;
+    unpaidCount: number;
+    expiredHoldCount: number;
+    blockedCount: number;
+  };
+  paidSeats: SeatRow[];
+  unpaidSeats: SeatRow[];
+  expiredHolds: { holdId: string; seatIds: string[]; expiresAt: string; createdAt: string }[];
+  blockedSeats: BlockedRow[];
+}
+
+type Tab = "seats" | "blocked";
+
 export default function SeatStatusReportPage() {
+  const [scheduleId, setScheduleId] = useState("");
+  const [tab, setTab] = useState<Tab>("seats");
   const [statusFilter, setStatusFilter] = useState<"ALL" | "PAID" | "UNPAID">("ALL");
   const [search, setSearch] = useState("");
 
-  const { data: blockedSeats = [] } = useQuery({
-    queryKey: ["blocked-seats"],
-    queryFn: () =>
-      seatsApi
-        .getBlocked()
-        .then((r: any) => (Array.isArray(r) ? r : (r?.data ?? []))),
+  const { data: schedulesRaw, isLoading: loadingSchedules } = useQuery<ScheduleOption[]>({
+    queryKey: ["report-schedules-all"],
+    queryFn: () => apiClient.get("/reports/schedules?all=true"),
+  });
+  const schedules = schedulesRaw ?? [];
+
+  const { data, isLoading, isError } = useQuery<SeatStatusReport>({
+    queryKey: ["seat-status-report", scheduleId],
+    queryFn: () => apiClient.get(`/reports/seat-status?scheduleId=${scheduleId}`),
+    enabled: !!scheduleId,
   });
 
-  const { data: bookingsData, isLoading } = useQuery({
-    queryKey: ["seat-report-bookings"],
-    queryFn: () => bookingsApi.getAll({ pageSize: 1000 }),
-  });
+  const allSeats: SeatRow[] = [
+    ...(data?.paidSeats ?? []),
+    ...(data?.unpaidSeats ?? []),
+  ];
 
-  const rows = useMemo<BookedSeatRow[]>(() => {
-    const bookings: any[] = (bookingsData as any)?.data ?? (Array.isArray(bookingsData) ? bookingsData : []);
-    const result: BookedSeatRow[] = [];
-    for (const booking of bookings) {
-      if (booking.status === "CANCELLED") continue;
-      const seats: any[] = booking.seats || [];
-      const paymentStatus = booking.paymentIntent?.status || "PENDING";
-      for (const seat of seats) {
-        result.push({
-          bookingRef: booking.bookingRef || "—",
-          passengerName:
-            seat.passengerName ||
-            seat.name ||
-            booking.passengerNames?.[0] ||
-            "—",
-          seatNumber: seat.seat?.seatNumber || seat.seatNumber || "—",
-          coachNumber: seat.seat?.coach?.number || seat.coach || "—",
-          fareMinor: seat.fareMinor ?? 0,
-          currency: booking.currency || "ETB",
-          paymentStatus,
-          bookingStatus: booking.status,
-          bookedAt: booking.createdAt,
-          releaseAt: getReleaseAt(booking, seat),
-          scheduleOrigin: booking.schedule?.originStation?.name || "—",
-          scheduleDestination: booking.schedule?.destinationStation?.name || "—",
-          scheduleDeparture: booking.schedule?.departureAt || "",
-        });
-      }
+  const filtered = allSeats.filter((r) => {
+    const isPaid = r.bookingStatus === "CONFIRMED" || r.bookingStatus === "BOARDED";
+    if (statusFilter === "PAID" && !isPaid) return false;
+    if (statusFilter === "UNPAID" && isPaid) return false;
+    if (search.trim()) {
+      const q = search.toLowerCase();
+      return (
+        r.bookingRef.toLowerCase().includes(q) ||
+        r.passengerName.toLowerCase().includes(q) ||
+        (r.seatNumber ?? "").toLowerCase().includes(q) ||
+        (r.coachNumber ?? "").toLowerCase().includes(q)
+      );
     }
-    return result;
-  }, [bookingsData]);
+    return true;
+  });
 
-  const filtered = useMemo(() => {
-    return rows.filter((r) => {
-      const isPaid =
-        r.paymentStatus === "SUCCEEDED" || r.paymentStatus === "COMPLETED";
-      if (statusFilter === "PAID" && !isPaid) return false;
-      if (statusFilter === "UNPAID" && isPaid) return false;
-      if (search) {
-        const q = search.toLowerCase();
-        return (
-          r.bookingRef.toLowerCase().includes(q) ||
-          r.passengerName.toLowerCase().includes(q) ||
-          (r.seatNumber ?? "").toLowerCase().includes(q) ||
-          (r.coachNumber ?? "").toLowerCase().includes(q)
-        );
-      }
-      return true;
-    });
-  }, [rows, statusFilter, search]);
-
-  const paidCount = rows.filter(
-    (r) => r.paymentStatus === "SUCCEEDED" || r.paymentStatus === "COMPLETED",
-  ).length;
-  const unpaidCount = rows.length - paidCount;
-  const expiredCount = rows.filter((r) => isExpired(r.releaseAt)).length;
+  const { paged: pagedSeats, page: seatsPage, totalPages: seatsTotalPages, setPage: setSeatsPage, reset: resetSeatsPage } = usePagination(filtered, 50);
+  const { paged: pagedBlocked, page: blockedPage, totalPages: blockedTotalPages, setPage: setBlockedPage } = usePagination(data?.blockedSeats ?? [], 50);
 
   const doExport = () => {
-    if (!filtered.length) {
-      alert("No data to export");
-      return;
-    }
-    const headers = [
-      "Booking Ref", "Passenger", "Seat", "Coach", "Fare",
-      "Payment Status", "Booking Status", "Booked At", "Release At",
-      "Origin", "Destination", "Departure",
-    ];
-    const csvRows = filtered.map((r) => [
+    if (!filtered.length) return;
+    const headers = ["Booking Ref", "Passenger", "Category", "Seat Class", "Coach", "Seat", "Fare", "Payment", "Booking Status", "Booked At"];
+    const rows = filtered.map((r) => [
       r.bookingRef,
       r.passengerName,
-      r.seatNumber,
-      r.coachNumber,
+      r.passengerCategory,
+      r.seatClassName ?? "—",
+      r.coachNumber ?? "—",
+      r.seatNumber ?? "—",
       formatCurrency(r.fareMinor, r.currency),
       r.paymentStatus,
       r.bookingStatus,
       r.bookedAt ? formatDateTime(r.bookedAt) : "—",
-      r.releaseAt ? formatDateTime(r.releaseAt) : "—",
-      r.scheduleOrigin,
-      r.scheduleDestination,
-      r.scheduleDeparture ? formatDateTime(r.scheduleDeparture) : "—",
     ]);
     const csv = [
       headers.map((h) => `"${h}"`).join(","),
-      ...csvRows.map((row) => row.map((v) => `"${v}"`).join(",")),
+      ...rows.map((row) => row.map((v) => `"${v}"`).join(",")),
     ].join("\n");
     const blob = new Blob([csv], { type: "text/csv" });
     const url = URL.createObjectURL(blob);
     const a = document.createElement("a");
     a.href = url;
-    a.download = `seat-status-report-${new Date().toISOString().split("T")[0]}.csv`;
+    a.download = `seat-status-${scheduleId}-${new Date().toISOString().split("T")[0]}.csv`;
     a.click();
     URL.revokeObjectURL(url);
   };
@@ -165,208 +130,258 @@ export default function SeatStatusReportPage() {
       <div>
         <h1 className="text-3xl font-bold text-foreground">Seat Status Report</h1>
         <p className="text-muted-foreground mt-1">
-          Track booked seats — paid vs unpaid, booking times, and hold release times
+          Paid, unpaid, expired holds and blocked seats for a schedule
         </p>
       </div>
 
-      {/* Summary Cards */}
-      <div className="grid grid-cols-1 md:grid-cols-4 gap-4">
-        <div className="card">
-          <div className="flex items-start justify-between">
-            <div>
-              <p className="text-muted-foreground text-sm font-medium">Paid Seats</p>
-              <p className="text-2xl font-bold mt-2 text-green-600 dark:text-green-400">{paidCount}</p>
-              <p className="text-xs text-muted-foreground mt-1">Payment confirmed</p>
-            </div>
-            <CheckCircle className="h-8 w-8 text-green-500 opacity-30" />
-          </div>
-        </div>
-
-        <div className="card">
-          <div className="flex items-start justify-between">
-            <div>
-              <p className="text-muted-foreground text-sm font-medium">Unpaid Seats</p>
-              <p className="text-2xl font-bold mt-2 text-amber-600 dark:text-amber-400">{unpaidCount}</p>
-              <p className="text-xs text-muted-foreground mt-1">Awaiting payment</p>
-            </div>
-            <Clock className="h-8 w-8 text-amber-500 opacity-30" />
-          </div>
-        </div>
-
-        <div className="card">
-          <div className="flex items-start justify-between">
-            <div>
-              <p className="text-muted-foreground text-sm font-medium">Expired Holds</p>
-              <p className="text-2xl font-bold mt-2 text-red-600 dark:text-red-400">{expiredCount}</p>
-              <p className="text-xs text-muted-foreground mt-1">Hold time passed, not paid</p>
-            </div>
-            <AlertCircle className="h-8 w-8 text-red-500 opacity-30" />
-          </div>
-        </div>
-
-        <div className="card">
-          <div className="flex items-start justify-between">
-            <div>
-              <p className="text-muted-foreground text-sm font-medium">Blocked Seats</p>
-              <p className="text-2xl font-bold mt-2 text-slate-600 dark:text-slate-400">
-                {(blockedSeats as any[]).length}
-              </p>
-              <p className="text-xs text-muted-foreground mt-1">Manually blocked</p>
-            </div>
-          </div>
-          {(blockedSeats as any[]).length > 0 && (
-            <div className="mt-3 border-t border-border pt-3 flex flex-col gap-1 max-h-32 overflow-y-auto">
-              {(blockedSeats as any[]).map((b: any) => (
-                <div key={b.id} className="flex items-center justify-between text-xs">
-                  <span className="font-medium text-foreground">
-                    Seat {b.seatNumber} · Coach {b.coachNumber}
-                  </span>
-                  <span className="text-muted-foreground truncate max-w-24" title={b.reason}>
-                    {b.reason}
-                  </span>
-                </div>
-              ))}
-            </div>
-          )}
-        </div>
-      </div>
-
-      {/* Filters */}
+      {/* Schedule selector */}
       <div className="card">
-        <div className="flex flex-wrap items-end gap-4">
-          <div className="flex-1 min-w-48">
-            <label className="label">Search</label>
-            <input
-              type="text"
-              className="input"
-              placeholder="Booking ref, passenger, seat, coach..."
-              value={search}
-              onChange={(e) => setSearch(e.target.value)}
-            />
-          </div>
-          <div>
-            <label className="label">Payment Status</label>
+        <div className="flex items-end gap-4 flex-wrap">
+          <div className="flex-1 min-w-72">
+            <label className="label">Schedule</label>
             <select
               className="input"
-              value={statusFilter}
-              onChange={(e) =>
-                setStatusFilter(e.target.value as "ALL" | "PAID" | "UNPAID")
-              }
+              value={scheduleId}
+              onChange={(e) => {
+                setScheduleId(e.target.value);
+                setTab("seats");
+                setStatusFilter("ALL");
+                setSearch("");
+              }}
+              disabled={loadingSchedules}
             >
-              <option value="ALL">All Seats</option>
-              <option value="PAID">Paid Only</option>
-              <option value="UNPAID">Unpaid Only</option>
+              <option value="">
+                {loadingSchedules ? "Loading schedules…" : "Select a schedule…"}
+              </option>
+              {schedules.map((s) => (
+                <option key={s.id} value={s.id}>
+                  {s.label}
+                </option>
+              ))}
             </select>
           </div>
-          <ActionButton
-            icon={Download}
-            variant="secondary"
-            onClick={doExport}
-            disabled={isLoading}
-          >
-            Export CSV
-          </ActionButton>
         </div>
-        {isLoading && (
-          <p className="text-xs text-muted-foreground mt-2">Loading...</p>
-        )}
+        {isLoading && <p className="text-xs text-muted-foreground mt-2">Loading…</p>}
+        {isError && <p className="text-xs text-red-500 mt-2">Failed to load report.</p>}
       </div>
 
-      {/* Table */}
-      <div className="card p-0">
-        <div className="overflow-x-auto">
-          <table className="w-full">
-            <thead className="bg-gray-50 dark:bg-gray-800">
-              <tr>
-                {[
-                  "Booking Ref", "Passenger", "Seat / Coach", "Fare",
-                  "Payment", "Booked At", "Release At", "Route",
-                ].map((h) => (
-                  <th
-                    key={h}
-                    className="px-4 py-3 text-left text-xs font-medium uppercase tracking-wider text-gray-500 dark:text-gray-400"
-                  >
-                    {h}
-                  </th>
-                ))}
-              </tr>
-            </thead>
-            <tbody className="bg-white dark:bg-gray-900 divide-y divide-gray-200 dark:divide-gray-700">
-              {filtered.map((row, i) => {
-                const isPaid =
-                  row.paymentStatus === "SUCCEEDED" ||
-                  row.paymentStatus === "COMPLETED";
-                const expired = isExpired(row.releaseAt);
-                return (
-                  <tr
-                    key={i}
-                    className="hover:bg-gray-50 dark:hover:bg-gray-800 transition-colors"
-                  >
-                    <td className="px-4 py-3 text-sm font-mono font-semibold whitespace-nowrap">
-                      {row.bookingRef}
-                    </td>
-                    <td className="px-4 py-3 text-sm whitespace-nowrap">
-                      {row.passengerName}
-                    </td>
-                    <td className="px-4 py-3 text-sm whitespace-nowrap">
-                      <span className="font-semibold">{row.seatNumber}</span>
-                      {row.coachNumber !== "—" && (
-                        <span className="text-muted-foreground">
-                          {" · Coach "}
-                          {row.coachNumber}
-                        </span>
-                      )}
-                    </td>
-                    <td className="px-4 py-3 text-sm whitespace-nowrap">
-                      {formatCurrency(row.fareMinor, row.currency)}
-                    </td>
-                    <td className="px-4 py-3 whitespace-nowrap">
-                      <Badge
-                        variant="status"
-                        status={isPaid ? "PAID" : row.paymentStatus}
-                      >
-                        {isPaid ? "PAID" : row.paymentStatus}
-                      </Badge>
-                    </td>
-                    <td className="px-4 py-3 text-sm whitespace-nowrap text-muted-foreground">
-                      {row.bookedAt ? formatDateTime(row.bookedAt) : "—"}
-                    </td>
-                    <td className="px-4 py-3 text-sm whitespace-nowrap">
-                      {isPaid ? (
-                        <span className="text-green-600 dark:text-green-400 text-xs font-medium">
-                          — Paid
-                        </span>
-                      ) : row.releaseAt ? (
-                        <span
-                          className={
-                            expired
-                              ? "text-red-600 dark:text-red-400 text-xs font-semibold"
-                              : "text-amber-600 dark:text-amber-400 text-xs font-medium"
-                          }
-                        >
-                          {expired ? "⚠ " : "⏱ "}
-                          {formatDateTime(row.releaseAt)}
-                          {expired && " (expired)"}
-                        </span>
-                      ) : (
-                        <span className="text-muted-foreground text-xs">—</span>
-                      )}
-                    </td>
-                    <td className="px-4 py-3 text-sm whitespace-nowrap text-muted-foreground">
-                      {row.scheduleOrigin} → {row.scheduleDestination}
-                      {row.scheduleDeparture && (
-                        <div className="text-xs">
-                          {formatDateTime(row.scheduleDeparture)}
-                        </div>
-                      )}
-                    </td>
-                  </tr>
-                );
-              })}
-            </tbody>
-          </table>
+      {!scheduleId && (
+        <div className="card py-16 text-center text-muted-foreground">
+          <Armchair className="h-10 w-10 mx-auto mb-3 opacity-30" />
+          <p>Select a schedule above to load the seat status report</p>
         </div>
-      </div>
+      )}
+
+      {data && (
+        <>
+          {/* Summary Cards */}
+          <div className="grid grid-cols-2 md:grid-cols-4 gap-4">
+            <div className="card">
+              <div className="flex items-start justify-between">
+                <div>
+                  <p className="text-muted-foreground text-sm font-medium">Paid Seats</p>
+                  <p className="text-2xl font-bold mt-2 text-green-600 dark:text-green-400">
+                    {data.summary.paidCount}
+                  </p>
+                  <p className="text-xs text-muted-foreground mt-1">Payment confirmed</p>
+                </div>
+                <CheckCircle className="h-8 w-8 text-green-500 opacity-30" />
+              </div>
+            </div>
+
+            <div className="card">
+              <div className="flex items-start justify-between">
+                <div>
+                  <p className="text-muted-foreground text-sm font-medium">Unpaid Seats</p>
+                  <p className="text-2xl font-bold mt-2 text-amber-600 dark:text-amber-400">
+                    {data.summary.unpaidCount}
+                  </p>
+                  <p className="text-xs text-muted-foreground mt-1">Awaiting payment</p>
+                </div>
+                <Clock className="h-8 w-8 text-amber-500 opacity-30" />
+              </div>
+            </div>
+
+            <div className="card">
+              <div className="flex items-start justify-between">
+                <div>
+                  <p className="text-muted-foreground text-sm font-medium">Expired Holds</p>
+                  <p className="text-2xl font-bold mt-2 text-red-600 dark:text-red-400">
+                    {data.summary.expiredHoldCount}
+                  </p>
+                  <p className="text-xs text-muted-foreground mt-1">Hold time passed</p>
+                </div>
+                <AlertCircle className="h-8 w-8 text-red-500 opacity-30" />
+              </div>
+            </div>
+
+            <div className="card">
+              <div className="flex items-start justify-between">
+                <div>
+                  <p className="text-muted-foreground text-sm font-medium">Blocked Seats</p>
+                  <p className="text-2xl font-bold mt-2 text-slate-600 dark:text-slate-400">
+                    {data.summary.blockedCount}
+                  </p>
+                  <p className="text-xs text-muted-foreground mt-1">Manually blocked</p>
+                </div>
+                <Ban className="h-8 w-8 text-slate-500 opacity-30" />
+              </div>
+            </div>
+          </div>
+
+          {/* Tabs */}
+          <div className="border-b border-border flex">
+            <button
+              onClick={() => setTab("seats")}
+              className={`px-5 py-2.5 text-sm font-medium border-b-2 transition-colors ${tab === "seats" ? "border-emerald-500 text-emerald-600 dark:text-emerald-400" : "border-transparent text-muted-foreground hover:text-foreground"}`}
+            >
+              Seat Details{allSeats.length > 0 ? ` (${allSeats.length})` : ""}
+            </button>
+            <button
+              onClick={() => setTab("blocked")}
+              className={`px-5 py-2.5 text-sm font-medium border-b-2 transition-colors ${tab === "blocked" ? "border-emerald-500 text-emerald-600 dark:text-emerald-400" : "border-transparent text-muted-foreground hover:text-foreground"}`}
+            >
+              Blocked Seats{data.blockedSeats.length > 0 ? ` (${data.blockedSeats.length})` : ""}
+            </button>
+          </div>
+
+          {/* Seat Details Tab */}
+          {tab === "seats" && <div className="card p-0">
+            <div className="flex items-center justify-between px-4 pt-4 pb-3 gap-4 flex-wrap">
+              <h3 className="text-sm font-semibold uppercase tracking-wider text-muted-foreground">
+                Seat Details
+              </h3>
+              <div className="flex items-center gap-3 flex-wrap">
+                <input
+                  type="text"
+                  className="input max-w-xs"
+                  placeholder="Booking ref, passenger, seat…"
+                  value={search}
+                  onChange={(e) => { setSearch(e.target.value); resetSeatsPage(); }}
+                />
+                <select
+                  className="input w-40"
+                  value={statusFilter}
+                  onChange={(e) => { setStatusFilter(e.target.value as "ALL" | "PAID" | "UNPAID"); resetSeatsPage(); }}
+                >
+                  <option value="ALL">All Seats</option>
+                  <option value="PAID">Paid Only</option>
+                  <option value="UNPAID">Unpaid Only</option>
+                </select>
+                <ActionButton icon={Download} variant="secondary" onClick={doExport} disabled={!filtered.length}>
+                  Export CSV
+                </ActionButton>
+              </div>
+            </div>
+            <div className="overflow-x-auto">
+              <table className="w-full text-sm">
+                <thead className="bg-gray-50 dark:bg-gray-800">
+                  <tr>
+                    {["Booking Ref", "Passenger", "Category", "Seat Class · Coach · Seat", "Fare", "Payment", "Booked At"].map((h) => (
+                      <th key={h} className="px-4 py-3 text-left text-xs font-medium uppercase tracking-wider text-gray-500 dark:text-gray-400 whitespace-nowrap">
+                        {h}
+                      </th>
+                    ))}
+                  </tr>
+                </thead>
+                <tbody className="bg-white dark:bg-gray-900 divide-y divide-gray-200 dark:divide-gray-700">
+                  {pagedSeats.map((row, i) => {
+                    const isPaid = row.bookingStatus === "CONFIRMED" || row.bookingStatus === "BOARDED";
+                    return (
+                      <tr key={i} className="hover:bg-gray-50 dark:hover:bg-gray-800 transition-colors">
+                        <td className="px-4 py-3 font-mono font-semibold whitespace-nowrap">{row.bookingRef}</td>
+                        <td className="px-4 py-3 whitespace-nowrap">{row.passengerName}</td>
+                        <td className="px-4 py-3 whitespace-nowrap text-xs text-muted-foreground">{row.passengerCategory}</td>
+                        <td className="px-4 py-3 whitespace-nowrap text-xs">
+                          <span className="font-medium">{row.seatClassName ?? "—"}</span>
+                          {row.coachNumber && <span className="text-muted-foreground"> · {row.coachNumber}</span>}
+                          {row.seatNumber && <span className="text-muted-foreground"> · #{row.seatNumber}</span>}
+                        </td>
+                        <td className="px-4 py-3 whitespace-nowrap tabular-nums">
+                          {formatCurrency(row.fareMinor, row.currency)}
+                        </td>
+                        <td className="px-4 py-3 whitespace-nowrap">
+                          <Badge variant="status" status={isPaid ? "PAID" : row.paymentStatus}>
+                            {isPaid ? "PAID" : row.paymentStatus}
+                          </Badge>
+                        </td>
+                        <td className="px-4 py-3 whitespace-nowrap text-xs text-muted-foreground">
+                          {row.bookedAt ? formatDateTime(row.bookedAt) : "—"}
+                        </td>
+                      </tr>
+                    );
+                  })}
+                  {pagedSeats.length === 0 && (
+                    <tr>
+                      <td colSpan={7} className="py-8 text-center text-sm text-muted-foreground">
+                        No seats found
+                      </td>
+                    </tr>
+                  )}
+                </tbody>
+              </table>
+            </div>
+            <Pagination currentPage={seatsPage} totalPages={seatsTotalPages} onPageChange={setSeatsPage} />
+          </div>}
+
+          {/* Blocked Seats Tab */}
+          {tab === "blocked" && (
+            <div className="card p-0">
+              <div className="px-4 pt-4 pb-3">
+                <h3 className="text-sm font-semibold uppercase tracking-wider text-muted-foreground">
+                  Blocked Seats
+                </h3>
+              </div>
+              <div className="overflow-x-auto">
+                <table className="w-full text-sm">
+                  <thead className="bg-gray-50 dark:bg-gray-800">
+                    <tr>
+                      {["Seat Class · Coach · Seat", "Reason", "Blocked By", "Blocked At", "Unblock At"].map((h) => (
+                        <th key={h} className="px-4 py-3 text-left text-xs font-medium uppercase tracking-wider text-gray-500 dark:text-gray-400 whitespace-nowrap">
+                          {h}
+                        </th>
+                      ))}
+                    </tr>
+                  </thead>
+                  <tbody className="bg-white dark:bg-gray-900 divide-y divide-gray-200 dark:divide-gray-700">
+                    {pagedBlocked.length === 0 && (
+                      <tr>
+                        <td colSpan={5} className="py-8 text-center text-sm text-muted-foreground">No blocked seats</td>
+                      </tr>
+                    )}
+                    {pagedBlocked.map((b) => (
+                      <tr key={b.id} className="hover:bg-gray-50 dark:hover:bg-gray-800 transition-colors">
+                        <td className="px-4 py-3 whitespace-nowrap text-xs">
+                          <span className="font-medium">{b.seatClassName ?? "—"}</span>
+                          {b.coachNumber && <span className="text-muted-foreground"> · {b.coachNumber}</span>}
+                          {b.seatNumber && <span className="text-muted-foreground"> · #{b.seatNumber}</span>}
+                        </td>
+                        <td className="px-4 py-3 text-xs text-muted-foreground max-w-xs truncate" title={b.reason}>
+                          {b.reason}
+                        </td>
+                        <td className="px-4 py-3 whitespace-nowrap text-xs">{b.blockedBy}</td>
+                        <td className="px-4 py-3 whitespace-nowrap text-xs text-muted-foreground">
+                          {formatDateTime(b.blockedAt)}
+                        </td>
+                        <td className="px-4 py-3 whitespace-nowrap text-xs text-muted-foreground">
+                          {b.unblockAt ? formatDateTime(b.unblockAt) : "—"}
+                        </td>
+                      </tr>
+                    ))}
+                  </tbody>
+                </table>
+              </div>
+              <Pagination currentPage={blockedPage} totalPages={blockedTotalPages} onPageChange={setBlockedPage} />
+            </div>
+          )}
+        </>
+      )}
+
+      {!data && !isLoading && scheduleId && (
+        <div className="card py-12 text-center text-muted-foreground">
+          No data found for this schedule.
+        </div>
+      )}
     </div>
   );
 }
diff --git a/apps/edr-passenger-web/backoffice/src/app/schedules/page.tsx b/apps/edr-passenger-web/backoffice/src/app/schedules/page.tsx
index 4ef9b97ed..b9b2765a7 100644
--- a/apps/edr-passenger-web/backoffice/src/app/schedules/page.tsx
+++ b/apps/edr-passenger-web/backoffice/src/app/schedules/page.tsx
@@ -9,6 +9,8 @@ import Modal from '@/components/ui/Modal';
 import ConfirmDialog from '@/components/ui/ConfirmDialog';
 import { apiClient } from '@/lib/api-client';
 import { routeCoachTemplatesApi } from '@/lib/api';
+import Pagination from '@/components/ui/Pagination';
+import { usePagination } from '@/lib/use-pagination';
 import { formatDateTime } from '@/lib/utils';
 
 interface Schedule {
@@ -368,6 +370,8 @@ export default function SchedulesPage() {
     );
   });
 
+  const { paged: pagedSchedules, page: schedulePage, totalPages: scheduleTotalPages, setPage: setSchedulePage } = usePagination(filteredSchedules as Schedule[], 20);
+
   const statusMap: Record<string, string> = {
     SCHEDULED: 'edr-badge-info',
     BOARDING: 'edr-badge-warning',
@@ -621,13 +625,16 @@ export default function SchedulesPage() {
               No schedules found. {filters.search && 'Try adjusting your search.'}
             </div>
           ) : (
-            <DataTable
-              columns={scheduleColumns}
-              data={filteredSchedules}
-              actions={scheduleActions}
-              loading={false}
-              emptyMessage="No schedules found."
-            />
+            <>
+              <DataTable
+                columns={scheduleColumns}
+                data={pagedSchedules}
+                actions={scheduleActions}
+                loading={false}
+                emptyMessage="No schedules found."
+              />
+              <Pagination currentPage={schedulePage} totalPages={scheduleTotalPages} onPageChange={setSchedulePage} />
+            </>
           )}
         </div>
       </div>
diff --git a/apps/edr-passenger-web/backoffice/src/app/stations/page.tsx b/apps/edr-passenger-web/backoffice/src/app/stations/page.tsx
index 063f4cab8..032a978a4 100644
--- a/apps/edr-passenger-web/backoffice/src/app/stations/page.tsx
+++ b/apps/edr-passenger-web/backoffice/src/app/stations/page.tsx
@@ -9,6 +9,8 @@ import ActionButton from '@/components/ui/ActionButton';
 import Modal from '@/components/ui/Modal';
 import ConfirmDialog from '@/components/ui/ConfirmDialog';
 import { stationsApi } from '@/lib/api';
+import Pagination from '@/components/ui/Pagination';
+import { usePagination } from '@/lib/use-pagination';
 
 export default function StationsPage() {
   const [filters, setFilters] = useState({ search: '', country: '', operational: '' });
@@ -90,6 +92,9 @@ export default function StationsPage() {
     }
   };
 
+  const stationItems = data?.items || [];
+  const { paged: pagedStations, page, totalPages, setPage } = usePagination(stationItems, 20);
+
   const handleDelete = (station: any) => {
     setDeleteConfirm({ isOpen: true, station, error: undefined });
   };
@@ -231,12 +236,13 @@ export default function StationsPage() {
 
       {/* Stations Table */}
       <DataTable
-        data={data?.items || []}
+        data={pagedStations}
         columns={columns}
         actions={actions}
         loading={isLoading}
         emptyMessage="No stations found"
       />
+      <Pagination currentPage={page} totalPages={totalPages} onPageChange={setPage} />
 
       {/* Delete Confirmation */}
       <ConfirmDialog
diff --git a/apps/edr-passenger-web/backoffice/src/app/tickets/page.tsx b/apps/edr-passenger-web/backoffice/src/app/tickets/page.tsx
index 1105e5b67..4b55b37be 100644
--- a/apps/edr-passenger-web/backoffice/src/app/tickets/page.tsx
+++ b/apps/edr-passenger-web/backoffice/src/app/tickets/page.tsx
@@ -11,11 +11,15 @@ import ConfirmDialog from '@/components/ui/ConfirmDialog';
 import Modal from '@/components/ui/Modal';
 import Image from 'next/image';
 import { ticketsApi, apiClient, stationsApi, excessBaggageApi } from '@/lib/api';
+import Pagination from '@/components/ui/Pagination';
 import { formatDateTime, formatCurrency, formatDateTimeShort } from '@/lib/utils';
 import { useAuthStore } from '@/lib/auth-store';
 
 export default function TicketsPage() {
   const [filters, setFilters] = useState({ search: '', status: '', originStationId: '', destinationStationId: '', departureDate: '', arrivalDate: '', dateFrom: '', dateTo: '', coachId: '' });
+  const [ticketPage, setTicketPage] = useState(1);
+  const resetTicketPage = () => setTicketPage(1);
+  const PAGE_SIZE = 50;
   const [deleteConfirmOpen, setDeleteConfirmOpen] = useState(false);
   const [ticketToDelete, setTicketToDelete] = useState<any>(null);
   const [deleteError, setDeleteError] = useState<string | null>(null);
@@ -65,7 +69,7 @@ export default function TicketsPage() {
   const queryClient = useQueryClient();
 
   const { data, isLoading, error } = useQuery({
-    queryKey: ['tickets', filters],
+    queryKey: ['tickets', filters, ticketPage],
     queryFn: () => ticketsApi.getAll({
       search: filters.search || undefined,
       status: filters.status || undefined,
@@ -76,11 +80,14 @@ export default function TicketsPage() {
       dateFrom: filters.dateFrom || undefined,
       dateTo: filters.dateTo || undefined,
       coachId: filters.coachId || undefined,
-      skip: 0,
-      take: 50,
+      skip: (ticketPage - 1) * PAGE_SIZE,
+      take: PAGE_SIZE,
     }),
   });
 
+  const ticketMeta = (data as any)?.meta;
+  const ticketTotalPages = ticketMeta ? ticketMeta.totalPages : Math.max(1, Math.ceil(((data as any)?.total ?? (data?.items?.length ?? 0)) / PAGE_SIZE));
+
   const { data: stationsData } = useQuery({
     queryKey: ['stations'],
     queryFn: () => stationsApi.getAll(),
@@ -562,7 +569,7 @@ export default function TicketsPage() {
               placeholder="Search by ticket number..."
               className="input"
               value={filters.search}
-              onChange={(e) => setFilters({ ...filters, search: e.target.value })}
+              onChange={(e) => { resetTicketPage(); setFilters({ ...filters, search: e.target.value }); }}
             />
           </div>
           <div>
@@ -570,7 +577,7 @@ export default function TicketsPage() {
             <select
               className="input"
               value={filters.originStationId}
-              onChange={(e) => setFilters({ ...filters, originStationId: e.target.value })}
+              onChange={(e) => { resetTicketPage(); setFilters({ ...filters, originStationId: e.target.value }); }}
             >
               <option value="">All Origins</option>
               {stations.map((station: any) => (
@@ -583,7 +590,7 @@ export default function TicketsPage() {
             <select
               className="input"
               value={filters.destinationStationId}
-              onChange={(e) => setFilters({ ...filters, destinationStationId: e.target.value })}
+              onChange={(e) => { resetTicketPage(); setFilters({ ...filters, destinationStationId: e.target.value }); }}
             >
               <option value="">All Destinations</option>
               {stations.map((station: any) => (
@@ -597,7 +604,7 @@ export default function TicketsPage() {
               type="date"
               className="input"
               value={filters.departureDate}
-              onChange={(e) => setFilters({ ...filters, departureDate: e.target.value })}
+              onChange={(e) => { resetTicketPage(); setFilters({ ...filters, departureDate: e.target.value }); }}
             />
           </div>
           <div>
@@ -605,7 +612,7 @@ export default function TicketsPage() {
             <select
               className="input"
               value={filters.coachId}
-              onChange={(e) => setFilters({ ...filters, coachId: e.target.value })}
+              onChange={(e) => { resetTicketPage(); setFilters({ ...filters, coachId: e.target.value }); }}
             >
               <option value="">All Coaches</option>
               {(Array.isArray(coachesData) ? coachesData : (coachesData as any)?.data || []).map((coach: any) => (
@@ -627,7 +634,7 @@ export default function TicketsPage() {
               <select
                 className="input"
                 value={filters.status}
-                onChange={(e) => setFilters({ ...filters, status: e.target.value })}
+                onChange={(e) => { resetTicketPage(); setFilters({ ...filters, status: e.target.value }); }}
               >
                 <option value="">All Status</option>
                 <option value="ACTIVE">Active</option>
@@ -638,12 +645,12 @@ export default function TicketsPage() {
             <div>
               <label className="label">Issued From</label>
               <input type="date" className="input" value={filters.dateFrom}
-                onChange={(e) => setFilters({ ...filters, dateFrom: e.target.value })} />
+                onChange={(e) => { resetTicketPage(); setFilters({ ...filters, dateFrom: e.target.value }); }} />
             </div>
             <div>
               <label className="label">Issued To</label>
               <input type="date" className="input" value={filters.dateTo}
-                onChange={(e) => setFilters({ ...filters, dateTo: e.target.value })} />
+                onChange={(e) => { resetTicketPage(); setFilters({ ...filters, dateTo: e.target.value }); }} />
             </div>
           </div>
         )}
@@ -657,6 +664,7 @@ export default function TicketsPage() {
         loading={isLoading}
         emptyMessage="No tickets found"
       />
+      <Pagination currentPage={ticketPage} totalPages={ticketTotalPages} onPageChange={setTicketPage} />
 
       {/* Board Confirmation Modal */}
       <Modal
diff --git a/apps/edr-passenger-web/backoffice/src/app/trains/page.tsx b/apps/edr-passenger-web/backoffice/src/app/trains/page.tsx
index 9dd17dfb8..527aebdc7 100644
--- a/apps/edr-passenger-web/backoffice/src/app/trains/page.tsx
+++ b/apps/edr-passenger-web/backoffice/src/app/trains/page.tsx
@@ -9,6 +9,8 @@ import Modal from '@/components/ui/Modal';
 import ConfirmDialog from '@/components/ui/ConfirmDialog';
 import Badge from '@/components/ui/Badge';
 import { fleetApi } from '@/lib/api';
+import Pagination from '@/components/ui/Pagination';
+import { usePagination } from '@/lib/use-pagination';
 import { Train as TrainType } from '@/types';
 import { formatDate } from '@/lib/utils';
 
@@ -119,6 +121,8 @@ export default function TrainsPage() {
     );
   });
 
+  const { paged: pagedTrains, page, totalPages, setPage } = usePagination(filteredTrains as TrainType[], 20);
+
   const trainColumns = [
     {
       key: 'number',
@@ -224,12 +228,13 @@ export default function TrainsPage() {
 
       {/* Trains Table */}
       <DataTable
-        data={filteredTrains}
+        data={pagedTrains}
         columns={trainColumns}
         actions={actions}
         loading={trainsLoading}
         emptyMessage={search ? "No trains match your search" : "No trains found"}
       />
+      <Pagination currentPage={page} totalPages={totalPages} onPageChange={setPage} />
 
       {/* Delete Confirmation */}
       <ConfirmDialog
diff --git a/apps/edr-passenger-web/backoffice/src/lib/use-pagination.ts b/apps/edr-passenger-web/backoffice/src/lib/use-pagination.ts
new file mode 100644
index 000000000..45beec180
--- /dev/null
+++ b/apps/edr-passenger-web/backoffice/src/lib/use-pagination.ts
@@ -0,0 +1,18 @@
+import { useState, useMemo } from 'react';
+
+export function usePagination<T>(items: T[], pageSize = 20) {
+  const [page, setPage] = useState(1);
+
+  const totalPages = Math.max(1, Math.ceil(items.length / pageSize));
+  const safePage = Math.min(page, totalPages);
+
+  const paged = useMemo(
+    () => items.slice((safePage - 1) * pageSize, safePage * pageSize),
+    [items, safePage, pageSize],
+  );
+
+  // Reset to page 1 whenever the source list changes length (e.g. after a filter)
+  const reset = () => setPage(1);
+
+  return { paged, page: safePage, totalPages, setPage, reset };
+}
diff --git a/apps/edr-passenger-web/portal/src/app/booking/confirmation/page.tsx b/apps/edr-passenger-web/portal/src/app/booking/confirmation/page.tsx
index 1039b1465..e9ed308d8 100644
--- a/apps/edr-passenger-web/portal/src/app/booking/confirmation/page.tsx
+++ b/apps/edr-passenger-web/portal/src/app/booking/confirmation/page.tsx
@@ -112,6 +112,15 @@ export default function ConfirmationPage() {
     // backgrounded tabs, so that can take a very long time.
     staleTime: 0,
     enabled: !!bookingId,
+    // Keep polling after CONFIRMED until tickets are issued — ticket generation runs
+    // async after the booking transaction commits (see finalizePaymentSuccess in
+    // payments.service.ts), so the first CONFIRMED fetch often returns an empty
+    // tickets array.
+    refetchInterval: (query) => {
+      const data = query.state.data;
+      if (!data || data.status !== "CONFIRMED") return false;
+      return (data.tickets?.length ?? 0) >= passengers.length ? false : FAST_POLL_INTERVAL_MS;
+    },
   });
 
   // Poll the payment intent while the booking is PENDING_PAYMENT — fast during the
@@ -153,7 +162,7 @@ export default function ConfirmationPage() {
   };
 
   const handleDownloadVoucher = async () => {
-    if (!pnr) {
+    if (!pnr || !bookingId) {
       alert("Booking data not available. Please try again.");
       return;
     }
@@ -164,23 +173,28 @@ export default function ConfirmationPage() {
 
     setIsGeneratingVoucher(true);
     try {
-      const { generatePassengerVoucherPDF } =
-        await import("@/lib/generate-voucher");
+      const { generatePassengerVoucherPDF } = await import("@/lib/generate-voucher");
+
+      // Always fetch fresh booking data so tickets are present even if the cached
+      // _booking raced ahead of ticket generation (tickets are written async after
+      // the booking is confirmed — see finalizePaymentSuccess in payments.service.ts).
+      const freshBooking: BookingWithTicket = await apiClient.get(`/bookings/${bookingId}`);
+      const bookingData = freshBooking ?? _booking;
 
       const activeSchedule = isRoundTrip ? outboundSchedule : selectedSchedule;
       // The server-confirmed settled amount/currency (what was actually charged) is
       // authoritative — prefer it over the ETB booking fare once available. Shown exactly
       // as returned by the API (no /100, no per-passenger split) on every passenger's
       // voucher — see fareIsMajorUnits below.
-      const settledAmountMinor = _booking?.payment?.amountMinor;
-      const settledCurrency = _booking?.payment?.currency;
+      const settledAmountMinor = bookingData?.payment?.amountMinor;
+      const settledCurrency = bookingData?.payment?.currency;
       const hasSettledAmount = settledAmountMinor != null && !!settledCurrency;
       // Derive display currency from nationality (same logic as review/payment pages)
       const nat = (searchCriteria?.nationality ?? '').toUpperCase();
       const passengerDisplayCurrency = nat === 'DJIBOUTIAN' ? 'DJF' : nat === 'ETHIOPIAN' ? 'ETB' : 'USD';
       const voucherCurrency = hasSettledAmount ? settledCurrency! : passengerDisplayCurrency;
-      const createdAt = _booking?.createdAt || new Date().toISOString();
-      const status = _booking?.status || "CONFIRMED";
+      const createdAt = bookingData?.createdAt || new Date().toISOString();
+      const status = bookingData?.status || "CONFIRMED";
 
       // Compute per-passenger fares (in ETB) using the same logic as the review/payment
       // pages. reviewedPassengerFares is the authoritative source; rebuild from package
@@ -206,7 +220,7 @@ export default function ConfirmationPage() {
           return isPkgChild ? pkgChildFare : pkgAdultFare;
         }
         const totalFare =
-          reviewedTotalMinor ?? paidAmountMinor ?? _booking?.totalMinor ?? 0;
+          reviewedTotalMinor ?? paidAmountMinor ?? bookingData?.totalMinor ?? 0;
         return Math.round(totalFare / passengers.length);
       };
 
@@ -254,11 +268,9 @@ export default function ConfirmationPage() {
       // synchronous user-activation window and risk iOS Safari silently blocking them.
       for (let i = 0; i < passengers.length; i++) {
         const p = passengers[i];
-        // Same match-by-name-then-position as the on-screen ticket list above — no
-        // fabricated placeholder if there's no backend ticket data (see generate-voucher.ts).
         const matchedTicket =
-          _booking?.tickets?.find((t) => t.passengerName === p.name) ??
-          _booking?.tickets?.[i] ??
+          bookingData?.tickets?.find((t) => t.passengerName === p.name) ??
+          bookingData?.tickets?.[i] ??
           null;
         const ticketNumber = matchedTicket?.barcodePayload || "Not yet issued";
 
diff --git a/apps/edr-passenger-web/portal/src/lib/generate-voucher.ts b/apps/edr-passenger-web/portal/src/lib/generate-voucher.ts
index 439c26c29..abbf6eedf 100644
--- a/apps/edr-passenger-web/portal/src/lib/generate-voucher.ts
+++ b/apps/edr-passenger-web/portal/src/lib/generate-voucher.ts
@@ -260,7 +260,7 @@ function drawJourneyLeg(doc: jsPDF, schedule: ScheduleInfo, legLabel: string | n
   doc.setTextColor(...INK); doc.setFontSize(16); doc.setFont('helvetica', 'bold');
   doc.text(schedule.origin.code, margin + padX, topY + 7);
   doc.setTextColor(...BODY); doc.setFontSize(8.5); doc.setFont('helvetica', 'normal');
-  doc.text(schedule.origin.city || schedule.origin.name, margin + padX, topY + 11.5);
+  doc.text(schedule.origin.name, margin + padX, topY + 11.5);
 
   const dep = new Date(schedule.departureAt);
   doc.setTextColor(...BRAND); doc.setFontSize(11.5); doc.setFont('helvetica', 'bold');
@@ -274,7 +274,7 @@ function drawJourneyLeg(doc: jsPDF, schedule: ScheduleInfo, legLabel: string | n
   doc.setTextColor(...INK); doc.setFontSize(16); doc.setFont('helvetica', 'bold');
   doc.text(schedule.destination.code, dx, topY + 7, { align: 'right' });
   doc.setTextColor(...BODY); doc.setFontSize(8.5); doc.setFont('helvetica', 'normal');
-  doc.text(schedule.destination.city || schedule.destination.name, dx, topY + 11.5, { align: 'right' });
+  doc.text(schedule.destination.name, dx, topY + 11.5, { align: 'right' });
 
   const arr = new Date(schedule.arrivalAt);
   doc.setTextColor(...BRAND); doc.setFontSize(11.5); doc.setFont('helvetica', 'bold');
diff --git a/booking-checker.html b/booking-checker.html
deleted file mode 100644
index 9d2b7ded4..000000000
--- a/booking-checker.html
+++ /dev/null
@@ -1,530 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-  <meta charset="UTF-8" />
-  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-  <title>EDR Booking Checker</title>
-  <style>
-    * { box-sizing: border-box; margin: 0; padding: 0; }
-
-    body {
-      font-family: system-ui, sans-serif;
-      background: #f1f5f9;
-      color: #1e293b;
-      min-height: 100vh;
-      padding: 2rem;
-    }
-
-    h1 {
-      font-size: 1.25rem;
-      font-weight: 700;
-      margin-bottom: 1.5rem;
-      color: #0f172a;
-    }
-
-    .card {
-      background: #fff;
-      border-radius: 0.75rem;
-      border: 1px solid #e2e8f0;
-      padding: 1.5rem;
-      margin-bottom: 1.5rem;
-    }
-
-    label {
-      display: block;
-      font-size: 0.8rem;
-      font-weight: 600;
-      color: #475569;
-      margin-bottom: 0.4rem;
-      text-transform: uppercase;
-      letter-spacing: 0.05em;
-    }
-
-    input[type="text"], textarea {
-      width: 100%;
-      border: 1px solid #cbd5e1;
-      border-radius: 0.5rem;
-      padding: 0.6rem 0.75rem;
-      font-size: 0.9rem;
-      outline: none;
-      transition: border-color 0.15s;
-    }
-
-    input[type="text"]:focus, textarea:focus {
-      border-color: #10b981;
-      box-shadow: 0 0 0 3px rgba(16,185,129,0.15);
-    }
-
-    textarea {
-      resize: vertical;
-      min-height: 140px;
-      font-family: monospace;
-      font-size: 0.85rem;
-    }
-
-    .hint { font-size: 0.75rem; color: #94a3b8; margin-top: 0.35rem; }
-
-    button {
-      background: #10b981;
-      color: #fff;
-      border: none;
-      border-radius: 0.5rem;
-      padding: 0.65rem 1.5rem;
-      font-size: 0.9rem;
-      font-weight: 600;
-      cursor: pointer;
-      transition: background 0.15s;
-    }
-    button:hover:not(:disabled) { background: #059669; }
-    button:disabled { background: #a7f3d0; cursor: not-allowed; }
-    .btn-secondary { background: #e2e8f0; color: #475569; }
-    .btn-secondary:hover:not(:disabled) { background: #cbd5e1; }
-
-    .btn-row { display: flex; gap: 0.75rem; align-items: center; margin-top: 1rem; flex-wrap: wrap; }
-
-    #status { font-size: 0.85rem; color: #64748b; }
-
-    .progress-bar-wrap {
-      width: 100%;
-      background: #e2e8f0;
-      border-radius: 9999px;
-      height: 6px;
-      margin-top: 0.75rem;
-      display: none;
-    }
-    .progress-bar {
-      height: 6px;
-      background: #10b981;
-      border-radius: 9999px;
-      transition: width 0.2s;
-      width: 0%;
-    }
-
-    .summary {
-      display: flex;
-      gap: 1.5rem;
-      flex-wrap: wrap;
-      margin-bottom: 1rem;
-      font-size: 0.85rem;
-      color: #475569;
-    }
-    .summary strong { color: #0f172a; }
-
-    .filter-row {
-      display: flex;
-      gap: 0.5rem;
-      margin-bottom: 1rem;
-      flex-wrap: wrap;
-    }
-    .filter-btn {
-      background: #f1f5f9;
-      color: #475569;
-      border: 1px solid #e2e8f0;
-      border-radius: 9999px;
-      padding: 0.3rem 0.9rem;
-      font-size: 0.78rem;
-      font-weight: 600;
-      cursor: pointer;
-    }
-    .filter-btn.active { background: #10b981; color: #fff; border-color: #10b981; }
-
-    .table-wrap { overflow-x: auto; }
-
-    table { width: 100%; border-collapse: collapse; font-size: 0.85rem; }
-
-    thead tr { background: #f8fafc; border-bottom: 2px solid #e2e8f0; }
-
-    th {
-      text-align: left;
-      padding: 0.6rem 0.75rem;
-      font-weight: 600;
-      color: #475569;
-      font-size: 0.75rem;
-      text-transform: uppercase;
-      letter-spacing: 0.04em;
-      white-space: nowrap;
-    }
-
-    td { padding: 0.6rem 0.75rem; border-bottom: 1px solid #f1f5f9; vertical-align: middle; }
-    tr:last-child td { border-bottom: none; }
-    tr:hover td { background: #f8fafc; }
-    tr.hidden-row { display: none; }
-
-    .badge {
-      display: inline-block;
-      padding: 0.2rem 0.55rem;
-      border-radius: 9999px;
-      font-size: 0.72rem;
-      font-weight: 600;
-    }
-    .badge-yes       { background: #fef3c7; color: #92400e; }
-    .badge-no        { background: #f1f5f9; color: #64748b; }
-    .badge-confirmed { background: #d1fae5; color: #065f46; }
-    .badge-cancelled { background: #fee2e2; color: #991b1b; }
-    .badge-pending   { background: #fef9c3; color: #854d0e; }
-    .badge-other     { background: #f1f5f9; color: #475569; }
-    .badge-dup       { background: #fee2e2; color: #991b1b; }
-
-    .error-row td { color: #ef4444; font-style: italic; }
-    .dup-row td   { background: #fff5f5; }
-    .dup-cell { background:#fee2e2;color:#991b1b;border-radius:6px;padding:0.4rem 0.6rem;display:inline-block;font-weight:600;font-size:0.82rem; }
-
-    #results-section { display: none; }
-
-    .export-btn { background: #6366f1; }
-    .export-btn:hover:not(:disabled) { background: #4f46e5; }
-  </style>
-</head>
-<body>
-
-<h1>EDR Booking Checker</h1>
-
-<div class="card">
-  <label for="base-url">API Base URL</label>
-  <input type="text" id="base-url" value="http://localhost:4000" />
-  <p class="hint">No trailing slash. e.g. https://api.edrsc.com</p>
-</div>
-
-<div class="card">
-  <label for="refs">Booking References</label>
-  <textarea id="refs" placeholder="ABCDEF&#10;GHIJKL&#10;MNOPQR&#10;One per line, comma-separated, or wrapped in {curly,braces}"></textarea>
-  <p class="hint">Supports any format: one per line, comma-separated, or <code>{REF1,REF2}</code> groups.</p>
-
-  <div class="btn-row">
-    <button id="run-btn" onclick="run()">Check Bookings</button>
-    <button class="btn-secondary" onclick="clearAll()">Clear</button>
-    <button class="btn-secondary export-btn" onclick="exportCSV()" id="export-btn" style="display:none;background:#6366f1;color:#fff;">Export CSV</button>
-    <span id="status"></span>
-  </div>
-  <div class="progress-bar-wrap" id="progress-wrap">
-    <div class="progress-bar" id="progress-bar"></div>
-  </div>
-</div>
-
-<div class="card" id="results-section">
-  <div class="summary" id="summary"></div>
-
-  <div class="filter-row">
-    <button class="filter-btn active" onclick="setFilter('all', this)">All</button>
-    <button class="filter-btn" onclick="setFilter('package', this)">Package Only</button>
-    <button class="filter-btn" onclick="setFilter('regular', this)">Regular Only</button>
-    <button class="filter-btn" onclick="setFilter('error', this)">Errors Only</button>
-    <button class="filter-btn" onclick="setFilter('dup', this)">Duplicate Seats</button>
-  </div>
-  <div style="margin-bottom:1rem;display:flex;align-items:center;gap:0.5rem;flex-wrap:wrap">
-    <label for="date-filter" style="margin:0;text-transform:none;font-size:0.82rem;letter-spacing:0">Date:</label>
-    <input type="text" id="date-filter" placeholder="e.g. 18 Jul 2026" style="width:160px" oninput="applyFilter(currentFilter)" />
-    <label for="route-filter" style="margin:0;text-transform:none;font-size:0.82rem;letter-spacing:0">Route:</label>
-    <input type="text" id="route-filter" placeholder="e.g. DIR or BISH" style="width:160px" oninput="applyFilter(currentFilter)" />
-    <label for="class-filter" style="margin:0;text-transform:none;font-size:0.82rem;letter-spacing:0">Seat Class:</label>
-    <input type="text" id="class-filter" placeholder="e.g. VIP" style="width:140px" oninput="applyFilter(currentFilter)" />
-    <span id="row-count" style="font-size:0.82rem;color:#64748b;margin-left:0.5rem"></span>
-  </div>
-
-  <div class="table-wrap">
-    <table>
-      <thead>
-        <tr>
-          <th>Journey</th>
-          <th>Duplicate Bookings</th>
-        </tr>
-      </thead>
-      <tbody id="tbody"></tbody>
-    </table>
-  </div>
-</div>
-
-<script>
-  let allRows = [];
-  let currentFilter = 'all';
-
-  function parseRefs(raw) {
-    // Remove curly braces, split on newlines/commas, deduplicate
-    const cleaned = raw.replace(/[{}]/g, ' ');
-    const refs = cleaned.split(/[\n,\s]+/).map(r => r.trim()).filter(Boolean);
-    return [...new Set(refs)];
-  }
-
-  function statusBadge(status) {
-    if (!status) return '<span class="badge badge-other">—</span>';
-    const s = status.toUpperCase();
-    const cls = s === 'CONFIRMED' ? 'confirmed'
-              : s === 'CANCELLED' ? 'cancelled'
-              : s.includes('PENDING') ? 'pending'
-              : 'other';
-    return `<span class="badge badge-${cls}">${status}</span>`;
-  }
-
-  async function run() {
-    const baseUrl = document.getElementById('base-url').value.trim().replace(/\/$/, '');
-    const refs = parseRefs(document.getElementById('refs').value);
-
-    if (!refs.length) { setStatus('Enter at least one booking reference.'); return; }
-
-    const btn = document.getElementById('run-btn');
-    btn.disabled = true;
-    document.getElementById('export-btn').style.display = 'none';
-    document.getElementById('results-section').style.display = 'none';
-    document.getElementById('progress-wrap').style.display = 'block';
-    setProgress(0);
-    setStatus(`Checking ${refs.length} booking(s)…`);
-
-    allRows = [];
-    let done = 0;
-
-    // Run in batches of 20 to avoid overwhelming the server
-    const BATCH = 20;
-    for (let i = 0; i < refs.length; i += BATCH) {
-      const batch = refs.slice(i, i + BATCH);
-      const batchResults = await Promise.all(
-        batch.map(async (ref) => {
-          try {
-            const proxyUrl = `http://localhost:8080/proxy?url=${encodeURIComponent(`${baseUrl}/bookings/${ref}`)}`;
-            const res = await fetch(proxyUrl);
-            if (!res.ok) throw new Error(`HTTP ${res.status}`);
-            const json = await res.json();
-            const d = json.data ?? json;
-            return {
-              ref,
-              status: d.status ?? 'UNKNOWN',
-              bookingType: d.bookingType ?? '—',
-              isPackage: d.isPackageBooking ?? !!d.packageId,
-              packageName: d.packageName ?? '—',
-              packageId: d.packageId ?? '—',
-              passengerNames: (d.passengers ?? []).map(p => p.fullName ?? '—').join(', '),
-              phone: d.contactPhone ?? '—',
-              coaches: (d.passengers ?? []).map(p => p.seat?.coach ?? '—').join(', '),
-              seatNumbers: (d.passengers ?? []).map(p => p.seat?.number ?? '—').join(', '),
-              seatClasses: (d.passengers ?? []).map(p => p.seat?.seatClass ?? '—').join(', '),
-              seatIds: (d.passengers ?? []).map(p => p.seat?.id).filter(Boolean),
-              seats: (d.passengers ?? []).map(p => {
-                const legScheduleMap = {
-                  1: d.schedule?.id,
-                  2: d.bookingType === 'ROUND_TRIP' ? d.returnSchedule?.id : d.leg2Schedule?.id,
-                  3: d.returnSchedule?.id,
-                  4: d.returnLeg2Schedule?.id,
-                };
-                const legScheduleObjMap = {
-                  1: d.schedule,
-                  2: d.bookingType === 'ROUND_TRIP' ? d.returnSchedule : d.leg2Schedule,
-                  3: d.returnSchedule,
-                  4: d.returnLeg2Schedule,
-                };
-                const sched = legScheduleObjMap[p.leg] ?? d.schedule;
-                const scheduleId = sched?.id ?? null;
-                const originSeq = sched?.origin?.sequence ?? sched?.originStation?.sequence ?? 0;
-                const destSeq   = sched?.destination?.sequence ?? sched?.destinationStation?.sequence ?? 999;
-                const depMap = {
-                  1: d.schedule?.departureAt,
-                  2: d.bookingType === 'ROUND_TRIP' ? d.returnSchedule?.departureAt : d.leg2Schedule?.departureAt,
-                  3: d.returnSchedule?.departureAt,
-                  4: d.returnLeg2Schedule?.departureAt,
-                };
-                const departureAt = depMap[p.leg] ?? d.schedule?.departureAt;
-                const depDate = departureAt ? new Date(departureAt).toLocaleDateString('en-GB', { day:'2-digit', month:'short', year:'numeric' }) : '—';
-                const legLabel = d.bookingType === 'ONE_WAY' ? 'Outbound'
-                  : d.bookingType === 'ROUND_TRIP'
-                    ? (p.leg === 1 ? 'Outbound' : 'Return')
-                  : d.bookingType === 'TRANSIT'
-                    ? (p.leg === 1 ? 'Outbound Leg 1' : 'Outbound Leg 2')
-                  : d.bookingType === 'ROUND_TRIP_TRANSIT'
-                    ? (p.leg === 1 ? 'Outbound Leg 1' : p.leg === 2 ? 'Outbound Leg 2' : p.leg === 3 ? 'Return Leg 1' : 'Return Leg 2')
-                  : `Leg ${p.leg}`;
-                return { scheduleId, originSeq, destSeq, depDate, legLabel, coach: p.seat?.coach ?? '—', number: p.seat?.number ?? '—', seatClass: p.seat?.seatClass ?? '—' };
-              }),
-              origin: d.schedule?.origin?.code ?? d.schedule?.origin?.name ?? '—',
-              destination: d.schedule?.destination?.code ?? d.schedule?.destination?.name ?? '—',
-              hasDupSeat: false,
-              dupSeatRefs: [],
-              error: null,
-            };
-          } catch (e) {
-            return { ref, status: 'ERROR', bookingType: '—', isPackage: false, packageName: '—', packageId: '—', passengerNames: '—', phone: '—', seatClasses: '—', seatIds: [], seats: [], origin: '—', destination: '—', hasDupSeat: false, dupSeatRefs: [], dupSeatIds: new Set(), error: e.message };
-          }
-        })
-      );
-      allRows.push(...batchResults);
-      done += batch.length;
-      setProgress(Math.round((done / refs.length) * 100));
-      setStatus(`Checked ${done} / ${refs.length}…`);
-    }
-
-    detectDuplicateSeats();
-    renderTable();
-    renderSummary();
-
-    document.getElementById('results-section').style.display = 'block';
-    document.getElementById('export-btn').style.display = 'inline-block';
-    document.getElementById('progress-wrap').style.display = 'none';
-    setStatus('');
-    btn.disabled = false;
-  }
-
-  function detectDuplicateSeats() {
-    // Group seats by scheduleId|coach|seatNumber
-    // Two bookings conflict if they share the same seat on the same schedule
-    // AND their origin→destination sequence ranges overlap
-    const seatMap = new Map(); // key: scheduleId|coach|seat -> [{ref, originSeq, destSeq}]
-    for (const row of allRows) {
-      if (row.error) continue;
-      for (const seat of row.seats) {
-        if (!seat.scheduleId || seat.coach === '—' || seat.number === '—') continue;
-        const key = `${seat.scheduleId}|${seat.coach}|${seat.number}`;
-        if (!seatMap.has(key)) seatMap.set(key, []);
-        seatMap.get(key).push({ ref: row.ref, originSeq: seat.originSeq, destSeq: seat.destSeq });
-      }
-    }
-
-    // Two segments [a1,a2] and [b1,b2] overlap if a1 < b2 && b1 < a2
-    function overlaps(a1, a2, b1, b2) { return a1 < b2 && b1 < a2; }
-
-    for (const row of allRows) {
-      if (row.error) continue;
-      const dupRefs = new Set();
-      const dupSeatKeys = new Set();
-      for (const seat of row.seats) {
-        if (!seat.scheduleId) continue;
-        const key = `${seat.scheduleId}|${seat.coach}|${seat.number}`;
-        const entries = seatMap.get(key) ?? [];
-        for (const other of entries) {
-          if (other.ref === row.ref) continue;
-          if (overlaps(seat.originSeq, seat.destSeq, other.originSeq, other.destSeq)) {
-            dupRefs.add(other.ref);
-            dupSeatKeys.add(`${seat.coach}|${seat.number}`);
-          }
-        }
-      }
-      row.hasDupSeat = dupRefs.size > 0;
-      row.dupSeatRefs = [...dupRefs];
-      row.dupSeatIds = dupSeatKeys;
-    }
-  }
-
-  function buildDupGroups() {
-    const groups = new Map();
-    for (const row of allRows) {
-      if (row.error || !row.hasDupSeat) continue;
-      const names = row.passengerNames.split(', ');
-      for (const seat of row.seats) {
-        if (!row.dupSeatIds.has(`${seat.coach}|${seat.number}`)) continue;
-        const key = `${seat.depDate}|${seat.legLabel}|${row.origin}→${row.destination}|${seat.seatClass}|${seat.coach}|${seat.number}`;
-        if (!groups.has(key)) groups.set(key, { entries: [], isPackage: false });
-        const name = (names[row.seats.indexOf(seat)] ?? '').trim() || '—';
-        groups.get(key).entries.push({ ref: row.ref, name, phone: row.phone, isPackage: row.isPackage });
-        if (row.isPackage) groups.get(key).isPackage = true;
-      }
-    }
-    return groups;
-  }
-
-  function renderTable() {
-    const tbody = document.getElementById('tbody');
-    tbody.innerHTML = '';
-    const groups = buildDupGroups();
-    if (!groups.size) return;
-
-    for (const [key, { entries, isPackage }] of groups) {
-      if (new Set(entries.map(e => e.ref)).size < 2) continue;
-      const [depDate, legLabel, route, seatClass, coach, seatNum] = key.split('|');
-      const tr = document.createElement('tr');
-      tr.dataset.dup = '1';
-      tr.dataset.type = isPackage ? 'package' : 'regular';
-      tr.dataset.date = depDate;
-      tr.dataset.route = route;
-      tr.dataset.seatclass = seatClass.toLowerCase();
-      tr.classList.add('dup-row');
-
-      const journeyCell = `<td style="white-space:nowrap">${depDate} · ${legLabel} · ${route} · ${seatClass} · ${coach}-${seatNum}</td>`;
-
-      const bookingsCell = `<td>${entries.map(e =>
-        `<div style="margin-bottom:0.5rem">
-          <span class="dup-cell">${e.ref}</span>
-          <span style="margin-left:0.4rem">${e.name}</span>
-          <span style="font-size:0.78rem;color:#64748b;margin-left:0.4rem">${e.phone}</span>
-        </div>`
-      ).join('')}</td>`;
-
-      tr.innerHTML = journeyCell + bookingsCell;
-      tbody.appendChild(tr);
-    }
-    applyFilter(currentFilter);
-  }
-
-  function renderSummary() {
-    const total    = allRows.length;
-    const pkgCount = allRows.filter(r => r.isPackage).length;
-    const errCount = allRows.filter(r => r.error).length;
-    const dupCount = allRows.filter(r => r.hasDupSeat).length;
-    const regCount = total - pkgCount - errCount;
-    document.getElementById('summary').innerHTML = `
-      <span>Total: <strong>${total}</strong></span>
-      <span>Package: <strong>${pkgCount}</strong></span>
-      <span>Regular: <strong>${regCount}</strong></span>
-      ${errCount ? `<span style="color:#ef4444">Errors: <strong>${errCount}</strong></span>` : ''}
-      ${dupCount ? `<span style="color:#dc2626">⚠ Duplicate Seats: <strong>${dupCount}</strong></span>` : ''}
-    `;
-  }
-
-  function setFilter(type, btn) {
-    currentFilter = type;
-    document.querySelectorAll('.filter-btn').forEach(b => b.classList.remove('active'));
-    btn.classList.add('active');
-    applyFilter(type);
-  }
-
-  function applyFilter(type) {
-    const dateQ = (document.getElementById('date-filter')?.value ?? '').trim().toLowerCase();
-    const routeQ = (document.getElementById('route-filter')?.value ?? '').trim().toLowerCase();
-    const classQ = (document.getElementById('class-filter')?.value ?? '').trim().toLowerCase();
-    let visible = 0;
-    document.querySelectorAll('#tbody tr').forEach(tr => {
-      const t = tr.dataset.type;
-      const typeMatch = type === 'all'
-        || (type === 'package' && t === 'package')
-        || (type === 'regular' && t === 'regular')
-        || (type === 'error'   && t === 'error')
-        || (type === 'dup'     && tr.dataset.dup === '1');
-      const dateMatch = !dateQ || (tr.dataset.date ?? '').toLowerCase().includes(dateQ);
-      const routeMatch = !routeQ || (tr.dataset.route ?? '').toLowerCase().includes(routeQ);
-      const classMatch = !classQ || (tr.dataset.seatclass ?? '').includes(classQ);
-      const show = typeMatch && dateMatch && routeMatch && classMatch;
-      tr.classList.toggle('hidden-row', !show);
-      if (show) visible++;
-    });
-    document.getElementById('row-count').textContent = `Showing ${visible} row${visible !== 1 ? 's' : ''}`;
-  }
-
-  function exportCSV() {
-    const header = 'Booking Ref,Status,Booking Type,Is Package,Package Name,Package ID,Passenger(s),Phone,Coach-Seat,Seat Class,Duplicate Seat In';
-    const lines = allRows.map(r =>
-      [r.ref, r.status, r.bookingType, r.isPackage, r.packageName, r.packageId, r.seats.map((s, idx) => `${(r.passengerNames.split(', ')[idx] ?? '').trim()} · ${s.legLabel} · ${s.seatClass} · ${r.origin}→${r.destination} · ${s.coach}-${s.number}`).join('; '), r.phone, r.seatClasses, r.dupSeatRefs.join('; ') || '']
-        .map(v => `"${String(v).replace(/"/g, '""')}"`)
-        .join(',')
-    );
-    const csv = [header, ...lines].join('\n');
-    const blob = new Blob([csv], { type: 'text/csv' });
-    const a = document.createElement('a');
-    a.href = URL.createObjectURL(blob);
-    a.download = 'booking-check-' + new Date().toISOString().slice(0,10) + '.csv';
-    a.click();
-  }
-
-  function clearAll() {
-    document.getElementById('date-filter').value = '';
-    document.getElementById('route-filter').value = '';
-    document.getElementById('class-filter').value = '';
-    document.getElementById('refs').value = '';
-    document.getElementById('tbody').innerHTML = '';
-    document.getElementById('results-section').style.display = 'none';
-    document.getElementById('export-btn').style.display = 'none';
-    document.getElementById('progress-wrap').style.display = 'none';
-    allRows = [];
-    setStatus('');
-  }
-
-  function setStatus(msg) { document.getElementById('status').textContent = msg; }
-  function setProgress(pct) { document.getElementById('progress-bar').style.width = pct + '%'; }
-</script>
-
-</body>
-</html>
diff --git a/booking-extractor.html b/booking-extractor.html
deleted file mode 100644
index 844c98b2c..000000000
--- a/booking-extractor.html
+++ /dev/null
@@ -1,256 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-  <meta charset="UTF-8" />
-  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-  <title>EDR Booking Extractor</title>
-  <style>
-    * { box-sizing: border-box; margin: 0; padding: 0; }
-    body { font-family: system-ui, sans-serif; background: #f1f5f9; color: #1e293b; min-height: 100vh; padding: 2rem; }
-    h1 { font-size: 1.25rem; font-weight: 700; margin-bottom: 1.5rem; color: #0f172a; }
-    .card { background: #fff; border-radius: 0.75rem; border: 1px solid #e2e8f0; padding: 1.5rem; margin-bottom: 1.5rem; }
-    label { display: block; font-size: 0.8rem; font-weight: 600; color: #475569; margin-bottom: 0.4rem; text-transform: uppercase; letter-spacing: 0.05em; }
-    .hint { font-size: 0.75rem; color: #94a3b8; margin-top: 0.35rem; }
-    .drop-zone {
-      border: 2px dashed #cbd5e1; border-radius: 0.5rem; padding: 2rem;
-      text-align: center; cursor: pointer; color: #94a3b8; font-size: 0.9rem;
-      transition: border-color 0.15s, background 0.15s;
-    }
-    .drop-zone.over { border-color: #10b981; background: #f0fdf4; color: #065f46; }
-    .drop-zone input[type="file"] { display: none; }
-    button {
-      background: #10b981; color: #fff; border: none; border-radius: 0.5rem;
-      padding: 0.65rem 1.5rem; font-size: 0.9rem; font-weight: 600; cursor: pointer; transition: background 0.15s;
-    }
-    button:hover:not(:disabled) { background: #059669; }
-    button:disabled { background: #a7f3d0; cursor: not-allowed; }
-    .btn-secondary { background: #e2e8f0; color: #475569; }
-    .btn-secondary:hover:not(:disabled) { background: #cbd5e1; }
-    .export-btn { background: #6366f1; color: #fff; }
-    .export-btn:hover:not(:disabled) { background: #4f46e5; }
-    .btn-row { display: flex; gap: 0.75rem; align-items: center; margin-top: 1rem; flex-wrap: wrap; }
-    #status { font-size: 0.85rem; color: #64748b; }
-    .summary { display: flex; gap: 1.5rem; flex-wrap: wrap; margin-bottom: 1rem; font-size: 0.85rem; color: #475569; }
-    .summary strong { color: #0f172a; }
-    .table-wrap { overflow-x: auto; }
-    table { width: 100%; border-collapse: collapse; font-size: 0.82rem; }
-    thead tr { background: #f8fafc; border-bottom: 2px solid #e2e8f0; }
-    th { text-align: left; padding: 0.5rem 0.75rem; font-weight: 600; color: #475569; font-size: 0.72rem; text-transform: uppercase; letter-spacing: 0.04em; white-space: nowrap; }
-    td { padding: 0.5rem 0.75rem; border-bottom: 1px solid #f1f5f9; vertical-align: middle; }
-    tr:last-child td { border-bottom: none; }
-    tr:hover td { background: #f8fafc; }
-    #results-section { display: none; }
-  </style>
-</head>
-<body>
-
-<h1>EDR Booking Extractor</h1>
-
-<div class="card">
-  <label>Bookings JSON File</label>
-  <div class="drop-zone" id="drop-zone" onclick="document.getElementById('file-input').click()">
-    <input type="file" id="file-input" accept=".json" onchange="handleFile(this.files[0])" />
-    Drop <code>bookings.json</code> here or click to browse
-  </div>
-  <p class="hint">Accepts a JSON array of bookings or an object with a <code>bookings</code> key.</p>
-  <div class="btn-row">
-    <button class="btn-secondary" onclick="clearAll()">Clear</button>
-    <button class="export-btn" id="export-btn" onclick="exportCSV()" style="display:none">Export CSV</button>
-    <span id="status"></span>
-  </div>
-</div>
-
-<div class="card" id="results-section">
-  <div class="summary" id="summary"></div>
-  <div style="margin-bottom:1rem;display:flex;align-items:center;gap:0.5rem;flex-wrap:wrap">
-    <label for="date-filter" style="margin:0;text-transform:none;font-size:0.82rem;letter-spacing:0">Departure Date:</label>
-    <input type="text" id="date-filter" placeholder="e.g. 18 Jul 2026" style="width:160px;border:1px solid #cbd5e1;border-radius:0.5rem;padding:0.4rem 0.6rem;font-size:0.85rem;outline:none" oninput="applyFilter()" />
-    <span id="row-count" style="font-size:0.82rem;color:#64748b"></span>
-  </div>
-  <div class="table-wrap">
-    <table>
-      <thead>
-        <tr>
-          <th>#</th>
-          <th>Booking Ref</th>
-          <th>Status</th>
-          <th>Booking Type</th>
-          <th>Phone</th>
-          <th>Email</th>
-          <th>Departure</th>
-          <th>Origin</th>
-          <th>Destination</th>
-          <th>Passenger(s)</th>
-          <th>Coach - Seat</th>
-          <th>Payment Method</th>
-          <th>Payment Status</th>
-          <th>Total (DJF)</th>
-          <th>Created At</th>
-        </tr>
-      </thead>
-      <tbody id="tbody"></tbody>
-    </table>
-  </div>
-</div>
-
-<script>
-  let extracted = [];
-
-  function fmt(v) { return v ?? ''; }
-
-  function extractRow(b) {
-    const seats = (b.seats ?? b.passengers ?? []);
-    const passengerNames = seats.map(s => s.passengerName ?? s.name ?? '').filter(Boolean).join(', ');
-    const coachSeats = seats.map(s => {
-      const num = s.seat?.seatNumber ?? '';
-      const coach = typeof s.seat?.coach === 'string' ? s.seat.coach : (s.seat?.coach?.number ?? '');
-      return coach && num ? `${coach}-${num}` : (num || coach || '');
-    }).filter(Boolean).join(', ');
-
-    const dep = b.schedule?.departureAt
-      ? new Date(b.schedule.departureAt).toLocaleString('en-GB', { day: '2-digit', month: 'short', year: 'numeric', hour: '2-digit', minute: '2-digit' })
-      : '';
-    const createdAt = b.createdAt
-      ? new Date(b.createdAt).toLocaleString('en-GB', { day: '2-digit', month: 'short', year: 'numeric', hour: '2-digit', minute: '2-digit' })
-      : '';
-
-    return {
-      booking_ref:      fmt(b.bookingRef),
-      status:           fmt(b.status),
-      booking_type:     fmt(b.bookingType),
-      phone:            fmt(b.contactPhone),
-      email:            fmt(b.contactEmail),
-      departure:        dep,
-      origin:           fmt(b.schedule?.originStation?.code),
-      destination:      fmt(b.schedule?.destinationStation?.code),
-      passenger_names:  passengerNames,
-      coach_seat:       coachSeats,
-      payment_method:   fmt(b.paymentIntent?.method),
-      payment_status:   fmt(b.paymentIntent?.status),
-      total:            b.displayTotalMinor != null ? (b.displayTotalMinor / 100).toFixed(2) : '',
-      created_at:       createdAt,
-    };
-  }
-
-  function extractObjects(text) {
-    const results = [];
-    let depth = 0, start = -1, inString = false, escape = false;
-    for (let i = 0; i < text.length; i++) {
-      const ch = text[i];
-      if (escape) { escape = false; continue; }
-      if (ch === '\\' && inString) { escape = true; continue; }
-      if (ch === '"') { inString = !inString; continue; }
-      if (inString) continue;
-      if (ch === '{') { if (depth === 0) start = i; depth++; }
-      else if (ch === '}') {
-        depth--;
-        if (depth === 0 && start !== -1) {
-          try { results.push(JSON.parse(text.slice(start, i + 1))); } catch (_) {}
-          start = -1;
-        }
-      }
-    }
-    return results;
-  }
-
-  window.handleFile = function(file) {
-    if (!file) return;
-    setStatus(`Reading ${file.name}…`);
-    const reader = new FileReader();
-    reader.onload = e => {
-      try {
-        const text = e.target.result.replace(/^\uFEFF/, '');
-        let bookings = [], parseWarning = '';
-        try {
-          const data = JSON.parse(text);
-          bookings = Array.isArray(data) ? data : (data.bookings ?? []);
-        } catch (_) {
-          bookings = extractObjects(text);
-          parseWarning = `⚠ File was truncated — recovered ${bookings.length} complete record(s).`;
-        }
-        if (!bookings.length) throw new Error('No booking records found in the JSON.');
-        extracted = bookings.map(extractRow);
-        renderTable();
-        document.getElementById('results-section').style.display = 'block';
-        document.getElementById('export-btn').style.display = 'inline-block';
-        document.getElementById('summary').innerHTML = `Loaded <strong>${extracted.length}</strong> booking(s) from <strong>${file.name}</strong>`;
-        setStatus(parseWarning);
-      } catch (err) {
-        setStatus(`Error: ${err.message}`);
-      }
-    };
-    reader.readAsText(file);
-  };
-
-  const HEADERS = ['booking_ref','status','booking_type','phone','email','departure','origin','destination','passenger_names','coach_seat','payment_method','payment_status','total','created_at'];
-
-  function renderTable() {
-    const tbody = document.getElementById('tbody');
-    tbody.innerHTML = '';
-    extracted.forEach((row, i) => {
-      const tr = document.createElement('tr');
-      tr.dataset.departure = row.departure.toLowerCase();
-      tr.innerHTML = `
-        <td>${i + 1}</td>
-        <td><code>${row.booking_ref || '—'}</code></td>
-        <td>${row.status || '—'}</td>
-        <td>${row.booking_type || '—'}</td>
-        <td>${row.phone || '—'}</td>
-        <td>${row.email || '—'}</td>
-        <td>${row.departure || '—'}</td>
-        <td>${row.origin || '—'}</td>
-        <td>${row.destination || '—'}</td>
-        <td>${row.passenger_names || '—'}</td>
-        <td>${row.coach_seat || '—'}</td>
-        <td>${row.payment_method || '—'}</td>
-        <td>${row.payment_status || '—'}</td>
-        <td>${row.total || '—'}</td>
-        <td>${row.created_at || '—'}</td>`;
-      tbody.appendChild(tr);
-    });
-    applyFilter();
-  }
-
-  function applyFilter() {
-    const q = (document.getElementById('date-filter')?.value ?? '').trim().toLowerCase();
-    let visible = 0;
-    document.querySelectorAll('#tbody tr').forEach(tr => {
-      const show = !q || (tr.dataset.departure ?? '').includes(q);
-      tr.style.display = show ? '' : 'none';
-      if (show) visible++;
-    });
-    document.getElementById('row-count').textContent = `Showing ${visible} row${visible !== 1 ? 's' : ''}`;
-  }
-
-  window.exportCSV = function() {
-    const header = HEADERS.join(',');
-    const lines = extracted.map(row =>
-      HEADERS.map(k => `"${String(row[k] ?? '').replace(/"/g, '""')}"`).join(',')
-    );
-    const a = document.createElement('a');
-    a.href = URL.createObjectURL(new Blob([[header, ...lines].join('\n')], { type: 'text/csv' }));
-    a.download = 'bookings_extracted.csv';
-    a.click();
-  };
-
-  window.clearAll = function() {
-    extracted = [];
-    document.getElementById('tbody').innerHTML = '';
-    document.getElementById('results-section').style.display = 'none';
-    document.getElementById('export-btn').style.display = 'none';
-    document.getElementById('file-input').value = '';
-    document.getElementById('date-filter').value = '';
-    document.getElementById('row-count').textContent = '';
-    setStatus('');
-  };
-
-  function setStatus(msg) { document.getElementById('status').textContent = msg; }
-
-  const dz = document.getElementById('drop-zone');
-  dz.addEventListener('dragover', e => { e.preventDefault(); dz.classList.add('over'); });
-  dz.addEventListener('dragleave', () => dz.classList.remove('over'));
-  dz.addEventListener('drop', e => { e.preventDefault(); dz.classList.remove('over'); handleFile(e.dataTransfer.files[0]); });
-</script>
-
-</body>
-</html>
diff --git a/booking-proxy.mjs b/booking-proxy.mjs
deleted file mode 100644
index 27f9248ee..000000000
--- a/booking-proxy.mjs
+++ /dev/null
@@ -1,53 +0,0 @@
-import http from 'http';
-import https from 'https';
-import fs from 'fs';
-import path from 'path';
-import { fileURLToPath } from 'url';
-
-const PORT = 8080;
-const __dir = path.dirname(fileURLToPath(import.meta.url));
-
-const server = http.createServer((req, res) => {
-  res.setHeader('Access-Control-Allow-Origin', '*');
-  res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization');
-
-  if (req.method === 'OPTIONS') { res.writeHead(204); res.end(); return; }
-
-  // Serve any .html file in the same directory
-  if (req.url === '/' || req.url.endsWith('.html')) {
-    const filename = req.url === '/' ? 'booking-checker.html' : req.url.slice(1);
-    const filepath = path.join(__dir, filename);
-    if (fs.existsSync(filepath)) {
-      res.writeHead(200, { 'Content-Type': 'text/html' });
-      fs.createReadStream(filepath).pipe(res);
-    } else {
-      res.writeHead(404); res.end('Not found');
-    }
-    return;
-  }
-
-  // Proxy /proxy?url=<encoded-api-url>
-  if (req.url.startsWith('/proxy?url=')) {
-    const target = decodeURIComponent(req.url.slice('/proxy?url='.length));
-    const parsed = new URL(target);
-    const mod = parsed.protocol === 'https:' ? https : http;
-    const options = {
-      hostname: parsed.hostname,
-      port: parsed.port || (parsed.protocol === 'https:' ? 443 : 80),
-      path: parsed.pathname + parsed.search,
-      method: req.method,
-      headers: { ...req.headers, host: parsed.hostname },
-    };
-    const proxy = mod.request(options, (apiRes) => {
-      res.writeHead(apiRes.statusCode, apiRes.headers);
-      apiRes.pipe(res);
-    });
-    proxy.on('error', (e) => { res.writeHead(502); res.end(e.message); });
-    req.pipe(proxy);
-    return;
-  }
-
-  res.writeHead(404); res.end();
-});
-
-server.listen(PORT, () => console.log(`Booking checker: http://localhost:${PORT}/booking-checker.html`));
diff --git a/docker-compose.e2e.yaml b/docker-compose.e2e.yaml
new file mode 100644
index 000000000..b00402761
--- /dev/null
+++ b/docker-compose.e2e.yaml
@@ -0,0 +1,194 @@
+# EDR Freight — ephemeral Cypress e2e stack.
+# Fully isolated from dev: own ports, own throwaway Postgres (tmpfs — data
+# vanishes on `down`), seeded test users. Requires the same .npmrc as the main
+# docker-compose.yaml (GitHub Packages auth for @tria-plc).
+#
+# Preferred entrypoint: the launcher (auto-up + free-port picking):
+#   pnpm e2e:freight:run|open|ci|up|down   → e2e/freight/scripts/e2e.mjs
+#
+# Host ports are env-parameterized (E2E_*_PORT). Defaults below avoid the dev
+# stacks (5273/5283/3221 are taken by the second dev checkout in
+# ~/projects/nathnael/edr-platform); when a default is busy the launcher scans
+# upward for a free port and remembers the choice in e2e/freight/.e2e-ports.json
+# while the stack is up:
+#   freight-api   3101   portal 5373   backoffice 5383
+#   postgres      5533   minio  9310 (console 9311)
+name: edr-freight-e2e
+
+services:
+  postgres-freight-e2e:
+    image: postgres:16-alpine
+    environment:
+      POSTGRES_DB: edr_freight_e2e
+      POSTGRES_USER: edr_e2e
+      POSTGRES_PASSWORD: edr_e2e
+    tmpfs:
+      - /var/lib/postgresql/data
+    ports:
+      - "${E2E_DB_PORT:-5533}:5432"
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U edr_e2e -d edr_freight_e2e"]
+      interval: 2s
+      timeout: 3s
+      retries: 30
+
+  minio-e2e:
+    image: minio/minio:latest
+    command: server /data --console-address ":9001"
+    environment:
+      MINIO_ROOT_USER: e2e-minio
+      MINIO_ROOT_PASSWORD: e2e-minio-secret
+    tmpfs:
+      - /data
+    ports:
+      - "${E2E_MINIO_PORT:-9310}:9000"
+      - "${E2E_MINIO_CONSOLE_PORT:-9311}:9001"
+    healthcheck:
+      test: ["CMD", "mc", "ready", "local"]
+      interval: 5s
+      timeout: 5s
+      retries: 12
+
+  # tmpfs wipes MinIO on every restart — recreate the app bucket each boot.
+  minio-init-e2e:
+    image: minio/mc:latest
+    depends_on:
+      minio-e2e:
+        condition: service_healthy
+    entrypoint:
+      - /bin/sh
+      - -c
+      - mc alias set e2e http://minio-e2e:9000 e2e-minio e2e-minio-secret && mc mb --ignore-existing e2e/fhc
+    restart: "no"
+
+  freight-api-e2e:
+    build:
+      context: .
+      dockerfile: apps/edr-freight-api/Dockerfile
+      secrets:
+        - npmrc
+    depends_on:
+      postgres-freight-e2e:
+        condition: service_healthy
+      minio-e2e:
+        condition: service_healthy
+      minio-init-e2e:
+        condition: service_completed_successfully
+    environment:
+      PORT: "3001"
+      DB_HOST: postgres-freight-e2e
+      DB_PORT: "5432"
+      DB_USER: edr_e2e
+      DB_PASSWORD: edr_e2e
+      DB_NAME: edr_freight_e2e
+      # e2e-only secrets — never reuse outside this stack
+      JWT_SECRET: e2e-jwt-secret
+      JWT_ACCESS_TOKEN_SECRET: e2e-access-secret
+      JWT_REFRESH_TOKEN_SECRET: e2e-refresh-secret
+      JWT_EXPIRES_IN: 1d
+      JWT_ACCESS_TOKEN_EXPIRES: 1d
+      JWT_REFRESH_TOKEN_EXPIRES: 7d
+      SERVICE_AUTH_TOKEN: e2e-service-token
+      # Org/unit/position boot seeders (env-gated in app code). Test USERS are
+      # NOT seeded by the API — Cypress inserts them via
+      # e2e/freight/cypress/fixtures/seed-users.sql before specs run.
+      SEED_EDR_ORG: "true"
+      SUPER_ADMIN_EMAIL: superadmin@tria.com
+      SUPER_ADMIN_PHONE: "+251900000000"
+      # Object storage
+      MINIO_ENDPOINT: minio-e2e
+      MINIO_PORT: "9000"
+      MINIO_USE_SSL: "false"
+      MINIO_ACCESS_KEY: e2e-minio
+      MINIO_SECRET_KEY: e2e-minio-secret
+      MINIO_REGION: us-east-1
+      # External integrations off
+      RABBITMQ_ENABLED: "false"
+      FAYDA_ENABLED: "false"
+      # SMS strategy has no kill switch and defaults to a real dev endpoint —
+      # blackhole it so e2e never sends SMS (failures are logged, non-fatal).
+      OZIKING_SMS_URL: http://127.0.0.1:9/sms
+      FREIGHT_PORTAL_URL: http://localhost:${E2E_PORTAL_PORT:-5373}
+    ports:
+      - "${E2E_API_PORT:-3101}:3001"
+    healthcheck:
+      # Boot runs 240+ migrations + seeders on first start — generous start_period.
+      test:
+        [
+          "CMD",
+          "node",
+          "-e",
+          "fetch('http://localhost:3001/api/health').then(r=>process.exit(r.ok?0:1)).catch(()=>process.exit(1))",
+        ]
+      interval: 5s
+      timeout: 5s
+      retries: 12
+      start_period: 180s
+
+  freight-portal-e2e:
+    build:
+      context: .
+      dockerfile: infrastructure/docker/Dockerfile.web
+      args:
+        TURBO_FILTER: "@edr/freight-portal"
+        APP_PATH: apps/edr-freight-web/portal
+        # Baked at build time: browser (host or host-networked cypress
+        # container) reaches the API through the published host port. A
+        # non-default API port therefore forces a web image rebuild.
+        VITE_API_URL: http://localhost:${E2E_API_PORT:-3101}
+        VITE_BASE_API_URL: http://localhost:${E2E_API_PORT:-3101}
+        VITE_USER_MANAGEMENT_BASE: /_um
+        VITE_GOOGLE_MAPS_API_KEY: ""
+        VITE_POSTHOG_KEY: ""
+        VITE_POSTHOG_HOST: ""
+      secrets:
+        - npmrc
+    ports:
+      - "${E2E_PORTAL_PORT:-5373}:80"
+
+  freight-backoffice-e2e:
+    build:
+      context: .
+      dockerfile: infrastructure/docker/Dockerfile.web
+      args:
+        TURBO_FILTER: "@edr/freight-backoffice"
+        APP_PATH: apps/edr-freight-web/backoffice
+        VITE_API_URL: http://localhost:${E2E_API_PORT:-3101}
+        VITE_BASE_API_URL: http://localhost:${E2E_API_PORT:-3101}
+        VITE_USER_MANAGEMENT_BASE: /_um
+        VITE_GOOGLE_MAPS_API_KEY: ""
+        VITE_POSTHOG_KEY: ""
+        VITE_POSTHOG_HOST: ""
+      secrets:
+        - npmrc
+    ports:
+      - "${E2E_BACKOFFICE_PORT:-5383}:80"
+
+  # Headless runner — opt-in via `--profile cypress`. host network so the
+  # in-container browser uses the exact same localhost URLs as `cypress open`
+  # on the host (Linux only; on macOS/Windows run Cypress from the host).
+  cypress:
+    # Keep in sync with the cypress version in e2e/freight/package.json.
+    image: cypress/included:${CYPRESS_VERSION:-15.18.1}
+    profiles: ["cypress"]
+    network_mode: host
+    depends_on:
+      freight-api-e2e:
+        condition: service_healthy
+    working_dir: /repo/e2e/freight
+    # NOTE: host network shares the abstract X-socket namespace with the host.
+    # Cypress spawns its Xvfb on :99 — run only ONE cypress container at a
+    # time, and don't run it on a host whose X server occupies :99.
+    entrypoint: ["cypress", "run", "--browser", "chrome"]
+    environment:
+      CI: "true"
+      E2E_DB_URL: postgres://edr_e2e:edr_e2e@localhost:${E2E_DB_PORT:-5533}/edr_freight_e2e
+      CYPRESS_BASE_URL: http://localhost:${E2E_BACKOFFICE_PORT:-5383}
+      CYPRESS_API_URL: http://localhost:${E2E_API_PORT:-3101}
+      CYPRESS_PORTAL_URL: http://localhost:${E2E_PORTAL_PORT:-5373}
+    volumes:
+      - .:/repo
+
+secrets:
+  npmrc:
+    file: .npmrc
diff --git a/e2e/freight/README.md b/e2e/freight/README.md
new file mode 100644
index 000000000..75b877b84
--- /dev/null
+++ b/e2e/freight/README.md
@@ -0,0 +1,108 @@
+# @edr/freight-e2e — Cypress e2e suite for the freight system
+
+Containerized, fully isolated e2e environment: throwaway Postgres (tmpfs),
+MinIO, freight-api, portal, and backoffice — plus a Cypress runner that works
+both headless-in-Docker and interactively from the host against the same URLs.
+
+## Stack (`docker-compose.e2e.yaml`, project name `edr-freight-e2e`)
+
+| Service                 | Default port | Notes                                          |
+| ----------------------- | ------------ | ---------------------------------------------- |
+| `freight-api-e2e`       | 3101         | migrations + seeders run at boot               |
+| `freight-portal-e2e`    | 5373         | nginx static build, API URL baked at build     |
+| `freight-backoffice-e2e`| 5383         | nginx static build, API URL baked at build     |
+| `postgres-freight-e2e`  | 5533         | `edr_freight_e2e`, tmpfs — gone on `down`      |
+| `minio-e2e`             | 9310/9311    | object storage for file features               |
+| `cypress`               | (host net)   | profile `cypress`, headless chrome             |
+
+Ports are env-parameterized (`E2E_API_PORT`, `E2E_PORTAL_PORT`,
+`E2E_BACKOFFICE_PORT`, `E2E_DB_PORT`, `E2E_MINIO_PORT`,
+`E2E_MINIO_CONSOLE_PORT`). Defaults avoid the dev stacks; if a default is
+busy anyway, the launcher scans upward for a free port, remembers the choice
+in `.e2e-ports.json` (gitignored) while the stack is up, and passes matching
+URLs to both compose and Cypress. The dev database is never touched.
+
+## Usage (from repo root)
+
+One command — the launcher (`scripts/e2e.mjs`) auto-builds and starts the
+stack if it isn't running, waits for healthchecks, then runs Cypress against
+whatever ports were picked:
+
+```bash
+pnpm e2e:freight:run     # headless run from the host (auto-up)
+pnpm e2e:freight:open    # interactive Cypress on the host (auto-up)
+pnpm e2e:freight:ci      # headless run inside the cypress container (auto-up)
+pnpm e2e:freight:up      # just start the stack
+pnpm e2e:freight:down    # teardown, drop all data + forget ports
+pnpm e2e:freight:run --spec 'cypress/e2e/flows/**'   # extra args → cypress
+```
+
+First `up` is slow (image builds + 240 migrations + seeders — healthcheck
+allows 3 min). Later runs against a live stack skip docker entirely. Requires
+the same root `.npmrc` (GitHub Packages auth for `@tria-plc`) as the main
+compose file. Note: a non-default API port forces a web-image rebuild (the
+API URL is baked into the static builds).
+
+The `cypress` service uses `network_mode: host` (Linux). On macOS/Windows run
+Cypress from the host (`e2e:freight:open` / `e2e:freight:run`) instead of the
+container.
+
+## Test users
+
+Inserted by Cypress itself — a global `before()` hook runs
+`cy.task("db:seedUsers")`, which executes `cypress/fixtures/seed-users.sql`
+then `cypress/fixtures/seed-company.sql` (idempotent, pre-hashed argon2
+passwords) against the e2e database. No API code is involved; the app's user
+seeders stay disabled. The API's always-on boot seeders must have run first
+(org/unit/positions) — guaranteed once `freight-api-e2e` is healthy.
+
+- Staff (backoffice): `linestaff|chief|director|ceo|marketer|operation|gl-et|gl-dj@edr.local`
+  — password `password@tria`
+- Customers (portal): `user@gmail.com`, `user2@gmail.com`
+  — password `12345678`
+
+`seed-company.sql` additionally gives `user@gmail.com` an ACTIVE company
+("E2E Logistics PLC", TIN `0102030405`) with an approved importer profile —
+the contract wizard's precondition — and grants `chief` the
+`edr_freight_app:admin` permission (customer-profile approval is
+FreightAdmin-guarded and no seeded position carries it otherwise).
+
+Full map in `cypress/fixtures/users.json`.
+
+## Conventions
+
+- **Programmatic login** everywhere except the two dedicated UI-login specs:
+  `cy.loginBackoffice(email?)` / `cy.loginPortal(email?)` — `cy.session`-cached
+  (across specs), `POST /api/auth/login`, sets the `auth-token` /
+  `refresh-token` cookies the apps read.
+- **Origins**: `baseUrl` is the backoffice (5383). Portal specs `cy.visit`
+  the absolute portal URL; a test that touches *both* apps wraps portal steps
+  in `cy.origin()` (different port = different origin). Cookies ignore ports —
+  always call the matching login command right before switching apps so
+  `cy.session` restores the right cookie snapshot.
+- **DB access**: `cy.task("db:query", { sql, params })` runs SQL against the
+  e2e database (`E2E_DB_URL`, default `localhost:5533`). Use for seeding
+  edge-case data and asserting side effects — it can never reach the dev DB.
+- **OTPs**: SMS/email delivery is disabled in e2e, but codes are still stored
+  in `freight.otp_verifications` — `cy.getOtp(emailOrPhone)` polls them out.
+  Used by signup verification and contract customer-signing.
+- **Spec layout**:
+  - `cypress/e2e/api/` — API contract via `cy.request` (no browser)
+  - `cypress/e2e/backoffice/` — staff app
+  - `cypress/e2e/portal/` — customer app
+  - `cypress/e2e/flows/` — cross-app journeys (both directions):
+    - `onboarding.cy.ts` — signup → OTP → wizard (docs + license upload) →
+      backoffice approval → customer can contract
+    - `contract-lifecycle.cy.ts` — wizard → submit → accept → 2-step approval
+      → PDF → customer OTP-sign → staff counter-sign → `CONTRACT_ACTIVE`
+- **Journey specs** (`flows/onboarding`, `flows/contract-lifecycle`) run with
+  `retries: 0` and resolve mid-journey state (user, company, contract) from
+  the DB at the start of each test: switching origin between tests reloads
+  the spec bundle, so module-level variables do NOT survive across tests.
+
+## Extending
+
+Deep module flows (booking wizard → staff approval → scheduling → billing)
+belong in `flows/`. Pattern: arrange via API/`db:query`, act through the UI of
+one app, assert through the UI of the other + a `db:query` cross-check. Prefer
+adding `data-testid` attributes to app code over brittle text selectors.
diff --git a/e2e/freight/cypress.config.ts b/e2e/freight/cypress.config.ts
new file mode 100644
index 000000000..a2acffe24
--- /dev/null
+++ b/e2e/freight/cypress.config.ts
@@ -0,0 +1,83 @@
+import { defineConfig } from "cypress";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { Client } from "pg";
+
+/**
+ * Freight e2e suite. Three origins:
+ *   backoffice  http://localhost:5383  (baseUrl — most specs live here)
+ *   portal      http://localhost:5373  (env.portalUrl; portal specs cy.visit it,
+ *                                       cross-app flows reach it via cy.origin)
+ *   api         http://localhost:3101  (env.apiUrl; cy.request only)
+ *
+ * All URLs are host-published ports from docker-compose.e2e.yaml. The cypress
+ * container in that compose file runs with network_mode: host, so the same
+ * localhost URLs work identically for `cypress open` on the host and for the
+ * containerized headless run.
+ */
+export default defineConfig({
+  e2e: {
+    baseUrl: process.env.CYPRESS_BASE_URL ?? "http://localhost:5383",
+    specPattern: "cypress/e2e/**/*.cy.ts",
+    supportFile: "cypress/support/e2e.ts",
+    video: process.env.CI === "true" || process.env.CYPRESS_VIDEO === "true",
+    screenshotOnRunFailure: true,
+    viewportWidth: 1440,
+    viewportHeight: 900,
+    defaultCommandTimeout: 10000,
+    requestTimeout: 15000,
+    retries: { runMode: 1, openMode: 0 },
+    env: {
+      apiUrl: process.env.CYPRESS_API_URL ?? "http://localhost:3101",
+      portalUrl: process.env.CYPRESS_PORTAL_URL ?? "http://localhost:5373",
+      backofficeUrl: process.env.CYPRESS_BASE_URL ?? "http://localhost:5383",
+      // Staff users: DEFAULT_PASSWORD from docker-compose.e2e.yaml.
+      defaultPassword: process.env.CYPRESS_DEFAULT_PASSWORD ?? "password@tria",
+      // Demo portal users: hardcoded in DemoUsersSeeder.
+      demoPassword: "12345678",
+    },
+    setupNodeEvents(on) {
+      const dbUrl =
+        process.env.E2E_DB_URL ??
+        "postgres://edr_e2e:edr_e2e@localhost:5533/edr_freight_e2e";
+
+      on("task", {
+        /** Run an arbitrary SQL statement against the ephemeral e2e database. */
+        async "db:query"({ sql, params = [] }: { sql: string; params?: unknown[] }) {
+          const client = new Client({ connectionString: dbUrl });
+          await client.connect();
+          try {
+            const result = await client.query(sql, params as never[]);
+            return { rowCount: result.rowCount, rows: result.rows };
+          } finally {
+            await client.end();
+          }
+        },
+
+        /**
+         * Seed the test users (staff + demo) directly in SQL. The API's
+         * user seeders are disabled in app code, so the fixture replicates
+         * their output. Idempotent — safe to run before every spec file.
+         */
+        async "db:seedUsers"() {
+          // cwd = the e2e/freight project root when Cypress runs.
+          // seed-company.sql depends on rows from seed-users.sql — keep order.
+          const client = new Client({ connectionString: dbUrl });
+          await client.connect();
+          try {
+            for (const file of ["seed-users.sql", "seed-company.sql"]) {
+              const sql = readFileSync(
+                join(process.cwd(), "cypress", "fixtures", file),
+                "utf8",
+              );
+              await client.query(sql);
+            }
+            return true;
+          } finally {
+            await client.end();
+          }
+        },
+      });
+    },
+  },
+});
diff --git a/e2e/freight/cypress/e2e/api/health-and-auth.cy.ts b/e2e/freight/cypress/e2e/api/health-and-auth.cy.ts
new file mode 100644
index 000000000..c183a11df
--- /dev/null
+++ b/e2e/freight/cypress/e2e/api/health-and-auth.cy.ts
@@ -0,0 +1,79 @@
+/**
+ * API contract smoke — no browser, pure cy.request against freight-api.
+ * Verifies the containerized stack booted: migrations ran, seeders ran,
+ * auth issues tokens.
+ */
+const api = () => Cypress.env("apiUrl") as string;
+
+describe("freight-api: health + auth contract", () => {
+  it("GET /api/health responds", () => {
+    cy.request(`${api()}/api/health`).its("status").should("eq", 200);
+  });
+
+  it("rejects bad credentials", () => {
+    cy.request({
+      method: "POST",
+      url: `${api()}/api/auth/login`,
+      body: { email: "nobody@edr.local", password: "wrong-password" },
+      failOnStatusCode: false,
+    })
+      .its("status")
+      .should("be.oneOf", [400, 401, 404]);
+  });
+
+  it("logs in every seeded staff user", () => {
+    cy.fixture("users.json").then((users) => {
+      Object.values<{ email: string }>(users.staff).forEach(({ email }) => {
+        cy.apiLogin(email);
+      });
+    });
+  });
+
+  it("staff token can read /api/me", () => {
+    cy.apiLogin("ceo@edr.local").then(({ token }) => {
+      cy.request({
+        url: `${api()}/api/me`,
+        headers: { Authorization: `Bearer ${token}` },
+      }).then((response) => {
+        expect(response.status).to.eq(200);
+      });
+    });
+  });
+
+  it("refresh-token rotates the session", () => {
+    cy.apiLogin("chief@edr.local").then(({ refreshToken }) => {
+      cy.request("POST", `${api()}/api/auth/refresh-token`, { refreshToken })
+        .its("body.token")
+        .should("be.a", "string");
+    });
+  });
+
+  it("demo portal users are seeded", () => {
+    // DemoUsersSeeder hardcodes this password (staff users use DEFAULT_PASSWORD)
+    cy.apiLogin("user@gmail.com", Cypress.env("demoPassword"));
+    cy.apiLogin("user2@gmail.com", Cypress.env("demoPassword"));
+  });
+});
+
+describe("freight-api: seeded database", () => {
+  it("migrations table is populated", () => {
+    cy.task<{ rowCount: number }>("db:query", {
+      sql: "select count(*)::int as count from migrations",
+    }).then(({ rows }: any) => {
+      expect(rows[0].count).to.be.greaterThan(100);
+    });
+  });
+
+  it("staff users exist with credentials", () => {
+    cy.task("db:query", {
+      sql: `select u.email from iam.users u
+            join iam.user_credentials c on c.user_id = u.id
+            where u.email like '%@edr.local' order by u.email`,
+    }).then(({ rows }: any) => {
+      const emails = rows.map((row: { email: string }) => row.email);
+      expect(emails).to.include.members(["ceo@edr.local", "linestaff@edr.local"]);
+    });
+  });
+});
+
+export {};
diff --git a/e2e/freight/cypress/e2e/backoffice/login.cy.ts b/e2e/freight/cypress/e2e/backoffice/login.cy.ts
new file mode 100644
index 000000000..0a729bdae
--- /dev/null
+++ b/e2e/freight/cypress/e2e/backoffice/login.cy.ts
@@ -0,0 +1,41 @@
+/**
+ * The one UI-driven login spec for backoffice — every other spec uses the
+ * programmatic cy.loginBackoffice() session.
+ * Login form: apps/edr-freight-web/backoffice/src/pages/auth/LoginPage.tsx
+ * (Mantine inputs, matched by placeholder).
+ */
+describe("backoffice: UI login", () => {
+  it("redirects unauthenticated users to /auth", () => {
+    cy.clearCookies();
+    cy.visit("/dashboard/overview");
+    cy.location("pathname").should("eq", "/auth");
+  });
+
+  it("logs in via the form and lands on the dashboard", () => {
+    cy.clearCookies();
+    cy.visit("/auth");
+    cy.get('input[placeholder="name@company.com or 09XXXXXXXX"]').type("ceo@edr.local");
+    cy.get('input[placeholder="Enter your password"]').type(
+      Cypress.env("defaultPassword"),
+      { log: false },
+    );
+    cy.get('button[type="submit"]').click();
+
+    cy.location("pathname", { timeout: 20000 }).should("match", /^\/dashboard/);
+    cy.getCookie("auth-token").should("exist");
+    cy.getCookie("refresh-token").should("exist");
+  });
+
+  it("shows an error for wrong credentials and stays on /auth", () => {
+    cy.clearCookies();
+    cy.visit("/auth");
+    cy.get('input[placeholder="name@company.com or 09XXXXXXXX"]').type("ceo@edr.local");
+    cy.get('input[placeholder="Enter your password"]').type("definitely-wrong");
+    cy.get('button[type="submit"]').click();
+
+    cy.location("pathname").should("eq", "/auth");
+    cy.getCookie("auth-token").should("not.exist");
+  });
+});
+
+export {};
diff --git a/e2e/freight/cypress/e2e/backoffice/smoke.cy.ts b/e2e/freight/cypress/e2e/backoffice/smoke.cy.ts
new file mode 100644
index 000000000..db3086e71
--- /dev/null
+++ b/e2e/freight/cypress/e2e/backoffice/smoke.cy.ts
@@ -0,0 +1,49 @@
+/**
+ * Route-level smoke over the backoffice shell: each key module page loads
+ * without bouncing back to /auth and without an unhandled crash. Deep
+ * per-module behavior belongs in dedicated specs — this catches the broad
+ * "page is broken / route is dead / guard rejects seeded role" class.
+ * Routes from apps/edr-freight-web/backoffice/src/App.tsx.
+ */
+const ROUTES = [
+  "/dashboard/overview",
+  "/dashboard/booking-requests",
+  "/dashboard/customers",
+  "/dashboard/invoices",
+  "/dashboard/contract-requests",
+  "/dashboard/shipment-requests",
+  "/dashboard/profile",
+];
+
+describe("backoffice: route smoke (ceo)", () => {
+  beforeEach(() => {
+    cy.loginBackoffice("ceo@edr.local");
+  });
+
+  ROUTES.forEach((route) => {
+    it(`renders ${route}`, () => {
+      cy.visit(route);
+      cy.location("pathname").should("not.eq", "/auth");
+      cy.location("pathname").should("contain", "/dashboard");
+      cy.get("#root").should("not.be.empty");
+    });
+  });
+});
+
+describe("backoffice: role-based access", () => {
+  it("line staff can reach the dashboard shell", () => {
+    cy.loginBackoffice("linestaff@edr.local");
+    cy.visit("/dashboard/overview");
+    cy.location("pathname").should("not.eq", "/auth");
+    cy.get("#root").should("not.be.empty");
+  });
+
+  it("operations officer can reach the dashboard shell", () => {
+    cy.loginBackoffice("operation@edr.local");
+    cy.visit("/dashboard/overview");
+    cy.location("pathname").should("not.eq", "/auth");
+    cy.get("#root").should("not.be.empty");
+  });
+});
+
+export {};
diff --git a/e2e/freight/cypress/e2e/flows/contract-lifecycle.cy.ts b/e2e/freight/cypress/e2e/flows/contract-lifecycle.cy.ts
new file mode 100644
index 000000000..e78fe1905
--- /dev/null
+++ b/e2e/freight/cypress/e2e/flows/contract-lifecycle.cy.ts
@@ -0,0 +1,216 @@
+/**
+ * Contract creation → finalization, spanning portal + backoffice:
+ *
+ *   1. portal (user@gmail.com, company seeded active by seed-company.sql):
+ *      wizard → GENERAL / Import / Container / 20ft → submit + approve quote
+ *   2. backoffice marketer: "Accept for approval" (validity) + approve the
+ *      LINE_STAFF step
+ *   3. backoffice director: approve the DIRECTOR step → PDF → CONTRACT_READY
+ *   4. portal customer: scroll contract, agree, draw signature, OTP-sign
+ *      → SIGNED_CUSTOMER
+ *   5. backoffice marketer: counter-sign as staff → GENERAL contract goes
+ *      CONTRACT_ACTIVE (per-booking clearance, no contract-level gate)
+ *
+ * Sequential steps of one journey — retries off (steps are not idempotent).
+ */
+
+const customer = "user@gmail.com";
+const companyTin = "0102030405"; // seed-company.sql
+
+/**
+ * The journey's contract = the seeded company's latest contract. Each test
+ * resolves it from the DB instead of sharing module state — tests stay
+ * independently runnable against the current DB state.
+ */
+function dbContract() {
+  return cy.task<{ rows: Array<{ id: string; reference: string; status: string }> }>(
+    "db:query",
+    {
+      sql: `SELECT ct.id, ct.reference, ct.status
+            FROM freight.contracts ct
+            JOIN freight.companies c ON c.id = ct.company_id
+            WHERE c.tin = $1
+            ORDER BY ct.created_at DESC LIMIT 1`,
+      params: [companyTin],
+    },
+  );
+}
+
+function withContract(fn: (c: { id: string; reference: string; status: string }) => void) {
+  dbContract().then(({ rows }) => {
+    expect(rows, "latest contract for the seeded company").to.have.length(1);
+    fn(rows[0]);
+  });
+}
+
+function expectStatus(expected: string) {
+  dbContract().then(({ rows }) => {
+    expect(rows[0]?.status, `contract status`).to.eq(expected);
+  });
+}
+
+describe("contract lifecycle: creation to finalization", { retries: 0 }, () => {
+  it("customer creates and submits a GENERAL import container contract", () => {
+    cy.loginPortal(customer);
+    cy.visitPortal("/contracts/new");
+
+    // Step 0 — Setup.
+    cy.mantineSelect(/^Operation Type/, /^Import$/);
+    cy.mantineSelect(/^Contract Kind/, "General Contract");
+    cy.mantineSelect(/^New or Renewal/, "New Contract");
+    cy.contains("Rail Transport Only", { timeout: 15000 }).click();
+    cy.mantineSelect(/^Payment Currency/, /^ETB/);
+    cy.contains("button", "Continue").click({ force: true });
+
+    // Step 1 — Cargo & Route.
+    cy.mantineSelect(/^Cargo Scope/, /Containerized/);
+    cy.get('[role="checkbox"][aria-label="20ft Container"]').click();
+    cy.get('textarea[placeholder*="Electronics"]').type(
+      "E2E electronics shipment scope",
+    );
+    cy.mantineSelect(/^Origin Yard/, "Djibouti Port Terminal");
+    cy.mantineSelect(/^Destination Yard/, "Mojo Dry Port");
+    cy.contains("button", "Continue").click({ force: true });
+
+    // Step 2 — Review & Submit → quotation modal.
+    cy.contains("button", "Submit").click({ force: true });
+    cy.contains("Approve your quotation", { timeout: 30000 }).should(
+      "be.visible",
+    );
+    cy.contains("button", "Approve & submit").click();
+
+    cy.location("pathname", { timeout: 20000 }).should("eq", "/contracts");
+    cy.contains("Submitted", { timeout: 15000 }).should("be.visible");
+
+    dbContract().then(({ rows }) => {
+      expect(rows, "contract row").to.have.length(1);
+      expect(rows[0].status).to.eq("SUBMITTED");
+      expect(rows[0].reference).to.match(/^CTR-/);
+    });
+  });
+
+  it("marketer accepts the submission and approves the LINE_STAFF step", () => {
+    cy.loginBackoffice("marketer@edr.local");
+    withContract((c) => cy.visit(`/dashboard/contract-requests/${c.id}`));
+
+    cy.contains("button", "Accept for approval", { timeout: 20000 }).click();
+    // Validity defaults to the first configured option in the accept modal.
+    cy.contains("button", "Accept & start approval", { timeout: 20000 })
+      .should("not.be.disabled")
+      .click();
+
+    // Approval chain instantiated: LINE_STAFF → DIRECTOR. Approve step 1.
+    cy.contains("Approval chain", { timeout: 20000 }).should("be.visible");
+    cy.contains("button", "Approve", { timeout: 20000 }).click();
+    cy.contains("button", "Confirm approval").click();
+    cy.contains("1/2", { timeout: 20000 }).should("be.visible");
+
+    expectStatus("PENDING_APPROVAL");
+  });
+
+  it("director approves the final step — contract PDF becomes ready", () => {
+    cy.loginBackoffice("director@edr.local");
+    withContract((c) => cy.visit(`/dashboard/contract-requests/${c.id}`));
+
+    cy.contains("button", "Approve", { timeout: 20000 }).click();
+    cy.contains("button", "Confirm approval").click();
+
+    // Final approval renders the contract PDF synchronously → CONTRACT_READY.
+    // The approval-chain card unmounts once the contract leaves approval, so
+    // assert on the signing CTA that replaces it.
+    cy.contains("button", "View & sign", { timeout: 30000 }).should("exist");
+
+    expectStatus("CONTRACT_READY");
+  });
+
+  it("customer signs the contract with OTP", () => {
+    cy.loginPortal(customer);
+    withContract((c) => cy.visitPortal(`/contracts/${c.id}/view`));
+
+    // Scroll the contract iframe to the bottom so the consent bar unlocks.
+    // Retried because the iframe can re-render (query refetch) after a scroll.
+    const unlockConsent = (attempt: number) => {
+      cy.get('iframe[title="Contract document"]', { timeout: 30000 }).then(
+        ($f) => {
+          const win = ($f[0] as HTMLIFrameElement).contentWindow;
+          // documentElement can be null while the srcDoc is (re)parsing —
+          // skip this round and let the retry pick it up.
+          const el =
+            win?.document?.scrollingElement ?? win?.document?.documentElement;
+          if (win && el) {
+            el.scrollTop = el.scrollHeight;
+            win.dispatchEvent(new Event("scroll"));
+          }
+        },
+      );
+      cy.wait(500).then(() => {
+        cy.get("body").then(($b) => {
+          if ($b.text().includes("I have read the entire contract")) return;
+          expect(attempt, "consent bar unlocked").to.be.lessThan(20);
+          unlockConsent(attempt + 1);
+        });
+      });
+    };
+    unlockConsent(0);
+
+    cy.contains("I have read the entire contract", { timeout: 15000 }).click();
+    cy.contains("button", /^Sign contract$|^Approve & sign$/).click();
+
+    // Signature modal: name + drawn signature.
+    cy.contains("label", "Full name")
+      .invoke("attr", "for")
+      .then((id) => {
+        cy.get(`[id="${id}"]`).clear().type("Demo User");
+      });
+    cy.drawSignature();
+    cy.contains("button", "Continue to verification").click();
+
+    // OTP modal — code goes to the signer's registered contacts (email only
+    // for the seeded demo user); read it from the DB.
+    cy.contains("Verify it's you", { timeout: 20000 }).should("be.visible");
+    cy.getOtp(customer).then((otp) => cy.typeOtp(otp));
+    cy.contains("button", "Verify & sign").click();
+
+    cy.contains("Your signature has been recorded", { timeout: 30000 }).should(
+      "be.visible",
+    );
+    expectStatus("SIGNED_CUSTOMER");
+  });
+
+  it("staff counter-signs — GENERAL contract becomes CONTRACT_ACTIVE", () => {
+    cy.loginBackoffice("marketer@edr.local");
+    withContract((c) => cy.visit(`/dashboard/contract-requests/${c.id}/view`));
+
+    cy.contains("button", /^Sign as staff$|^Approve & sign$/, {
+      timeout: 30000,
+    }).click();
+    cy.contains("label", "Full name")
+      .invoke("attr", "for")
+      .then((id) => {
+        cy.get(`[id="${id}"]`).clear().type("EDR Marketer");
+      });
+    cy.drawSignature();
+    // Scoped to the modal — the toolbar behind it has its own "Approve & sign".
+    cy.get(".mantine-Modal-content")
+      .contains("button", /^Confirm signature$|^Approve & sign$/)
+      .click();
+
+    cy.contains("counter-signed", { timeout: 30000 }).should("be.visible");
+
+    // GENERAL → clearance runs per booking, contract goes straight active.
+    expectStatus("CONTRACT_ACTIVE");
+
+    // Both signatures recorded.
+    withContract((c) => {
+      cy.task<{ rows: Array<{ role: string }> }>("db:query", {
+        sql: `SELECT s.role FROM freight.contract_signatures s
+              WHERE s.contract_id = $1 ORDER BY s.role`,
+        params: [c.id],
+      }).then(({ rows }) => {
+        expect(rows.map((r) => r.role)).to.include.members(["CUSTOMER", "STAFF"]);
+      });
+    });
+  });
+});
+
+export {};
diff --git a/e2e/freight/cypress/e2e/flows/cross-app.cy.ts b/e2e/freight/cypress/e2e/flows/cross-app.cy.ts
new file mode 100644
index 000000000..fe60170ba
--- /dev/null
+++ b/e2e/freight/cypress/e2e/flows/cross-app.cy.ts
@@ -0,0 +1,69 @@
+/**
+ * Cross-app flow: same business objects seen from both directions —
+ * customer (portal, port 5373) and staff (backoffice, port 5383 = baseUrl).
+ * Different ports = different origins, so portal steps inside a test that
+ * also touches backoffice run inside cy.origin().
+ *
+ * Cookie caveat: cookies ignore ports, so both apps share the localhost
+ * cookie jar. Always call the matching login command immediately before
+ * switching apps — cy.session restores the right cookie snapshot.
+ *
+ * This spec is the template for full journeys (booking → approval →
+ * scheduling → billing). It verifies both sides of the fence against
+ * seeded data via UI + API cross-checks.
+ */
+const portal = () => Cypress.env("portalUrl") as string;
+const api = () => Cypress.env("apiUrl") as string;
+
+describe("flow: customer and staff see the same world", () => {
+  it("staff views booking requests, customer views bookings", () => {
+    // Staff side on the primary origin (baseUrl) first — the first origin a
+    // test visits becomes primary; every other origin needs cy.origin().
+    cy.loginBackoffice("ceo@edr.local");
+    cy.visit("/dashboard/booking-requests");
+    cy.location("pathname").should("eq", "/dashboard/booking-requests");
+    cy.get("#root").should("not.be.empty");
+
+    // Customer side — switch session first, then enter the portal origin.
+    cy.loginPortal("user@gmail.com");
+    cy.origin(portal(), () => {
+      cy.visit("/bookings");
+      cy.location("pathname").should("not.eq", "/login");
+      cy.get("#root").should("not.be.empty");
+    });
+  });
+
+  it("staff and customer both resolve their own /api/me identity", () => {
+    cy.apiLogin("ceo@edr.local").then(({ token }) => {
+      cy.request({
+        url: `${api()}/api/me`,
+        headers: { Authorization: `Bearer ${token}` },
+      })
+        .its("status")
+        .should("eq", 200);
+    });
+    cy.apiLogin("user@gmail.com", Cypress.env("demoPassword")).then(({ token }) => {
+      cy.request({
+        url: `${api()}/api/me`,
+        headers: { Authorization: `Bearer ${token}` },
+      })
+        .its("status")
+        .should("eq", 200);
+    });
+  });
+
+  it("cy.origin: staff dashboard then portal in a single test", () => {
+    cy.loginBackoffice("ceo@edr.local");
+    cy.visit("/dashboard/overview");
+    cy.get("#root").should("not.be.empty");
+
+    cy.loginPortal("user@gmail.com");
+    cy.origin(Cypress.env("portalUrl") as string, () => {
+      cy.visit("/portal");
+      cy.location("pathname").should("not.eq", "/login");
+      cy.get("#root").should("not.be.empty");
+    });
+  });
+});
+
+export {};
diff --git a/e2e/freight/cypress/e2e/flows/onboarding.cy.ts b/e2e/freight/cypress/e2e/flows/onboarding.cy.ts
new file mode 100644
index 000000000..ed6df900b
--- /dev/null
+++ b/e2e/freight/cypress/e2e/flows/onboarding.cy.ts
@@ -0,0 +1,203 @@
+/**
+ * Full customer onboarding journey, both apps:
+ *
+ *   1. portal    — /signup form → OTP (read from DB, delivery is off in e2e)
+ *                  → account created → onboarding wizard (nationality/role →
+ *                  company → personnel → contact → PoA → documents incl. the
+ *                  per-role business license) → "Submit for review"
+ *   2. backoffice — staff (chief, holds edr_freight_app:admin) approves the
+ *                  importer profile on /dashboard/customers/:id
+ *   3. portal    — the new customer is active: contract wizard reachable
+ *
+ * Tests are sequential steps of ONE journey (fresh unique user per run), so
+ * retries are disabled — a mid-journey retry would replay a non-idempotent
+ * step against already-advanced state.
+ *
+ * NOTE: switching origin between tests (portal 5373 ↔ backoffice 5383)
+ * reloads the spec bundle and resets module state — later tests resolve the
+ * journey's user/company from the DB instead of module variables.
+ */
+
+const stamp = Date.now();
+const email = `e2e.onboard.${stamp}@example.com`;
+// Ethiopian mobile: 9 + 8 digits, unique per run.
+const phoneNational = `9${String(stamp).slice(-8)}`;
+const signupPassword = "Password@e2e1";
+const companyName = `E2E Onboard Co ${stamp}`;
+const tin = String(stamp).slice(-10).padStart(10, "1");
+const vat = String(stamp + 1).slice(-10).padStart(10, "2");
+const fan = String(stamp).slice(-13).padStart(16, "3");
+
+const portal = () => Cypress.env("portalUrl") as string;
+
+/** The journey's company/user = the latest e2e.onboard.* signup in the DB. */
+function latestOnboardJourney() {
+  return cy.task<{ rows: Array<{ name: string; email: string }> }>("db:query", {
+    sql: `SELECT c.name, u.email
+          FROM freight.companies c
+          JOIN freight.external_profiles ep ON ep.company_id = c.id
+          JOIN iam.users u ON u.id = ep.user_id
+          WHERE u.email LIKE 'e2e.onboard.%'
+          ORDER BY c.created_at DESC LIMIT 1`,
+  });
+}
+
+/** Fill a labelled Mantine input (label[for] → input id). */
+function fill(label: string | RegExp, value: string) {
+  cy.contains("label", label)
+    .invoke("attr", "for")
+    .then((id) => {
+      cy.get(`[id="${id}"]`).clear({ force: true }).type(value, { force: true });
+    });
+}
+
+/** The wizard's phone inputs (react-phone-number-input, type=tel). */
+function fillPhone(index: number, national: string) {
+  cy.get('.mantine-Modal-content input[type="tel"]')
+    .eq(index)
+    .clear({ force: true })
+    .type(national, { force: true });
+}
+
+describe("customer onboarding journey", { retries: 0 }, () => {
+  it("signs up with OTP and completes the onboarding wizard", () => {
+    // The eTrade TIN lookup 400s in e2e (external service unreachable). The
+    // form handles it ("fill in the details manually") but axios also throws
+    // an uncaught rejection — ignore just that one.
+    cy.on("uncaught:exception", (err) =>
+      err.message.includes("Request failed with status code 400") ? false : true,
+    );
+    cy.visit(`${portal()}/signup`);
+
+    fill(/^First name/, "Onboard");
+    fill(/^Last name/, "Tester");
+    fill(/^Email/, email);
+    cy.get('input[type="tel"]').first().type(phoneNational, { force: true });
+    fill(/^Password/, signupPassword);
+    fill(/^Confirm password/, signupPassword);
+    cy.contains("button", "Continue").click();
+
+    // OTP stage — the code is generated + stored even though delivery is off.
+    cy.contains("Verify", { timeout: 15000 }).should("be.visible");
+    cy.getOtp(email).then((otp) => cy.typeOtp(otp));
+    cy.contains("button", "Verify & create account").click();
+
+    // Signed in → /portal → wizard auto-opens on the nationality/role step.
+    cy.location("pathname", { timeout: 20000 }).should("eq", "/portal");
+    cy.contains("Where is your company registered?", { timeout: 15000 }).should(
+      "be.visible",
+    );
+    cy.contains("button", "Ethiopian Company").click();
+    cy.contains("button", "Importer").click();
+    cy.get(".mantine-Modal-content").contains("button", "Continue").click();
+
+    // Company step. TIN first — the eTrade auto-lookup fails in e2e (no
+    // external network) and the form allows manual entry.
+    cy.get('input[placeholder="0012345678"]', { timeout: 15000 }).type(tin);
+    fill(/^Company Name/, companyName);
+    fill(/^Company Email/, `ops.${stamp}@example.com`);
+    fillPhone(0, "911234567");
+    fill(/^Location/, "Addis Ababa, Ethiopia");
+    fill(/^VAT Number/, vat);
+    cy.get('input[placeholder="1234567890123456"]').type(fan);
+    cy.mantineSelect(/^Region/, "Addis Ababa");
+    fill(/^Zone/, "Zone 1");
+    fill(/^Woreda/, "Woreda 1");
+    fill(/^Kebele/, "Kebele 1");
+    fill(/^House No/, "123");
+    cy.get(".mantine-Modal-content").contains("button", "Continue").click();
+
+    // Personnel (general manager).
+    fill(/^Name/, "General Manager");
+    fill(/^Email/, `gm.${stamp}@example.com`);
+    fillPhone(0, "911234568");
+    cy.get(".mantine-Modal-content").contains("button", "Continue").click();
+
+    // Contact person.
+    fill(/^Name/, "Contact Person");
+    fillPhone(0, "911234569");
+    cy.get(".mantine-Modal-content").contains("button", "Continue").click();
+
+    // PoA — optional for an importer.
+    cy.get(".mantine-Modal-content").contains("button", "Continue").click();
+
+    // Documents: no company docs are configured in e2e, but every role needs
+    // a business license.
+    cy.contains("Business license", { timeout: 15000 }).should("be.visible");
+    cy.get('.mantine-Modal-content input[type="file"]')
+      .first()
+      .selectFile("cypress/fixtures/docs/license.pdf", { force: true });
+    cy.get(".mantine-Modal-content")
+      .contains("button", "Submit for review")
+      .click();
+
+    cy.contains("You're all set", { timeout: 30000 }).should("be.visible");
+
+    // DB cross-check: submitted, awaiting approval.
+    cy.task<{ rows: Array<{ status: string; onboarding_completed: boolean }> }>(
+      "db:query",
+      {
+        sql: `SELECT c.status, ep.onboarding_completed
+              FROM freight.companies c
+              JOIN freight.external_profiles ep ON ep.company_id = c.id
+              JOIN iam.users u ON u.id = ep.user_id
+              WHERE u.email = $1`,
+        params: [email],
+      },
+    ).then(({ rows }) => {
+      expect(rows, "company row").to.have.length(1);
+      expect(rows[0].status).to.eq("pending");
+      expect(rows[0].onboarding_completed).to.eq(true);
+    });
+  });
+
+  it("backoffice staff approves the submitted importer profile", () => {
+    cy.loginBackoffice("chief@edr.local");
+    cy.visit("/dashboard/customers");
+
+    latestOnboardJourney().then(({ rows }) => {
+      expect(rows, "onboarded company").to.have.length(1);
+      const company = rows[0].name;
+
+      cy.get('input[placeholder*="Search by company"]').type(company);
+      cy.contains(company, { timeout: 15000 }).click();
+
+      // Role profiles table → approve the pending importer profile. Once
+      // active, the row's action flips to "Suspend".
+      cy.contains("button", "Approve", { timeout: 15000 }).click();
+      cy.contains("button", "Suspend", { timeout: 15000 }).should("be.visible");
+
+      cy.task<{ rows: Array<{ status: string; reference: string | null; company_status: string }> }>(
+        "db:query",
+        {
+          sql: `SELECT p.status, p.reference, c.status AS company_status
+                FROM freight.company_profiles p
+                JOIN freight.companies c ON c.id = p.company_id
+                WHERE c.name = $1 AND p.type = 'importer'`,
+          params: [company],
+        },
+      ).then(({ rows: profiles }) => {
+        expect(profiles, "importer profile").to.have.length(1);
+        expect(profiles[0].status).to.eq("active");
+        expect(profiles[0].reference, "minted reference").to.be.a("string").and
+          .not.be.empty;
+        expect(profiles[0].company_status).to.eq("active");
+      });
+    });
+  });
+
+  it("the approved customer can reach the contract wizard", () => {
+    latestOnboardJourney().then(({ rows }) => {
+      cy.loginPortal(rows[0].email, signupPassword);
+    });
+    cy.visitPortal("/contracts/new");
+
+    // No "Awaiting Approval" gate — the wizard's first step renders.
+    cy.contains("label", "Operation Type", { timeout: 15000 }).should(
+      "be.visible",
+    );
+    cy.contains("Awaiting Approval").should("not.exist");
+  });
+});
+
+export {};
diff --git a/e2e/freight/cypress/e2e/portal/login.cy.ts b/e2e/freight/cypress/e2e/portal/login.cy.ts
new file mode 100644
index 000000000..55ef4bc21
--- /dev/null
+++ b/e2e/freight/cypress/e2e/portal/login.cy.ts
@@ -0,0 +1,36 @@
+/**
+ * UI login for the customer portal (seeded demo user).
+ * Form: apps/edr-freight-web/portal/src/pages/accounts/LoginPage.tsx.
+ * Portal is a different origin (port 5373), so specs visit it via absolute
+ * URL — each test here stays on that single origin, no cy.origin needed.
+ */
+const portal = () => Cypress.env("portalUrl") as string;
+
+describe("portal: UI login", () => {
+  it("logs in via the form", () => {
+    cy.clearCookies();
+    cy.visit(`${portal()}/login`);
+    cy.get('input[placeholder="name@company.com or 09XXXXXXXX"]').type("user@gmail.com");
+    cy.get('input[placeholder="Enter your password"]').type(
+      Cypress.env("demoPassword"),
+      { log: false },
+    );
+    cy.get('button[type="submit"]').click();
+
+    cy.location("pathname", { timeout: 20000 }).should("not.eq", "/login");
+    cy.getCookie("auth-token").should("exist");
+  });
+
+  it("rejects wrong credentials", () => {
+    cy.clearCookies();
+    cy.visit(`${portal()}/login`);
+    cy.get('input[placeholder="name@company.com or 09XXXXXXXX"]').type("user@gmail.com");
+    cy.get('input[placeholder="Enter your password"]').type("definitely-wrong");
+    cy.get('button[type="submit"]').click();
+
+    cy.location("pathname").should("eq", "/login");
+    cy.getCookie("auth-token").should("not.exist");
+  });
+});
+
+export {};
diff --git a/e2e/freight/cypress/e2e/portal/smoke.cy.ts b/e2e/freight/cypress/e2e/portal/smoke.cy.ts
new file mode 100644
index 000000000..5372d7359
--- /dev/null
+++ b/e2e/freight/cypress/e2e/portal/smoke.cy.ts
@@ -0,0 +1,29 @@
+/**
+ * Route-level smoke over the customer portal.
+ * Routes from apps/edr-freight-web/portal/src/App.tsx.
+ */
+const portal = () => Cypress.env("portalUrl") as string;
+
+const ROUTES = ["/portal", "/bookings", "/contracts", "/billing", "/tracking"];
+
+describe("portal: route smoke (demo customer)", () => {
+  beforeEach(() => {
+    cy.loginPortal("user@gmail.com");
+  });
+
+  ROUTES.forEach((route) => {
+    it(`renders ${route}`, () => {
+      cy.visit(`${portal()}${route}`);
+      cy.location("pathname").should("not.eq", "/login");
+      cy.get("#root").should("not.be.empty");
+    });
+  });
+
+  it("new booking wizard opens", () => {
+    cy.visit(`${portal()}/bookings/new`);
+    cy.location("pathname").should("eq", "/bookings/new");
+    cy.get("#root").should("not.be.empty");
+  });
+});
+
+export {};
diff --git a/e2e/freight/cypress/fixtures/docs/license.pdf b/e2e/freight/cypress/fixtures/docs/license.pdf
new file mode 100644
index 000000000..8a4f1376d
--- /dev/null
+++ b/e2e/freight/cypress/fixtures/docs/license.pdf
@@ -0,0 +1,11 @@
+%PDF-1.4
+1 0 obj<</Type/Catalog/Pages 2 0 R>>endobj
+2 0 obj<</Type/Pages/Kids[3 0 R]/Count 1>>endobj
+3 0 obj<</Type/Page/Parent 2 0 R/MediaBox[0 0 200 200]>>endobj
+xref
+0 4
+0000000000 65535 f 
+trailer<</Size 4/Root 1 0 R>>
+startxref
+0
+%%EOF
diff --git a/e2e/freight/cypress/fixtures/seed-company.sql b/e2e/freight/cypress/fixtures/seed-company.sql
new file mode 100644
index 000000000..73b01bee1
--- /dev/null
+++ b/e2e/freight/cypress/fixtures/seed-company.sql
@@ -0,0 +1,51 @@
+-- Arrange-data for the contract lifecycle specs, applied after seed-users.sql.
+-- Idempotent. Two things the app cannot provide without manual steps:
+--
+-- 1. chief gets `edr_freight_app:admin` (customer-profile approval is
+--    FreightAdmin-guarded and no seeded position carries it).
+-- 2. user@gmail.com gets an ACTIVE company + approved importer profile so the
+--    contract wizard is reachable without first running the onboarding journey.
+
+-- 1. chief → edr_freight_app:admin
+INSERT INTO iam.position_permissions (id, position_id, permission_id)
+SELECT gen_random_uuid(), p.id, perm.id
+FROM iam.positions p
+JOIN iam.permissions perm ON perm.key = 'edr_freight_app:admin'
+WHERE p.key = 'chief'
+  AND NOT EXISTS (
+    SELECT 1 FROM iam.position_permissions pp
+    WHERE pp.position_id = p.id AND pp.permission_id = perm.id
+  );
+
+-- 2a. Active customer company (TIN is the idempotency key).
+INSERT INTO freight.companies
+  (id, name, type, status, tin, fan_number, country, address, phone, email,
+   nationality, kind, attributes)
+SELECT gen_random_uuid(), 'E2E Logistics PLC', 'customer', 'active',
+  '0102030405', '1234567890123456', 'Ethiopia', 'Addis Ababa, Ethiopia',
+  '+251911000001', 'ops@e2e-logistics.test', 'ethiopian', 'commercial',
+  '{"contactPersonName":"Test Contact","contactPersonPhone":"+251911000002","generalManagerName":"Test GM","generalManagerEmail":"gm@e2e-logistics.test","generalManagerPhone":"+251911000003"}'::jsonb
+WHERE NOT EXISTS (SELECT 1 FROM freight.companies WHERE tin = '0102030405');
+
+-- 2b. Approved importer profile (reference normally minted on approval).
+INSERT INTO freight.company_profiles (id, company_id, type, status, reference)
+SELECT gen_random_uuid(), c.id, 'importer', 'active', 'IMP-E2E-0001'
+FROM freight.companies c
+WHERE c.tin = '0102030405'
+  AND NOT EXISTS (
+    SELECT 1 FROM freight.company_profiles p
+    WHERE p.company_id = c.id AND p.type = 'importer'
+  );
+
+-- 2c. Link the demo portal user to the company, onboarding already done.
+INSERT INTO freight.external_profiles
+  (id, user_id, company_id, first_name, last_name, is_primary_contact,
+   active_profile_type, onboarding_step, onboarding_completed)
+SELECT gen_random_uuid(), u.id, c.id, 'Demo', 'User', true,
+  'importer', 'done', true
+FROM iam.users u
+JOIN freight.companies c ON c.tin = '0102030405'
+WHERE u.email = 'user@gmail.com'
+  AND NOT EXISTS (
+    SELECT 1 FROM freight.external_profiles ep WHERE ep.user_id = u.id
+  );
diff --git a/e2e/freight/cypress/fixtures/seed-users.sql b/e2e/freight/cypress/fixtures/seed-users.sql
new file mode 100644
index 000000000..5f42e3d5f
--- /dev/null
+++ b/e2e/freight/cypress/fixtures/seed-users.sql
@@ -0,0 +1,137 @@
+-- Test users for the freight e2e stack — replicates what the (disabled)
+-- FreightStaffUsersSeeder + DemoUsersSeeder would write, without touching
+-- API code. Idempotent: every insert is guarded by WHERE NOT EXISTS.
+--
+-- Prerequisites (created by the API's always-on boot seeders):
+--   iam.organizations key='edr_freight', iam.units key='edr_freight_app',
+--   iam.positions keys ceo/chief/director/marketer/operation/ethiopian_gl/djibouti_gl.
+--
+-- Passwords are pre-hashed (argon2id):
+--   staff  (@edr.local)  → password@tria
+--   demo   (gmail.com)   → 12345678
+
+-- ── Demo organization ────────────────────────────────────────────────────────
+insert into iam.organizations (id, name, key, is_super_admin, is_government_organization, status)
+select gen_random_uuid(), '{"en":"Demo IAM"}'::jsonb, 'demo_iam', false, true, 'Active'
+where not exists (select 1 from iam.organizations where key = 'demo_iam');
+
+-- ── Roles ────────────────────────────────────────────────────────────────────
+insert into iam.roles (id, key, name)
+select gen_random_uuid(), v.key, jsonb_build_object('en', v.name)
+from (values
+  ('edr_line_staff',         'edr_line_staff'),
+  ('edr_org_manager',        'edr_org_manager'),
+  ('edr_director',           'edr_director'),
+  ('edr_ceo',                'edr_ceo'),
+  ('edr_marketing',          'edr_marketing'),
+  ('edr_operations_officer', 'edr_operations_officer'),
+  ('edr_gl_ethiopia',        'edr_gl_ethiopia'),
+  ('edr_gl_djibouti',        'edr_gl_djibouti'),
+  ('demo_user1',             'Demo User1'),
+  ('demo_user2',             'Demo User2')
+) v(key, name)
+where not exists (select 1 from iam.roles r where r.key = v.key);
+
+-- ── Demo permissions + role grants ───────────────────────────────────────────
+insert into iam.permissions (id, key, name)
+select gen_random_uuid(), v.key, jsonb_build_object('en', v.name)
+from (values
+  ('can:demo:user1', 'Can access demo user1'),
+  ('can:demo:user2', 'Can access demo user2')
+) v(key, name)
+where not exists (select 1 from iam.permissions p where p.key = v.key);
+
+insert into iam.role_permissions (id, role_id, permission_id)
+select gen_random_uuid(), r.id, p.id
+from (values ('demo_user1', 'can:demo:user1'), ('demo_user2', 'can:demo:user2')) v(role_key, perm_key)
+join iam.roles r on r.key = v.role_key
+join iam.permissions p on p.key = v.perm_key
+where not exists (
+  select 1 from iam.role_permissions rp where rp.role_id = r.id and rp.permission_id = p.id
+);
+
+-- ── Users ────────────────────────────────────────────────────────────────────
+insert into iam.users (id, email, username, name, status, is_active, has_set_password, user_type)
+select gen_random_uuid(), v.email, v.username, jsonb_build_object('en', v.display),
+       'accepted', true, true, 'employee'
+from (values
+  ('linestaff@edr.local', 'linestaff', 'linestaff'),
+  ('chief@edr.local',     'chief',     'chief'),
+  ('director@edr.local',  'director',  'director'),
+  ('ceo@edr.local',       'ceo',       'ceo'),
+  ('marketer@edr.local',  'marketer',  'marketer'),
+  ('operation@edr.local', 'operation', 'operation'),
+  ('gl-et@edr.local',     'gl_et',     'gl_et'),
+  ('gl-dj@edr.local',     'gl_dj',     'gl_dj'),
+  ('user@gmail.com',      'user',      'Demo User 1'),
+  ('user2@gmail.com',     'user2',     'Demo User 2')
+) v(email, username, display)
+where not exists (select 1 from iam.users u where u.email = v.email);
+
+-- ── Credentials ──────────────────────────────────────────────────────────────
+insert into iam.user_credentials (id, user_id, password, is_active)
+select gen_random_uuid(), u.id,
+       case when u.email like '%@edr.local'
+         then '$argon2id$v=19$m=65536,t=3,p=4$JFEcHu4Kp55fsrVDPbHDPg$0NfnGzaE39T/qdmzte73oCkohC0Ri+f8DcrvAF4kyH4'  -- password@tria
+         else '$argon2id$v=19$m=65536,t=3,p=4$aBwVFf7I74pqSJqe9cBoig$gCIKa+6dCAb2X86G+0IjgPtil127cx6A6mwhvLj00Bw'  -- 12345678
+       end,
+       true
+from iam.users u
+where (u.email like '%@edr.local' or u.email in ('user@gmail.com', 'user2@gmail.com'))
+  and not exists (select 1 from iam.user_credentials c where c.user_id = u.id);
+
+-- ── User → role (staff under edr_freight, demo under demo_iam) ──────────────
+insert into iam.user_roles (id, user_id, role_id, organization_id)
+select gen_random_uuid(), u.id, r.id, o.id
+from (values
+  ('linestaff@edr.local', 'edr_line_staff',         'edr_freight'),
+  ('chief@edr.local',     'edr_org_manager',        'edr_freight'),
+  ('director@edr.local',  'edr_director',           'edr_freight'),
+  ('ceo@edr.local',       'edr_ceo',                'edr_freight'),
+  ('marketer@edr.local',  'edr_marketing',          'edr_freight'),
+  ('operation@edr.local', 'edr_operations_officer', 'edr_freight'),
+  ('gl-et@edr.local',     'edr_gl_ethiopia',        'edr_freight'),
+  ('gl-dj@edr.local',     'edr_gl_djibouti',        'edr_freight'),
+  ('user@gmail.com',      'demo_user1',             'demo_iam'),
+  ('user2@gmail.com',     'demo_user2',             'demo_iam')
+) v(email, role_key, org_key)
+join iam.users u on u.email = v.email
+join iam.roles r on r.key = v.role_key
+join iam.organizations o on o.key = v.org_key
+where not exists (select 1 from iam.user_roles ur where ur.user_id = u.id and ur.role_id = r.id);
+
+-- ── Staff employees + position assignment (drives permissions) ───────────────
+insert into iam.employees (id, is_current, status, name, organization_id, unit_id, user_id)
+select gen_random_uuid(), true, 'pending', u.name, o.id, un.id, u.id
+from iam.users u
+join iam.organizations o on o.key = 'edr_freight'
+join iam.units un on un.key = 'edr_freight_app' and un.organization_id = o.id
+where u.email like '%@edr.local'
+  and not exists (select 1 from iam.employees e where e.user_id = u.id);
+
+-- start_date must be set: the login query filters positions on
+-- start_date <= NOW(), and a NULL start_date silently drops the position
+-- (and with it every permission) from the JWT.
+insert into iam.employee_positions (id, is_delegate, is_current, status, start_date, unit_id, employee_id, position_id)
+select gen_random_uuid(), false, true, 'APPROVED', now() - interval '1 day', un.id, e.id, p.id
+from (values
+  ('linestaff@edr.local', 'operation'),
+  ('chief@edr.local',     'chief'),
+  ('director@edr.local',  'director'),
+  ('ceo@edr.local',       'ceo'),
+  ('marketer@edr.local',  'marketer'),
+  ('operation@edr.local', 'operation'),
+  ('gl-et@edr.local',     'ethiopian_gl'),
+  ('gl-dj@edr.local',     'djibouti_gl')
+) v(email, position_key)
+join iam.users u on u.email = v.email
+join iam.employees e on e.user_id = u.id
+join iam.units un on un.key = 'edr_freight_app'
+join iam.positions p on p.key = v.position_key and p.unit_id = un.id
+where not exists (
+  select 1 from iam.employee_positions ep where ep.employee_id = e.id and ep.position_id = p.id
+);
+
+-- Backfill for rows created before start_date was included above.
+update iam.employee_positions set start_date = now() - interval '1 day'
+where start_date is null;
diff --git a/e2e/freight/cypress/fixtures/users.json b/e2e/freight/cypress/fixtures/users.json
new file mode 100644
index 000000000..88c56149f
--- /dev/null
+++ b/e2e/freight/cypress/fixtures/users.json
@@ -0,0 +1,16 @@
+{
+  "staff": {
+    "lineStaff": { "email": "linestaff@edr.local", "role": "edr_line_staff" },
+    "chief": { "email": "chief@edr.local", "role": "edr_org_manager" },
+    "director": { "email": "director@edr.local", "role": "edr_director" },
+    "ceo": { "email": "ceo@edr.local", "role": "edr_ceo" },
+    "marketer": { "email": "marketer@edr.local", "role": "edr_marketing" },
+    "operation": { "email": "operation@edr.local", "role": "edr_operations_officer" },
+    "glEthiopia": { "email": "gl-et@edr.local", "role": "edr_gl_ethiopia" },
+    "glDjibouti": { "email": "gl-dj@edr.local", "role": "edr_gl_djibouti" }
+  },
+  "customers": {
+    "demo1": { "email": "user@gmail.com" },
+    "demo2": { "email": "user2@gmail.com" }
+  }
+}
diff --git a/e2e/freight/cypress/support/commands.ts b/e2e/freight/cypress/support/commands.ts
new file mode 100644
index 000000000..6a958d5be
--- /dev/null
+++ b/e2e/freight/cypress/support/commands.ts
@@ -0,0 +1,176 @@
+/**
+ * Auth model (see apps/edr-freight-api + freight web apps):
+ *  - POST {api}/api/auth/login  { email, password }
+ *    → flattened body { success, token, refreshToken } (response interceptor
+ *      flattens /api/auth responses — no .data nesting).
+ *  - Both web apps read cookies `auth-token` / `refresh-token` and attach
+ *    `Authorization: Bearer <token>`.
+ *  - Cookies are port-agnostic on localhost, so portal and backoffice share
+ *    one cookie jar. cy.session snapshots/restores cookies per session id,
+ *    which keeps staff and customer sessions from clobbering each other —
+ *    but inside a single test, switching apps requires re-invoking the
+ *    matching login command first (see flows specs).
+ */
+
+export interface LoginBody {
+  success: boolean;
+  token: string;
+  refreshToken: string;
+}
+
+const apiUrl = () => Cypress.env("apiUrl") as string;
+const password = () => Cypress.env("defaultPassword") as string;
+
+function apiLogin(email: string, pass?: string): Cypress.Chainable<LoginBody> {
+  return cy
+    .request<LoginBody>("POST", `${apiUrl()}/api/auth/login`, {
+      email,
+      password: pass ?? password(),
+    })
+    .then((response) => {
+      expect(response.status).to.eq(201);
+      expect(response.body.token, "login token").to.be.a("string");
+      return cy.wrap(response.body, { log: false });
+    });
+}
+
+function sessionFor(app: "backoffice" | "portal", email: string, pass?: string) {
+  cy.session(
+    [app, email],
+    () => {
+      apiLogin(email, pass).then(({ token, refreshToken }) => {
+        cy.setCookie("auth-token", token);
+        cy.setCookie("refresh-token", refreshToken);
+      });
+    },
+    {
+      cacheAcrossSpecs: true,
+      validate() {
+        cy.getCookie("auth-token").then((cookie) => {
+          expect(cookie, "auth-token cookie").to.exist;
+          cy.request({
+            url: `${apiUrl()}/api/me`,
+            headers: { Authorization: `Bearer ${cookie!.value}` },
+          })
+            .its("status")
+            .should("eq", 200);
+        });
+      },
+    },
+  );
+}
+
+Cypress.Commands.add("apiLogin", (email: string, pass?: string) => apiLogin(email, pass));
+
+Cypress.Commands.add("loginBackoffice", (email = "ceo@edr.local", pass?: string) => {
+  sessionFor("backoffice", email, pass);
+});
+
+Cypress.Commands.add("loginPortal", (email = "user@gmail.com", pass?: string) => {
+  // Demo portal users are seeded with a hardcoded password (DemoUsersSeeder),
+  // unlike staff users which use DEFAULT_PASSWORD.
+  sessionFor("portal", email, pass ?? (Cypress.env("demoPassword") as string));
+});
+
+Cypress.Commands.add("visitPortal", (path = "/") => {
+  cy.visit(`${Cypress.env("portalUrl")}${path}`);
+});
+
+/**
+ * Read the latest OTP the API generated for a contact. SMS/email delivery is
+ * disabled in e2e (RABBITMQ_ENABLED=false) but the code is still stored in
+ * freight.otp_verifications — keyed by normalized email (lowercased) or E.164
+ * phone. Polls because the row is written async to the UI action.
+ */
+Cypress.Commands.add("getOtp", (target: string) => {
+  const read = (attempt: number): Cypress.Chainable<string> =>
+    cy
+      .task<{ rows: Array<{ otp: string }> }>(
+        "db:query",
+        {
+          sql: `SELECT otp FROM freight.otp_verifications
+                WHERE email = $1 OR phone = $1
+                ORDER BY updated_at DESC LIMIT 1`,
+          params: [target],
+        },
+        { log: false },
+      )
+      .then((res) => {
+        if (res.rows.length > 0) return cy.wrap(res.rows[0].otp, { log: false });
+        expect(attempt, `OTP row for ${target}`).to.be.lessThan(20);
+        return cy.wait(500, { log: false }).then(() => read(attempt + 1));
+      });
+  return read(0);
+});
+
+/** Open a Mantine <Select> by its label and pick an option by exact text. */
+Cypress.Commands.add("mantineSelect", (label: string | RegExp, option: string | RegExp) => {
+  cy.contains("label", label)
+    .invoke("attr", "for")
+    .then((id) => {
+      cy.get(`[id="${id}"]`).click({ force: true });
+    });
+  cy.get('[role="option"]').contains(option).click();
+});
+
+/** Type a 6-digit code into a Mantine PinInput. */
+Cypress.Commands.add("typeOtp", (code: string) => {
+  cy.get(".mantine-PinInput-root input").should("have.length.at.least", code.length);
+  code.split("").forEach((digit, i) => {
+    cy.get(".mantine-PinInput-root input").eq(i).type(digit, { force: true });
+  });
+});
+
+/**
+ * Draw a squiggle on the signature-pad canvas (mouse events). When the account
+ * already has a saved signature the modal opens in "Approve signature" mode
+ * with no canvas — nothing to draw, the saved image is used as-is.
+ */
+Cypress.Commands.add("drawSignature", () => {
+  cy.get(".mantine-Modal-content").then(($modals) => {
+    if ($modals.find("canvas").length === 0) return;
+    drawOnCanvas();
+  });
+});
+
+function drawOnCanvas() {
+  cy.get(".mantine-Modal-content canvas")
+    .first()
+    .then(($canvas) => {
+      const rect = $canvas[0].getBoundingClientRect();
+      const midX = rect.left + rect.width / 2;
+      const midY = rect.top + rect.height / 2;
+      cy.wrap($canvas)
+        .trigger("mousedown", { clientX: midX - 60, clientY: midY, force: true })
+        .trigger("mousemove", { clientX: midX - 20, clientY: midY - 15, force: true })
+        .trigger("mousemove", { clientX: midX + 20, clientY: midY + 15, force: true })
+        .trigger("mousemove", { clientX: midX + 60, clientY: midY, force: true })
+        .trigger("mouseup", { force: true });
+    });
+}
+
+declare global {
+  // eslint-disable-next-line @typescript-eslint/no-namespace
+  namespace Cypress {
+    interface Chainable {
+      /** POST /api/auth/login, returns the flattened token body. */
+      apiLogin(email: string, pass?: string): Chainable<LoginBody>;
+      /** Cached programmatic staff session (default ceo@edr.local). */
+      loginBackoffice(email?: string, pass?: string): Chainable<void>;
+      /** Cached programmatic customer session (default user@gmail.com). */
+      loginPortal(email?: string, pass?: string): Chainable<void>;
+      /** cy.visit against the portal origin (env.portalUrl). */
+      visitPortal(path?: string): Chainable<void>;
+      /** Latest OTP stored for an email/phone (delivery is off in e2e). */
+      getOtp(target: string): Chainable<string>;
+      /** Open a Mantine Select by label, pick an option. */
+      mantineSelect(label: string | RegExp, option: string | RegExp): Chainable<void>;
+      /** Fill a Mantine PinInput with a code. */
+      typeOtp(code: string): Chainable<void>;
+      /** Scribble on the signature-pad canvas inside the open modal. */
+      drawSignature(): Chainable<void>;
+    }
+  }
+}
+
+export {};
diff --git a/e2e/freight/cypress/support/e2e.ts b/e2e/freight/cypress/support/e2e.ts
new file mode 100644
index 000000000..49bc8540b
--- /dev/null
+++ b/e2e/freight/cypress/support/e2e.ts
@@ -0,0 +1,18 @@
+import "./commands";
+
+// The API's user seeders are disabled in app code — the SQL fixture creates
+// the staff + demo test users instead. Idempotent, runs before each spec file.
+before(() => {
+  cy.task("db:seedUsers");
+});
+
+// Third-party noise (PostHog, Google Maps, socket.io reconnects) can throw
+// uncaught exceptions that are irrelevant to the assertion under test. App
+// errors still fail tests via failed assertions / failed intercepts.
+Cypress.on("uncaught:exception", (err) => {
+  const ignorable = [/posthog/i, /google/i, /websocket/i, /socket\.io/i, /ResizeObserver/i];
+  if (ignorable.some((pattern) => pattern.test(err.message))) {
+    return false;
+  }
+  return true;
+});
diff --git a/e2e/freight/package.json b/e2e/freight/package.json
new file mode 100644
index 000000000..4097b09da
--- /dev/null
+++ b/e2e/freight/package.json
@@ -0,0 +1,22 @@
+{
+  "name": "@edr/freight-e2e",
+  "version": "0.0.0",
+  "private": true,
+  "description": "Cypress end-to-end tests for the EDR freight system (portal + backoffice + API)",
+  "scripts": {
+    "cy:open": "cypress open --e2e",
+    "cy:run": "cypress run",
+    "cy:run:backoffice": "cypress run --spec 'cypress/e2e/backoffice/**'",
+    "cy:run:portal": "cypress run --spec 'cypress/e2e/portal/**'",
+    "cy:run:api": "cypress run --spec 'cypress/e2e/api/**'",
+    "cy:run:flows": "cypress run --spec 'cypress/e2e/flows/**'",
+    "type-check": "tsc --noEmit"
+  },
+  "devDependencies": {
+    "cypress": "^15.3.0",
+    "pg": "^8.13.0",
+    "typescript": "^5.5.4",
+    "@types/node": "^22.0.0",
+    "@types/pg": "^8.11.0"
+  }
+}
diff --git a/e2e/freight/scripts/e2e.mjs b/e2e/freight/scripts/e2e.mjs
new file mode 100644
index 000000000..81c8bf216
--- /dev/null
+++ b/e2e/freight/scripts/e2e.mjs
@@ -0,0 +1,193 @@
+#!/usr/bin/env node
+/**
+ * Freight e2e launcher — one command, no manual steps:
+ *
+ *   node e2e/freight/scripts/e2e.mjs <up|run|open|ci|down> [cypress args...]
+ *
+ * - run/open/ci auto-start the docker stack (build + wait healthy) if it
+ *   isn't already running, then launch Cypress pointed at the right ports.
+ * - Host ports default to 3101/5373/5383/5533/9310/9311; any default that is
+ *   busy is replaced by the next free port. Chosen ports are written to
+ *   e2e/freight/.e2e-ports.json (gitignored) and reused while the stack is
+ *   up, so cypress and compose always agree.
+ * - Extra args are forwarded to Cypress: `pnpm e2e:freight:run --spec ...`.
+ *
+ * No dependencies — plain Node, spawns `docker compose` and `pnpm`.
+ */
+
+import { execFileSync, spawnSync } from "node:child_process";
+import { existsSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { createServer } from "node:net";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const e2eDir = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+const repoRoot = resolve(e2eDir, "..", "..");
+const stateFile = join(e2eDir, ".e2e-ports.json");
+const composeBase = ["compose", "-f", join(repoRoot, "docker-compose.e2e.yaml")];
+
+const DEFAULT_PORTS = {
+  E2E_API_PORT: 3101,
+  E2E_PORTAL_PORT: 5373,
+  E2E_BACKOFFICE_PORT: 5383,
+  E2E_DB_PORT: 5533,
+  E2E_MINIO_PORT: 9310,
+  E2E_MINIO_CONSOLE_PORT: 9311,
+};
+
+// Long-running services that must be up before tests (minio-init exits).
+const SERVICES = [
+  "postgres-freight-e2e",
+  "minio-e2e",
+  "freight-api-e2e",
+  "freight-portal-e2e",
+  "freight-backoffice-e2e",
+];
+
+function fail(msg) {
+  console.error(`\ne2e: ${msg}`);
+  process.exit(1);
+}
+
+function preflight() {
+  try {
+    execFileSync("docker", ["info"], { stdio: "ignore" });
+  } catch {
+    fail("docker is not running (or not installed) — start Docker and retry.");
+  }
+  if (!existsSync(join(repoRoot, ".npmrc"))) {
+    fail(
+      ".npmrc missing at repo root — image builds need GitHub Packages auth " +
+        "for @tria-plc (same file the main docker-compose.yaml uses).",
+    );
+  }
+}
+
+function isPortFree(port) {
+  return new Promise((res) => {
+    const srv = createServer();
+    srv.once("error", () => res(false));
+    srv.once("listening", () => srv.close(() => res(true)));
+    srv.listen(port);
+  });
+}
+
+function stackRunning(env) {
+  try {
+    const out = execFileSync(
+      "docker",
+      [...composeBase, "ps", "--services", "--status", "running"],
+      { encoding: "utf8", env, stdio: ["ignore", "pipe", "ignore"] },
+    );
+    const running = new Set(out.split("\n").filter(Boolean));
+    return SERVICES.every((s) => running.has(s));
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * While the stack runs, ports are whatever it was started with (state file,
+ * else the defaults — a hand-started stack used the compose defaults). Only a
+ * fresh start gets to scan for free ports.
+ */
+async function resolvePorts() {
+  if (stackRunning(process.env)) {
+    return existsSync(stateFile)
+      ? JSON.parse(readFileSync(stateFile, "utf8"))
+      : { ...DEFAULT_PORTS };
+  }
+  const ports = {};
+  const taken = new Set();
+  for (const [name, preferred] of Object.entries(DEFAULT_PORTS)) {
+    let port = preferred;
+    while (taken.has(port) || !(await isPortFree(port))) port += 1;
+    taken.add(port);
+    ports[name] = port;
+    if (port !== preferred)
+      console.log(`e2e: port ${preferred} busy → ${name}=${port}`);
+  }
+  return ports;
+}
+
+function envFor(ports) {
+  return {
+    ...process.env,
+    ...Object.fromEntries(
+      Object.entries(ports).map(([k, v]) => [k, String(v)]),
+    ),
+    CYPRESS_BASE_URL: `http://localhost:${ports.E2E_BACKOFFICE_PORT}`,
+    CYPRESS_API_URL: `http://localhost:${ports.E2E_API_PORT}`,
+    CYPRESS_PORTAL_URL: `http://localhost:${ports.E2E_PORTAL_PORT}`,
+    E2E_DB_URL: `postgres://edr_e2e:edr_e2e@localhost:${ports.E2E_DB_PORT}/edr_freight_e2e`,
+  };
+}
+
+function compose(args, env) {
+  const { status } = spawnSync("docker", [...composeBase, ...args], {
+    stdio: "inherit",
+    env,
+  });
+  return status ?? 1;
+}
+
+function up(ports, env) {
+  preflight();
+  console.log(
+    `e2e: starting stack — api :${ports.E2E_API_PORT}  portal :${ports.E2E_PORTAL_PORT}  backoffice :${ports.E2E_BACKOFFICE_PORT}  db :${ports.E2E_DB_PORT}`,
+  );
+  const status = compose(["up", "-d", "--build", "--wait"], env);
+  if (status !== 0)
+    fail(
+      "stack failed to become healthy. Inspect with:\n" +
+        "  docker compose -f docker-compose.e2e.yaml logs freight-api-e2e",
+    );
+  writeFileSync(stateFile, JSON.stringify(ports, null, 2) + "\n");
+}
+
+function ensureUp(ports, env) {
+  if (stackRunning(env)) return;
+  up(ports, env);
+}
+
+function runPnpm(script, extra, env) {
+  const { status } = spawnSync(
+    "pnpm",
+    ["--filter", "@edr/freight-e2e", "run", script, ...extra],
+    { cwd: repoRoot, stdio: "inherit", env },
+  );
+  process.exit(status ?? 1);
+}
+
+const [cmd, ...extra] = process.argv.slice(2);
+const ports = await resolvePorts();
+const env = envFor(ports);
+
+switch (cmd) {
+  case "up":
+    up(ports, env);
+    break;
+  case "run":
+    ensureUp(ports, env);
+    runPnpm("cy:run", extra, env);
+    break;
+  case "open":
+    ensureUp(ports, env);
+    runPnpm("cy:open", extra, env);
+    break;
+  case "ci":
+    ensureUp(ports, env);
+    process.exit(compose(["--profile", "cypress", "run", "--rm", "cypress", ...extra], env));
+    break;
+  case "down":
+    process.exit(
+      (() => {
+        const status = compose(["down", "-v", "--remove-orphans"], env);
+        rmSync(stateFile, { force: true });
+        return status;
+      })(),
+    );
+    break;
+  default:
+    fail(`unknown command "${cmd ?? ""}" — use up | run | open | ci | down`);
+}
diff --git a/e2e/freight/tsconfig.json b/e2e/freight/tsconfig.json
new file mode 100644
index 000000000..c2b049986
--- /dev/null
+++ b/e2e/freight/tsconfig.json
@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "lib": ["ES2022", "DOM"],
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "skipLibCheck": true,
+    "esModuleInterop": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noEmit": true,
+    "types": ["cypress", "node"]
+  },
+  "include": ["cypress/**/*.ts", "cypress.config.ts"]
+}
diff --git a/package.json b/package.json
index 8909de6cf..193732907 100644
--- a/package.json
+++ b/package.json
@@ -23,6 +23,11 @@
     "format": "prettier --write \"**/*.{ts,tsx,json,md}\"",
     "docker:build": "docker compose build",
     "docker:up": "docker compose up -d",
+    "e2e:freight:up": "node e2e/freight/scripts/e2e.mjs up",
+    "e2e:freight:open": "node e2e/freight/scripts/e2e.mjs open",
+    "e2e:freight:run": "node e2e/freight/scripts/e2e.mjs run",
+    "e2e:freight:ci": "node e2e/freight/scripts/e2e.mjs ci",
+    "e2e:freight:down": "node e2e/freight/scripts/e2e.mjs down",
     "prepare": "husky"
   },
   "devDependencies": {
diff --git a/packages/types/src/freight/contracts.ts b/packages/types/src/freight/contracts.ts
index f803c42d3..f30ee6469 100644
--- a/packages/types/src/freight/contracts.ts
+++ b/packages/types/src/freight/contracts.ts
@@ -534,6 +534,7 @@ export const INCIDENT_TYPES = [
   "CONTAINER_OPENED",
   "CONTAINER_DAMAGED",
   "FLUID_LEAKING",
+  "OTHER",
 ] as const;
 export type IncidentType = (typeof INCIDENT_TYPES)[number];
 
@@ -674,6 +675,18 @@ export interface IContract extends BaseEntity {
    * exactly what to fix before resubmitting.
    */
   latestChangeRequestNote?: string | null;
+  /**
+   * Body of the latest REJECTION review note (detail response only, when
+   * status is REJECTED). Shows staff and customer why the contract was
+   * rejected.
+   */
+  latestRejectionNote?: string | null;
+  /**
+   * Body of the latest send-back STAFF_NOTE (detail response only, while the
+   * contract is PENDING_APPROVAL and no step has acted since the send-back).
+   * Tells the returned-to approver why the chain came back to them.
+   */
+  latestSendBackNote?: string | null;
   clearanceStatus: ContractClearanceStatus;
   clearanceCycleNumber: number;
   /**
diff --git a/packages/types/src/freight/index.ts b/packages/types/src/freight/index.ts
index be13ed349..2fe24773f 100644
--- a/packages/types/src/freight/index.ts
+++ b/packages/types/src/freight/index.ts
@@ -546,6 +546,7 @@ export interface ICustomerTruck {
   truckType: string;
   assignedAt: string;
   arrivedAt?: string | null;
+  departedAt?: string | null;
   containers?: ICustomerTruckContainer[];
 }
 
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index f59a388ba..72daf6a26 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -580,7 +580,7 @@ importers:
         version: 5.101.0(react@19.2.6)
       '@tria-plc/iamui':
         specifier: file:../../../local-packages/tria-plc-iamui-0.1.1.tgz
-        version: file:local-packages/tria-plc-iamui-0.1.1.tgz(0ce39b7e349029277dcd938d06eeb0f7)
+        version: file:local-packages/tria-plc-iamui-0.1.1.tgz(a5d0bdee55164ae56064fb273b530e00)
       '@vis.gl/react-google-maps':
         specifier: ^1.8.3
         version: 1.8.3(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
@@ -1203,6 +1203,24 @@ importers:
         specifier: ^5.5.4
         version: 5.9.3
 
+  e2e/freight:
+    devDependencies:
+      '@types/node':
+        specifier: ^22.0.0
+        version: 22.20.1
+      '@types/pg':
+        specifier: ^8.11.0
+        version: 8.20.0
+      cypress:
+        specifier: ^15.3.0
+        version: 15.18.1
+      pg:
+        specifier: ^8.13.0
+        version: 8.21.0
+      typescript:
+        specifier: ^5.5.4
+        version: 5.9.3
+
   packages/api-common:
     dependencies:
       '@edr/types':
@@ -1743,6 +1761,13 @@ packages:
     resolution: {integrity: sha512-Vd/9EVDiu6PPJt9yAh6roZP6El1xHrdvIVGjyBsHR0RYwNHgL7FJPyIIW4fANJNG6FtyZfvlRPpFI4ZM/lubvw==}
     engines: {node: '>=18'}
 
+  '@cypress/request@4.0.1':
+    resolution: {integrity: sha512-y20e+e6dFYkOUUJLVUZTsJRuTiXZaUQ32WD+R/ux/HBybbTx4ge7cNINcua0pU8+SNkKuRbOF12mBmzuzM8n5w==}
+    engines: {node: '>= 14.17.0'}
+
+  '@cypress/xvfb@1.2.4':
+    resolution: {integrity: sha512-skbBzPggOVYCbnGgV+0dmBdW/s77ZkAOXIC1knS8NagwDjBrNC1LuXtQJeiN6l+m7lzmHtaoUw/ctJKdqkG57Q==}
+
   '@date-fns/tz@1.5.0':
     resolution: {integrity: sha512-lwYN/vDPeNRULcepoE/LO2Pgx+7/RV+S9ARfbc9lr2DtGkOD7pAiruHvbR1RX3Qyf6ja47EWJDMsNK5vK08DJg==}
 
@@ -4702,6 +4727,9 @@ packages:
   '@types/node@20.19.42':
     resolution: {integrity: sha512-5L7SUaFC1RyDraj2yRhyBzHTobyXHmohD100CChNtyPyleoq37Mqab5Gn8XEKI04dfN/oqPdpHk38MgcQWHbZg==}
 
+  '@types/node@22.20.1':
+    resolution: {integrity: sha512-EANqOCF9QFyra+4pfxUcX9STKJpCLjMbObVzljIJomAWSnuSIEAvyzEU53GaajbXJEgdh0iEcPL+DGvpUd4k1Q==}
+
   '@types/node@24.13.1':
     resolution: {integrity: sha512-RSpUJGmvsJ1ZeBehQZFhIdpsz+bIpES0nIQXko4Ybq+N+kX6XvOq3Jo+iJ82FWLdblFq85AsMikd3m35jgezYg==}
 
@@ -4760,6 +4788,9 @@ packages:
   '@types/signature_pad@2.3.6':
     resolution: {integrity: sha512-v3j92gCQJoxomHhd+yaG4Vsf8tRS/XbzWKqDv85UsqjMGy4zhokuwKe4b6vhbgncKkh+thF+gpz6+fypTtnFqQ==}
 
+  '@types/sinonjs__fake-timers@8.1.1':
+    resolution: {integrity: sha512-0kSuKjAS0TrGLJ0M/+8MaFkGsQhZpB6pxOmvS3K8FYI72K//YmdfoW9X2qPsAKh1mkwxGD5zib9s1FIFed6E8g==}
+
   '@types/sizzle@2.3.10':
     resolution: {integrity: sha512-TC0dmN0K8YcWEAEfiPi5gJP14eJe30TTGjkvek3iM/1NdHHsdCA/Td6GvNndMOo/iSnIsZ4HuuhrYPDAmbxzww==}
 
@@ -4778,6 +4809,9 @@ packages:
   '@types/tinymce@4.6.9':
     resolution: {integrity: sha512-pDxBUlV4v1jgJ97SlnVOSyf3KUy3OQ3s5Ddpfh1L9M5lXlBmX7TJ2OLSozx1WBxp91acHvYPWDwz2U/kMM1oxQ==}
 
+  '@types/tmp@0.2.6':
+    resolution: {integrity: sha512-chhaNf2oKHlRkDGt+tiKE2Z5aJ6qalm7Z9rlLdBwmOiAAf09YQvvoLXjWK4HWPF1xU/fqvMgfNfpVoBscA/tKA==}
+
   '@types/trusted-types@2.0.7':
     resolution: {integrity: sha512-ScaPdn1dQczgbl0QFTeTOmVHFULt394XJgOQNoyVhZ6r2vLnMLJfBPd53SB52T/3G36VI1/g2MZaX0cwDuXsfw==}
 
@@ -5372,6 +5406,9 @@ packages:
   append-field@1.0.0:
     resolution: {integrity: sha512-klpgFSWLW1ZEs8svjfb7g4qWY0YS5imI82dTg+QahUvJ8YqAY0P10Uk8tTyh9ZGuYEZEMaeJYCF5BFuX552hsw==}
 
+  arch@2.2.0:
+    resolution: {integrity: sha512-Of/R0wqp83cgHozfIYLbBMnej79U/SVGOOyuB3VVFv1NRM/PSFMK12x9KVtiYzJqmnU5WR2qp0Z5rHb7sWGnFQ==}
+
   archiver-utils@2.1.0:
     resolution: {integrity: sha512-bEL/yUb/fNNiNTuUz979Z0Yg5L+LzLxGJz8x79lYmR54fmTIb6ob/hNQgkQnIUDWIFjZVQwl9Xs356I6BAMHfw==}
     engines: {node: '>= 6'}
@@ -5472,6 +5509,13 @@ packages:
   asap@2.0.6:
     resolution: {integrity: sha512-BSHWgDSAiKs50o2Re8ppvp3seVHXSRM44cdSsT9FfNEUUZLOGWVCsiWaRPWM1Znn+mqZ1OfVZ3z3DWEzSp7hRA==}
 
+  asn1@0.2.6:
+    resolution: {integrity: sha512-ix/FxPn0MDjeyJ7i/yoHGFt/EX6LyNbxSEhPPXODPL+KB0VPk86UYfL0lMdy+KCnv+fmvIzySwaK5COwqVbWTQ==}
+
+  assert-plus@1.0.0:
+    resolution: {integrity: sha512-NfJ4UzBCcQGLDlQq7nHxH+tv3kyZ0hHQqF5BO6J7tNJeP5do1llPr8dZ8zHonfhAu0PHAdMkSo+8o0wxg9lZWw==}
+    engines: {node: '>=0.8'}
+
   assertion-error@2.0.1:
     resolution: {integrity: sha512-Izi8RQcffqCeNVgFigKli1ssklIbpHnCYc6AknXGYoB6grJqyeby7jv12JUQgmTAnIDnbck1uxksT4dzN3PWBA==}
     engines: {node: '>=12'}
@@ -5504,6 +5548,10 @@ packages:
   asynckit@0.4.0:
     resolution: {integrity: sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==}
 
+  at-least-node@1.0.0:
+    resolution: {integrity: sha512-+q/t7Ekv1EDY2l6Gda6LLiX14rU9TV20Wa3ofeQmwPFZbOMo9DXrLbOjFaaclkXKWidIaopwAObQDqwWtGUjqg==}
+    engines: {node: '>= 4.0.0'}
+
   atob@2.1.2:
     resolution: {integrity: sha512-Wm6ukoaOGJi/73p/cl2GvLjTI5JM1k/O14isD73YML8StrH/7/lRFgmg8nICZgD3bZZvjwCGxtMOD3wWNAu8cg==}
     engines: {node: '>= 4.5.0'}
@@ -5527,6 +5575,12 @@ packages:
     resolution: {integrity: sha512-wvUjBtSGN7+7SjNpq/9M2Tg350UZD3q62IFZLbRAR1bSMlCo1ZaeW+BJ+D090e4hIIZLBcTDWe4Mh4jvUDajzQ==}
     engines: {node: '>= 0.4'}
 
+  aws-sign2@0.7.0:
+    resolution: {integrity: sha512-08kcGqnYf/YmjoRhfxyu+CLxBjUtHLXLXX/vUfx9l2LYzG3c1m61nrpyFUZI6zeS+Li/wWMMidD9KgrqtGq3mA==}
+
+  aws4@1.13.2:
+    resolution: {integrity: sha512-lHe62zvbTB5eEABUVi/AwVh0ZKY9rMMDhmm+eeyuuUQbQ3+J+fONVQOZyj+DdrvD4BY33uYniyRJ4UJIaSKAfw==}
+
   axe-core@4.12.0:
     resolution: {integrity: sha512-FTavr/7Ba0IptwGOPxnQvdyW2tAsdLBMTBXz7rKH6xJ2skpyxpBxyHkDdBs4lf69yRqYpkqCdfhnwS8YULGOmg==}
     engines: {node: '>=4'}
@@ -5663,6 +5717,9 @@ packages:
     resolution: {integrity: sha512-bopVNp6ugyA150DDuZfPFdt1KZ5a94ZDiwX4hMgZDzF+GttD80lEy8kj98kbyhLXnPvhtIo93mdnLIjpCAeeOw==}
     engines: {node: '>=10.0.0'}
 
+  bcrypt-pbkdf@1.0.2:
+    resolution: {integrity: sha512-qeFIXtP4MSoi6NLqO12WfqARWWuCKi2Rn/9hJLEmtB5yTNr9DqFWkJRCf2qShWzPeAMRnOgCrq0sg/KLv5ES9w==}
+
   bcrypt@6.0.0:
     resolution: {integrity: sha512-cU8v/EGSrnH+HnxV2z0J7/blxH8gq7Xh2JFT6Aroax7UohdmiJJlxApMxtKfuI7z68NvvVcmR78k2LbT6efhRg==}
     engines: {node: '>= 18'}
@@ -5684,12 +5741,18 @@ packages:
   bl@4.1.0:
     resolution: {integrity: sha512-1W07cM9gS6DcLperZfFSj+bWLtaPGSOHWhPiGzXmvVJbRLdG82sH/Kn8EtW1VqWVA54AKf2h5k5BbnIbwF3h6w==}
 
+  blob-util@2.0.2:
+    resolution: {integrity: sha512-T7JQa+zsXXEa6/8ZhHcQEW1UFfVM49Ts65uBkFL6fz2QmrElqmbajIDJvuA0tEhRe5eIjpV9ZF+0RfZR9voJFQ==}
+
   block-stream2@2.1.0:
     resolution: {integrity: sha512-suhjmLI57Ewpmq00qaygS8UgEq2ly2PCItenIyhMqVjo4t4pGzqMvfgJuX8iWTeSDdfSSqS6j38fL4ToNL7Pfg==}
 
   bluebird@3.4.7:
     resolution: {integrity: sha512-iD3898SR7sWVRHbiQv+sHUtHnMvC1o3nW5rAcqnq3uOn07DSAppZYUkIGslDz6gXC7HfunPe7YVBgoEJASPcHA==}
 
+  bluebird@3.7.2:
+    resolution: {integrity: sha512-XpNj6GDQzdfW+r2Wnn7xiSAd7TM3jzkxGXBGTtWKuSXv1xUV+azxAm8jdWZN06QTQk+2N2XB9jRDkvbmQmcRtg==}
+
   body-parser@1.20.5:
     resolution: {integrity: sha512-3grm+/2tUOvu2cjJkvsIxrv/wVpfXQW4PsQHYm7yk4vfpu7Ekl6nEsYBoJUL6qDwZUx8wUhQ8tR2qz+ad9c9OA==}
     engines: {node: '>= 0.8', npm: 1.2.8000 || >= 1.4.16}
@@ -5794,6 +5857,10 @@ packages:
     resolution: {integrity: sha512-AKcdTnFSWATd5/GCPRxr2ChwIJ85CeyrEyjRHlKxQ56d4XJMGym0uAiKn0xbLOGOl3+yRpOTi484dVCEc5AUzQ==}
     engines: {node: '>=0.10.0'}
 
+  cachedir@2.4.0:
+    resolution: {integrity: sha512-9EtFOZR8g22CL7BWjJ9BUx1+A/djkofnyW3aOXZORNW2kxoUpx2h+uN2cOqwPmFhnpVmxg+KW2OjOSgChTEvsQ==}
+    engines: {node: '>=6'}
+
   call-bind-apply-helpers@1.0.2:
     resolution: {integrity: sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==}
     engines: {node: '>= 0.4'}
@@ -5832,6 +5899,9 @@ packages:
     resolution: {integrity: sha512-5ON+q7jCTgMp9cjpu4Jo6XbvfYwSB2Ow3kzHKfIyJfaCAOHLbdKPQqGKgfED/R5B+3TFFfe8pegYA+b423SRyA==}
     engines: {node: '>=10.0.0'}
 
+  caseless@0.12.0:
+    resolution: {integrity: sha512-4tYFyifaFfGacoiObjJegolkwSU4xQNGbVgUiNYVUxbQ2x2lUsFvY4hVgVzGiIe6WLOPqycWXA40l+PWsxthUw==}
+
   cfb@1.2.2:
     resolution: {integrity: sha512-KfdUZsSOw19/ObEWasvBP/Ac4reZvAGauZhs6S/gqNhXhI7cKwvlH7ulj+dOEYnca4bm4SGo8C1bTAQvnTjgQA==}
     engines: {node: '>=0.8'}
@@ -5890,6 +5960,10 @@ packages:
     resolution: {integrity: sha512-NIxF55hv4nSqQswkAeiOi1r83xy8JldOFDTWiug55KBu9Jnblncd2U6ViHmYgHf01TPZS77NJBhBMKdWj9HQMQ==}
     engines: {node: '>=8'}
 
+  ci-info@4.4.0:
+    resolution: {integrity: sha512-77PSwercCZU2Fc4sX94eF8k8Pxte6JAwL4/ICZLFjJLqegs7kCuAsqqj/70NQF6TvDpgFjkubQB2FW2ZZddvQg==}
+    engines: {node: '>=8'}
+
   citty@0.1.6:
     resolution: {integrity: sha512-tskPPKEs8D2KPafUypv2gxwJP8h/OaJmC82QQGGDQcHvXX43xF2VDACcJVmZ0EuSxkpO9Kc4MlrA3q0+FG58AQ==}
 
@@ -5931,6 +6005,10 @@ packages:
     resolution: {integrity: sha512-ywqV+5MmyL4E7ybXgKys4DugZbX0FC6LnwrhjuykIjnK9k8OQacQ7axGKnjDXWNhns0xot3bZI5h55H8yo9cJg==}
     engines: {node: '>=6'}
 
+  cli-table3@0.6.1:
+    resolution: {integrity: sha512-w0q/enDHhPLq44ovMGdQeeDLvwxwavsJX7oQGYt/LrBlYsyaxyDnp6z3QzFut/6kLLKnlcUVJLrpB7KBfgG/RA==}
+    engines: {node: 10.* || >= 12.*}
+
   cli-table3@0.6.5:
     resolution: {integrity: sha512-+W/5efTR7y5HRD7gACw9yQjqMVvEMLBHmboM/kPWam+H+Hmyrgjh6YncVKK122YZkXrLudzTuAukUw9FnMf7IQ==}
     engines: {node: 10.* || >= 12.*}
@@ -5939,6 +6017,10 @@ packages:
     resolution: {integrity: sha512-nPdaFdQ0h/GEigbPClz11D0v/ZJEwxmeVZGeMo3Z5StPtUTkA9o1lD6QwoirYiSDzbcwn2XcjwmCp68W1IS4TA==}
     engines: {node: '>=18'}
 
+  cli-truncate@5.2.0:
+    resolution: {integrity: sha512-xRwvIOMGrfOAnM1JYtqQImuaNtDEv9v6oIYAs4LIHwTiKee8uwvIi363igssOC0O5U04i4AlENs79LQLu9tEMw==}
+    engines: {node: '>=20'}
+
   cli-width@1.1.1:
     resolution: {integrity: sha512-eMU2akIeEIkCxGXUNmDnJq1KzOIiPnJ+rKqRe6hcxE3vIOPvpMrBYOn/Bl7zNlYJj/zQxXquAnozHUCf9Whnsg==}
 
@@ -6022,6 +6104,10 @@ packages:
     resolution: {integrity: sha512-pFGrxThWcWQ2MsAz6RtgeWe4NK2kUE1WfsrvvlctdII745EW9I0yflqhe7++M5LEc7bV2c/9/5zc8sFcpL0Drw==}
     engines: {node: '>=0.1.90'}
 
+  colors@1.4.0:
+    resolution: {integrity: sha512-a+UqTh4kgZg/SlGvfbzDHpgRu7AAQOmmqRHJnxhRZICKFUT91brVhNNt58CMWU9PsBbv3PDCZUHbVxuDiH2mtA==}
+    engines: {node: '>=0.1.90'}
+
   combined-stream@1.0.8:
     resolution: {integrity: sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==}
     engines: {node: '>= 0.8'}
@@ -6045,10 +6131,18 @@ packages:
     resolution: {integrity: sha512-NOKm8xhkzAjzFx8B2v5OAHT+u5pRQc2UCa2Vq9jYL/31o2wi9mxBA7LIFs3sV5VSC49z6pEhfbMULvShKj26WA==}
     engines: {node: '>= 6'}
 
+  commander@6.2.1:
+    resolution: {integrity: sha512-U7VdrJFnJgo4xjrHpTzu0yrHPGImdsmD95ZlgYSEajAn2JKzDhDTPG9kBTefmObL2w/ngeZnilk+OV9CG3d7UA==}
+    engines: {node: '>= 6'}
+
   comment-json@5.0.0:
     resolution: {integrity: sha512-uiqLcOiVDJtBP8WGkZHEP+FZIhTzP1dxvn59EfoYUi9gqupjrBWVQkO2atDrbnKPwLeotFYDsuNb26uBMqB+hw==}
     engines: {node: '>= 6'}
 
+  common-tags@1.8.2:
+    resolution: {integrity: sha512-gk/Z852D2Wtb//0I+kRFNKKE9dIIVirjoqPoA1wJU+XePVXZfGeBpk45+A1rKO4Q43prqWBNY/MiIeRLbPWUaA==}
+    engines: {node: '>=4.0.0'}
+
   compare-func@2.0.0:
     resolution: {integrity: sha512-zHig5N+tPWARooBnb0Zx1MFcdfpyJrfTJ3Y5L+IFvUm8rM74hHz66z0gw0x4tijh5CorKkKUCnW82R2vmpeCRA==}
 
@@ -6140,6 +6234,9 @@ packages:
   core-js@3.49.0:
     resolution: {integrity: sha512-es1U2+YTtzpwkxVLwAFdSpaIMyQaq0PBgm3YD1W3Qpsn1NAmO3KSgZfu+oGSWVu6NvLHoHCV/aYcsE5wiB7ALg==}
 
+  core-util-is@1.0.2:
+    resolution: {integrity: sha512-3lqz5YjWTYnW6dlDa5TLaTCcShfar1e40rmcJVwCBJC6mWlFuj0eCHIElmG1g5kyuJ/GD+8Wn4FFCcz4gJPfaQ==}
+
   core-util-is@1.0.3:
     resolution: {integrity: sha512-ZQBvi1DcpJ4GDqanjucZ2Hj3wEO5pZDS89BWbkcrvdxksJorwUDDZamX9ldFkp9aw2lmBDLgkObEA4DWNJ9FYQ==}
 
@@ -6254,6 +6351,11 @@ packages:
     resolution: {integrity: sha512-TVF6svNzeQCOpjCqsy0/CSy8VgObG3wXusJ73xW2GbG5rGx7lC8zxDSURicsXI2UsGdi2L0QNRCi745/wUDvsA==}
     engines: {node: '>=0.4.0'}
 
+  cypress@15.18.1:
+    resolution: {integrity: sha512-JtkTVtUE2lvLYgZCaug+Uai0H9IqsJirlBO49c87QwG0bJUGvAUVBz1EJve0b0oaYP244Ew9M0BkrHpcqkYxmw==}
+    engines: {node: ^20.1.0 || ^22.0.0 || >=24.0.0}
+    hasBin: true
+
   d3-array@3.2.4:
     resolution: {integrity: sha512-tdQAmyA18i4J7wprpYq8ClcxZy3SC31QMeByyCFyRt7BVHdREQZ5lpzoe5mFEYZUWe+oq8HBvk9JjpibyEV4Jg==}
     engines: {node: '>=12'}
@@ -6305,6 +6407,10 @@ packages:
     resolution: {integrity: sha512-wAV9QHOsNbwnWdNW2FYvE1P56wtgSbM+3SZcdGiWQILwVjACCXDCI3Ai8QlCjMDB8YK5zySiXZYBiwGmNY3lnw==}
     engines: {node: '>=12'}
 
+  dashdash@1.14.1:
+    resolution: {integrity: sha512-jRFi8UDGo6j+odZiEpjazZaWqEal3w/basFjQHQEwVtZJGDpxbH1MeYluwCS8Xq5wmLJooDlMgvVarmWfGM44g==}
+    engines: {node: '>=0.10'}
+
   data-uri-to-buffer@4.0.1:
     resolution: {integrity: sha512-0R9ikRb668HB7QDxT1vkpuUBtqc53YyAwMwGeUFKRojY/NWKvdZ+9UYtRfGmhqNbRkTSVpMbmyhXipFFv2cb/A==}
     engines: {node: '>= 12'}
@@ -6587,6 +6693,9 @@ packages:
   ebec@2.3.0:
     resolution: {integrity: sha512-bt+0tSL7223VU3PSVi0vtNLZ8pO1AfWolcPPMk2a/a5H+o/ZU9ky0n3A0zhrR4qzJTN61uPsGIO4ShhOukdzxA==}
 
+  ecc-jsbn@0.1.2:
+    resolution: {integrity: sha512-eh9O+hwRHNbG4BLTjEl3nw044CkGm5X6LoaCf7LPp7UU8Qrt47JYNi6nPX8xjW97TKGKm1ouctg0QSpZe9qrnw==}
+
   ecdsa-sig-formatter@1.0.11:
     resolution: {integrity: sha512-nagl3RYrbNv6kQkeJIpt6NJZy8twLB/2vtz6yN9Z4vRKHN4/QZJIEbqohALSgwKdnksuY3k5Addp5lg8sVoVcQ==}
 
@@ -6913,6 +7022,9 @@ packages:
     resolution: {integrity: sha512-i/2XbnSz/uxRCU6+NdVJgKWDTM427+MqYbkQzD321DuCQJUqOuJKIA0IM2+W2xtYHdKOmZ4dR6fExsd4SXL+WQ==}
     engines: {node: '>=6'}
 
+  eventemitter2@6.4.7:
+    resolution: {integrity: sha512-tYUSVOGeQPKt/eC1ABfhHy5Xd96N3oIijJvN3O9+TsC28T5V9yX9oEfEK5faP0EFSNVOG97qtAS68GBrQB2hDg==}
+
   eventemitter2@6.4.9:
     resolution: {integrity: sha512-JEPTiaOt9f04oa6NOkc4aH+nVp5I3wEjpHbIPqfgCdD5v5bUzy7xQqwcVO2aDQgOWhI28da57HksMrzK9HlRxg==}
 
@@ -6941,6 +7053,10 @@ packages:
     resolution: {integrity: sha512-XctvKaEMaj1Ii9oDOqbW/6e1gXknSY4g/aLCDicOXqBE4M0nRWkUu0PTp++UPNzoFY12BNHMfs/VadKIS6llvg==}
     engines: {node: '>=8.3.0'}
 
+  execa@4.1.0:
+    resolution: {integrity: sha512-j5W0//W7f8UxAn8hXVnwG8tLwdiUy4FJLcSupCg6maBYZDpyBvTApK7KyuI4bKj8KOh1r2YH+6ucuYtJv1bTZA==}
+    engines: {node: '>=10'}
+
   execa@5.1.1:
     resolution: {integrity: sha512-8uSpZZocAZRBAPIEINJj3Lo9HyGitllczc27Eh5YYojjMFMn8yHMDMaUHE2Jqfq05D/wucwI4JGURyXt1vchyg==}
     engines: {node: '>=10'}
@@ -6953,6 +7069,10 @@ packages:
     resolution: {integrity: sha512-9Be3ZoN4LmYR90tUoVu2te2BsbzHfhJyfEiAVfz7N5/zv+jduIfLrV2xdQXOHbaD6KgpGdO9PRPM1Y4Q9QkPkA==}
     engines: {node: ^18.19.0 || >=20.5.0}
 
+  executable@4.1.1:
+    resolution: {integrity: sha512-8iA79xD3uAch729dUG8xaaBBFGaEa0wdD2VkYLFHwlqosEj/jT66AzcreRDSgV7ehnNLBW2WR5jIXwGKjVdTLg==}
+    engines: {node: '>=4'}
+
   exit-hook@1.1.1:
     resolution: {integrity: sha512-MsG3prOVw1WtLXAZbM3KiYtooKR1LvxHh3VHsVtIy0uiUu8usxgB/94DP2HxtD/661lLdB6yzQ09lGJSQr6nkg==}
     engines: {node: '>=0.10.0'}
@@ -6998,6 +7118,9 @@ packages:
     resolution: {integrity: sha512-BwY5b5Ql4+qZoefgMj2NUmx+tehVTH/Kf4k1ZEtOHNFcm2wSxMRo992l6X3TIgni2eZVTZ85xMOjF31fwZAj6Q==}
     engines: {node: '>=0.10.0'}
 
+  extend@3.0.2:
+    resolution: {integrity: sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g==}
+
   extglob@2.0.4:
     resolution: {integrity: sha512-Nmb6QXkELsuBr24CJSkilo6UHHgbekK5UiZgfE6UHD3Eb27YC6oD+bhcT+tJ6cl8dmsgdQxnWlcry8ksBIBLpw==}
     engines: {node: '>=0.10.0'}
@@ -7007,6 +7130,10 @@ packages:
     engines: {node: '>= 10.17.0'}
     hasBin: true
 
+  extsprintf@1.3.0:
+    resolution: {integrity: sha512-11Ndz7Nv+mvAC1j0ktTa7fAb0vLyGGX+rMHNBYQviQDGU0Hw7lhctJANqbPhu9nV9/izT/IntTgZ7Im/9LJs9g==}
+    engines: {'0': node >=0.6.0}
+
   eyes@0.1.8:
     resolution: {integrity: sha512-GipyPsXO1anza0AOZdy69Im7hGFCNB7Y/NGjDlZGJ3GJJLtwNSb2vrzYrTYJRrRloVx7pl+bhUaTB8yiccPvFQ==}
     engines: {node: '> 0.1.90'}
@@ -7191,6 +7318,9 @@ packages:
     resolution: {integrity: sha512-gIXjKqtFuWEgzFRJA9WCQeSJLZDjgJUOMCMzxtvFq/37KojM1BFGufqsCy0r4qSQmYLsZYMeyRqzIWOMup03sw==}
     engines: {node: '>=14'}
 
+  forever-agent@0.6.1:
+    resolution: {integrity: sha512-j0KLYPhm6zeac4lz3oJ3o65qvgQCcPubiyotZrXqEaG4hNagNYO8qdlUrX5vwqv9ohqeT/Z3j6+yW067yWWdUw==}
+
   fork-ts-checker-webpack-plugin@9.1.0:
     resolution: {integrity: sha512-mpafl89VFPJmhnJ1ssH+8wmM2b50n+Rew5x42NeI2U78aRWgtkEtGmctp7iT16UjquJTjorEmIfESj3DxdW84Q==}
     engines: {node: '>=14.21.3'}
@@ -7262,6 +7392,10 @@ packages:
     resolution: {integrity: sha512-eKpRKAovdpZtR1WopLHxlBWvAgPny3c4gX1G5Jhwmmw4XJj0ifSD5qB5TOo8hmA0wlRKDAOAhEE1yVPgs6Fgcg==}
     engines: {node: '>=14.14'}
 
+  fs-extra@9.1.0:
+    resolution: {integrity: sha512-hcg3ZmepS30/7BSFqRvoo3DOMQu7IjqxO5nCDt+zM9XWjb33Wg7ziNT+Qvqbuc3+gWpzO02JubVyk2G4Zvo1OQ==}
+    engines: {node: '>=10'}
+
   fs-monkey@1.1.0:
     resolution: {integrity: sha512-QMUezzXWII9EV5aTFXW1UBVUO77wYPpjqIF8/AviUCThNeSYZykpoTixUeaNNBwmCev0AMDWMAni+f8Hxb1IFw==}
 
@@ -7362,6 +7496,9 @@ packages:
     resolution: {integrity: sha512-Ln0UQDlxH1BapMu3GPtf7CuYNwRZf2gwCuPqbyG6pB8WfmFpzqcy4xtAaAMUhnNqjMKTiCPZG2oMT3YSx8U2NA==}
     engines: {node: '>=0.10.0'}
 
+  getpass@0.1.7:
+    resolution: {integrity: sha512-0fzj9JxOLfJ+XGLhR8ze3unN0KZCgZwiSSDz168VERjK8Wl8kVSdcu2kspd4s4wtAa1y/qrVRiAA0WclVsu0ng==}
+
   giget@2.0.0:
     resolution: {integrity: sha512-L5bGsVkxJbJgdnwyuheIunkGatUF/zssUoxxjACCseZYAVbaqdh9Tsmmlkl8vYan09H7sbvKt4pS8GqKLBrEzA==}
     hasBin: true
@@ -7406,6 +7543,10 @@ packages:
     resolution: {integrity: sha512-wHTUcDUoZ1H5/0iVqEudYW4/kAlN5cZ3j/bXn0Dpbizl9iaUVeWSHqiOjsgk6OW2bkLclbBjzewBz6weQ1zA2Q==}
     engines: {node: '>=18'}
 
+  global-dirs@3.0.1:
+    resolution: {integrity: sha512-NBcGGFbBA9s1VzD41QXDG+3++t9Mn5t1FpLdhESY6oKY4gYTFpX4wO3sqGUa0Srjtbfj3szX0RnemmrVRUdULA==}
+    engines: {node: '>=10'}
+
   globals@13.24.0:
     resolution: {integrity: sha512-AhO5QUcj8llrbG09iWhPU2B204J1xnPeL8kQmVorSsy+Sjj1sk8gIyh6cUocGmH4L0UuhAJy+hJMRA4mgA4mFQ==}
     engines: {node: '>=8'}
@@ -7501,6 +7642,10 @@ packages:
     resolution: {integrity: sha512-ODYZC64uqzmtfGMEAX/FvZiRyWLpAC3vYnNunURUnkGVTS+mI0smVsWaPydRBsE3g+ok7h960jChO8mFcWlHaQ==}
     engines: {node: '>=0.10.0'}
 
+  hasha@5.2.2:
+    resolution: {integrity: sha512-Hrp5vIK/xr5SkeN2onO32H0MgNZ0f17HRNH39WfL0SYUNOTZ5Lz1TJ8Pajo/87dYGEFlLMm7mIc/k/s6Bvz9HQ==}
+    engines: {node: '>=8'}
+
   hasown@2.0.4:
     resolution: {integrity: sha512-T2UbfbBEF32wiepXIsMlTW9+dDYC6wMh/t/vYA4tuOMKqWz/n3vr1NFSxQiyP+zk2mXsoMA/i/7qV6LKut1t1A==}
     engines: {node: '>= 0.4'}
@@ -7571,6 +7716,10 @@ packages:
     resolution: {integrity: sha512-T1gkAiYYDWYx3V5Bmyu7HcfcvL7mUrTWiM6yOfa3PIphViJ/gFPbvidQ+veqSOHci/PxBcDabeUNCzpOODJZig==}
     engines: {node: '>= 14'}
 
+  http-signature@1.4.0:
+    resolution: {integrity: sha512-G5akfn7eKbpDN+8nPS/cb57YeA1jLTVxjpCj7tmm3QKPdyDy7T+qSC40e9ptydSWvkwjSXw1VbkpyEm39ukeAg==}
+    engines: {node: '>=0.10'}
+
   https-proxy-agent@5.0.1:
     resolution: {integrity: sha512-dFcAjpTQFgoLMzC2VwU+C/CbS7uRL0lWmxDITmqm7C+7F0Odmj6s9l6alZc6AELXhrnggM2CeWSXHGOdX2YtwA==}
     engines: {node: '>= 6'}
@@ -7579,6 +7728,10 @@ packages:
     resolution: {integrity: sha512-vK9P5/iUfdl95AI+JVyUuIcVtd4ofvtrOr3HNtM2yxC9bnMbEdp3x01OhQNnjb8IJYi38VlTE3mBXwcfvywuSw==}
     engines: {node: '>= 14'}
 
+  human-signals@1.1.1:
+    resolution: {integrity: sha512-SEQu7vl8KjNL2eoGBLF3+wAjpsNfA9XMlXAYj/3EdaNfAlxKthD1xjEQfGOUhllCGGJVNY34bRr6lPINhNjyZw==}
+    engines: {node: '>=8.12.0'}
+
   human-signals@2.1.0:
     resolution: {integrity: sha512-B4FFZ6q/T2jhhksgkbEW3HBvWIfDW85snkQgawt07S7J5QXTk6BkNV+0yAeZrM5QpMAdYlocGoljn0sJ/WQkFw==}
     engines: {node: '>=10.17.0'}
@@ -7684,6 +7837,10 @@ packages:
   inherits@2.0.4:
     resolution: {integrity: sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==}
 
+  ini@2.0.0:
+    resolution: {integrity: sha512-7PnF4oN3CvZF23ADhA5wRaYEQpJ8qygSkbtTXWBeXWXmEVRXK+1ITciHWwHhsjv1TmW0MgacIv6hEi5pX5NQdA==}
+    engines: {node: '>=10'}
+
   ini@4.1.1:
     resolution: {integrity: sha512-QQnnxNyfvmHFIsj7gkPcYymR8Jdw/o7mp5ZFihxn6h8Ci6fh3Dx4E1gPjpQEpIuPo9XVNY/ZUwh4BPMjGyL01g==}
     engines: {node: ^14.17.0 || ^16.13.0 || >=18.0.0}
@@ -7852,6 +8009,10 @@ packages:
     engines: {node: '>=14.16'}
     hasBin: true
 
+  is-installed-globally@0.4.0:
+    resolution: {integrity: sha512-iwGqO3J21aaSkC7jWnHP/difazwS7SFeIqxv6wEtLU8Y5KlzFTjyqcSIT0d8s4+dDhKytsk9PJZ2BkS5eZwQRQ==}
+    engines: {node: '>=10'}
+
   is-interactive@1.0.0:
     resolution: {integrity: sha512-2HvIEKRoqS62guEC+qBjpvRubdX910WCMuJTZ+I9yvqKU2/12eSL549HMwtabb4oupdj2sMP50k+XJfB/8JE6w==}
     engines: {node: '>=8'}
@@ -7969,6 +8130,9 @@ packages:
     resolution: {integrity: sha512-p3EcsicXjit7SaskXHs1hA91QxgTw46Fv6EFKKGS5DRFLD8yKnohjF3hxoju94b/OcMZoQukzpPpBE9uLVKzgQ==}
     engines: {node: '>= 0.4'}
 
+  is-typedarray@1.0.0:
+    resolution: {integrity: sha512-cyA56iCMHAh5CdzjJIa4aohJyeO1YbwLi3Jc35MmRU6poroFjIGZzUzupGiRPOjgHg9TLu43xbpwXk523fMxKA==}
+
   is-unicode-supported@0.1.0:
     resolution: {integrity: sha512-knxG2q4UC3u8stRGyAVJCOdxFmv5DZiRcdlIaAQXAbSfJya+OhopNotLQrstBhququ4ZpuKbDc/8S6mgXgPFPw==}
     engines: {node: '>=10'}
@@ -8257,6 +8421,9 @@ packages:
     resolution: {integrity: sha512-ePWsvanv0DWuDRsW8dnt+R4jQ31SCRCQ7hhNcPXZPsoBZiemuZNYGf7adZdqX2D86j6rvKp3RpCxVTSb8WQlOw==}
     hasBin: true
 
+  jsbn@0.1.1:
+    resolution: {integrity: sha512-UVU9dibq2JcFWxQPA6KCqj5O42VOmAY3zQUfEKxU0KpTGXwNoCjkX1e13eHNvw/xPynt6pU0rZ1htjWTNTSXsg==}
+
   jsdom@25.0.1:
     resolution: {integrity: sha512-8i7LzZj7BF8uplX+ZyOlIz86V6TAsSs+np6m1kpW9u0JWi4z/1t+FzcK1aek+ybTnAC4KhBL4uXCNT0wcUIeCw==}
     engines: {node: '>=18'}
@@ -8286,12 +8453,18 @@ packages:
   json-schema-typed@8.0.2:
     resolution: {integrity: sha512-fQhoXdcvc3V28x7C7BMs4P5+kNlgUURe2jmUT1T//oBRMDrqy1QPelJimwZGo7Hg9VPV3EQV5Bnq4hbFy2vetA==}
 
+  json-schema@0.4.0:
+    resolution: {integrity: sha512-es94M3nTIfsEPisRafak+HDLfHXnKBhV3vU5eqPcS3flIWqcxJWgXHXiey3YrpaNsanY5ei1VoYEbOzijuq9BA==}
+
   json-stable-stringify-without-jsonify@1.0.1:
     resolution: {integrity: sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw==}
 
   json-stream@1.0.0:
     resolution: {integrity: sha512-H/ZGY0nIAg3QcOwE1QN/rK/Fa7gJn7Ii5obwp6zyPO4xiPNwpIMjqy2gwjBEGqzkF/vSWEIBQCBuN19hYiL6Qg==}
 
+  json-stringify-safe@5.0.1:
+    resolution: {integrity: sha512-ZClg6AaYvamvYEE82d3Iyd3vSSIjQ+odgjaTzRuO3s7toCdFKczob2i0zCh7JE8kWn17yvAWhUVxvqGwUalsRA==}
+
   json5@1.0.2:
     resolution: {integrity: sha512-g1MWMLBiz8FKi1e4w0UyVL3w+iJceWAFBAaBnnGKOpNa5f8TLktkbre1+s6oICydWAm+HRUGTmI+//xv2hvXYA==}
     hasBin: true
@@ -8330,6 +8503,10 @@ packages:
   jspdf@4.2.1:
     resolution: {integrity: sha512-YyAXyvnmjTbR4bHQRLzex3CuINCDlQnBqoSYyjJwTP2x9jDLuKDzy7aKUl0hgx3uhcl7xzg32agn5vlie6HIlQ==}
 
+  jsprim@2.0.2:
+    resolution: {integrity: sha512-gqXddjPqQ6G40VdnI6T6yObEC+pDNvyP95wdQhkWkg7crHH3km5qP1FsOXEkzEQwnz6gz5qGTn1c2Y52wP3OyQ==}
+    engines: {'0': node >=0.6.0}
+
   jsx-ast-utils@3.3.5:
     resolution: {integrity: sha512-ZZow9HBI5O6EPgSJLUb8n2NKgmVWTwCvHGwFuJlMjvLFqlGG6pjirPhtdsseaLZjSibD8eegzmYpUZwoIlj2cQ==}
     engines: {node: '>=4.0'}
@@ -8508,6 +8685,10 @@ packages:
     resolution: {integrity: sha512-LWzX2KsqcB1wqQ4AHgYb4RsDXauQiqhjLk+6hjbaeHG4zpjjVAB6wC/gz6X0l+Du1cN3pUB5ZlrvTbhGSNnUQQ==}
     engines: {node: '>=18.0.0'}
 
+  listr2@9.0.5:
+    resolution: {integrity: sha512-ME4Fb83LgEgwNw96RKNvKV4VTLuXfoKudAmm2lP8Kk87KaMK0/Xrx/aAkMWmT8mDb+3MlFDspfbCs7adjRxA2g==}
+    engines: {node: '>=20.0.0'}
+
   little-state-machine@4.8.1:
     resolution: {integrity: sha512-liPHqaWMQ7rzZryQUDnbZ1Gclnnai3dIyaJ0nAgwZRXMzqbYrydrlCI0NDojRUbE5VYh5vu6hygEUZiH77nQkQ==}
     peerDependencies:
@@ -9194,6 +9375,9 @@ packages:
     resolution: {integrity: sha512-weP+BZ8MVNnlCm8c0Qdc1WSWq4Qn7I+9CJGm7Qali6g44e/PUzbjNqJX5NJ9ljlNMosfJvg1fKEGILklK9cwnw==}
     engines: {node: '>=18'}
 
+  ospath@1.2.2:
+    resolution: {integrity: sha512-o6E5qJV5zkAbIDNhGSIlyOhScKXgQrSRMilfph0clDfM0nEnBOlKlH4sWDmG95BW/CvwNz0vmm7dJVtU2KlMiA==}
+
   outvariant@1.4.3:
     resolution: {integrity: sha512-+Sl2UErvtsoajRDKCE5/dBz4DIvHXQQnAxtQTF04OJxY0+DyZXSo5P5Bb7XYWOh81syohlYL24hbDwxedPUJCA==}
 
@@ -9562,6 +9746,10 @@ packages:
     engines: {node: '>=14'}
     hasBin: true
 
+  pretty-bytes@5.6.0:
+    resolution: {integrity: sha512-FFw039TmrBqFK8ma/7OL3sDz/VytdtJr044/QUJtH0wK9lb9jLq9tJyIxUwtQJHwar2BqtiA4iCWSwo9JLkzFg==}
+    engines: {node: '>=6'}
+
   pretty-format@29.7.0:
     resolution: {integrity: sha512-Pdlw/oPxN+aXdmM9R00JVC9WVFoCLTKJvDVLgmJ+qAffBMxsV85l/Lu7sNx4zSzPyoL2euImuEwHhOXdEgNFZQ==}
     engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
@@ -9609,6 +9797,9 @@ packages:
     resolution: {integrity: sha512-TmatMXdr2KlRiA2CyDu8GqR8EjahTG3aY3nXjdzFyoZbmB8hrBsTyMezhULIXKnC0jpfjlmiZ3+EaCzoInSu/A==}
     engines: {node: '>= 14'}
 
+  proxy-from-env@1.0.0:
+    resolution: {integrity: sha512-F2JHgJQ1iqwnHDcQjVBsq3n/uoaFL+iPW/eAeL7kVxy/2RrWaN4WroKjjvbsoRtv0ftelNyC01bjRhn/bhcf4A==}
+
   proxy-from-env@1.1.0:
     resolution: {integrity: sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg==}
 
@@ -10083,6 +10274,9 @@ packages:
     resolution: {integrity: sha512-PV0dzCYDNfRi1jCDbJzpW7jNNDRuCOG/jI5ctQcGKt/clZD+YcPS3yIlWuTJMmESC8aevCFmWJy5wjAFgNqN6w==}
     engines: {node: '>=0.10'}
 
+  request-progress@3.0.0:
+    resolution: {integrity: sha512-MnWzEHHaxHO2iWiQuHrUPBi/1WeBf5PkxQqNyNvLl9VAYSdXkP8tQ3pBSeCPD+yw0v0Aq1zosWLz0BdeXpWwZg==}
+
   require-directory@2.1.1:
     resolution: {integrity: sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==}
     engines: {node: '>=0.10.0'}
@@ -10410,6 +10604,10 @@ packages:
     resolution: {integrity: sha512-iOBWFgUX7caIZiuutICxVgX1SdxwAVFFKwt1EvMYYec/NWO5meOJ6K5uQxhrYBdQJne4KxiqZc+KptFOWFSI9w==}
     engines: {node: '>=18'}
 
+  slice-ansi@8.0.0:
+    resolution: {integrity: sha512-stxByr12oeeOyY2BlviTNQlYV5xOj47GirPr4yA1hE9JCtxfQN0+tVbkxwCtYDQWhEKWFHsEK48ORg5jrouCAg==}
+    engines: {node: '>=20'}
+
   smart-buffer@4.2.0:
     resolution: {integrity: sha512-94hK0Hh8rPqQl2xXc3HsaBoOXKV20MToPkcXvwbISWLEs+64sBq5kFgn2kJDHb1Pry9yrP0dxrCI9RRci7RXKg==}
     engines: {node: '>= 6.0.0', npm: '>= 3.0.0'}
@@ -10516,6 +10714,11 @@ packages:
     resolution: {integrity: sha512-+idbmIXoYET47hH+d7dfm2epdOMUDjqcB4648sTZ+t2JwoyBFL/insLfB/racrDmsKB3diwsDA696pZMieAC5g==}
     engines: {node: '>=0.8'}
 
+  sshpk@1.18.0:
+    resolution: {integrity: sha512-2p2KJZTSqQ/I3+HX42EpYOa2l3f8Erv8MWKsy2I9uf4wA7yFIkXRffYdsx86y6z4vHtV8u7g+pPlr8/4ouAxsQ==}
+    engines: {node: '>=0.10.0'}
+    hasBin: true
+
   stable-hash@0.0.5:
     resolution: {integrity: sha512-+L3ccpzibovGXFK+Ap/f8LOS0ahMrHTf3xu7mMLSpEGU0EO9ucaysSylKo9eRDFNhWve/y275iPmIZ4z39a9iA==}
 
@@ -10593,6 +10796,10 @@ packages:
     resolution: {integrity: sha512-tsaTIkKW9b4N+AEj+SVA+WhJzV7/zMhcSu78mLKWSk7cXMOSHsBKFWUs0fWwq8QyK3MgJBQRX6Gbi4kYbdvGkQ==}
     engines: {node: '>=18'}
 
+  string-width@8.2.2:
+    resolution: {integrity: sha512-GaPUh5gfdrYzqeVNZvUfT23vYYxXzKYidUcnMtJg/3rxRV63EFZy3k6xfKlmfeJD0176lnUV/Usr3XcwSvFzpg==}
+    engines: {node: '>=20'}
+
   string.prototype.includes@2.0.1:
     resolution: {integrity: sha512-o7+c9bW6zpAdJHTtujeePODAhkuicdAryFsfVKwA+wGw89wJ4GTY484WTucM9hLtDEOpOvI+aHnzqnC5lHp4Rg==}
     engines: {node: '>= 0.4'}
@@ -10766,6 +10973,12 @@ packages:
   symbol-tree@3.2.4:
     resolution: {integrity: sha512-9QNk5KwDF+Bvz+PyObkmSYjI5ksVUYtjW7AU22r2NKcfLJcXp96hkDWU3+XndOsUb+AQ9QhfzfCT2O+CNWT5Tw==}
 
+  systeminformation@5.33.0:
+    resolution: {integrity: sha512-0LYSL01CCbjVeJG7iXI8fUCFU76zMjzbHd/EU3or4QpSFYCLMgslR11prwHuA3siz5jmOkqoLhjgOyDRmXBKmA==}
+    engines: {node: '>=10.0.0'}
+    os: [darwin, linux, win32, freebsd, openbsd, netbsd, sunos, android]
+    hasBin: true
+
   tabbable@6.4.0:
     resolution: {integrity: sha512-05PUHKSNE8ou2dwIxTngl4EzcnsCDZGJ/iCLtDflR/SHB/ny14rXc+qU5P4mG9JkusiV7EivzY9Mhm55AzAvCg==}
 
@@ -10883,6 +11096,9 @@ packages:
   thenify@3.3.1:
     resolution: {integrity: sha512-RVZSIV5IG10Hk3enotrhvz0T9em6cyHBLkH/YAZuKqd8hRkKhSfCGIcP2KUY0EPxndzANBmNllzWPwak+bheSw==}
 
+  throttleit@1.0.1:
+    resolution: {integrity: sha512-vDZpf9Chs9mAdfY046mcPt8fg5QSZr37hEH4TXYBnDF+izxgrbRGUAAaBvIk/fJm9aOFCGFd1EsNg5AZCbnQCQ==}
+
   through2@2.0.5:
     resolution: {integrity: sha512-/mrRod8xqpA+IHSLyGCQ2s8SPHiCDEeQJSep1jqLYeEUClOFG2Qsh+4FU6G9VeqpZnGW/Su8LQGc4YKni5rYSQ==}
 
@@ -11006,6 +11222,10 @@ packages:
   traverse@0.3.9:
     resolution: {integrity: sha512-iawgk0hLP3SxGKDfnDJf8wTz4p2qImnyihM5Hh/sGvQ3K37dPi/w8sRhdNIxYA1TwFwc5mDhIJq+O0RsvXBKdQ==}
 
+  tree-kill@1.2.2:
+    resolution: {integrity: sha512-L0Orpi8qGpRG//Nd+H90vFB+3iHnue1zSSGmNOOCh1GLJ7rUKVwV2HvijphGQS2UmhUZewS9VgvxYIdgr+fG1A==}
+    hasBin: true
+
   trim-canvas@0.1.2:
     resolution: {integrity: sha512-nd4Ga3iLFV94mdhW9JFMLpQbHUyCQuhFOD71PEAt1NjtMD5wbZctzhX8c3agHNybMR5zXD1XTGoIEWk995E6pQ==}
 
@@ -11090,6 +11310,9 @@ packages:
   tslib@2.8.1:
     resolution: {integrity: sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==}
 
+  tunnel-agent@0.6.0:
+    resolution: {integrity: sha512-McnNiV1l8RYeY8tBgEpuodCC1mLUdbSN+CYBL7kJsJNInOP8UjDDEwdk6Mw60vdLLrr5NHKZhMAOSrR2NZuQ+w==}
+
   turbo@2.9.16:
     resolution: {integrity: sha512-NqgRQy6j6dPYcdSdv0q1g9QsZg7SWg87RERM8otw/1AtKU2yTFVClOM7cbwKzOonZr/Ek1blTBucw64L9H0Bwg==}
     hasBin: true
@@ -11097,6 +11320,9 @@ packages:
   tw-animate-css@1.4.0:
     resolution: {integrity: sha512-7bziOlRqH0hJx80h/3mbicLW7o8qLsH5+RaLR2t+OHM3D0JlWGODQKQ4cxbK7WlvmUxpcj6Kgu6EKqjrGFe3QQ==}
 
+  tweetnacl@0.14.5:
+    resolution: {integrity: sha512-KXXFFdAbFXY4geFIwoyNK+f5Z1b7swfXABfL7HXCmoIWMKU3dmS26672A4EeQtDzLKy7SXmfBu51JolvEKwtGA==}
+
   type-check@0.4.0:
     resolution: {integrity: sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==}
     engines: {node: '>= 0.8.0'}
@@ -11113,6 +11339,10 @@ packages:
     resolution: {integrity: sha512-t0rzBq87m3fVcduHDUFhKmyyX+9eo6WQjZvf51Ea/M0Q7+T374Jp1aUiyUl0GKxp8M/OETVHSDvmkyPgvX+X2w==}
     engines: {node: '>=10'}
 
+  type-fest@0.8.1:
+    resolution: {integrity: sha512-4dbzIzqvjtgiM5rw1k5rEHtBANKmdudhGyBEajN01fEyhaAIhsoKNy6y7+IN93IfpFtwY9iqi7kD+xwKhQsNJA==}
+    engines: {node: '>=8'}
+
   type-fest@4.41.0:
     resolution: {integrity: sha512-TeTSQ6H5YHvpqVwBRcnLDCBnDOHWYu7IvGbHT6N8AOymcr9PJGjc1GTtiWZTYg0NCgYwvnYWEkVChQAr9bjfwA==}
     engines: {node: '>=16'}
@@ -11285,6 +11515,10 @@ packages:
   until-async@3.0.2:
     resolution: {integrity: sha512-IiSk4HlzAMqTUseHHe3VhIGyuFmN90zMTpD3Z3y8jeQbzLIq500MVM7Jq2vUAnTKAFPJrqwkzr6PoTcPhGcOiw==}
 
+  untildify@4.0.0:
+    resolution: {integrity: sha512-KK8xQ1mkzZeg9inewmFVDNkg3l5LUhoq9kN6iWYB/CC9YMG8HA+c1Q8HwDe6dEX7kErrEVNVBO3fWsVq5iDgtw==}
+    engines: {node: '>=8'}
+
   unzipper@0.10.14:
     resolution: {integrity: sha512-ti4wZj+0bQTiX2KmKWuwj7lhV+2n//uXEotUmGuQqrbVZSEGFMbI68+c6JCQ8aAmUWYvtHEz2A8K6wXvueR/6g==}
 
@@ -11425,6 +11659,10 @@ packages:
       react: ^16.8 || ^17.0 || ^18.0 || ^19.0.0 || ^19.0.0-rc
       react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0.0 || ^19.0.0-rc
 
+  verror@1.10.0:
+    resolution: {integrity: sha512-ZZKSmDAEFOijERBLkmYfJ+vmk3w+7hOLYDNkRCuRuMJGEmqYNCNLyBBFwWKVMhfwaEF3WOd0Zlw86U/WC/+nYw==}
+    engines: {'0': node >=0.6.0}
+
   victory-vendor@36.9.2:
     resolution: {integrity: sha512-PnpQQMuxlwYdocC8fIJqVXvkeViHYzotI+NJrCuav0ZYFoq912ZHBk3mCeuj+5/VpodOjPe1z0Fk2ihgzlXqjQ==}
 
@@ -11763,6 +12001,10 @@ packages:
   yauzl@2.10.0:
     resolution: {integrity: sha512-p4a9I6X6nu6IhoGmBqAcbJy1mlC4j27vEPZX9F4L4/vZT3Lyq1VkFHw/V/PUcB9Buo+DG3iHkT0x3Qya58zc3g==}
 
+  yauzl@3.4.0:
+    resolution: {integrity: sha512-jIH9yLR9wqr0wOS0TpBvo/g/2UgZH5qePVbjgRliiF0BYvOZyaBknKsF+x9Iht0O6sqgnB93rCICdOZFecJuDw==}
+    engines: {node: '>=12'}
+
   year@0.2.1:
     resolution: {integrity: sha512-9GnJUZ0QM4OgXuOzsKNzTJ5EOkums1Xc+3YQXp+Q+UxFjf7zLucp9dQ8QMIft0Szs1E1hUiXFim1OYfEKFq97w==}
     engines: {node: '>=0.8'}
@@ -11889,11 +12131,11 @@ snapshots:
       '@babel/helpers': 7.29.7
       '@babel/parser': 7.29.7
       '@babel/template': 7.29.7
-      '@babel/traverse': 7.29.7(supports-color@5.5.0)
+      '@babel/traverse': 7.29.7
       '@babel/types': 7.29.7
       '@jridgewell/remapping': 2.3.5
       convert-source-map: 2.0.0
-      debug: 4.4.3(supports-color@5.5.0)
+      debug: 4.4.3(supports-color@8.1.1)
       gensync: 1.0.0-beta.2
       json5: 2.2.3
       semver: 6.3.1
@@ -11928,7 +12170,7 @@ snapshots:
       '@babel/helper-optimise-call-expression': 7.29.7
       '@babel/helper-replace-supers': 7.29.7(@babel/core@7.29.7)
       '@babel/helper-skip-transparent-expression-wrappers': 7.29.7
-      '@babel/traverse': 7.29.7(supports-color@5.5.0)
+      '@babel/traverse': 7.29.7
       semver: 6.3.1
     transitivePeerDependencies:
       - supports-color
@@ -11937,7 +12179,14 @@ snapshots:
 
   '@babel/helper-member-expression-to-functions@7.29.7':
     dependencies:
-      '@babel/traverse': 7.29.7(supports-color@5.5.0)
+      '@babel/traverse': 7.29.7
+      '@babel/types': 7.29.7
+    transitivePeerDependencies:
+      - supports-color
+
+  '@babel/helper-module-imports@7.29.7':
+    dependencies:
+      '@babel/traverse': 7.29.7
       '@babel/types': 7.29.7
     transitivePeerDependencies:
       - supports-color
@@ -11952,9 +12201,9 @@ snapshots:
   '@babel/helper-module-transforms@7.29.7(@babel/core@7.29.7)':
     dependencies:
       '@babel/core': 7.29.7
-      '@babel/helper-module-imports': 7.29.7(supports-color@5.5.0)
+      '@babel/helper-module-imports': 7.29.7
       '@babel/helper-validator-identifier': 7.29.7
-      '@babel/traverse': 7.29.7(supports-color@5.5.0)
+      '@babel/traverse': 7.29.7
     transitivePeerDependencies:
       - supports-color
 
@@ -11969,13 +12218,13 @@ snapshots:
       '@babel/core': 7.29.7
       '@babel/helper-member-expression-to-functions': 7.29.7
       '@babel/helper-optimise-call-expression': 7.29.7
-      '@babel/traverse': 7.29.7(supports-color@5.5.0)
+      '@babel/traverse': 7.29.7
     transitivePeerDependencies:
       - supports-color
 
   '@babel/helper-skip-transparent-expression-wrappers@7.29.7':
     dependencies:
-      '@babel/traverse': 7.29.7(supports-color@5.5.0)
+      '@babel/traverse': 7.29.7
       '@babel/types': 7.29.7
     transitivePeerDependencies:
       - supports-color
@@ -12128,6 +12377,18 @@ snapshots:
       '@babel/parser': 7.29.7
       '@babel/types': 7.29.7
 
+  '@babel/traverse@7.29.7':
+    dependencies:
+      '@babel/code-frame': 7.29.7
+      '@babel/generator': 7.29.7
+      '@babel/helper-globals': 7.29.7
+      '@babel/parser': 7.29.7
+      '@babel/template': 7.29.7
+      '@babel/types': 7.29.7
+      debug: 4.4.3(supports-color@8.1.1)
+    transitivePeerDependencies:
+      - supports-color
+
   '@babel/traverse@7.29.7(supports-color@5.5.0)':
     dependencies:
       '@babel/code-frame': 7.29.7
@@ -12286,6 +12547,33 @@ snapshots:
 
   '@csstools/css-tokenizer@3.0.4': {}
 
+  '@cypress/request@4.0.1':
+    dependencies:
+      aws-sign2: 0.7.0
+      aws4: 1.13.2
+      caseless: 0.12.0
+      combined-stream: 1.0.8
+      extend: 3.0.2
+      forever-agent: 0.6.1
+      form-data: 4.0.5
+      http-signature: 1.4.0
+      is-typedarray: 1.0.0
+      isstream: 0.1.2
+      json-stringify-safe: 5.0.1
+      mime-types: 2.1.35
+      performance-now: 2.1.0
+      qs: 6.15.2
+      safe-buffer: 5.2.1
+      tough-cookie: 5.1.2
+      tunnel-agent: 0.6.0
+
+  '@cypress/xvfb@1.2.4(supports-color@8.1.1)':
+    dependencies:
+      debug: 3.2.7(supports-color@8.1.1)
+      lodash.once: 4.1.1
+    transitivePeerDependencies:
+      - supports-color
+
   '@date-fns/tz@1.5.0': {}
 
   '@dotenvx/dotenvx@1.71.0':
@@ -12324,7 +12612,7 @@ snapshots:
 
   '@emotion/babel-plugin@11.13.5':
     dependencies:
-      '@babel/helper-module-imports': 7.29.7(supports-color@5.5.0)
+      '@babel/helper-module-imports': 7.29.7
       '@babel/runtime': 7.29.7
       '@emotion/hash': 0.9.2
       '@emotion/memoize': 0.9.0
@@ -12490,7 +12778,7 @@ snapshots:
   '@eslint/eslintrc@2.1.4':
     dependencies:
       ajv: 6.15.0
-      debug: 4.4.3(supports-color@5.5.0)
+      debug: 4.4.3(supports-color@8.1.1)
       espree: 9.6.1
       globals: 13.24.0
       ignore: 5.3.2
@@ -12636,7 +12924,7 @@ snapshots:
   '@humanwhocodes/config-array@0.13.0':
     dependencies:
       '@humanwhocodes/object-schema': 2.0.3
-      debug: 4.4.3(supports-color@5.5.0)
+      debug: 4.4.3(supports-color@8.1.1)
       minimatch: 3.1.5
     transitivePeerDependencies:
       - supports-color
@@ -13803,7 +14091,7 @@ snapshots:
 
   '@puppeteer/browsers@2.13.2':
     dependencies:
-      debug: 4.4.3(supports-color@5.5.0)
+      debug: 4.4.3(supports-color@8.1.1)
       extract-zip: 2.0.1
       progress: 2.0.3
       proxy-agent: 6.5.0
@@ -15871,7 +16159,7 @@ snapshots:
 
   '@tokenizer/inflate@0.4.1':
     dependencies:
-      debug: 4.4.3(supports-color@5.5.0)
+      debug: 4.4.3(supports-color@8.1.1)
       token-types: 6.1.2
     transitivePeerDependencies:
       - supports-color
@@ -16162,6 +16450,130 @@ snapshots:
       - utf-8-validate
       - vite
 
+  '@tria-plc/iamui@file:local-packages/tria-plc-iamui-0.1.1.tgz(a5d0bdee55164ae56064fb273b530e00)':
+    dependencies:
+      '@emotion/react': 11.14.0(@types/react@18.3.31)(react@19.2.6)
+      '@emotion/styled': 11.14.1(@emotion/react@11.14.0(@types/react@18.3.31)(react@19.2.6))(@types/react@18.3.31)(react@19.2.6)
+      '@hookform/resolvers': 5.4.0(react-hook-form@7.77.0(react@19.2.6))
+      '@lottiefiles/react-lottie-player': 3.6.0(react@19.2.6)
+      '@mantine/charts': 7.17.8(@mantine/core@7.17.8(@mantine/hooks@7.17.8(react@19.2.6))(@types/react@18.3.31)(react-dom@19.2.6(react@19.2.6))(react@19.2.6))(@mantine/hooks@7.17.8(react@19.2.6))(react-dom@19.2.6(react@19.2.6))(react@19.2.6)(recharts@3.8.1(@types/react@18.3.31)(react-dom@19.2.6(react@19.2.6))(react-is@19.2.7)(react@19.2.6)(redux@5.0.1))
+      '@mantine/core': 7.17.8(@mantine/hooks@7.17.8(react@19.2.6))(@types/react@18.3.31)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@mantine/dates': 7.17.8(@mantine/core@7.17.8(@mantine/hooks@7.17.8(react@19.2.6))(@types/react@18.3.31)(react-dom@19.2.6(react@19.2.6))(react@19.2.6))(@mantine/hooks@7.17.8(react@19.2.6))(dayjs@1.11.21)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@mantine/hooks': 7.17.8(react@19.2.6)
+      '@mantine/notifications': 7.17.8(@mantine/core@7.17.8(@mantine/hooks@7.17.8(react@19.2.6))(@types/react@18.3.31)(react-dom@19.2.6(react@19.2.6))(react@19.2.6))(@mantine/hooks@7.17.8(react@19.2.6))(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-accordion': 1.2.13(@types/react-dom@18.3.7(@types/react@18.3.31))(@types/react@18.3.31)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-alert-dialog': 1.1.16(@types/react-dom@18.3.7(@types/react@18.3.31))(@types/react@18.3.31)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-avatar': 1.1.12(@types/react-dom@18.3.7(@types/react@18.3.31))(@types/react@18.3.31)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-checkbox': 1.3.4(@types/react-dom@18.3.7(@types/react@18.3.31))(@types/react@18.3.31)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-collapsible': 1.1.13(@types/react-dom@18.3.7(@types/react@18.3.31))(@types/react@18.3.31)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-context-menu': 2.3.0(@types/react-dom@18.3.7(@types/react@18.3.31))(@types/react@18.3.31)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-dialog': 1.1.16(@types/react-dom@18.3.7(@types/react@18.3.31))(@types/react@18.3.31)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-dropdown-menu': 2.1.17(@types/react-dom@18.3.7(@types/react@18.3.31))(@types/react@18.3.31)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-hover-card': 1.1.16(@types/react-dom@18.3.7(@types/react@18.3.31))(@types/react@18.3.31)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-label': 2.1.9(@types/react-dom@18.3.7(@types/react@18.3.31))(@types/react@18.3.31)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-navigation-menu': 1.2.15(@types/react-dom@18.3.7(@types/react@18.3.31))(@types/react@18.3.31)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-popover': 1.1.16(@types/react-dom@18.3.7(@types/react@18.3.31))(@types/react@18.3.31)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-progress': 1.1.9(@types/react-dom@18.3.7(@types/react@18.3.31))(@types/react@18.3.31)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-radio-group': 1.4.0(@types/react-dom@18.3.7(@types/react@18.3.31))(@types/react@18.3.31)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-scroll-area': 1.2.11(@types/react-dom@18.3.7(@types/react@18.3.31))(@types/react@18.3.31)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-select': 2.3.0(@types/react-dom@18.3.7(@types/react@18.3.31))(@types/react@18.3.31)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-separator': 1.1.9(@types/react-dom@18.3.7(@types/react@18.3.31))(@types/react@18.3.31)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-slot': 1.2.5(@types/react@18.3.31)(react@19.2.6)
+      '@radix-ui/react-switch': 1.3.0(@types/react-dom@18.3.7(@types/react@18.3.31))(@types/react@18.3.31)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-tabs': 1.1.14(@types/react-dom@18.3.7(@types/react@18.3.31))(@types/react@18.3.31)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-toast': 1.2.16(@types/react-dom@18.3.7(@types/react@18.3.31))(@types/react@18.3.31)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@radix-ui/react-tooltip': 1.2.9(@types/react-dom@18.3.7(@types/react@18.3.31))(@types/react@18.3.31)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@react-pdf-viewer/core': 3.12.0(pdfjs-dist@5.4.296)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@react-pdf-viewer/default-layout': 3.12.0(pdfjs-dist@5.4.296)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@react-pdf/renderer': 4.5.1(react@19.2.6)
+      '@reduxjs/toolkit': 2.12.0(react-redux@9.3.0(@types/react@18.3.31)(react@19.2.6)(redux@5.0.1))(react@19.2.6)
+      '@tabler/icons-react': 3.44.0(react@19.2.6)
+      '@tailwindcss/vite': 4.3.0(vite@5.4.21(@types/node@24.13.1)(lightningcss@1.32.0)(terser@5.48.0))
+      '@tanstack/react-query': 5.101.0(react@19.2.6)
+      '@tanstack/react-query-devtools': 5.101.0(@tanstack/react-query@5.101.0(react@19.2.6))(react@19.2.6)
+      '@tanstack/react-table': 8.21.3(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      '@tinymce/tinymce-react': 6.3.0(react-dom@19.2.6(react@19.2.6))(react@19.2.6)(tinymce@7.9.3)
+      '@types/dompurify': 3.2.0
+      '@types/node': 24.13.1
+      '@types/tinymce': 4.6.9
+      axios: 1.17.0
+      class-variance-authority: 0.7.1
+      clsx: 2.1.1
+      cmdk: 1.1.1(@types/react-dom@18.3.7(@types/react@18.3.31))(@types/react@18.3.31)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      date-fns: 3.6.0
+      dayjs: 1.11.21
+      dompurify: 3.4.8
+      ethiopian-calendar-date-converter: 2.1.6
+      ethiopian-calendar-new: 1.1.0
+      file-type: 18.7.0
+      framer-motion: 12.40.0(@emotion/is-prop-valid@1.4.0)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      html2canvas: 1.4.1
+      i18next: 25.10.10(typescript@5.9.3)
+      i18next-browser-languagedetector: 8.2.1
+      jquery: 3.7.1
+      js-cookie: 3.0.8
+      jspdf: 3.0.4
+      lodash: 4.18.1
+      lucide-react: 0.513.0(react@19.2.6)
+      mantine-react-table: 2.0.0-beta.9(@mantine/core@7.17.8(@mantine/hooks@7.17.8(react@19.2.6))(@types/react@18.3.31)(react-dom@19.2.6(react@19.2.6))(react@19.2.6))(@mantine/dates@7.17.8(@mantine/core@7.17.8(@mantine/hooks@7.17.8(react@19.2.6))(@types/react@18.3.31)(react-dom@19.2.6(react@19.2.6))(react@19.2.6))(@mantine/hooks@7.17.8(react@19.2.6))(dayjs@1.11.21)(react-dom@19.2.6(react@19.2.6))(react@19.2.6))(@mantine/hooks@7.17.8(react@19.2.6))(@tabler/icons-react@3.44.0(react@19.2.6))(clsx@2.1.1)(dayjs@1.11.21)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      mui-ethiopian-datepicker: 0.3.2(4b3af212eafdf0059f009b005d7e343d)
+      next-themes: 0.4.6(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      path: 0.12.7
+      pdf-lib: 1.17.1
+      qs: 6.15.2
+      react: 19.2.6
+      react-cookie: 8.1.2(@types/react@18.3.31)(react@19.2.6)
+      react-css-nocode-editor: 1.0.13(react-dom@19.2.6(react@19.2.6))(react-is@19.2.7)(react@19.2.6)
+      react-day-picker: 8.10.2(date-fns@3.6.0)(react@19.2.6)
+      react-dom: 19.2.6(react@19.2.6)
+      react-dropzone: 14.4.1(react@19.2.6)
+      react-hook-form: 7.77.0(react@19.2.6)
+      react-i18next: 15.7.4(i18next@25.10.10(typescript@5.9.3))(react-dom@19.2.6(react@19.2.6))(react@19.2.6)(typescript@5.9.3)
+      react-icons: 5.6.0(react@19.2.6)
+      react-image-crop: 11.0.10(react@19.2.6)
+      react-intersection-observer: 9.16.0(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      react-pdf: 10.4.1(@types/react@18.3.31)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      react-pdf-html: 2.1.5(@react-pdf/renderer@4.5.1(react@19.2.6))(react@19.2.6)
+      react-redux: 9.3.0(@types/react@18.3.31)(react@19.2.6)(redux@5.0.1)
+      react-resizable-panels: 3.0.6(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      react-router-dom: 7.17.0(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      react-signature-canvas: 1.1.0-alpha.2(@types/prop-types@15.7.15)(@types/react@18.3.31)(prop-types@15.8.1)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      recharts: 3.8.1(@types/react@18.3.31)(react-dom@19.2.6(react@19.2.6))(react-is@19.2.7)(react@19.2.6)(redux@5.0.1)
+      rollup-plugin-visualizer: 7.0.1(rollup@4.61.1)
+      socket.io-client: 4.8.3
+      sonner: 2.0.7(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      tailwind-merge: 3.6.0
+      tailwind-scrollbar-hide: 4.0.0(tailwindcss@4.3.0)
+      tailwindcss: 4.3.0
+      tailwindcss-animate: 1.0.7(tailwindcss@4.3.0)
+      tinymce: 7.9.3
+      url: 0.11.4
+      vaul: 1.1.2(@types/react-dom@18.3.7(@types/react@18.3.31))(@types/react@18.3.31)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
+      xlsx: 0.18.5
+      zod: 3.25.76
+    transitivePeerDependencies:
+      - '@babel/core'
+      - '@emotion/is-prop-valid'
+      - '@mui/icons-material'
+      - '@mui/material'
+      - '@mui/x-date-pickers'
+      - '@types/prop-types'
+      - '@types/react'
+      - '@types/react-dom'
+      - bufferutil
+      - debug
+      - pdfjs-dist
+      - prop-types
+      - react-is
+      - react-native
+      - redux
+      - rolldown
+      - rollup
+      - supports-color
+      - typescript
+      - utf-8-validate
+      - vite
+
   '@ts-morph/common@0.27.0':
     dependencies:
       fast-glob: 3.3.3
@@ -16376,6 +16788,10 @@ snapshots:
     dependencies:
       undici-types: 6.21.0
 
+  '@types/node@22.20.1':
+    dependencies:
+      undici-types: 6.21.0
+
   '@types/node@24.13.1':
     dependencies:
       undici-types: 7.18.2
@@ -16442,6 +16858,8 @@ snapshots:
 
   '@types/signature_pad@2.3.6': {}
 
+  '@types/sinonjs__fake-timers@8.1.1': {}
+
   '@types/sizzle@2.3.10': {}
 
   '@types/stack-utils@2.0.3': {}
@@ -16464,6 +16882,8 @@ snapshots:
     dependencies:
       '@types/jquery': 4.0.1
 
+  '@types/tmp@0.2.6': {}
+
   '@types/trusted-types@2.0.7':
     optional: true
 
@@ -16514,7 +16934,7 @@ snapshots:
       '@typescript-eslint/types': 8.60.1
       '@typescript-eslint/typescript-estree': 8.60.1(typescript@5.9.3)
       '@typescript-eslint/visitor-keys': 8.60.1
-      debug: 4.4.3(supports-color@5.5.0)
+      debug: 4.4.3(supports-color@8.1.1)
       eslint: 8.57.1
       typescript: 5.9.3
     transitivePeerDependencies:
@@ -16524,7 +16944,7 @@ snapshots:
     dependencies:
       '@typescript-eslint/tsconfig-utils': 8.60.1(typescript@5.9.3)
       '@typescript-eslint/types': 8.60.1
-      debug: 4.4.3(supports-color@5.5.0)
+      debug: 4.4.3(supports-color@8.1.1)
       typescript: 5.9.3
     transitivePeerDependencies:
       - supports-color
@@ -16543,7 +16963,7 @@ snapshots:
       '@typescript-eslint/types': 8.60.1
       '@typescript-eslint/typescript-estree': 8.60.1(typescript@5.9.3)
       '@typescript-eslint/utils': 8.60.1(eslint@8.57.1)(typescript@5.9.3)
-      debug: 4.4.3(supports-color@5.5.0)
+      debug: 4.4.3(supports-color@8.1.1)
       eslint: 8.57.1
       ts-api-utils: 2.5.0(typescript@5.9.3)
       typescript: 5.9.3
@@ -16558,7 +16978,7 @@ snapshots:
       '@typescript-eslint/tsconfig-utils': 8.60.1(typescript@5.9.3)
       '@typescript-eslint/types': 8.60.1
       '@typescript-eslint/visitor-keys': 8.60.1
-      debug: 4.4.3(supports-color@5.5.0)
+      debug: 4.4.3(supports-color@8.1.1)
       minimatch: 10.2.5
       semver: 7.8.2
       tinyglobby: 0.2.17
@@ -16838,7 +17258,7 @@ snapshots:
 
   agent-base@6.0.2:
     dependencies:
-      debug: 4.4.3(supports-color@5.5.0)
+      debug: 4.4.3(supports-color@8.1.1)
     transitivePeerDependencies:
       - supports-color
 
@@ -17093,6 +17513,8 @@ snapshots:
 
   append-field@1.0.0: {}
 
+  arch@2.2.0: {}
+
   archiver-utils@2.1.0:
     dependencies:
       glob: 7.2.3
@@ -17240,6 +17662,12 @@ snapshots:
 
   asap@2.0.6: {}
 
+  asn1@0.2.6:
+    dependencies:
+      safer-buffer: 2.1.2
+
+  assert-plus@1.0.0: {}
+
   assertion-error@2.0.1: {}
 
   assign-symbols@1.0.0: {}
@@ -17264,6 +17692,8 @@ snapshots:
 
   asynckit@0.4.0: {}
 
+  at-least-node@1.0.0: {}
+
   atob@2.1.2: {}
 
   attr-accept@2.2.5: {}
@@ -17285,6 +17715,10 @@ snapshots:
     dependencies:
       possible-typed-array-names: 1.1.0
 
+  aws-sign2@0.7.0: {}
+
+  aws4@1.13.2: {}
+
   axe-core@4.12.0: {}
 
   axios@1.17.0:
@@ -17348,6 +17782,16 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
+  babel-plugin-styled-components@2.3.0(styled-components@5.3.11(react-dom@19.2.6(react@19.2.6))(react-is@19.2.7)(react@19.2.6))(supports-color@5.5.0):
+    dependencies:
+      '@babel/helper-annotate-as-pure': 7.29.7
+      '@babel/helper-module-imports': 7.29.7(supports-color@5.5.0)
+      '@babel/plugin-syntax-jsx': 7.29.7(@babel/core@7.29.7)
+      picomatch: 4.0.4
+      styled-components: 5.3.11(react-dom@19.2.6(react@19.2.6))(react-is@19.2.7)(react@19.2.6)
+    transitivePeerDependencies:
+      - supports-color
+
   babel-polyfill@6.26.0:
     dependencies:
       babel-runtime: 6.26.0
@@ -17442,6 +17886,10 @@ snapshots:
 
   basic-ftp@5.3.1: {}
 
+  bcrypt-pbkdf@1.0.2:
+    dependencies:
+      tweetnacl: 0.14.5
+
   bcrypt@6.0.0:
     dependencies:
       node-addon-api: 8.8.0
@@ -17466,12 +17914,16 @@ snapshots:
       inherits: 2.0.4
       readable-stream: 3.6.2
 
+  blob-util@2.0.2: {}
+
   block-stream2@2.1.0:
     dependencies:
       readable-stream: 3.6.2
 
   bluebird@3.4.7: {}
 
+  bluebird@3.7.2: {}
+
   body-parser@1.20.5:
     dependencies:
       bytes: 3.1.2
@@ -17493,7 +17945,7 @@ snapshots:
     dependencies:
       bytes: 3.1.2
       content-type: 1.0.5
-      debug: 4.4.3(supports-color@5.5.0)
+      debug: 4.4.3(supports-color@8.1.1)
       http-errors: 2.0.1
       iconv-lite: 0.7.2
       on-finished: 2.4.1
@@ -17624,6 +18076,8 @@ snapshots:
       union-value: 1.0.1
       unset-value: 1.0.0
 
+  cachedir@2.4.0: {}
+
   call-bind-apply-helpers@1.0.2:
     dependencies:
       es-errors: 1.3.0
@@ -17665,6 +18119,8 @@ snapshots:
       svg-pathdata: 6.0.3
     optional: true
 
+  caseless@0.12.0: {}
+
   cfb@1.2.2:
     dependencies:
       adler-32: 1.3.1
@@ -17731,6 +18187,8 @@ snapshots:
 
   ci-info@3.9.0: {}
 
+  ci-info@4.4.0: {}
+
   citty@0.1.6:
     dependencies:
       consola: 3.4.2
@@ -17774,6 +18232,12 @@ snapshots:
 
   cli-spinners@2.9.2: {}
 
+  cli-table3@0.6.1:
+    dependencies:
+      string-width: 4.2.3
+    optionalDependencies:
+      colors: 1.4.0
+
   cli-table3@0.6.5:
     dependencies:
       string-width: 4.2.3
@@ -17785,6 +18249,11 @@ snapshots:
       slice-ansi: 5.0.0
       string-width: 7.2.0
 
+  cli-truncate@5.2.0:
+    dependencies:
+      slice-ansi: 8.0.0
+      string-width: 8.2.2
+
   cli-width@1.1.1: {}
 
   cli-width@4.1.0: {}
@@ -17858,6 +18327,9 @@ snapshots:
 
   colors@1.0.3: {}
 
+  colors@1.4.0:
+    optional: true
+
   combined-stream@1.0.8:
     dependencies:
       delayed-stream: 1.0.0
@@ -17872,11 +18344,15 @@ snapshots:
 
   commander@4.1.1: {}
 
+  commander@6.2.1: {}
+
   comment-json@5.0.0:
     dependencies:
       array-timsort: 1.0.3
       esprima: 4.0.1
 
+  common-tags@1.8.2: {}
+
   compare-func@2.0.0:
     dependencies:
       array-ify: 1.0.0
@@ -17953,6 +18429,8 @@ snapshots:
 
   core-js@3.49.0: {}
 
+  core-util-is@1.0.2: {}
+
   core-util-is@1.0.3: {}
 
   cors@2.8.6:
@@ -18084,6 +18562,48 @@ snapshots:
 
   cycle@1.0.3: {}
 
+  cypress@15.18.1:
+    dependencies:
+      '@cypress/request': 4.0.1
+      '@cypress/xvfb': 1.2.4(supports-color@8.1.1)
+      '@types/sinonjs__fake-timers': 8.1.1
+      '@types/sizzle': 2.3.10
+      '@types/tmp': 0.2.6
+      arch: 2.2.0
+      blob-util: 2.0.2
+      bluebird: 3.7.2
+      buffer: 5.7.1
+      cachedir: 2.4.0
+      chalk: 4.1.2
+      ci-info: 4.4.0
+      cli-table3: 0.6.1
+      commander: 6.2.1
+      common-tags: 1.8.2
+      dayjs: 1.11.21
+      debug: 4.4.3(supports-color@8.1.1)
+      eventemitter2: 6.4.7
+      execa: 4.1.0
+      executable: 4.1.1
+      fs-extra: 9.1.0
+      hasha: 5.2.2
+      is-installed-globally: 0.4.0
+      listr2: 9.0.5
+      lodash: 4.18.1
+      log-symbols: 4.1.0
+      minimist: 1.2.8
+      ospath: 1.2.2
+      pretty-bytes: 5.6.0
+      process: 0.11.10
+      proxy-from-env: 1.0.0
+      request-progress: 3.0.0
+      supports-color: 8.1.1
+      systeminformation: 5.33.0
+      tmp: 0.2.7
+      tree-kill: 1.2.2
+      tslib: 1.14.1
+      untildify: 4.0.0
+      yauzl: 3.4.0
+
   d3-array@3.2.4:
     dependencies:
       internmap: 2.0.3
@@ -18126,6 +18646,10 @@ snapshots:
 
   dargs@8.1.0: {}
 
+  dashdash@1.14.1:
+    dependencies:
+      assert-plus: 1.0.0
+
   data-uri-to-buffer@4.0.1: {}
 
   data-uri-to-buffer@6.0.2: {}
@@ -18175,9 +18699,11 @@ snapshots:
     dependencies:
       ms: 2.0.0
 
-  debug@3.2.7:
+  debug@3.2.7(supports-color@8.1.1):
     dependencies:
       ms: 2.1.3
+    optionalDependencies:
+      supports-color: 8.1.1
 
   debug@4.4.3(supports-color@5.5.0):
     dependencies:
@@ -18185,6 +18711,12 @@ snapshots:
     optionalDependencies:
       supports-color: 5.5.0
 
+  debug@4.4.3(supports-color@8.1.1):
+    dependencies:
+      ms: 2.1.3
+    optionalDependencies:
+      supports-color: 8.1.1
+
   decamelize@1.2.0: {}
 
   decimal.js-light@2.5.1: {}
@@ -18366,6 +18898,11 @@ snapshots:
 
   ebec@2.3.0: {}
 
+  ecc-jsbn@0.1.2:
+    dependencies:
+      jsbn: 0.1.1
+      safer-buffer: 2.1.2
+
   ecdsa-sig-formatter@1.0.11:
     dependencies:
       safe-buffer: 5.2.1
@@ -18407,7 +18944,7 @@ snapshots:
   engine.io-client@6.6.5:
     dependencies:
       '@socket.io/component-emitter': 3.1.2
-      debug: 4.4.3(supports-color@5.5.0)
+      debug: 4.4.3(supports-color@8.1.1)
       engine.io-parser: 5.2.3
       ws: 8.20.1
       xmlhttprequest-ssl: 2.1.2
@@ -18427,7 +18964,7 @@ snapshots:
       base64id: 2.0.0
       cookie: 0.7.2
       cors: 2.8.6
-      debug: 4.4.3(supports-color@5.5.0)
+      debug: 4.4.3(supports-color@8.1.1)
       engine.io-parser: 5.2.3
       ws: 8.21.0
     transitivePeerDependencies:
@@ -18651,7 +19188,7 @@ snapshots:
 
   eslint-import-resolver-node@0.3.10:
     dependencies:
-      debug: 3.2.7
+      debug: 3.2.7(supports-color@8.1.1)
       is-core-module: 2.16.2
       resolve: 2.0.0-next.7
     transitivePeerDependencies:
@@ -18660,7 +19197,7 @@ snapshots:
   eslint-import-resolver-typescript@3.10.1(eslint-plugin-import@2.32.0(@typescript-eslint/parser@8.60.1(eslint@8.57.1)(typescript@5.9.3))(eslint@8.57.1))(eslint@8.57.1):
     dependencies:
       '@nolyfill/is-core-module': 1.0.39
-      debug: 4.4.3(supports-color@5.5.0)
+      debug: 4.4.3(supports-color@8.1.1)
       eslint: 8.57.1
       get-tsconfig: 4.14.0
       is-bun-module: 2.0.0
@@ -18674,7 +19211,7 @@ snapshots:
 
   eslint-module-utils@2.13.0(@typescript-eslint/parser@8.60.1(eslint@8.57.1)(typescript@5.9.3))(eslint-import-resolver-node@0.3.10)(eslint-import-resolver-typescript@3.10.1(eslint-plugin-import@2.32.0(@typescript-eslint/parser@8.60.1(eslint@8.57.1)(typescript@5.9.3))(eslint@8.57.1))(eslint@8.57.1))(eslint@8.57.1):
     dependencies:
-      debug: 3.2.7
+      debug: 3.2.7(supports-color@8.1.1)
     optionalDependencies:
       '@typescript-eslint/parser': 8.60.1(eslint@8.57.1)(typescript@5.9.3)
       eslint: 8.57.1
@@ -18690,7 +19227,7 @@ snapshots:
       array.prototype.findlastindex: 1.2.6
       array.prototype.flat: 1.3.3
       array.prototype.flatmap: 1.3.3
-      debug: 3.2.7
+      debug: 3.2.7(supports-color@8.1.1)
       doctrine: 2.1.0
       eslint: 8.57.1
       eslint-import-resolver-node: 0.3.10
@@ -18788,7 +19325,7 @@ snapshots:
       ajv: 6.15.0
       chalk: 4.1.2
       cross-spawn: 7.0.6
-      debug: 4.4.3(supports-color@5.5.0)
+      debug: 4.4.3(supports-color@8.1.1)
       doctrine: 3.0.0
       escape-string-regexp: 4.0.0
       eslint-scope: 7.2.2
@@ -18854,6 +19391,8 @@ snapshots:
 
   event-target-shim@5.0.1: {}
 
+  eventemitter2@6.4.7: {}
+
   eventemitter2@6.4.9: {}
 
   eventemitter3@4.0.7: {}
@@ -18886,6 +19425,18 @@ snapshots:
       unzipper: 0.10.14
       uuid: 8.3.2
 
+  execa@4.1.0:
+    dependencies:
+      cross-spawn: 7.0.6
+      get-stream: 5.2.0
+      human-signals: 1.1.1
+      is-stream: 2.0.1
+      merge-stream: 2.0.0
+      npm-run-path: 4.0.1
+      onetime: 5.1.2
+      signal-exit: 3.0.7
+      strip-final-newline: 2.0.0
+
   execa@5.1.1:
     dependencies:
       cross-spawn: 7.0.6
@@ -18925,6 +19476,10 @@ snapshots:
       strip-final-newline: 4.0.0
       yoctocolors: 2.1.2
 
+  executable@4.1.1:
+    dependencies:
+      pify: 2.3.0
+
   exit-hook@1.1.1: {}
 
   exit@0.1.2: {}
@@ -19000,7 +19555,7 @@ snapshots:
       content-type: 1.0.5
       cookie: 0.7.2
       cookie-signature: 1.2.2
-      debug: 4.4.3(supports-color@5.5.0)
+      debug: 4.4.3(supports-color@8.1.1)
       depd: 2.0.0
       encodeurl: 2.0.0
       escape-html: 1.0.3
@@ -19036,6 +19591,8 @@ snapshots:
       assign-symbols: 1.0.0
       is-extendable: 1.0.1
 
+  extend@3.0.2: {}
+
   extglob@2.0.4:
     dependencies:
       array-unique: 0.3.2
@@ -19051,7 +19608,7 @@ snapshots:
 
   extract-zip@2.0.1:
     dependencies:
-      debug: 4.4.3(supports-color@5.5.0)
+      debug: 4.4.3(supports-color@8.1.1)
       get-stream: 5.2.0
       yauzl: 2.10.0
     optionalDependencies:
@@ -19059,6 +19616,8 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
+  extsprintf@1.3.0: {}
+
   eyes@0.1.8: {}
 
   falsey@0.3.2:
@@ -19200,7 +19759,7 @@ snapshots:
 
   finalhandler@2.1.1:
     dependencies:
-      debug: 4.4.3(supports-color@5.5.0)
+      debug: 4.4.3(supports-color@8.1.1)
       encodeurl: 2.0.0
       escape-html: 1.0.3
       on-finished: 2.4.1
@@ -19266,6 +19825,8 @@ snapshots:
       cross-spawn: 7.0.6
       signal-exit: 4.1.0
 
+  forever-agent@0.6.1: {}
+
   fork-ts-checker-webpack-plugin@9.1.0(typescript@5.9.3)(webpack@5.106.0):
     dependencies:
       '@babel/code-frame': 7.29.7
@@ -19341,6 +19902,13 @@ snapshots:
       jsonfile: 6.2.1
       universalify: 2.0.1
 
+  fs-extra@9.1.0:
+    dependencies:
+      at-least-node: 1.0.0
+      graceful-fs: 4.2.11
+      jsonfile: 6.2.1
+      universalify: 2.0.1
+
   fs-monkey@1.1.0: {}
 
   fs.realpath@1.0.0: {}
@@ -19434,12 +20002,16 @@ snapshots:
     dependencies:
       basic-ftp: 5.3.1
       data-uri-to-buffer: 6.0.2
-      debug: 4.4.3(supports-color@5.5.0)
+      debug: 4.4.3(supports-color@8.1.1)
     transitivePeerDependencies:
       - supports-color
 
   get-value@2.0.6: {}
 
+  getpass@0.1.7:
+    dependencies:
+      assert-plus: 1.0.0
+
   giget@2.0.0:
     dependencies:
       citty: 0.1.6
@@ -19501,6 +20073,10 @@ snapshots:
     dependencies:
       ini: 4.1.1
 
+  global-dirs@3.0.1:
+    dependencies:
+      ini: 2.0.0
+
   globals@13.24.0:
     dependencies:
       type-fest: 0.20.2
@@ -19623,6 +20199,11 @@ snapshots:
       is-number: 3.0.0
       kind-of: 4.0.0
 
+  hasha@5.2.2:
+    dependencies:
+      is-stream: 2.0.1
+      type-fest: 0.8.1
+
   hasown@2.0.4:
     dependencies:
       function-bind: 1.1.2
@@ -19702,24 +20283,32 @@ snapshots:
   http-proxy-agent@7.0.2:
     dependencies:
       agent-base: 7.1.4
-      debug: 4.4.3(supports-color@5.5.0)
+      debug: 4.4.3(supports-color@8.1.1)
     transitivePeerDependencies:
       - supports-color
 
+  http-signature@1.4.0:
+    dependencies:
+      assert-plus: 1.0.0
+      jsprim: 2.0.2
+      sshpk: 1.18.0
+
   https-proxy-agent@5.0.1:
     dependencies:
       agent-base: 6.0.2
-      debug: 4.4.3(supports-color@5.5.0)
+      debug: 4.4.3(supports-color@8.1.1)
     transitivePeerDependencies:
       - supports-color
 
   https-proxy-agent@7.0.6:
     dependencies:
       agent-base: 7.1.4
-      debug: 4.4.3(supports-color@5.5.0)
+      debug: 4.4.3(supports-color@8.1.1)
     transitivePeerDependencies:
       - supports-color
 
+  human-signals@1.1.1: {}
+
   human-signals@2.1.0: {}
 
   human-signals@5.0.0: {}
@@ -19795,6 +20384,8 @@ snapshots:
 
   inherits@2.0.4: {}
 
+  ini@2.0.0: {}
+
   ini@4.1.1: {}
 
   input-format@0.3.14(react-dom@19.2.6(react@19.2.6))(react@19.2.6):
@@ -19960,6 +20551,11 @@ snapshots:
     dependencies:
       is-docker: 3.0.0
 
+  is-installed-globally@0.4.0:
+    dependencies:
+      global-dirs: 3.0.1
+      is-path-inside: 3.0.3
+
   is-interactive@1.0.0: {}
 
   is-interactive@2.0.0: {}
@@ -20051,6 +20647,8 @@ snapshots:
     dependencies:
       which-typed-array: 1.1.22
 
+  is-typedarray@1.0.0: {}
+
   is-unicode-supported@0.1.0: {}
 
   is-unicode-supported@1.3.0: {}
@@ -20124,7 +20722,7 @@ snapshots:
 
   istanbul-lib-source-maps@4.0.1:
     dependencies:
-      debug: 4.4.3(supports-color@5.5.0)
+      debug: 4.4.3(supports-color@8.1.1)
       istanbul-lib-coverage: 3.2.2
       source-map: 0.6.1
     transitivePeerDependencies:
@@ -20514,6 +21112,8 @@ snapshots:
     dependencies:
       argparse: 2.0.1
 
+  jsbn@0.1.1: {}
+
   jsdom@25.0.1:
     dependencies:
       cssstyle: 4.6.0
@@ -20554,10 +21154,14 @@ snapshots:
 
   json-schema-typed@8.0.2: {}
 
+  json-schema@0.4.0: {}
+
   json-stable-stringify-without-jsonify@1.0.1: {}
 
   json-stream@1.0.0: {}
 
+  json-stringify-safe@5.0.1: {}
+
   json5@1.0.2:
     dependencies:
       minimist: 1.2.8
@@ -20626,6 +21230,13 @@ snapshots:
       dompurify: 3.4.8
       html2canvas: 1.4.1
 
+  jsprim@2.0.2:
+    dependencies:
+      assert-plus: 1.0.0
+      extsprintf: 1.3.0
+      json-schema: 0.4.0
+      verror: 1.10.0
+
   jsx-ast-utils@3.3.5:
     dependencies:
       array-includes: 3.1.9
@@ -20778,7 +21389,7 @@ snapshots:
     dependencies:
       chalk: 5.6.2
       commander: 13.1.0
-      debug: 4.4.3(supports-color@5.5.0)
+      debug: 4.4.3(supports-color@8.1.1)
       execa: 8.0.1
       lilconfig: 3.1.3
       listr2: 8.3.3
@@ -20800,6 +21411,15 @@ snapshots:
       rfdc: 1.4.1
       wrap-ansi: 9.0.2
 
+  listr2@9.0.5:
+    dependencies:
+      cli-truncate: 5.2.0
+      colorette: 2.0.20
+      eventemitter3: 5.0.4
+      log-update: 6.1.0
+      rfdc: 1.4.1
+      wrap-ansi: 9.0.2
+
   little-state-machine@4.8.1(react@19.2.6):
     dependencies:
       react: 19.2.6
@@ -21493,6 +22113,8 @@ snapshots:
       string-width: 7.2.0
       strip-ansi: 7.2.0
 
+  ospath@1.2.2: {}
+
   outvariant@1.4.3: {}
 
   own-keys@1.0.1:
@@ -21531,7 +22153,7 @@ snapshots:
     dependencies:
       '@tootallnate/quickjs-emscripten': 0.23.0
       agent-base: 7.1.4
-      debug: 4.4.3(supports-color@5.5.0)
+      debug: 4.4.3(supports-color@8.1.1)
       get-uri: 6.0.5
       http-proxy-agent: 7.0.2
       https-proxy-agent: 7.0.6
@@ -21658,8 +22280,7 @@ snapshots:
 
   perfect-debounce@1.0.0: {}
 
-  performance-now@2.1.0:
-    optional: true
+  performance-now@2.1.0: {}
 
   pg-cloudflare@1.4.0:
     optional: true
@@ -21814,6 +22435,8 @@ snapshots:
 
   prettier@3.8.3: {}
 
+  pretty-bytes@5.6.0: {}
+
   pretty-format@29.7.0:
     dependencies:
       '@jest/schemas': 29.6.3
@@ -21860,7 +22483,7 @@ snapshots:
   proxy-agent@6.5.0:
     dependencies:
       agent-base: 7.1.4
-      debug: 4.4.3(supports-color@5.5.0)
+      debug: 4.4.3(supports-color@8.1.1)
       http-proxy-agent: 7.0.2
       https-proxy-agent: 7.0.6
       lru-cache: 7.18.3
@@ -21870,6 +22493,8 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
+  proxy-from-env@1.0.0: {}
+
   proxy-from-env@1.1.0: {}
 
   proxy-from-env@2.1.0: {}
@@ -21887,7 +22512,7 @@ snapshots:
     dependencies:
       '@puppeteer/browsers': 2.13.2
       chromium-bidi: 14.0.0(devtools-protocol@0.0.1608973)
-      debug: 4.4.3(supports-color@5.5.0)
+      debug: 4.4.3(supports-color@8.1.1)
       devtools-protocol: 0.0.1608973
       typed-query-selector: 2.12.2
       webdriver-bidi-protocol: 0.4.1
@@ -22127,6 +22752,15 @@ snapshots:
       - '@babel/core'
       - react-is
 
+  react-css-nocode-editor@1.0.13(react-dom@19.2.6(react@19.2.6))(react-is@19.2.7)(react@19.2.6):
+    dependencies:
+      react: 19.2.6
+      react-dom: 19.2.6(react@19.2.6)
+      styled-components: 5.3.11(react-dom@19.2.6(react@19.2.6))(react-is@19.2.7)(react@19.2.6)
+    transitivePeerDependencies:
+      - '@babel/core'
+      - react-is
+
   react-day-picker@8.10.2(date-fns@3.6.0)(react@19.2.6):
     dependencies:
       date-fns: 3.6.0
@@ -22568,6 +23202,10 @@ snapshots:
 
   repeat-string@1.6.1: {}
 
+  request-progress@3.0.0:
+    dependencies:
+      throttleit: 1.0.1
+
   require-directory@2.1.1: {}
 
   require-from-string@2.0.2: {}
@@ -22688,7 +23326,7 @@ snapshots:
 
   router@2.2.0:
     dependencies:
-      debug: 4.4.3(supports-color@5.5.0)
+      debug: 4.4.3(supports-color@8.1.1)
       depd: 2.0.0
       is-promise: 4.0.0
       parseurl: 1.3.3
@@ -22806,7 +23444,7 @@ snapshots:
 
   send@1.2.1:
     dependencies:
-      debug: 4.4.3(supports-color@5.5.0)
+      debug: 4.4.3(supports-color@8.1.1)
       encodeurl: 2.0.0
       escape-html: 1.0.3
       etag: 1.8.1
@@ -22990,6 +23628,11 @@ snapshots:
       ansi-styles: 6.2.3
       is-fullwidth-code-point: 5.1.0
 
+  slice-ansi@8.0.0:
+    dependencies:
+      ansi-styles: 6.2.3
+      is-fullwidth-code-point: 5.1.0
+
   smart-buffer@4.2.0: {}
 
   smob@1.6.2: {}
@@ -23019,7 +23662,7 @@ snapshots:
 
   socket.io-adapter@2.5.8:
     dependencies:
-      debug: 4.4.3(supports-color@5.5.0)
+      debug: 4.4.3(supports-color@8.1.1)
       ws: 8.21.0
     transitivePeerDependencies:
       - bufferutil
@@ -23029,7 +23672,7 @@ snapshots:
   socket.io-client@4.8.3:
     dependencies:
       '@socket.io/component-emitter': 3.1.2
-      debug: 4.4.3(supports-color@5.5.0)
+      debug: 4.4.3(supports-color@8.1.1)
       engine.io-client: 6.6.5
       socket.io-parser: 4.2.6
     transitivePeerDependencies:
@@ -23040,7 +23683,7 @@ snapshots:
   socket.io-parser@4.2.6:
     dependencies:
       '@socket.io/component-emitter': 3.1.2
-      debug: 4.4.3(supports-color@5.5.0)
+      debug: 4.4.3(supports-color@8.1.1)
     transitivePeerDependencies:
       - supports-color
 
@@ -23049,7 +23692,7 @@ snapshots:
       accepts: 1.3.8
       base64id: 2.0.0
       cors: 2.8.6
-      debug: 4.4.3(supports-color@5.5.0)
+      debug: 4.4.3(supports-color@8.1.1)
       engine.io: 6.6.9
       socket.io-adapter: 2.5.8
       socket.io-parser: 4.2.6
@@ -23061,7 +23704,7 @@ snapshots:
   socks-proxy-agent@8.0.5:
     dependencies:
       agent-base: 7.1.4
-      debug: 4.4.3(supports-color@5.5.0)
+      debug: 4.4.3(supports-color@8.1.1)
       socks: 2.8.9
     transitivePeerDependencies:
       - supports-color
@@ -23122,6 +23765,18 @@ snapshots:
     dependencies:
       frac: 1.1.2
 
+  sshpk@1.18.0:
+    dependencies:
+      asn1: 0.2.6
+      assert-plus: 1.0.0
+      bcrypt-pbkdf: 1.0.2
+      dashdash: 1.14.1
+      ecc-jsbn: 0.1.2
+      getpass: 0.1.7
+      jsbn: 0.1.1
+      safer-buffer: 2.1.2
+      tweetnacl: 0.14.5
+
   stable-hash@0.0.5: {}
 
   stack-trace@0.0.10: {}
@@ -23202,6 +23857,11 @@ snapshots:
       get-east-asian-width: 1.6.0
       strip-ansi: 7.2.0
 
+  string-width@8.2.2:
+    dependencies:
+      get-east-asian-width: 1.6.0
+      strip-ansi: 7.2.0
+
   string.prototype.includes@2.0.1:
     dependencies:
       call-bind: 1.0.9
@@ -23324,6 +23984,24 @@ snapshots:
     transitivePeerDependencies:
       - '@babel/core'
 
+  styled-components@5.3.11(react-dom@19.2.6(react@19.2.6))(react-is@19.2.7)(react@19.2.6):
+    dependencies:
+      '@babel/helper-module-imports': 7.29.7(supports-color@5.5.0)
+      '@babel/traverse': 7.29.7(supports-color@5.5.0)
+      '@emotion/is-prop-valid': 1.4.0
+      '@emotion/stylis': 0.8.5
+      '@emotion/unitless': 0.7.5
+      babel-plugin-styled-components: 2.3.0(styled-components@5.3.11(react-dom@19.2.6(react@19.2.6))(react-is@19.2.7)(react@19.2.6))(supports-color@5.5.0)
+      css-to-react-native: 3.2.0
+      hoist-non-react-statics: 3.3.2
+      react: 19.2.6
+      react-dom: 19.2.6(react@19.2.6)
+      react-is: 19.2.7
+      shallowequal: 1.1.0
+      supports-color: 5.5.0
+    transitivePeerDependencies:
+      - '@babel/core'
+
   styled-jsx@5.1.1(babel-plugin-macros@3.1.0)(react@18.3.1):
     dependencies:
       client-only: 0.0.1
@@ -23349,7 +24027,7 @@ snapshots:
     dependencies:
       component-emitter: 1.3.1
       cookiejar: 2.1.4
-      debug: 4.4.3(supports-color@5.5.0)
+      debug: 4.4.3(supports-color@8.1.1)
       fast-safe-stringify: 2.1.1
       form-data: 4.0.5
       formidable: 3.5.4
@@ -23403,6 +24081,8 @@ snapshots:
 
   symbol-tree@3.2.4: {}
 
+  systeminformation@5.33.0: {}
+
   tabbable@6.4.0: {}
 
   tagged-tag@1.0.0: {}
@@ -23530,6 +24210,8 @@ snapshots:
     dependencies:
       any-promise: 1.3.0
 
+  throttleit@1.0.1: {}
+
   through2@2.0.5:
     dependencies:
       readable-stream: 2.3.8
@@ -23639,6 +24321,8 @@ snapshots:
 
   traverse@0.3.9: {}
 
+  tree-kill@1.2.2: {}
+
   trim-canvas@0.1.2: {}
 
   ts-api-utils@2.5.0(typescript@5.9.3):
@@ -23743,6 +24427,10 @@ snapshots:
 
   tslib@2.8.1: {}
 
+  tunnel-agent@0.6.0:
+    dependencies:
+      safe-buffer: 5.2.1
+
   turbo@2.9.16:
     optionalDependencies:
       '@turbo/darwin-64': 2.9.16
@@ -23754,6 +24442,8 @@ snapshots:
 
   tw-animate-css@1.4.0: {}
 
+  tweetnacl@0.14.5: {}
+
   type-check@0.4.0:
     dependencies:
       prelude-ls: 1.2.1
@@ -23764,6 +24454,8 @@ snapshots:
 
   type-fest@0.21.3: {}
 
+  type-fest@0.8.1: {}
+
   type-fest@4.41.0: {}
 
   type-fest@5.7.0:
@@ -23842,7 +24534,7 @@ snapshots:
       app-root-path: 3.1.0
       buffer: 6.0.3
       dayjs: 1.11.21
-      debug: 4.4.3(supports-color@5.5.0)
+      debug: 4.4.3(supports-color@8.1.1)
       dedent: 1.7.2(babel-plugin-macros@3.1.0)
       dotenv: 16.6.1
       glob: 10.5.0
@@ -23866,7 +24558,7 @@ snapshots:
       app-root-path: 3.1.0
       buffer: 6.0.3
       dayjs: 1.11.21
-      debug: 4.4.3(supports-color@5.5.0)
+      debug: 4.4.3(supports-color@8.1.1)
       dedent: 1.7.2(babel-plugin-macros@3.1.0)
       dotenv: 16.6.1
       glob: 10.5.0
@@ -23968,6 +24660,8 @@ snapshots:
 
   until-async@3.0.2: {}
 
+  untildify@4.0.0: {}
+
   unzipper@0.10.14:
     dependencies:
       big-integer: 1.6.52
@@ -24118,6 +24812,12 @@ snapshots:
       - '@types/react'
       - '@types/react-dom'
 
+  verror@1.10.0:
+    dependencies:
+      assert-plus: 1.0.0
+      core-util-is: 1.0.2
+      extsprintf: 1.3.0
+
   victory-vendor@36.9.2:
     dependencies:
       '@types/d3-array': 3.2.2
@@ -24161,7 +24861,7 @@ snapshots:
   vite-node@2.1.9(@types/node@24.13.1)(lightningcss@1.32.0)(terser@5.48.0):
     dependencies:
       cac: 6.7.14
-      debug: 4.4.3(supports-color@5.5.0)
+      debug: 4.4.3(supports-color@8.1.1)
       es-module-lexer: 1.7.0
       pathe: 1.1.2
       vite: 5.4.21(@types/node@24.13.1)(lightningcss@1.32.0)(terser@5.48.0)
@@ -24197,7 +24897,7 @@ snapshots:
       '@vitest/spy': 2.1.9
       '@vitest/utils': 2.1.9
       chai: 5.3.3
-      debug: 4.4.3(supports-color@5.5.0)
+      debug: 4.4.3(supports-color@8.1.1)
       expect-type: 1.3.0
       magic-string: 0.30.21
       pathe: 1.1.2
@@ -24538,6 +25238,10 @@ snapshots:
       buffer-crc32: 0.2.13
       fd-slicer: 1.1.0
 
+  yauzl@3.4.0:
+    dependencies:
+      pend: 1.2.0
+
   year@0.2.1: {}
 
   yn@3.1.1: {}
diff --git a/pnpm-workspace.yaml b/pnpm-workspace.yaml
index ecf919f09..e5e748478 100644
--- a/pnpm-workspace.yaml
+++ b/pnpm-workspace.yaml
@@ -4,6 +4,7 @@ packages:
   - "apps/edr-passenger-web/*"
   - "packages/*"
   - "packages/config/*"
+  - "e2e/*"
 verifyDepsBeforeRun: warn
 allowBuilds:
   "@nestjs/core": true
@@ -14,6 +15,7 @@ allowBuilds:
   argon2: true
   bcrypt: true
   core-js: true
+  cypress: true
   es5-ext: true
   esbuild: true
   highlight.js: true
diff --git a/ticket-extractor.html b/ticket-extractor.html
deleted file mode 100644
index 17be60576..000000000
--- a/ticket-extractor.html
+++ /dev/null
@@ -1,239 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-  <meta charset="UTF-8" />
-  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-  <title>EDR Ticket Extractor</title>
-  <style>
-    * { box-sizing: border-box; margin: 0; padding: 0; }
-    body { font-family: system-ui, sans-serif; background: #f1f5f9; color: #1e293b; min-height: 100vh; padding: 2rem; }
-    h1 { font-size: 1.25rem; font-weight: 700; margin-bottom: 1.5rem; color: #0f172a; }
-    .card { background: #fff; border-radius: 0.75rem; border: 1px solid #e2e8f0; padding: 1.5rem; margin-bottom: 1.5rem; }
-    label { display: block; font-size: 0.8rem; font-weight: 600; color: #475569; margin-bottom: 0.4rem; text-transform: uppercase; letter-spacing: 0.05em; }
-    .hint { font-size: 0.75rem; color: #94a3b8; margin-top: 0.35rem; }
-    .drop-zone {
-      border: 2px dashed #cbd5e1; border-radius: 0.5rem; padding: 2rem;
-      text-align: center; cursor: pointer; color: #94a3b8; font-size: 0.9rem;
-      transition: border-color 0.15s, background 0.15s;
-    }
-    .drop-zone.over { border-color: #10b981; background: #f0fdf4; color: #065f46; }
-    .drop-zone input[type="file"] { display: none; }
-    button {
-      background: #10b981; color: #fff; border: none; border-radius: 0.5rem;
-      padding: 0.65rem 1.5rem; font-size: 0.9rem; font-weight: 600; cursor: pointer; transition: background 0.15s;
-    }
-    button:hover:not(:disabled) { background: #059669; }
-    button:disabled { background: #a7f3d0; cursor: not-allowed; }
-    .btn-secondary { background: #e2e8f0; color: #475569; }
-    .btn-secondary:hover:not(:disabled) { background: #cbd5e1; }
-    .export-btn { background: #6366f1; color: #fff; }
-    .export-btn:hover:not(:disabled) { background: #4f46e5; }
-    .btn-row { display: flex; gap: 0.75rem; align-items: center; margin-top: 1rem; flex-wrap: wrap; }
-    #status { font-size: 0.85rem; color: #64748b; }
-    .summary { display: flex; gap: 1.5rem; flex-wrap: wrap; margin-bottom: 1rem; font-size: 0.85rem; color: #475569; }
-    .summary strong { color: #0f172a; }
-    .table-wrap { overflow-x: auto; }
-    table { width: 100%; border-collapse: collapse; font-size: 0.82rem; }
-    thead tr { background: #f8fafc; border-bottom: 2px solid #e2e8f0; }
-    th { text-align: left; padding: 0.5rem 0.75rem; font-weight: 600; color: #475569; font-size: 0.72rem; text-transform: uppercase; letter-spacing: 0.04em; white-space: nowrap; }
-    td { padding: 0.5rem 0.75rem; border-bottom: 1px solid #f1f5f9; vertical-align: middle; }
-    tr:last-child td { border-bottom: none; }
-    tr:hover td { background: #f8fafc; }
-    #results-section { display: none; }
-  </style>
-</head>
-<body>
-
-<h1>EDR Ticket Extractor</h1>
-
-<div class="card">
-  <label>Tickets JSON File</label>
-  <div class="drop-zone" id="drop-zone" onclick="document.getElementById('file-input').click()">
-    <input type="file" id="file-input" accept=".json" onchange="handleFile(this.files[0])" />
-    Drop <code>tickets.json</code> here or click to browse
-  </div>
-  <p class="hint">Accepts a JSON array of tickets or an object with a <code>tickets</code> key.</p>
-  <div class="btn-row">
-    <button class="btn-secondary" onclick="clearAll()">Clear</button>
-    <button class="export-btn" id="export-btn" onclick="exportCSV()" style="display:none">Export CSV</button>
-    <span id="status"></span>
-  </div>
-</div>
-
-<div class="card" id="results-section">
-  <div class="summary" id="summary"></div>
-  <div class="table-wrap">
-    <table>
-      <thead>
-        <tr>
-          <th>#</th>
-          <th>Ticket No.</th>
-          <th>Booking Ref</th>
-          <th>Passenger</th>
-          <th>Phone</th>
-          <th>Email</th>
-          <th>Journey Type</th>
-          <th>Origin</th>
-          <th>Destination</th>
-          <th>Seat Class</th>
-          <th>Coach</th>
-          <th>Seat</th>
-        </tr>
-      </thead>
-      <tbody id="tbody"></tbody>
-    </table>
-  </div>
-</div>
-
-<script>
-  const FIELDS = [
-    { key: 'ticket_number',   paths: [['ticketNumber']] },
-    { key: 'booking_ref',     paths: [['bookingRef']] },
-    { key: 'passenger_name',  paths: [['passengerName'], ['booking','seats',0,'passengerName']] },
-    { key: 'phone_number',    paths: [['booking','contactPhone'], ['booking','passenger','phone']] },
-    { key: 'email',           paths: [['booking','contactEmail'], ['booking','passenger','email']] },
-    { key: 'journey_type',    paths: [['booking','bookingType']] },
-    { key: 'origin',          paths: [['schedule','originStation','code']] },
-    { key: 'destination',     paths: [['schedule','destinationStation','code']] },
-    { key: 'seat_class',      paths: [['seat','coach','coachType','name']] },
-    { key: 'coach_number',    paths: [['seat','coach','number']] },
-    { key: 'seat_number',     paths: [['seat','seatNumber']] },
-  ];
-
-  let extracted = [];
-
-  function getField(obj, keys) {
-    let cur = obj;
-    for (const k of keys) {
-      if (cur == null) return '';
-      if (Array.isArray(cur) && typeof k === 'number') cur = cur[k];
-      else if (typeof cur === 'object' && k in cur) cur = cur[k];
-      else return '';
-    }
-    return cur ?? '';
-  }
-
-  function extractRow(t) {
-    const row = {};
-    for (const f of FIELDS) {
-      for (const path of f.paths) {
-        const val = getField(t, path);
-        if (val !== '') { row[f.key] = String(val); break; }
-      }
-      if (!row[f.key]) row[f.key] = '';
-    }
-    return row;
-  }
-
-  // Extract complete JSON objects from a truncated array string using brace-depth counting
-  function extractObjects(text) {
-    const results = [];
-    let depth = 0, start = -1, inString = false, escape = false;
-    for (let i = 0; i < text.length; i++) {
-      const ch = text[i];
-      if (escape) { escape = false; continue; }
-      if (ch === '\\' && inString) { escape = true; continue; }
-      if (ch === '"') { inString = !inString; continue; }
-      if (inString) continue;
-      if (ch === '{') {
-        if (depth === 0) start = i;
-        depth++;
-      } else if (ch === '}') {
-        depth--;
-        if (depth === 0 && start !== -1) {
-          try { results.push(JSON.parse(text.slice(start, i + 1))); } catch (_) {}
-          start = -1;
-        }
-      }
-    }
-    return results;
-  }
-
-  window.handleFile = function(file) {
-    if (!file) return;
-    setStatus(`Reading ${file.name}…`);
-    const reader = new FileReader();
-    reader.onload = e => {
-      try {
-        const text = e.target.result.replace(/^\uFEFF/, '');
-        let tickets = [];
-        let parseWarning = '';
-        try {
-          const data = JSON.parse(text);
-          tickets = Array.isArray(data) ? data : (data.tickets ?? []);
-        } catch (_) {
-          // Truncated file: extract complete JSON objects by brace depth
-          tickets = extractObjects(text);
-          parseWarning = `⚠ File was truncated — recovered ${tickets.length} complete record(s).`;
-        }
-        if (!Array.isArray(tickets) || !tickets.length) throw new Error('No ticket records found in the JSON.');
-        extracted = tickets.map(extractRow);
-        renderTable();
-        document.getElementById('results-section').style.display = 'block';
-        document.getElementById('export-btn').style.display = 'inline-block';
-        document.getElementById('summary').innerHTML = `Loaded <strong>${extracted.length}</strong> ticket(s) from <strong>${file.name}</strong>`;
-        setStatus(parseWarning);
-      } catch (err) {
-        setStatus(`Error: ${err.message}`);
-      }
-    };
-    reader.readAsText(file);
-  }
-
-  function renderTable() {
-    const tbody = document.getElementById('tbody');
-    tbody.innerHTML = '';
-    extracted.forEach((row, i) => {
-      const tr = document.createElement('tr');
-      tr.innerHTML = `
-        <td>${i + 1}</td>
-        <td><code>${row.ticket_number || '—'}</code></td>
-        <td><code>${row.booking_ref || '—'}</code></td>
-        <td>${row.passenger_name || '—'}</td>
-        <td>${row.phone_number || '—'}</td>
-        <td>${row.email || '—'}</td>
-        <td>${row.journey_type || '—'}</td>
-        <td>${row.origin || '—'}</td>
-        <td>${row.destination || '—'}</td>
-        <td>${row.seat_class || '—'}</td>
-        <td>${row.coach_number || '—'}</td>
-        <td>${row.seat_number || '—'}</td>`;
-      tbody.appendChild(tr);
-    });
-  }
-
-  window.exportCSV = function() {
-    const header = FIELDS.map(f => f.key).join(',');
-    const lines = extracted.map(row =>
-      FIELDS.map(f => `"${String(row[f.key] ?? '').replace(/"/g, '""')}"`).join(',')
-    );
-    const csv = [header, ...lines].join('\n');
-    const a = document.createElement('a');
-    a.href = URL.createObjectURL(new Blob([csv], { type: 'text/csv' }));
-    a.download = 'tickets_extracted.csv';
-    a.click();
-  }
-
-  window.clearAll = function() {
-    extracted = [];
-    document.getElementById('tbody').innerHTML = '';
-    document.getElementById('results-section').style.display = 'none';
-    document.getElementById('export-btn').style.display = 'none';
-    document.getElementById('file-input').value = '';
-    setStatus('');
-  }
-
-  function setStatus(msg) { document.getElementById('status').textContent = msg; }
-
-  // Drag and drop
-  const dz = document.getElementById('drop-zone');
-  dz.addEventListener('dragover', e => { e.preventDefault(); dz.classList.add('over'); });
-  dz.addEventListener('dragleave', () => dz.classList.remove('over'));
-  dz.addEventListener('drop', e => {
-    e.preventDefault(); dz.classList.remove('over');
-    handleFile(e.dataTransfer.files[0]);
-  });
-</script>
-
-</body>
-</html>