diff --git a/apps/edr-freight-api/src/app.module.ts b/apps/edr-freight-api/src/app.module.ts
index 64df33f35..df82299a8 100644
--- a/apps/edr-freight-api/src/app.module.ts
+++ b/apps/edr-freight-api/src/app.module.ts
@@ -2,6 +2,7 @@ import {
   MiddlewareConsumer,
   Module,
   OnApplicationBootstrap,
+  RequestMethod,
 } from "@nestjs/common";
 import { ConfigModule, ConfigService } from "@nestjs/config";
 import { TypeOrmModule, TypeOrmModuleOptions } from "@nestjs/typeorm";
@@ -101,6 +102,7 @@ import { InterchangeDocumentsModule } from "./modules/interchange-documents/inte
 import { ImportOperationsModule } from "./modules/import-operations/import-operations.module";
 import { AiModule } from "./modules/ai/ai.module";
 import { LoggerMiddleware } from "./logger.middleware";
+import { LoginAudienceMiddleware } from "./modules/auth/login-audience.middleware";
 
 @Module({
   imports: [
@@ -240,6 +242,7 @@ import { LoggerMiddleware } from "./logger.middleware";
     // MarshallingDemoTrainsSeeder,
     ApprovedFirstLastMileDemoBookingsSeeder,
     PaidImportExportMileDemoSeeder,
+    LoginAudienceMiddleware,
   ],
 })
 export class AppModule implements OnApplicationBootstrap {
@@ -328,5 +331,9 @@ export class AppModule implements OnApplicationBootstrap {
 
   configure(consumer: MiddlewareConsumer) {
     consumer.apply(LoggerMiddleware).forRoutes("*");
+    consumer.apply(LoginAudienceMiddleware).forRoutes(
+      { path: "auth/login", method: RequestMethod.POST },
+      { path: "auth/mfa-verify", method: RequestMethod.POST },
+    );
   }
 }
diff --git a/apps/edr-freight-api/src/main.ts b/apps/edr-freight-api/src/main.ts
index 5b027448c..cf4c37b2d 100644
--- a/apps/edr-freight-api/src/main.ts
+++ b/apps/edr-freight-api/src/main.ts
@@ -2,6 +2,7 @@ import "reflect-metadata";
 import * as dotenv from "dotenv";
 dotenv.config();
 import { NestFactory } from "@nestjs/core";
+import type { NestExpressApplication } from "@nestjs/platform-express";
 import { DocumentBuilder, SwaggerModule } from "@nestjs/swagger";
 import {
   HttpExceptionFilter,
@@ -11,8 +12,25 @@ import {
 
 import { AppModule } from "./app.module";
 
+/**
+ * JSON body ceiling. Signing posts the signature AND the company stamp as
+ * base64 in one JSON body, and base64 inflates bytes by ~4/3 — a 10MB stamp is
+ * ~13.4MB on the wire. Express defaults to 100kb, which rejected any real stamp
+ * image with a 413 "request entity too large".
+ */
+const JSON_BODY_LIMIT = '20mb';
+
 async function bootstrap() {
-  const app = await NestFactory.create(AppModule);
+  const app = await NestFactory.create<NestExpressApplication>(AppModule);
+
+  // Nest's own body-parser API, NOT `app.use(json(...))` from express: express
+  // is not a declared dependency of this app (it arrives under
+  // @nestjs/platform-express), so importing it directly resolved only through
+  // pnpm's hoisted dev store and died as MODULE_NOT_FOUND in the production
+  // image, where `pnpm deploy --prod` installs declared dependencies only.
+  // This also RECONFIGURES the default parsers rather than racing them.
+  app.useBodyParser('json', { limit: JSON_BODY_LIMIT });
+  app.useBodyParser('urlencoded', { limit: JSON_BODY_LIMIT, extended: true });
 
   // Dev CORS: reflect any localhost origin and allow credentials so the
   // freight portal (5173), passenger portal (5174), backoffices (5183/5184)
@@ -28,6 +46,9 @@ async function bootstrap() {
       "Accept",
       "Authorization",
       "X-Requested-With",
+      // Which freight frontend is calling — /auth/login uses this to reject
+      // cross-audience credentials (EDRFREIGHT-415).
+      "X-Client-App",
       // IAM context headers required by @tria-plc/api-common's JwtGuard
       "organization-unit-id",
       "delegator-position-id",
@@ -40,6 +61,13 @@ async function bootstrap() {
       "x-delegator-position-id",
       "x-current-project-id",
       "x-current-position-id",
+      // Headers sent by the freight-backoffice OKR/objective-service client
+      // (withHeaders.tsx, signatureAndTeeterService.ts, useIncomingReport.ts)
+      // under yet another naming convention — unprefixed "tenant-key"/"unit-id",
+      // and "x-delegated-position-id" (delegated, not delegator).
+      "tenant-key",
+      "unit-id",
+      "x-delegated-position-id",
     ],
     exposedHeaders: ["Content-Disposition"],
     maxAge: 86400, // cache preflight for 24h to cut chatter in dev
diff --git a/apps/edr-freight-api/src/migrations/3000000000000-AddContractSuspension.ts b/apps/edr-freight-api/src/migrations/3000000000000-AddContractSuspension.ts
new file mode 100644
index 000000000..0e0484345
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/3000000000000-AddContractSuspension.ts
@@ -0,0 +1,25 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+/**
+ * Backoffice contract suspension (reversible freeze at any post-signature step)
+ * and customer-initiated contract cancellation.
+ *
+ * Only one new column is needed: the status to restore when the suspension is
+ * lifted. The reason and the actor already have a home — contract_review_notes
+ * rows with note_type SUSPENSION / SUSPENSION_LIFTED / CANCELLATION.
+ */
+export class AddContractSuspension3000000000000 implements MigrationInterface {
+  name = 'AddContractSuspension3000000000000';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE freight.contracts ADD COLUMN IF NOT EXISTS status_before_suspension varchar(40);`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE freight.contracts DROP COLUMN IF EXISTS status_before_suspension;`,
+    );
+  }
+}
diff --git a/apps/edr-freight-api/src/migrations/3010000000000-AddBookingTransitAssignee.ts b/apps/edr-freight-api/src/migrations/3010000000000-AddBookingTransitAssignee.ts
new file mode 100644
index 000000000..50fb9db2b
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/3010000000000-AddBookingTransitAssignee.ts
@@ -0,0 +1,31 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+/**
+ * Transit-assignee handshake on the SHIPMENT, not the contract.
+ *
+ * Clearance runs per booking now, so the ask GL Ethiopia raises before filing a
+ * customs declaration ("who handles this shipment in Djibouti?") and Djibouti's
+ * answer belong on the booking. The contract-cycle columns added by
+ * 2950000000000 stay for the legacy contract-level cycles.
+ */
+export class AddBookingTransitAssignee3010000000000 implements MigrationInterface {
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      ALTER TABLE freight.bookings
+        ADD COLUMN IF NOT EXISTS transit_assignee_requested_at timestamptz NULL,
+        ADD COLUMN IF NOT EXISTS transit_assignee_request_note text NULL,
+        ADD COLUMN IF NOT EXISTS transit_assignee_name text NULL,
+        ADD COLUMN IF NOT EXISTS transit_assignee_assigned_at timestamptz NULL
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      ALTER TABLE freight.bookings
+        DROP COLUMN IF EXISTS transit_assignee_requested_at,
+        DROP COLUMN IF EXISTS transit_assignee_request_note,
+        DROP COLUMN IF EXISTS transit_assignee_name,
+        DROP COLUMN IF EXISTS transit_assignee_assigned_at
+    `);
+  }
+}
diff --git a/apps/edr-freight-api/src/migrations/3020000000000-AddContractSubmittedAt.ts b/apps/edr-freight-api/src/migrations/3020000000000-AddContractSubmittedAt.ts
new file mode 100644
index 000000000..f2c579f6b
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/3020000000000-AddContractSubmittedAt.ts
@@ -0,0 +1,23 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+/**
+ * A contract's `created_at` is the DRAFT row's insert time, not when the
+ * customer actually submitted it for review — a DRAFT can sit edited for days
+ * first. `submitted_at` is stamped by ContractTransitionService.submit /
+ * confirmSubmit so the history UI can show a real submission time.
+ */
+export class AddContractSubmittedAt3020000000000 implements MigrationInterface {
+  name = 'AddContractSubmittedAt3020000000000';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE freight.contracts ADD COLUMN IF NOT EXISTS submitted_at timestamptz;`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE freight.contracts DROP COLUMN IF EXISTS submitted_at;`,
+    );
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/auth/login-audience.middleware.spec.ts b/apps/edr-freight-api/src/modules/auth/login-audience.middleware.spec.ts
new file mode 100644
index 000000000..2303c3ef2
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/auth/login-audience.middleware.spec.ts
@@ -0,0 +1,92 @@
+import { ForbiddenException } from '@nestjs/common';
+
+import { LoginAudienceMiddleware } from './login-audience.middleware';
+
+/**
+ * Touches only the DataSource, so build off the prototype rather than
+ * standing up a full Nest module — same pattern as
+ * warehouses/receive-export-paid.spec.ts.
+ */
+function makeMiddleware(userType: string | undefined) {
+  const query = jest.fn().mockResolvedValue(userType ? [{ userType }] : []);
+  const middleware = Object.create(
+    LoginAudienceMiddleware.prototype,
+  ) as LoginAudienceMiddleware;
+  (middleware as unknown as { dataSource: unknown }).dataSource = { query };
+  return middleware;
+}
+
+function makeReq(clientApp: string | undefined, email = 'someone@example.com') {
+  return {
+    header: (name: string) =>
+      name.toLowerCase() === 'x-client-app' ? clientApp : undefined,
+    body: { email },
+  } as any;
+}
+
+describe('LoginAudienceMiddleware', () => {
+  it('rejects when the client app header is missing', async () => {
+    const middleware = makeMiddleware('employee');
+    const next = jest.fn();
+
+    await expect(
+      middleware.use(makeReq(undefined), {} as any, next),
+    ).rejects.toBeInstanceOf(ForbiddenException);
+    expect(next).not.toHaveBeenCalled();
+  });
+
+  it('rejects an unrecognized client app header', async () => {
+    const middleware = makeMiddleware('employee');
+    const next = jest.fn();
+
+    await expect(
+      middleware.use(makeReq('mobile'), {} as any, next),
+    ).rejects.toBeInstanceOf(ForbiddenException);
+  });
+
+  it('rejects an employee account signing in through the portal client', async () => {
+    const middleware = makeMiddleware('employee');
+    const next = jest.fn();
+
+    await expect(
+      middleware.use(makeReq('portal'), {} as any, next),
+    ).rejects.toBeInstanceOf(ForbiddenException);
+    expect(next).not.toHaveBeenCalled();
+  });
+
+  it('rejects a customer account signing in through the backoffice client', async () => {
+    const middleware = makeMiddleware('individual');
+    const next = jest.fn();
+
+    await expect(
+      middleware.use(makeReq('backoffice'), {} as any, next),
+    ).rejects.toBeInstanceOf(ForbiddenException);
+  });
+
+  it('allows an employee account through the backoffice client', async () => {
+    const middleware = makeMiddleware('employee');
+    const next = jest.fn();
+
+    await middleware.use(makeReq('backoffice'), {} as any, next);
+
+    expect(next).toHaveBeenCalledTimes(1);
+  });
+
+  it('allows a customer account through the portal client', async () => {
+    const middleware = makeMiddleware('individual');
+    const next = jest.fn();
+
+    await middleware.use(makeReq('portal'), {} as any, next);
+
+    expect(next).toHaveBeenCalledTimes(1);
+  });
+
+  it('lets an unknown identifier fall through to the login handler', async () => {
+    const middleware = makeMiddleware(undefined);
+    const next = jest.fn();
+
+    await middleware.use(makeReq('portal'), {} as any, next);
+
+    expect(next).toHaveBeenCalledTimes(1);
+  });
+});
diff --git a/apps/edr-freight-api/src/modules/auth/login-audience.middleware.ts b/apps/edr-freight-api/src/modules/auth/login-audience.middleware.ts
new file mode 100644
index 000000000..3af58d02c
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/auth/login-audience.middleware.ts
@@ -0,0 +1,58 @@
+import { ForbiddenException, Injectable, NestMiddleware } from '@nestjs/common';
+import { InjectDataSource } from '@nestjs/typeorm';
+import { DataSource } from 'typeorm';
+import { NextFunction, Request, Response } from 'express';
+
+export const CLIENT_APP_HEADER = 'x-client-app';
+
+// EUserType values from @tria-plc/api-common, duplicated here to avoid
+// pulling in the full enum just for this string comparison.
+const ALLOWED_USER_TYPES_BY_CLIENT: Record<string, string[]> = {
+  backoffice: ['employee'],
+  portal: ['individual', 'external_organization'],
+};
+
+/**
+ * Blocks EDRFREIGHT-415: /auth/login and /auth/mfa-verify match credentials
+ * against email/username/phone_number only (see vendor
+ * findUserForLogin), with no check that the account's userType belongs on
+ * the app that's asking. A backoffice (employee) client presenting a
+ * customer's credentials — or vice versa — must not get a session.
+ */
+@Injectable()
+export class LoginAudienceMiddleware implements NestMiddleware {
+  constructor(@InjectDataSource() private readonly dataSource: DataSource) {}
+
+  async use(req: Request, _res: Response, next: NextFunction) {
+    const clientApp = req.header(CLIENT_APP_HEADER);
+    const allowedUserTypes = clientApp
+      ? ALLOWED_USER_TYPES_BY_CLIENT[clientApp]
+      : undefined;
+    if (!allowedUserTypes) {
+      throw new ForbiddenException(
+        `Missing or unrecognized ${CLIENT_APP_HEADER} header`,
+      );
+    }
+
+    const identifier: unknown = req.body?.email;
+    if (typeof identifier !== 'string' || !identifier) {
+      // No identifier to look up — the vendor DTO validation rejects the
+      // request on its own.
+      return next();
+    }
+
+    const [user] = await this.dataSource.query(
+      `SELECT user_type AS "userType" FROM iam.users
+       WHERE email = $1 OR username = $1 OR phone_number = $1 LIMIT 1`,
+      [identifier],
+    );
+
+    if (user && !allowedUserTypes.includes(user.userType)) {
+      throw new ForbiddenException(
+        `This account cannot sign in through the ${clientApp} application`,
+      );
+    }
+
+    next();
+  }
+}
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 6bef20630..5e8b6aa0e 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
@@ -263,6 +263,36 @@ export class BookingLifecycleNotifierService {
     this.inApp(b, 'Booking cancelled', msg);
   }
 
+  /**
+   * GL Ethiopia asked Djibouti to name the transit officer. Staff-only, and
+   * deep-linked to the Djibouti clearance page where the name is entered — the
+   * customs declaration is blocked until they answer.
+   */
+  transitAssigneeRequested(b: Booking, note: string | null): void {
+    const msg =
+      `GL Ethiopia needs a transit assignee for shipment ${b.reference} before ` +
+      `the customs declaration can be filed.${note ? ` Note: "${note}"` : ''}`;
+    this.logger.log(`TRANSIT ASSIGNEE REQUESTED — ${this.ref(b)}`);
+    this.inAppStaff(b, `Transit assignee needed — ${b.reference}`, msg, {
+      type: NotificationType.CLEARANCE_REVIEW,
+      link: `/dashboard/gl-djibouti/clearance/${b.id}`,
+    });
+  }
+
+  /** Djibouti named (or changed) the transit officer — Ethiopia can proceed. */
+  transitAssigneeAssigned(b: Booking, assignee: string, previous: string | null): void {
+    const msg = previous
+      ? `GL Djibouti changed the transit assignee for shipment ${b.reference} from ` +
+        `"${previous}" to "${assignee}".`
+      : `GL Djibouti assigned ${assignee} to handle shipment ${b.reference} in transit. ` +
+        `The customs declaration can now be filed.`;
+    this.logger.log(`TRANSIT ASSIGNEE ASSIGNED — ${this.ref(b)}`);
+    this.inAppStaff(b, `Transit assignee set — ${b.reference}`, msg, {
+      type: NotificationType.CLEARANCE_REVIEW,
+      link: `/dashboard/bookings/${b.id}/clearance`,
+    });
+  }
+
   // ── Clearance milestones needing customer action ──────────────────────────
 
   /** GL advised duty & tax — the customer must pay and upload the slip. */
@@ -362,6 +392,21 @@ export class BookingLifecycleNotifierService {
     );
   }
 
+  /**
+   * The customer disputed the advised duty & tax. This goes to STAFF, not the
+   * customer: GL Ethiopia is the one who has to re-advise, and the clearance
+   * page is where they do it.
+   */
+  dutyDisputed(b: Booking, note: string): void {
+    const msg =
+      `The customer disputed the duty & tax advised on booking ${this.ref(b)}: ` +
+      `"${note}". Review and re-advise the amount on the clearance page.`;
+    this.inAppStaff(b, `Duty disputed on ${this.ref(b)}`, msg, {
+      type: NotificationType.CLEARANCE_REVIEW,
+      link: `/dashboard/bookings/${b.id}/clearance`,
+    });
+  }
+
   /** Customer uploaded a duty/tax payment slip — GL verifies it. */
   dutySlipUploadedToStaff(b: Booking, round: 'first' | 'second' | 'final'): void {
     const label =
diff --git a/apps/edr-freight-api/src/modules/bookings/booking-transition.accept.spec.ts b/apps/edr-freight-api/src/modules/bookings/booking-transition.accept.spec.ts
index 068ed53af..871d03c72 100644
--- a/apps/edr-freight-api/src/modules/bookings/booking-transition.accept.spec.ts
+++ b/apps/edr-freight-api/src/modules/bookings/booking-transition.accept.spec.ts
@@ -37,7 +37,7 @@ describe('BookingTransitionService — acceptIntake validity window', () => {
       {} as never, // fileUploadSettingsService
       {} as never, // bookingBatchService
       bookingsService as never,
-      { isPhasedGeneralCustomsBooking: () => false } as never,
+      { isPhasedCustomsBooking: () => false } as never,
       {} as never, // workflowService
       {} as never, // invoiceService
       { validate20ftPairing: jest.fn().mockResolvedValue([]) } as never,
@@ -59,6 +59,7 @@ describe('BookingTransitionService — acceptIntake validity window', () => {
         clearanceDocsUploadedToStaff: jest.fn(),
         dutySlipUploadedToStaff: jest.fn(),
       } as never, // notifier
+      { emit: jest.fn() } as never, // events
     );
     return { service, bookingsRepository, ruleEngineService, contractService };
   }
diff --git a/apps/edr-freight-api/src/modules/bookings/booking-transition.clearance.spec.ts b/apps/edr-freight-api/src/modules/bookings/booking-transition.clearance.spec.ts
index 890ae6344..0cc7e59e4 100644
--- a/apps/edr-freight-api/src/modules/bookings/booking-transition.clearance.spec.ts
+++ b/apps/edr-freight-api/src/modules/bookings/booking-transition.clearance.spec.ts
@@ -46,7 +46,7 @@ describe('BookingTransitionService — finalizeClearance gate', () => {
       fileUploadSettingsService as never,
       {} as never, // bookingBatchService
       bookingsService as never,
-      { isPhasedGeneralCustomsBooking: () => false } as never,
+      { isPhasedCustomsBooking: () => false } as never,
       {} as never, // workflowService
       {} as never, // invoiceService
       { validate20ftPairing: jest.fn().mockResolvedValue([]) } as never,
@@ -68,6 +68,7 @@ describe('BookingTransitionService — finalizeClearance gate', () => {
         clearanceDocsUploadedToStaff: jest.fn(),
         dutySlipUploadedToStaff: jest.fn(),
       } as never, // notifier
+      { emit: jest.fn() } as never, // events
     );
     return { service, bookingsRepository };
   }
@@ -149,7 +150,7 @@ describe('BookingTransitionService — finalizeClearance customs output gate', (
       fileUploadSettingsService as never,
       {} as never, // bookingBatchService
       bookingsService as never,
-      { isPhasedGeneralCustomsBooking: () => false } as never,
+      { isPhasedCustomsBooking: () => false } as never,
       {} as never, // workflowService
       {} as never, // invoiceService
       { validate20ftPairing: jest.fn().mockResolvedValue([]) } as never,
@@ -171,6 +172,7 @@ describe('BookingTransitionService — finalizeClearance customs output gate', (
         clearanceDocsUploadedToStaff: jest.fn(),
         dutySlipUploadedToStaff: jest.fn(),
       } as never, // notifier
+      { emit: jest.fn() } as never, // events
     );
     return { service, bookingsRepository };
   }
@@ -238,7 +240,7 @@ describe('BookingTransitionService — submitClearanceDocuments required-fields
       fileUploadSettingsService as never,
       {} as never, // bookingBatchService
       bookingsService as never,
-      { isPhasedGeneralCustomsBooking: () => false } as never,
+      { isPhasedCustomsBooking: () => false } as never,
       {} as never, // workflowService
       {} as never, // invoiceService
       { validate20ftPairing: jest.fn().mockResolvedValue([]) } as never,
@@ -260,6 +262,7 @@ describe('BookingTransitionService — submitClearanceDocuments required-fields
         clearanceDocsUploadedToStaff: jest.fn(),
         dutySlipUploadedToStaff: jest.fn(),
       } as never, // notifier
+      { emit: jest.fn() } as never, // events
     );
     return { service, bookingsRepository, filesService };
   }
diff --git a/apps/edr-freight-api/src/modules/bookings/booking-transition.operation.spec.ts b/apps/edr-freight-api/src/modules/bookings/booking-transition.operation.spec.ts
index cbbb999ef..5f82a8e3b 100644
--- a/apps/edr-freight-api/src/modules/bookings/booking-transition.operation.spec.ts
+++ b/apps/edr-freight-api/src/modules/bookings/booking-transition.operation.spec.ts
@@ -48,7 +48,7 @@ describe('BookingTransitionService — operation review', () => {
       {} as never, // fileUploadSettingsService
       bookingBatchService as never,
       bookingsService as never,
-      { isPhasedGeneralCustomsBooking: () => false } as never,
+      { isPhasedCustomsBooking: () => false } as never,
       {} as never, // workflowService
       invoiceService as never,
       { validate20ftPairing: jest.fn().mockResolvedValue([]) } as never,
@@ -70,6 +70,7 @@ describe('BookingTransitionService — operation review', () => {
         clearanceDocsUploadedToStaff: jest.fn(),
         dutySlipUploadedToStaff: jest.fn(),
       } as never, // notifier
+      { emit: jest.fn() } as never, // events
     );
     return { service, bookingsRepository, bookingBatchService, invoiceService };
   }
@@ -164,11 +165,12 @@ describe('BookingTransitionService — requestOperation export space gate', () =
       {} as never, // fileUploadSettingsService
       bookingBatchService as never,
       bookingsService as never,
-      { isPhasedGeneralCustomsBooking: () => false } as never,
+      { isPhasedCustomsBooking: () => false } as never,
       {} as never, // workflowService
       {} as never, // invoiceService
       { validate20ftPairing: jest.fn().mockResolvedValue([]) } as never,
       notifier as never,
+      { emit: jest.fn() } as never, // events
     );
     return { service, bookingsRepository, bookingBatchService };
   }
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 ec6e466b2..d7b24d514 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,7 +7,7 @@ import {
   Logger,
   Optional,
 } from "@nestjs/common";
-import { OnEvent } from "@nestjs/event-emitter";
+import { EventEmitter2, OnEvent } from "@nestjs/event-emitter";
 
 import { BookingBatchService } from '../train-scheduling/booking-batch.service';
 import { eatDay } from '../train-scheduling/batch-window.util';
@@ -56,11 +56,12 @@ export class BookingTransitionService {
         private readonly invoiceService: BookingInvoiceService,
     private readonly containerValidationService: ContainerValidationService,
     private readonly notifier: BookingLifecycleNotifierService,
+    private readonly events: EventEmitter2,
     @Optional() private readonly milestoneService?: ClearanceMilestoneService,
   ) {}
 
-  private isPhasedGeneralCustoms(booking: Booking): boolean {
-    return this.bookingClearanceService.isPhasedGeneralCustomsBooking(booking);
+  private isPhasedCustoms(booking: Booking): boolean {
+    return this.bookingClearanceService.isPhasedCustomsBooking(booking);
   }
 
   /** Reject submit when the booking's 20ft containers can't be balanced onto wagons. */
@@ -376,6 +377,8 @@ export class BookingTransitionService {
     } as never);
     const fresh = await this.bookingsService.findById(updated!.id);
     this.notifier.completed(fresh);
+    // A ONE_TIME contract closes on its single shipment being delivered.
+    this.events.emit('booking.completed', { bookingId });
     // Customer tracking: close out the tail milestones so a finished shipment
     // never shows a forever-pending timeline. EXIT_NOTE/PROCESS_COMPLETED are
     // implied by delivery; a storage invoice that was never raised is skipped
@@ -491,7 +494,7 @@ export class BookingTransitionService {
     operationReady?: boolean;
   }> {
     const booking = await this.bookingsService.findById(bookingId);
-    if (this.isPhasedGeneralCustoms(booking)) {
+    if (this.isPhasedCustoms(booking)) {
       return this.bookingClearanceService.getClearanceView(bookingId);
     }
     const { inputCode, outputCode, includesCustoms } =
@@ -650,7 +653,7 @@ export class BookingTransitionService {
       status: "DOCUMENTS_UNDER_REVIEW",
     } as never);
 
-    if (this.isPhasedGeneralCustoms(booking)) {
+    if (this.isPhasedCustoms(booking)) {
       await this.workflowService.onCustomerDocsUploadedForBooking(
         bookingId,
         booking.tradeDirection ?? 'IMPORT',
@@ -732,7 +735,7 @@ export class BookingTransitionService {
     }
     if (
       status === 'QUERIED' &&
-      this.isPhasedGeneralCustoms(booking) &&
+      this.isPhasedCustoms(booking) &&
       booking.preClearanceFinalizedAt
     ) {
       throw new BadRequestException(
@@ -755,7 +758,7 @@ export class BookingTransitionService {
         "CHANGES_REQUESTED",
         staffId,
       );
-      if (this.isPhasedGeneralCustoms(booking)) {
+      if (this.isPhasedCustoms(booking)) {
         await this.workflowService.onDocumentReviewReopenedForBooking(bookingId);
         await this.bookingsRepository.update(bookingId, {
           clearanceCurrentPhase: ContractDocPhase.GlEtReview,
@@ -767,7 +770,7 @@ export class BookingTransitionService {
     if (status === "QUERIED") {
       this.notifier.documentQueried(updated, fileKey, note ?? '');
     }
-    if (this.isPhasedGeneralCustoms(updated)) {
+    if (this.isPhasedCustoms(updated)) {
       const allApproved = await this.isClearanceFullyApproved(updated);
       if (allApproved) {
         await this.workflowService.onAllDocsApprovedForBooking(bookingId);
@@ -817,7 +820,7 @@ export class BookingTransitionService {
    */
   async finalizeClearance(bookingId: string): Promise<Booking> {
     const booking = await this.bookingsService.findById(bookingId);
-    if (this.isPhasedGeneralCustoms(booking)) {
+    if (this.isPhasedCustoms(booking)) {
       throw new BadRequestException(
         'General customs bookings use phased clearance — complete milestones via the phased actions instead of finalize.',
       );
diff --git a/apps/edr-freight-api/src/modules/bookings/bookings.controller.ts b/apps/edr-freight-api/src/modules/bookings/bookings.controller.ts
index 4ebfc9fab..5b6bddbff 100644
--- a/apps/edr-freight-api/src/modules/bookings/bookings.controller.ts
+++ b/apps/edr-freight-api/src/modules/bookings/bookings.controller.ts
@@ -823,6 +823,34 @@ export class BookingsController {
     return this.transitionService.enrichBookingResponse(booking);
   }
 
+  @Post(':id/clearance/transit-assignee/request')
+  @BookingStaff(FREIGHT_PERMS.contracts.clearanceEtActions)
+  @ApiOperation({
+    summary:
+      'GL ET asks GL Djibouti to name the transit officer — required before the import customs declaration',
+  })
+  async requestBookingTransitAssignee(
+    @Param('id', ParseUUIDPipe) id: string,
+    @Body('note') note: string | undefined,
+  ) {
+    const booking = await this.bookingClearanceService.requestTransitAssignee(id, note);
+    return this.transitionService.enrichBookingResponse(booking);
+  }
+
+  @Post(':id/clearance/transit-assignee/assign')
+  @BookingStaff(FREIGHT_PERMS.contracts.clearanceDjActions)
+  @ApiOperation({
+    summary:
+      'GL Djibouti names the transit officer (free text) — unblocks the customs declaration; calling again reassigns',
+  })
+  async assignBookingTransitAssignee(
+    @Param('id', ParseUUIDPipe) id: string,
+    @Body('assignee') assignee: string,
+  ) {
+    const booking = await this.bookingClearanceService.assignTransitAssignee(id, assignee);
+    return this.transitionService.enrichBookingResponse(booking);
+  }
+
   @Post(':id/clearance/declaration')
   @BookingStaff(FREIGHT_PERMS.contracts.clearanceEtActions)
   @UseInterceptors(AnyFilesInterceptor())
@@ -872,6 +900,24 @@ export class BookingsController {
     return this.transitionService.enrichBookingResponse(booking);
   }
 
+  @Post(':id/clearance/duty/dispute')
+  @ApiOperation({
+    summary:
+      'Customer disputes the advised duty/tax with a reason — reopens the step so GL Ethiopia can re-advise (repeatable)',
+  })
+  async disputeBookingDuty(
+    @Param('id', ParseUUIDPipe) id: string,
+    @Body('note') note: string,
+    @CurrentUser() user: TCurrentUser,
+  ) {
+    const booking = await this.bookingClearanceService.disputeDuty(
+      id,
+      note,
+      resolveAuthUserId(user),
+    );
+    return this.transitionService.enrichBookingResponse(booking);
+  }
+
   @Post(':id/clearance/finalize-pre-clearance')
   @BookingStaff(FREIGHT_PERMS.contracts.clearanceEtActions)
   @ApiOperation({ summary: 'GL ET finalizes import pre-clearance on booking' })
diff --git a/apps/edr-freight-api/src/modules/bookings/bookings.repository.ts b/apps/edr-freight-api/src/modules/bookings/bookings.repository.ts
index a0b3b4e0e..b9ced4f96 100644
--- a/apps/edr-freight-api/src/modules/bookings/bookings.repository.ts
+++ b/apps/edr-freight-api/src/modules/bookings/bookings.repository.ts
@@ -1,8 +1,16 @@
 import { BaseRepository } from '@edr/api-common';
 import { SchedulingStatus } from '@edr/types';
-import { Injectable } from '@nestjs/common';
+import { ConflictException, Injectable } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
-import { DataSource, EntityManager, FindOptionsWhere, In, Repository, SelectQueryBuilder } from 'typeorm';
+import {
+  DataSource,
+  DeepPartial,
+  EntityManager,
+  FindOptionsWhere,
+  In,
+  Repository,
+  SelectQueryBuilder,
+} from 'typeorm';
 
 import { wagonsPerUnitForSize } from '../rule-engine/container-type.util';
 import { ContainerType } from '../rule-engine/entities/container-type.entity';
@@ -26,6 +34,22 @@ import {
 import { FileRecord } from '../files/entities/file.entity';
 import { ContainerWeightResult } from '../rule-engine/rule-engine.service';
 
+/** A booking is ready for a batch: commercial = signed, government = approved/paid. */
+const BATCH_POOL_READY = `((booking.is_government = false AND booking.status = 'FULLY_EXECUTED')
+  OR (booking.is_government = true AND booking.status IN ('APPROVED','PAID')))`;
+
+/**
+ * Suspending a contract freezes its bookings, so they drop out of every
+ * scheduling pool. Filtering here (rather than letting the write guard throw)
+ * keeps the batch crons quiet — a frozen contract simply stops being a
+ * candidate until the suspension is lifted.
+ */
+const NOT_ON_SUSPENDED_CONTRACT = `(booking.contract_id IS NULL
+  OR NOT EXISTS (
+    SELECT 1 FROM freight.contracts c
+    WHERE c.id = booking.contract_id AND c.status = 'SUSPENDED'
+  ))`;
+
 export interface BookingListFilterOptions {
   statuses?: string[];
   status?: string;
@@ -68,6 +92,42 @@ export class BookingsRepository extends BaseRepository<Booking> {
     return this.repository.findOne({ where: { reference } });
   }
 
+  /**
+   * Suspending a contract freezes its bookings too, so the single write path
+   * every booking mutation funnels through is the place to enforce it — one
+   * guard instead of one per transition method.
+   *
+   * The batch/scheduling pools filter suspended contracts out up front
+   * (see {@link excludeSuspendedContract}), so the engine and its crons never
+   * reach a frozen booking and this only ever fires on a user-initiated action.
+   *
+   * ponytail: the seven `manager.getRepository(Booking)` writes inside
+   * train-scheduling transactions bypass this — they only run on bookings the
+   * pool already handed out, which the filter above has excluded. Move them onto
+   * this repository if that ever stops holding.
+   */
+  private async assertContractNotSuspended(id: string): Promise<void> {
+    const row = await this.repository
+      .createQueryBuilder('booking')
+      .select('contract.status', 'status')
+      .innerJoin(Contract, 'contract', 'contract.id = booking.contract_id')
+      .where('booking.id = :id', { id })
+      .getRawOne<{ status: string }>();
+    if (row?.status === 'SUSPENDED') {
+      throw new ConflictException(
+        'This shipment belongs to a suspended contract. EDR must lift the suspension before it can move.',
+      );
+    }
+  }
+
+  override async update(
+    id: string,
+    data: DeepPartial<Booking>,
+  ): Promise<Booking | null> {
+    await this.assertContractNotSuspended(id);
+    return super.update(id, data);
+  }
+
   /**
    * Highest NNNNNN sequence already issued for `BK-<year>-…` references.
    * Includes soft-deleted bookings so the next number clears references that
@@ -551,6 +611,17 @@ export class BookingsRepository extends BaseRepository<Booking> {
     );
   }
 
+  /** Review notes of one type, newest first — the duty advice/dispute rounds. */
+  async findReviewNotes(
+    bookingId: string,
+    type: ReviewNoteType,
+  ): Promise<BookingReviewNote[]> {
+    return this.dataSource.getRepository(BookingReviewNote).find({
+      where: { bookingId, type },
+      order: { createdAt: 'DESC' },
+    });
+  }
+
   async findLatestReviewNote(
     bookingId: string,
     type?: ReviewNoteType,
@@ -1032,7 +1103,8 @@ export class BookingsRepository extends BaseRepository<Booking> {
         'scheduleBooking.booking_id = booking.id',
       )
       .where('booking.status = :paidStatus', { paidStatus: 'PAID' })
-      .andWhere('scheduleBooking.id IS NULL');
+      .andWhere('scheduleBooking.id IS NULL')
+      .andWhere(NOT_ON_SUSPENDED_CONTRACT);
 
     // Day-level pooling: customers no longer set train_schedule_id, so the wizard
     // surfaces the whole (route, EAT day) pool. Fall back to the legacy
@@ -1091,10 +1163,8 @@ export class BookingsRepository extends BaseRepository<Booking> {
       .leftJoin(TrainScheduleBooking, 'sb', 'sb.booking_id = booking.id')
       .where('booking.train_schedule_id = :scheduleId', { scheduleId })
       .andWhere('sb.id IS NULL')
-      .andWhere(
-        `((booking.is_government = false AND booking.status = 'FULLY_EXECUTED')
-          OR (booking.is_government = true AND booking.status IN ('APPROVED','PAID')))`,
-      )
+      .andWhere(BATCH_POOL_READY)
+      .andWhere(NOT_ON_SUSPENDED_CONTRACT)
       .orderBy('booking.is_government', 'DESC')
       .addOrderBy('booking.priority_score', 'DESC')
       .addOrderBy('booking.fully_executed_at', 'ASC')
@@ -1130,10 +1200,8 @@ export class BookingsRepository extends BaseRepository<Booking> {
         { day },
       )
       .andWhere('sb.id IS NULL')
-      .andWhere(
-        `((booking.is_government = false AND booking.status = 'FULLY_EXECUTED')
-          OR (booking.is_government = true AND booking.status IN ('APPROVED','PAID')))`,
-      )
+      .andWhere(BATCH_POOL_READY)
+      .andWhere(NOT_ON_SUSPENDED_CONTRACT)
       .orderBy('booking.is_government', 'DESC')
       .addOrderBy('booking.priority_score', 'DESC')
       .addOrderBy('booking.fully_executed_at', 'ASC')
@@ -1170,10 +1238,8 @@ export class BookingsRepository extends BaseRepository<Booking> {
         { day },
       )
       .andWhere('sb.id IS NULL')
-      .andWhere(
-        `((booking.is_government = false AND booking.status = 'FULLY_EXECUTED')
-          OR (booking.is_government = true AND booking.status IN ('APPROVED','PAID')))`,
-      )
+      .andWhere(BATCH_POOL_READY)
+      .andWhere(NOT_ON_SUSPENDED_CONTRACT)
       .orderBy('booking.is_government', 'DESC')
       .addOrderBy('booking.priority_score', 'DESC')
       .addOrderBy('booking.fully_executed_at', 'ASC')
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 0e858e702..81e5c833a 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
@@ -62,13 +62,15 @@ describe('clearance.util — clearanceCodesForBooking (intercity)', () => {
     expect(direct.inputCode).toBe(INTERCITY_DOCUMENTS_SETTING_CODE);
   });
 
-  it('ONE_TIME contract drawdowns skip the per-booking set (contract collected it)', () => {
+  it('ONE_TIME contract shipments carry the same per-booking set', () => {
+    // Contracts no longer collect clearance documents — every shipment does,
+    // whatever kind of contract it draws on.
     const drawdown = clearanceCodesForBooking({
       ...base,
       contractId: 'c1',
       contractKind: 'ONE_TIME',
     } as unknown as Booking);
-    expect(drawdown.inputCode).toBeNull();
+    expect(drawdown.inputCode).toBe(INTERCITY_DOCUMENTS_SETTING_CODE);
     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 5a63beca6..242cee9d3 100644
--- a/apps/edr-freight-api/src/modules/bookings/clearance.util.ts
+++ b/apps/edr-freight-api/src/modules/bookings/clearance.util.ts
@@ -11,9 +11,8 @@ 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.
+ * DOMESTIC has no customs, so one shared set serves every intercity booking —
+ * ONE_TIME and GENERAL alike, collected per booking and reviewed by Operations.
  */
 export const INTERCITY_DOCUMENTS_SETTING_CODE = 'intercity_documents';
 
@@ -77,16 +76,6 @@ 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/bookings/entities/booking-review-note.entity.ts b/apps/edr-freight-api/src/modules/bookings/entities/booking-review-note.entity.ts
index 91171a793..75007326e 100644
--- a/apps/edr-freight-api/src/modules/bookings/entities/booking-review-note.entity.ts
+++ b/apps/edr-freight-api/src/modules/bookings/entities/booking-review-note.entity.ts
@@ -2,7 +2,16 @@ import { BaseEntity } from '@edr/api-common';
 import { Column, Entity, Index, JoinColumn, ManyToOne } from 'typeorm';
 import { Booking } from './booking.entity';
 
-export const REVIEW_NOTE_TYPES = ['CHANGES_REQUESTED', 'REJECTION', 'STAFF_NOTE'] as const;
+export const REVIEW_NOTE_TYPES = [
+  'CHANGES_REQUESTED',
+  'REJECTION',
+  'STAFF_NOTE',
+  /**
+   * The customer disputed the advised duty & tax and asked GL Ethiopia to
+   * correct it. One row per round — the advice/dispute loop can repeat.
+   */
+  'DUTY_DISPUTE',
+] as const;
 export type ReviewNoteType = (typeof REVIEW_NOTE_TYPES)[number];
 
 @Entity({ schema: 'freight', name: 'booking_review_note' })
diff --git a/apps/edr-freight-api/src/modules/bookings/entities/booking.entity.ts b/apps/edr-freight-api/src/modules/bookings/entities/booking.entity.ts
index 4ab9e397e..3d0603f5f 100644
--- a/apps/edr-freight-api/src/modules/bookings/entities/booking.entity.ts
+++ b/apps/edr-freight-api/src/modules/bookings/entities/booking.entity.ts
@@ -557,6 +557,23 @@ export class Booking extends BaseEntity {
   @Column({ name: 'pre_clearance_finalized_at', type: 'timestamptz', nullable: true })
   preClearanceFinalizedAt?: Date | null;
 
+  /**
+   * Pre-declaration handshake: GL Ethiopia asks GL Djibouti who will handle this
+   * shipment in transit, Djibouti answers with a name (free text — the officer is
+   * not a platform user). The import declaration is blocked until `name` is set.
+   */
+  @Column({ name: 'transit_assignee_requested_at', type: 'timestamptz', nullable: true })
+  transitAssigneeRequestedAt?: Date | null;
+
+  @Column({ name: 'transit_assignee_request_note', type: 'text', nullable: true })
+  transitAssigneeRequestNote?: string | null;
+
+  @Column({ name: 'transit_assignee_name', type: 'text', nullable: true })
+  transitAssigneeName?: string | null;
+
+  @Column({ name: 'transit_assignee_assigned_at', type: 'timestamptz', nullable: true })
+  transitAssigneeAssignedAt?: Date | null;
+
   /** GL staff user bound to this shipment by the station manager. */
   @Column({ name: 'gl_assigned_staff_id', type: 'uuid', nullable: true })
   glAssignedStaffId?: string | null;
diff --git a/apps/edr-freight-api/src/modules/contracts/booking-clearance.service.spec.ts b/apps/edr-freight-api/src/modules/contracts/booking-clearance.service.spec.ts
index 7b5cb77d6..3d8776e80 100644
--- a/apps/edr-freight-api/src/modules/contracts/booking-clearance.service.spec.ts
+++ b/apps/edr-freight-api/src/modules/contracts/booking-clearance.service.spec.ts
@@ -15,6 +15,9 @@ const generalImportBooking = {
   dutyRequired: true,
   roHoldReason: null,
   vesselDepartureDate: null,
+  // Djibouti already named the transit officer — the declaration gate is open.
+  transitAssigneeRequestedAt: new Date('2026-01-01T00:00:00Z'),
+  transitAssigneeName: 'Ahmed Bourhan',
 } as Booking;
 
 const generalExportBooking = {
@@ -27,6 +30,8 @@ const generalExportBooking = {
 function makeService(overrides?: {
   booking?: Booking;
   workflowThrows?: boolean;
+  /** Resolve the input doc set with no required fields → every doc counts approved. */
+  docsApproved?: boolean;
 }) {
   const booking = overrides?.booking ?? generalImportBooking;
   const bookingsRepository = {
@@ -38,10 +43,14 @@ function makeService(overrides?: {
   };
   const filesService = {
     upsertByCode: jest.fn().mockResolvedValue({}),
+    upload: jest.fn().mockResolvedValue({}),
+    deleteByCode: jest.fn().mockResolvedValue(undefined),
     findByResource: jest.fn().mockResolvedValue([]),
   };
   const fileUploadSettingsService = {
-    getByCode: jest.fn().mockRejectedValue(new Error('no setting')),
+    getByCode: overrides?.docsApproved
+      ? jest.fn().mockResolvedValue({ fields: [] })
+      : jest.fn().mockRejectedValue(new Error('no setting')),
   };
   const workflowService = {
     assertPriorCompleteForBooking: overrides?.workflowThrows
@@ -49,6 +58,7 @@ function makeService(overrides?: {
       : jest.fn().mockResolvedValue(undefined),
     completeMilestoneForBooking: jest.fn().mockResolvedValue(undefined),
     onDeclarationUploadedForBooking: jest.fn().mockResolvedValue(undefined),
+    onAllDocsApprovedForBooking: jest.fn().mockResolvedValue(undefined),
     onDutySkippedForBooking: jest.fn().mockResolvedValue(undefined),
     listMilestonesForBooking: jest.fn().mockResolvedValue([]),
     resolvePhaseForBooking: jest.fn().mockReturnValue(null),
@@ -91,6 +101,8 @@ function makeService(overrides?: {
       documentQueried: jest.fn(),
       dutySlipUploadedToStaff: jest.fn(),
       clearanceDocsUploadedToStaff: jest.fn(),
+      transitAssigneeRequested: jest.fn(),
+      transitAssigneeAssigned: jest.fn(),
     } as never, // notifier
   );
 
@@ -186,6 +198,82 @@ describe('BookingClearanceService', () => {
         service.uploadDeclaration('b-general', [{ fieldname: 'decl' } as Express.Multer.File]),
       ).rejects.toBeInstanceOf(BadRequestException);
     });
+
+    it('rejects an import declaration before Djibouti names the transit officer', async () => {
+      const { service, workflowService } = makeService({
+        docsApproved: true,
+        booking: {
+          ...generalImportBooking,
+          transitAssigneeRequestedAt: null,
+          transitAssigneeName: null,
+        } as Booking,
+      });
+
+      await expect(
+        service.uploadDeclaration('b-general', [{ fieldname: 'decl' } as Express.Multer.File]),
+      ).rejects.toThrow(/Request a transit assignee/i);
+      expect(workflowService.onDeclarationUploadedForBooking).not.toHaveBeenCalled();
+    });
+
+    it('lets the export declaration through without a transit assignee', async () => {
+      const { service, workflowService } = makeService({
+        docsApproved: true,
+        booking: {
+          ...generalExportBooking,
+          transitAssigneeRequestedAt: null,
+          transitAssigneeName: null,
+        } as Booking,
+      });
+
+      await service.uploadDeclaration('b-export', [
+        { fieldname: 'decl' } as Express.Multer.File,
+      ]);
+
+      expect(workflowService.onDeclarationUploadedForBooking).toHaveBeenCalled();
+    });
+  });
+
+  describe('transit assignee handshake', () => {
+    it('refuses an assignment GL Ethiopia never asked for', async () => {
+      const { service } = makeService({
+        booking: {
+          ...generalImportBooking,
+          transitAssigneeRequestedAt: null,
+          transitAssigneeName: null,
+        } as Booking,
+      });
+
+      await expect(
+        service.assignTransitAssignee('b-general', 'Ahmed Bourhan'),
+      ).rejects.toThrow(/has not requested a transit assignee/i);
+    });
+
+    it('stamps the ask and then the name', async () => {
+      const { service, bookingsRepository } = makeService({
+        booking: {
+          ...generalImportBooking,
+          transitAssigneeName: null,
+        } as Booking,
+      });
+
+      await service.requestTransitAssignee('b-general', '  night shift  ');
+      expect(bookingsRepository.update).toHaveBeenCalledWith(
+        'b-general',
+        expect.objectContaining({
+          transitAssigneeRequestedAt: expect.any(Date),
+          transitAssigneeRequestNote: 'night shift',
+        }),
+      );
+
+      await service.assignTransitAssignee('b-general', ' Ahmed Bourhan ');
+      expect(bookingsRepository.update).toHaveBeenCalledWith(
+        'b-general',
+        expect.objectContaining({
+          transitAssigneeName: 'Ahmed Bourhan',
+          transitAssigneeAssignedAt: expect.any(Date),
+        }),
+      );
+    });
   });
 
   describe('uploadReleaseOrder', () => {
diff --git a/apps/edr-freight-api/src/modules/contracts/booking-clearance.service.ts b/apps/edr-freight-api/src/modules/contracts/booking-clearance.service.ts
index 69773010c..bfb44852a 100644
--- a/apps/edr-freight-api/src/modules/contracts/booking-clearance.service.ts
+++ b/apps/edr-freight-api/src/modules/contracts/booking-clearance.service.ts
@@ -71,12 +71,32 @@ export interface BookingClearanceView {
   roAmendmentRequestedAt?: string | null;
   operationReady?: boolean;
   preClearanceFinalized?: boolean;
+  /**
+   * Pre-declaration handshake with GL Djibouti: who handles this shipment in
+   * transit. `name` stays null until Djibouti answers, and GL Ethiopia cannot
+   * file the import customs declaration before it is set.
+   */
+  transitAssignee?: {
+    requestedAt: string | null;
+    requestNote: string | null;
+    name: string | null;
+    assignedAt: string | null;
+  } | null;
   dutyAdvice?: {
     amount: number;
     currency: string;
     declarationSerial?: string | null;
     noticeFile?: { id: string; name: string; url: string } | null;
   } | null;
+  /**
+   * The customer's open objection to the advised duty. Present only until GL
+   * re-advises; `rounds` counts how many times it has been sent back.
+   */
+  dutyDispute?: {
+    note: string;
+    raisedAt: string;
+    rounds: number;
+  } | null;
   workflowFiles?: ReturnType<typeof buildWorkflowFiles>;
   /** Import post-allocation T1 transit document state (null until wagon allocation). */
   t1?: ClearanceT1State | null;
@@ -113,13 +133,10 @@ export class BookingClearanceService {
     private readonly notifier: BookingLifecycleNotifierService,
   ) {}
 
-  private async assertPhasedGeneralCustoms(booking: Booking): Promise<void> {
+  private async assertPhasedCustoms(booking: Booking): Promise<void> {
     if (!booking.customsClearingEnabled) {
       throw new BadRequestException('Phased clearance applies only to customs bookings.');
     }
-    if (booking.contractKind !== 'GENERAL') {
-      throw new BadRequestException('Per-booking phased clearance applies to general contracts.');
-    }
     if (!booking.contractId) {
       throw new BadRequestException('Booking is not linked to a contract.');
     }
@@ -127,7 +144,7 @@ export class BookingClearanceService {
 
   private async loadBooking(bookingId: string): Promise<Booking> {
     const booking = await this.bookingsService.findById(bookingId);
-    await this.assertPhasedGeneralCustoms(booking);
+    await this.assertPhasedCustoms(booking);
     return booking;
   }
 
@@ -214,6 +231,7 @@ export class BookingClearanceService {
       booking.tradeDirection ?? 'IMPORT',
     );
     const dutyAdvice = this.buildDutyAdvice(files, milestones);
+    const dutyDispute = await this.buildDutyDispute(bookingId, milestones);
     const workflowFiles = buildWorkflowFiles(
       files,
       booking.tradeDirection ?? 'IMPORT',
@@ -272,7 +290,18 @@ export class BookingClearanceService {
         : null,
       operationReady: boundary,
       preClearanceFinalized: Boolean(booking.preClearanceFinalizedAt),
+      transitAssignee: {
+        requestedAt: booking.transitAssigneeRequestedAt
+          ? booking.transitAssigneeRequestedAt.toISOString()
+          : null,
+        requestNote: booking.transitAssigneeRequestNote ?? null,
+        name: booking.transitAssigneeName ?? null,
+        assignedAt: booking.transitAssigneeAssignedAt
+          ? booking.transitAssigneeAssignedAt.toISOString()
+          : null,
+      },
       dutyAdvice,
+      dutyDispute,
       workflowFiles,
       t1,
       train,
@@ -330,6 +359,22 @@ export class BookingClearanceService {
     };
   }
 
+  private async buildDutyDispute(
+    bookingId: string,
+    milestones: ClearanceMilestone[],
+  ): Promise<BookingClearanceView['dutyDispute']> {
+    const advised = milestones.find((m) => m.milestoneCode === 'DUTY_TAXES_ADVISED');
+    if (!advised || advised.status === 'COMPLETED') return null;
+    const notes = await this.bookingsRepository.findReviewNotes(bookingId, 'DUTY_DISPUTE');
+    const latest = notes[0];
+    if (!latest) return null;
+    return {
+      note: latest.note,
+      raisedAt: latest.createdAt.toISOString(),
+      rounds: notes.length,
+    };
+  }
+
   private async isClearanceFullyApproved(booking: Booking): Promise<boolean> {
     const { inputCode } = clearanceCodesForBooking(booking);
     if (!inputCode) return true;
@@ -352,14 +397,60 @@ export class BookingClearanceService {
     );
   }
 
-  isPhasedGeneralCustomsBooking(booking: Booking): boolean {
+  /** Any contract booking (ONE_TIME or GENERAL) whose service bundles customs. */
+  isPhasedCustomsBooking(booking: Booking): boolean {
     return (
-      Boolean(booking.customsClearingEnabled) &&
-      booking.contractKind === 'GENERAL' &&
-      Boolean(booking.contractId)
+      Boolean(booking.customsClearingEnabled) && Boolean(booking.contractId)
     );
   }
 
+  /**
+   * GL Ethiopia asks Djibouti to name the officer who will handle this shipment
+   * in transit. The import declaration is gated on the answer, so this is the
+   * first thing ET does once the customer documents are approved. Re-requesting
+   * is allowed (a nudge) and simply restamps the ask.
+   */
+  async requestTransitAssignee(
+    bookingId: string,
+    note: string | undefined,
+  ): Promise<Booking> {
+    const booking = await this.loadBooking(bookingId);
+
+    await this.bookingsRepository.update(bookingId, {
+      transitAssigneeRequestedAt: new Date(),
+      transitAssigneeRequestNote: note?.trim() || null,
+    } as never);
+
+    this.notifier.transitAssigneeRequested(booking, note?.trim() ?? null);
+    return this.bookingsService.findById(bookingId);
+  }
+
+  /**
+   * GL Djibouti names the transit officer — free text, because the person is not
+   * a platform user. Answering unblocks the declaration for Ethiopia. A later
+   * call overwrites the name (reassignment) and re-notifies.
+   */
+  async assignTransitAssignee(bookingId: string, assignee: string): Promise<Booking> {
+    const booking = await this.loadBooking(bookingId);
+    if (!assignee?.trim()) {
+      throw new BadRequestException('Name the officer who will handle the transit.');
+    }
+    if (!booking.transitAssigneeRequestedAt) {
+      throw new BadRequestException(
+        'GL Ethiopia has not requested a transit assignee for this shipment yet.',
+      );
+    }
+
+    const previous = booking.transitAssigneeName ?? null;
+    await this.bookingsRepository.update(bookingId, {
+      transitAssigneeName: assignee.trim(),
+      transitAssigneeAssignedAt: new Date(),
+    } as never);
+
+    this.notifier.transitAssigneeAssigned(booking, assignee.trim(), previous);
+    return this.bookingsService.findById(bookingId);
+  }
+
   async uploadDeclaration(
     bookingId: string,
     files: Express.Multer.File[],
@@ -373,6 +464,16 @@ export class BookingClearanceService {
         'All required customer documents must be approved before uploading a declaration.',
       );
     }
+    // Import only: the declaration is filed against whoever physically handles
+    // the shipment in Djibouti, so that name must be in first. Exports have no
+    // such handshake — their Djibouti steps come after the declaration.
+    if (tradeDirection === 'IMPORT' && !booking.transitAssigneeName) {
+      throw new BadRequestException(
+        booking.transitAssigneeRequestedAt
+          ? 'GL Djibouti has not assigned the transit officer yet — the declaration cannot be filed until they do.'
+          : 'Request a transit assignee from GL Djibouti before filing the customs declaration.',
+      );
+    }
     const milestones = await this.workflowService.listMilestonesForBooking(bookingId);
     const docsApproved = milestones.find((m) => m.milestoneCode === 'DOCUMENTS_APPROVED');
     if (docsApproved?.status !== 'COMPLETED' && docsApproved?.status !== 'SKIPPED') {
@@ -460,6 +561,65 @@ export class BookingClearanceService {
     return this.bookingsService.findById(bookingId);
   }
 
+  /**
+   * The customer disagrees with the advised duty & tax on this booking and asks
+   * GL Ethiopia to correct it. Nothing is paid; the advice milestone reopens so
+   * the Duty & tax step becomes actionable again on the GL clearance page, with
+   * the customer's message shown beside it. GL re-advises (same endpoint as the
+   * first time), which closes the dispute — the loop may run as many rounds as
+   * it takes.
+   */
+  async disputeDuty(
+    bookingId: string,
+    note: string,
+    userId?: string,
+  ): Promise<Booking> {
+    const booking = await this.loadBooking(bookingId);
+    if (booking.tradeDirection !== 'IMPORT') {
+      throw new BadRequestException('Duty applies only to import bookings.');
+    }
+    if (!note?.trim()) {
+      throw new BadRequestException(
+        'Say what is wrong with the advised amount so GL can correct it.',
+      );
+    }
+    if (!booking.dutyRequired) {
+      throw new BadRequestException('Duty/tax is not required for this clearance.');
+    }
+
+    const milestones = await this.workflowService.listMilestonesForBooking(bookingId);
+    const byCode = new Map(milestones.map((m) => [m.milestoneCode, m]));
+    if (byCode.get('DUTY_TAXES_ADVISED')?.status !== 'COMPLETED') {
+      throw new BadRequestException(
+        'There is no advised duty amount to dispute yet.',
+      );
+    }
+    // Once the slip is in, the money is paid — a dispute then is a refund
+    // conversation, not a re-advice.
+    if (byCode.get('DUTY_TAX_PAID')?.status === 'COMPLETED') {
+      throw new BadRequestException(
+        'The duty payment slip has already been submitted — contact GL Ethiopia directly.',
+      );
+    }
+
+    await this.bookingsRepository.createReviewNote(
+      bookingId,
+      note.trim(),
+      'DUTY_DISPUTE',
+      userId,
+    );
+    // Back to GL: reopening the milestone is what re-arms the Duty & tax step
+    // (the stepper picks its active step from milestone completion).
+    await this.milestoneService.reopenForBooking(bookingId, 'DUTY_TAXES_ADVISED');
+    await this.bookingsRepository.update(bookingId, {
+      clearanceCurrentPhase: ContractDocPhase.GlEtOutput,
+    } as never);
+
+    const updated = await this.bookingsService.findById(bookingId);
+    this.notifier.dutyDisputed(updated, note.trim());
+    return updated;
+  }
+
   async uploadDutySlip(bookingId: string, file: Express.Multer.File): Promise<Booking> {
     const booking = await this.loadBooking(bookingId);
     if (booking.tradeDirection !== 'IMPORT') {
@@ -720,7 +880,7 @@ export class BookingClearanceService {
     ]);
     const filtered: Booking[] = [];
     for (const b of candidates) {
-      if (!this.isPhasedGeneralCustomsBooking(b)) continue;
+      if (!this.isPhasedCustomsBooking(b)) continue;
       const milestones = await this.workflowService.listMilestonesForBooking(b.id);
       if (belongsOnEtClearanceQueue(milestones)) filtered.push(b);
     }
@@ -733,7 +893,7 @@ export class BookingClearanceService {
     ]);
     const filtered: Booking[] = [];
     for (const b of candidates) {
-      if (!this.isPhasedGeneralCustomsBooking(b)) continue;
+      if (!this.isPhasedCustomsBooking(b)) continue;
       const milestones = await this.workflowService.listMilestonesForBooking(b.id);
       if (
         belongsOnDjClearanceQueue(b.tradeDirection, null, milestones, {
diff --git a/apps/edr-freight-api/src/modules/contracts/booking-duty-dispute.spec.ts b/apps/edr-freight-api/src/modules/contracts/booking-duty-dispute.spec.ts
new file mode 100644
index 000000000..4a3904182
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/contracts/booking-duty-dispute.spec.ts
@@ -0,0 +1,162 @@
+import { BadRequestException } from '@nestjs/common';
+
+import { BookingClearanceService } from './booking-clearance.service';
+import type { Booking } from '../bookings/entities/booking.entity';
+
+/**
+ * The duty advice → dispute → re-advice loop, at the booking level. GL
+ * Ethiopia advises an amount; the customer either pays it or sends it back
+ * with a reason. Sending it back reopens the advice milestone — that is what
+ * puts the Duty & tax step back in GL's hands — and the round can repeat
+ * until the amount is agreed.
+ */
+describe('BookingClearanceService — duty dispute', () => {
+  const booking = (over: Partial<Booking> = {}): Booking =>
+    ({
+      id: 'bk-1',
+      reference: 'BKG-2026-00042',
+      tradeDirection: 'IMPORT',
+      customsClearingEnabled: true,
+      contractId: 'ctr-1',
+      dutyRequired: true,
+      ...over,
+    }) as Booking;
+
+  const milestone = (code: string, status: string) =>
+    ({ milestoneCode: code, status }) as never;
+
+  let repo: {
+    createReviewNote: jest.Mock;
+    findReviewNotes: jest.Mock;
+    update: jest.Mock;
+  };
+  let bookingsService: { findById: jest.Mock };
+  let workflowService: { listMilestonesForBooking: jest.Mock };
+  let milestoneService: { reopenForBooking: jest.Mock };
+  let notifier: { dutyDisputed: jest.Mock };
+  let service: BookingClearanceService;
+
+  const build = (milestones: unknown[]) => {
+    workflowService.listMilestonesForBooking.mockResolvedValue(milestones);
+  };
+
+  beforeEach(() => {
+    repo = {
+      createReviewNote: jest.fn().mockResolvedValue(undefined),
+      findReviewNotes: jest.fn().mockResolvedValue([]),
+      update: jest.fn().mockResolvedValue(undefined),
+    };
+    bookingsService = { findById: jest.fn().mockResolvedValue(booking()) };
+    workflowService = { listMilestonesForBooking: jest.fn().mockResolvedValue([]) };
+    milestoneService = { reopenForBooking: jest.fn().mockResolvedValue(undefined) };
+    notifier = { dutyDisputed: jest.fn() };
+
+    service = new BookingClearanceService(
+      repo as never,
+      bookingsService as never,
+      {} as never, // filesService
+      {} as never, // fileUploadSettingsService
+      workflowService as never,
+      milestoneService as never,
+      {} as never, // dropdownSettingsService
+      {} as never, // glOperationsService
+      notifier as never,
+    );
+    build([
+      milestone('DUTY_TAXES_ADVISED', 'COMPLETED'),
+      milestone('DUTY_TAX_PAID', 'PENDING'),
+    ]);
+  });
+
+  it('records the objection and hands the step back to GL', async () => {
+    await service.disputeDuty('bk-1', '  Declared value is wrong  ', 'user-1');
+
+    expect(repo.createReviewNote).toHaveBeenCalledWith(
+      'bk-1',
+      'Declared value is wrong',
+      'DUTY_DISPUTE',
+      'user-1',
+    );
+    // Reopening the advice milestone is what re-arms the Duty & tax step.
+    expect(milestoneService.reopenForBooking).toHaveBeenCalledWith(
+      'bk-1',
+      'DUTY_TAXES_ADVISED',
+    );
+    expect(repo.update).toHaveBeenCalledWith('bk-1', {
+      clearanceCurrentPhase: 'GL_ET_OUTPUT',
+    });
+  });
+
+  it('tells GL Ethiopia, not the customer', async () => {
+    await service.disputeDuty('bk-1', 'Too high', 'user-1');
+    expect(notifier.dutyDisputed).toHaveBeenCalledWith(
+      expect.objectContaining({ id: 'bk-1' }),
+      'Too high',
+    );
+  });
+
+  it('requires a reason — GL cannot correct an unexplained objection', async () => {
+    await expect(service.disputeDuty('bk-1', '   ')).rejects.toBeInstanceOf(
+      BadRequestException,
+    );
+    expect(milestoneService.reopenForBooking).not.toHaveBeenCalled();
+  });
+
+  it('refuses when nothing has been advised yet', async () => {
+    build([milestone('DUTY_TAXES_ADVISED', 'PENDING')]);
+    await expect(service.disputeDuty('bk-1', 'Too high')).rejects.toThrow(
+      /no advised duty amount/i,
+    );
+  });
+
+  it('refuses once the payment slip is in — that is a refund, not a re-advice', async () => {
+    build([
+      milestone('DUTY_TAXES_ADVISED', 'COMPLETED'),
+      milestone('DUTY_TAX_PAID', 'COMPLETED'),
+    ]);
+    await expect(service.disputeDuty('bk-1', 'Too high')).rejects.toThrow(
+      /already been submitted/i,
+    );
+  });
+
+  it('refuses when duty was never required for this clearance', async () => {
+    bookingsService.findById.mockResolvedValue(booking({ dutyRequired: false }));
+    await expect(service.disputeDuty('bk-1', 'Too high')).rejects.toThrow(
+      /not required/i,
+    );
+  });
+
+  describe('the view', () => {
+    const buildDispute = (milestones: unknown[]) =>
+      (
+        service as unknown as {
+          buildDutyDispute: (id: string, m: unknown[]) => Promise<unknown>;
+        }
+      ).buildDutyDispute('bk-1', milestones);
+
+    it('shows the objection while GL still owes a corrected advice', async () => {
+      repo.findReviewNotes.mockResolvedValue([
+        { note: 'Second look please', createdAt: new Date('2026-07-20T09:00:00Z') },
+        { note: 'First objection', createdAt: new Date('2026-07-18T09:00:00Z') },
+      ]);
+
+      const dispute = await buildDispute([
+        milestone('DUTY_TAXES_ADVISED', 'PENDING'),
+      ]);
+
+      expect(dispute).toMatchObject({ note: 'Second look please', rounds: 2 });
+    });
+
+    it('clears itself once GL re-advises', async () => {
+      repo.findReviewNotes.mockResolvedValue([
+        { note: 'First objection', createdAt: new Date('2026-07-18T09:00:00Z') },
+      ]);
+
+      const dispute = await buildDispute([
+        milestone('DUTY_TAXES_ADVISED', 'COMPLETED'),
+      ]);
+
+      expect(dispute).toBeNull();
+    });
+  });
+});
diff --git a/apps/edr-freight-api/src/modules/contracts/booking-request.service.ts b/apps/edr-freight-api/src/modules/contracts/booking-request.service.ts
index 99fed335a..1ca7cd84f 100644
--- a/apps/edr-freight-api/src/modules/contracts/booking-request.service.ts
+++ b/apps/edr-freight-api/src/modules/contracts/booking-request.service.ts
@@ -60,6 +60,11 @@ export class BookingRequestService {
         'This contract is completed — the full contracted quantity has been booked.',
       );
     }
+    if (contract.status === 'SUSPENDED') {
+      throw new ConflictException(
+        'This contract is suspended — shipment requests are on hold until EDR lifts the suspension.',
+      );
+    }
     if (contract.status !== 'CONTRACT_ACTIVE') {
       throw new ConflictException(
         'The contract must be active before requesting a shipment.',
diff --git a/apps/edr-freight-api/src/modules/contracts/contract-booking.completion.spec.ts b/apps/edr-freight-api/src/modules/contracts/contract-booking.completion.spec.ts
index 563f056d2..c222ffc16 100644
--- a/apps/edr-freight-api/src/modules/contracts/contract-booking.completion.spec.ts
+++ b/apps/edr-freight-api/src/modules/contracts/contract-booking.completion.spec.ts
@@ -24,7 +24,6 @@ describe('ContractBookingService — quantity-cap completion', () => {
       {} as never, // containerTypesService
       {} as never, // ruleEngineService
       {} as never, // milestoneService
-      {} as never, // workflowService
       {} as never, // invoiceService
       { createdToStaff: jest.fn() } as never, // bookingNotifier
       {} as never, // dataSource
@@ -132,6 +131,82 @@ describe('ContractBookingService — quantity-cap completion', () => {
     expect(contractsRepository.update).not.toHaveBeenCalled();
   });
 
+  describe('completion on booking delivery', () => {
+    function makeDeliveryService(contract: Partial<Contract>) {
+      const contractsRepository = {
+        findById: jest.fn().mockResolvedValue(contract),
+        update: jest.fn().mockResolvedValue(undefined),
+      };
+      const bookingsRepository = {
+        findById: jest
+          .fn()
+          .mockResolvedValue({ id: 'b-1', reference: 'BKG-1', contractId: 'c-1' }),
+      };
+      const service = new ContractBookingService(
+        contractsRepository as never,
+        bookingsRepository as never,
+        {} as never,
+        {} as never,
+        {} as never,
+        {} as never,
+        {} as never,
+        {} as never,
+        { createdToStaff: jest.fn() } as never,
+        {} as never,
+        {} as never,
+        {} as never,
+        {} as never,
+      );
+      return { service, contractsRepository };
+    }
+
+    it('completes a ONE_TIME contract when its booking is delivered', async () => {
+      const { service, contractsRepository } = makeDeliveryService({
+        id: 'c-1',
+        reference: 'CTR-1',
+        contractKind: 'ONE_TIME',
+        status: 'CONTRACT_ACTIVE',
+      });
+      jest.spyOn(service, 'splitOutstanding').mockResolvedValue(null);
+
+      await service.onBookingCompleted({ bookingId: 'b-1' });
+
+      expect(contractsRepository.update).toHaveBeenCalledWith('c-1', {
+        status: 'CONTRACT_CLOSED',
+      });
+    });
+
+    it('keeps a split ONE_TIME contract open while a remainder is outstanding', async () => {
+      const { service, contractsRepository } = makeDeliveryService({
+        id: 'c-1',
+        reference: 'CTR-1',
+        contractKind: 'ONE_TIME',
+        freightType: 'CONTAINER',
+        status: 'CONTRACT_ACTIVE',
+      });
+      jest.spyOn(service, 'splitOutstanding').mockResolvedValue({
+        bySize: new Map([['20ft', { total: 5, outstanding: 2 }]]),
+        bulk: null,
+      });
+
+      await service.onBookingCompleted({ bookingId: 'b-1' });
+
+      expect(contractsRepository.update).not.toHaveBeenCalled();
+    });
+
+    it('leaves a GENERAL contract alone — it closes on cap or expiry', async () => {
+      const { service, contractsRepository } = makeDeliveryService({
+        id: 'c-1',
+        contractKind: 'GENERAL',
+        status: 'CONTRACT_ACTIVE',
+      });
+
+      await service.onBookingCompleted({ bookingId: 'b-1' });
+
+      expect(contractsRepository.update).not.toHaveBeenCalled();
+    });
+  });
+
   it('reopens a completed contract when capacity was released', async () => {
     const { service, contractsRepository } = makeService();
     contractsRepository.findByIdWithRelations.mockResolvedValue(
diff --git a/apps/edr-freight-api/src/modules/contracts/contract-booking.consolidation.spec.ts b/apps/edr-freight-api/src/modules/contracts/contract-booking.consolidation.spec.ts
index 4bc768cc1..84465145d 100644
--- a/apps/edr-freight-api/src/modules/contracts/contract-booking.consolidation.spec.ts
+++ b/apps/edr-freight-api/src/modules/contracts/contract-booking.consolidation.spec.ts
@@ -55,7 +55,6 @@ describe('ContractBookingService — drawdown consolidation gate', () => {
       {} as never, // containerTypesService
       {} as never, // ruleEngineService
       milestoneService as never,
-      {} as never, // workflowService
       invoiceService as never,
       {
         createdToStaff: jest.fn(),
diff --git a/apps/edr-freight-api/src/modules/contracts/contract-booking.initiate-gate.spec.ts b/apps/edr-freight-api/src/modules/contracts/contract-booking.initiate-gate.spec.ts
new file mode 100644
index 000000000..6b5f54c91
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/contracts/contract-booking.initiate-gate.spec.ts
@@ -0,0 +1,74 @@
+import { ForbiddenException } from '@nestjs/common';
+
+import { ContractBookingService } from './contract-booking.service';
+import { Contract } from './entities/contract.entity';
+
+/**
+ * Who may open a shipment instance on a customs (Path B) contract. The customer
+ * initiates his own ONE_TIME customs booking and uploads the GL-input documents
+ * on it; GL still clears it and completes it with cargo and price. GENERAL
+ * customs instances come from a shipment request, and completing/creating a
+ * customs booking outright stays GL-only.
+ */
+describe('ContractBookingService — customs booking gate', () => {
+  function makeService() {
+    return new ContractBookingService(
+      {} as never, // contractsRepository
+      {} as never, // bookingsRepository
+      {} as never, // bookingPricingService
+      {} as never, // consolidationService
+      {} as never, // containerTypesService
+      {} as never, // ruleEngineService
+      {} as never, // milestoneService
+      {} as never, // invoiceService
+      {} as never, // bookingNotifier
+      {} as never, // dataSource
+      {} as never, // trainSchedulingService
+      {} as never, // bookingBatchService
+      {} as never, // bookingTransitionService
+    );
+  }
+
+  type WithPrivate = {
+    assertGate: (
+      c: Contract,
+      isGlActor: boolean,
+      isInitiate?: boolean,
+    ) => Promise<string>;
+  };
+
+  const customsContract = (contractKind: 'ONE_TIME' | 'GENERAL'): Contract =>
+    ({
+      id: 'c-1',
+      contractKind,
+      status: 'FULLY_EXECUTED',
+      customsClearingEnabled: true,
+    }) as Contract;
+
+  const gate = (c: Contract, isGl: boolean, isInitiate?: boolean) =>
+    (makeService() as never as WithPrivate).assertGate(c, isGl, isInitiate);
+
+  it('lets the customer initiate a ONE_TIME customs shipment', async () => {
+    await expect(gate(customsContract('ONE_TIME'), false, true)).resolves.toBe(
+      'CUSTOMER',
+    );
+  });
+
+  it('still lets GL initiate on the customer behalf', async () => {
+    await expect(gate(customsContract('ONE_TIME'), true, true)).resolves.toBe(
+      'GL_ET',
+    );
+  });
+
+  it('rejects a customer creating a customs booking outright (cargo + day)', async () => {
+    await expect(gate(customsContract('ONE_TIME'), false)).rejects.toBeInstanceOf(
+      ForbiddenException,
+    );
+  });
+
+  it('rejects a customer initiating a GENERAL customs shipment (request only)', async () => {
+    await expect(
+      gate(customsContract('GENERAL'), false, true),
+    ).rejects.toBeInstanceOf(ForbiddenException);
+  });
+});
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 7e657cc07..c567f71ce 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
@@ -37,16 +37,20 @@ import { hasFreightPermission } from '../../common/freight-permission.util';
 
 import { Contract } from './entities/contract.entity';
 import { ContractRoute } from './entities/contract-route.entity';
-import { ContractsRepository } from './contracts.repository';
+import {
+  ContractsRepository,
+  TERMINAL_BOOKING_STATUSES,
+} from './contracts.repository';
 import { ClearanceMilestoneService } from './clearance-milestone.service';
-import { ClearanceWorkflowService } from './clearance-workflow.service';
+import { isEffectivelyExpired } from './utils/contract-expiry.util';
 import {
   CreateBookingContainerLineDto,
   CreateBookingUnderContractDto,
 } from './dto/create-booking-under-contract.dto';
 
-/** Statuses that still occupy the single active-booking slot of a ONE_TIME contract. */
-const TERMINAL_BOOKING_STATUSES = ['EXPIRED', 'CANCELLED', 'COMPLETED', 'REJECTED'];
+// TERMINAL_BOOKING_STATUSES (the statuses that free the ONE_TIME active-booking
+// slot) lives in contracts.repository.ts — the contract cancel gate needs the
+// same list.
 
 /** Bookings that never shipped release their quantity hold on the contract. */
 const RELEASING_BOOKING_STATUSES = ['CANCELLED', 'REJECTED', 'EXPIRED'];
@@ -94,7 +98,6 @@ export class ContractBookingService {
     private readonly containerTypesService: ContainerTypesService,
     private readonly ruleEngineService: RuleEngineService,
     private readonly milestoneService: ClearanceMilestoneService,
-    private readonly workflowService: ClearanceWorkflowService,
     private readonly invoiceService: BookingInvoiceService,
     private readonly bookingNotifier: BookingLifecycleNotifierService,
     private readonly dataSource: DataSource,
@@ -187,21 +190,14 @@ export class ContractBookingService {
 
     const freightType = contract.freightType;
 
-    // GENERAL + customs (Path B) runs per-booking clearance: the booking starts
-    // in the clearance gate (AWAITING_DOCUMENTS) instead of going straight to
-    // operations, and there is NO contract-level clearance cycle to link.
-    const generalCustoms =
-      contract.contractKind === 'GENERAL' && Boolean(contract.customsClearingEnabled);
-
-    // 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). 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;
+    // EVERY contract booking clears per booking now — both contract kinds, both
+    // paths, intercity included. Customs (Path B): GL runs the phased ET/DJ
+    // workflow on this booking. Non-customs (Path A) and intercity: the customer
+    // uploads his own document set on the booking and Operations reviews it
+    // (AWAITING_DOCUMENTS → DOCUMENTS_UNDER_REVIEW → CLEARANCE_READY →
+    // requestOperation; intercity finalize goes straight to the ride-along pool).
+    // So the booking is always born in the clearance gate, never in the
+    // operations queue, and no contract-level clearance cycle exists to link.
 
     // Intercity (DOMESTIC) bookings ride on a passing import/export train:
     // there is no window and no date — staff accept them onto a train at
@@ -218,24 +214,11 @@ export class ContractBookingService {
       throw new BadRequestException('A binding shipment day is required');
     }
 
-    // Booking-window gate (config-driven): an operations booking may only be
-    // created while the route's booking window is open — import: the day's window
-    // (windowOpenHour EAT, importWindowLeadDays before departure, windowDurationHours);
-    // export: within exportBookingLeadHours of departure. Bookings that enter the
-    // clearance gate first (Path B customs AND Path A per-booking self-clearance)
-    // are scheduled later, so they are not gated here.
-    if (!generalCustoms && !generalSelfClear && !isIntercity) {
-      await this.trainSchedulingService.assertBookingWindowOpen({
-        originYardId: route?.originYardId ?? null,
-        destinationYardId: route?.destinationYardId ?? null,
-        scheduledDate: dto.scheduledDate ?? null,
-        direction: contract.tradeDirection ?? null,
-      });
-      // EXPORT rides whole or not at all (no split concept): reject the booking
-      // up front when no single open train on the day can carry it, telling the
-      // customer how much space is still bookable.
-      await this.assertExportTrainSpace(contract, route, dto);
-    }
+    // No booking-window / export-space gate here any more: every contract
+    // booking enters the clearance gate first and is scheduled only once the
+    // documents are approved. Both checks run at that point instead —
+    // `completeUnderContract` (bare instances) and `requestOperation` (bookings
+    // created with cargo) — against the day the customer actually picks.
 
     // Hard capacity gate: a container line whose total weight exceeds the
     // container type's max capacity can never be booked — no surcharge path,
@@ -265,10 +248,7 @@ export class ContractBookingService {
       companyProfileId: contract.companyProfileId ?? null,
       isGovernment: contract.isGovernment,
       governmentInstitution: contract.governmentInstitution ?? null,
-      status:
-        generalCustoms || generalSelfClear
-          ? 'AWAITING_DOCUMENTS'
-          : 'OPERATION_REQUEST_PENDING',
+      status: 'AWAITING_DOCUMENTS',
       bookingType: 'ONE_TIME',
       contractId: contract.id,
       contractRouteId: route?.id ?? null,
@@ -375,10 +355,7 @@ export class ContractBookingService {
     // exactly once whether the booking parks for a partner or finalizes inline.
     this.bookingNotifier.createdToStaff(withContainers ?? booking);
 
-    const intendedStatus =
-      generalCustoms || generalSelfClear
-        ? 'AWAITING_DOCUMENTS'
-        : 'OPERATION_REQUEST_PENDING';
+    const intendedStatus = 'AWAITING_DOCUMENTS';
     if (
       withContainers &&
       freightType === 'CONTAINER' &&
@@ -404,11 +381,7 @@ export class ContractBookingService {
       }
     }
 
-    await this.finalizeContractBooking(
-      booking.id,
-      contract,
-      generalCustoms,
-    );
+    await this.finalizeContractBooking(booking.id, contract);
 
     await this.maybeCompleteContract(contract);
 
@@ -417,13 +390,22 @@ export class ContractBookingService {
   }
 
   /**
-   * Initiate a BARE booking instance under a GENERAL non-customs contract
-   * (Path A per-booking self-clearance). One click, zero input: no schedule
-   * date, no cargo, no window check, no pricing. The instance starts in the
-   * clearance gate (AWAITING_DOCUMENTS); the customer uploads clearance docs,
-   * Operations reviews and finalizes, and only then does the customer complete
-   * the booking (cargo + binding day + window check) via
-   * {@link completeUnderContract} — the same machinery a one-time shipment uses.
+   * Initiate a BARE booking instance under an import/export contract — ONE_TIME
+   * or GENERAL, customs or not. One click, zero input: no schedule date, no
+   * cargo, no window check, no pricing. The instance starts in the clearance
+   * gate (AWAITING_DOCUMENTS) and is where ALL clearance documents live:
+   *
+   * - Path A (self-clearance): the customer initiates, uploads his clearance
+   *   proof, Operations reviews and finalizes.
+   * - Path B (customs, ONE_TIME): the customer initiates too, then uploads the
+   *   GL-input documents on the instance; GL approves them and runs the phased
+   *   ET/DJ workflow (pre-booking milestones are seeded here). GL may still
+   *   initiate on his behalf. GENERAL customs instances come from a shipment
+   *   request ({@link initiateForShipmentRequest}), not from here.
+   *
+   * Only after the clearance is finalized is the booking completed (cargo +
+   * binding day + window check) via {@link completeUnderContract} — by the
+   * customer on Path A, by GL on Path B.
    */
   async initiateUnderContract(
     contractId: string,
@@ -434,13 +416,12 @@ export class ContractBookingService {
     const contract = await this.contractsRepository.findByIdWithRelations(contractId);
     if (!contract) throw new NotFoundException(`Contract ${contractId} not found`);
 
-    const generalSelfClear =
-      contract.contractKind === 'GENERAL' &&
-      !contract.customsClearingEnabled &&
-      contract.tradeDirection !== 'DOMESTIC';
-    if (!generalSelfClear) {
+    // Intercity has no shipment day to defer to, so it is booked directly with
+    // its cargo (the documents still live on that booking). Everything else —
+    // ONE_TIME or GENERAL, customs or self-clear — starts as a bare instance.
+    if (contract.tradeDirection === 'DOMESTIC') {
       throw new BadRequestException(
-        'Initiate booking applies only to general import/export contracts without customs clearing.',
+        'Intercity shipments are booked directly with their cargo — there is no initiate step.',
       );
     }
 
@@ -453,12 +434,28 @@ export class ContractBookingService {
     const isGlActor =
       actorPermissions != null &&
       hasFreightPermission(actorPermissions, FREIGHT_PERMS.contracts.createBooking);
-    const createdByRole = await this.assertGate(contract, isGlActor);
+    // The customer initiates his own shipment instance on ONE_TIME contracts
+    // (customs or self-clearance); GL may also initiate on a customs contract.
+    // GENERAL customs instances come from a shipment request, not from here.
+    const createdByRole = await this.assertGate(contract, isGlActor, true);
 
     if (contract.contractValidUntil && contract.contractValidUntil.getTime() < Date.now()) {
       throw new BadRequestException('Contract validity has expired — no new bookings.');
     }
 
+    // ONE_TIME carries a single shipment at a time; a bare instance occupies the
+    // slot from the moment it is initiated (it is not a terminal status). The
+    // split chain is the one exception — a paid partial frees the slot and
+    // completion enforces that the next booking takes the whole remainder.
+    if (contract.contractKind === 'ONE_TIME' && !(await this.hasSplitBooking(contractId))) {
+      const active = await this.countActiveBookings(contractId);
+      if (active > 0) {
+        throw new BadRequestException(
+          'This one-time contract already has an active booking.',
+        );
+      }
+    }
+
     const route = await this.resolveRoute(contract, dto.contractRouteId);
 
     // Bare instance: no cargo, no date, no price. Draws no contract capacity
@@ -503,6 +500,16 @@ export class ContractBookingService {
         } as never),
     );
 
+    // Customs: the instance runs the phased ET/DJ workflow, so its pre-booking
+    // milestones exist from initiation (the post-booking half is seeded when the
+    // booking is completed). Self-clearance has no milestone timeline.
+    if (contract.customsClearingEnabled) {
+      await this.milestoneService.seedPreBookingMilestonesOnBooking(
+        booking.id,
+        contract.tradeDirection,
+      );
+    }
+
     const result = await this.bookingsRepository.findByIdWithFiles(booking.id);
     this.bookingNotifier.createdToStaff(result ?? booking);
     return { booking: result ?? booking, warnings: [] };
@@ -718,6 +725,15 @@ export class ContractBookingService {
     // after OPERATION_CHANGES_REQUESTED already has its cargo and only re-picks
     // the shipment day.
     if (!hasCargo) {
+      // ONE_TIME split chain: the instance that follows a paid partial must take
+      // the WHOLE outstanding remainder — same rule a booking created with cargo
+      // passes at creation.
+      if (
+        contract.contractKind === 'ONE_TIME' &&
+        (await this.hasSplitBooking(contract.id))
+      ) {
+        await this.assertExactRemainder(contract, dto);
+      }
       await this.assertWithinQuantityCap(contract, dto);
       if (freightType === 'CONTAINER') {
         await this.assertWithinMaxCapacity(contract, dto);
@@ -817,10 +833,7 @@ export class ContractBookingService {
       // Invoice the now-priced booking and, for a customs instance, seed the
       // post-booking milestones (pre-booking ones exist since initiation —
       // ensure* fills only what is missing). Idempotent, non-blocking.
-      const generalCustoms =
-        contract.contractKind === 'GENERAL' &&
-        Boolean(contract.customsClearingEnabled);
-      await this.finalizeContractBooking(booking.id, contract, generalCustoms);
+      await this.finalizeContractBooking(booking.id, contract);
       await this.maybeCompleteContract(contract);
     } else if (freightType === 'CONTAINER') {
       // Resubmit only re-picks the shipment day — the persisted container
@@ -886,33 +899,17 @@ export class ContractBookingService {
   private async finalizeContractBooking(
     bookingId: string,
     contract: Contract,
-    generalCustoms: boolean,
   ): Promise<void> {
     const booking = await this.bookingsRepository.findByIdWithFiles(bookingId);
     if (!booking || booking.status === 'PENDING_CONSOLIDATION') return;
 
-    // ONE_TIME customs (legacy contract-cycle path): link the contract clearance
-    // cycle to this booking, seed post-booking milestones, and lock the contract
-    // to ACTIVE_SHIPMENT_IN_PROGRESS. NOT for GENERAL — it has no contract cycle
-    // and must stay CONTRACT_ACTIVE so further shipment requests can be accepted.
-    if (contract.customsClearingEnabled && !generalCustoms) {
-      const cycle = await this.contractsRepository.currentCycle(contract.id);
-      if (cycle) {
-        await this.contractsRepository.linkBooking(cycle.id, bookingId);
-      }
-      await this.milestoneService.seedPostBookingMilestones(
-        bookingId,
-        contract.tradeDirection,
-      );
-      await this.contractsRepository.update(contract.id, {
-        status: 'ACTIVE_SHIPMENT_IN_PROGRESS',
-        clearanceStatus: 'ACTIVE_SHIPMENT_IN_PROGRESS',
-      } as never);
-    } else if (generalCustoms) {
-      // Per-booking clearance: seed the full milestone timeline on the booking.
-      // ensure* skips codes that already exist — an initiated instance carries
-      // its pre-booking milestones from initiation, and a consolidation pairing
-      // replay must not duplicate the timeline.
+    // Customs runs per booking for BOTH contract kinds: seed the full milestone
+    // timeline on the booking. ensure* skips codes that already exist — an
+    // initiated instance carries its pre-booking milestones from initiation, and
+    // a consolidation pairing replay must not duplicate the timeline. The
+    // contract itself is never moved to ACTIVE_SHIPMENT_IN_PROGRESS any more; it
+    // holds no clearance state at all.
+    if (contract.customsClearingEnabled) {
       await this.milestoneService.ensureBookingMilestones(
         bookingId,
         contract.tradeDirection,
@@ -982,10 +979,7 @@ export class ContractBookingService {
         booking.contractId,
       );
       if (!contract) continue;
-      const generalCustoms =
-        contract.contractKind === 'GENERAL' &&
-        Boolean(contract.customsClearingEnabled);
-      await this.finalizeContractBooking(id, contract, generalCustoms).catch(
+      await this.finalizeContractBooking(id, contract).catch(
         (err) =>
           this.logger.error(
             `Failed to finalize paired contract booking ${booking.reference}: ${
@@ -1000,36 +994,38 @@ export class ContractBookingService {
    * Returns the role to stamp on the booking, or throws if the caller is not
    * allowed to create one for this contract's execution path.
    */
-  private async assertGate(contract: Contract, isGlActor: boolean): Promise<string> {
+  private async assertGate(
+    contract: Contract,
+    isGlActor: boolean,
+    isInitiate = false,
+  ): Promise<string> {
+    // Suspended contracts are frozen for everyone, GL included — say so instead
+    // of letting the executed-status check below give a misleading reason.
+    if (contract.status === 'SUSPENDED') {
+      throw new BadRequestException(
+        'This contract is suspended — no new shipments can be booked until EDR lifts the suspension.',
+      );
+    }
     if (contract.customsClearingEnabled) {
-      // Path B — Global Logistics creates the booking ON BEHALF OF the customer.
-      // The customer never books a customs contract himself.
-      if (!isGlActor) {
+      // Path B — the customer OPENS the shipment instance on a ONE_TIME customs
+      // contract (one click, no cargo) and uploads the GL-input documents on it;
+      // GL still runs the phased ET/DJ clearance and completes the booking with
+      // cargo, day and price. A GENERAL customs instance is opened by a shipment
+      // request instead, and completing any customs booking stays GL-only.
+      const customerMayInitiate = isInitiate && contract.contractKind === 'ONE_TIME';
+      if (!isGlActor && !customerMayInitiate) {
         throw new ForbiddenException(
           'Customs-clearance contracts are booked by Global Logistics on behalf of the customer.',
         );
       }
-      if (contract.contractKind === 'GENERAL') {
-        // GENERAL customs has NO contract clearance cycle — GL books per accepted
-        // shipment request while the contract is active; clearance is per booking.
-        if (contract.status !== 'CONTRACT_ACTIVE') {
-          throw new BadRequestException(
-            'Contract must be active to book a shipment.',
-          );
-        }
-        return 'GL_ET';
-      }
-      // ONE_TIME customs — pre-booking boundary milestone must be complete.
-      const boundaryOk = await this.workflowService.isBoundaryComplete(
-        contract.id,
-        contract.tradeDirection,
-      );
-      if (!boundaryOk) {
+      // No contract clearance cycle exists on either kind now — clearance runs
+      // on the booking, so an executed/active contract is the only gate here.
+      if (!['FULLY_EXECUTED', 'CONTRACT_ACTIVE'].includes(contract.status)) {
         throw new BadRequestException(
-          'Pre-booking clearance is not complete — booking cannot be created yet.',
+          'Contract must be fully executed before booking a shipment.',
         );
       }
-      return 'GL_ET';
+      return isGlActor ? 'GL_ET' : 'CUSTOMER';
     }
 
     // Path A — customer (or staff) once the contract is executed.
@@ -1041,6 +1037,40 @@ export class ContractBookingService {
     return isGlActor ? 'STAFF' : 'CUSTOMER';
   }
 
+  /**
+   * GL fallback worklist: executed ONE_TIME customs contracts with no live
+   * shipment instance yet. The customer normally opens it himself from the
+   * portal; this list lets GL do it on his behalf, and shows the contracts that
+   * are on no other queue (clearance lives on the booking, which does not exist
+   * yet). GENERAL customs is excluded — opened by shipment requests.
+   */
+  async awaitingShipmentContracts(): Promise<Contract[]> {
+    const { items } = await this.contractsRepository.findAllPaginated({
+      page: 1,
+      pageSize: 500,
+      statuses: ['FULLY_EXECUTED'],
+      customsClearingEnabled: true,
+      contractKind: 'ONE_TIME',
+      sortBy: 'createdAt',
+      sortOrder: 'DESC',
+    } as never);
+
+    const out: Contract[] = [];
+    for (const contract of items) {
+      if (contract.contractValidUntil && contract.contractValidUntil.getTime() < Date.now()) {
+        continue;
+      }
+      // A split chain frees the slot for the remainder, so those contracts stay
+      // on the list even while the paid partial booking still exists.
+      if (await this.hasSplitBooking(contract.id)) {
+        out.push(contract);
+        continue;
+      }
+      if ((await this.countActiveBookings(contract.id)) === 0) out.push(contract);
+    }
+    return out;
+  }
+
   private async countActiveBookings(contractId: string): Promise<number> {
     return this.dataSource
       .getRepository(Booking)
@@ -1418,6 +1448,53 @@ export class ContractBookingService {
     ];
   }
 
+  /**
+   * A ONE_TIME contract carries exactly one shipment: once that booking is
+   * delivered (COMPLETED) the contract is fulfilled and moves to
+   * CONTRACT_CLOSED — shown as "Completed" and greyed out in both portals, and
+   * blocking any further booking. A split ONE_TIME is the exception: its
+   * remainder chain must be rebooked and delivered first, so the contract stays
+   * open while the split remainder is outstanding.
+   *
+   * GENERAL contracts are untouched — they close on cap exhaustion or expiry.
+   * Best-effort: a status hiccup must never fail the booking that completed.
+   */
+  @OnEvent('booking.completed')
+  async onBookingCompleted(payload: { bookingId: string }): Promise<void> {
+    try {
+      const booking = await this.bookingsRepository.findById(payload.bookingId);
+      if (!booking?.contractId) return;
+      const contract = await this.contractsRepository.findById(booking.contractId);
+      if (!contract || contract.contractKind === 'GENERAL') return;
+      // Already closed/expired/cancelled — nothing to do.
+      if (isEffectivelyExpired(contract)) return;
+
+      const outstanding = await this.splitOutstanding(contract);
+      if (outstanding) {
+        // 0.001 tolerance absorbs bulk-ton float rounding, same as the
+        // cap-exhaustion path below.
+        const exhausted =
+          contract.freightType === 'CONTAINER'
+            ? [...outstanding.bySize.values()].every((s) => s.outstanding <= 0)
+            : (outstanding.bulk?.outstanding ?? 0) <= 0.001;
+        if (!exhausted) return;
+      }
+
+      await this.contractsRepository.update(contract.id, {
+        status: 'CONTRACT_CLOSED',
+      } as never);
+      this.logger.log(
+        `Contract ${contract.reference} completed — its one-time booking ${booking.reference} was delivered.`,
+      );
+    } catch (err) {
+      this.logger.error(
+        `Could not close contract for completed booking ${payload.bookingId}: ${
+          err instanceof Error ? err.message : String(err)
+        }`,
+      );
+    }
+  }
+
   /**
    * Complete the contract once its quantity cap is fully consumed. Runs after
    * every booking created under a GENERAL contract, and under a ONE_TIME
diff --git a/apps/edr-freight-api/src/modules/contracts/contract-clearance.service.ts b/apps/edr-freight-api/src/modules/contracts/contract-clearance.service.ts
index 0ceea38ed..31fc1f252 100644
--- a/apps/edr-freight-api/src/modules/contracts/contract-clearance.service.ts
+++ b/apps/edr-freight-api/src/modules/contracts/contract-clearance.service.ts
@@ -34,7 +34,7 @@ import { Contract } from './entities/contract.entity';
 import { ContractDocReviewStatus } from './entities/contract-document-review.entity';
 import { FilterContractDto } from './dto/filter-contract.dto';
 import { AdviseContractDutyDto } from './dto/phased-clearance.dto';
-import { buildWorkflowFiles, belongsOnDjClearanceQueue, belongsOnEtClearanceQueue, DJ_CONTRACT_QUEUE_STATUSES, persistDeclarationUploads, persistTransitPermitUploads, PHASED_CUSTOMS_CONTRACT_QUEUE_STATUSES } from './phased-clearance.util';
+import { buildWorkflowFiles, persistDeclarationUploads, persistTransitPermitUploads, PHASED_CUSTOMS_CONTRACT_QUEUE_STATUSES } from './phased-clearance.util';
 
 const RO_VESSEL_MIN_DAYS_CODE = 'ro_vessel_min_days';
 
@@ -1060,46 +1060,6 @@ export class ContractClearanceService {
     });
   }
 
-  /**
-   * Operations queue: self-clearance (Path A) contracts awaiting Operations
-   * review of the customer's own clearance documents.
-   */
-  /**
-   * Statuses a non-customs contract passes through around Operations
-   * clearance review — the set a caller may narrow {@link opsQueue} to.
-   */
-  private static readonly OPS_CLEARANCE_STATUSES = [
-    'AWAITING_CLEARANCE_DOCUMENTS',
-    'CLEARANCE_UNDER_REVIEW',
-    'CLEARANCE_READY_FOR_BOOKING',
-    'FULLY_EXECUTED',
-    'CONTRACT_ACTIVE',
-    'ACTIVE_SHIPMENT_IN_PROGRESS',
-    'CONTRACT_CLOSED',
-    'CANCELLED',
-  ];
-
-  async opsQueue(filter: FilterContractDto): Promise<PaginatedContracts> {
-    // Callers may narrow to any subset of the ops-clearance lifecycle (the
-    // hub's status filter sends an explicit list); anything outside the
-    // whitelist is dropped so this endpoint can't become a general contract
-    // browser. No statuses given → the original under-review queue.
-    const requested = (filter.statuses ?? filter.status ?? '')
-      .split(',')
-      .map((s) => s.trim())
-      .filter((s) =>
-        ContractClearanceService.OPS_CLEARANCE_STATUSES.includes(s),
-      );
-    return this.contractsRepository.findAllPaginated({
-      page: filter.page ?? 1,
-      pageSize: filter.pageSize ?? 100,
-      statuses: requested.length ? requested : ['CLEARANCE_UNDER_REVIEW'],
-      customsClearingEnabled: false,
-      search: filter.search,
-      sortBy: filter.sortBy,
-      sortOrder: filter.sortOrder,
-    });
-  }
 
   /** GL ET history: contracts that completed Path B clearance. */
   async history(filter: FilterContractDto): Promise<PaginatedContracts> {
@@ -1693,80 +1653,4 @@ export class ContractClearanceService {
     return this.contractsService.findById(contractId);
   }
 
-  /** GL ET queue: customs ONE_TIME contracts in phased clearance (persistent after booking). */
-  async etQueue(filter: FilterContractDto): Promise<PaginatedContracts> {
-    const base = await this.contractsRepository.findAllPaginated({
-      page: 1,
-      pageSize: 500,
-      statuses: [...PHASED_CUSTOMS_CONTRACT_QUEUE_STATUSES],
-      customsClearingEnabled: true,
-      contractKind: 'ONE_TIME',
-      sortBy: filter.sortBy,
-      sortOrder: filter.sortOrder,
-    });
-
-    const filtered: typeof base.items = [];
-    for (const c of base.items) {
-      const milestones = await this.workflowService.listMilestones(c.id);
-      if (belongsOnEtClearanceQueue(milestones)) filtered.push(c);
-    }
-
-    const page = filter.page ?? 1;
-    const pageSize = filter.pageSize ?? 50;
-    const start = (page - 1) * pageSize;
-    const items = filtered.slice(start, start + pageSize);
-
-    return {
-      items,
-      total: filtered.length,
-      meta: {
-        page,
-        pageSize,
-        total: filtered.length,
-        totalPages: Math.ceil(filtered.length / pageSize) || 1,
-        hasNextPage: start + pageSize < filtered.length,
-        hasPreviousPage: page > 1,
-      },
-    };
-  }
-
-  /** GL DJ queue: customs ONE_TIME contracts handed off to or handled by Djibouti GL. */
-  async djQueue(filter: FilterContractDto): Promise<PaginatedContracts> {
-    const base = await this.contractsRepository.findAllPaginated({
-      page: 1,
-      pageSize: 500,
-      statuses: [...DJ_CONTRACT_QUEUE_STATUSES],
-      customsClearingEnabled: true,
-      contractKind: 'ONE_TIME',
-      sortBy: filter.sortBy,
-      sortOrder: filter.sortOrder,
-    });
-
-    const filtered: typeof base.items = [];
-    for (const c of base.items) {
-      const cycle = await this.contractsRepository.currentCycle(c.id);
-      const milestones = await this.workflowService.listMilestones(c.id);
-      if (belongsOnDjClearanceQueue(c.tradeDirection, cycle, milestones)) {
-        filtered.push(c);
-      }
-    }
-
-    const page = filter.page ?? 1;
-    const pageSize = filter.pageSize ?? 50;
-    const start = (page - 1) * pageSize;
-    const items = filtered.slice(start, start + pageSize);
-
-    return {
-      items,
-      total: filtered.length,
-      meta: {
-        page,
-        pageSize,
-        total: filtered.length,
-        totalPages: Math.ceil(filtered.length / pageSize) || 1,
-        hasNextPage: start + pageSize < filtered.length,
-        hasPreviousPage: page > 1,
-      },
-    };
-  }
 }
diff --git a/apps/edr-freight-api/src/modules/contracts/contract-duplicate-guard.spec.ts b/apps/edr-freight-api/src/modules/contracts/contract-duplicate-guard.spec.ts
new file mode 100644
index 000000000..1290b2e90
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/contracts/contract-duplicate-guard.spec.ts
@@ -0,0 +1,79 @@
+import { ConflictException } from '@nestjs/common';
+
+import { ContractsService } from './contracts.service';
+import type { CreateContractDto } from './dto/create-contract.dto';
+
+/**
+ * The duplicate guard blocks a new request only when EVERY commercial
+ * dimension matches a live contract — service type, operation type, contract
+ * kind, cargo scope and route. Any one differing must let the request through.
+ */
+describe('ContractsService duplicate guard', () => {
+  const LANE = { originYardId: 'yard-dj', destinationYardId: 'yard-mj' };
+
+  const existing = {
+    id: 'c-1',
+    reference: 'CTR-2026-00001',
+    status: 'PENDING_APPROVAL',
+    contractValidUntil: null,
+    tradeDirection: 'IMPORT',
+    contractKind: 'ONE_TIME',
+    freightType: 'CONTAINER',
+    routes: [LANE],
+    cargoScope: [{ containerSize: '20ft' }, { containerSize: '40ft' }],
+  };
+
+  const dto = (overrides: Partial<CreateContractDto> = {}) =>
+    ({
+      serviceTypeId: 'svc-1',
+      tradeDirection: 'IMPORT',
+      contractKind: 'ONE_TIME',
+      freightType: 'CONTAINER',
+      routes: [LANE],
+      cargoScope: [{ containerSize: '20ft' }, { containerSize: '40ft' }],
+      ...overrides,
+    }) as CreateContractDto;
+
+  const guard = (input: CreateContractDto) => {
+    const service = new ContractsService(
+      {} as never,
+      { findDuplicateCandidates: async () => [existing] } as never,
+      {} as never,
+      {} as never,
+      {} as never,
+      {} as never,
+    );
+    return (
+      service as unknown as {
+        assertNoDuplicateContract(companyId: string, dto: CreateContractDto): Promise<void>;
+      }
+    ).assertNoDuplicateContract('company-1', input);
+  };
+
+  it('blocks an identical request', async () => {
+    await expect(guard(dto())).rejects.toBeInstanceOf(ConflictException);
+  });
+
+  it.each([
+    ['operation type', { tradeDirection: 'EXPORT' }],
+    ['contract kind', { contractKind: 'GENERAL' }],
+    ['freight type', { freightType: 'BULK' }],
+    ['cargo scope', { cargoScope: [{ containerSize: '20ft' }] }],
+    ['route', { routes: [{ originYardId: 'yard-dj', destinationYardId: 'yard-aa' }] }],
+  ])('allows a request with a different %s', async (_label, overrides) => {
+    await expect(guard(dto(overrides as Partial<CreateContractDto>))).resolves.toBeUndefined();
+  });
+
+  it('ignores quantity caps when comparing cargo scope', async () => {
+    await expect(
+      guard(
+        dto({
+          cargoScope: [
+            { containerSize: '20ft', quantityCap: 10 },
+            { containerSize: '40ft', quantityCap: 5 },
+          ],
+        }),
+      ),
+    ).rejects.toBeInstanceOf(ConflictException);
+  });
+});
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 11681a28f..92a313569 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,33 @@ export class ContractNotifierService {
     this.inApp(c, 'Contract rejected', msg);
   }
 
+  /** Backoffice froze the contract — every action on it is blocked until lifted. */
+  suspended(c: Contract, reason: string): void {
+    const msg =
+      `Your contract ${c.reference} has been suspended. Reason: ${reason}. ` +
+      `No new shipments can be booked and existing shipments are on hold until the suspension is lifted.`;
+    void this.notifyContact(c, msg, 'SUSPENDED');
+    this.inApp(c, 'Contract suspended', msg);
+  }
+
+  /** Backoffice lifted the suspension — the contract resumes where it left off. */
+  suspensionLifted(c: Contract, note?: string | null): void {
+    const msg =
+      `The suspension on your contract ${c.reference} has been lifted. ` +
+      `You can continue where you left off.${note ? ` Note: ${note}` : ''}`;
+    void this.notifyContact(c, msg, 'SUSPENSION LIFTED');
+    this.inApp(c, 'Contract suspension lifted', msg);
+  }
+
+  /** Customer cancelled their own contract — staff-side record. */
+  cancelledByCustomer(c: Contract, reason: string): void {
+    this.inAppStaff(
+      c,
+      'Contract cancelled by customer',
+      `Contract ${c.reference} was cancelled by the customer. Reason: ${reason}`,
+    );
+  }
+
   /**
    * 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
diff --git a/apps/edr-freight-api/src/modules/contracts/contract-suspension.spec.ts b/apps/edr-freight-api/src/modules/contracts/contract-suspension.spec.ts
new file mode 100644
index 000000000..5cf24d747
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/contracts/contract-suspension.spec.ts
@@ -0,0 +1,132 @@
+import { ContractTransitionService } from './contract-transition.service';
+import type { Contract } from './entities/contract.entity';
+
+/**
+ * Suspension is only worth having if it is reversible and if it actually
+ * freezes things, and the customer's own cancel is only safe while no shipment
+ * is running. Those three rules are the whole feature — everything else is
+ * plumbing.
+ */
+describe('ContractTransitionService — suspend / resume / customer cancel', () => {
+  const contract = (over: Partial<Contract> = {}): Contract =>
+    ({
+      id: 'c-1',
+      reference: 'CTR-2026-00042',
+      companyId: 'co-1',
+      status: 'CONTRACT_ACTIVE',
+      freightType: 'CONTAINER',
+      ...over,
+    }) as Contract;
+
+  let current: Contract;
+  let repo: {
+    update: jest.Mock;
+    createReviewNote: jest.Mock;
+    countActiveBookings: jest.Mock;
+  };
+  let notifier: {
+    suspended: jest.Mock;
+    suspensionLifted: jest.Mock;
+    cancelledByCustomer: jest.Mock;
+  };
+  let service: ContractTransitionService;
+
+  /** A staff user holding the suspend key — authorization is tested elsewhere. */
+  const staff = {
+    permissions: [{ key: 'edr_freight_app:contracts:suspend' }],
+  };
+
+  beforeEach(() => {
+    current = contract();
+    repo = {
+      // Mirror the real repository: the update patches the row the next
+      // findById returns, so resume() reads what suspend() wrote.
+      update: jest.fn().mockImplementation((_id: string, patch: object) => {
+        current = { ...current, ...patch } as Contract;
+        return Promise.resolve(current);
+      }),
+      createReviewNote: jest.fn().mockResolvedValue(undefined),
+      countActiveBookings: jest.fn().mockResolvedValue(0),
+    };
+    notifier = {
+      suspended: jest.fn(),
+      suspensionLifted: jest.fn(),
+      cancelledByCustomer: jest.fn(),
+    };
+    // These three transitions touch only the repository, the read-back service
+    // and the notifier — the other 14 constructor deps stay unused, so the
+    // instance is built bare and only what is exercised is injected.
+    service = Object.create(
+      ContractTransitionService.prototype,
+    ) as ContractTransitionService;
+    Object.assign(service, {
+      contractsRepository: repo,
+      contractsService: { findById: () => Promise.resolve(current) },
+      notifier,
+    });
+  });
+
+  it('freezes at the current step and remembers where to come back to', async () => {
+    current = contract({ status: 'CLEARANCE_UNDER_REVIEW' });
+
+    await service.suspend('c-1', 'Unpaid demurrage', 'staff-1', staff as never);
+
+    expect(repo.update).toHaveBeenCalledWith('c-1', {
+      status: 'SUSPENDED',
+      statusBeforeSuspension: 'CLEARANCE_UNDER_REVIEW',
+    });
+    expect(notifier.suspended).toHaveBeenCalled();
+  });
+
+  it('restores the pre-suspension status when the suspension is lifted', async () => {
+    current = contract({ status: 'ACTIVE_SHIPMENT_IN_PROGRESS' });
+    await service.suspend('c-1', 'Docs missing', 'staff-1', staff as never);
+
+    await service.resume('c-1', undefined, 'staff-1', staff as never);
+
+    expect(repo.update).toHaveBeenLastCalledWith('c-1', {
+      status: 'ACTIVE_SHIPMENT_IN_PROGRESS',
+      statusBeforeSuspension: null,
+    });
+  });
+
+  it('refuses to suspend a contract the customer has not signed yet', async () => {
+    current = contract({ status: 'PENDING_APPROVAL' });
+
+    await expect(
+      service.suspend('c-1', 'too early', 'staff-1', staff as never),
+    ).rejects.toThrow(/PENDING_APPROVAL/);
+    expect(repo.update).not.toHaveBeenCalled();
+  });
+
+  it('lets the customer cancel a contract with no live shipment', async () => {
+    await service.cancelByCustomer('c-1', 'Changed supplier', 'user-1');
+
+    expect(repo.update).toHaveBeenCalledWith('c-1', { status: 'CANCELLED' });
+    expect(repo.createReviewNote).toHaveBeenCalledWith(
+      'c-1',
+      'Changed supplier',
+      'CANCELLATION',
+      'user-1',
+      'CUSTOMER',
+    );
+  });
+
+  it('blocks the customer cancel while a shipment is still running', async () => {
+    repo.countActiveBookings.mockResolvedValue(2);
+
+    await expect(
+      service.cancelByCustomer('c-1', undefined, 'user-1'),
+    ).rejects.toThrow(/2 active shipments/);
+    expect(repo.update).not.toHaveBeenCalled();
+  });
+
+  it('refuses a customer cancel on a suspended contract — only staff can lift it', async () => {
+    current = contract({ status: 'SUSPENDED' });
+
+    await expect(
+      service.cancelByCustomer('c-1', undefined, 'user-1'),
+    ).rejects.toThrow(/suspended/);
+    expect(repo.update).not.toHaveBeenCalled();
+  });
+});
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 b579acdfb..1a4de8245 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
@@ -28,6 +28,7 @@ import {
   FREIGHT_PERMS,
   forFreightType,
 } from '../../seed/freight-permissions.registry';
+import { TERMINAL_CONTRACT_STATUSES } from './utils/contract-expiry.util';
 import { ContractDocumentHistoryService } from './contract-document-history.service';
 import { ApprovalRulesService } from '../rule-engine/services/approval-rules.service';
 import { CargoTypesService } from '../rule-engine/services/cargo-types.service';
@@ -38,10 +39,8 @@ import { OtpService } from '../otp/otp.service';
 import { ContractTemplatesService } from '../contract-templates/contract-templates.service';
 import { ContractPricingService } from './contract-pricing.service';
 import { ContractNotifierService } from './contract-notifier.service';
-import { ClearanceMilestoneService } from './clearance-milestone.service';
 import { ContractsRepository } from './contracts.repository';
 import { ContractsService } from './contracts.service';
-import { contractClearanceSettingCode } from './contract-clearance.util';
 import {
   Contract,
   ContractDocumentArticle,
@@ -131,6 +130,21 @@ function maskSignerContacts(contacts: { phone?: string; email?: string }): strin
     .join(' and ');
 }
 
+/**
+ * Where the backoffice may freeze a contract: every step from the customer's
+ * signature onward, up to (but not including) the terminal states. Suspending
+ * an unsigned contract is meaningless — staff reject or request changes there.
+ */
+export const SUSPENDABLE_CONTRACT_STATUSES = [
+  'SIGNED_CUSTOMER',
+  'FULLY_EXECUTED',
+  'CONTRACT_ACTIVE',
+  'AWAITING_CLEARANCE_DOCUMENTS',
+  'CLEARANCE_UNDER_REVIEW',
+  'CLEARANCE_READY_FOR_BOOKING',
+  'ACTIVE_SHIPMENT_IN_PROGRESS',
+] as const;
+
 /** Status-machine guard mirroring booking-status.util. */
 function assertContractStatus(contract: Contract, allowed: string[]): void {
   if (!allowed.includes(contract.status)) {
@@ -154,7 +168,6 @@ export class ContractTransitionService {
     private readonly dropdownSettingsService: DropdownSettingsService,
     private readonly filesService: FilesService,
     private readonly signaturesService: SignaturesService,
-    private readonly milestoneService: ClearanceMilestoneService,
     private readonly documentViewModelBuilder: ContractDocumentViewModelBuilder,
     private readonly renderer: ContractRendererService,
     private readonly pdfService: ContractPdfService,
@@ -212,6 +225,7 @@ export class ContractTransitionService {
 
     await this.contractsRepository.update(contractId, {
       status: 'SUBMITTED',
+      submittedAt: new Date(),
     } as never);
     const updated = await this.contractsService.findById(contractId);
     this.notifier.submittedToStaff(updated);
@@ -228,6 +242,7 @@ export class ContractTransitionService {
 
     await this.contractsRepository.update(contractId, {
       status: 'SUBMITTED',
+      submittedAt: new Date(),
     } as never);
     const updated = await this.contractsService.findById(contractId);
     this.notifier.submittedToStaff(updated);
@@ -1262,43 +1277,16 @@ export class ContractTransitionService {
       lockedAt: now,
     };
 
-    // A clearance gate applies whenever a clearance doc set resolves — Path B
-    // (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,
-      contract.customsClearingEnabled ?? false,
-    );
-
-    // GENERAL contracts run clearance PER BOOKING, not at the contract level —
-    // both paths. Customs (Path B): the customer files shipment requests, GL
-    // books each one and the booking carries its own clearance. Self-clearance
-    // (Path A): the customer books, then uploads the clearance docs on that
-    // booking for Operations to review. Only ONE_TIME contracts keep the
-    // contract-level cycle below.
-    const isGeneral = contract.contractKind === 'GENERAL';
-
-    if (clearanceCode && !isGeneral) {
-      // Open a clearance cycle, seed the pre-booking milestones, and route the
-      // customer to upload. Path A is ops-reviewed; Path B is GL-reviewed — the
-      // distinction is enforced at the review/finalize endpoints, not here.
-      const cycleNumber = (contract.clearanceCycleNumber ?? 0) + 1;
-      const cycle = await this.contractsRepository.openCycle(contractId, cycleNumber);
-      await this.milestoneService.seedPreBookingMilestones(contract, cycle.id);
-      // No prepay gate: the customs clearance service fee (Path B) is billed on
-      // the booking invoice together with the freight, so the document step
-      // opens immediately.
-      updates.status = 'AWAITING_CLEARANCE_DOCUMENTS';
-      updates.clearanceStatus = 'AWAITING_DOCUMENTS';
-      updates.clearanceCycleNumber = cycleNumber;
-    } else {
-      // No contract-level clearance gate — DOMESTIC, or any GENERAL contract
-      // (which clears per booking). Ready for shipment requests / direct booking.
-      updates.status =
-        contract.contractKind === 'GENERAL' ? 'CONTRACT_ACTIVE' : 'FULLY_EXECUTED';
-      updates.clearanceStatus = 'NOT_APPLICABLE';
-    }
+    // Clearance ALWAYS runs per booking — both contract kinds, both paths, and
+    // intercity. A signed contract carries no clearance cycle and collects no
+    // documents: the shipment instance created after signature does. Customs
+    // (Path B): the customer initiates the booking (GENERAL: via a shipment
+    // request) and uploads on it, GL reviews and completes it. Self-clearance
+    // (Path A) and intercity: the customer initiates/books and Operations
+    // reviews the booking documents.
+    updates.status =
+      contract.contractKind === 'GENERAL' ? 'CONTRACT_ACTIVE' : 'FULLY_EXECUTED';
+    updates.clearanceStatus = 'NOT_APPLICABLE';
 
     await this.contractsRepository.update(contractId, updates as never);
     await this.regenerateContractPdf(contractId, contract.reference);
@@ -1308,6 +1296,123 @@ export class ContractTransitionService {
   }
 
   /** Customer requests renewal → RENEWAL_DRAFT linked via renewalOfId. */
+  /**
+   * Backoffice freeze, available at every step from the customer signature
+   * onward. The pre-suspension status is stashed so {@link resume} can put the
+   * contract back exactly where it was — a suspension you cannot lift is just a
+   * cancellation under another name.
+   *
+   * While SUSPENDED nothing moves: no new bookings or shipment requests
+   * (ContractBookingService / BookingRequestService), and no writes to the
+   * contract's existing bookings (BookingsRepository.update).
+   */
+  async suspend(
+    contractId: string,
+    reason: string,
+    actorId: string,
+    user?: TCurrentUser | null,
+  ): Promise<Contract> {
+    const contract = await this.contractsService.findById(contractId);
+    assertFreightPermission(user, FREIGHT_PERMS.contracts.suspend);
+    assertContractStatus(contract, [...SUSPENDABLE_CONTRACT_STATUSES]);
+
+    await this.contractsRepository.createReviewNote(
+      contractId,
+      reason,
+      'SUSPENSION',
+      actorId,
+      'STAFF',
+    );
+    await this.contractsRepository.update(contractId, {
+      status: 'SUSPENDED',
+      statusBeforeSuspension: contract.status,
+    } as never);
+    const updated = await this.contractsService.findById(contractId);
+    this.notifier.suspended(updated, reason);
+    return updated;
+  }
+
+  /** Lift a suspension — the contract returns to the status it was frozen at. */
+  async resume(
+    contractId: string,
+    note: string | undefined,
+    actorId: string,
+    user?: TCurrentUser | null,
+  ): Promise<Contract> {
+    const contract = await this.contractsService.findById(contractId);
+    assertFreightPermission(user, FREIGHT_PERMS.contracts.suspend);
+    assertContractStatus(contract, ['SUSPENDED']);
+
+    // Legacy safety net: a row suspended before the column existed has nothing
+    // to restore. CONTRACT_ACTIVE is the post-signature resting state for both
+    // contract kinds, so it is the only sane default.
+    const restored = contract.statusBeforeSuspension ?? 'CONTRACT_ACTIVE';
+
+    if (note?.trim()) {
+      await this.contractsRepository.createReviewNote(
+        contractId,
+        note.trim(),
+        'SUSPENSION_LIFTED',
+        actorId,
+        'STAFF',
+      );
+    }
+    await this.contractsRepository.update(contractId, {
+      status: restored,
+      statusBeforeSuspension: null,
+    } as never);
+    const updated = await this.contractsService.findById(contractId);
+    this.notifier.suspensionLifted(updated, note ?? null);
+    return updated;
+  }
+
+  /**
+   * Customer cancels their own contract so they can request a fresh one for the
+   * same lane — the duplicate-contract guard treats CANCELLED as released.
+   * Blocked while any booking on the contract is still live: cancelling a
+   * contract with cargo in motion would strand it.
+   */
+  async cancelByCustomer(
+    contractId: string,
+    reason: string | undefined,
+    userId?: string,
+  ): Promise<Contract> {
+    const contract = await this.contractsService.findById(contractId);
+    if ((TERMINAL_CONTRACT_STATUSES as readonly string[]).includes(contract.status)) {
+      throw new ConflictException(
+        `Contract is already ${contract.status.toLowerCase().replace(/_/g, ' ')}.`,
+      );
+    }
+    if (contract.status === 'SUSPENDED') {
+      throw new ConflictException(
+        'This contract is suspended by EDR — contact us to lift the suspension first.',
+      );
+    }
+
+    const active = await this.contractsRepository.countActiveBookings(contractId);
+    if (active > 0) {
+      throw new BadRequestException(
+        `This contract has ${active} active shipment${active === 1 ? '' : 's'}. ` +
+          'Cancel or complete them before cancelling the contract.',
+      );
+    }
+
+    const body = reason?.trim() || 'Cancelled by the customer.';
+    await this.contractsRepository.createReviewNote(
+      contractId,
+      body,
+      'CANCELLATION',
+      userId,
+      'CUSTOMER',
+    );
+    await this.contractsRepository.update(contractId, {
+      status: 'CANCELLED',
+    } as never);
+    const updated = await this.contractsService.findById(contractId);
+    this.notifier.cancelledByCustomer(updated, body);
+    return updated;
+  }
+
   async renew(contractId: string, userId?: string): Promise<Contract> {
     const source = await this.contractsService.findById(contractId);
 
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 74574ed28..ab330ae9c 100644
--- a/apps/edr-freight-api/src/modules/contracts/contracts.controller.ts
+++ b/apps/edr-freight-api/src/modules/contracts/contracts.controller.ts
@@ -66,9 +66,12 @@ import { ContractListSummaryDto } from './dto/contract-list-summary.dto';
 import { AcceptContractDto } from './dto/accept-contract.dto';
 import { UpdateContractDocumentDto } from './dto/contract-document.dto';
 import {
+  CancelContractDto,
   RejectContractDto,
   RejectStepDto,
   RequestChangesDto,
+  ResumeContractDto,
+  SuspendContractDto,
 } from './dto/approve-step.dto';
 import { SignContractDto } from './dto/sign-contract.dto';
 import { ReviewClearanceDocumentDto } from './dto/review-clearance-document.dto';
@@ -273,6 +276,18 @@ export class ContractsController {
     return this.clearanceService.queue(filter);
   }
 
+  // Must stay ABOVE @Get(':id') — declared after it, Nest matched the literal
+  // path as an id and ParseUUIDPipe answered 400 "uuid is expected".
+  @Get('awaiting-shipment')
+  @BookingStaff(FREIGHT_PERMS.contracts.createBooking)
+  @ApiOperation({
+    summary:
+      'GL worklist: executed one-time customs contracts with no shipment instance yet — GL initiates the booking the customer then uploads documents on.',
+  })
+  awaitingShipmentContracts() {
+    return this.contractBookingService.awaitingShipmentContracts();
+  }
+
   @Get(':id')
   @ApiOperation({ summary: 'Get contract by ID (routes, cargo scope, unit rates)' })
   async findOne(
@@ -453,6 +468,65 @@ export class ContractsController {
     );
   }
 
+  @Post(':id/suspend')
+  @BookingStaff(FREIGHT_PERMS.contracts.suspend)
+  @ApiOperation({
+    summary: 'Staff freeze a signed contract (reversible, any post-signature step)',
+  })
+  suspend(
+    @Param('id', ParseUUIDPipe) id: string,
+    @Body() dto: SuspendContractDto,
+    @CurrentUser() user: TCurrentUser,
+  ) {
+    return this.transitionService.suspend(
+      id,
+      dto.reason,
+      resolveAuthUserId(user),
+      user,
+    );
+  }
+
+  @Post(':id/resume')
+  @BookingStaff(FREIGHT_PERMS.contracts.suspend)
+  @ApiOperation({ summary: 'Staff lift a suspension — contract returns to its prior status' })
+  resume(
+    @Param('id', ParseUUIDPipe) id: string,
+    @Body() dto: ResumeContractDto,
+    @CurrentUser() user: TCurrentUser,
+  ) {
+    return this.transitionService.resume(
+      id,
+      dto.note,
+      resolveAuthUserId(user),
+      user,
+    );
+  }
+
+  @Post(':id/cancel')
+  @ApiOperation({
+    summary: 'Customer cancels their own contract (blocked while a booking is live)',
+  })
+  async cancel(
+    @Param('id', ParseUUIDPipe) id: string,
+    @Body() dto: CancelContractDto,
+    @CurrentUser() user: TCurrentUser,
+  ) {
+    // Same ownership rule as renew: staff with bookings.view/contracts.view pass
+    // through, everyone else must own the contract's company.
+    const contract = await this.contractsService.findById(id);
+    if (
+      !hasFreightPermission(user, FREIGHT_PERMS.bookings.view) &&
+      !hasFreightPermission(user, FREIGHT_PERMS.contracts.view)
+    ) {
+      await this.contractsService.assertCustomerCanAccessContract(user?.id, contract);
+    }
+    return this.transitionService.cancelByCustomer(
+      id,
+      dto.reason,
+      resolveAuthUserId(user),
+    );
+  }
+
   @Post(':id/approval-steps/:stepId/approve')
   @BookingStaff(FREIGHT_PERMS.contracts.view)
   @ApiOperation({ summary: 'Approve one approval step in sequence' })
@@ -924,31 +998,8 @@ export class ContractsController {
     return this.clearanceService.finalizeExportClearance(id, resolveAuthUserId(user));
   }
 
-  @Get('clearance/et-queue')
-  @BookingStaff(FREIGHT_PERMS.contracts.clearanceEtActions)
-  @ApiOperation({ summary: 'GL Ethiopia phased clearance list (persistent after booking)' })
-  etClearanceQueue(@Query() filter: FilterContractDto) {
-    return this.clearanceService.etQueue(filter);
-  }
-
-  @Get('clearance/dj-queue')
-  @BookingStaff(FREIGHT_PERMS.contracts.clearanceDjActions)
-  @ApiOperation({ summary: 'GL Djibouti phased clearance list (persistent after booking)' })
-  djClearanceQueue(@Query() filter: FilterContractDto) {
-    return this.clearanceService.djQueue(filter);
-  }
-
   // ── Path A self-clearance — Operations reviews the customer's own docs ───────
 
-  @Get('clearance/ops-queue')
-  @BookingStaff(FREIGHT_PERMS.contracts.opsClearanceReview)
-  @ApiOperation({
-    summary: 'Operations queue: self-clearance (non-customs) contracts awaiting review',
-  })
-  opsClearanceQueue(@Query() filter: FilterContractDto) {
-    return this.clearanceService.opsQueue(filter);
-  }
-
   @Post(':id/clearance/ops-review')
   @BookingStaff(FREIGHT_PERMS.contracts.opsClearanceReview)
   @ApiOperation({
@@ -1017,7 +1068,7 @@ export class ContractsController {
   @Post(':id/bookings/initiate')
   @ApiOperation({
     summary:
-      'Initiate a bare booking instance under a GENERAL non-customs contract — no cargo, no date; enters per-booking clearance (AWAITING_DOCUMENTS).',
+      'Initiate a bare booking instance under an import/export contract (ONE_TIME or GENERAL) — no cargo, no date; enters per-booking clearance (AWAITING_DOCUMENTS). ONE_TIME customs instances are opened by the customer (or GL); GENERAL customs comes from a shipment request.',
   })
   initiateBooking(
     @Param('id', ParseUUIDPipe) id: string,
@@ -1335,7 +1386,7 @@ export class ContractsController {
   ) {
     const file = (files ?? [])[0];
     const booking = await this.bookingsService.findById(bookingId);
-    if (this.bookingClearanceService.isPhasedGeneralCustomsBooking(booking)) {
+    if (this.bookingClearanceService.isPhasedCustomsBooking(booking)) {
       return this.bookingClearanceService.uploadDutySlip(bookingId, file);
     }
     return this.glOperationsService.uploadDutySlip(bookingId, file);
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 b9c22d1af..49ef3a29f 100644
--- a/apps/edr-freight-api/src/modules/contracts/contracts.repository.ts
+++ b/apps/edr-freight-api/src/modules/contracts/contracts.repository.ts
@@ -3,6 +3,7 @@ import { Injectable } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
 import { DataSource, In, IsNull, Repository, SelectQueryBuilder } from 'typeorm';
 
+import { Booking } from '../bookings/entities/booking.entity';
 import { FileRecord } from '../files/entities/file.entity';
 import { Contract } from './entities/contract.entity';
 import { ContractApprovalStep } from './entities/contract-approval-step.entity';
@@ -16,6 +17,18 @@ import { ContractReviewNote, ContractReviewNoteType } from './entities/contract-
 import { ContractSignature, ContractSignerRole } from './entities/contract-signature.entity';
 import { TERMINAL_CONTRACT_STATUSES } from './utils/contract-expiry.util';
 
+/**
+ * Booking statuses that release whatever the booking was holding — contract
+ * capacity, the one-time active slot, the cancel gate. Everything else counts
+ * as a live booking.
+ */
+export const TERMINAL_BOOKING_STATUSES = [
+  'EXPIRED',
+  'CANCELLED',
+  'COMPLETED',
+  'REJECTED',
+];
+
 export interface ContractListFilterOptions {
   statuses?: string[];
   status?: string;
@@ -68,8 +81,9 @@ export class ContractsRepository extends BaseRepository<Contract> {
   }
 
   /**
-   * Non-terminal contracts for the same company + service type, with routes
-   * loaded — candidates for the duplicate-contract check on create(). Terminal
+   * Non-terminal contracts for the same company + service type, with routes and
+   * cargo scope loaded — candidates for the duplicate-contract check on
+   * create() (which also compares operation type, kind and scope). Terminal
    * filtering happens in JS via isEffectivelyExpired (also covers the
    * date-passed-but-not-yet-cron-flipped case).
    */
@@ -80,6 +94,7 @@ export class ContractsRepository extends BaseRepository<Contract> {
     return this.repository
       .createQueryBuilder('contract')
       .leftJoinAndSelect('contract.routes', 'routes')
+      .leftJoinAndSelect('contract.cargoScope', 'cargoScope')
       .where('contract.deleted_at IS NULL')
       .andWhere('contract.company_id = :companyId', { companyId })
       .andWhere('contract.service_type_id = :serviceTypeId', { serviceTypeId })
@@ -541,6 +556,23 @@ export class ContractsRepository extends BaseRepository<Contract> {
 
   // ── Review notes ──────────────────────────────────────────────────────────────
 
+  /**
+   * Bookings on the contract that have not reached a terminal state. Gates the
+   * customer's own contract cancellation (a contract carrying live cargo may
+   * not be cancelled) and is surfaced on the detail response so the portal can
+   * disable the button instead of failing the call.
+   */
+  async countActiveBookings(contractId: string): Promise<number> {
+    return this.dataSource
+      .getRepository(Booking)
+      .createQueryBuilder('b')
+      .where('b.contract_id = :contractId', { contractId })
+      .andWhere('b.status NOT IN (:...terminal)', {
+        terminal: TERMINAL_BOOKING_STATUSES,
+      })
+      .getCount();
+  }
+
   async createReviewNote(
     contractId: string,
     body: string,
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 43aab750f..24aa2b597 100644
--- a/apps/edr-freight-api/src/modules/contracts/contracts.service.ts
+++ b/apps/edr-freight-api/src/modules/contracts/contracts.service.ts
@@ -10,7 +10,7 @@ import { DataSource } from 'typeorm';
 import { insertWithGeneratedReference } from '@edr/api-common';
 
 import { YardCountry } from '@edr/types';
-
+//
 import { deriveTradeDirection } from '../../common/derive-trade-direction.util';
 import { CompaniesService } from '../companies/companies.service';
 import { ServiceType } from '../rule-engine/entities/service-type.entity';
@@ -73,6 +73,30 @@ function describeCargoScope(scope?: ContractCargoScope[]): string | null {
     .join(', ');
 }
 
+/**
+ * Order-independent identity of a cargo scope — two contracts cover the same
+ * cargo only when they list the same container sizes / commodities. Quantity
+ * caps are deliberately ignored: they size a GENERAL contract, they don't make
+ * it a different scope.
+ */
+function cargoScopeKey(
+  scope?: Array<
+    Pick<ContractCargoScope, 'containerSize' | 'cargoTypeId' | 'cargoFreeText'>
+  > | null,
+): string {
+  if (!scope?.length) return '';
+  return scope
+    .map((row) =>
+      [
+        row.containerSize?.trim().toLowerCase() ?? '',
+        row.cargoTypeId ?? '',
+        row.cargoFreeText?.trim().toLowerCase() ?? '',
+      ].join('|'),
+    )
+    .sort()
+    .join(',');
+}
+
 const NEEDS_ACTION_STATUSES = [
   'SUBMITTED',
   'PENDING_APPROVAL',
@@ -190,25 +214,34 @@ export class ContractsService {
   }
 
   /**
-   * Same customer + same service type + an overlapping route already has a
-   * non-expired contract → block. A route "overlaps" if any origin/destination
-   * pair matches — good enough today since ONE_TIME and GENERAL contracts both
-   * carry a single route in practice, and still correct if that changes.
+   * A live contract only blocks a new request when EVERY commercial dimension
+   * of the wizard matches it: service type, operation type (trade direction),
+   * contract kind, cargo scope and route. Change any one of them — a different
+   * lane, bulk instead of containers, GENERAL instead of ONE_TIME — and the
+   * customer may request another contract.
+   *
+   * A route "overlaps" if any origin/destination pair matches; cargo scope
+   * matches only when the two scope sets are identical (same freight type and
+   * the same container sizes / commodities).
    */
   private async assertNoDuplicateContract(
     companyId: string,
-    serviceTypeId: string,
-    routes: CreateContractDto['routes'],
+    dto: CreateContractDto,
   ): Promise<void> {
     const candidates = await this.contractsRepository.findDuplicateCandidates(
       companyId,
-      serviceTypeId,
+      dto.serviceTypeId,
     );
+    const incomingScope = cargoScopeKey(dto.cargoScope);
     const duplicate = candidates.find(
       (c) =>
         !isEffectivelyExpired(c) &&
+        c.tradeDirection === dto.tradeDirection &&
+        c.contractKind === dto.contractKind &&
+        c.freightType === dto.freightType &&
+        cargoScopeKey(c.cargoScope) === incomingScope &&
         (c.routes ?? []).some((existingRoute) =>
-          routes.some(
+          dto.routes.some(
             (r) =>
               r.originYardId === existingRoute.originYardId &&
               r.destinationYardId === existingRoute.destinationYardId,
@@ -220,7 +253,7 @@ export class ContractsService {
         ? duplicate.contractValidUntil.toISOString().slice(0, 10)
         : 'its approval completes';
       throw new ConflictException(
-        `An active contract already exists for this service type and route (${duplicate.reference}, valid until ${until}). A new request can't be submitted until it expires or is rejected/cancelled.`,
+        `An active contract already exists for this service type, operation type, contract kind, cargo scope and route (${duplicate.reference}, valid until ${until}). Change any one of them, or wait until this contract expires or is rejected/cancelled.`,
       );
     }
   }
@@ -257,7 +290,7 @@ export class ContractsService {
     this.assertRouteShape(dto.contractKind, dto.routes);
     await this.assertRoutesMatchDirection(dto.tradeDirection, dto.routes);
     if (companyId) {
-      await this.assertNoDuplicateContract(companyId, dto.serviceTypeId, dto.routes);
+      await this.assertNoDuplicateContract(companyId, dto);
     }
 
     // Stamp the operational profile for portal scoping. A forwarder contract
@@ -813,6 +846,24 @@ export class ContractsService {
       }
     }
 
+    // Why the contract is frozen — shown to staff and customer alike.
+    if (contract.status === 'SUSPENDED') {
+      try {
+        const note = await this.contractsRepository.findLatestReviewNote(
+          contract.id,
+          'SUSPENSION',
+        );
+        contract.latestSuspensionNote = note?.body ?? null;
+      } catch {
+        contract.latestSuspensionNote = null;
+      }
+    }
+
+    // Lets the portal disable "Cancel contract" instead of letting the customer
+    // click it and read a 400. The API re-checks on cancel regardless.
+    contract.activeBookingCount =
+      await this.contractsRepository.countActiveBookings(contract.id);
+
     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 9a86a5b4e..6aa36b13d 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
@@ -50,3 +50,17 @@ export class CancelContractDto {
   @IsString()
   reason?: string;
 }
+
+export class SuspendContractDto {
+  @ApiProperty({ description: 'Why the contract is being frozen — shown to the customer' })
+  @IsString()
+  @MinLength(1)
+  reason!: string;
+}
+
+export class ResumeContractDto {
+  @ApiPropertyOptional({ description: 'Optional note recorded when the suspension is lifted' })
+  @IsOptional()
+  @IsString()
+  note?: string;
+}
diff --git a/apps/edr-freight-api/src/modules/contracts/entities/contract-review-note.entity.ts b/apps/edr-freight-api/src/modules/contracts/entities/contract-review-note.entity.ts
index 4d2a46365..5b64fe5f7 100644
--- a/apps/edr-freight-api/src/modules/contracts/entities/contract-review-note.entity.ts
+++ b/apps/edr-freight-api/src/modules/contracts/entities/contract-review-note.entity.ts
@@ -13,6 +13,12 @@ export const CONTRACT_REVIEW_NOTE_TYPES = [
    * correct it. One row per round — the advice/dispute loop can repeat.
    */
   'DUTY_DISPUTE',
+  /** Backoffice froze the contract; body is the reason shown to the customer. */
+  'SUSPENSION',
+  /** Backoffice lifted a suspension; body is the optional lift note. */
+  'SUSPENSION_LIFTED',
+  /** Customer cancelled their own contract; body is their reason. */
+  'CANCELLATION',
 ] as const;
 export type ContractReviewNoteType =
   (typeof CONTRACT_REVIEW_NOTE_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 3fe48ea27..cdf6b4ecf 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
@@ -29,6 +29,8 @@ export const CONTRACT_STATUSES = [
   'CLEARANCE_UNDER_REVIEW',
   'CLEARANCE_READY_FOR_BOOKING',
   'ACTIVE_SHIPMENT_IN_PROGRESS',
+  // Reversible backoffice freeze — see statusBeforeSuspension.
+  'SUSPENDED',
   'CONTRACT_CLOSED',
   'EXPIRED',
   'REJECTED',
@@ -214,9 +216,21 @@ export class Contract extends BaseEntity {
   @Column({ name: 'expires_at', type: 'timestamptz', nullable: true })
   expiresAt?: Date | null;
 
+  /** When the customer last submitted this contract (DRAFT/CHANGES_REQUESTED → SUBMITTED). */
+  @Column({ name: 'submitted_at', type: 'timestamptz', nullable: true })
+  submittedAt?: Date | null;
+
   @Column({ name: 'status', type: 'varchar', length: 40, default: 'DRAFT' })
   status!: string;
 
+  /**
+   * Status the contract held when the backoffice suspended it, restored when
+   * the suspension is lifted. Null unless the contract is (or once was)
+   * SUSPENDED. A suspension without this would just be a cancellation.
+   */
+  @Column({ name: 'status_before_suspension', type: 'varchar', length: 40, nullable: true })
+  statusBeforeSuspension?: string | null;
+
   @Column({ name: 'clearance_status', type: 'varchar', length: 40, default: 'NOT_APPLICABLE' })
   clearanceStatus!: string;
 
@@ -343,4 +357,18 @@ export class Contract extends BaseEntity {
    * contract_review_notes, not a column here.
    */
   latestSendBackNote?: string | null;
+
+  /**
+   * Body of the most recent SUSPENSION review note, attached by
+   * ContractsService.findById while the contract is SUSPENDED so both sides see
+   * why it was frozen. Lives in contract_review_notes, not a column here.
+   */
+  latestSuspensionNote?: string | null;
+
+  /**
+   * Count of this contract's non-terminal bookings, attached by
+   * ContractsService.findById. The portal disables customer cancellation while
+   * it is > 0 (the API enforces the same). Not a column.
+   */
+  activeBookingCount?: number;
 }
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 a42dcd220..0c3b2aa51 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,13 +1,16 @@
 import { ApiPropertyOptional } from '@nestjs/swagger';
 import { Transform } from 'class-transformer';
-import { IsBoolean, IsIn, IsOptional, IsUUID } from 'class-validator';
+import { IsBoolean, IsDateString, IsIn, IsOptional, IsUUID } from 'class-validator';
 
+import { PaginationQueryDto } from '../../../common/dto/pagination-query.dto';
 import {
   LOCOMOTIVE_STATUSES,
   LOCOMOTIVE_TYPES,
 } from '../entities/locomotive.entity';
 
-export class FilterLocomotivesDto {
+// Extends the shared pagination DTO for `page`/`pageSize`/`search`; those are
+// only read by `GET /locomotives/paged` — the plain list ignores them.
+export class FilterLocomotivesDto extends PaginationQueryDto {
   @ApiPropertyOptional({ enum: LOCOMOTIVE_STATUSES })
   @IsOptional()
   @IsIn([...LOCOMOTIVE_STATUSES])
@@ -47,4 +50,14 @@ export class FilterLocomotivesDto {
   @IsOptional()
   @IsUUID()
   excludeTrainId?: string;
+
+  @ApiPropertyOptional({ description: 'Registered on or after this day (YYYY-MM-DD)' })
+  @IsOptional()
+  @IsDateString()
+  createdFrom?: string;
+
+  @ApiPropertyOptional({ description: 'Registered on or before this day (YYYY-MM-DD)' })
+  @IsOptional()
+  @IsDateString()
+  createdTo?: string;
 }
diff --git a/apps/edr-freight-api/src/modules/locomotives/locomotives.controller.ts b/apps/edr-freight-api/src/modules/locomotives/locomotives.controller.ts
index 77d8b0df2..3883f8d99 100644
--- a/apps/edr-freight-api/src/modules/locomotives/locomotives.controller.ts
+++ b/apps/edr-freight-api/src/modules/locomotives/locomotives.controller.ts
@@ -24,6 +24,14 @@ export class LocomotivesController {
     return this.locomotivesService.findAll(filter);
   }
 
+  // Must be declared before @Get(':id') so the path isn't captured as an id.
+  @Get('paged')
+  @StaffReference()
+  @ApiOperation({ summary: 'List locomotives, paginated ({items, meta})' })
+  findAllPaged(@Query() filter: FilterLocomotivesDto) {
+    return this.locomotivesService.findAllPaged(filter);
+  }
+
   @Get(':id')
   @StaffReference()
   @ApiOperation({ summary: 'Get a locomotive by ID' })
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 3ad5b3650..11300cfee 100644
--- a/apps/edr-freight-api/src/modules/locomotives/locomotives.repository.ts
+++ b/apps/edr-freight-api/src/modules/locomotives/locomotives.repository.ts
@@ -1,7 +1,7 @@
 import { BaseRepository } from '@edr/api-common';
 import { Injectable } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
-import { Repository } from 'typeorm';
+import { Repository, SelectQueryBuilder } from 'typeorm';
 
 import { Locomotive, type LocomotiveStatus, type LocomotiveType } from './entities/locomotive.entity';
 import { TrainLocomotive } from '../trains/entities/train-locomotive.entity';
@@ -16,18 +16,22 @@ export class LocomotivesRepository extends BaseRepository<Locomotive> {
   }
 
   /**
-   * 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.
+   * Filter/sort builder shared by the coupling picker and the paginated list:
+   * the usual status/type/yard filters, free-text over code + name, a
+   * registration-day range, and 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: {
+  buildListQuery(opts: {
     status?: LocomotiveStatus;
     locomotiveType?: LocomotiveType;
     currentYardId?: string;
     excludeCoupled?: boolean;
     keepTrainId?: string;
-  }): Promise<Locomotive[]> {
+    search?: string;
+    createdFrom?: string;
+    createdTo?: string;
+  }): SelectQueryBuilder<Locomotive> {
     const qb = this.repository
       .createQueryBuilder('locomotive')
       .leftJoinAndSelect('locomotive.currentYard', 'currentYard')
@@ -39,6 +43,25 @@ export class LocomotivesRepository extends BaseRepository<Locomotive> {
     if (opts.currentYardId)
       qb.andWhere('locomotive.currentYardId = :yardId', { yardId: opts.currentYardId });
 
+    const search = opts.search?.trim();
+    if (search) {
+      qb.andWhere('(locomotive.code ILIKE :search OR locomotive.name ILIKE :search)', {
+        search: `%${search}%`,
+      });
+    }
+
+    // Registration-day range, both ends inclusive (the UI picks whole days).
+    if (opts.createdFrom) {
+      qb.andWhere('locomotive.createdAt >= CAST(:createdFrom AS date)', {
+        createdFrom: opts.createdFrom,
+      });
+    }
+    if (opts.createdTo) {
+      qb.andWhere("locomotive.createdAt < CAST(:createdTo AS date) + INTERVAL '1 day'", {
+        createdTo: opts.createdTo,
+      });
+    }
+
     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.
@@ -53,7 +76,11 @@ export class LocomotivesRepository extends BaseRepository<Locomotive> {
       qb.andWhere(`NOT EXISTS (${sub.getQuery()})`).setParameters(sub.getParameters());
     }
 
-    return qb.getMany();
+    return qb;
+  }
+
+  findForCoupling(opts: Parameters<LocomotivesRepository['buildListQuery']>[0]): Promise<Locomotive[]> {
+    return this.buildListQuery(opts).getMany();
   }
 
   /**
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 46396893e..1da03072e 100644
--- a/apps/edr-freight-api/src/modules/locomotives/locomotives.service.ts
+++ b/apps/edr-freight-api/src/modules/locomotives/locomotives.service.ts
@@ -1,6 +1,9 @@
+import { PaginatedResponse } from '@edr/types';
 import { ConflictException, Injectable, NotFoundException } from '@nestjs/common';
 import { DataSource } from 'typeorm';
 
+import { paginateQuery } from '../../common/utils/pagination.util';
+
 import { CreateLocomotiveDto } from './dto/create-locomotive.dto';
 import { FilterLocomotivesDto } from './dto/filter-locomotives.dto';
 import { UpdateLocomotiveDto } from './dto/update-locomotive.dto';
@@ -53,6 +56,21 @@ export class LocomotivesService {
     });
   }
 
+  /** Same filters as `findAll` plus search/date range, on the shared list envelope. */
+  findAllPaged(filter: FilterLocomotivesDto): Promise<PaginatedResponse<Locomotive>> {
+    const qb = this.locomotivesRepository.buildListQuery({
+      status: filter.status as LocomotiveStatus | undefined,
+      locomotiveType: filter.locomotiveType as LocomotiveType | undefined,
+      currentYardId: filter.currentYardId,
+      excludeCoupled: filter.excludeCoupled,
+      keepTrainId: filter.excludeTrainId,
+      search: filter.search,
+      createdFrom: filter.createdFrom,
+      createdTo: filter.createdTo,
+    });
+    return paginateQuery(qb, filter);
+  }
+
   /** Default max pull weight (tons) applied when the caller omits it. */
   private static readonly DEFAULT_MAX_PULL_WEIGHT_TONS = 2500;
 
diff --git a/apps/edr-freight-api/src/modules/routes/dto/filter-routes.dto.ts b/apps/edr-freight-api/src/modules/routes/dto/filter-routes.dto.ts
index 59188a2a6..dfd9a1a91 100644
--- a/apps/edr-freight-api/src/modules/routes/dto/filter-routes.dto.ts
+++ b/apps/edr-freight-api/src/modules/routes/dto/filter-routes.dto.ts
@@ -1,14 +1,13 @@
 import { ApiPropertyOptional } from '@nestjs/swagger';
-import { IsEnum, IsOptional, IsString } from 'class-validator';
+import { IsEnum, IsOptional } from 'class-validator';
 
+import { PaginationQueryDto } from '../../../common/dto/pagination-query.dto';
 import { RouteStatus } from '../entities/route.entity';
 
-export class FilterRoutesDto {
-  @ApiPropertyOptional({ description: 'Search origin/destination yard codes or names' })
-  @IsOptional()
-  @IsString()
-  search?: string;
-
+// `search` (origin/destination/milestone yard codes and names) plus
+// `page`/`pageSize` come from the shared pagination DTO; the page window is only
+// read by `GET /routes/paged`.
+export class FilterRoutesDto extends PaginationQueryDto {
   @ApiPropertyOptional({ enum: ['AVAILABLE', 'MAINTENANCE', 'DAMAGED', 'STOP_WORKING'] })
   @IsOptional()
   @IsEnum(['AVAILABLE', 'MAINTENANCE', 'DAMAGED', 'STOP_WORKING'])
diff --git a/apps/edr-freight-api/src/modules/routes/routes.controller.ts b/apps/edr-freight-api/src/modules/routes/routes.controller.ts
index cf2314156..259dd4c9f 100644
--- a/apps/edr-freight-api/src/modules/routes/routes.controller.ts
+++ b/apps/edr-freight-api/src/modules/routes/routes.controller.ts
@@ -21,6 +21,13 @@ export class RoutesController {
     return this.routesService.findAll(filter);
   }
 
+  // Must be declared before @Get(':id') so the path isn't captured as an id.
+  @Get('paged')
+  @ApiOperation({ summary: 'List routes, paginated ({items, meta})' })
+  findAllPaged(@Query() filter: FilterRoutesDto) {
+    return this.routesService.findAllPaged(filter);
+  }
+
   @Get(':id')
   @ApiOperation({ summary: 'Get route by ID' })
   findOne(@Param('id', ParseUUIDPipe) id: string) {
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 855f8ec02..8c2989b87 100644
--- a/apps/edr-freight-api/src/modules/routes/routes.service.ts
+++ b/apps/edr-freight-api/src/modules/routes/routes.service.ts
@@ -4,9 +4,10 @@ import {
   Injectable,
   NotFoundException,
 } from '@nestjs/common';
-import { TrainScheduleStatus } from '@edr/types';
+import { PaginatedResponse, TrainScheduleStatus } from '@edr/types';
 import { DataSource, In, Not } from 'typeorm';
 
+import { paginateArray } from '../../common/utils/pagination.util';
 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';
@@ -68,6 +69,18 @@ export class RoutesService {
     });
   }
 
+  /**
+   * `findAll` on the shared `{items, meta}` envelope.
+   *
+   * ponytail: slices in memory — the corridor table is small (tens of rows) and
+   * both the ordering (formatted "A → B → C" label) and the search span the
+   * milestone collection, which a single SQL page window cannot express. Move to
+   * a query builder if routes ever grow past a few hundred.
+   */
+  async findAllPaged(filter: FilterRoutesDto): Promise<PaginatedResponse<Route>> {
+    return paginateArray(await this.findAll(filter), filter);
+  }
+
   async findById(id: string): Promise<Route> {
     const route = await this.dataSource.getRepository(Route).findOne({
       where: { id },
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 b308a5921..a402e6237 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
@@ -1,5 +1,6 @@
 import { BookingBatchService } from './booking-batch.service';
 import { Booking } from '../bookings/entities/booking.entity';
+import { WagonStockLedger } from './wagon-stock-ledger.util';
 
 describe('BookingBatchService — PAID reconcile', () => {
   const scheduleId = 'schedule-1';
@@ -40,10 +41,12 @@ describe('BookingBatchService — PAID reconcile', () => {
     previewPaidBookingWagonShortage: jest.Mock;
     getBookableSchedules: jest.Mock;
     getWindowConfig: jest.Mock;
+    wagonStockForSchedule: jest.Mock;
   };
   let dataSource: {
     getRepository: jest.Mock;
     transaction: jest.Mock;
+    query: jest.Mock;
   };
   let notifier: {
     payNow: jest.Mock;
@@ -90,6 +93,13 @@ describe('BookingBatchService — PAID reconcile', () => {
       }),
       // No shortage by default — paid bookings link as before.
       previewPaidBookingWagonShortage: jest.fn().mockResolvedValue(null),
+      // No physical stock configured → the wagon-type gate stands down and these
+      // specs keep testing the abstract capacity budget on its own.
+      wagonStockForSchedule: jest.fn().mockResolvedValue({
+        mode: 'YARD',
+        remainingByTypeId: new Map<string, number>(),
+        codesByTypeId: new Map<string, string>(),
+      }),
       getBookableSchedules: jest.fn().mockResolvedValue([]),
       getWindowConfig: jest.fn().mockResolvedValue({
         importWindowLeadDays: 3,
@@ -116,6 +126,10 @@ describe('BookingBatchService — PAID reconcile', () => {
         };
         await fn(manager);
       }),
+      // cargo/container type -> allowed wagon type lookups (loadAllowedWagonTypeIds).
+      // Empty = unresolvable, so the physical-stock gate stands down and these
+      // specs keep exercising the abstract capacity budget alone.
+      query: jest.fn().mockResolvedValue([]),
     };
 
     notifier = {
@@ -1237,6 +1251,7 @@ describe('BookingBatchService — built-train wagon capacity', () => {
         return genericRepo;
       }),
       transaction: jest.fn(),
+      query: jest.fn().mockResolvedValue([]),
     };
     const service = new BookingBatchService(
       dataSource as never,
@@ -1344,3 +1359,106 @@ describe('BookingBatchService — built-train wagon capacity', () => {
     });
   });
 });
+
+/**
+ * The reported failure: a train advertising 20 free wagons where only 16 are of
+ * the type the booking can ride. Selecting all 20 took the customer's money for
+ * space that never existed and then stalled at allocation on wagon 17.
+ */
+describe('BookingBatchService — physical wagon-type gate', () => {
+  const NW5 = 'wagon-type-nw5';
+  const PW2 = 'wagon-type-pw2';
+  const WHOLE_LEG = { fromEdge: 0, toEdge: 1 };
+
+  /** 16 NW5 + 4 PW2 = 20 wagons on the train, but only 16 usable by an NW5 booking. */
+  const mixedStock = () => new WagonStockLedger(new Map([[NW5, 16], [PW2, 4]]), 1);
+
+  const internals = (svc: BookingBatchService) =>
+    svc as unknown as {
+      hasWagonStock: (
+        stock: WagonStockLedger,
+        ids: string[],
+        needed: number,
+        leg: { fromEdge: number; toEdge: number },
+      ) => boolean;
+      maybeOfferPartial: (
+        booking: Booking,
+        isPair: boolean,
+        candidates: unknown[],
+        need: { wagons: number; weightTons: number; lengthMeters: number },
+        ids: string[],
+      ) => Promise<boolean>;
+      tryPartialOffer: unknown;
+      isSplitEligible: unknown;
+    };
+
+  const service = () =>
+    new BookingBatchService(
+      { getRepository: jest.fn(), transaction: jest.fn(), query: jest.fn() } as never,
+      {} as never,
+      {} as never,
+      {} as never,
+      {} as never,
+      {} as never,
+      {} as never,
+      {} as never,
+      {} as never,
+      {} as never,
+      undefined,
+      { findOpenOffer: jest.fn() } as never,
+    );
+
+  it('refuses a 20-wagon NW5 booking on a train holding only 16 NW5', () => {
+    const svc = internals(service());
+    const stock = mixedStock();
+    expect(svc.hasWagonStock(stock, [NW5], 20, WHOLE_LEG)).toBe(false);
+    expect(svc.hasWagonStock(stock, [NW5], 16, WHOLE_LEG)).toBe(true);
+    // A booking that may ride either type sees all 20.
+    expect(svc.hasWagonStock(stock, [NW5, PW2], 20, WHOLE_LEG)).toBe(true);
+  });
+
+  it('stands down when the booking has no allowed wagon type configured', () => {
+    // Unresolvable configuration must not strand every booking that uses it —
+    // the abstract capacity budget still governs.
+    expect(internals(service()).hasWagonStock(mixedStock(), [], 999, WHOLE_LEG)).toBe(true);
+  });
+
+  it('sizes the split offer to the wagons that physically exist, not the free slots', async () => {
+    const svc = service();
+    const inner = internals(svc);
+    // Isolate the sizing decision: eligibility and offer creation are covered
+    // elsewhere, what matters here is the room handed to tryPartialOffer.
+    (inner as { isSplitEligible: unknown }).isSplitEligible = () => true;
+    const tryPartial = jest
+      .fn()
+      .mockResolvedValue({ wagons: 16, weightTons: 1600, lengthMeters: 224 });
+    (inner as { tryPartialOffer: unknown }).tryPartialOffer = tryPartial;
+
+    const stock = mixedStock();
+    const candidate = {
+      id: 'schedule-1',
+      // 20 abstract slots free, weight and length wide open.
+      budget: {
+        legOf: () => WHOLE_LEG,
+        remainingFor: () => ({ wagons: 20, weightTons: 99_999, lengthMeters: 99_999 }),
+        subtract: jest.fn(),
+      },
+      armed: false,
+      stock,
+    };
+
+    const offered = await inner.maybeOfferPartial(
+      { id: 'b1', reference: 'BK-1', originYardId: 'a', destinationYardId: 'b' } as Booking,
+      false,
+      [candidate],
+      { wagons: 20, weightTons: 2000, lengthMeters: 280 },
+      [NW5],
+    );
+
+    expect(offered).toBe(true);
+    // 16, not the 20 free slots — the customer is billed for what can be loaded.
+    expect(tryPartial.mock.calls[0][2]).toMatchObject({ wagons: 16 });
+    // Those 16 are now held, so the next booking in the pass cannot re-take them.
+    expect(stock.availableFor([NW5], WHOLE_LEG)).toBe(0);
+  });
+});
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 e010b4db9..586ef2f7c 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
@@ -87,6 +87,7 @@ import {
   OverageTolerance,
   stopYardsFor,
 } from './corridor-capacity.util';
+import { WagonStockLedger } from './wagon-stock-ledger.util';
 
 export type { Capacity } from './corridor-capacity.util';
 
@@ -1619,6 +1620,8 @@ export class BookingBatchService implements OnModuleInit {
     const limits = await this.capacityLimits(locomotive);
     await this.syncScheduleMaxWagons(schedule, locomotive);
     const budget = await this.remainingBudget(schedule, limits, wagonDims);
+    const stock = await this.stockLedgerFor(schedule, budget);
+    const allowedWagonTypes = await this.loadAllowedWagonTypeIds();
     const minPerWagon = this.minPerWagonNeed(wagonDims);
     if (budget.isExhausted(minPerWagon)) {
       await this.setWindow(scheduleId, "FULL");
@@ -1655,14 +1658,19 @@ export class BookingBatchService implements OnModuleInit {
       // Consolidated partners always share one corridor, so the primary's leg
       // stands for the pair.
       const leg = budget.legForYards(booking.originYardId, booking.destinationYardId);
+      const wagonTypeIds = this.allowedWagonTypeIdsFor(booking, allowedWagonTypes);
+      // Abstract room AND real wagons of a type this booking can ride — see
+      // fillRouteDayInternal for why both gates are needed.
+      const stocked = this.hasWagonStock(stock, wagonTypeIds, need.wagons, leg);
 
-      // Per-unit fit trace: which axis (wagons/weight/length) admits or rejects.
+      // Per-unit fit trace: which axis (wagons/weight/length/stock) admits or rejects.
       this.logger.debug(
         `[fillSchedule ${scheduleId}] unit ${booking.reference}: need=${JSON.stringify(need)} ` +
-          `roomOnLeg=${JSON.stringify(budget.remainingFor(leg))} fits=${budget.fits(need, leg)}`,
+          `roomOnLeg=${JSON.stringify(budget.remainingFor(leg))} fits=${budget.fits(need, leg)} ` +
+          `stocked=${stocked}`,
       );
 
-      if (!budget.fits(need, leg)) {
+      if (!budget.fits(need, leg) || !stocked) {
         if (isGov) {
           const freed = await this.preemptForGovernment(
             scheduleId,
@@ -1677,16 +1685,19 @@ export class BookingBatchService implements OnModuleInit {
           // Doesn't fit whole. A split-eligible import booking is offered the part
           // that fits in the remaining room (top-up path splits the boundary
           // booking, mirroring fillRouteDay); otherwise skip and try the next.
-          const cand: { id: string; budget: CorridorBudget; armed: boolean } = {
-            id: scheduleId,
-            budget,
-            armed,
-          };
-          if (await this.maybeOfferPartial(booking, isPair, [cand], need)) {
+          const cand: {
+            id: string;
+            budget: CorridorBudget;
+            armed: boolean;
+            stock: WagonStockLedger;
+          } = { id: scheduleId, budget, armed, stock };
+          if (
+            await this.maybeOfferPartial(booking, isPair, [cand], need, wagonTypeIds)
+          ) {
             armed = cand.armed;
             continue;
           }
-          continue; // skip a unit that exceeds weight/length/wagons, try the next
+          continue; // skip a unit that exceeds weight/length/wagons/stock, try the next
         }
       }
 
@@ -1704,6 +1715,8 @@ export class BookingBatchService implements OnModuleInit {
           commercialReserved += 1;
         }
         budget.subtract(need, leg);
+        // Hold the physical wagons too — the next unit must not re-count them.
+        stock.consume(wagonTypeIds, need.wagons, leg);
         reservedThisPass += 1;
       } catch (err) {
         this.logger.error(
@@ -1823,11 +1836,14 @@ export class BookingBatchService implements OnModuleInit {
     }
 
     const wagonDims = await this.loadWagonDims();
+    const allowedWagonTypes = await this.loadAllowedWagonTypeIds();
 
-    // Live per-schedule corridor budget + arm/changed flags, in departure order.
+    // Live per-schedule corridor budget + physical wagon-type stock + arm/changed
+    // flags, in departure order.
     const trains: Array<{
       id: string;
       budget: CorridorBudget;
+      stock: WagonStockLedger;
       armed: boolean;
       changed: boolean;
     }> = [];
@@ -1844,7 +1860,8 @@ export class BookingBatchService implements OnModuleInit {
       const limits = await this.capacityLimits(locomotive);
       await this.syncScheduleMaxWagons(schedule, locomotive);
       const budget = await this.remainingBudget(schedule, limits, wagonDims);
-      trains.push({ id, budget, armed: false, changed: false });
+      const stock = await this.stockLedgerFor(schedule, budget);
+      trains.push({ id, budget, stock, armed: false, changed: false });
     }
     if (trains.length === 0) return { scheduleIds, commercialReserved: 0 };
 
@@ -1884,12 +1901,20 @@ export class BookingBatchService implements OnModuleInit {
 
       const legOn = (t: { budget: CorridorBudget }): CorridorLeg | null =>
         t.budget.legOf(booking.originYardId, booking.destinationYardId);
+      // Consolidated pairs share one wagon set; the primary's types stand for both.
+      const wagonTypeIds = this.allowedWagonTypeIdsFor(booking, allowedWagonTypes);
 
       // First train (earliest departure) whose corridor carries this booking's
-      // leg and still fits it as-is.
+      // leg, still fits it as-is AND physically holds enough wagons of a type the
+      // booking can ride. Both gates matter: abstract room without the right
+      // wagon type is space the allocator can never turn into a loaded consist.
       let target = trains.find((t) => {
         const leg = legOn(t);
-        return leg != null && t.budget.fits(need, leg);
+        return (
+          leg != null &&
+          t.budget.fits(need, leg) &&
+          this.hasWagonStock(t.stock, wagonTypeIds, need.wagons, leg)
+        );
       });
 
       // Per-unit trace: chosen train + each train's remaining room on this leg.
@@ -1934,7 +1959,13 @@ export class BookingBatchService implements OnModuleInit {
         // already consumed most of the room). Consolidated pairs / government /
         // non-import never split — isSplitEligible guards that. Passing the live
         // `trains` entries lets maybeOfferPartial mutate the chosen budget/armed.
-        const offered = await this.maybeOfferPartial(booking, isPair, trains, need);
+        const offered = await this.maybeOfferPartial(
+          booking,
+          isPair,
+          trains,
+          need,
+          wagonTypeIds,
+        );
         if (offered) {
           // A partial offer opens a real commercial pay window, same as reserve().
           commercialReserved += 1;
@@ -1964,6 +1995,9 @@ export class BookingBatchService implements OnModuleInit {
           commercialReserved += 1;
         }
         target.budget.subtract(need, legOn(target)!);
+        // Hold the physical wagons too, so the next unit in this pass sees them
+        // gone — otherwise two bookings both "fit" the same 16 NW5.
+        target.stock.consume(wagonTypeIds, need.wagons, legOn(target)!);
         target.changed = true;
         reservedThisPass += 1;
       } catch (err) {
@@ -2027,14 +2061,32 @@ export class BookingBatchService implements OnModuleInit {
   private async maybeOfferPartial(
     booking: Booking,
     isPair: boolean,
-    candidates: Array<{ id: string; budget: CorridorBudget; armed: boolean }>,
+    candidates: Array<{
+      id: string;
+      budget: CorridorBudget;
+      armed: boolean;
+      stock?: WagonStockLedger;
+    }>,
     need: Capacity,
+    wagonTypeIds: string[] = [],
   ): Promise<boolean> {
     if (!this.isSplitEligible(booking, isPair)) return false;
     const target = candidates
       .map((c) => {
         const leg = c.budget.legOf(booking.originYardId, booking.destinationYardId);
-        return leg ? { c, leg, room: c.budget.remainingFor(leg) } : null;
+        if (!leg) return null;
+        const room = c.budget.remainingFor(leg);
+        // The offer may never exceed the wagons that physically exist in a type
+        // this booking can ride. This is what turns "20 free wagons, only 16 of
+        // them NW5" into an offer for 16 — the customer pays for 16 and the
+        // other 4 leave as the usual remainder booking, instead of paying for
+        // 20 and stalling at allocation on wagon 17.
+        const physical = wagonTypeIds.length
+          ? c.stock?.availableFor(wagonTypeIds, leg)
+          : undefined;
+        const wagons =
+          physical == null ? room.wagons : Math.min(room.wagons, physical);
+        return { c, leg, room: { ...room, wagons } };
       })
       .filter((x): x is NonNullable<typeof x> => x != null && x.room.wagons >= 1)
       .sort((a, b) => b.room.wagons - a.room.wagons)[0];
@@ -2047,6 +2099,7 @@ export class BookingBatchService implements OnModuleInit {
     );
     if (!offered) return false;
     target.c.budget.subtract(offered, target.leg);
+    target.c.stock?.consume(wagonTypeIds, offered.wagons, target.leg);
     target.c.armed = true;
     return true;
   }
@@ -3468,6 +3521,131 @@ export class BookingBatchService implements OnModuleInit {
     return dims.length ? dims : [fallback];
   }
 
+  /**
+   * Physical wagon-type stock for one schedule, on the same corridor edges its
+   * {@link CorridorBudget} uses. Sourced from the scheduling service so the
+   * batch counts exactly the wagons the allocator will later plan against.
+   */
+  private async stockLedgerFor(
+    schedule: TrainSchedule,
+    budget: CorridorBudget,
+  ): Promise<WagonStockLedger> {
+    const stock = await this.trainSchedulingService.wagonStockForSchedule(
+      schedule.id,
+      schedule.originStationId,
+      budget.stops,
+    );
+    return new WagonStockLedger(
+      stock.remainingByTypeId,
+      Math.max(1, budget.stops.length - 1),
+    );
+  }
+
+  /**
+   * Whether the train holds enough PHYSICAL wagons of the types this booking may
+   * ride. Unresolvable configuration (no allowed wagon type) returns true: the
+   * abstract budget still governs, and a mis-configured cargo type must not
+   * silently strand every booking that uses it.
+   */
+  private hasWagonStock(
+    stock: WagonStockLedger,
+    wagonTypeIds: string[],
+    wagonsNeeded: number,
+    leg: CorridorLeg,
+  ): boolean {
+    if (!wagonTypeIds.length) return true;
+    return stock.availableFor(wagonTypeIds, leg) >= wagonsNeeded;
+  }
+
+  private allowedWagonTypeCache: {
+    byCargoTypeId: Map<string, string[]>;
+    byContainerTypeId: Map<string, string[]>;
+    expiresAt: number;
+  } | null = null;
+
+  /**
+   * Wagon-type ids each cargo / container type may ride, read straight from the
+   * join tables.
+   *
+   * The batch pool finders deliberately do NOT join `cargoType.wagonTypes` /
+   * `containerType.wagonTypes` — those many-to-many joins multiply rows badly on
+   * a hot path. So the pool's booking entities carry the type FK but not the
+   * allowed list, and resolving it per booking through the relation would come
+   * back empty. Two small lookups, cached for a minute like {@link loadWagonDims},
+   * give the same answer without touching the pool query.
+   */
+  private async loadAllowedWagonTypeIds(): Promise<{
+    byCargoTypeId: Map<string, string[]>;
+    byContainerTypeId: Map<string, string[]>;
+  }> {
+    if (this.allowedWagonTypeCache && this.allowedWagonTypeCache.expiresAt > Date.now()) {
+      return this.allowedWagonTypeCache;
+    }
+    // Inactive wagon types are excluded, matching loadAllowedWagonTypes() in the
+    // scheduling service — the allocator will not plan against them either.
+    const [cargoRows, containerRows]: [
+      Array<{ typeId: string; wagonTypeId: string }>,
+      Array<{ typeId: string; wagonTypeId: string }>,
+    ] = await Promise.all([
+      this.dataSource.query(
+        `SELECT ct.cargo_type_id AS "typeId", ct.wagon_type_id AS "wagonTypeId"
+           FROM freight.cargo_type_wagon_types ct
+           JOIN freight.wagon_types wt ON wt.id = ct.wagon_type_id
+          WHERE wt.is_active IS NOT FALSE`,
+      ),
+      this.dataSource.query(
+        `SELECT ct.container_type_id AS "typeId", ct.wagon_type_id AS "wagonTypeId"
+           FROM freight.container_type_wagon_types ct
+           JOIN freight.wagon_types wt ON wt.id = ct.wagon_type_id
+          WHERE wt.is_active IS NOT FALSE`,
+      ),
+    ]);
+
+    const collect = (rows: Array<{ typeId: string; wagonTypeId: string }>) => {
+      const map = new Map<string, string[]>();
+      for (const row of rows) {
+        const list = map.get(row.typeId) ?? [];
+        list.push(row.wagonTypeId);
+        map.set(row.typeId, list);
+      }
+      return map;
+    };
+
+    const value = {
+      byCargoTypeId: collect(cargoRows),
+      byContainerTypeId: collect(containerRows),
+    };
+    this.allowedWagonTypeCache = { ...value, expiresAt: Date.now() + 60_000 };
+    return value;
+  }
+
+  /**
+   * Every wagon-type id this booking may ride. Empty means "unresolvable" — the
+   * caller must then skip the physical-stock gate rather than block the booking
+   * on missing configuration.
+   */
+  private allowedWagonTypeIdsFor(
+    booking: Booking,
+    allowed: {
+      byCargoTypeId: Map<string, string[]>;
+      byContainerTypeId: Map<string, string[]>;
+    },
+  ): string[] {
+    if (booking.freightType === "BULK") {
+      const cargoTypeId = booking.cargoTypeId ?? booking.cargoType?.id;
+      return cargoTypeId ? (allowed.byCargoTypeId.get(cargoTypeId) ?? []) : [];
+    }
+    const ids = new Set<string>();
+    for (const line of booking.bookingContainers ?? []) {
+      const containerTypeId = line.containerTypeId ?? line.containerType?.id;
+      if (!containerTypeId) continue;
+      for (const id of allowed.byContainerTypeId.get(containerTypeId) ?? []) {
+        ids.add(id);
+      }
+    }
+    return [...ids];
+  }
+
   /**
    * Ordered stop yards of the schedule's route (origin → milestones →
    * destination); the legacy two-stop pseudo-route when milestones are absent.
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 db18d6804..b4520a43c 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
@@ -5,6 +5,7 @@ import {
   NotFoundException,
   Optional,
 } from '@nestjs/common';
+import { EventEmitter2 } from '@nestjs/event-emitter';
 import { InjectDataSource } from '@nestjs/typeorm';
 import { DataSource, EntityManager, In } from 'typeorm';
 import { Freight } from '@edr/types';
@@ -48,6 +49,7 @@ export class BookingJourneyService {
     @InjectDataSource() private readonly dataSource: DataSource,
     private readonly yardFacilities: YardFacilitiesService,
     private readonly facilityHandling: FacilityHandlingService,
+    private readonly events: EventEmitter2,
     @Optional() private readonly milestoneService?: ClearanceMilestoneService,
   ) {}
 
@@ -145,6 +147,12 @@ export class BookingJourneyService {
       });
     });
 
+    // Intercity ends here — a ONE_TIME contract closes on its shipment being
+    // delivered (import/export emit this from booking-transition.complete).
+    if (nextStatus === 'COMPLETED') {
+      this.events.emit('booking.completed', { bookingId });
+    }
+
     // Customer tracking: THIS booking arrived (train may still be rolling).
     void this.completeMilestones(booking, [
       ...(booking.tradeDirection === 'IMPORT'
@@ -303,6 +311,12 @@ export class BookingJourneyService {
         RETURNING b.id, b.trade_direction`,
       [schedule.id, schedule.destinationStationId, now],
     );
+    // Intercity rows just completed — let a ONE_TIME contract close on delivery.
+    for (const row of rows) {
+      if (row.trade_direction === 'DOMESTIC') {
+        this.events.emit('booking.completed', { bookingId: row.id });
+      }
+    }
     return rows.map((r) => r.id);
   }
 
@@ -487,7 +501,13 @@ export class BookingJourneyService {
           currentYardId: booking.destinationYardId,
           currentTrainScheduleId: null,
           trainSetWagonId: null,
-          status: Freight.WagonStatus.Available,
+          // A wagon that belongs to a built train stays coupled to it (ASSIGNED);
+          // only loose wagons return to the open AVAILABLE pool. Marking a
+          // coupled wagon AVAILABLE made it show up in the train-builder's
+          // "available wagons" picker, where attaching it always 409'd.
+          status: wagon.trainId
+            ? Freight.WagonStatus.Assigned
+            : Freight.WagonStatus.Available,
         });
       }
     }
diff --git a/apps/edr-freight-api/src/modules/train-scheduling/dto/create-container-train-schedule.dto.ts b/apps/edr-freight-api/src/modules/train-scheduling/dto/create-container-train-schedule.dto.ts
index 8ad256a16..9dfea0781 100644
--- a/apps/edr-freight-api/src/modules/train-scheduling/dto/create-container-train-schedule.dto.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/dto/create-container-train-schedule.dto.ts
@@ -34,11 +34,11 @@ export class CreateContainerTrainScheduleDto {
     type: [String],
     format: 'uuid',
     description:
-      'Hand-picked locomotives pulling the train (minimum 2 — front and back). Ignored when trainId is provided.',
+      'Hand-picked locomotives pulling the train (minimum 1). Ignored when trainId is provided.',
   })
   @IsOptional()
   @IsArray()
-  @ArrayMinSize(2, { message: 'A train must be pulled by at least two locomotives' })
+  @ArrayMinSize(1, { message: 'A train must be pulled by at least one locomotive' })
   @IsUUID('all', { each: true })
   locomotiveIds?: string[];
 
diff --git a/apps/edr-freight-api/src/modules/train-scheduling/train-capacity.util.spec.ts b/apps/edr-freight-api/src/modules/train-scheduling/train-capacity.util.spec.ts
index 8342eae47..0b8d4ad05 100644
--- a/apps/edr-freight-api/src/modules/train-scheduling/train-capacity.util.spec.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/train-capacity.util.spec.ts
@@ -5,7 +5,7 @@ import {
   consistViolations,
   deriveTrainCapacityFromLocomotive,
   grossWagonWeightTons,
-  minLocomotiveLimits,
+  combinedLocomotiveLimits,
   sizePartialOfferWagons,
   trainSetLocomotiveLimits,
 } from './train-capacity.util';
@@ -197,42 +197,75 @@ describe('train-capacity.util', () => {
     expect(bookingTrainLengthMeters('BULK', 3, { container: 14, bulk: 18 })).toBe(54);
   });
 
-  it('takes the weakest locomotive across a multi-locomotive set', () => {
-    const limits = minLocomotiveLimits([
-      { maxPullWeightTons: 3500, maxTrainLengthMeters: 760, overageToleranceTons: 90 },
-      { maxPullWeightTons: 4000, maxTrainLengthMeters: 760, overageToleranceTons: 20 },
+  it('SUMS pull weight and weight tolerance across a multi-locomotive set', () => {
+    // Two units haul together: 1750 + 1750 = 3500T base, 90 + 90 = 180T overage.
+    const limits = combinedLocomotiveLimits([
+      { maxPullWeightTons: 1750, maxTrainLengthMeters: 760, overageToleranceTons: 90 },
+      { maxPullWeightTons: 1750, maxTrainLengthMeters: 760, overageToleranceTons: 90 },
     ]);
     expect(limits?.maxPullWeightTons).toBe(3500);
-    expect(limits?.overageToleranceTons).toBe(20);
+    expect(limits?.overageToleranceTons).toBe(180);
+    // A single locomotive is just its own limit — no doubling, no halving.
+    expect(
+      combinedLocomotiveLimits([
+        { maxPullWeightTons: 1750, maxTrainLengthMeters: 760, overageToleranceTons: 90 },
+      ])?.maxPullWeightTons,
+    ).toBe(1750);
+  });
+
+  it('takes the MINIMUM train length — a second locomotive does not lengthen the siding', () => {
+    const limits = combinedLocomotiveLimits([
+      { maxPullWeightTons: 1750, maxTrainLengthMeters: 760, overageToleranceMeters: 20 },
+      { maxPullWeightTons: 1750, maxTrainLengthMeters: 700, overageToleranceMeters: 5 },
+    ]);
+    expect(limits?.maxTrainLengthMeters).toBe(700);
+    expect(limits?.overageToleranceMeters).toBe(5);
   });
 
   it('ignores unconfigured (null) tolerances instead of zeroing the set (S-2026-00024)', () => {
     // LOCO-019 had 90T tolerance, LOCO-020 had none configured: the set must
-    // keep the 90, not collapse to 0 and reject 3547.6T on a 3500T train.
-    const limits = minLocomotiveLimits([
-      { maxPullWeightTons: 3500, maxTrainLengthMeters: 760, overageToleranceTons: 90 },
-      { maxPullWeightTons: 3500, maxTrainLengthMeters: 760, overageToleranceTons: null },
+    // keep the 90 rather than collapse to 0 — an unset value abstains.
+    const limits = combinedLocomotiveLimits([
+      { maxPullWeightTons: 1750, maxTrainLengthMeters: 760, overageToleranceTons: 90 },
+      { maxPullWeightTons: 1750, maxTrainLengthMeters: 760, overageToleranceTons: null },
     ]);
     expect(limits?.overageToleranceTons).toBe(90);
     // All unconfigured → no tolerance.
-    const none = minLocomotiveLimits([
+    const none = combinedLocomotiveLimits([
       { maxPullWeightTons: 3500, maxTrainLengthMeters: 760 },
     ]);
     expect(none?.overageToleranceTons).toBe(0);
   });
 
+  it('reports no pull limit when NO locomotive has one configured', () => {
+    // Summing must not turn "unset" into 0 and strand every booking; an
+    // all-unset set keeps the old "no opinion" behaviour.
+    const limits = combinedLocomotiveLimits([
+      { maxPullWeightTons: 0, maxTrainLengthMeters: 760 },
+      { maxPullWeightTons: 0, maxTrainLengthMeters: 760 },
+    ]);
+    expect(limits?.maxPullWeightTons).toBe(Infinity);
+    // One configured, one not → only the configured one contributes.
+    expect(
+      combinedLocomotiveLimits([
+        { maxPullWeightTons: 1750, maxTrainLengthMeters: 760 },
+        { maxPullWeightTons: 0, maxTrainLengthMeters: 760 },
+      ])?.maxPullWeightTons,
+    ).toBe(1750);
+  });
+
   it('trainSetLocomotiveLimits prefers link rows and falls back to the legacy single loco', () => {
-    const l1 = { maxPullWeightTons: 3500, maxTrainLengthMeters: 760, overageToleranceTons: 90 };
-    const l2 = { maxPullWeightTons: 3600, maxTrainLengthMeters: 700, overageToleranceTons: null };
+    const l1 = { maxPullWeightTons: 1750, maxTrainLengthMeters: 760, overageToleranceTons: 90 };
+    const l2 = { maxPullWeightTons: 1800, maxTrainLengthMeters: 700, overageToleranceTons: null };
     expect(
       trainSetLocomotiveLimits({ locomotive: null, locomotives: [{ locomotive: l1 }, { locomotive: l2 }] }),
     ).toEqual({
-      maxPullWeightTons: 3500,
+      maxPullWeightTons: 3550,
       maxTrainLengthMeters: 700,
       overageToleranceTons: 90,
       overageToleranceMeters: 0,
     });
-    expect(trainSetLocomotiveLimits({ locomotive: l1 })?.maxPullWeightTons).toBe(3500);
+    expect(trainSetLocomotiveLimits({ locomotive: l1 })?.maxPullWeightTons).toBe(1750);
     expect(trainSetLocomotiveLimits(null)).toBeNull();
     expect(trainSetLocomotiveLimits({ locomotive: null, locomotives: [] })).toBeNull();
   });
diff --git a/apps/edr-freight-api/src/modules/train-scheduling/train-capacity.util.ts b/apps/edr-freight-api/src/modules/train-scheduling/train-capacity.util.ts
index b4b3a64de..7f9586c3c 100644
--- a/apps/edr-freight-api/src/modules/train-scheduling/train-capacity.util.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/train-capacity.util.ts
@@ -256,27 +256,40 @@ function round3(value: number): number {
 }
 
 /**
- * Effective pull limits for a train set with multiple locomotives: the weakest
- * locomotive caps the train, so take the minimum pull weight and minimum length
- * across all assigned locomotives. Returns null when no locomotives are given.
+ * Effective limits for a train set, per axis:
+ *
+ * - **Pull weight ADDS UP.** Locomotives haul together, so two 1750T units pull
+ *   3500T. Only CONFIGURED pull weights are summed; a set with none configured
+ *   reports Infinity (no opinion), exactly as before.
+ * - **Weight tolerance ADDS UP**, following its axis — each locomotive brings its
+ *   own overage allowance, so 2 × 90T gives the set 180T. Unset abstains (0).
+ * - **Length takes the MINIMUM.** Train length is a siding/loop constraint, not
+ *   a haulage one: coupling a second locomotive does not lengthen the track, so
+ *   the most restrictive locomotive still governs (and its tolerance with it).
+ *
+ * Returns null when no locomotives are given.
  */
-export function minLocomotiveLimits(
+export function combinedLocomotiveLimits(
   locomotives: Array<
     Pick<LocomotiveLimits, 'maxPullWeightTons' | 'maxTrainLengthMeters'> &
       Partial<Pick<LocomotiveLimits, 'overageToleranceTons' | 'overageToleranceMeters'>>
   >,
 ): LocomotiveLimits | null {
   if (!locomotives.length) return null;
+  const configuredPulls = locomotives
+    .map((l) => num(l.maxPullWeightTons))
+    .filter((v) => v > 0);
+
   return {
-    maxPullWeightTons: Math.min(
-      ...locomotives.map((l) => num(l.maxPullWeightTons, Infinity) || Infinity),
-    ),
+    maxPullWeightTons: configuredPulls.length
+      ? round3(configuredPulls.reduce((sum, v) => sum + v, 0))
+      : Infinity,
     maxTrainLengthMeters: Math.min(
       ...locomotives.map((l) => num(l.maxTrainLengthMeters, Infinity) || Infinity),
     ),
-    // Weakest CONFIGURED tolerance governs the set — a locomotive with no
-    // tolerance set has no opinion, it does not zero out the others.
-    overageToleranceTons: minConfigured(locomotives.map((l) => l.overageToleranceTons)),
+    overageToleranceTons: sumConfigured(locomotives.map((l) => l.overageToleranceTons)),
+    // Paired with the length axis, so it stays the weakest CONFIGURED value — a
+    // locomotive with no tolerance set has no opinion, it does not zero the others.
     overageToleranceMeters: minConfigured(locomotives.map((l) => l.overageToleranceMeters)),
   };
 }
@@ -286,10 +299,16 @@ function minConfigured(values: Array<number | null | undefined>): number {
   return configured.length ? Math.min(...configured) : 0;
 }
 
+function sumConfigured(values: Array<number | null | undefined>): number {
+  const configured = values.filter((v) => v != null).map((v) => num(v));
+  return configured.length ? round3(configured.reduce((sum, v) => sum + v, 0)) : 0;
+}
+
 /**
- * Effective limits for a whole train set: min across its linked locomotives,
- * falling back to the legacy single `locomotive` column for sets created
- * before multi-loco support. Null when the set has no locomotive at all.
+ * Effective limits for a whole train set: {@link combinedLocomotiveLimits} over
+ * its linked locomotives, falling back to the legacy single `locomotive` column
+ * for sets created before multi-loco support. Null when the set has no
+ * locomotive at all.
  */
 export function trainSetLocomotiveLimits(
   trainSet?: {
@@ -306,7 +325,7 @@ export function trainSetLocomotiveLimits(
     : trainSet.locomotive
       ? [trainSet.locomotive]
       : [];
-  return minLocomotiveLimits(pool);
+  return combinedLocomotiveLimits(pool);
 }
 
 /** Per-booking train length from wagon count and freight-specific wagon type length. */
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 15a542d31..418338257 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
@@ -133,7 +133,7 @@ import { pickLowestFreeNumber, pickTrainNumberPool } from './train-number.util';
 import {
   bookingCargoTons,
   deriveTrainCapacityFromLocomotive,
-  minLocomotiveLimits,
+  combinedLocomotiveLimits,
   trainSetLocomotiveLimits,
   wagonTypeDimensionsFromEntity,
   LocomotiveLimits,
@@ -1300,9 +1300,9 @@ export class TrainSchedulingService {
         .slice()
         .sort((a, b) => a.sequenceNo - b.sequenceNo)
         .map((link) => link.locomotiveId);
-      if (locomotiveIds.length < 2) {
+      if (locomotiveIds.length < 1) {
         throw new BadRequestException(
-          `Train ${builtTrain.code} has fewer than two locomotives; rebuild it before scheduling`,
+          `Train ${builtTrain.code} has no locomotive; rebuild it before scheduling`,
         );
       }
       if (builtTrain.currentYardId !== route.originYardId) {
@@ -1323,8 +1323,8 @@ export class TrainSchedulingService {
       }
     } else {
       locomotiveIds = [...new Set(dto.locomotiveIds ?? [])];
-      if (locomotiveIds.length < 2) {
-        throw new BadRequestException('A train must be pulled by at least two locomotives');
+      if (locomotiveIds.length < 1) {
+        throw new BadRequestException('A train must be pulled by at least one locomotive');
       }
     }
 
@@ -1382,7 +1382,7 @@ export class TrainSchedulingService {
         builtTrain?.id ?? null,
       );
       // Effective capacity is capped by the weakest locomotive in the set.
-      const limitLoco = minLocomotiveLimits(lockedLocomotives) ?? undefined;
+      const limitLoco = combinedLocomotiveLimits(lockedLocomotives) ?? undefined;
       const departure = new Date(dto.scheduleDate);
       // Every schedule starts with a CLOSED customer window; the window engine opens
       // it on schedule. DOMESTIC runs the same one-booking-day cycle as IMPORT
@@ -1572,7 +1572,7 @@ export class TrainSchedulingService {
     };
 
     const setLocomotives = this.locomotivesOfTrainSet(schedule.trainSet);
-    const limitLoco = minLocomotiveLimits(setLocomotives) ?? undefined;
+    const limitLoco = combinedLocomotiveLimits(setLocomotives) ?? undefined;
     const limits = await this.resolveTrainLimitConfig(previewDto, limitLoco);
 
     // Callers that add bookings without hand-picking container slots (the
@@ -3971,36 +3971,12 @@ export class TrainSchedulingService {
     const builtTrainId = await this.builtTrainIdOfSchedule(targetScheduleId);
 
     const originYardId = dto.originStationId;
-    let stock: WagonStock;
-    if (builtTrainId) {
-      stock = await this.builtTrainStock(builtTrainId);
-    } else {
-      // Dynamic consist: a slot's physical wagon may ride from the train's origin
-      // OR already sit at the booking's own boarding yard and attach there — so
-      // the usable fleet is the union across the origin and every boarding yard.
-      const boardYardIds = [
-        ...new Set(
-          [originYardId, ...bookings.map((b) => b.originYardId)].filter(Boolean),
-        ),
-      ];
-      const fleetCountsByYard = await Promise.all(
-        boardYardIds.map((yardId) =>
-          this.countFleetAvailability(yardId, targetScheduleId),
-        ),
-      );
-      const remainingByTypeId = new Map<string, number>();
-      const codesByTypeId = new Map<string, string>();
-      for (const rows of fleetCountsByYard) {
-        for (const row of rows) {
-          remainingByTypeId.set(
-            row.wagonTypeId,
-            (remainingByTypeId.get(row.wagonTypeId) ?? 0) + row.available,
-          );
-          codesByTypeId.set(row.wagonTypeId, row.wagonTypeCode);
-        }
-      }
-      stock = { mode: 'YARD', remainingByTypeId, codesByTypeId };
-    }
+    const stock: WagonStock = await this.wagonStockForSchedule(
+      targetScheduleId,
+      originYardId,
+      bookings.map((b) => b.originYardId),
+      builtTrainId,
+    );
 
     // 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.
@@ -4129,7 +4105,7 @@ export class TrainSchedulingService {
       // warning (it must arrive before dispatch), but a set too weak to pull the train
       // is a hard violation.
       const offYard = assignedLocomotives.find((l) => l.currentYardId !== originYardId);
-      const setLimits = minLocomotiveLimits(assignedLocomotives);
+      const setLimits = combinedLocomotiveLimits(assignedLocomotives);
       if (offYard) {
         warnings.push(
           `Locomotive ${offYard.code} is not at the schedule origin yard yet; it must arrive before dispatch`,
@@ -4799,6 +4775,51 @@ export class TrainSchedulingService {
    * type. This is the whole plannable pool for its schedules — the plan is
    * full when every consist wagon is allocated.
    */
+  /**
+   * The physical wagons a schedule can actually plan against, by wagon type.
+   *
+   * A schedule built from a Train Builder train plans against ONLY that train's
+   * own consist. A legacy/dynamic-consist schedule plans against the boarding
+   * yards' loose pool: a slot's wagon may ride from the train's origin OR
+   * already sit at the booking's own boarding yard and attach there, so the
+   * usable fleet is the union across the origin and every boarding yard.
+   *
+   * Public because batch fill needs the SAME stock the allocator will later
+   * validate against — selecting a booking the allocator cannot place is how
+   * customers ended up paying for wagons that were never there.
+   */
+  async wagonStockForSchedule(
+    scheduleId: string | undefined,
+    originYardId: string,
+    boardingYardIds: Array<string | null | undefined> = [],
+    preloadedBuiltTrainId?: string | null,
+  ): Promise<WagonStock> {
+    const builtTrainId =
+      preloadedBuiltTrainId !== undefined
+        ? preloadedBuiltTrainId
+        : await this.builtTrainIdOfSchedule(scheduleId);
+    if (builtTrainId) return this.builtTrainStock(builtTrainId);
+
+    const boardYardIds = [
+      ...new Set([originYardId, ...boardingYardIds].filter((id): id is string => Boolean(id))),
+    ];
+    const fleetCountsByYard = await Promise.all(
+      boardYardIds.map((yardId) => this.countFleetAvailability(yardId, scheduleId)),
+    );
+    const remainingByTypeId = new Map<string, number>();
+    const codesByTypeId = new Map<string, string>();
+    for (const rows of fleetCountsByYard) {
+      for (const row of rows) {
+        remainingByTypeId.set(
+          row.wagonTypeId,
+          (remainingByTypeId.get(row.wagonTypeId) ?? 0) + row.available,
+        );
+        codesByTypeId.set(row.wagonTypeId, row.wagonTypeCode);
+      }
+    }
+    return { mode: 'YARD', remainingByTypeId, codesByTypeId };
+  }
+
   private async builtTrainStock(builtTrainId: string): Promise<WagonStock> {
     const wagons = await this.dataSource.getRepository(Wagon).find({
       where: { trainId: builtTrainId },
@@ -5347,7 +5368,7 @@ export class TrainSchedulingService {
    * schedule-creation picker. Mirrors the locomotive picker's advance-scheduling
    * philosophy: nothing serviceable is filtered out — staff see the status,
    * whether the train sits at the origin yard yet, and its future schedules.
-   * Trains with fewer than two locomotives are omitted (never schedulable).
+   * Trains with no locomotive at all are omitted (never schedulable).
    */
   async getAvailableTrainsForRoute(routeId: string) {
     const route = await this.getSchedulableRoute(routeId);
@@ -5385,7 +5406,7 @@ export class TrainSchedulingService {
     const futureCounts = new Map(counts.map((c) => [c.train_id, Number(c.future_count)]));
 
     return trains
-      .filter((train) => (train.locomotives ?? []).length >= 2)
+      .filter((train) => (train.locomotives ?? []).length >= 1)
       .map((train) => {
         const wagons = train.wagons ?? [];
         return {
@@ -5417,7 +5438,15 @@ export class TrainSchedulingService {
           totalLengthMeters: roundTons(
             wagons.reduce((sum, w) => sum + (Number(w.wagonType?.lengthMeters) || 0), 0),
           ),
-          maxPullWeightTons: roundTons(Number(train.capacityTons)),
+          // Live from the coupled set — `capacity_tons` still holds the old
+          // single-locomotive figure on trains built before pull weight summed.
+          maxPullWeightTons: roundTons(
+            combinedLocomotiveLimits(
+              (train.locomotives ?? [])
+                .map((link) => link.locomotive)
+                .filter((loco): loco is Locomotive => Boolean(loco)),
+            )?.maxPullWeightTons ?? Number(train.capacityTons),
+          ),
           atOriginYard: train.currentYardId === route.originYardId,
           futureScheduleCount: futureCounts.get(train.id) ?? 0,
         };
@@ -5467,7 +5496,7 @@ export class TrainSchedulingService {
     );
     const pinnedToLiveIds = await this.wagonIdsPinnedToLiveSchedules();
 
-    const limits = minLocomotiveLimits(this.locomotivesOfTrainSet(schedule.trainSet));
+    const limits = combinedLocomotiveLimits(this.locomotivesOfTrainSet(schedule.trainSet));
     const maxPullWeightTons = roundTons(Number(limits?.maxPullWeightTons ?? 0));
     const overageToleranceTons = roundTons(Number(limits?.overageToleranceTons) || 0);
     const maxTrainLengthMeters = roundTons(Number(limits?.maxTrainLengthMeters ?? 0));
@@ -5590,7 +5619,7 @@ export class TrainSchedulingService {
         .filter((slot) => slot.physicalWagonId && (slot.allocations?.length ?? 0) > 0)
         .map((slot) => slot.physicalWagonId as string),
     );
-    const limits = minLocomotiveLimits(this.locomotivesOfTrainSet(schedule.trainSet));
+    const limits = combinedLocomotiveLimits(this.locomotivesOfTrainSet(schedule.trainSet));
     const pullCapTons = roundTons(
       Number(limits?.maxPullWeightTons ?? 0) + (Number(limits?.overageToleranceTons) || 0),
     );
diff --git a/apps/edr-freight-api/src/modules/train-scheduling/wagon-stock-ledger.util.spec.ts b/apps/edr-freight-api/src/modules/train-scheduling/wagon-stock-ledger.util.spec.ts
new file mode 100644
index 000000000..47823cddd
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/train-scheduling/wagon-stock-ledger.util.spec.ts
@@ -0,0 +1,70 @@
+import { WagonStockLedger } from './wagon-stock-ledger.util';
+
+const WHOLE = { fromEdge: 0, toEdge: 1 };
+
+describe('WagonStockLedger', () => {
+  it('reports the wagons of a booking\'s OWN types, not the train total', () => {
+    // The reported case: 20 free wagons on the train, but only 16 of them NW5.
+    const ledger = new WagonStockLedger(
+      new Map([
+        ['nw5', 16],
+        ['pw2', 4],
+      ]),
+      1,
+    );
+    expect(ledger.availableFor(['nw5'], WHOLE)).toBe(16);
+    expect(ledger.availableFor(['pw2'], WHOLE)).toBe(4);
+    // A cargo type mapped to both may ride either, so they add up.
+    expect(ledger.availableFor(['nw5', 'pw2'], WHOLE)).toBe(20);
+    // Duplicates must not double-count.
+    expect(ledger.availableFor(['nw5', 'nw5'], WHOLE)).toBe(16);
+    // An unconfigured type has no stock.
+    expect(ledger.availableFor(['unknown'], WHOLE)).toBe(0);
+  });
+
+  it('consumes what it can and reports the shortfall', () => {
+    const ledger = new WagonStockLedger(new Map([['nw5', 16]]), 1);
+    // A 20-wagon booking can only take 16 — the caller splits on that number.
+    expect(ledger.consume(['nw5'], 20, WHOLE)).toBe(16);
+    expect(ledger.availableFor(['nw5'], WHOLE)).toBe(0);
+    expect(ledger.consume(['nw5'], 1, WHOLE)).toBe(0);
+  });
+
+  it('drains the deepest stock first across candidate types', () => {
+    const ledger = new WagonStockLedger(
+      new Map([
+        ['nw5', 10],
+        ['nw7', 3],
+      ]),
+      1,
+    );
+    expect(ledger.consume(['nw5', 'nw7'], 12, WHOLE)).toBe(12);
+    // 10 from NW5 then 2 from NW7 — one NW7 left.
+    expect(ledger.availableFor(['nw7'], WHOLE)).toBe(1);
+    expect(ledger.availableFor(['nw5'], WHOLE)).toBe(0);
+  });
+
+  it('frees stock past an alight yard — disjoint legs never compete', () => {
+    // Three stops (A→B→C) = two edges. An intercity booking riding A→B must
+    // not consume the wagon on B→C.
+    const ledger = new WagonStockLedger(new Map([['nw5', 5]]), 2);
+    const firstLeg = { fromEdge: 0, toEdge: 1 };
+    const secondLeg = { fromEdge: 1, toEdge: 2 };
+
+    ledger.consume(['nw5'], 5, firstLeg);
+    expect(ledger.availableFor(['nw5'], firstLeg)).toBe(0);
+    expect(ledger.availableFor(['nw5'], secondLeg)).toBe(5);
+
+    // A whole-route booking sees the busiest edge it crosses, so it is blocked.
+    expect(ledger.availableFor(['nw5'], { fromEdge: 0, toEdge: 2 })).toBe(0);
+  });
+
+  it('counts the busiest edge within a leg, not the sum of edges', () => {
+    const ledger = new WagonStockLedger(new Map([['nw5', 10]]), 3);
+    ledger.consume(['nw5'], 4, { fromEdge: 0, toEdge: 1 });
+    ledger.consume(['nw5'], 6, { fromEdge: 1, toEdge: 2 });
+    // Edge 0 uses 4, edge 1 uses 6 — a booking over both needs 10 free at once.
+    expect(ledger.availableFor(['nw5'], { fromEdge: 0, toEdge: 2 })).toBe(4);
+    expect(ledger.availableFor(['nw5'], { fromEdge: 2, toEdge: 3 })).toBe(10);
+  });
+});
diff --git a/apps/edr-freight-api/src/modules/train-scheduling/wagon-stock-ledger.util.ts b/apps/edr-freight-api/src/modules/train-scheduling/wagon-stock-ledger.util.ts
new file mode 100644
index 000000000..0e4f6949d
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/train-scheduling/wagon-stock-ledger.util.ts
@@ -0,0 +1,86 @@
+import type { CorridorLeg } from './corridor-capacity.util';
+
+/**
+ * Physical wagon-type stock for one train, consumed per corridor edge.
+ *
+ * The {@link CorridorBudget} tracks ABSTRACT capacity — slots, pull weight,
+ * length. It cannot tell a NW5 from a PW2, so a train showing "20 free wagons"
+ * would admit a 20-wagon booking whose cargo only rides NW5 even when the yard
+ * holds 16 NW5 and 4 PW2. The batch selected all 20, the customer paid for 20,
+ * and allocation then failed on wagon 17 with "No NW5 wagon available at the
+ * yard" — money taken for space that never existed.
+ *
+ * This ledger is the missing axis: how many wagons of the types a booking may
+ * actually ride are free. Batch fill consults it alongside the budget, so a
+ * booking is admitted whole only when both agree, and is otherwise offered a
+ * split sized to the wagons that genuinely exist.
+ *
+ * Stock is consumed PER EDGE, mirroring `planWagonsWithStock`: a wagon freed at
+ * an alight yard is available again downstream, so an intercity ride-along on
+ * Gelan→Adama never competes for stock with an export on Adama→Doraleh.
+ */
+export class WagonStockLedger {
+  private readonly usedPerEdge = new Map<string, number[]>();
+
+  constructor(
+    private readonly remainingByTypeId: Map<string, number>,
+    private readonly edgeCount: number,
+  ) {}
+
+  /** Free wagons of ONE type on a leg: total minus its busiest edge within that leg. */
+  private availableForType(wagonTypeId: string, leg: CorridorLeg): number {
+    const total = this.remainingByTypeId.get(wagonTypeId) ?? 0;
+    const row = this.usedPerEdge.get(wagonTypeId);
+    if (!row) return total;
+    let busiest = 0;
+    for (let edge = leg.fromEdge; edge < leg.toEdge; edge += 1) {
+      busiest = Math.max(busiest, row[edge] ?? 0);
+    }
+    return Math.max(0, total - busiest);
+  }
+
+  /**
+   * Free wagons across every type a booking may ride. A cargo/container type
+   * mapped to several wagon types can use any of them, so they add up.
+   */
+  availableFor(wagonTypeIds: readonly string[], leg: CorridorLeg): number {
+    let total = 0;
+    for (const id of new Set(wagonTypeIds)) {
+      total += this.availableForType(id, leg);
+    }
+    return total;
+  }
+
+  /**
+   * Take `wagons` from the candidate types, deepest stock first so the consist
+   * drains evenly (same tie-break as the wagon planner). Returns how many were
+   * actually taken — less than asked when the stock is short.
+   */
+  consume(wagonTypeIds: readonly string[], wagons: number, leg: CorridorLeg): number {
+    let outstanding = Math.max(0, Math.floor(wagons));
+    const candidates = [...new Set(wagonTypeIds)];
+    let taken = 0;
+
+    while (outstanding > 0) {
+      const deepest = candidates
+        .map((id) => ({ id, free: this.availableForType(id, leg) }))
+        .filter((c) => c.free > 0)
+        .sort((a, b) => b.free - a.free)[0];
+      if (!deepest) break;
+
+      const take = Math.min(outstanding, deepest.free);
+      let row = this.usedPerEdge.get(deepest.id);
+      if (!row) {
+        row = new Array<number>(this.edgeCount).fill(0);
+        this.usedPerEdge.set(deepest.id, row);
+      }
+      for (let edge = leg.fromEdge; edge < leg.toEdge; edge += 1) {
+        row[edge] = (row[edge] ?? 0) + take;
+      }
+      outstanding -= take;
+      taken += take;
+    }
+
+    return taken;
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/train-sets/entities/train-set-locomotive.entity.ts b/apps/edr-freight-api/src/modules/train-sets/entities/train-set-locomotive.entity.ts
index 4ad52a226..5c26d2475 100644
--- a/apps/edr-freight-api/src/modules/train-sets/entities/train-set-locomotive.entity.ts
+++ b/apps/edr-freight-api/src/modules/train-sets/entities/train-set-locomotive.entity.ts
@@ -6,7 +6,7 @@ import { TrainSet } from './train-set.entity';
 
 /**
  * Link row joining a train set to one of its locomotives. A train set must be
- * pulled by at least two locomotives (front + back); `sequenceNo` is a plain
+ * pulled by at least one locomotive; `sequenceNo` is a plain
  * order index — no front/rear semantics are modelled yet.
  */
 @Entity({ schema: 'freight', name: 'train_set_locomotives' })
diff --git a/apps/edr-freight-api/src/modules/train-sets/entities/train-set.entity.ts b/apps/edr-freight-api/src/modules/train-sets/entities/train-set.entity.ts
index c82cfd2eb..5f98ea608 100644
--- a/apps/edr-freight-api/src/modules/train-sets/entities/train-set.entity.ts
+++ b/apps/edr-freight-api/src/modules/train-sets/entities/train-set.entity.ts
@@ -29,7 +29,7 @@ export class TrainSet extends BaseEntity {
   @JoinColumn({ name: 'locomotive_id' })
   locomotive?: Locomotive;
 
-  /** All locomotives pulling this train set (minimum 2). */
+  /** All locomotives pulling this train set (minimum 1). */
   @OneToMany(() => TrainSetLocomotive, (link) => link.trainSet)
   locomotives?: TrainSetLocomotive[];
 
diff --git a/apps/edr-freight-api/src/modules/trains/dto/build-train.dto.ts b/apps/edr-freight-api/src/modules/trains/dto/build-train.dto.ts
index 5ba77fb10..54322c789 100644
--- a/apps/edr-freight-api/src/modules/trains/dto/build-train.dto.ts
+++ b/apps/edr-freight-api/src/modules/trains/dto/build-train.dto.ts
@@ -33,10 +33,10 @@ export class BuildTrainDto {
   @ApiProperty({
     type: [String],
     format: 'uuid',
-    description: 'Locomotives pulling the train (minimum 2 — front and back), in consist order',
+    description: 'Locomotives pulling the train (minimum 1), in consist order',
   })
   @IsArray()
-  @ArrayMinSize(2, { message: 'A train must be pulled by at least two locomotives' })
+  @ArrayMinSize(1, { message: 'A train must be pulled by at least one locomotive' })
   @IsUUID('all', { each: true })
   locomotiveIds!: string[];
 
diff --git a/apps/edr-freight-api/src/modules/trains/dto/update-train-locomotives.dto.ts b/apps/edr-freight-api/src/modules/trains/dto/update-train-locomotives.dto.ts
index 36562e970..0fab5ec5b 100644
--- a/apps/edr-freight-api/src/modules/trains/dto/update-train-locomotives.dto.ts
+++ b/apps/edr-freight-api/src/modules/trains/dto/update-train-locomotives.dto.ts
@@ -5,10 +5,10 @@ export class UpdateTrainLocomotivesDto {
   @ApiProperty({
     type: [String],
     format: 'uuid',
-    description: 'Full replacement locomotive set (minimum 2), in consist order',
+    description: 'Full replacement locomotive set (minimum 1), in consist order',
   })
   @IsArray()
-  @ArrayMinSize(2, { message: 'A train must be pulled by at least two locomotives' })
+  @ArrayMinSize(1, { message: 'A train must be pulled by at least one locomotive' })
   @IsUUID('all', { each: true })
   locomotiveIds!: string[];
 }
diff --git a/apps/edr-freight-api/src/modules/trains/entities/train-locomotive.entity.ts b/apps/edr-freight-api/src/modules/trains/entities/train-locomotive.entity.ts
index 681b39a55..0c834379e 100644
--- a/apps/edr-freight-api/src/modules/trains/entities/train-locomotive.entity.ts
+++ b/apps/edr-freight-api/src/modules/trains/entities/train-locomotive.entity.ts
@@ -6,7 +6,7 @@ import { Train } from './train.entity';
 
 /**
  * Link row joining a built train to one of its locomotives. A train must be
- * pulled by at least two locomotives (front + back); `sequenceNo` is the order
+ * pulled by at least one locomotive; `sequenceNo` is the order
  * in the consist — 0 is the lead locomotive.
  *
  * Mirrors `train_set_locomotives`, but for the persistent fleet `Train` built
diff --git a/apps/edr-freight-api/src/modules/trains/entities/train.entity.ts b/apps/edr-freight-api/src/modules/trains/entities/train.entity.ts
index 493e564e8..7a1ea5b64 100644
--- a/apps/edr-freight-api/src/modules/trains/entities/train.entity.ts
+++ b/apps/edr-freight-api/src/modules/trains/entities/train.entity.ts
@@ -80,7 +80,7 @@ export class Train extends BaseEntity {
   @OneToMany(() => Wagon, (wagon) => wagon.train)
   wagons!: Wagon[];
 
-  /** Locomotives pulling this train (minimum 2), ordered by sequenceNo. */
+  /** Locomotives pulling this train (minimum 1), ordered by sequenceNo. */
   @OneToMany(() => TrainLocomotive, (link) => link.train)
   locomotives?: TrainLocomotive[];
 }
\ No newline at end of file
diff --git a/apps/edr-freight-api/src/modules/trains/train-builder.controller.ts b/apps/edr-freight-api/src/modules/trains/train-builder.controller.ts
index 19d631fbc..2b74c0253 100644
--- a/apps/edr-freight-api/src/modules/trains/train-builder.controller.ts
+++ b/apps/edr-freight-api/src/modules/trains/train-builder.controller.ts
@@ -62,7 +62,7 @@ export class TrainBuilderController {
 
   @Put(':id/locomotives')
   @FleetManage(FREIGHT_PERMS.trains.update)
-  @ApiOperation({ summary: 'Replace the locomotive set (minimum 2, same yard)' })
+  @ApiOperation({ summary: 'Replace the locomotive set (minimum 1, same yard)' })
   setLocomotives(
     @Param('id', ParseUUIDPipe) id: string,
     @Body() dto: UpdateTrainLocomotivesDto,
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 31f108740..6aed88f07 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
@@ -3,6 +3,7 @@ import {
   BadRequestException,
   ConflictException,
   Injectable,
+  Logger,
   NotFoundException,
 } from '@nestjs/common';
 import { DataSource, EntityManager, ILike, In } from 'typeorm';
@@ -10,7 +11,7 @@ import { QueryDeepPartialEntity } from 'typeorm/query-builder/QueryPartialEntity
 
 import { Locomotive } from '../locomotives/entities/locomotive.entity';
 import { Yard } from '../rule-engine/entities/yard.entity';
-import { minLocomotiveLimits } from '../train-scheduling/train-capacity.util';
+import { combinedLocomotiveLimits } from '../train-scheduling/train-capacity.util';
 import { WagonType } from '../wagon-types/entities/wagon-type.entity';
 import { WagonMovement } from '../wagons/entities/wagon-movement.entity';
 import { Wagon } from '../wagons/entities/wagon.entity';
@@ -55,12 +56,14 @@ export interface ActiveScheduleRef {
  */
 @Injectable()
 export class TrainBuilderService {
+  private readonly logger = new Logger(TrainBuilderService.name);
+
   constructor(private readonly dataSource: DataSource) {}
 
   async buildTrain(dto: BuildTrainDto) {
     const locomotiveIds = [...new Set(dto.locomotiveIds)];
-    if (locomotiveIds.length < 2) {
-      throw new BadRequestException('A train must be pulled by at least two locomotives');
+    if (locomotiveIds.length < 1) {
+      throw new BadRequestException('A train must be pulled by at least one locomotive');
     }
 
     const trainId = await this.dataSource.transaction(async (manager) => {
@@ -96,7 +99,7 @@ export class TrainBuilderService {
       );
 
       // Effective haul capacity is capped by the weakest locomotive in the set.
-      const limits = minLocomotiveLimits(locomotives);
+      const limits = combinedLocomotiveLimits(locomotives);
       const train = await manager.getRepository(Train).save(
         manager.getRepository(Train).create({
           code,
@@ -283,7 +286,7 @@ export class TrainBuilderService {
         : null,
     }));
 
-    const limits = minLocomotiveLimits(
+    const limits = combinedLocomotiveLimits(
       (train.locomotives ?? [])
         .map((link) => link.locomotive)
         .filter((loco): loco is Locomotive => Boolean(loco)),
@@ -339,11 +342,11 @@ export class TrainBuilderService {
     };
   }
 
-  /** Replace the locomotive set (still minimum 2, same-yard rule applies). */
+  /** Replace the locomotive set (minimum 1, same-yard rule applies). */
   async setLocomotives(id: string, dto: UpdateTrainLocomotivesDto) {
     const locomotiveIds = [...new Set(dto.locomotiveIds)];
-    if (locomotiveIds.length < 2) {
-      throw new BadRequestException('A train must be pulled by at least two locomotives');
+    if (locomotiveIds.length < 1) {
+      throw new BadRequestException('A train must be pulled by at least one locomotive');
     }
     await this.dataSource.transaction(async (manager) => {
       const train = await this.getEditableTrain(manager, id);
@@ -360,7 +363,7 @@ export class TrainBuilderService {
         train.id,
       );
       await this.replaceLocomotiveLinks(manager, train.id, locomotiveIds);
-      const limits = minLocomotiveLimits(locomotives);
+      const limits = combinedLocomotiveLimits(locomotives);
       await manager
         .getRepository(Train)
         .update(train.id, { capacityTons: round(limits?.maxPullWeightTons ?? 0) });
@@ -520,6 +523,28 @@ export class TrainBuilderService {
         sequenceNumber: null,
         status: WagonStatus.Maintenance,
       });
+      // Audit row: which train it came off and when. The wagon does not change
+      // yard here, so from/to are the same — the ledger is the wagon's history
+      // surface, and a maintenance detach has to be in it.
+      const yardId = wagon.currentYardId ?? train.currentYardId ?? null;
+      if (yardId) {
+        await manager.getRepository(WagonMovement).save(
+          manager.getRepository(WagonMovement).create({
+            wagonId: wagon.id,
+            fromYardId: yardId,
+            toYardId: yardId,
+            kind: WagonMovementKind.Maintenance,
+            note: `Sent to maintenance from train ${train.trainNumber ?? train.code}`,
+            occurredAt: new Date(),
+          }),
+        );
+      } else {
+        // to_yard_id is NOT NULL — a yard-less wagon still goes to maintenance,
+        // it just cannot carry a ledger row.
+        this.logger.warn(
+          `Wagon ${wagon.wagonNumber} sent to maintenance with no yard — ledger row skipped`,
+        );
+      }
       await this.resequenceWagons(manager, train.id);
     });
     return this.getComposition(id);
@@ -743,7 +768,16 @@ export class TrainBuilderService {
       totalLengthMeters: round(
         wagons.reduce((sum, w) => sum + (Number(w.wagonType?.lengthMeters) || 0), 0),
       ),
-      maxPullWeightTons: round(train.capacityTons),
+      // Derived live from the coupled set, NOT from the stored capacity_tons.
+      // That column is written at build/re-couple time, so every train built
+      // before pull weight became additive still holds the old single-locomotive
+      // figure. Computing it here keeps the board honest without a backfill;
+      // the column self-heals the next time the locomotive set is saved.
+      maxPullWeightTons: round(
+        combinedLocomotiveLimits(locomotives)?.maxPullWeightTons ??
+          Number(train.capacityTons) ??
+          0,
+      ),
     };
   }
 
@@ -878,7 +912,7 @@ export class TrainBuilderService {
       where: { trainId: train.id },
       relations: { locomotive: true },
     });
-    const limits = minLocomotiveLimits(
+    const limits = combinedLocomotiveLimits(
       links
         .map((link) => link.locomotive)
         .filter((loco): loco is Locomotive => Boolean(loco)),
diff --git a/apps/edr-freight-api/src/modules/wagons/dto/list-wagons-query.dto.ts b/apps/edr-freight-api/src/modules/wagons/dto/list-wagons-query.dto.ts
index c7eecfc02..328a6eaa8 100644
--- a/apps/edr-freight-api/src/modules/wagons/dto/list-wagons-query.dto.ts
+++ b/apps/edr-freight-api/src/modules/wagons/dto/list-wagons-query.dto.ts
@@ -1,7 +1,17 @@
 import { WagonStatus } from '@edr/types';
 import { ApiPropertyOptional } from '@nestjs/swagger';
-import { Type } from 'class-transformer';
-import { IsEnum, IsInt, IsOptional, IsString, IsUUID, Max, Min } from 'class-validator';
+import { Transform, Type } from 'class-transformer';
+import {
+  IsBoolean,
+  IsDateString,
+  IsEnum,
+  IsInt,
+  IsOptional,
+  IsString,
+  IsUUID,
+  Max,
+  Min,
+} from 'class-validator';
 
 export class ListWagonsQueryDto {
   @ApiPropertyOptional({ description: 'Search wagon number (partial match)' })
@@ -29,6 +39,15 @@ export class ListWagonsQueryDto {
   @IsUUID()
   trainId?: string;
 
+  @ApiPropertyOptional({
+    description:
+      'Only loose wagons (not coupled to a built train) — what a picker can actually take.',
+  })
+  @IsOptional()
+  @Transform(({ value }: { value: unknown }) => value === true || value === 'true')
+  @IsBoolean()
+  unassigned?: boolean;
+
   @ApiPropertyOptional({
     description: 'Filter by run number — matches export OR import run (e.g. 8001).',
   })
@@ -53,11 +72,21 @@ export class ListWagonsQueryDto {
   @Min(1)
   page?: number;
 
-  @ApiPropertyOptional({ minimum: 1, maximum: 500 })
+  @ApiPropertyOptional({ default: 10, minimum: 1, maximum: 100 })
   @IsOptional()
   @Type(() => Number)
   @IsInt()
   @Min(1)
-  @Max(500)
-  limit?: number;
+  @Max(100)
+  pageSize?: number;
+
+  @ApiPropertyOptional({ description: 'Registered on or after this day (YYYY-MM-DD)' })
+  @IsOptional()
+  @IsDateString()
+  createdFrom?: string;
+
+  @ApiPropertyOptional({ description: 'Registered on or before this day (YYYY-MM-DD)' })
+  @IsOptional()
+  @IsDateString()
+  createdTo?: string;
 }
diff --git a/apps/edr-freight-api/src/modules/wagons/wagon-transfer-requests.service.spec.ts b/apps/edr-freight-api/src/modules/wagons/wagon-transfer-requests.service.spec.ts
index ecf512aac..205d86450 100644
--- a/apps/edr-freight-api/src/modules/wagons/wagon-transfer-requests.service.spec.ts
+++ b/apps/edr-freight-api/src/modules/wagons/wagon-transfer-requests.service.spec.ts
@@ -232,4 +232,29 @@ describe('WagonTransferRequestsService — partial fulfilment', () => {
       ).rejects.toBeInstanceOf(BadRequestException);
     });
   });
+
+  describe('listRequests', () => {
+    // TypeORM paginates a joined query through a DISTINCT subquery and resolves
+    // every orderBy criterion against entity metadata — a DB column name there
+    // (`r.created_at`) makes it read `.databaseName` of undefined → 500.
+    it('sorts by the entity property path, not the DB column', async () => {
+      const qb = {
+        leftJoinAndSelect: jest.fn().mockReturnThis(),
+        andWhere: jest.fn().mockReturnThis(),
+        orderBy: jest.fn().mockReturnThis(),
+        skip: jest.fn().mockReturnThis(),
+        take: jest.fn().mockReturnThis(),
+        getManyAndCount: jest.fn().mockResolvedValue([[], 0]),
+      };
+      requestRepo.createQueryBuilder.mockReturnValue(qb);
+
+      await service.listRequests({
+        status: 'PENDING,PARTIALLY_FULFILLED',
+        page: 1,
+        pageSize: 10,
+      });
+
+      expect(qb.orderBy).toHaveBeenCalledWith('r.createdAt', 'DESC');
+    });
+  });
 });
diff --git a/apps/edr-freight-api/src/modules/wagons/wagon-transfer-requests.service.ts b/apps/edr-freight-api/src/modules/wagons/wagon-transfer-requests.service.ts
index 79a74f4ce..8d4159726 100644
--- a/apps/edr-freight-api/src/modules/wagons/wagon-transfer-requests.service.ts
+++ b/apps/edr-freight-api/src/modules/wagons/wagon-transfer-requests.service.ts
@@ -114,6 +114,8 @@ export class WagonTransferRequestsService {
         currentYardId: yardId,
         wagonTypeId,
         status: WagonStatus.Available,
+        // Coupled to a built train = not movable; bulkTransfer rejects it too.
+        trainId: IsNull(),
       },
     });
   }
@@ -159,7 +161,7 @@ export class WagonTransferRequestsService {
         ? 'r.quantity'
         : query.sortBy === 'status'
           ? 'r.status'
-          : 'r.created_at';
+          : 'r.createdAt';
     qb.orderBy(sortColumn, query.sortOrder ?? 'DESC');
 
     return paginateQuery(qb, { page: query.page, pageSize: query.pageSize });
@@ -399,6 +401,7 @@ export class WagonTransferRequestsService {
           currentYardId: request.fromYardId,
           wagonTypeId: request.wagonTypeId,
           status: WagonStatus.Available,
+          trainId: IsNull(),
         },
         order: { wagonNumber: 'ASC' },
         take: remaining,
diff --git a/apps/edr-freight-api/src/modules/wagons/wagons.controller.ts b/apps/edr-freight-api/src/modules/wagons/wagons.controller.ts
index bac10299d..c792057d8 100644
--- a/apps/edr-freight-api/src/modules/wagons/wagons.controller.ts
+++ b/apps/edr-freight-api/src/modules/wagons/wagons.controller.ts
@@ -39,7 +39,9 @@ export class WagonsController {
 
   @Get()
   @StaffReference()
-  @ApiOperation({ summary: 'List all wagons' })
+  @ApiOperation({
+    summary: 'List wagons, paginated ({items, meta}) — 10 per page by default',
+  })
   findAll(@Query() query: ListWagonsQueryDto) {
     return this.wagonsService.findAll(query);
   }
diff --git a/apps/edr-freight-api/src/modules/wagons/wagons.service.ts b/apps/edr-freight-api/src/modules/wagons/wagons.service.ts
index 99c28469f..f51846e2d 100644
--- a/apps/edr-freight-api/src/modules/wagons/wagons.service.ts
+++ b/apps/edr-freight-api/src/modules/wagons/wagons.service.ts
@@ -1,4 +1,4 @@
-import { Freight, WagonMovementKind, WagonStatus } from '@edr/types';
+import { Freight, PaginatedResponse, WagonMovementKind, WagonStatus } from '@edr/types';
 import {
   BadRequestException,
   Injectable,
@@ -6,7 +6,8 @@ import {
   ConflictException,
 } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
-import { Repository, DataSource, In } from 'typeorm';
+import { Repository, DataSource, In, SelectQueryBuilder } from 'typeorm';
+import { paginateQuery } from '../../common/utils/pagination.util';
 import { CreateWagonDto } from './dto/create-wagon.dto';
 import { ListWagonsQueryDto } from './dto/list-wagons-query.dto';
 import { UpdateWagonDto } from './dto/update-wagon.dto';
@@ -42,7 +43,8 @@ export class WagonsService {
     return this.wagonRepo.save(wagon);
   }
 
-  async findAll(query: ListWagonsQueryDto = {}): Promise<Wagon[]> {
+  /** Shared filter/sort builder behind `findAll` (array) and `findAllPaged` (envelope). */
+  private buildListQuery(query: ListWagonsQueryDto): SelectQueryBuilder<Wagon> {
     const search = query.search?.trim();
     const trainId = query.trainId?.trim();
     const wagonTypeId = query.wagonTypeId?.trim();
@@ -61,6 +63,9 @@ export class WagonsService {
     if (query.currentYardId)
       qb.andWhere('w.currentYardId = :currentYardId', { currentYardId: query.currentYardId });
     if (trainId) qb.andWhere('w.trainId = :trainId', { trainId });
+    // Pickers (train-builder, transfer fulfilment) can only take a wagon that is
+    // not already coupled to a built train — never offer one the API will reject.
+    if (query.unassigned) qb.andWhere('w.trainId IS NULL');
     if (wagonTypeId) qb.andWhere('w.wagonTypeId = :wagonTypeId', { wagonTypeId });
 
     // Filter by run: the odd export run identifies the pair, so match either
@@ -72,6 +77,18 @@ export class WagonsService {
       );
     }
 
+    // Registration-day range, both ends inclusive (the UI picks whole days).
+    if (query.createdFrom) {
+      qb.andWhere('w.createdAt >= CAST(:createdFrom AS date)', {
+        createdFrom: query.createdFrom,
+      });
+    }
+    if (query.createdTo) {
+      qb.andWhere("w.createdAt < CAST(:createdTo AS date) + INTERVAL '1 day'", {
+        createdTo: query.createdTo,
+      });
+    }
+
     // Search matches the wagon number or either run number.
     if (search) {
       qb.andWhere(
@@ -95,12 +112,16 @@ export class WagonsService {
     const sortOrder = query.sortOrder?.toUpperCase() === 'DESC' ? 'DESC' : 'ASC';
     qb.orderBy(`w.${sortBy}`, sortOrder);
 
-    if (query.page && query.limit) {
-      qb.skip((Number(query.page) - 1) * Number(query.limit));
-    }
-    if (query.limit) qb.take(Number(query.limit));
+    return qb;
+  }
 
-    return qb.getMany();
+  /**
+   * The wagon list is always a page. Callers that genuinely need every row
+   * (yard workspace, coupling pickers) walk the pages client-side — see
+   * `wagonService.listAll` in the backoffice.
+   */
+  findAll(query: ListWagonsQueryDto = {}): Promise<PaginatedResponse<Wagon>> {
+    return paginateQuery(this.buildListQuery(query), query, { defaultPageSize: 10 });
   }
 
   async findById(id: string): Promise<Wagon> {
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 2924169eb..eaf2f1c02 100644
--- a/apps/edr-freight-api/src/seed/freight-permissions.registry.ts
+++ b/apps/edr-freight-api/src/seed/freight-permissions.registry.ts
@@ -103,6 +103,9 @@ export const CONTRACT_PERMISSIONS: FreightPermissionSeed[] = [
   // Each has its own permission so the two desks are genuinely separate people.
   perm('a3000001-0001-4000-8000-000000000019', 'edr_freight_app:contracts:hazardous_approval_one', 'Hazardous approval — first review'),
   perm('a3000001-0001-4000-8000-00000000001a', 'edr_freight_app:contracts:hazardous_approval_two', 'Hazardous approval — second review'),
+  // Freeze/unfreeze a signed contract. One key covers both directions — whoever
+  // may suspend must be able to lift it again.
+  perm('a3000001-0001-4000-8000-00000000001b', 'edr_freight_app:contracts:suspend', 'Suspend / resume a signed contract'),
 ];
 
 // Existing per-slug view ids are kept as-is: position-type grants reference
@@ -447,6 +450,7 @@ export const FREIGHT_PERMS = {
     clearanceEtActions: 'edr_freight_app:contracts:clearance_et_actions',
     clearanceDjActions: 'edr_freight_app:contracts:clearance_dj_actions',
     clearanceDutyAdvise: 'edr_freight_app:contracts:clearance_duty_advise',
+    suspend: 'edr_freight_app:contracts:suspend',
   },
   trainScheduling: {
     view: 'edr_freight_app:train_scheduling:view',
@@ -897,6 +901,7 @@ export const ROLE_PERMISSION_PRESETS = {
     FREIGHT_PERMS.contracts.approveLineStaff,
     FREIGHT_PERMS.contracts.generateContract,
     ...bothFreightTypes(FREIGHT_PERMS.contracts.signStaff),
+    FREIGHT_PERMS.contracts.suspend,
   ],
   orgManager: [...BOOKING_RULE_ENGINE_PERMISSION_KEYS],
 } as const;
diff --git a/apps/edr-freight-web/backoffice/src/App.tsx b/apps/edr-freight-web/backoffice/src/App.tsx
index 5e2e48f32..77e67f210 100644
--- a/apps/edr-freight-web/backoffice/src/App.tsx
+++ b/apps/edr-freight-web/backoffice/src/App.tsx
@@ -168,8 +168,8 @@ const buildSidebarSections = (demoItems: SidebarItem[]): SidebarSection[] => [
         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).
+      // Operations hub: per-shipment clearance-document review for services
+      // WITHOUT customs clearing (self-clearance) — bookings only.
       {
         label: "Clearance Documents",
         href: "/dashboard/contracts/clearance-documents",
diff --git a/apps/edr-freight-web/backoffice/src/auth/http.ts b/apps/edr-freight-web/backoffice/src/auth/http.ts
index 82ae8e808..c59144706 100644
--- a/apps/edr-freight-web/backoffice/src/auth/http.ts
+++ b/apps/edr-freight-web/backoffice/src/auth/http.ts
@@ -76,6 +76,10 @@ api.interceptors.request.use((config) => {
     config.headers.Authorization = `Bearer ${token}`;
   }
 
+  // Tells the backend which app is asking, so /auth/login can reject
+  // cross-audience credentials (EDRFREIGHT-415).
+  config.headers["X-Client-App"] = "backoffice";
+
   return config;
 });
 
diff --git a/apps/edr-freight-web/backoffice/src/components/contracts/ContractActionsToolbar.tsx b/apps/edr-freight-web/backoffice/src/components/contracts/ContractActionsToolbar.tsx
index fcd04fb58..d2a245f24 100644
--- a/apps/edr-freight-web/backoffice/src/components/contracts/ContractActionsToolbar.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/contracts/ContractActionsToolbar.tsx
@@ -1,13 +1,15 @@
 import { useMemo, useState } from "react";
 import { useNavigate } from "react-router-dom";
 import { useQuery } from "@tanstack/react-query";
-import { Button, Modal, Stack, Text, Textarea } from "@mantine/core";
+import { Button, Group, Modal, Stack, Text, Textarea } from "@mantine/core";
 import {
   Check,
   Eye,
-  FilePen,
+  // FilePen, // ponytail: back with the "Edit contract articles" button
   FileSignature,
   MessageSquareWarning,
+  PauseCircle,
+  PlayCircle,
   ShieldCheck,
   XCircle,
   Zap,
@@ -43,6 +45,21 @@ const CLEARANCE_REVIEW_STATUSES = [
   "CLEARANCE_READY_FOR_BOOKING",
 ];
 
+/**
+ * Every step from the customer signature onward can be frozen. Mirrors
+ * SUSPENDABLE_CONTRACT_STATUSES on the API — the server is the authority, this
+ * list only decides whether the button is drawn.
+ */
+const SUSPENDABLE_STATUSES = [
+  "SIGNED_CUSTOMER",
+  "FULLY_EXECUTED",
+  "CONTRACT_ACTIVE",
+  "AWAITING_CLEARANCE_DOCUMENTS",
+  "CLEARANCE_UNDER_REVIEW",
+  "CLEARANCE_READY_FOR_BOOKING",
+  "ACTIVE_SHIPMENT_IN_PROGRESS",
+];
+
 /** Detail-page staff actions: accept / request changes / reject / generate / sign. */
 export function ContractActionsToolbar({
   contract,
@@ -62,6 +79,8 @@ export function ContractActionsToolbar({
     FREIGHT_PERMS.contracts.requestChanges[arm],
   );
   const mayReject = hasPermission(user, FREIGHT_PERMS.contracts.reject[arm]);
+  // One key both ways — whoever can freeze a contract can unfreeze it.
+  const maySuspend = hasPermission(user, FREIGHT_PERMS.contracts.suspend);
 
   const [editorOpen, setEditorOpen] = useState(false);
   const [editorMode, setEditorMode] = useState<"accept" | "edit">("accept");
@@ -70,6 +89,10 @@ export function ContractActionsToolbar({
   const [changesNote, setChangesNote] = useState("");
   const [rejectOpen, setRejectOpen] = useState(false);
   const [rejectReason, setRejectReason] = useState("");
+  const [suspendOpen, setSuspendOpen] = useState(false);
+  const [suspendReason, setSuspendReason] = useState("");
+  const [resumeOpen, setResumeOpen] = useState(false);
+  const [resumeNote, setResumeNote] = useState("");
 
   // Whether the document is editable depends on WHO is viewing — only the
   // approver whose turn it is may edit — so the server decides, not the client.
@@ -110,6 +133,86 @@ export function ContractActionsToolbar({
     );
   }
 
+  // Frozen: nothing on this contract moves — no new bookings, no progress on
+  // the shipments already under it — until the suspension is lifted, which
+  // returns the contract to the status it was suspended at.
+  if (status === "SUSPENDED") {
+    return (
+      <SectionCard icon={PauseCircle} title="Contract suspended">
+        <Stack gap="sm">
+          <Text size="sm" c="dimmed">
+            This contract is frozen. New bookings are blocked and its existing
+            shipments cannot progress.
+            {contract.statusBeforeSuspension
+              ? ` Lifting the suspension returns it to ${contract.statusBeforeSuspension}.`
+              : ""}
+          </Text>
+          {contract.latestSuspensionNote && (
+            <Text size="sm">
+              <b>Reason:</b> {contract.latestSuspensionNote}
+            </Text>
+          )}
+          {maySuspend ? (
+            <Button
+              fullWidth
+              color="edr-green"
+              leftSection={<PlayCircle size={16} />}
+              onClick={() => setResumeOpen(true)}
+            >
+              Lift suspension
+            </Button>
+          ) : (
+            <Text size="sm" c="dimmed">
+              You do not have permission to lift a suspension.
+            </Text>
+          )}
+        </Stack>
+
+        <Modal
+          opened={resumeOpen}
+          onClose={() => setResumeOpen(false)}
+          title="Lift suspension?"
+          centered
+        >
+          <Stack gap="md">
+            <Text size="sm">
+              Contract <b>{contract.reference}</b> will return to{" "}
+              <b>{contract.statusBeforeSuspension ?? "CONTRACT_ACTIVE"}</b> and
+              the customer will be notified. Bookings on it resume immediately.
+            </Text>
+            <Textarea
+              label="Note (optional)"
+              placeholder="Why the suspension is being lifted…"
+              autosize
+              minRows={2}
+              value={resumeNote}
+              onChange={(e) => setResumeNote(e.currentTarget.value)}
+            />
+            <Group justify="flex-end" gap="sm">
+              <Button variant="default" onClick={() => setResumeOpen(false)}>
+                Cancel
+              </Button>
+              <Button
+                color="edr-green"
+                loading={mutations.resume.isPending}
+                onClick={() =>
+                  mutations.resume.mutate(resumeNote.trim() || undefined, {
+                    onSuccess: () => {
+                      setResumeOpen(false);
+                      setResumeNote("");
+                    },
+                  })
+                }
+              >
+                Lift suspension
+              </Button>
+            </Group>
+          </Stack>
+        </Modal>
+      </SectionCard>
+    );
+  }
+
   const canAccept =
     status === "SUBMITTED" && (mayAccept || mayRequestChanges || mayReject);
   // The document stays editable for the whole approval chain, but only by the
@@ -130,6 +233,7 @@ export function ContractActionsToolbar({
   const clearanceReviewer = contract.customsClearingEnabled
     ? "Review clearance (GL)"
     : "Review clearance (Ops)";
+  const canSuspend = maySuspend && SUSPENDABLE_STATUSES.includes(status);
 
   return (
     <SectionCard icon={Zap} title="Staff actions">
@@ -182,9 +286,9 @@ export function ContractActionsToolbar({
           <>
             <Text size="xs" c="dimmed">
               {canEditDocument
-                ? "It is your turn to approve. You can edit the articles before approving — the PDF is generated automatically once the last approver approves."
+                ? "It is your turn to approve — the PDF is generated automatically once the last approver approves."
                 : draft?.nextApproverRole
-                  ? `Awaiting ${draft.nextApproverRole}. Only the current approver can edit the document.`
+                  ? `Awaiting ${draft.nextApproverRole}.`
                   : "Awaiting approval."}
             </Text>
             <Button
@@ -196,6 +300,9 @@ export function ContractActionsToolbar({
             >
               Preview document
             </Button>
+            {/* Article editing is hidden for now (frontend only) — the approval
+                chain approves the document as accepted. Uncomment to restore.
+
             {canEditDocument && (
               <Button
                 fullWidth
@@ -210,6 +317,8 @@ export function ContractActionsToolbar({
                 Edit contract articles
               </Button>
             )}
+
+            */}
           </>
         )}
 
@@ -241,10 +350,23 @@ export function ContractActionsToolbar({
         {/* GL "Create booking" removed for now — clearance ends at finalize and
             the customer creates the booking in the portal. */}
 
+        {canSuspend && (
+          <Button
+            fullWidth
+            variant="light"
+            color="orange"
+            leftSection={<PauseCircle size={16} />}
+            onClick={() => setSuspendOpen(true)}
+          >
+            Suspend contract
+          </Button>
+        )}
+
         {!canAccept &&
           !inApproval &&
           !canViewContract &&
-          !canReviewClearance && (
+          !canReviewClearance &&
+          !canSuspend && (
             <Text size="sm" c="dimmed">
               No staff actions available for this status. Monitor until the
               workflow advances.
@@ -315,6 +437,51 @@ export function ContractActionsToolbar({
         </Stack>
       </Modal>
 
+      {/* Suspend — freezes the contract AND every shipment under it */}
+      <Modal
+        opened={suspendOpen}
+        onClose={() => setSuspendOpen(false)}
+        title="Suspend this contract?"
+        centered
+      >
+        <Stack gap="md">
+          <Text size="sm">
+            Contract <b>{contract.reference}</b> will be frozen at its current
+            step (<b>{status}</b>). No new shipments can be booked and the
+            shipments already under it stop moving until the suspension is
+            lifted. The customer is notified.
+          </Text>
+          <Textarea
+            label="Reason for suspension"
+            placeholder="Explain why this contract is being suspended…"
+            autosize
+            minRows={3}
+            value={suspendReason}
+            onChange={(e) => setSuspendReason(e.currentTarget.value)}
+          />
+          <Group justify="flex-end" gap="sm">
+            <Button variant="default" onClick={() => setSuspendOpen(false)}>
+              Cancel
+            </Button>
+            <Button
+              color="orange"
+              disabled={!suspendReason.trim()}
+              loading={mutations.suspend.isPending}
+              onClick={() =>
+                mutations.suspend.mutate(suspendReason, {
+                  onSuccess: () => {
+                    setSuspendOpen(false);
+                    setSuspendReason("");
+                  },
+                })
+              }
+            >
+              Suspend contract
+            </Button>
+          </Group>
+        </Stack>
+      </Modal>
+
       {/* Reject */}
       <Modal
         opened={rejectOpen}
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 3747c2d2d..27a74cbf1 100644
--- a/apps/edr-freight-web/backoffice/src/components/contracts/ContractApprovalStepsCard.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/contracts/ContractApprovalStepsCard.tsx
@@ -31,6 +31,17 @@ const isHazardStep = (requiredRole: string): boolean =>
 const roleLabel = (requiredRole: string): string =>
   CONTRACT_APPROVAL_ROLE_LABELS[requiredRole] ?? requiredRole;
 
+/** When the approver acted — "27 Jul 2026, 18:18". */
+const fmtActedAt = (iso: string): string =>
+  new Date(iso).toLocaleString("en-GB", {
+    day: "numeric",
+    month: "short",
+    year: "numeric",
+    hour: "2-digit",
+    minute: "2-digit",
+    hour12: false,
+  });
+
 type Mutations = ReturnType<typeof useContractMutations>;
 
 interface ContractApprovalStepsCardProps {
@@ -349,6 +360,10 @@ function StepRow({
           ? "edr-green"
           : "gray";
   const hazard = isHazardStep(step.requiredRole);
+  // A send-back wipes acted_at with the status, so a re-opened step shows no
+  // stale timestamp.
+  const acted =
+    step.actedAt && step.status !== "PENDING" ? fmtActedAt(step.actedAt) : null;
 
   return (
     <Group
@@ -412,6 +427,14 @@ function StepRow({
               </Badge>
             )}
           </Group>
+          {/* Decided steps carry their verdict time — the chain doubles as an
+              audit trail, so "who was waiting on whom, and for how long" has to
+              be readable without opening the revision history. */}
+          {acted && (
+            <Text size="xs" c="dimmed" truncate>
+              {step.status === "REJECTED" ? "Rejected" : "Approved"} {acted}
+            </Text>
+          )}
           {step.note && (
             <Text size="xs" c="dimmed" truncate>
               {step.note}
diff --git a/apps/edr-freight-web/backoffice/src/components/contracts/ContractDocumentEditorModal.tsx b/apps/edr-freight-web/backoffice/src/components/contracts/ContractDocumentEditorModal.tsx
index de18fa847..59300b458 100644
--- a/apps/edr-freight-web/backoffice/src/components/contracts/ContractDocumentEditorModal.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/contracts/ContractDocumentEditorModal.tsx
@@ -9,23 +9,24 @@ import {
   Group,
   Loader,
   Modal,
+  ScrollArea,
   // Select, // ponytail: unused now the validity dropdown below is commented out
   Stack,
   Text,
   Textarea,
   TextInput,
-  Tooltip,
+  // Tooltip, // ponytail: back with the article editor block
 } from "@mantine/core";
 import {
-  ArrowDown,
-  ArrowUp,
+  // ArrowDown, // ponytail: back with the article editor block
+  // ArrowUp,
   FileText,
   Info,
   Lock,
   Plus,
   Trash2,
 } from "lucide-react";
-import { DateInput } from "@mantine/dates";
+import { DateTimePicker } from "@mantine/dates";
 import type { Freight } from "@edr/types";
 
 import { contractsService } from "@/services/contracts.service";
@@ -37,6 +38,30 @@ function newArticleId(): string {
   return `art-${Date.now()}-${Math.floor(Math.random() * 1e6)}`;
 }
 
+/** Midnight today — the earliest day a contract's validity may start. */
+function startOfToday(): Date {
+  const d = new Date();
+  d.setHours(0, 0, 0, 0);
+  return d;
+}
+
+/** Local `YYYY-MM-DD` — the shape Mantine hands day cells. */
+function localDay(date: Date): string {
+  const pad = (n: number) => String(n).padStart(2, "0");
+  return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`;
+}
+
+/**
+ * Print today in bold inside the calendar. `highlightToday` only rings the cell,
+ * which staff read as "disabled" on a picker whose minimum IS today — the weight
+ * makes it obvious the day is pickable.
+ */
+function boldToday(date: string) {
+  return date === localDay(new Date())
+    ? { style: { fontWeight: 800 } }
+    : {};
+}
+
 interface EditableArticle {
   id: string;
   title: string;
@@ -118,6 +143,17 @@ export function ContractDocumentEditorModal({
     );
   }, [opened, draft]);
 
+  // Accept mode opens on NOW — a contract never starts in the past, and the
+  // pickers below refuse earlier days. Seconds are dropped so the value matches
+  // what the HH:mm picker shows.
+  useEffect(() => {
+    if (!opened || mode !== "accept") return;
+    const now = new Date();
+    now.setSeconds(0, 0);
+    setValidityStart(now);
+    setValidityEnd(null);
+  }, [opened, mode]);
+
   // Default validity to the first configured option (accept mode).
   // useEffect(() => {
   //   if (mode === "accept" && !validityDays && validityOptions.length > 0) {
@@ -129,29 +165,30 @@ export function ContractDocumentEditorModal({
   // decides per-caller — the client cannot derive this from the contract alone.
   const locked = mode === "edit" && !draft?.editableByMe;
 
-  const moveArticle = (index: number, delta: number) => {
-    setArticles((prev) => {
-      const next = [...prev];
-      const target = index + delta;
-      if (target < 0 || target >= next.length) return prev;
-      [next[index], next[target]] = [next[target], next[index]];
-      return next;
-    });
-  };
+  // Article edit handlers — parked with the editor block below.
+  // const moveArticle = (index: number, delta: number) => {
+  //   setArticles((prev) => {
+  //     const next = [...prev];
+  //     const target = index + delta;
+  //     if (target < 0 || target >= next.length) return prev;
+  //     [next[index], next[target]] = [next[target], next[index]];
+  //     return next;
+  //   });
+  // };
 
-  const updateArticle = (id: string, patch: Partial<EditableArticle>) =>
-    setArticles((prev) =>
-      prev.map((a) => (a.id === id ? { ...a, ...patch } : a)),
-    );
+  // const updateArticle = (id: string, patch: Partial<EditableArticle>) =>
+  //   setArticles((prev) =>
+  //     prev.map((a) => (a.id === id ? { ...a, ...patch } : a)),
+  //   );
 
-  const removeArticle = (id: string) =>
-    setArticles((prev) => prev.filter((a) => a.id !== id));
+  // const removeArticle = (id: string) =>
+  //   setArticles((prev) => prev.filter((a) => a.id !== id));
 
-  const addArticle = () =>
-    setArticles((prev) => [
-      ...prev,
-      { id: newArticleId(), title: "", body: "" },
-    ]);
+  // const addArticle = () =>
+  //   setArticles((prev) => [
+  //     ...prev,
+  //     { id: newArticleId(), title: "", body: "" },
+  //   ]);
 
   const buildSnapshot = (): Freight.IContractDocumentSnapshot => ({
     code: draft?.code ?? null,
@@ -238,17 +275,63 @@ export function ContractDocumentEditorModal({
               ? draft?.nextApproverRole
                 ? `Only the current approver (${draft.nextApproverRole}) can edit this document right now.`
                 : "This document can no longer be edited — the contract has advanced beyond approval."
-              : "Edits apply to THIS contract only. The six shared templates are never changed."}
+              : "This document is read-only — it is accepted exactly as the template produced it. Set the validity dates, then accept."}
           </Alert>
 
-          <TextInput
-            label="Document title"
-            placeholder="e.g. Bulk Cargo Transportation and Customs Clearance Services"
-            value={documentTitle}
-            onChange={(e) => setDocumentTitle(e.currentTarget.value)}
-            disabled={locked}
-          />
+          {/* Accept is a REVIEW step: the document is shown exactly as the
+              template produced it, with nothing editable. Any wording change
+              belongs to the template or to the separate edit action. */}
+          {mode === "accept" ? (
+            <ScrollArea.Autosize mah={340} type="auto">
+              <Stack gap="sm" pr="sm">
+                <Text fw={700} fz={15}>
+                  {documentTitle || "Contract document"}
+                </Text>
 
+                {whereasClauses.length > 0 && (
+                  <Stack gap={4}>
+                    {whereasClauses.map((clause, i) => (
+                      <Text key={i} fz={13} c="dimmed">
+                        WHEREAS {clause}
+                      </Text>
+                    ))}
+                  </Stack>
+                )}
+
+                {articles.length === 0 ? (
+                  <Text fz={13} c="dimmed">
+                    This template carries no articles.
+                  </Text>
+                ) : (
+                  articles.map((article, index) => (
+                    <Box key={article.id}>
+                      <Text fz={13} fw={700}>
+                        Article {index + 1}
+                        {article.title ? ` — ${article.title}` : ""}
+                      </Text>
+                      <Text
+                        fz={12.5}
+                        c="dimmed"
+                        style={{ whiteSpace: "pre-wrap" }}
+                      >
+                        {article.body}
+                      </Text>
+                    </Box>
+                  ))
+                )}
+              </Stack>
+            </ScrollArea.Autosize>
+          ) : (
+            <TextInput
+              label="Document title"
+              placeholder="e.g. Bulk Cargo Transportation and Customs Clearance Services"
+              value={documentTitle}
+              onChange={(e) => setDocumentTitle(e.currentTarget.value)}
+              disabled={locked}
+            />
+          )}
+
+          {mode !== "accept" && (
           <Box>
             <Group justify="space-between" mb={6}>
               <Text size="sm" fw={600}>
@@ -304,6 +387,12 @@ export function ContractDocumentEditorModal({
               </Stack>
             )}
           </Box>
+          )}
+
+          {/* Article editing is hidden for now (frontend only) — staff accept the
+              contract on the template's articles as-is. The articles themselves
+              still ride along in buildSnapshot(), so the generated document is
+              unchanged. Uncomment this block to bring the editor back.
 
           <Divider label="Articles" labelPosition="left" />
 
@@ -364,7 +453,7 @@ export function ContractDocumentEditorModal({
                     }
                   />
                   <Textarea
-                    placeholder="Article body — each line becomes a numbered clause. Use '- ' for bullets. Placeholders like {{client.companyName}} are supported."
+                    placeholder="Article body — each line becomes a numbered clause."
                     autosize
                     minRows={3}
                     styles={{ input: { fontFamily: "var(--mantine-font-family-monospace)" } }}
@@ -389,6 +478,8 @@ export function ContractDocumentEditorModal({
             </Button>
           </Stack>
 
+          */}
+
           <Divider />
 
           {mode === "accept" && (
@@ -414,20 +505,29 @@ export function ContractDocumentEditorModal({
                 </Text>
               )} */}
               <Group grow align="flex-start">
-                <DateInput
-                  label="Start date"
+                <DateTimePicker
+                  label="Start date & time"
                   placeholder="Contract validity start"
                   value={validityStart}
                   onChange={(v) => setValidityStart(v ? new Date(v) : null)}
+                  // Today is the earliest start — and it is ringed in the
+                  // calendar so it reads as selectable rather than blocked.
+                  minDate={startOfToday()}
                   maxDate={validityEnd ?? undefined}
+                  highlightToday
+                  getDayProps={boldToday}
+                  valueFormat="DD MMM YYYY HH:mm"
                   clearable
                 />
-                <DateInput
-                  label="End date"
+                <DateTimePicker
+                  label="End date & time"
                   placeholder="Contract validity end"
                   value={validityEnd}
                   onChange={(v) => setValidityEnd(v ? new Date(v) : null)}
-                  minDate={validityStart ?? undefined}
+                  minDate={validityStart ?? startOfToday()}
+                  highlightToday
+                  getDayProps={boldToday}
+                  valueFormat="DD MMM YYYY HH:mm"
                   clearable
                 />
               </Group>
diff --git a/apps/edr-freight-web/backoffice/src/components/contracts/ContractMilestonesTimeline.tsx b/apps/edr-freight-web/backoffice/src/components/contracts/ContractMilestonesTimeline.tsx
new file mode 100644
index 000000000..435baaf68
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/components/contracts/ContractMilestonesTimeline.tsx
@@ -0,0 +1,220 @@
+import { useMemo } from "react";
+import {
+  BadgeCheck,
+  CalendarClock,
+  Flame,
+  Send,
+  ShieldCheck,
+  FileSignature,
+} from "lucide-react";
+import { Group, Stack, Text, Timeline, Tooltip } from "@mantine/core";
+import type { Freight } from "@edr/types";
+
+import {
+  CONTRACT_APPROVAL_ROLE_LABELS,
+  HAZARDOUS_APPROVAL_ROLE_PERMISSION,
+} from "@/lib/permissions";
+
+interface ContractMilestonesTimelineProps {
+  contract: Freight.IContract;
+}
+
+const SIGNATURE_ROLE_LABELS: Record<Freight.ContractSignatureRole, string> = {
+  CUSTOMER: "Signed by customer",
+  STAFF: "Signed by EDR — line staff",
+  DIRECTOR: "Signed by EDR — director",
+  CEO: "Signed by EDR — CEO",
+};
+
+/** "27 Jul 2026, 18:18" — the exact stamp, shown in the tooltip. */
+function formatWhen(iso: string): string {
+  return new Date(iso).toLocaleString(undefined, {
+    dateStyle: "medium",
+    timeStyle: "short",
+  });
+}
+
+/** "3 hours ago" — the at-a-glance read. */
+function formatAgo(iso: string): string {
+  const seconds = Math.round((Date.now() - new Date(iso).getTime()) / 1000);
+  if (seconds < 60) return "just now";
+  const units: Array<[Intl.RelativeTimeFormatUnit, number]> = [
+    ["year", 31536000],
+    ["month", 2592000],
+    ["day", 86400],
+    ["hour", 3600],
+    ["minute", 60],
+  ];
+  const rtf = new Intl.RelativeTimeFormat(undefined, { numeric: "auto" });
+  for (const [unit, secondsPerUnit] of units) {
+    if (seconds >= secondsPerUnit) {
+      return rtf.format(-Math.floor(seconds / secondsPerUnit), unit);
+    }
+  }
+  return "just now";
+}
+
+function formatDate(iso: string): string {
+  return new Date(iso).toLocaleDateString(undefined, { dateStyle: "medium" });
+}
+
+type MilestoneIcon = typeof Send;
+
+interface Milestone {
+  key: string;
+  at: string;
+  title: string;
+  detail?: string;
+  color: string;
+  icon: MilestoneIcon;
+}
+
+/**
+ * The dated moments of a contract's life — submission, hazardous approval,
+ * final approval, both parties' signatures, full execution — read straight off
+ * the contract and its already-loaded approvalSteps/signatures (no extra
+ * fetch). Sits above the document edit history on the History tab.
+ */
+export function ContractMilestonesTimeline({
+  contract,
+}: ContractMilestonesTimelineProps) {
+  const milestones = useMemo<Milestone[]>(() => {
+    const items: Milestone[] = [];
+
+    // A DRAFT/RENEWAL_DRAFT contract hasn't been (re)submitted yet — nothing
+    // to date. submittedAt is only tracked going forward; a contract that
+    // reached SUBMITTED before that column existed falls back to createdAt.
+    const submittedAt =
+      contract.submittedAt ??
+      (contract.status !== "DRAFT" && contract.status !== "RENEWAL_DRAFT"
+        ? contract.createdAt
+        : null);
+    if (submittedAt) {
+      items.push({
+        key: "submitted",
+        at: submittedAt,
+        title: "Submitted for review",
+        color: "blue",
+        icon: Send,
+      });
+    }
+
+    for (const step of contract.approvalSteps ?? []) {
+      if (!(step.requiredRole in HAZARDOUS_APPROVAL_ROLE_PERMISSION)) continue;
+      if (!step.actedAt) continue;
+      items.push({
+        key: `hazard-${step.id}`,
+        at: step.actedAt,
+        title: CONTRACT_APPROVAL_ROLE_LABELS[step.requiredRole] ?? step.requiredRole,
+        detail: step.status === "REJECTED" ? "Rejected" : "Approved",
+        color: step.status === "REJECTED" ? "red" : "orange",
+        icon: Flame,
+      });
+    }
+
+    if (contract.contractGeneratedAt) {
+      items.push({
+        key: "approved",
+        at: contract.contractGeneratedAt,
+        title: "Contract approved",
+        detail: "Every approval step cleared and the document was generated",
+        color: "edr-green",
+        icon: ShieldCheck,
+      });
+    }
+
+    for (const sig of contract.signatures ?? []) {
+      items.push({
+        key: `signature-${sig.id}`,
+        at: sig.signedAt,
+        title: SIGNATURE_ROLE_LABELS[sig.role] ?? `Signed by ${sig.role}`,
+        detail: sig.signerDisplayName,
+        color: "grape",
+        icon: FileSignature,
+      });
+    }
+
+    if (contract.fullyExecutedAt) {
+      items.push({
+        key: "executed",
+        at: contract.fullyExecutedAt,
+        title: "Fully executed",
+        detail: "Both parties have signed",
+        color: "edr-green",
+        icon: BadgeCheck,
+      });
+    }
+
+    return items.sort(
+      (a, b) => new Date(a.at).getTime() - new Date(b.at).getTime(),
+    );
+  }, [contract]);
+
+  const hasValidity = contract.contractValidFrom && contract.contractValidUntil;
+
+  if (milestones.length === 0 && !hasValidity) {
+    return (
+      <Text size="sm" c="dimmed" ta="center" py="lg">
+        No dated milestones recorded yet.
+      </Text>
+    );
+  }
+
+  return (
+    <Stack gap="md">
+      {hasValidity && (
+        <Group
+          gap="xs"
+          px="sm"
+          py="xs"
+          style={{
+            borderRadius: 8,
+            border: "1px solid var(--mantine-color-gray-2)",
+            background: "var(--mantine-color-gray-0)",
+            width: "fit-content",
+          }}
+        >
+          <CalendarClock size={16} color="var(--mantine-color-gray-6)" />
+          <Text size="sm">
+            Valid <strong>{formatDate(contract.contractValidFrom!)}</strong>
+            {" → "}
+            <strong>{formatDate(contract.contractValidUntil!)}</strong>
+          </Text>
+        </Group>
+      )}
+
+      {milestones.length > 0 && (
+        <Timeline active={milestones.length} bulletSize={26} lineWidth={2} color="edr-green">
+          {milestones.map((m) => {
+            const Icon = m.icon;
+            return (
+              <Timeline.Item
+                key={m.key}
+                bullet={<Icon size={13} />}
+                color={m.color}
+                title={
+                  <Group gap="xs" wrap="wrap" align="baseline">
+                    <Text size="sm" fw={600}>
+                      {m.title}
+                    </Text>
+                    <Tooltip label={formatWhen(m.at)} withArrow>
+                      <Text size="xs" c="dimmed">
+                        {formatAgo(m.at)}
+                      </Text>
+                    </Tooltip>
+                  </Group>
+                }
+              >
+                {m.detail && (
+                  <Text size="xs" c="dimmed" mt={2}>
+                    {m.detail}
+                  </Text>
+                )}
+              </Timeline.Item>
+            );
+          })}
+        </Timeline>
+      )}
+    </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 572d05dce..d91435495 100644
--- a/apps/edr-freight-web/backoffice/src/components/contracts/GlCreateBookingForm.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/contracts/GlCreateBookingForm.tsx
@@ -1018,14 +1018,9 @@ export default function GlCreateBookingForm() {
             // Non-fatal
           }
         }
-        if (contract.contractKind === "GENERAL") {
-          // GENERAL per-booking clearance: land on the booking's clearance
-          // detail — the same page the Shipments tab on the hub opens.
-          navigate(`/dashboard/clearance/${booking.id}`);
-        } else {
-          // ONE_TIME customs keeps its clearance on the contract.
-          navigate(`/dashboard/contracts/clearance/${contract.id}`);
-        }
+        // Clearance is always per booking — land on that booking's clearance
+        // detail, the same page the hub opens.
+        navigate(`/dashboard/clearance/${booking.id}`);
       },
     });
   };
@@ -1067,7 +1062,13 @@ export default function GlCreateBookingForm() {
         variant="default"
         radius="md"
         leftSection={<ChevronLeft size={16} />}
-        onClick={() => navigate(`/dashboard/contracts/clearance/${contract.id}`)}
+        onClick={() =>
+          navigate(
+            completeBookingId
+              ? `/dashboard/clearance/${completeBookingId}`
+              : "/dashboard/contracts/clearance",
+          )
+        }
       >
         Back to clearance
       </Button>
diff --git a/apps/edr-freight-web/backoffice/src/components/contracts/PhasedClearanceActionPanel.tsx b/apps/edr-freight-web/backoffice/src/components/contracts/PhasedClearanceActionPanel.tsx
index 8917cb216..e79a4eb28 100644
--- a/apps/edr-freight-web/backoffice/src/components/contracts/PhasedClearanceActionPanel.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/contracts/PhasedClearanceActionPanel.tsx
@@ -349,11 +349,11 @@ export function PhasedClearanceActionPanel({
                   API refuses the upload until the name is in. */}
               {showEt &&
               canEt &&
-              !isBooking &&
               !clearance.transitAssignee?.name &&
               !isMilestoneDone(clearance.milestones, "DECLARED") ? (
                 <TransitAssigneePanel
-                  contractId={entityId}
+                  entityId={entityId}
+                  isBooking={isBooking}
                   transitAssignee={clearance.transitAssignee}
                   side="ET"
                   onChanged={onChanged}
diff --git a/apps/edr-freight-web/backoffice/src/components/contracts/StampUpload.tsx b/apps/edr-freight-web/backoffice/src/components/contracts/StampUpload.tsx
index 1c1e4d87c..bdf47c5fd 100644
--- a/apps/edr-freight-web/backoffice/src/components/contracts/StampUpload.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/contracts/StampUpload.tsx
@@ -2,7 +2,7 @@ import { useRef, useState } from "react";
 import { Box, Button, Group, Image, Paper, Stack, Text } from "@mantine/core";
 import { RefreshCw, Stamp, X } from "lucide-react";
 
-const MAX_STAMP_MB = 5;
+const MAX_STAMP_MB = 10;
 
 export interface StampUploadProps {
   /** Stamp image as a data URL, or null when none is attached yet. */
diff --git a/apps/edr-freight-web/backoffice/src/components/contracts/TransitAssigneePanel.tsx b/apps/edr-freight-web/backoffice/src/components/contracts/TransitAssigneePanel.tsx
index 78acae89c..bcca14456 100644
--- a/apps/edr-freight-web/backoffice/src/components/contracts/TransitAssigneePanel.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/contracts/TransitAssigneePanel.tsx
@@ -15,10 +15,14 @@ import { CheckCircle2, Clock, Send, UserCheck } from "lucide-react";
 import { useState } from "react";
 import toast from "react-hot-toast";
 
+import { bookingsService } from "@/services/bookings.service";
 import { contractsService } from "@/services/contracts.service";
 
 export interface TransitAssigneePanelProps {
-  contractId: string;
+  /** Booking id when `isBooking`, contract id otherwise. */
+  entityId: string;
+  /** Clearance runs per booking now; contract-level cycles are the legacy case. */
+  isBooking?: boolean;
   transitAssignee: Freight.ContractClearanceView["transitAssignee"];
   /**
    * ET asks and waits; DJ answers with a name. The same state renders from both
@@ -50,7 +54,8 @@ const fmt = (iso?: string | null) =>
  * different name later; the newest one wins and Ethiopia is notified again.
  */
 export function TransitAssigneePanel({
-  contractId,
+  entityId,
+  isBooking = false,
   transitAssignee,
   side,
   readOnly = false,
@@ -59,9 +64,12 @@ export function TransitAssigneePanel({
   const [note, setNote] = useState("");
   const [assignee, setAssignee] = useState(transitAssignee?.name ?? "");
   const [changing, setChanging] = useState(false);
+  const service = isBooking ? bookingsService : contractsService;
 
   const request = useMutation({
-    mutationFn: () => contractsService.requestTransitAssignee(contractId, note.trim()),
+    mutationFn: async () => {
+      await service.requestTransitAssignee(entityId, note.trim());
+    },
     onSuccess: () => {
       toast.success("Request sent to GL Djibouti");
       setNote("");
@@ -70,8 +78,9 @@ export function TransitAssigneePanel({
   });
 
   const assign = useMutation({
-    mutationFn: () =>
-      contractsService.assignTransitAssignee(contractId, assignee.trim()),
+    mutationFn: async () => {
+      await service.assignTransitAssignee(entityId, assignee.trim());
+    },
     onSuccess: () => {
       toast.success("Transit assignee sent to GL Ethiopia");
       setChanging(false);
diff --git a/apps/edr-freight-web/backoffice/src/components/contracts/detail/RequestDetailCards.tsx b/apps/edr-freight-web/backoffice/src/components/contracts/detail/RequestDetailCards.tsx
index 595252cbf..d8c5f819a 100644
--- a/apps/edr-freight-web/backoffice/src/components/contracts/detail/RequestDetailCards.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/contracts/detail/RequestDetailCards.tsx
@@ -95,12 +95,16 @@ export function RequestCustomerCard({ contract }: { contract?: ReqContract | nul
   );
 }
 
+// Validity is accepted to the minute, so the expiry reads with its time — a
+// contract that lapses at 09:00 looks identical to one lapsing at 23:59 without it.
 const fmtDate = (iso?: string | null) =>
   iso
     ? new Intl.DateTimeFormat("en-GB", {
         day: "2-digit",
         month: "short",
         year: "numeric",
+        hour: "2-digit",
+        minute: "2-digit",
       }).format(new Date(iso))
     : "—";
 
diff --git a/apps/edr-freight-web/backoffice/src/components/fleet/WagonMovementHistoryModal.tsx b/apps/edr-freight-web/backoffice/src/components/fleet/WagonMovementHistoryModal.tsx
index e2713fdcb..7ad92fa7a 100644
--- a/apps/edr-freight-web/backoffice/src/components/fleet/WagonMovementHistoryModal.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/fleet/WagonMovementHistoryModal.tsx
@@ -32,6 +32,11 @@ const KIND_META: Record<string, { label: string; color: string; icon: ReactNode
     color: "orange",
     icon: <Wrench size={14} />,
   },
+  MAINTENANCE: {
+    label: "Sent to maintenance",
+    color: "red",
+    icon: <Wrench size={14} />,
+  },
 };
 
 const yardLabel = (
@@ -103,10 +108,16 @@ const WagonMovementHistoryModal = ({
                     <Text size="sm" fw={600}>
                       {from}
                     </Text>
-                    <ArrowRight size={13} />
-                    <Text size="sm" fw={600}>
-                      {to}
-                    </Text>
+                    {/* Status events (maintenance) sit in one yard — an arrow
+                        pointing at the same yard reads as a broken row. */}
+                    {movement.fromYardId !== movement.toYardId && (
+                      <>
+                        <ArrowRight size={13} />
+                        <Text size="sm" fw={600}>
+                          {to}
+                        </Text>
+                      </>
+                    )}
                     <Badge size="xs" variant="light" color={meta.color}>
                       {meta.label}
                     </Badge>
diff --git a/apps/edr-freight-web/backoffice/src/components/trainBuilder/AvailableWagonsPanel.tsx b/apps/edr-freight-web/backoffice/src/components/trainBuilder/AvailableWagonsPanel.tsx
index fc33ae45a..1bddb77cd 100644
--- a/apps/edr-freight-web/backoffice/src/components/trainBuilder/AvailableWagonsPanel.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/trainBuilder/AvailableWagonsPanel.tsx
@@ -41,7 +41,12 @@ export default function AvailableWagonsPanel({
   const wagonsQuery = useQuery(
     api.wagons.list.queryOptions({
       input: {
-        filters: { status: Freight.WagonStatus.Available, currentYardId: yardId },
+        filters: {
+          status: Freight.WagonStatus.Available,
+          currentYardId: yardId,
+          // Loose wagons only — one already on another train cannot be coupled.
+          unassigned: true,
+        },
       },
       enabled: Boolean(yardId),
     }),
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 810bdc721..99c7e6ef0 100644
--- a/apps/edr-freight-web/backoffice/src/components/trainBuilder/BuildTrainModal.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/trainBuilder/BuildTrainModal.tsx
@@ -30,7 +30,7 @@ const parseError = (error: unknown, fallback: string) => {
 
 /**
  * Step one of the Train Builder: pick the yard it is being assembled in and
- * couple at least two locomotives from that yard. The train code is assigned by
+ * couple at least one locomotive from that yard. The train code is assigned by
  * the system. Wagons are attached afterwards on the composition page.
  */
 export default function BuildTrainModal({ opened, onClose, onBuilt }: BuildTrainModalProps) {
@@ -86,9 +86,9 @@ export default function BuildTrainModal({ opened, onClose, onBuilt }: BuildTrain
   }, [opened]);
 
   const handleBuild = async () => {
-    if (!yardId || locomotiveIds.length < 2) {
+    if (!yardId || locomotiveIds.length < 1) {
       toast({
-        title: "Pick a yard and couple at least two locomotives",
+        title: "Pick a yard and couple at least one locomotive",
         variant: "destructive",
       });
       return;
@@ -185,17 +185,15 @@ export default function BuildTrainModal({ opened, onClose, onBuilt }: BuildTrain
         />
         <MultiSelect
           label="Locomotives"
-          description="A train must be pulled by at least two locomotives (front and back). First pick becomes the lead."
-          placeholder={yardId ? "Select at least two locomotives" : "Select a yard first"}
+          description="A train must be pulled by at least one locomotive. First pick becomes the lead."
+          placeholder={yardId ? "Select at least one locomotive" : "Select a yard first"}
           data={locomotiveOptions}
           value={locomotiveIds}
           onChange={setLocomotiveIds}
           searchable
           disabled={!yardId}
           error={
-            locomotiveIds.length > 0 && locomotiveIds.length < 2
-              ? "Select at least two locomotives"
-              : undefined
+            locomotiveIds.length < 1 ? "Select at least one locomotive" : undefined
           }
           nothingFoundMessage={
             yardId ? "No available locomotives in this yard" : "Select a yard first"
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 ef7135bcc..f99fb07fa 100644
--- a/apps/edr-freight-web/backoffice/src/components/trainBuilder/ChangeLocomotivesModal.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/trainBuilder/ChangeLocomotivesModal.tsx
@@ -16,7 +16,7 @@ const parseError = (error: unknown, fallback: string) => {
   return fallback;
 };
 
-/** Swap the locomotive set of a built train (minimum 2, same-yard rule). */
+/** Swap the locomotive set of a built train (minimum 1, same-yard rule). */
 export default function ChangeLocomotivesModal({
   composition,
   opened,
@@ -74,8 +74,8 @@ export default function ChangeLocomotivesModal({
 
   const handleSave = async () => {
     if (!composition) return;
-    if (locomotiveIds.length < 2) {
-      toast({ title: "A train needs at least two locomotives", variant: "destructive" });
+    if (locomotiveIds.length < 1) {
+      toast({ title: "A train needs at least one locomotive", variant: "destructive" });
       return;
     }
     try {
@@ -112,9 +112,7 @@ export default function ChangeLocomotivesModal({
           onChange={setLocomotiveIds}
           searchable
           error={
-            locomotiveIds.length > 0 && locomotiveIds.length < 2
-              ? "Select at least two locomotives"
-              : undefined
+            locomotiveIds.length < 1 ? "Select at least one locomotive" : undefined
           }
           nothingFoundMessage="No available locomotives in this yard"
         />
diff --git a/apps/edr-freight-web/backoffice/src/components/trainBuilder/ConsistWagonList.tsx b/apps/edr-freight-web/backoffice/src/components/trainBuilder/ConsistWagonList.tsx
index 4e1b25629..2aab0ca10 100644
--- a/apps/edr-freight-web/backoffice/src/components/trainBuilder/ConsistWagonList.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/trainBuilder/ConsistWagonList.tsx
@@ -12,6 +12,7 @@ import { type ReactNode } from "react";
 import { createPortal } from "react-dom";
 
 import type { TrainCompositionWagon } from "@/services/trainBuilder.service";
+import { wagonTypeColor } from "./trainStatus";
 
 /** Reparent dragged row to body — fixes position:fixed inside transformed parents. */
 const PortalAwareRow = ({
@@ -58,11 +59,36 @@ export default function ConsistWagonList({
     );
   }
 
+  // Legend of the types actually coupled, in consist order — the colour code is
+  // only readable if the row tints are keyed somewhere.
+  const legend = [
+    ...new Map(
+      wagons
+        .filter((w) => w.wagonType)
+        .map((w) => [w.wagonType!.code, w.wagonType!]),
+    ).values(),
+  ];
+
   return (
     <DragDropContext onDragEnd={onDragEnd}>
       <Droppable droppableId="train-consist-wagons" isDropDisabled={!editable || busy}>
         {(dropProvided) => (
           <Stack gap="xs" ref={dropProvided.innerRef} {...dropProvided.droppableProps}>
+            {legend.length > 1 ? (
+              <Group gap={6} wrap="wrap">
+                {legend.map((type) => (
+                  <Badge
+                    key={type.code}
+                    size="sm"
+                    radius="sm"
+                    variant="light"
+                    color={wagonTypeColor(type.code)}
+                  >
+                    {type.code} · {type.name}
+                  </Badge>
+                ))}
+              </Group>
+            ) : null}
             {wagons.map((wagon, index) => (
               <Draggable
                 key={wagon.id}
@@ -97,8 +123,8 @@ export interface ConsistWagonListProps {
   editable: boolean;
   onReorder: (wagonIds: string[]) => void;
   onRemove: (wagonId: string) => void;
-  /** Detach the wagon and move it to MAINTENANCE status. */
-  onMaintenance: (wagonId: string) => void;
+  /** Detach the wagon and move it to MAINTENANCE status (page confirms first). */
+  onMaintenance: (wagon: TrainCompositionWagon) => void;
   busy?: boolean;
 }
 
@@ -119,8 +145,10 @@ function WagonRow({
   editable: boolean;
   busy: boolean;
   onRemove: (wagonId: string) => void;
-  onMaintenance: (wagonId: string) => void;
+  onMaintenance: (wagon: TrainCompositionWagon) => void;
 }) {
+  const color = wagonTypeColor(wagon.wagonType?.code);
+
   return (
     <PortalAwareRow snapshot={snapshot}>
       <Group
@@ -132,9 +160,14 @@ function WagonRow({
         p="sm"
         style={{
           ...dragProvided.draggableProps.style,
-          border: "1px solid var(--mantine-color-gray-3)",
+          border: `1px solid var(--mantine-color-${color}-2)`,
+          borderLeft: `4px solid var(--mantine-color-${color}-5)`,
           borderRadius: "var(--mantine-radius-md)",
-          background: snapshot.isDragging ? "var(--mantine-color-gray-0)" : "white",
+          // Tinted by wagon type so a mixed consist is scannable at a glance;
+          // the drag state keeps its own neutral lift.
+          background: snapshot.isDragging
+            ? "white"
+            : `var(--mantine-color-${color}-0)`,
           boxShadow: snapshot.isDragging ? "0 8px 24px rgba(0, 0, 0, 0.12)" : undefined,
           cursor: editable ? (snapshot.isDragging ? "grabbing" : "grab") : "default",
           userSelect: "none",
@@ -145,13 +178,20 @@ function WagonRow({
             <GripVertical size={18} />
           </Box>
         ) : null}
-        <Badge variant="light" color="gray" size="sm">
+        <Badge variant="filled" color={color} size="sm">
           {index + 1}
         </Badge>
         <Stack gap={2} style={{ flex: 1, minWidth: 0 }}>
-          <Text size="sm" fw={600} ff="monospace" truncate>
-            {wagon.wagonNumber}
-          </Text>
+          <Group gap={6} wrap="nowrap">
+            <Text size="sm" fw={600} ff="monospace" truncate>
+              {wagon.wagonNumber}
+            </Text>
+            {wagon.wagonType ? (
+              <Badge variant="light" color={color} size="xs" radius="sm">
+                {wagon.wagonType.code}
+              </Badge>
+            ) : null}
+          </Group>
           <Text size="xs" c="dimmed" truncate>
             {wagon.wagonType
               ? `${wagon.wagonType.name} · ${wagon.wagonType.capacityTons}T cap · ${wagon.wagonType.lengthMeters}m`
@@ -165,7 +205,7 @@ function WagonRow({
                 variant="subtle"
                 color="orange"
                 disabled={busy}
-                onClick={() => onMaintenance(wagon.id)}
+                onClick={() => onMaintenance(wagon)}
                 aria-label={`Send wagon ${wagon.wagonNumber} to maintenance`}
               >
                 <Wrench size={16} />
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 83efa8ff2..330a31119 100644
--- a/apps/edr-freight-web/backoffice/src/components/trainBuilder/trainStatus.ts
+++ b/apps/edr-freight-web/backoffice/src/components/trainBuilder/trainStatus.ts
@@ -56,6 +56,58 @@ export const locomotiveStatusLabel = (status: string): string =>
     .replace(/_/g, " ")
     .replace(/^\w/, (c) => c.toUpperCase());
 
+/**
+ * Hues for the wagon-type color code. No red or gray — red reads as a fault on
+ * a consist row, gray is the "unknown type" fallback.
+ */
+const WAGON_TYPE_COLORS = [
+  "blue",
+  "teal",
+  "grape",
+  "orange",
+  "cyan",
+  "indigo",
+  "pink",
+  "lime",
+  "violet",
+  "yellow",
+];
+
+/**
+ * Fixed hue per seeded wagon-type code. Related families sit on neighbouring
+ * hues (gondolas blue/indigo, hoppers grape/violet, flats teal/lime) so a
+ * consist reads as groups, not confetti. Explicit rather than hashed because
+ * hashing 10 codes into 10 hues collides — and two types sharing a colour is
+ * exactly what a colour code must not do.
+ */
+const WAGON_TYPE_CODE_COLORS: Record<string, string> = {
+  CW3: "blue", // Gondola open
+  CW4: "indigo", // Gondola covered
+  KW2: "grape", // Hopper covered
+  KW3: "violet", // Hopper open
+  NW5: "teal", // Flat
+  NW6: "lime", // Flat (long)
+  NW7: "pink", // Double deck sedan
+  BW1: "cyan", // Refrigerated
+  GW2: "orange", // Tank
+  PW2: "yellow", // Box
+};
+
+/**
+ * Stable hue per wagon-type code. Unseeded codes fall back to a hash so a new
+ * type still gets a consistent colour instead of collapsing to gray.
+ */
+export const wagonTypeColor = (code?: string | null): string => {
+  if (!code) return "gray";
+  const seeded = WAGON_TYPE_CODE_COLORS[code];
+  if (seeded) return seeded;
+  let hash = 0;
+  for (let i = 0; i < code.length; i++) {
+    hash = (hash * 31 + code.charCodeAt(i)) >>> 0;
+  }
+  return WAGON_TYPE_COLORS[hash % WAGON_TYPE_COLORS.length]!;
+};
+
 /** 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/constants/URLS.ts b/apps/edr-freight-web/backoffice/src/constants/URLS.ts
index 482de4967..eaf3b180c 100644
--- a/apps/edr-freight-web/backoffice/src/constants/URLS.ts
+++ b/apps/edr-freight-web/backoffice/src/constants/URLS.ts
@@ -144,6 +144,10 @@ export const URL_CONSTANTS = {
     CLEARANCE_DECLARATION: (id: string) =>
       `/bookings/${id}/clearance/declaration`,
     CLEARANCE_DUTY: (id: string) => `/bookings/${id}/clearance/duty`,
+    CLEARANCE_TRANSIT_ASSIGNEE_REQUEST: (id: string) =>
+      `/bookings/${id}/clearance/transit-assignee/request`,
+    CLEARANCE_TRANSIT_ASSIGNEE_ASSIGN: (id: string) =>
+      `/bookings/${id}/clearance/transit-assignee/assign`,
     CLEARANCE_FINALIZE_PRE: (id: string) =>
       `/bookings/${id}/clearance/finalize-pre-clearance`,
     CLEARANCE_TRANSIT_PERMIT: (id: string) =>
@@ -170,6 +174,8 @@ export const URL_CONSTANTS = {
     STAFF_REQUEST_CHANGES: (id: string) =>
       `/contracts/${id}/staff/request-changes`,
     STAFF_REJECT: (id: string) => `/contracts/${id}/staff/reject`,
+    SUSPEND: (id: string) => `/contracts/${id}/suspend`,
+    RESUME: (id: string) => `/contracts/${id}/resume`,
     APPROVE_STEP: (id: string, stepId: string) =>
       `/contracts/${id}/approval-steps/${stepId}/approve`,
     REJECT_STEP: (id: string, stepId: string) =>
@@ -217,10 +223,7 @@ export const URL_CONSTANTS = {
       `/contracts/${id}/clearance/export-release`,
     CLEARANCE_FINALIZE_EXPORT: (id: string) =>
       `/contracts/${id}/clearance/finalize-export-clearance`,
-    CLEARANCE_ET_QUEUE: "/contracts/clearance/et-queue",
-    CLEARANCE_DJ_QUEUE: "/contracts/clearance/dj-queue",
     // Path A self-clearance — Operations reviews the customer's own clearance docs.
-    OPS_CLEARANCE_QUEUE: "/contracts/clearance/ops-queue",
     OPS_CLEARANCE_REVIEW: (id: string) =>
       `/contracts/${id}/clearance/ops-review`,
     OPS_CLEARANCE_FINALIZE: (id: string) =>
@@ -228,6 +231,9 @@ export const URL_CONSTANTS = {
     CLEARANCE_HISTORY: "/contracts/clearance/history",
     OPS_CLEARANCE_HISTORY: "/contracts/clearance/ops-history",
     BOOKINGS: (id: string) => `/contracts/${id}/bookings`,
+    BOOKINGS_INITIATE: (id: string) => `/contracts/${id}/bookings/initiate`,
+    // GL worklist: executed customs contracts with no shipment instance yet.
+    AWAITING_SHIPMENT: "/contracts/awaiting-shipment",
     BOOKINGS_COMPLETE: (id: string, bookingId: string) =>
       `/contracts/${id}/bookings/${bookingId}/complete`,
     VALIDATE_SHIPMENT: (id: string) => `/contracts/${id}/validate-shipment`,
diff --git a/apps/edr-freight-web/backoffice/src/features/contracts/contract-status.config.ts b/apps/edr-freight-web/backoffice/src/features/contracts/contract-status.config.ts
index 2277d702b..afbe4fc4a 100644
--- a/apps/edr-freight-web/backoffice/src/features/contracts/contract-status.config.ts
+++ b/apps/edr-freight-web/backoffice/src/features/contracts/contract-status.config.ts
@@ -67,8 +67,14 @@ export const CONTRACT_STATUS_STYLES: Record<string, StatusStyle> = {
     label: "Shipment in Progress",
     color: "bg-sky-50 text-sky-700 border-sky-200",
   },
+  SUSPENDED: {
+    label: "Suspended",
+    color: "bg-orange-50 text-orange-700 border-orange-200",
+  },
   CONTRACT_CLOSED: {
-    label: "Closed",
+    // A fulfilled contract (one-time shipment delivered, or cap consumed) —
+    // greyed out to read as inactive.
+    label: "Completed",
     color: "bg-slate-100 text-slate-700 border-slate-300",
   },
   EXPIRED: {
@@ -122,6 +128,7 @@ export const CONTRACT_STATUS_COLOR: Record<string, string> = {
   CLEARANCE_UNDER_REVIEW: "yellow",
   CLEARANCE_READY_FOR_BOOKING: "edr-green",
   ACTIVE_SHIPMENT_IN_PROGRESS: "cyan",
+  SUSPENDED: "orange",
   CONTRACT_CLOSED: "gray",
   EXPIRED: "red",
   REJECTED: "red",
@@ -232,11 +239,17 @@ export const CONTRACT_STATUS_META: Record<string, StatusMeta> = {
     stage: 4,
   },
   CONTRACT_CLOSED: {
-    title: "Closed",
-    description: "Contract fulfilled and closed.",
+    title: "Completed",
+    description: "Contract fulfilled — its shipment was delivered.",
     color: "text-slate-500",
     stage: 5,
   },
+  SUSPENDED: {
+    title: "Suspended",
+    description: "Frozen by EDR — bookings and shipments are on hold.",
+    color: "text-orange-600",
+    stage: -1,
+  },
   EXPIRED: {
     title: "Expired",
     description: "Validity window elapsed.",
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 cb125ddff..bc0697996 100644
--- a/apps/edr-freight-web/backoffice/src/hooks/contracts/useContracts.ts
+++ b/apps/edr-freight-web/backoffice/src/hooks/contracts/useContracts.ts
@@ -53,30 +53,9 @@ export function useContractClearanceQueue(enabled = true) {
   });
 }
 
-export function useEtClearanceQueue(enabled = true) {
-  return useQuery({
-    queryKey: QUERY_KEYS.CONTRACTS.clearanceQueue("ET"),
-    queryFn: () => contractsService.getEtClearanceQueue(),
-    enabled,
-  });
-}
-
-export function useDjClearanceQueue(enabled = true) {
-  return useQuery({
-    queryKey: QUERY_KEYS.CONTRACTS.clearanceQueue("DJ"),
-    queryFn: () => contractsService.getDjClearanceQueue(),
-    enabled,
-  });
-}
-
-/** Path A self-clearance queue (Operations reviews non-customs contracts). */
-export function useOpsClearanceQueue(enabled = true) {
-  return useQuery({
-    queryKey: QUERY_KEYS.CONTRACTS.clearanceQueue("OPS"),
-    queryFn: () => contractsService.getOpsClearanceQueue(),
-    enabled,
-  });
-}
+// The awaiting-shipment worklist hook was removed with the clearance hub's
+// "Start shipment" dialog — nothing calls GET /contracts/awaiting-shipment any
+// more. The endpoint still exists server-side if the worklist comes back.
 
 export function useContractClearanceHistory(enabled = true) {
   return useQuery({
@@ -172,6 +151,19 @@ export function useContractMutations(contractId: string) {
     onError: (error) => toast.error(extractErrorMessage(error, "Failed to reject contract")),
   });
 
+  const suspend = useMutation({
+    mutationFn: (reason: string) => contractsService.suspend(contractId, reason),
+    onSuccess: (data) => onSuccess(data, "Contract suspended"),
+    onError: (error) => toast.error(extractErrorMessage(error, "Failed to suspend contract")),
+  });
+
+  const resume = useMutation({
+    mutationFn: (note: string | undefined) => contractsService.resume(contractId, note),
+    onSuccess: (data) =>
+      onSuccess(data, `Suspension lifted — contract is back to ${data.status}`),
+    onError: (error) => toast.error(extractErrorMessage(error, "Failed to lift suspension")),
+  });
+
   const approveStep = useMutation({
     // The server derives the required role from the step itself, so the client
     // does not send one.
@@ -277,6 +269,8 @@ export function useContractMutations(contractId: string) {
     updateDocument,
     requestChanges,
     reject,
+    suspend,
+    resume,
     approveStep,
     rejectStep,
     generateContract,
diff --git a/apps/edr-freight-web/backoffice/src/lib/permissions.ts b/apps/edr-freight-web/backoffice/src/lib/permissions.ts
index 161ec03ea..e50f93c2c 100644
--- a/apps/edr-freight-web/backoffice/src/lib/permissions.ts
+++ b/apps/edr-freight-web/backoffice/src/lib/permissions.ts
@@ -60,6 +60,7 @@ export const FREIGHT_PERMS = {
     clearanceDutyAdvise: "edr_freight_app:contracts:clearance_duty_advise",
     clearanceEtActions: "edr_freight_app:contracts:clearance_et_actions",
     clearanceDjActions: "edr_freight_app:contracts:clearance_dj_actions",
+    suspend: "edr_freight_app:contracts:suspend",
   },
   trainScheduling: {
     view: "edr_freight_app:train_scheduling:view",
diff --git a/apps/edr-freight-web/backoffice/src/pages/bookings/DocumentClearanceDetailPage.tsx b/apps/edr-freight-web/backoffice/src/pages/bookings/DocumentClearanceDetailPage.tsx
index 7be7871dd..88af3cad1 100644
--- a/apps/edr-freight-web/backoffice/src/pages/bookings/DocumentClearanceDetailPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/bookings/DocumentClearanceDetailPage.tsx
@@ -1,6 +1,6 @@
 import { useMemo } from "react";
 import { useQuery } from "@tanstack/react-query";
-import { useNavigate, useParams } from "react-router-dom";
+import { useLocation, useNavigate, useParams } from "react-router-dom";
 import {
   Alert,
   Badge,
@@ -50,9 +50,20 @@ export default function DocumentClearanceDetailPage() {
   const params = useParams<{ id?: string; bookingId?: string }>();
   const id = params.id ?? params.bookingId;
   const navigate = useNavigate();
+  const location = useLocation();
   const { user } = useAuth();
   const { view, viewer } = useFileViewer();
 
+  // The same shipment is opened from several worklists (GL Ethiopia clearance,
+  // the Operations clearance-documents hub, shipment requests…), so "back" is
+  // whichever list sent us here. Deep links have no sender: fall back to the
+  // hub this user actually works in.
+  const backTo =
+    (location.state as { from?: string } | null)?.from ??
+    (hasPermission(user, FREIGHT_PERMS.contracts.clearanceEtActions)
+      ? "/dashboard/contracts/clearance"
+      : "/dashboard/contracts/clearance-documents");
+
   const { data: booking } = useBookingDetail(id);
   const {
     data: clearance,
@@ -95,10 +106,10 @@ export default function DocumentClearanceDetailPage() {
   }, [clearance]);
 
   const reference = booking?.reference ?? "Clearance";
+  // Phased customs clearance runs on every contract booking now — ONE_TIME and
+  // GENERAL alike; the persisted phase is what marks the workflow as running.
   const isPhasedGeneral =
-    Boolean(booking?.customsClearingEnabled) &&
-    booking?.contractKind === "GENERAL" &&
-    Boolean(clearance?.phase);
+    Boolean(booking?.customsClearingEnabled) && Boolean(clearance?.phase);
 
   // Bare initiated instance whose clearance is done: GL completes the booking
   // (container numbers, VGM, shipment day) via the completion form.
@@ -147,9 +158,9 @@ export default function DocumentClearanceDetailPage() {
       <PageContainer>
         <PageHeader
           title="Clearance not found"
-          backTo="/dashboard/contracts/clearance"
+          backTo={backTo}
           breadcrumbs={[
-            { label: "Document Clearance", href: "/dashboard/contracts/clearance" },
+            { label: "Document Clearance", href: backTo },
             { label: "Not found" },
           ]}
         />
@@ -165,9 +176,9 @@ export default function DocumentClearanceDetailPage() {
       <Stack gap="lg">
         <PageHeader
           title={reference}
-          backTo="/dashboard/contracts/clearance"
+          backTo={backTo}
           breadcrumbs={[
-            { label: "Document Clearance", href: "/dashboard/contracts/clearance" },
+            { label: "Document Clearance", href: backTo },
             { label: reference },
           ]}
           meta={
diff --git a/apps/edr-freight-web/backoffice/src/pages/bookings/DocumentClearanceListPage.tsx b/apps/edr-freight-web/backoffice/src/pages/bookings/DocumentClearanceListPage.tsx
index 34e659177..b0e199d12 100644
--- a/apps/edr-freight-web/backoffice/src/pages/bookings/DocumentClearanceListPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/bookings/DocumentClearanceListPage.tsx
@@ -1,6 +1,6 @@
 import { useCallback, useMemo, useState } from "react";
 import { useQuery } from "@tanstack/react-query";
-import { useNavigate } from "react-router-dom";
+import { useLocation, useNavigate } from "react-router-dom";
 import {
   ActionIcon,
   Badge,
@@ -139,6 +139,7 @@ export default function DocumentClearanceListPage({
   opsMode?: boolean;
 }) {
   const navigate = useNavigate();
+  const location = useLocation();
   const [pageTab, setPageTab] = useState<PageTab>("queue");
   const [activeTab, setActiveTab] = useState<ClearanceTabKey>("all");
   const [query, setQuery] = useState("");
@@ -205,8 +206,13 @@ export default function DocumentClearanceListPage({
   }, [rows, pagination.pageIndex, pagination.pageSize]);
 
   const openDetail = useCallback(
-    (id: string) => navigate(`/dashboard/clearance/${id}`),
-    [navigate],
+    // `from` so the detail page's Back returns to this list, whichever route
+    // it is mounted at (ops self-clearance review, history, …).
+    (id: string) =>
+      navigate(`/dashboard/clearance/${id}`, {
+        state: { from: location.pathname },
+      }),
+    [navigate, location.pathname],
   );
 
   const statusBadge = isHistory ? (
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 a4ae9f880..d31c60dd4 100644
--- a/apps/edr-freight-web/backoffice/src/pages/contracts/ClearanceDocumentsPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/contracts/ClearanceDocumentsPage.tsx
@@ -1,4 +1,3 @@
-import { directionLabel } from "@/lib/utils";
 import {
   ActionIcon,
   Box,
@@ -6,36 +5,20 @@ import {
   Group,
   Select,
   Stack,
-  Tabs,
   Text,
   TextInput,
   ThemeIcon,
 } from "@mantine/core";
 import { useDebouncedValue } from "@mantine/hooks";
 import { keepPreviousData, useQuery } from "@tanstack/react-query";
-import {
-  ArrowRight,
-  FileText,
-  Inbox,
-  RefreshCw,
-  Repeat,
-  Search,
-  User,
-  X,
-} from "lucide-react";
+import { FileText, Inbox, RefreshCw, Search, User, X } from "lucide-react";
 import { useCallback, useMemo, useState } from "react";
 import { useNavigate } from "react-router-dom";
 
 import { BookingStatusBadge } from "@/components/bookings/BookingStatusBadge";
 import { bookingTable } from "@/components/bookings/booking-ui.styles";
-import { ContractStatusBadge } from "@/components/contracts/ContractStatusBadge";
 import { PageContainer, PageHeader } from "@/components/page";
-import {
-  toContractListRow,
-  type ContractListRow,
-} from "@/features/contracts/mapContractListRow";
 import { bookingsService } from "@/services/bookings.service";
-import { contractsService } from "@/services/contracts.service";
 import type { BookingDetail } from "@/types/booking";
 import {
   Badge,
@@ -46,45 +29,16 @@ import {
 } from "@edr/ui-common";
 
 /**
- * Operations "Clearance Documents" hub — worklist for clearance-document
- * review on contracts WITHOUT customs clearing (self-clearance):
- * Contracts tab = contract-level review (one-time flow), General tab =
- * per-booking review under GENERAL non-customs contracts. Rows deep-link to
- * the existing review detail pages; search / status filter / pagination are
- * all server-side.
+ * Operations "Clearance Documents" hub — the worklist for self-clearance
+ * (non-customs) document review. Clearance is always per SHIPMENT: the customer
+ * uploads his documents on the booking he initiated, whatever kind of contract
+ * it draws on, so this hub lists bookings only. Rows deep-link to the booking
+ * clearance review page; search / status filter / pagination are server-side.
  */
 
-type HubTab = "contracts" | "general";
-
 const PAGE_SIZE = 10;
 
-/** Status filter options for the Contracts tab (values = `statuses` param). */
-const CONTRACT_STATUS_OPTIONS = [
-  {
-    value: [
-      "AWAITING_CLEARANCE_DOCUMENTS",
-      "CLEARANCE_UNDER_REVIEW",
-      "CLEARANCE_READY_FOR_BOOKING",
-      "FULLY_EXECUTED",
-      "CONTRACT_ACTIVE",
-      "ACTIVE_SHIPMENT_IN_PROGRESS",
-      "CONTRACT_CLOSED",
-      "CANCELLED",
-    ].join(","),
-    label: "All statuses",
-  },
-  { value: "AWAITING_CLEARANCE_DOCUMENTS", label: "Awaiting documents" },
-  { value: "CLEARANCE_UNDER_REVIEW", label: "Under review" },
-  { value: "CLEARANCE_READY_FOR_BOOKING", label: "Ready for booking" },
-  { value: "FULLY_EXECUTED,CONTRACT_ACTIVE", label: "Finalized" },
-  {
-    value: "ACTIVE_SHIPMENT_IN_PROGRESS,CONTRACT_CLOSED",
-    label: "In progress / closed",
-  },
-  { value: "CANCELLED", label: "Cancelled" },
-];
-
-/** Status filter options for the General (per-booking) tab. */
+/** Status filter options (values = `statuses` param). */
 const BOOKING_STATUS_OPTIONS = [
   {
     value: "AWAITING_DOCUMENTS,DOCUMENTS_UNDER_REVIEW,CLEARANCE_READY",
@@ -97,12 +51,8 @@ const BOOKING_STATUS_OPTIONS = [
 
 export default function ClearanceDocumentsPage() {
   const navigate = useNavigate();
-  const [hubTab, setHubTab] = useState<HubTab>("contracts");
   const [query, setQuery] = useState("");
   const [debouncedQuery] = useDebouncedValue(query, 300);
-  const [contractStatuses, setContractStatuses] = useState(
-    CONTRACT_STATUS_OPTIONS[0].value,
-  );
   const [bookingStatuses, setBookingStatuses] = useState(
     BOOKING_STATUS_OPTIONS[0].value,
   );
@@ -116,34 +66,12 @@ export default function ClearanceDocumentsPage() {
 
   const page = pagination.pageIndex + 1;
 
-  const contractsQuery = useQuery({
-    queryKey: [
-      "clearance-documents",
-      "contracts",
-      contractStatuses,
-      page,
-      search,
-    ],
+  const bookingsQuery = useQuery({
+    queryKey: ["clearance-documents", "bookings", bookingStatuses, page, search],
     queryFn: () =>
-      contractsService.getOpsClearanceQueue({
-        page,
-        pageSize: PAGE_SIZE,
-        statuses: contractStatuses,
-        search,
-      }),
-    enabled: hubTab === "contracts",
-    placeholderData: keepPreviousData,
-  });
-
-  const generalQuery = useQuery({
-    queryKey: ["clearance-documents", "general", bookingStatuses, page, search],
-    queryFn: () =>
-      // Per-booking self-clearance instances are drawdowns under GENERAL
-      // non-customs contracts: they carry bookingType=ONE_TIME (each shipment
-      // is one-time) with contractKind=GENERAL, so filtering on
-      // bookingType=GENERAL_CONTRACT returned nothing. customsClearingEnabled
-      // =false + the three per-booking clearance statuses already isolate
-      // exactly this worklist — the same set the old booking-request tab showed.
+      // Self-clearance instances carry bookingType=ONE_TIME whatever their
+      // contract kind, so customsClearingEnabled=false + the three per-booking
+      // clearance statuses are what isolate exactly this worklist.
       bookingsService.list({
         statuses: bookingStatuses,
         customsClearingEnabled: "false",
@@ -151,112 +79,10 @@ export default function ClearanceDocumentsPage() {
         pageSize: PAGE_SIZE,
         search,
       }),
-    enabled: hubTab === "general",
     placeholderData: keepPreviousData,
   });
 
-  const contractRows = useMemo(
-    () => (contractsQuery.data?.items ?? []).map(toContractListRow),
-    [contractsQuery.data?.items],
-  );
-  const bookingRows = generalQuery.data?.items ?? [];
-
-  const contractColumns: ColumnDef<ContractListRow>[] = useMemo(
-    () => [
-      {
-        id: "contract",
-        header: () => <span className={bookingTable.headerCell}>Customer</span>,
-        cell: ({ row }) => {
-          const c = row.original;
-          return (
-            <div className="flex items-center gap-3 py-1.5">
-              <div className={bookingTable.rowIcon}>
-                <User className="size-4" strokeWidth={1.75} />
-              </div>
-              <div className="min-w-0">
-                <p className="truncate font-medium text-foreground">
-                  {c.customerLabel}
-                </p>
-                <p className="mt-0.5 flex items-center gap-1 truncate text-xs text-muted-foreground">
-                  <FileText className="size-3 shrink-0 opacity-70" />
-                  {c.reference}
-                </p>
-              </div>
-            </div>
-          );
-        },
-      },
-      {
-        id: "route",
-        header: () => <span className={bookingTable.headerCell}>Route</span>,
-        cell: ({ row }) => {
-          const c = row.original;
-          return (
-            <div className="space-y-1 py-1">
-              <div className="flex items-center gap-1.5 text-sm font-medium text-foreground">
-                <span className="max-w-[8rem] truncate">{c.originLabel}</span>
-                <ArrowRight className="size-3.5 shrink-0 text-muted-foreground" />
-                <span className="max-w-[8rem] truncate">
-                  {c.destinationLabel}
-                </span>
-              </div>
-              <div className="flex gap-1.5">
-                <Badge
-                  variant="outline"
-                  className="h-5 border-border/50 bg-background/50 px-1.5 text-[10px] font-medium uppercase backdrop-blur-sm"
-                >
-                  {directionLabel(c.tradeDirection)}
-                </Badge>
-                <Badge
-                  variant="secondary"
-                  className="h-5 bg-muted/40 px-1.5 text-[10px] font-medium"
-                >
-                  {c.freightType}
-                </Badge>
-              </div>
-            </div>
-          );
-        },
-      },
-      {
-        id: "kind",
-        header: () => <span className={bookingTable.headerCell}>Kind</span>,
-        cell: ({ row }) => (
-          <Badge
-            variant="outline"
-            className="h-5 border-border/50 bg-background/50 px-1.5 text-[10px] font-medium uppercase"
-          >
-            {row.original.contractKind === "GENERAL" ? (
-              <span className="inline-flex items-center gap-1">
-                <Repeat className="size-3" /> General
-              </span>
-            ) : (
-              "One-time"
-            )}
-          </Badge>
-        ),
-      },
-      {
-        id: "status",
-        size: 200,
-        minSize: 180,
-        header: () => <span className={bookingTable.headerCell}>Status</span>,
-        cell: ({ row }) => (
-          <div className="py-1">
-            <ContractStatusBadge
-              status={row.original.status}
-              isRenewal={row.original.isRenewal}
-            />
-          </div>
-        ),
-        meta: {
-          headerClassName: "min-w-[11rem]",
-          cellClassName: "min-w-[11rem]",
-        },
-      },
-    ],
-    [],
-  );
+  const bookingRows = bookingsQuery.data?.items ?? [];
 
   const bookingColumns: ColumnDef<BookingDetail>[] = useMemo(
     () => [
@@ -335,39 +161,29 @@ export default function ClearanceDocumentsPage() {
     [],
   );
 
-  const isContracts = hubTab === "contracts";
-  const activeQuery = isContracts ? contractsQuery : generalQuery;
-  const total = activeQuery.data?.total ?? 0;
+  const total = bookingsQuery.data?.total ?? 0;
   const pageCount = Math.max(1, Math.ceil(total / PAGE_SIZE));
   const showEmpty =
-    !activeQuery.isLoading &&
-    !activeQuery.isError &&
-    (isContracts ? contractRows.length : bookingRows.length) === 0;
-  const tableStatus = activeQuery.isLoading
+    !bookingsQuery.isLoading && !bookingsQuery.isError && bookingRows.length === 0;
+  const tableStatus = bookingsQuery.isLoading
     ? "loading"
-    : activeQuery.isError
+    : bookingsQuery.isError
       ? "error"
       : "success";
 
-  const statusOptions = isContracts
-    ? CONTRACT_STATUS_OPTIONS
-    : BOOKING_STATUS_OPTIONS;
-  const statusValue = isContracts ? contractStatuses : bookingStatuses;
-  const setStatusValue = isContracts ? setContractStatuses : setBookingStatuses;
-
   return (
     <PageContainer>
       <Stack gap="lg">
         <PageHeader
           title="Clearance Documents"
-          subtitle="Operations review of customer clearance documents for contracts without customs clearing."
+          subtitle="Operations review of the clearance documents customers upload on their shipments (services without customs clearing)."
           action={
             <ActionIcon
               variant="default"
               size="lg"
               radius="md"
-              loading={activeQuery.isFetching}
-              onClick={() => void activeQuery.refetch()}
+              loading={bookingsQuery.isFetching}
+              onClick={() => void bookingsQuery.refetch()}
               aria-label="Refresh"
             >
               <RefreshCw size={16} />
@@ -375,29 +191,12 @@ export default function ClearanceDocumentsPage() {
           }
         />
 
-        <Tabs
-          value={hubTab}
-          onChange={(v) => {
-            setHubTab((v as HubTab) ?? "contracts");
-            resetPage();
-          }}
-        >
-          <Tabs.List>
-            <Tabs.Tab value="contracts">Contracts</Tabs.Tab>
-            <Tabs.Tab value="general">General</Tabs.Tab>
-          </Tabs.List>
-        </Tabs>
-
         <Card p={0}>
           <Stack gap={0}>
             <Box px="md" pt="md" pb="sm" w="100%">
               <Group justify="space-between" gap="md" wrap="wrap">
                 <TextInput
-                  placeholder={
-                    isContracts
-                      ? "Search reference or customer…"
-                      : "Search booking, contract or customer…"
-                  }
+                  placeholder="Search booking, contract or customer…"
                   leftSection={<Search size={18} />}
                   value={query}
                   onChange={(e) => {
@@ -424,10 +223,10 @@ export default function ClearanceDocumentsPage() {
                   radius="lg"
                 />
                 <Select
-                  data={statusOptions}
-                  value={statusValue}
+                  data={BOOKING_STATUS_OPTIONS}
+                  value={bookingStatuses}
                   onChange={(v) => {
-                    setStatusValue(v ?? statusOptions[0].value);
+                    setBookingStatuses(v ?? BOOKING_STATUS_OPTIONS[0].value);
                     resetPage();
                   }}
                   allowDeselect={false}
@@ -446,61 +245,36 @@ export default function ClearanceDocumentsPage() {
                 <ThemeIcon variant="light" color="gray" radius="xl" size={48}>
                   <Inbox size={22} />
                 </ThemeIcon>
-                <Text c="dimmed">
-                  No {isContracts ? "contracts" : "bookings"} match this view.
-                </Text>
+                <Text c="dimmed">No shipments match this view.</Text>
               </Stack>
             ) : (
               <Box style={{ overflowX: "auto" }} w="100%">
-                {isContracts ? (
-                  <DataTable
-                    columns={contractColumns}
-                    data={contractRows}
-                    status={tableStatus}
-                    onRowClick={(row) =>
-                      navigate(
-                        `/dashboard/contracts/clearance-documents/${row.id}`,
-                      )
-                    }
-                    pagination={{
-                      pageIndex: pagination.pageIndex,
-                      pageSize: pagination.pageSize,
-                      pageCount,
-                      totalCount: total,
-                    }}
-                    tableOptions={{
-                      state: { pagination },
-                      onPaginationChange: setPagination,
-                      manualPagination: true,
-                      pageCount,
-                    }}
-                    containerClassName="border-0 shadow-none bg-transparent"
-                    footer={DataTableFooter}
-                  />
-                ) : (
-                  <DataTable
-                    columns={bookingColumns}
-                    data={bookingRows}
-                    status={tableStatus}
-                    onRowClick={(row) =>
-                      navigate(`/dashboard/clearance/${row.id}`)
-                    }
-                    pagination={{
-                      pageIndex: pagination.pageIndex,
-                      pageSize: pagination.pageSize,
-                      pageCount,
-                      totalCount: total,
-                    }}
-                    tableOptions={{
-                      state: { pagination },
-                      onPaginationChange: setPagination,
-                      manualPagination: true,
-                      pageCount,
-                    }}
-                    containerClassName="border-0 shadow-none bg-transparent"
-                    footer={DataTableFooter}
-                  />
-                )}
+                <DataTable
+                  columns={bookingColumns}
+                  data={bookingRows}
+                  status={tableStatus}
+                  // `from` so the detail page's Back returns to THIS hub, not
+                  // to whichever worklist the fallback would guess.
+                  onRowClick={(row) =>
+                    navigate(`/dashboard/clearance/${row.id}`, {
+                      state: { from: "/dashboard/contracts/clearance-documents" },
+                    })
+                  }
+                  pagination={{
+                    pageIndex: pagination.pageIndex,
+                    pageSize: pagination.pageSize,
+                    pageCount,
+                    totalCount: total,
+                  }}
+                  tableOptions={{
+                    state: { pagination },
+                    onPaginationChange: setPagination,
+                    manualPagination: true,
+                    pageCount,
+                  }}
+                  containerClassName="border-0 shadow-none bg-transparent"
+                  footer={DataTableFooter}
+                />
               </Box>
             )}
           </Stack>
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 eea92f295..3d1e20bb6 100644
--- a/apps/edr-freight-web/backoffice/src/pages/contracts/ContractClearanceListPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/contracts/ContractClearanceListPage.tsx
@@ -1,12 +1,4 @@
-import { directionLabel } from "@/lib/utils";
-import {
-  Fragment,
-  useCallback,
-  useEffect,
-  useMemo,
-  useState,
-  type ReactNode,
-} from "react";
+import { useCallback, useMemo, useState } from "react";
 import { useNavigate } from "react-router-dom";
 import {
   ActionIcon,
@@ -16,7 +8,6 @@ import {
   Card,
   Group,
   Menu,
-  SegmentedControl,
   Stack,
   Text,
   TextInput,
@@ -26,38 +17,32 @@ import {
 import {
   ArrowRight,
   Calendar,
-  ChevronRight,
   ExternalLink,
   Eye,
   FileText,
   Inbox,
-  LayoutGrid,
   MoreHorizontal,
   PackageCheck,
   PackagePlus,
   RefreshCw,
   Search,
   ShieldCheck,
-  ShipWheel,
-  Table as TableIcon,
-  Truck,
   User,
   X,
 } from "lucide-react";
 import {
   DataTable,
-  DataTableFooter,
   usePagination,
   type ColumnDef,
 } from "@edr/ui-common";
 import type { Freight } from "@edr/types";
+import { useQuery } from "@tanstack/react-query";
 
 import { PageContainer } from "@/components/page/PageContainer";
 import { PageHeader } from "@/components/page/PageHeader";
 import { KpiStrip } from "@/components/page/KpiStrip";
 import { bookingTable } from "@/components/bookings/booking-ui.styles";
 import { useAuth } from "@/auth/useAuth";
-import { useContractClearanceQueue } from "@/hooks/contracts/useContracts";
 import { useBookingEtClearanceQueue } from "@/hooks/bookings/useBookings";
 import type { BookingDetail } from "@/types/booking";
 import { FREIGHT_PERMS, hasPermission, isDjiboutiGl } from "@/lib/permissions";
@@ -67,99 +52,6 @@ import {
   summarizeRequestedCargo,
 } from "@/features/clearance/requestedCargo";
 import { contractsService } from "@/services/contracts.service";
-import { useQuery } from "@tanstack/react-query";
-
-type ViewMode = "table" | "cards";
-type QueueTab = "all" | "shipments";
-
-/** Persist the selected queue tab so returning from a detail keeps it. */
-const QUEUE_TAB_STORAGE_KEY = "edr.clearance.queueTab";
-
-interface ClearanceRow {
-  id: string;
-  reference: string;
-  customerLabel: string;
-  tradeDirection: string;
-  freightType: string;
-  originLabel: string;
-  destinationLabel: string;
-  /** Full ordered corridor across the contract's route legs (origin → … → destination). */
-  routeStops: string[];
-  contractKind: string;
-  serviceTypeName: string;
-  customs: boolean;
-  status: string;
-  /** true once GL has finalized clearance — customer may book in the portal. */
-  ready: boolean;
-  /** true once GL Ethiopia created the shipment booking. */
-  bookingCreated: boolean;
-  /** true when the created booking EXPIRED unpaid — GL must rebook. */
-  paymentExpired: boolean;
-  /** The expired booking, so rebook can copy its cargo. */
-  expiredBookingId: string | null;
-}
-
-function yardLabel(
-  yard?: { label?: string; code?: string; name?: string } | null,
-  fallback = "—",
-): string {
-  if (!yard) return fallback;
-  return yard.label ?? yard.name ?? yard.code ?? fallback;
-}
-
-/**
- * Chain the contract's ordered route legs into one corridor of stops —
- * origin of the first leg, then each leg's destination (Djibouti → Adama →
- * Dire Dawa). A leg whose origin differs from the previous destination inserts
- * that stop too, so gapped route lists stay readable.
- */
-function contractRouteStops(routes: Freight.IContractRoute[]): string[] {
-  const stops: string[] = [];
-  for (const r of routes) {
-    const origin = yardLabel(r.originYard);
-    const destination = yardLabel(r.destinationYard);
-    if (stops.length === 0 || stops[stops.length - 1] !== origin) {
-      stops.push(origin);
-    }
-    stops.push(destination);
-  }
-  return stops;
-}
-
-function toClearanceRow(contract: Freight.IContract): ClearanceRow {
-  const routes = [...(contract.routes ?? [])].sort(
-    (a, b) => a.sortOrder - b.sortOrder,
-  );
-  const first = routes[0];
-  const last = routes[routes.length - 1] ?? first;
-  return {
-    id: contract.id,
-    reference: contract.reference,
-    // The queue joins the company relation — show its name, never the raw uuid.
-    customerLabel: contract.isGovernment
-      ? (contract.governmentInstitution ?? "Government")
-      : (contract.company?.name ?? "—"),
-    tradeDirection: contract.tradeDirection ?? "—",
-    freightType: contract.freightType ?? "—",
-    originLabel: yardLabel(first?.originYard),
-    destinationLabel: yardLabel(last?.destinationYard),
-    routeStops: contractRouteStops(routes),
-    contractKind: contract.contractKind,
-    serviceTypeName: contract.serviceType?.serviceName ?? "—",
-    customs:
-      contract.serviceType?.includesCustoms ?? contract.customsClearingEnabled,
-    status: contract.status,
-    ready: contract.status === "CLEARANCE_READY_FOR_BOOKING",
-    bookingCreated: contract.status === "ACTIVE_SHIPMENT_IN_PROGRESS",
-    paymentExpired:
-      contract.status === "ACTIVE_SHIPMENT_IN_PROGRESS" &&
-      contract.latestCycleBookingStatus === "EXPIRED",
-    expiredBookingId:
-      contract.latestCycleBookingStatus === "EXPIRED"
-        ? (contract.latestCycleBookingId ?? null)
-        : null,
-  };
-}
 
 function CustomsBadge({ customs }: { customs: boolean }) {
   return customs ? (
@@ -179,199 +71,32 @@ function CustomsBadge({ customs }: { customs: boolean }) {
   );
 }
 
-function DirectionIcon({ direction }: { direction: string }) {
-  const isImport = direction === "IMPORT";
-  const Icon = isImport ? Truck : ShipWheel;
-  const label = directionLabel(direction);
-  return (
-    <Tooltip label={label} withArrow>
-      <ThemeIcon
-        variant="light"
-        color={isImport ? "edr-green" : "gray"}
-        radius="md"
-        size={28}
-        aria-label={label}
-      >
-        <Icon size={15} strokeWidth={1.9} />
-      </ThemeIcon>
-    </Tooltip>
-  );
-}
-
-function StatusBadge({ row }: { row: ClearanceRow }) {
-  // Terminal contracts stay listed as history — badge the terminal state
-  // instead of falling through to "Under review".
-  if (["EXPIRED", "CANCELLED", "REJECTED"].includes(row.status)) {
-    return (
-      <Tooltip
-        label="This contract is no longer active — kept here for clearance history."
-        withArrow
-      >
-        <Badge
-          size="sm"
-          variant="light"
-          color={row.status === "EXPIRED" ? "orange" : "red"}
-          radius="sm"
-        >
-          {row.status === "EXPIRED"
-            ? "Contract expired"
-            : row.status === "CANCELLED"
-              ? "Cancelled"
-              : "Rejected"}
-        </Badge>
-      </Tooltip>
-    );
-  }
-  if (row.paymentExpired) {
-    return (
-      <Tooltip
-        label="The customer did not pay in time — the booking expired. GL rebooks on the customer's behalf."
-        withArrow
-      >
-        <Badge
-          size="sm"
-          variant="light"
-          color="orange"
-          radius="sm"
-          leftSection={<RefreshCw size={12} />}
-        >
-          Payment expired
-        </Badge>
-      </Tooltip>
-    );
-  }
-  if (row.bookingCreated) {
-    return (
-      <Tooltip label="GL Ethiopia created the shipment booking" withArrow>
-        <Badge
-          size="sm"
-          variant="light"
-          color="blue"
-          radius="sm"
-          leftSection={<PackagePlus size={12} />}
-        >
-          Booking created
-        </Badge>
-      </Tooltip>
-    );
-  }
-  if (row.ready) {
-    return (
-      <Tooltip
-        label="Document approval finalized — the customer creates the booking in the portal"
-        withArrow
-      >
-        <Badge
-          size="sm"
-          variant="light"
-          color="edr-green"
-          radius="sm"
-          leftSection={<PackageCheck size={12} />}
-        >
-          Documents approved
-        </Badge>
-      </Tooltip>
-    );
-  }
-  return (
-    <Badge size="sm" variant="light" color="yellow" radius="sm">
-      Under review
-    </Badge>
-  );
-}
-
 /**
- * Document Clearance hub. Lists every customs (Path B) contract in phased clearance,
- * including after booking is created — stays visible for reference and follow-up.
+ * Document Clearance hub (GL Ethiopia). Clearance always runs on the SHIPMENT:
+ * every row here is a booking instance in phased customs clearance, whatever
+ * kind of contract it draws on. The "Start shipment" dialog (and its
+ * awaiting-shipment contract list) was removed — shipments are opened from the
+ * contract itself, not from this hub.
  */
 export default function ContractClearanceListPage() {
   const navigate = useNavigate();
   const { user } = useAuth();
-  const canReview = hasPermission(user, FREIGHT_PERMS.contracts.clearanceReview);
-  const canEt = hasPermission(user, FREIGHT_PERMS.contracts.clearanceEtActions);
-  // Creating a booking under a cleared contract is a GL Ethiopia action — never
+  // Opening/creating a booking under a contract is a GL Ethiopia action — never
   // available to Djibouti GL.
   const canCreateBooking =
     hasPermission(user, FREIGHT_PERMS.contracts.createBooking) &&
     !isDjiboutiGl(user);
 
-  const defaultQueue: QueueTab = canReview ? "all" : "shipments";
-  const [queueTab, setQueueTab] = useState<QueueTab>(() => {
-    const stored =
-      typeof window !== "undefined"
-        ? window.localStorage.getItem(QUEUE_TAB_STORAGE_KEY)
-        : null;
-    return stored === "all" || stored === "shipments" ? stored : defaultQueue;
-  });
   const [query, setQuery] = useState("");
-  const [view, setView] = useState<ViewMode>("table");
   const { pagination, setPagination } = usePagination({ pageSize: 10 });
 
-  const selectQueueTab = useCallback((tab: QueueTab) => {
-    setQueueTab(tab);
-    if (typeof window !== "undefined") {
-      window.localStorage.setItem(QUEUE_TAB_STORAGE_KEY, tab);
-    }
-  }, []);
-
-  // Contract clearance rows feed both the Contracts tab and the header KPIs, so
-  // they load regardless of the active tab.
-  const { data: allData, isLoading: allLoading, isError: allError, isFetching: allFetching, refetch: refetchAll } =
-    useContractClearanceQueue(true);
   const {
     data: bookingQueue,
-    isLoading: bookingsLoading,
-    isError: bookingsError,
-    isFetching: bookingsFetching,
-    refetch: refetchBookings,
-  } = useBookingEtClearanceQueue(queueTab === "shipments");
-
-  const data = allData;
-  const isLoading = queueTab === "shipments" ? bookingsLoading : allLoading;
-  const isError = queueTab === "shipments" ? bookingsError : allError;
-  const isFetching = queueTab === "shipments" ? bookingsFetching : allFetching;
-  const refetch = () => {
-    if (queueTab === "shipments") void refetchBookings();
-    else void refetchAll();
-  };
-
-  const queueTabOptions = useMemo(() => {
-    const opts: { value: QueueTab; label: ReactNode }[] = [];
-    if (canReview) {
-      opts.push({
-        value: "all",
-        label: (
-          <Group gap={6} wrap="nowrap">
-            <FileText size={15} />
-            <Box visibleFrom="sm">Contracts</Box>
-          </Group>
-        ),
-      });
-    }
-    if (canReview || canEt) {
-      opts.push({
-        value: "shipments",
-        label: (
-          <Group gap={6} wrap="nowrap">
-            <PackageCheck size={15} />
-            <Box visibleFrom="sm">Shipments</Box>
-          </Group>
-        ),
-      });
-    }
-    return opts;
-  }, [canReview, canEt]);
-
-  // If a persisted/default tab isn't available for this user, fall back to the
-  // first permitted tab.
-  useEffect(() => {
-    if (
-      queueTabOptions.length > 0 &&
-      !queueTabOptions.some((o) => o.value === queueTab)
-    ) {
-      selectQueueTab(queueTabOptions[0].value);
-    }
-  }, [queueTabOptions, queueTab, selectQueueTab]);
+    isLoading,
+    isError,
+    isFetching,
+    refetch,
+  } = useBookingEtClearanceQueue(true);
 
   // Shipment requests carry the requested quantities (per container type, or
   // bulk weight/items). Map them onto the booking rows by createdBookingId so
@@ -379,7 +104,6 @@ export default function ContractClearanceListPage() {
   const { data: requestQueue } = useQuery({
     queryKey: ["shipment-request-queue"],
     queryFn: () => contractsService.getBookingRequestQueue(),
-    enabled: queueTab === "shipments",
   });
   const requestedByBooking = useMemo(() => {
     const map = new Map<string, Freight.RequestedShipmentLines>();
@@ -389,9 +113,8 @@ export default function ContractClearanceListPage() {
     return map;
   }, [requestQueue]);
 
-  // GENERAL-contract shipment bookings in per-booking clearance.
-  const bookingRows = useMemo(() => {
-    const rows: ShipmentBookingRow[] = (bookingQueue ?? []).map((b: BookingDetail) => ({
+  const allRows = useMemo(() => {
+    return (bookingQueue ?? []).map((b: BookingDetail) => ({
       id: b.id,
       reference: b.reference,
       customerLabel: b.company?.name ?? b.governmentInstitution ?? "—",
@@ -406,37 +129,11 @@ export default function ContractClearanceListPage() {
       contractKind: b.contractKind ?? null,
       customs: b.serviceType?.includesCustoms ?? Boolean(b.customsClearingEnabled),
       createdAt: b.createdAt ?? null,
-      // A bare initiated instance has no cargo/price yet — GL still has to create
-      // (complete) the booking.
+      // A bare initiated instance has no cargo/price yet — GL still has to
+      // create (complete) the booking.
       bookingCreated: Number(b.totalAmount ?? 0) > 0,
-    }));
-    const q = query.trim().toLowerCase();
-    if (!q) return rows;
-    return rows.filter(
-      (r) =>
-        r.reference.toLowerCase().includes(q) ||
-        r.customerLabel.toLowerCase().includes(q) ||
-        (r.contractReference ?? "").toLowerCase().includes(q) ||
-        r.originLabel.toLowerCase().includes(q) ||
-        r.destinationLabel.toLowerCase().includes(q) ||
-        summarizeRequestedCargo(r.requested).toLowerCase().includes(q),
-    );
-  }, [bookingQueue, query, requestedByBooking]);
-
-  const allRows = useMemo(
-    () => (data?.items ?? []).map(toClearanceRow),
-    [data?.items],
-  );
-
-  const counts = useMemo(
-    () => ({
-      all: allRows.length,
-      ready: allRows.filter((r) => r.ready).length,
-      booked: allRows.filter((r) => r.bookingCreated).length,
-      review: allRows.filter((r) => !r.ready && !r.bookingCreated).length,
-    }),
-    [allRows],
-  );
+    })) as ShipmentBookingRow[];
+  }, [bookingQueue, requestedByBooking]);
 
   const rows = useMemo(() => {
     const q = query.trim().toLowerCase();
@@ -445,163 +142,33 @@ export default function ContractClearanceListPage() {
       (r) =>
         r.reference.toLowerCase().includes(q) ||
         r.customerLabel.toLowerCase().includes(q) ||
+        (r.contractReference ?? "").toLowerCase().includes(q) ||
         r.originLabel.toLowerCase().includes(q) ||
-        r.destinationLabel.toLowerCase().includes(q),
+        r.destinationLabel.toLowerCase().includes(q) ||
+        summarizeRequestedCargo(r.requested).toLowerCase().includes(q),
     );
   }, [allRows, query]);
 
-  const total = queueTab === "shipments" ? bookingRows.length : rows.length;
-  const pageCount = Math.max(1, Math.ceil(total / pagination.pageSize));
-
-  const pagedRows = useMemo(() => {
-    const start = pagination.pageIndex * pagination.pageSize;
-    return rows.slice(start, start + pagination.pageSize);
-  }, [rows, pagination.pageIndex, pagination.pageSize]);
-
-  const openDetail = useCallback(
-    (id: string) => navigate(`/dashboard/contracts/clearance/${id}`),
-    [navigate],
+  const counts = useMemo(
+    () => ({
+      all: allRows.length,
+      review: allRows.filter(
+        (r) => r.status === "AWAITING_DOCUMENTS" || r.status === "DOCUMENTS_UNDER_REVIEW",
+      ).length,
+      ready: allRows.filter((r) => r.status === "CLEARANCE_READY" || r.bookingCreated)
+        .length,
+    }),
+    [allRows],
   );
 
-  const columns: ColumnDef<ClearanceRow>[] = useMemo(
-    () => [
-      {
-        id: "contract",
-        header: () => <span className={bookingTable.headerCell}>Contract</span>,
-        cell: ({ row }) => {
-          const r = row.original;
-          return (
-            <div className="flex items-center gap-3 py-1.5">
-              <div className={bookingTable.rowIcon}>
-                <ShieldCheck className="size-4" strokeWidth={1.75} />
-              </div>
-              <div className="min-w-0">
-                <p className="truncate font-medium text-foreground">
-                  {r.reference}
-                </p>
-                <p className="mt-0.5 flex items-center gap-1 truncate text-xs text-muted-foreground">
-                  <User className="size-3 shrink-0 opacity-70" />
-                  {r.customerLabel}
-                </p>
-              </div>
-            </div>
-          );
-        },
-      },
-      {
-        id: "route",
-        header: () => <span className={bookingTable.headerCell}>Route</span>,
-        cell: ({ row }) => {
-          const r = row.original;
-          return (
-            <Stack gap={4} py={2}>
-              <Group gap={6} wrap="wrap">
-                {(r.routeStops.length >= 2
-                  ? r.routeStops
-                  : [r.originLabel, r.destinationLabel]
-                ).map((stop, i) => (
-                  <Fragment key={i}>
-                    {i > 0 ? (
-                      <ArrowRight
-                        size={14}
-                        className="shrink-0 text-muted-foreground"
-                      />
-                    ) : null}
-                    <Text size="sm" fw={500}>
-                      {stop}
-                    </Text>
-                  </Fragment>
-                ))}
-              </Group>
-              <Group gap={8} align="center">
-                <DirectionIcon direction={r.tradeDirection} />
-                <Badge size="xs" variant="default" radius="sm">
-                  {r.freightType}
-                </Badge>
-              </Group>
-            </Stack>
-          );
-        },
-      },
-      {
-        id: "kind",
-        header: () => <span className={bookingTable.headerCell}>Kind</span>,
-        cell: ({ row }) => (
-          <Badge size="xs" variant="default" radius="sm" tt="uppercase">
-            {row.original.contractKind === "GENERAL" ? "General" : "One-time"}
-          </Badge>
-        ),
-      },
-      {
-        id: "service",
-        header: () => <span className={bookingTable.headerCell}>Service</span>,
-        cell: ({ row }) => {
-          const r = row.original;
-          return (
-            <Stack gap={4} py={2} style={{ minWidth: 0 }}>
-              <Text size="sm" fw={500} truncate maw={160}>
-                {r.serviceTypeName}
-              </Text>
-              <CustomsBadge customs={r.customs} />
-            </Stack>
-          );
-        },
-      },
-      {
-        id: "status",
-        header: () => <span className={bookingTable.headerCell}>Status</span>,
-        cell: ({ row }) => <StatusBadge row={row.original} />,
-      },
-      {
-        id: "go",
-        size: 150,
-        cell: ({ row }) =>
-          row.original.ready && canCreateBooking ? (
-            <Group justify="flex-end" pr="xs">
-              <Button
-                size="compact-sm"
-                color="edr-green"
-                radius="md"
-                leftSection={<PackagePlus size={14} />}
-                onClick={(e) => {
-                  e.stopPropagation();
-                  navigate(
-                    `/dashboard/contracts/${row.original.id}/create-booking`,
-                  );
-                }}
-              >
-                Create booking
-              </Button>
-            </Group>
-          ) : row.original.paymentExpired && canCreateBooking ? (
-            <Group justify="flex-end" pr="xs">
-              <Button
-                size="compact-sm"
-                color="grape"
-                radius="md"
-                leftSection={<RefreshCw size={14} />}
-                onClick={(e) => {
-                  e.stopPropagation();
-                  navigate(
-                    `/dashboard/contracts/${row.original.id}/create-booking${
-                      row.original.expiredBookingId
-                        ? `?copyFrom=${row.original.expiredBookingId}`
-                        : ""
-                    }`,
-                  );
-                }}
-              >
-                Rebook
-              </Button>
-            </Group>
-          ) : (
-            <Group justify="flex-end" pr="xs">
-              <ChevronRight size={16} className="text-muted-foreground" />
-            </Group>
-          ),
-      },
-    ],
-    [navigate, canCreateBooking],
+
+  const openBooking = useCallback(
+    // `from` so the detail page's Back returns to this hub.
+    (id: string) =>
+      navigate(`/dashboard/clearance/${id}`, {
+        state: { from: "/dashboard/contracts/clearance" },
+      }),
+    [navigate],
   );
 
   return (
@@ -609,7 +176,7 @@ export default function ContractClearanceListPage() {
       <Stack gap="lg">
         <PageHeader
           title="Document Clearance"
-          subtitle="All customs contracts in phased clearance — stays visible after booking is created."
+          subtitle="Every customs shipment in phased clearance — the documents live on the shipment, not on the contract."
           meta={
             <Badge
               variant="light"
@@ -621,16 +188,18 @@ export default function ContractClearanceListPage() {
             </Badge>
           }
           action={
-            <ActionIcon
-              variant="default"
-              size="lg"
-              radius="md"
-              onClick={() => refetch()}
-              loading={isFetching}
-              aria-label="Refresh"
-            >
-              <RefreshCw size={16} />
-            </ActionIcon>
+            <Group gap="sm" wrap="nowrap">
+              <ActionIcon
+                variant="default"
+                size="lg"
+                radius="md"
+                onClick={() => void refetch()}
+                loading={isFetching}
+                aria-label="Refresh"
+              >
+                <RefreshCw size={16} />
+              </ActionIcon>
+            </Group>
           }
         />
 
@@ -651,7 +220,7 @@ export default function ContractClearanceListPage() {
             },
             {
               label: "Ready / booked",
-              value: counts.ready + counts.booked,
+              value: counts.ready,
               icon: PackageCheck,
               color: "edr-green",
             },
@@ -662,32 +231,15 @@ export default function ContractClearanceListPage() {
 
         <Card p={0} withBorder shadow="sm" radius="lg">
           <Stack gap={0}>
-            {queueTabOptions.length > 1 ? (
-              <Box px="md" pt="md">
-                <SegmentedControl
-                  size="sm"
-                  radius="md"
-                  value={queueTab}
-                  onChange={(v) => {
-                    selectQueueTab(v as QueueTab);
-                    setPagination({ pageIndex: 0, pageSize: pagination.pageSize });
-                  }}
-                  data={queueTabOptions}
-                />
-              </Box>
-            ) : null}
             <Box px="md" pt="md" pb="sm">
               <Group justify="space-between" gap="md" wrap="wrap">
                 <TextInput
-                  placeholder="Search reference, customer, or route…"
+                  placeholder="Search shipment, contract, customer or route…"
                   leftSection={<Search size={18} />}
                   value={query}
                   onChange={(e) => {
                     setQuery(e.currentTarget.value);
-                    setPagination({
-                      pageIndex: 0,
-                      pageSize: pagination.pageSize,
-                    });
+                    setPagination({ pageIndex: 0, pageSize: pagination.pageSize });
                   }}
                   rightSection={
                     query ? (
@@ -705,100 +257,39 @@ export default function ContractClearanceListPage() {
                   radius="lg"
                   style={{ flex: 1, minWidth: 220 }}
                 />
-                <Group gap="sm" wrap="nowrap">
-                  <Text size="sm" c="dimmed">
-                    {total} record{total !== 1 ? "s" : ""}
-                  </Text>
-                  <SegmentedControl
-                    size="sm"
-                    radius="md"
-                    value={view}
-                    onChange={(v) => setView(v as ViewMode)}
-                    data={[
-                      {
-                        value: "table",
-                        label: (
-                          <Group gap={6} wrap="nowrap">
-                            <TableIcon size={15} />
-                            <Box visibleFrom="sm">Table</Box>
-                          </Group>
-                        ),
-                      },
-                      {
-                        value: "cards",
-                        label: (
-                          <Group gap={6} wrap="nowrap">
-                            <LayoutGrid size={15} />
-                            <Box visibleFrom="sm">Cards</Box>
-                          </Group>
-                        ),
-                      },
-                    ]}
-                  />
-                </Group>
+                <Text size="sm" c="dimmed">
+                  {rows.length} record{rows.length !== 1 ? "s" : ""}
+                </Text>
               </Group>
             </Box>
 
-            {queueTab === "shipments" ? (
-              <ShipmentBookingsTable
-                rows={bookingRows}
-                loading={bookingsLoading}
-                error={bookingsError}
-                canCreateBooking={canCreateBooking}
-                onOpen={(id) => navigate(`/dashboard/clearance/${id}`)}
-                onCreateBooking={(row) =>
-                  navigate(
-                    `/dashboard/contracts/${row.contractId}/bookings/${row.id}/complete`,
-                  )
-                }
-                onRebook={(row) =>
-                  // Re-complete the SAME expired booking (new day, same finished
-                  // per-booking clearance) — a fresh create-booking would spawn a
-                  // new instance and force the customer through clearance + fee
-                  // again.
-                  navigate(
-                    `/dashboard/contracts/${row.contractId}/bookings/${row.id}/complete?copyFrom=${row.id}`,
-                  )
-                }
-                onViewContract={(contractId) =>
-                  navigate(`/dashboard/contracts/clearance/${contractId}`)
-                }
-              />
-            ) : view === "table" ? (
-              <Box style={{ overflowX: "auto" }} px="xs" pb="xs">
-                <DataTable<ClearanceRow, unknown>
-                  columns={columns}
-                  data={pagedRows}
-                  status={
-                    isLoading ? "loading" : isError ? "error" : "success"
-                  }
-                  onRowClick={(row) => openDetail(row.id)}
-                  pagination={{
-                    pageIndex: pagination.pageIndex,
-                    pageSize: pagination.pageSize,
-                    pageCount,
-                    totalCount: total,
-                  }}
-                  tableOptions={{
-                    state: { pagination },
-                    onPaginationChange: setPagination,
-                    manualPagination: true,
-                    pageCount,
-                  }}
-                  containerClassName="border-0 shadow-none bg-transparent"
-                  footer={DataTableFooter}
-                />
-              </Box>
-            ) : (
-              <ClearanceCardGrid
-                rows={pagedRows}
-                loading={isLoading}
-                onOpen={openDetail}
-              />
-            )}
+            <ShipmentBookingsTable
+              rows={rows}
+              loading={isLoading}
+              error={isError}
+              canCreateBooking={canCreateBooking}
+              onOpen={openBooking}
+              onCreateBooking={(row) =>
+                navigate(
+                  `/dashboard/contracts/${row.contractId}/bookings/${row.id}/complete`,
+                )
+              }
+              onRebook={(row) =>
+                // Re-complete the SAME expired booking (new day, same finished
+                // per-booking clearance) — a fresh instance would force the
+                // customer through clearance + fee again.
+                navigate(
+                  `/dashboard/contracts/${row.contractId}/bookings/${row.id}/complete?copyFrom=${row.id}`,
+                )
+              }
+              onViewContract={(contractId) =>
+                navigate(`/dashboard/contracts/${contractId}`)
+              }
+            />
           </Stack>
         </Card>
       </Stack>
+
     </PageContainer>
   );
 }
@@ -1124,135 +615,3 @@ function ShipmentBookingsTable({
     </Box>
   );
 }
-
-function ClearanceCardGrid({
-  rows,
-  loading,
-  onOpen,
-}: {
-  rows: ClearanceRow[];
-  loading: boolean;
-  onOpen: (id: string) => void;
-}) {
-  if (loading) {
-    return (
-      <Box px="md" py="xl">
-        <Text c="dimmed" ta="center">
-          Loading…
-        </Text>
-      </Box>
-    );
-  }
-  if (rows.length === 0) {
-    return (
-      <Stack align="center" gap={8} py={48}>
-        <ThemeIcon variant="light" color="gray" radius="xl" size={48}>
-          <Inbox size={22} />
-        </ThemeIcon>
-        <Text c="dimmed">No contracts need customs clearance.</Text>
-      </Stack>
-    );
-  }
-  return (
-    <Box
-      px="md"
-      pb="md"
-      style={{
-        display: "grid",
-        gridTemplateColumns: "repeat(auto-fill, minmax(280px, 1fr))",
-        gap: "var(--mantine-spacing-md)",
-      }}
-    >
-      {rows.map((r) => (
-        <ClearanceCard key={r.id} row={r} onOpen={() => onOpen(r.id)} />
-      ))}
-    </Box>
-  );
-}
-
-function ClearanceCard({
-  row,
-  onOpen,
-}: {
-  row: ClearanceRow;
-  onOpen: () => void;
-}) {
-  return (
-    <Card
-      withBorder
-      shadow="sm"
-      radius="lg"
-      p="md"
-      onClick={onOpen}
-      role="button"
-      tabIndex={0}
-      onKeyDown={(e) => {
-        if (e.key === "Enter" || e.key === " ") {
-          e.preventDefault();
-          onOpen();
-        }
-      }}
-      style={{ cursor: "pointer", transition: "all 120ms ease" }}
-      className="hover:border-edr-green-4 hover:shadow-md"
-    >
-      <Group justify="space-between" align="flex-start" wrap="nowrap">
-        <Group gap={10} wrap="nowrap" style={{ minWidth: 0 }}>
-          <ThemeIcon variant="light" color="edr-green" radius="md" size={40}>
-            <FileText size={19} />
-          </ThemeIcon>
-          <Box style={{ minWidth: 0 }}>
-            <Text fw={700} size="sm" c="edr-text" truncate>
-              {row.reference}
-            </Text>
-            <Group gap={4} wrap="nowrap">
-              <User size={11} className="shrink-0 opacity-70" />
-              <Text size="xs" c="dimmed" truncate>
-                {row.customerLabel}
-              </Text>
-            </Group>
-          </Box>
-        </Group>
-        <StatusBadge row={row} />
-      </Group>
-
-      <Box
-        mt="md"
-        p="sm"
-        style={{
-          borderRadius: 12,
-          background: "var(--mantine-color-edr-card-6)",
-          border: "1px solid var(--mantine-color-edr-border-6)",
-        }}
-      >
-        <Group gap={8} wrap="nowrap" justify="center">
-          <Text size="sm" fw={600} truncate maw={130}>
-            {row.originLabel}
-          </Text>
-          <ArrowRight size={15} className="shrink-0 text-muted-foreground" />
-          <Text size="sm" fw={600} truncate maw={130}>
-            {row.destinationLabel}
-          </Text>
-        </Group>
-      </Box>
-
-      <Group justify="space-between" mt="md" wrap="nowrap">
-        <Group gap={8} wrap="nowrap">
-          <DirectionIcon direction={row.tradeDirection} />
-          <Badge size="xs" variant="default" radius="sm">
-            {row.freightType}
-          </Badge>
-        </Group>
-        <Badge size="xs" variant="default" radius="sm" tt="uppercase">
-          {row.contractKind === "GENERAL" ? "General" : "One-time"}
-        </Badge>
-      </Group>
-
-      <Group justify="space-between" mt={8} wrap="nowrap" gap={8}>
-        <Text size="xs" c="dimmed" truncate maw={150}>
-          {row.serviceTypeName}
-        </Text>
-        <CustomsBadge customs={row.customs} />
-      </Group>
-    </Card>
-  );
-}
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 4f1d2cb42..5ae66a51e 100644
--- a/apps/edr-freight-web/backoffice/src/pages/contracts/ContractRequestDetailPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/contracts/ContractRequestDetailPage.tsx
@@ -16,6 +16,7 @@ import {
   Flame,
   History,
   LayoutGrid,
+  Milestone,
   Package,
   Receipt,
   RefreshCw,
@@ -54,6 +55,7 @@ import { ContractApprovalStepsCard } from "@/components/contracts/ContractApprov
 import { HazardDeclarationPanel } from "@/components/contracts/HazardDeclarationPanel";
 import { ClearanceWorkflowFilesPanel } from "@/components/contracts/ClearanceWorkflowFilesPanel";
 import { ContractRevisionTimeline } from "@/components/contracts/ContractRevisionTimeline";
+import { ContractMilestonesTimeline } from "@/components/contracts/ContractMilestonesTimeline";
 import {
   ContractCustomerCard,
   ContractDocumentsCard,
@@ -110,6 +112,21 @@ function formatDate(value: string | null | undefined): string {
       });
 }
 
+/** Same, plus the clock — for values the staff pick to the minute. */
+function formatDateTime(value: string | null | undefined): string {
+  if (!value) return "—";
+  const d = new Date(value);
+  return Number.isNaN(d.getTime())
+    ? "—"
+    : d.toLocaleString(undefined, {
+        year: "numeric",
+        month: "short",
+        day: "numeric",
+        hour: "2-digit",
+        minute: "2-digit",
+      });
+}
+
 export default function ContractRequestDetailPage() {
   const { id } = useParams<{ id: string }>();
   const navigate = useNavigate();
@@ -370,7 +387,8 @@ export default function ContractRequestDetailPage() {
                 {contract.contractValidUntil ? (
                   <MetaItem
                     icon={CalendarClock}
-                    text={`Valid until ${formatDate(contract.contractValidUntil)}`}
+                    // Validity is accepted to the minute — show the time.
+                    text={`Valid until ${formatDateTime(contract.contractValidUntil)}`}
                   />
                 ) : null}
               </Group>
@@ -515,13 +533,22 @@ export default function ContractRequestDetailPage() {
                 ) : null}
               </Stack>
             ) : currentTab === "history" ? (
-              <SectionCard
-                icon={History}
-                title="Change history"
-                subtitle="Every recorded edit to this contract — who changed what, and when."
-              >
-                <ContractRevisionTimeline contractId={contract.id} bare />
-              </SectionCard>
+              <Stack gap="lg">
+                <SectionCard
+                  icon={Milestone}
+                  title="Key milestones"
+                  subtitle="Submission, approval, signatures and validity — the dated record of this contract."
+                >
+                  <ContractMilestonesTimeline contract={contract} />
+                </SectionCard>
+                <SectionCard
+                  icon={History}
+                  title="Change history"
+                  subtitle="Every recorded edit to this contract — who changed what, and when."
+                >
+                  <ContractRevisionTimeline contractId={contract.id} bare />
+                </SectionCard>
+              </Stack>
             ) : currentTab === "customer" ? (
               <ContractCustomerCard contract={contract} />
             ) : (
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 1a9352348..22d3b3fca 100644
--- a/apps/edr-freight-web/backoffice/src/pages/contracts/GlClearanceDetailPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/contracts/GlClearanceDetailPage.tsx
@@ -236,13 +236,15 @@ export default function GlClearanceDetailPage() {
           </Tabs.List>
 
           <Tabs.Panel value="workflow">
-            {/* GL Ethiopia cannot file the customs declaration until this desk
-                names the officer handling the shipment in transit, so the ask
-                sits above everything else on the page. */}
-            {data.kind === "contract" ? (
+            {/* GL Ethiopia cannot file the import customs declaration until this
+                desk names the officer handling the shipment in transit, so the
+                ask sits above everything else on the page. Exports have no such
+                gate — Djibouti's steps come after the declaration. */}
+            {isImport ? (
               <Box mb="md">
                 <TransitAssigneePanel
-                  contractId={id!}
+                  entityId={id!}
+                  isBooking={data.kind === "booking"}
                   transitAssignee={data.clearance.transitAssignee}
                   side="DJ"
                   readOnly={
diff --git a/apps/edr-freight-web/backoffice/src/pages/contracts/GlDjiboutiClearanceListPage.tsx b/apps/edr-freight-web/backoffice/src/pages/contracts/GlDjiboutiClearanceListPage.tsx
index c5c424e9a..c82cfd152 100644
--- a/apps/edr-freight-web/backoffice/src/pages/contracts/GlDjiboutiClearanceListPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/contracts/GlDjiboutiClearanceListPage.tsx
@@ -8,7 +8,6 @@ import {
   Button,
   Card,
   Group,
-  SegmentedControl,
   Select,
   Stack,
   Text,
@@ -21,14 +20,11 @@ import {
   ArrowRight,
   CalendarClock,
   ChevronRight,
-  FileSignature,
   FileText,
   Inbox,
   PackageCheck,
   RefreshCw,
   Search,
-  ShieldCheck,
-  Ship,
   ShipWheel,
   Truck,
   User,
@@ -41,18 +37,14 @@ import {
   usePagination,
   type ColumnDef,
 } from "@edr/ui-common";
-import type { Freight } from "@edr/types";
 
 import { PageContainer } from "@/components/page/PageContainer";
 import { PageHeader } from "@/components/page/PageHeader";
 import { KpiStrip } from "@/components/page/KpiStrip";
 import { bookingTable } from "@/components/bookings/booking-ui.styles";
-import { useDjClearanceQueue } from "@/hooks/contracts/useContracts";
 import { useBookingDjClearanceQueue } from "@/hooks/bookings/useBookings";
 import type { BookingDetail } from "@/types/booking";
 
-type QueueTab = "contracts" | "shipments";
-
 const prettyStatus = (s?: string | null) =>
   (s ?? "")
     .toLowerCase()
@@ -198,52 +190,6 @@ function toShipmentRow(b: BookingDetail): ShipmentRow {
   };
 }
 
-interface ContractRow {
-  id: string;
-  reference: string;
-  customerLabel: string;
-  originLabel: string;
-  destinationLabel: string;
-  tradeDirection: string;
-  freightType: string;
-  serviceTypeName: string;
-  customs: boolean;
-  status: string;
-  clearanceStatus: string;
-  phase: string | null;
-  cycleNumber: number;
-  validFrom: string | null;
-  validUntil: string | null;
-  validityDays: number | null;
-  estimatedShipmentDate: string | null;
-}
-
-function toContractRow(c: Freight.IContract): ContractRow {
-  const routes = [...(c.routes ?? [])].sort((a, b) => a.sortOrder - b.sortOrder);
-  const first = routes[0];
-  const last = routes[routes.length - 1] ?? first;
-  return {
-    id: c.id,
-    reference: c.reference,
-    customerLabel: c.isGovernment
-      ? (c.governmentInstitution ?? "Government")
-      : (c.company?.name ?? "—"),
-    originLabel: yardLabel(first?.originYard),
-    destinationLabel: yardLabel(last?.destinationYard),
-    tradeDirection: c.tradeDirection ?? "—",
-    freightType: c.freightType ?? "—",
-    serviceTypeName: c.serviceType?.serviceName ?? "—",
-    customs: c.serviceType?.includesCustoms ?? Boolean(c.customsClearingEnabled),
-    status: c.status,
-    clearanceStatus: c.clearanceStatus,
-    phase: (c.clearancePhase as string | null) ?? null,
-    cycleNumber: c.clearanceCycleNumber ?? 1,
-    validFrom: c.contractValidFrom ?? null,
-    validUntil: c.contractValidUntil ?? null,
-    validityDays: c.contractValidityDays ?? null,
-    estimatedShipmentDate: c.estimatedShipmentDate ?? null,
-  };
-}
 
 // ── Shared cell pieces ───────────────────────────────────────────────────────
 
@@ -301,15 +247,13 @@ function RouteCell({
 // ── Page ─────────────────────────────────────────────────────────────────────
 
 /**
- * GL Djibouti clearance queues:
- * - Contracts: ONE_TIME customs contracts in phased clearance (legacy flow).
- * - Shipments: GENERAL-contract bookings in per-booking clearance awaiting a DJ
- *   action (DO collection after ET finalizes pre-clearance, RO for exports,
- *   loading milestones). Managed like the one-time flow, but per booking.
+ * GL Djibouti clearance queue. Clearance runs per SHIPMENT — every booking in
+ * per-booking clearance awaiting a Djibouti action (DO collection after ET
+ * finalizes pre-clearance, RO for exports, loading milestones), whatever kind
+ * of contract it draws on.
  */
 export default function GlDjiboutiClearanceListPage() {
   const navigate = useNavigate();
-  const [tab, setTab] = useState<QueueTab>("shipments");
   const [query, setQuery] = useState("");
   const [direction, setDirection] = useState<string | null>(null);
   const [freight, setFreight] = useState<string | null>(null);
@@ -317,13 +261,6 @@ export default function GlDjiboutiClearanceListPage() {
   const [action, setAction] = useState<string | null>(null);
   const { pagination, setPagination } = usePagination({ pageSize: 10 });
 
-  const {
-    data: contractQueue,
-    isLoading: contractsLoading,
-    isError: contractsError,
-    isFetching: contractsFetching,
-    refetch: refetchContracts,
-  } = useDjClearanceQueue();
   const {
     data: bookingQueue,
     isLoading: bookingsLoading,
@@ -341,34 +278,26 @@ export default function GlDjiboutiClearanceListPage() {
     () => (bookingQueue ?? []).map(toShipmentRow),
     [bookingQueue],
   );
-  const allContractRows = useMemo(
-    () => (contractQueue?.items ?? []).map(toContractRow),
-    [contractQueue?.items],
-  );
-
-  // KPI metrics span both queues, regardless of active tab or filters.
+  // KPI metrics span the whole queue, regardless of filters.
   const metrics = useMemo(
     () => ({
       shipments: allShipmentRows.length,
-      contracts: allContractRows.length,
       collectDo: allShipmentRows.filter((r) => r.action.key === "COLLECT_DO")
         .length,
       issueRo: allShipmentRows.filter((r) => r.action.key === "ISSUE_RO").length,
       roHolds: allShipmentRows.filter((r) => r.action.key === "RO_HOLD").length,
     }),
-    [allShipmentRows, allContractRows],
+    [allShipmentRows],
   );
 
-  const statusOptions = useMemo(() => {
-    const source =
-      tab === "shipments"
-        ? allShipmentRows.map((r) => r.status)
-        : allContractRows.map((r) => r.status);
-    return [...new Set(source)].sort().map((s) => ({
-      value: s,
-      label: prettyStatus(s),
-    }));
-  }, [tab, allShipmentRows, allContractRows]);
+  const statusOptions = useMemo(
+    () =>
+      [...new Set(allShipmentRows.map((r) => r.status))].sort().map((s) => ({
+        value: s,
+        label: prettyStatus(s),
+      })),
+    [allShipmentRows],
+  );
 
   const matchesShared = useCallback(
     (
@@ -411,16 +340,10 @@ export default function GlDjiboutiClearanceListPage() {
     [allShipmentRows, action, matchesShared],
   );
 
-  const contractRows = useMemo(
-    () => allContractRows.filter((r) => matchesShared(r)),
-    [allContractRows, matchesShared],
-  );
-
-  const rows = tab === "shipments" ? shipmentRows : contractRows;
-  const isLoading = tab === "contracts" ? contractsLoading : bookingsLoading;
-  const isError = tab === "contracts" ? contractsError : bookingsError;
-  const isFetching = contractsFetching || bookingsFetching;
-  const total = rows.length;
+  const isLoading = bookingsLoading;
+  const isError = bookingsError;
+  const isFetching = bookingsFetching;
+  const total = shipmentRows.length;
   const pageCount = Math.max(1, Math.ceil(total / pagination.pageSize));
   const showEmpty = !isLoading && !isError && total === 0;
 
@@ -429,11 +352,6 @@ export default function GlDjiboutiClearanceListPage() {
     return shipmentRows.slice(start, start + pagination.pageSize);
   }, [shipmentRows, pagination.pageIndex, pagination.pageSize]);
 
-  const pagedContractRows = useMemo(() => {
-    const start = pagination.pageIndex * pagination.pageSize;
-    return contractRows.slice(start, start + pagination.pageSize);
-  }, [contractRows, pagination.pageIndex, pagination.pageSize]);
-
   const hasFilters = Boolean(query || direction || freight || status || action);
 
   const clearFilters = useCallback(() => {
@@ -446,9 +364,8 @@ export default function GlDjiboutiClearanceListPage() {
   }, [resetPage]);
 
   const handleRefresh = useCallback(() => {
-    void refetchContracts();
     void refetchBookings();
-  }, [refetchContracts, refetchBookings]);
+  }, [refetchBookings]);
 
   const openDetail = useCallback(
     (id: string) => navigate(`/dashboard/gl-djibouti/clearance/${id}`),
@@ -599,161 +516,12 @@ export default function GlDjiboutiClearanceListPage() {
     [],
   );
 
-  const contractColumns: ColumnDef<ContractRow>[] = useMemo(
-    () => [
-      {
-        id: "contract",
-        header: () => <span className={bookingTable.headerCell}>Contract</span>,
-        cell: ({ row }) => {
-          const r = row.original;
-          return (
-            <div className="flex items-center gap-3 py-1.5">
-              <div className={bookingTable.rowIcon}>
-                <Ship className="size-4" strokeWidth={1.75} />
-              </div>
-              <div className="min-w-0">
-                <p className="truncate font-medium text-foreground">
-                  {r.reference}
-                </p>
-                <p className="mt-0.5 flex items-center gap-1 truncate text-xs text-muted-foreground">
-                  <User className="size-3 shrink-0 opacity-70" />
-                  {r.customerLabel}
-                </p>
-              </div>
-            </div>
-          );
-        },
-      },
-      {
-        id: "route",
-        header: () => <span className={bookingTable.headerCell}>Route</span>,
-        cell: ({ row }) => {
-          const r = row.original;
-          return (
-            <RouteCell
-              origin={r.originLabel}
-              destination={r.destinationLabel}
-              direction={r.tradeDirection}
-              freightType={r.freightType}
-            />
-          );
-        },
-      },
-      {
-        id: "service",
-        header: () => <span className={bookingTable.headerCell}>Service</span>,
-        cell: ({ row }) => {
-          const r = row.original;
-          return (
-            <Stack gap={4} py={2} style={{ minWidth: 0 }}>
-              <Text size="sm" fw={500} truncate maw={160}>
-                {r.serviceTypeName}
-              </Text>
-              {r.customs ? (
-                <Badge
-                  size="xs"
-                  variant="light"
-                  color="edr-green"
-                  radius="sm"
-                  leftSection={<ShieldCheck size={11} />}
-                >
-                  Customs
-                </Badge>
-              ) : (
-                <Badge size="xs" variant="light" color="gray" radius="sm">
-                  No customs
-                </Badge>
-              )}
-            </Stack>
-          );
-        },
-      },
-      {
-        id: "clearance",
-        header: () => <span className={bookingTable.headerCell}>Clearance</span>,
-        cell: ({ row }) => {
-          const r = row.original;
-          return (
-            <Stack gap={4} py={2}>
-              <Badge
-                size="sm"
-                variant="light"
-                color={statusColor(r.clearanceStatus)}
-                radius="sm"
-              >
-                {prettyStatus(r.clearanceStatus)}
-              </Badge>
-              <Text size="xs" c="dimmed">
-                {phaseLabel(r.phase)}
-                {r.cycleNumber > 1 ? ` · Cycle ${r.cycleNumber}` : ""}
-              </Text>
-            </Stack>
-          );
-        },
-      },
-      {
-        id: "status",
-        header: () => <span className={bookingTable.headerCell}>Status</span>,
-        cell: ({ row }) => (
-          <Badge
-            size="sm"
-            variant="light"
-            color={statusColor(row.original.status)}
-            radius="sm"
-          >
-            {prettyStatus(row.original.status)}
-          </Badge>
-        ),
-      },
-      {
-        id: "validity",
-        header: () => <span className={bookingTable.headerCell}>Validity</span>,
-        cell: ({ row }) => {
-          const r = row.original;
-          return (
-            <Stack gap={2} py={2}>
-              <Group gap={6} wrap="nowrap">
-                <CalendarClock
-                  size={13}
-                  className="shrink-0 text-muted-foreground"
-                />
-                <Text size="sm" c="dimmed">
-                  {r.validUntil
-                    ? `Until ${formatDate(r.validUntil)}`
-                    : r.validityDays
-                      ? `${r.validityDays} days`
-                      : "—"}
-                </Text>
-              </Group>
-              {r.estimatedShipmentDate ? (
-                <Text size="xs" c="dimmed">
-                  Est. shipment {formatDate(r.estimatedShipmentDate)}
-                </Text>
-              ) : null}
-            </Stack>
-          );
-        },
-      },
-      {
-        id: "chevron",
-        size: 40,
-        header: "",
-        cell: () => (
-          <Group justify="flex-end" pr="xs">
-            <ChevronRight size={16} className="text-muted-foreground" />
-          </Group>
-        ),
-      },
-    ],
-    [],
-  );
-
   return (
     <PageContainer>
       <Stack gap="lg">
         <PageHeader
           title="GL Djibouti — Clearance"
-          subtitle="Customs contracts and shipment bookings handed off to Djibouti GL."
+          subtitle="Customs shipments handed off to Djibouti GL — every clearance step lives on the shipment."
           action={
             <ActionIcon
               variant="default"
@@ -769,7 +537,7 @@ export default function GlDjiboutiClearanceListPage() {
         />
 
         <KpiStrip
-          loading={contractsLoading || bookingsLoading}
+          loading={bookingsLoading}
           items={[
             {
               label: "Shipments in queue",
@@ -777,12 +545,6 @@ export default function GlDjiboutiClearanceListPage() {
               icon: PackageCheck,
               color: "blue",
             },
-            {
-              label: "Contracts in queue",
-              value: metrics.contracts,
-              icon: FileSignature,
-              color: "edr-green",
-            },
             {
               label: "Imports — collect DO",
               value: metrics.collectDo,
@@ -806,46 +568,6 @@ export default function GlDjiboutiClearanceListPage() {
 
         <Card p={0} withBorder shadow="sm" radius="lg">
           <Stack gap={0}>
-            <Box px="md" pt="md">
-              <SegmentedControl
-                size="sm"
-                value={tab}
-                onChange={(v) => {
-                  setTab(v as QueueTab);
-                  setStatus(null);
-                  setAction(null);
-                  resetPage();
-                }}
-                radius="md"
-                data={[
-                  {
-                    value: "shipments",
-                    label: (
-                      <Group gap={6} wrap="nowrap">
-                        <PackageCheck size={15} />
-                        <Box visibleFrom="sm">Shipments</Box>
-                        <Badge size="sm" radius="sm" variant="light" color="edr-green">
-                          {allShipmentRows.length}
-                        </Badge>
-                      </Group>
-                    ),
-                  },
-                  {
-                    value: "contracts",
-                    label: (
-                      <Group gap={6} wrap="nowrap">
-                        <FileSignature size={15} />
-                        <Box visibleFrom="sm">Contracts</Box>
-                        <Badge size="sm" radius="sm" variant="light" color="gray">
-                          {allContractRows.length}
-                        </Badge>
-                      </Group>
-                    ),
-                  },
-                ]}
-              />
-            </Box>
-
             <Box px="md" pt="md" pb="sm">
               <Group gap="sm" wrap="wrap">
                 <TextInput
@@ -917,20 +639,18 @@ export default function GlDjiboutiClearanceListPage() {
                   radius="lg"
                   w={190}
                 />
-                {tab === "shipments" ? (
-                  <Select
-                    placeholder="DJ action"
-                    data={DJ_ACTION_OPTIONS}
-                    value={action}
-                    onChange={(v) => {
-                      setAction(v);
-                      resetPage();
-                    }}
-                    clearable
-                    radius="lg"
-                    w={180}
-                  />
-                ) : null}
+                <Select
+                  placeholder="DJ action"
+                  data={DJ_ACTION_OPTIONS}
+                  value={action}
+                  onChange={(v) => {
+                    setAction(v);
+                    resetPage();
+                  }}
+                  clearable
+                  radius="lg"
+                  w={180}
+                />
                 {hasFilters ? (
                   <Button
                     variant="subtle"
@@ -957,9 +677,7 @@ export default function GlDjiboutiClearanceListPage() {
                 <Text c="dimmed">
                   {hasFilters
                     ? "No records match these filters."
-                    : tab === "contracts"
-                      ? "No Djibouti customs contracts yet."
-                      : "No shipment bookings awaiting a Djibouti action."}
+                    : "No shipments awaiting a Djibouti action."}
                 </Text>
                 {hasFilters ? (
                   <Button
@@ -975,49 +693,26 @@ export default function GlDjiboutiClearanceListPage() {
               </Stack>
             ) : (
               <Box style={{ overflowX: "auto" }} px="xs" pb="xs">
-                {tab === "shipments" ? (
-                  <DataTable<ShipmentRow, unknown>
-                    columns={shipmentColumns}
-                    data={pagedShipmentRows}
-                    status={isLoading ? "loading" : isError ? "error" : "success"}
-                    onRowClick={(row) => openDetail(row.id)}
-                    pagination={{
-                      pageIndex: pagination.pageIndex,
-                      pageSize: pagination.pageSize,
-                      pageCount,
-                      totalCount: total,
-                    }}
-                    tableOptions={{
-                      state: { pagination },
-                      onPaginationChange: setPagination,
-                      manualPagination: true,
-                      pageCount,
-                    }}
-                    containerClassName="border-0 shadow-none bg-transparent"
-                    footer={DataTableFooter}
-                  />
-                ) : (
-                  <DataTable<ContractRow, unknown>
-                    columns={contractColumns}
-                    data={pagedContractRows}
-                    status={isLoading ? "loading" : isError ? "error" : "success"}
-                    onRowClick={(row) => openDetail(row.id)}
-                    pagination={{
-                      pageIndex: pagination.pageIndex,
-                      pageSize: pagination.pageSize,
-                      pageCount,
-                      totalCount: total,
-                    }}
-                    tableOptions={{
-                      state: { pagination },
-                      onPaginationChange: setPagination,
-                      manualPagination: true,
-                      pageCount,
-                    }}
-                    containerClassName="border-0 shadow-none bg-transparent"
-                    footer={DataTableFooter}
-                  />
-                )}
+                <DataTable<ShipmentRow, unknown>
+                  columns={shipmentColumns}
+                  data={pagedShipmentRows}
+                  status={isLoading ? "loading" : isError ? "error" : "success"}
+                  onRowClick={(row) => openDetail(row.id)}
+                  pagination={{
+                    pageIndex: pagination.pageIndex,
+                    pageSize: pagination.pageSize,
+                    pageCount,
+                    totalCount: total,
+                  }}
+                  tableOptions={{
+                    state: { pagination },
+                    onPaginationChange: setPagination,
+                    manualPagination: true,
+                    pageCount,
+                  }}
+                  containerClassName="border-0 shadow-none bg-transparent"
+                  footer={DataTableFooter}
+                />
               </Box>
             )}
           </Stack>
diff --git a/apps/edr-freight-web/backoffice/src/pages/fleet/FleetResourcePage.tsx b/apps/edr-freight-web/backoffice/src/pages/fleet/FleetResourcePage.tsx
index 9a017d8c7..213501d74 100644
--- a/apps/edr-freight-web/backoffice/src/pages/fleet/FleetResourcePage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/fleet/FleetResourcePage.tsx
@@ -1,7 +1,7 @@
 import type { ColumnDef } from "@edr/ui-common";
 import { Box, Button, Card, Container, Group, Modal, Select, Stack, Text, Title } from "@mantine/core";
 import { DatePickerInput } from "@mantine/dates";
-import { useMutation, useQuery } from "@tanstack/react-query";
+import { keepPreviousData, useMutation, useQuery } from "@tanstack/react-query";
 
 import { api } from "@/services/api";
 import { useAuth } from "@/auth/useAuth";
@@ -30,8 +30,13 @@ import {
     type FleetFormFieldDef,
     type FleetResourceSlug,
 } from "@/pages/fleet/config/resources";
-import type { FleetListFilters, FleetRecord } from "@/services/fleet/fleet.service";
+import {
+  isFleetServerPaginated,
+  type FleetListFilters,
+  type FleetRecord,
+} from "@/services/fleet/fleet.service";
 import { DataTable, DataTableFooter, usePagination } from "@edr/ui-common";
+import { useDebouncedValue } from "@mantine/hooks";
 
 const DEFAULT_SLUG: FleetResourceSlug = "locomotives";
 
@@ -53,6 +58,10 @@ const FleetResourcePage = () => {
 
   const { pagination, setPagination } = usePagination({ pageSize: 10 });
   const [search, setSearch] = useState("");
+  const [debouncedSearch] = useDebouncedValue(search, 300);
+  // Wagons and locomotives page in the database; the rest still list in full
+  // and page in the browser (see `pagedHandlers` in fleet.service).
+  const serverPaged = isFleetServerPaginated(slug);
   const [statusFilter, setStatusFilter] = useState("ALL");
   // Registration date range. Server-side list filters (status/yard/train) are
   // applied by the API; this narrows what comes back, alongside search.
@@ -93,14 +102,42 @@ const FleetResourcePage = () => {
     if (wagonTypeId && wagonTypeId !== "ALL") {
       (filters as { wagonTypeId?: string }).wagonTypeId = wagonTypeId;
     }
-    if (slug !== "locomotives" && search.trim()) {
-      filters.search = search.trim();
+    // The plain locomotives list has no server-side search — its page window
+    // does, so the term is only sent on the paginated path.
+    if ((serverPaged || slug !== "locomotives") && debouncedSearch.trim()) {
+      filters.search = debouncedSearch.trim();
     }
     return filters;
-  }, [slug, listFilterValues, search]);
+  }, [slug, listFilterValues, debouncedSearch, serverPaged]);
 
-  const { data: allRows = [], isLoading, isError, error } = useQuery(
-    api.fleet.list.queryOptions({ input: { slug, filters: serverListFilters } }),
+  // On the server-paged path the page window, the search and the registration
+  // date range are all resolved by the API — nothing is filtered client-side.
+  const pagedFilters = useMemo(
+    (): FleetListFilters => ({
+      ...serverListFilters,
+      page: pagination.pageIndex + 1,
+      pageSize: pagination.pageSize,
+      ...(dateFrom ? { createdFrom: dateFrom } : {}),
+      ...(dateTo ? { createdTo: dateTo } : {}),
+    }),
+    [serverListFilters, pagination.pageIndex, pagination.pageSize, dateFrom, dateTo],
+  );
+
+  const listQuery = useQuery({
+    ...api.fleet.list.queryOptions({ input: { slug, filters: serverListFilters } }),
+    enabled: !serverPaged,
+  });
+  const pagedQuery = useQuery({
+    ...api.fleet.listPaged.queryOptions({ input: { slug, filters: pagedFilters } }),
+    enabled: serverPaged,
+    placeholderData: keepPreviousData,
+  });
+
+  const activeQuery = serverPaged ? pagedQuery : listQuery;
+  const { isLoading, isError, error } = activeQuery;
+  const allRows = useMemo(
+    () => (serverPaged ? (pagedQuery.data?.items ?? []) : (listQuery.data ?? [])),
+    [serverPaged, pagedQuery.data, listQuery.data],
   );
   const create = useMutation(api.fleet.create.mutationOptions());
   const update = useMutation(api.fleet.update.mutationOptions());
@@ -118,9 +155,15 @@ const FleetResourcePage = () => {
   const { data: cargoTypes = [], isLoading: cargoTypesLoading } = useQuery(
     api.cargoTypes.list.queryOptions({ staleTime: Infinity }),
   );
-  const { data: wagons = [], isLoading: wagonsLoading } = useQuery(
-    api.wagons.list.queryOptions({ input: {} }),
+  // Whole-fleet list for the "Wagon" form select — page-walked, so only fetch it
+  // where a form actually offers that select (containers), not on every slug.
+  const needsWagonOptions = Boolean(
+    config?.formFields.some((field) => field.dynamicOptions === "wagons"),
   );
+  const { data: wagons = [], isLoading: wagonsLoading } = useQuery({
+    ...api.wagons.list.queryOptions({ input: {} }),
+    enabled: needsWagonOptions,
+  });
   const { data: containers = [], isLoading: containersLoading } = useQuery(
     api.containers.list.queryOptions(),
   );
@@ -270,6 +313,9 @@ const FleetResourcePage = () => {
 
   const filteredRows = useMemo(() => {
     if (!config) return allRows;
+    // The API already applied every filter and cut the page — re-filtering here
+    // would drop rows the server deliberately returned.
+    if (serverPaged) return allRows;
     const term = search.trim().toLowerCase();
     return allRows.filter((row) => {
       const record = row as unknown as Record<string, unknown>;
@@ -287,13 +333,19 @@ const FleetResourcePage = () => {
           .includes(term),
       );
     });
-  }, [allRows, search, statusFilter, config, usesServerListFilters, dateFrom, dateTo]);
+  }, [allRows, search, statusFilter, config, usesServerListFilters, dateFrom, dateTo, serverPaged]);
 
-  const pageCount = Math.max(1, Math.ceil(filteredRows.length / pagination.pageSize));
+  const totalCount = serverPaged
+    ? (pagedQuery.data?.meta.total ?? 0)
+    : filteredRows.length;
+  const pageCount = serverPaged
+    ? Math.max(1, pagedQuery.data?.meta.totalPages ?? 1)
+    : Math.max(1, Math.ceil(filteredRows.length / pagination.pageSize));
   const pagedRows = useMemo(() => {
+    if (serverPaged) return filteredRows;
     const start = pagination.pageIndex * pagination.pageSize;
     return filteredRows.slice(start, start + pagination.pageSize);
-  }, [filteredRows, pagination.pageIndex, pagination.pageSize]);
+  }, [filteredRows, pagination.pageIndex, pagination.pageSize, serverPaged]);
 
   const columns = useMemo((): ColumnDef<FleetRecord>[] => {
     if (!config) return [];
@@ -584,7 +636,7 @@ const FleetResourcePage = () => {
                   pageIndex: pagination.pageIndex,
                   pageSize: pagination.pageSize,
                   pageCount,
-                  totalCount: filteredRows.length,
+                  totalCount,
                 }}
                 tableOptions={{
                   manualPagination: true,
@@ -610,7 +662,7 @@ const FleetResourcePage = () => {
               emptyMessage={`No ${itemLabel} found`}
               pagination={pagination}
               pageCount={pageCount}
-              totalCount={filteredRows.length}
+              totalCount={totalCount}
               onPaginationChange={setPagination}
               onEdit={
                 canUpdate
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 d4a26133f..4823be33d 100644
--- a/apps/edr-freight-web/backoffice/src/pages/fleet/RoutesPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/fleet/RoutesPage.tsx
@@ -1,4 +1,4 @@
-import { FormEvent, useMemo, useState } from "react";
+import { FormEvent, useEffect, useMemo, useState } from "react";
 import {
   ArrowRight,
   Ban,
@@ -27,7 +27,8 @@ import {
   Tooltip,
 } from "@mantine/core";
 
-import { useMutation, useQuery } from "@tanstack/react-query";
+import { useDebouncedValue } from "@mantine/hooks";
+import { keepPreviousData, useMutation, useQuery } from "@tanstack/react-query";
 
 import { KpiStrip, PageContainer, PageHeader } from "@/components/page";
 import FleetToolbar from "@/components/fleet/FleetToolbar";
@@ -155,6 +156,7 @@ function RouteTimeline({ route }: { route: RouteRecord }) {
 
 export default function RoutesPage() {
   const [search, setSearch] = useState("");
+  const [debouncedSearch] = useDebouncedValue(search, 300);
   const [formOpen, setFormOpen] = useState(false);
   const [viewing, setViewing] = useState<RouteRecord | null>(null);
   const [editing, setEditing] = useState<RouteRecord | null>(null);
@@ -167,7 +169,26 @@ export default function RoutesPage() {
   const canUpdate = canFleetAction(user, "routes", "update");
   const canDelete = canFleetAction(user, "routes", "delete");
 
-  const routesQuery = useQuery(api.routes.list.queryOptions());
+  const routesQuery = useQuery({
+    ...api.routes.listPaged.queryOptions({
+      input: {
+        page: pagination.pageIndex + 1,
+        pageSize: pagination.pageSize,
+        ...(debouncedSearch.trim() ? { search: debouncedSearch.trim() } : {}),
+      },
+    }),
+    placeholderData: keepPreviousData,
+  });
+  // KPI counts stay whole-fleet (they must not move with the search box), so
+  // they come from two count-only pages rather than the visible one.
+  const totalCountQuery = useQuery(
+    api.routes.listPaged.queryOptions({ input: { page: 1, pageSize: 1 } }),
+  );
+  const availableCountQuery = useQuery(
+    api.routes.listPaged.queryOptions({
+      input: { page: 1, pageSize: 1, status: "AVAILABLE" },
+    }),
+  );
   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.
@@ -182,35 +203,19 @@ export default function RoutesPage() {
   const updateMutation = useMutation(api.routes.update.mutationOptions());
   const deactivateMutation = useMutation(api.routes.deactivate.mutationOptions());
 
-  const filteredRoutes = useMemo(() => {
-    const query = search.trim().toLowerCase();
-    if (!query) return routesQuery.data ?? [];
-    return (routesQuery.data ?? []).filter((route) => {
-      const searchable = [
-        formatRouteLabel(route),
-        route.originYard?.label,
-        route.originYard?.code,
-        route.destinationYard?.label,
-        route.destinationYard?.code,
-        ...(route.milestones ?? []).map(
-          (m) => m.yard?.label ?? m.yard?.code ?? m.yardId,
-        ),
-      ]
-        .filter(Boolean)
-        .join(" ")
-        .toLowerCase();
-      return searchable.includes(query);
-    });
-  }, [routesQuery.data, search]);
+  // Narrowing the result set can strand the user on a page that no longer
+  // exists (search down to 3 rows while on page 5 → empty table).
+  useEffect(() => {
+    setPagination((prev) => (prev.pageIndex === 0 ? prev : { ...prev, pageIndex: 0 }));
+  }, [debouncedSearch, setPagination]);
 
-  const pageCount = Math.max(1, Math.ceil(filteredRoutes.length / pagination.pageSize));
-  const pagedRoutes = useMemo(() => {
-    const start = pagination.pageIndex * pagination.pageSize;
-    return filteredRoutes.slice(start, start + pagination.pageSize);
-  }, [filteredRoutes, pagination.pageIndex, pagination.pageSize]);
+  // Filtering, sorting and the page window all happen server-side.
+  const pagedRoutes = routesQuery.data?.items ?? [];
+  const matchCount = routesQuery.data?.meta.total ?? 0;
+  const pageCount = Math.max(1, routesQuery.data?.meta.totalPages ?? 1);
 
-  const allRoutes = routesQuery.data ?? [];
-  const availableCount = allRoutes.filter((r) => r.status === "AVAILABLE").length;
+  const totalRoutes = totalCountQuery.data?.meta.total ?? 0;
+  const availableCount = availableCountQuery.data?.meta.total ?? 0;
 
   const yardOptions = useMemo(
     () =>
@@ -489,11 +494,11 @@ export default function RoutesPage() {
       <KpiStrip
         loading={routesQuery.isLoading}
         items={[
-          { label: "Total routes", value: allRoutes.length, icon: RouteIcon },
+          { label: "Total routes", value: totalRoutes, icon: RouteIcon },
           { label: "Available", value: availableCount, icon: CircleCheck, color: "edr-green" },
           {
             label: "Unavailable",
-            value: allRoutes.length - availableCount,
+            value: totalRoutes - availableCount,
             icon: Ban,
             color: "gray",
           },
@@ -522,7 +527,7 @@ export default function RoutesPage() {
                 pageIndex: pagination.pageIndex,
                 pageSize: pagination.pageSize,
                 pageCount,
-                totalCount: filteredRoutes.length,
+                totalCount: matchCount,
               }}
               tableOptions={{
                 manualPagination: true,
@@ -581,7 +586,7 @@ export default function RoutesPage() {
               <RuleEngineListFooter
                 pagination={pagination}
                 pageCount={pageCount}
-                totalCount={filteredRoutes.length}
+                totalCount={matchCount}
                 itemLabel="routes"
                 onPaginationChange={setPagination}
               />
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 f9e4555ae..63f45617e 100644
--- a/apps/edr-freight-web/backoffice/src/pages/trainBuilder/TrainBuilderDetailPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/trainBuilder/TrainBuilderDetailPage.tsx
@@ -26,6 +26,7 @@ import {
   Train as TrainIcon,
   TrainFront,
   Weight,
+  Wrench,
 } from "lucide-react";
 import { useState } from "react";
 import { useNavigate, useParams } from "react-router-dom";
@@ -48,6 +49,7 @@ import { api } from "@/services/api";
 import { useAuth } from "@/auth/useAuth";
 import { canFleetAction, FREIGHT_PERMS, hasPermission } from "@/lib/permissions";
 import { useToast } from "@/hooks/use-toast";
+import type { TrainCompositionWagon } from "@/services/trainBuilder.service";
 
 const parseError = (error: unknown, fallback: string) => {
   if (isAxiosError(error)) {
@@ -78,6 +80,8 @@ export default function TrainBuilderDetailPage() {
   const [yardModalOpen, setYardModalOpen] = useState(false);
   const [disbandOpen, setDisbandOpen] = useState(false);
   const [deactivateOpen, setDeactivateOpen] = useState(false);
+  const [maintenanceTarget, setMaintenanceTarget] =
+    useState<TrainCompositionWagon | null>(null);
   const { user } = useAuth();
   const canUpdate = canFleetAction(user, "trains", "update");
   const canDelete = canFleetAction(user, "trains", "delete");
@@ -396,12 +400,7 @@ export default function TrainBuilderDetailPage() {
                     "Could not detach wagon",
                   )
                 }
-                onMaintenance={(wagonId) =>
-                  void withToast(
-                    () => maintenanceWagon.mutateAsync({ id: composition.id, wagonId }),
-                    "Could not send wagon to maintenance",
-                  )
-                }
+                onMaintenance={(wagon) => setMaintenanceTarget(wagon)}
               />
             </Stack>
           </Card>
@@ -460,6 +459,54 @@ export default function TrainBuilderDetailPage() {
         onClose={() => setYardModalOpen(false)}
       />
 
+      <Modal
+        opened={Boolean(maintenanceTarget)}
+        onClose={() => setMaintenanceTarget(null)}
+        title={<Text fw={600}>Send wagon to maintenance?</Text>}
+        radius="lg"
+        centered
+      >
+        <Stack gap="md">
+          <Text size="sm" c="dimmed">
+            Wagon{" "}
+            <Text span fw={700} ff="monospace" c="dark">
+              {maintenanceTarget?.wagonNumber}
+            </Text>{" "}
+            is detached from train{" "}
+            <Text span fw={700} c="dark">
+              {composition.code}
+            </Text>{" "}
+            and set to MAINTENANCE — it stays out of the available pool until it
+            clears. The detach is stamped with the time and this train number in
+            the wagon's history.
+          </Text>
+          <Group justify="flex-end">
+            <Button variant="default" onClick={() => setMaintenanceTarget(null)}>
+              Keep in consist
+            </Button>
+            <Button
+              color="orange"
+              leftSection={<Wrench size={16} />}
+              loading={maintenanceWagon.isPending}
+              onClick={() =>
+                void withToast(async () => {
+                  await maintenanceWagon.mutateAsync({
+                    id: composition.id,
+                    wagonId: maintenanceTarget!.id,
+                  });
+                  toast({
+                    title: `Wagon ${maintenanceTarget!.wagonNumber} sent to maintenance`,
+                  });
+                  setMaintenanceTarget(null);
+                }, "Could not send wagon to maintenance")
+              }
+            >
+              Send to maintenance
+            </Button>
+          </Group>
+        </Stack>
+      </Modal>
+
       <Modal
         opened={deactivateOpen}
         onClose={() => setDeactivateOpen(false)}
diff --git a/apps/edr-freight-web/backoffice/src/pages/wagons/TransferFulfillModal.tsx b/apps/edr-freight-web/backoffice/src/pages/wagons/TransferFulfillModal.tsx
index dc8c49620..6f5a0c129 100644
--- a/apps/edr-freight-web/backoffice/src/pages/wagons/TransferFulfillModal.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/wagons/TransferFulfillModal.tsx
@@ -48,6 +48,8 @@ export function TransferFulfillModal({
               currentYardId: request.fromYardId,
               wagonTypeId: request.wagonTypeId,
               status: Freight.WagonStatus.Available,
+              // A coupled wagon cannot be moved out of its train by a transfer.
+              unassigned: true,
             }
           : {},
       },
diff --git a/apps/edr-freight-web/backoffice/src/pages/wagons/TransferHistoryPanel.tsx b/apps/edr-freight-web/backoffice/src/pages/wagons/TransferHistoryPanel.tsx
new file mode 100644
index 000000000..dff9cdaa3
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/pages/wagons/TransferHistoryPanel.tsx
@@ -0,0 +1,342 @@
+import {
+  Badge,
+  Button,
+  Card,
+  Group,
+  SegmentedControl,
+  Skeleton,
+  Stack,
+  Switch,
+  Text,
+  ThemeIcon,
+  Timeline,
+  Tooltip,
+} from "@mantine/core";
+import { useQuery } from "@tanstack/react-query";
+import {
+  ArrowRight,
+  ChevronLeft,
+  ChevronRight,
+  History,
+  Inbox,
+  Truck,
+} from "lucide-react";
+import { useState } from "react";
+
+import { useAuth } from "@/auth/useAuth";
+import { FREIGHT_PERMS, hasPermission } from "@/lib/permissions";
+import { api } from "@/services/api";
+import type {
+  WagonMovementRecord,
+  WagonTransferRequest,
+} from "@/services/wagon.service";
+
+import {
+  STATUS_META,
+  TransferProgress,
+  TransferStatusBadge,
+  wagonTypeLabel,
+  yardLabel,
+} from "./wagon-transfer-ui";
+
+const fmtTime = (iso?: string | null) =>
+  iso
+    ? new Date(iso).toLocaleTimeString("en-GB", {
+        hour: "2-digit",
+        minute: "2-digit",
+        hour12: false,
+      })
+    : "—";
+
+/** "Today" / "Yesterday" / "Mon 12 Jul 2026" — the header of one timeline block. */
+const dayLabel = (iso: string) => {
+  const d = new Date(iso);
+  const days = Math.round(
+    (new Date().setHours(0, 0, 0, 0) - new Date(iso).setHours(0, 0, 0, 0)) /
+      86_400_000,
+  );
+  if (days === 0) return "Today";
+  if (days === 1) return "Yesterday";
+  return d.toLocaleDateString("en-GB", {
+    weekday: "short",
+    day: "numeric",
+    month: "short",
+    year: "numeric",
+  });
+};
+
+/** Bucket an already-DESC-sorted list into day blocks, order preserved. */
+function groupByDay<T>(items: T[], at: (item: T) => string) {
+  const groups: Array<{ key: string; label: string; items: T[] }> = [];
+  for (const item of items) {
+    const iso = at(item);
+    const key = new Date(iso).toDateString();
+    const last = groups[groups.length - 1];
+    if (last?.key === key) last.items.push(item);
+    else groups.push({ key, label: dayLabel(iso), items: [item] });
+  }
+  return groups;
+}
+
+const MOVEMENT_KIND_LABEL: Record<string, string> = {
+  LOADED: "Carried cargo",
+  EMPTY_REPOSITION: "Repositioned empty",
+  MANUAL: "Manual move",
+};
+
+function EmptyState({ label }: { label: string }) {
+  return (
+    <Stack align="center" gap={6} py="xl">
+      <ThemeIcon variant="light" color="gray" radius="xl" size={44}>
+        <History size={20} />
+      </ThemeIcon>
+      <Text size="sm" c="dimmed">
+        {label}
+      </Text>
+    </Stack>
+  );
+}
+
+function RequestItem({ request }: { request: WagonTransferRequest }) {
+  const meta = STATUS_META[request.status];
+  return (
+    <Timeline.Item
+      bullet={<Inbox size={12} />}
+      color={meta?.color ?? "gray"}
+      lineVariant="dotted"
+    >
+      <Group justify="space-between" align="flex-start" gap="md" wrap="wrap">
+        <Stack gap={4} style={{ flex: 1, minWidth: 220 }}>
+          <Group gap={6} wrap="nowrap">
+            <Text size="sm" fw={600}>
+              {yardLabel(request.fromYard)}
+            </Text>
+            <ArrowRight size={13} className="shrink-0 opacity-60" />
+            <Text size="sm" fw={600}>
+              {yardLabel(request.toYard)}
+            </Text>
+            <Badge variant="default" radius="sm" size="sm">
+              {wagonTypeLabel(request.wagonType)}
+            </Badge>
+          </Group>
+          {request.reason ? (
+            <Text size="xs" c="dimmed" lineClamp={1}>
+              {request.reason}
+            </Text>
+          ) : null}
+        </Stack>
+        <Group gap="sm" wrap="nowrap">
+          <TransferProgress request={request} />
+          <TransferStatusBadge status={request.status} />
+          <Text size="xs" c="dimmed" w={38} ta="right">
+            {fmtTime(request.createdAt)}
+          </Text>
+        </Group>
+      </Group>
+    </Timeline.Item>
+  );
+}
+
+function MovementItem({ movement }: { movement: WagonMovementRecord }) {
+  return (
+    <Timeline.Item
+      bullet={<Truck size={12} />}
+      color={movement.transferRequestId ? "edr-green" : "gray"}
+      lineVariant="dotted"
+    >
+      <Group justify="space-between" align="center" gap="md" wrap="wrap">
+        <Group gap={8} wrap="nowrap" style={{ flex: 1, minWidth: 220 }}>
+          <Badge variant="light" color="gray" radius="sm" ff="monospace">
+            {movement.wagon?.wagonNumber ?? "Wagon"}
+          </Badge>
+          <Text size="sm" fw={500}>
+            {yardLabel(movement.fromYard)}
+          </Text>
+          <ArrowRight size={13} className="shrink-0 opacity-60" />
+          <Text size="sm" fw={500}>
+            {yardLabel(movement.toYard)}
+          </Text>
+        </Group>
+        <Group gap="sm" wrap="nowrap">
+          {movement.transferRequestId ? (
+            <Tooltip label="Delivered against a transfer request" withArrow>
+              <Badge variant="dot" color="teal" radius="sm" size="sm">
+                Transfer
+              </Badge>
+            </Tooltip>
+          ) : (
+            <Badge variant="light" color="gray" radius="sm" size="sm">
+              {MOVEMENT_KIND_LABEL[movement.kind] ?? movement.kind}
+            </Badge>
+          )}
+          <Text size="xs" c="dimmed" w={38} ta="right">
+            {fmtTime(movement.occurredAt)}
+          </Text>
+        </Group>
+      </Group>
+    </Timeline.Item>
+  );
+}
+
+/**
+ * Who moved what. A staffer sees their own activity; holders of
+ * `transfer_history_all` can widen it to every staffer (the backend enforces
+ * the scope regardless of the toggle).
+ */
+export default function TransferHistoryPanel() {
+  const { user } = useAuth();
+  const canSeeAll = hasPermission(user, FREIGHT_PERMS.wagons.transferHistoryAll);
+  const [allStaff, setAllStaff] = useState(false);
+  const [view, setView] = useState<"requests" | "movements">("requests");
+  const [page, setPage] = useState(1);
+  const scopeAll = canSeeAll && allStaff;
+
+  const mine = useQuery({
+    ...api.wagonTransferRequests.history.queryOptions({
+      input: { page, pageSize: 20 },
+    }),
+    enabled: !scopeAll,
+  });
+  const all = useQuery({
+    ...api.wagonTransferRequests.historyAll.queryOptions({
+      input: { page, pageSize: 20 },
+    }),
+    enabled: scopeAll,
+  });
+  const source = scopeAll ? all : mine;
+  const requests = source.data?.requests ?? [];
+  const movements = source.data?.movements ?? [];
+  const meta = source.data?.meta;
+
+  const showingRequests = view === "requests";
+  const total = showingRequests
+    ? (meta?.requestsTotal ?? 0)
+    : (meta?.movementsTotal ?? 0);
+  // Each list pages independently on the server; the pager follows the one on screen.
+  const pageSize = meta?.pageSize ?? 20;
+  const totalPages = Math.max(1, Math.ceil(total / pageSize));
+  const groups = showingRequests
+    ? groupByDay(requests, (r) => r.createdAt)
+    : groupByDay(movements, (m) => m.occurredAt);
+
+  return (
+    <Card withBorder radius="md" p="md">
+      <Stack gap="md">
+        <Group justify="space-between" align="flex-start" gap="md" wrap="wrap">
+          <Stack gap={2}>
+            <Text fw={600}>Transfer history</Text>
+            <Text size="xs" c="dimmed">
+              {scopeAll
+                ? "Every staffer's requests and wagon moves"
+                : "Requests you filed or fulfilled, and the wagons you moved"}
+            </Text>
+          </Stack>
+          <Group gap="sm" wrap="wrap">
+            <SegmentedControl
+              size="xs"
+              radius="md"
+              value={view}
+              onChange={(v) => {
+                setView(v as "requests" | "movements");
+                setPage(1);
+              }}
+              data={[
+                {
+                  value: "requests",
+                  label: `Requests ${meta?.requestsTotal ?? 0}`,
+                },
+                {
+                  value: "movements",
+                  label: `Wagons moved ${meta?.movementsTotal ?? 0}`,
+                },
+              ]}
+            />
+            {canSeeAll ? (
+              <Switch
+                label="All staff"
+                checked={allStaff}
+                onChange={(e) => {
+                  setAllStaff(e.currentTarget.checked);
+                  setPage(1);
+                }}
+              />
+            ) : null}
+          </Group>
+        </Group>
+
+        {source.isLoading ? (
+          <Stack gap="sm">
+            {[0, 1, 2, 3].map((i) => (
+              <Skeleton key={i} height={44} radius="md" />
+            ))}
+          </Stack>
+        ) : groups.length === 0 ? (
+          <EmptyState
+            label={
+              showingRequests
+                ? "No transfer requests recorded yet."
+                : "No wagon moves recorded yet."
+            }
+          />
+        ) : (
+          <Stack gap="lg">
+            {groups.map((group) => (
+              <Stack key={group.key} gap="xs">
+                <Group gap="xs" wrap="nowrap">
+                  <Text size="xs" fw={700} c="dimmed" tt="uppercase">
+                    {group.label}
+                  </Text>
+                  <Text size="xs" c="dimmed">
+                    · {group.items.length}
+                  </Text>
+                </Group>
+                <Timeline
+                  bulletSize={22}
+                  lineWidth={2}
+                  active={group.items.length}
+                >
+                  {showingRequests
+                    ? (group.items as WagonTransferRequest[]).map((r) => (
+                        <RequestItem key={r.id} request={r} />
+                      ))
+                    : (group.items as WagonMovementRecord[]).map((m) => (
+                        <MovementItem key={m.id} movement={m} />
+                      ))}
+                </Timeline>
+              </Stack>
+            ))}
+          </Stack>
+        )}
+
+        <Group justify="space-between" gap="sm" wrap="wrap">
+          <Text size="xs" c="dimmed">
+            {total} {showingRequests ? "request(s)" : "move(s)"} · page{" "}
+            {meta?.page ?? page} of {totalPages}
+          </Text>
+          <Group gap="xs">
+            <Button
+              variant="default"
+              size="xs"
+              radius="md"
+              leftSection={<ChevronLeft size={14} />}
+              disabled={page <= 1}
+              onClick={() => setPage((p) => Math.max(1, p - 1))}
+            >
+              Previous
+            </Button>
+            <Button
+              variant="default"
+              size="xs"
+              radius="md"
+              rightSection={<ChevronRight size={14} />}
+              disabled={page >= totalPages}
+              onClick={() => setPage((p) => p + 1)}
+            >
+              Next
+            </Button>
+          </Group>
+        </Group>
+      </Stack>
+    </Card>
+  );
+}
diff --git a/apps/edr-freight-web/backoffice/src/pages/wagons/WagonTransfersPage.tsx b/apps/edr-freight-web/backoffice/src/pages/wagons/WagonTransfersPage.tsx
index 3d8d8fe8c..58eb5a3cd 100644
--- a/apps/edr-freight-web/backoffice/src/pages/wagons/WagonTransfersPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/wagons/WagonTransfersPage.tsx
@@ -4,10 +4,9 @@ import {
   Button,
   Card,
   Group,
-  Loader,
+  Modal,
   Select,
   Stack,
-  Switch,
   Tabs,
   Text,
   TextInput,
@@ -46,6 +45,7 @@ import {
 } from "@edr/ui-common";
 
 import TransferFulfillModal from "./TransferFulfillModal";
+import TransferHistoryPanel from "./TransferHistoryPanel";
 import {
   TransferCloseShortModal,
   TransferRequestFormModal,
@@ -103,6 +103,9 @@ export default function WagonTransfersPage() {
   const [formOpen, setFormOpen] = useState(false);
   const [carryOver, setCarryOver] = useState<WagonTransferRequest | null>(null);
   const [fulfilling, setFulfilling] = useState<WagonTransferRequest | null>(null);
+  const [withdrawing, setWithdrawing] = useState<WagonTransferRequest | null>(
+    null,
+  );
   const [closingShort, setClosingShort] = useState<WagonTransferRequest | null>(
     null,
   );
@@ -269,15 +272,7 @@ export default function WagonTransfersPage() {
                 radius="md"
                 variant="subtle"
                 color="red"
-                loading={cancel.isPending}
-                onClick={async () => {
-                  try {
-                    await cancel.mutateAsync({ id: r.id });
-                    toast.success("Request withdrawn");
-                  } catch {
-                    // interceptor surfaces the reason
-                  }
-                }}
+                onClick={() => setWithdrawing(r)}
               >
                 Withdraw
               </Button>
@@ -494,132 +489,53 @@ export default function WagonTransfersPage() {
           }
         }}
       />
+      <Modal
+        opened={Boolean(withdrawing)}
+        onClose={() => setWithdrawing(null)}
+        radius="md"
+        title="Withdraw this request?"
+      >
+        {!withdrawing ? null : (
+          <Stack gap="sm">
+            <Text size="sm">
+              {yardLabel(withdrawing.fromYard)} →{" "}
+              {yardLabel(withdrawing.toYard)} ·{" "}
+              {wagonTypeLabel(withdrawing.wagonType)} ·{" "}
+              {withdrawing.quantity} wagon(s)
+            </Text>
+            <Text size="sm" c="dimmed">
+              The source yard stops seeing it. Withdrawing can't be undone —
+              raise a new request if you still need the wagons.
+            </Text>
+            <Group justify="flex-end" gap="sm">
+              <Button
+                variant="default"
+                radius="md"
+                onClick={() => setWithdrawing(null)}
+              >
+                Keep it
+              </Button>
+              <Button
+                color="red"
+                radius="md"
+                leftSection={<XCircle size={15} />}
+                loading={cancel.isPending}
+                onClick={async () => {
+                  try {
+                    await cancel.mutateAsync({ id: withdrawing.id });
+                    toast.success("Request withdrawn");
+                    setWithdrawing(null);
+                  } catch {
+                    // interceptor surfaces the reason
+                  }
+                }}
+              >
+                Withdraw
+              </Button>
+            </Group>
+          </Stack>
+        )}
+      </Modal>
     </PageContainer>
   );
 }
-
-/**
- * Who moved what. A staffer sees their own activity; holders of
- * `transfer_history_all` can widen it to every staffer (the backend enforces
- * the scope regardless of the toggle).
- */
-function TransferHistoryPanel() {
-  const { user } = useAuth();
-  const canSeeAll = hasPermission(user, FREIGHT_PERMS.wagons.transferHistoryAll);
-  const [allStaff, setAllStaff] = useState(false);
-  const [page, setPage] = useState(1);
-  const scopeAll = canSeeAll && allStaff;
-
-  const mine = useQuery({
-    ...api.wagonTransferRequests.history.queryOptions({
-      input: { page, pageSize: 20 },
-    }),
-    enabled: !scopeAll,
-  });
-  const all = useQuery({
-    ...api.wagonTransferRequests.historyAll.queryOptions({
-      input: { page, pageSize: 20 },
-    }),
-    enabled: scopeAll,
-  });
-  const source = scopeAll ? all : mine;
-  const requests = source.data?.requests ?? [];
-  const movements = source.data?.movements ?? [];
-  const meta = source.data?.meta;
-
-  return (
-    <Card withBorder radius="md" p="md">
-      <Stack gap="md">
-        <Group justify="space-between" wrap="wrap">
-          <Text fw={600}>Transfer history</Text>
-          {canSeeAll ? (
-            <Switch
-              label="All staff"
-              checked={allStaff}
-              onChange={(e) => {
-                setAllStaff(e.currentTarget.checked);
-                setPage(1);
-              }}
-            />
-          ) : null}
-        </Group>
-
-        {source.isLoading ? (
-          <Group justify="center" py="lg">
-            <Loader size="sm" />
-          </Group>
-        ) : (
-          <Group align="flex-start" grow gap="lg" wrap="wrap">
-            <Stack gap={6} miw={280}>
-              <Text size="sm" fw={700} c="dimmed" tt="uppercase">
-                Requests ({meta?.requestsTotal ?? 0})
-              </Text>
-              {requests.length === 0 ? (
-                <Text size="sm" c="dimmed">
-                  Nothing yet.
-                </Text>
-              ) : (
-                requests.map((r) => (
-                  <Group key={r.id} gap={8} wrap="nowrap" justify="space-between">
-                    <Text size="sm" truncate>
-                      {yardLabel(r.fromYard)} → {yardLabel(r.toYard)} ·{" "}
-                      {r.fulfilledQuantity}/{r.quantity}
-                    </Text>
-                    <TransferStatusBadge status={r.status} />
-                  </Group>
-                ))
-              )}
-            </Stack>
-
-            <Stack gap={6} miw={280}>
-              <Text size="sm" fw={700} c="dimmed" tt="uppercase">
-                Wagons moved ({meta?.movementsTotal ?? 0})
-              </Text>
-              {movements.length === 0 ? (
-                <Text size="sm" c="dimmed">
-                  Nothing yet.
-                </Text>
-              ) : (
-                movements.map((m) => (
-                  <Group key={m.id} gap={8} wrap="nowrap" justify="space-between">
-                    <Text size="sm" truncate>
-                      {m.wagon?.wagonNumber ?? "Wagon"} · {yardLabel(m.fromYard)} →{" "}
-                      {yardLabel(m.toYard)}
-                    </Text>
-                    <Text size="xs" c="dimmed">
-                      {fmtDateTime(m.occurredAt)}
-                    </Text>
-                  </Group>
-                ))
-              )}
-            </Stack>
-          </Group>
-        )}
-
-        <Group justify="center" gap="sm">
-          <Button
-            variant="default"
-            size="xs"
-            radius="md"
-            disabled={page <= 1}
-            onClick={() => setPage((p) => Math.max(1, p - 1))}
-          >
-            Previous
-          </Button>
-          <Text size="sm" c="dimmed">
-            Page {meta?.page ?? page} of {meta?.totalPages ?? 1}
-          </Text>
-          <Button
-            variant="default"
-            size="xs"
-            radius="md"
-            disabled={page >= (meta?.totalPages ?? 1)}
-            onClick={() => setPage((p) => p + 1)}
-          >
-            Next
-          </Button>
-        </Group>
-      </Stack>
-    </Card>
-  );
-}
diff --git a/apps/edr-freight-web/backoffice/src/services/api.ts b/apps/edr-freight-web/backoffice/src/services/api.ts
index 52ba5c696..ef84826aa 100644
--- a/apps/edr-freight-web/backoffice/src/services/api.ts
+++ b/apps/edr-freight-web/backoffice/src/services/api.ts
@@ -170,6 +170,7 @@ import {
 } from "./payments.service";
 import {
   routesService,
+  type RouteListFilters,
   type RouteRecord,
   type SaveRoutePayload,
   type YardRef,
@@ -1507,6 +1508,13 @@ export const api = {
       (input) => ["routes", input?.status ?? "all"],
     ),
 
+    listPaged: endpoint<RouteListFilters, PaginatedResponse<RouteRecord>>(
+      "routes",
+      "listPaged",
+      (filters) => routesService.getPaged(filters).then((r) => r.data),
+      (filters) => ["routes", "paged", filters],
+    ),
+
     yards: endpoint<void, YardRef[]>(
       "routes",
       "yards",
@@ -1624,17 +1632,25 @@ export const api = {
   },
 
   wagons: {
+    /** Every match, page-walked — for pickers and yard views. Lists use `listPaged`. */
     list: endpoint<{ filters?: WagonListFilters }, Wagon[]>(
       "wagons",
       "list",
-      ({ filters }) => wagonService.getAll(filters ?? {}).then((r) => r.data),
+      ({ filters }) => wagonService.listAll(filters ?? {}),
       ({ filters }) => ["wagons", "list", filters ?? {}],
     ),
 
+    listPaged: endpoint<{ filters?: WagonListFilters }, PaginatedResponse<Wagon>>(
+      "wagons",
+      "listPaged",
+      ({ filters }) => wagonService.getAll(filters ?? {}).then((r) => r.data),
+      ({ filters }) => ["wagons", "listPaged", filters ?? {}],
+    ),
+
     listByTrain: endpoint<{ trainId: string }, Wagon[]>(
       "wagons",
       "listByTrain",
-      ({ trainId }) => wagonService.getByTrain(trainId).then((r) => r.data),
+      ({ trainId }) => wagonService.getByTrain(trainId),
       ({ trainId }) => ["wagons", "train", trainId],
     ),
 
@@ -2082,6 +2098,16 @@ export const api = {
       ({ slug, filters }) => [...QUERY_KEYS.FLEET.list(slug), filters ?? {}],
     ),
 
+    listPaged: endpoint<
+      { slug: FleetResourceSlug; filters?: FleetListFilters },
+      PaginatedResponse<FleetRecord>
+    >(
+      "fleet",
+      "listPaged",
+      ({ slug, filters }) => fleetService.listPaged(slug, filters),
+      ({ slug, filters }) => [...QUERY_KEYS.FLEET.list(slug), "paged", filters ?? {}],
+    ),
+
     create: endpoint<
       { slug: FleetResourceSlug; data: Record<string, unknown> },
       unknown
diff --git a/apps/edr-freight-web/backoffice/src/services/bookings.service.ts b/apps/edr-freight-web/backoffice/src/services/bookings.service.ts
index 23ff5b8ff..dc969dfc4 100644
--- a/apps/edr-freight-web/backoffice/src/services/bookings.service.ts
+++ b/apps/edr-freight-web/backoffice/src/services/bookings.service.ts
@@ -332,6 +332,18 @@ export const bookingsService = {
     return unwrap(response.data) as Freight.ClearanceView;
   },
 
+  /** GL ET asks Djibouti to name the officer handling the shipment in transit. */
+  requestTransitAssignee: (id: string, note?: string) =>
+    postBooking<BookingDetail>(B.CLEARANCE_TRANSIT_ASSIGNEE_REQUEST(id), {
+      note,
+    }),
+
+  /** GL Djibouti names (or changes) that officer — unblocks the declaration. */
+  assignTransitAssignee: (id: string, assignee: string) =>
+    postBooking<BookingDetail>(B.CLEARANCE_TRANSIT_ASSIGNEE_ASSIGN(id), {
+      assignee,
+    }),
+
   uploadDeclaration: async (
     id: string,
     files: Record<string, File | null>,
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 2f4c3d50c..f5acfedeb 100644
--- a/apps/edr-freight-web/backoffice/src/services/contracts.service.ts
+++ b/apps/edr-freight-web/backoffice/src/services/contracts.service.ts
@@ -245,6 +245,14 @@ export const contractsService = {
   reject: (id: string, reason: string) =>
     postContract<Freight.IContract>(C.STAFF_REJECT(id), { reason }),
 
+  /** Freeze a signed contract. Reversible — see {@link resume}. */
+  suspend: (id: string, reason: string) =>
+    postContract<Freight.IContract>(C.SUSPEND(id), { reason }),
+
+  /** Lift a suspension; the contract returns to the status it was frozen at. */
+  resume: (id: string, note?: string) =>
+    postContract<Freight.IContract>(C.RESUME(id), { note }),
+
   /**
    * Approve the next pending step. The server resolves the step's required role
    * and authorizes against it — the client never declares its own role.
@@ -377,22 +385,29 @@ export const contractsService = {
   finalizeClearance: (id: string) =>
     postContract<Freight.IContract>(C.CLEARANCE_FINALIZE(id)),
 
-  getEtClearanceQueue: async (): Promise<PaginatedContracts> => {
-    const response = await client.get<PaginatedContracts>(C.CLEARANCE_ET_QUEUE);
+  /**
+   * GL worklist: executed one-time customs contracts with no shipment instance
+   * yet. GL initiates the booking; the customer then uploads his clearance
+   * documents on it.
+   */
+  getAwaitingShipmentContracts: async (): Promise<Freight.IContract[]> => {
+    const response = await client.get(C.AWAITING_SHIPMENT);
     const data = unwrap(response.data);
-    return {
-      items: (data.items ?? []) as Freight.IContract[],
-      total: data.total ?? 0,
-    };
+    return (Array.isArray(data) ? data : (data?.items ?? [])) as Freight.IContract[];
   },
 
-  getDjClearanceQueue: async (): Promise<PaginatedContracts> => {
-    const response = await client.get<PaginatedContracts>(C.CLEARANCE_DJ_QUEUE);
-    const data = unwrap(response.data);
-    return {
-      items: (data.items ?? []) as Freight.IContract[],
-      total: data.total ?? 0,
-    };
+  /** Open a bare shipment instance under a contract (no cargo, no day). */
+  initiateBookingUnderContract: async (
+    id: string,
+    contractRouteId?: string,
+  ): Promise<{ id: string; reference: string }> => {
+    const result = await postContract<{
+      booking?: { id: string; reference: string };
+      id?: string;
+      reference?: string;
+    }>(C.BOOKINGS_INITIATE(id), contractRouteId ? { contractRouteId } : {});
+    const booking = result.booking ?? result;
+    return { id: booking.id ?? "", reference: booking.reference ?? "" };
   },
 
   uploadDeclaration: async (
@@ -575,25 +590,6 @@ export const contractsService = {
     return unwrap(response.data) as { advised: boolean; skipped: boolean };
   },
 
-  // ── Path A self-clearance (Operations review) ──
-  getOpsClearanceQueue: async (filter?: {
-    page?: number;
-    pageSize?: number;
-    search?: string;
-    /** Comma-separated ops-clearance lifecycle statuses; omitted → under-review queue. */
-    statuses?: string;
-  }): Promise<PaginatedContracts> => {
-    const response = await client.get<PaginatedContracts>(
-      C.OPS_CLEARANCE_QUEUE,
-      { params: filter },
-    );
-    const data = unwrap(response.data);
-    return {
-      items: (data.items ?? []) as Freight.IContract[],
-      total: data.total ?? 0,
-    };
-  },
-
   getClearanceHistory: async (): Promise<PaginatedContracts> => {
     const response = await client.get<PaginatedContracts>(C.CLEARANCE_HISTORY);
     const data = unwrap(response.data);
diff --git a/apps/edr-freight-web/backoffice/src/services/fleet/fleet.service.ts b/apps/edr-freight-web/backoffice/src/services/fleet/fleet.service.ts
index 85d3ce4a3..e47160176 100644
--- a/apps/edr-freight-web/backoffice/src/services/fleet/fleet.service.ts
+++ b/apps/edr-freight-web/backoffice/src/services/fleet/fleet.service.ts
@@ -1,3 +1,5 @@
+import type { PaginatedResponse } from "@edr/types";
+
 import { cargoService, type Cargo } from "@/services/cargoService";
 import { containerService, type Container } from "@/services/containerService";
 import {
@@ -21,13 +23,27 @@ const listHandlers: Record<
 > = {
   locomotives: (filters) => locomotivesService.getAll(filters ?? {}).then((r) => r.data),
   trains: () => trainService.getAll().then((r) => r.data),
-  wagons: (filters) => wagonService.getAll(filters ?? {}).then((r) => r.data),
+  wagons: (filters) => wagonService.listAll(filters ?? {}),
   containers: () => containerService.getAll().then((r) => r.data),
   cargoes: () => cargoService.getAll().then((r) => r.data),
   vehicles: (filters) => vehiclesService.getAll(filters ?? {}).then((r) => r.data),
   drivers: (filters) => driversService.getAll(filters ?? {}).then((r) => r.data),
 };
 
+/**
+ * Server-paginated slugs. Everything else still lists in full and pages in the
+ * browser — add an entry here once its API grows a `/paged` endpoint.
+ */
+const pagedHandlers: Partial<
+  Record<FleetResourceSlug, (filters: FleetListFilters) => Promise<PaginatedResponse<FleetRecord>>>
+> = {
+  locomotives: (filters) => locomotivesService.getPaged(filters).then((r) => r.data),
+  wagons: (filters) => wagonService.getAll(filters).then((r) => r.data),
+};
+
+export const isFleetServerPaginated = (slug: FleetResourceSlug): boolean =>
+  slug in pagedHandlers;
+
 const createHandlers: Record<FleetResourceSlug, (data: Record<string, unknown>) => Promise<unknown>> = {
   locomotives: (data) => locomotivesService.create(data),
   trains: (data) => trainService.create(data),
@@ -63,6 +79,12 @@ const removeHandlers: Record<FleetResourceSlug, (id: string) => Promise<unknown>
 
 export const fleetService = {
   list: (slug: FleetResourceSlug, filters?: FleetListFilters) => listHandlers[slug](filters),
+  /** Only for slugs in `pagedHandlers` — guard with `isFleetServerPaginated`. */
+  listPaged: (slug: FleetResourceSlug, filters: FleetListFilters = {}) => {
+    const handler = pagedHandlers[slug];
+    if (!handler) throw new Error(`Fleet resource "${slug}" has no paginated list endpoint`);
+    return handler(filters);
+  },
   create: (slug: FleetResourceSlug, data: Record<string, unknown>) => createHandlers[slug](data),
   update: (slug: FleetResourceSlug, id: string, data: Record<string, unknown>) =>
     updateHandlers[slug](id, data),
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 5dec1c05e..fa80ec86c 100644
--- a/apps/edr-freight-web/backoffice/src/services/locomotives.service.ts
+++ b/apps/edr-freight-web/backoffice/src/services/locomotives.service.ts
@@ -1,3 +1,5 @@
+import type { PaginatedResponse } from '@edr/types';
+
 import { api as apiClient } from '../auth/http';
 
 import { URL_CONSTANTS } from '@/constants/URLS';
@@ -19,8 +21,31 @@ export interface LocomotiveListFilters {
   excludeCoupled?: boolean;
   /** With excludeCoupled: keep THIS train's own coupled locos in the list. */
   excludeTrainId?: string;
+  /** Free-text over code + name — only honoured by `getPaged`. */
+  search?: string;
+  /** Registration day range (YYYY-MM-DD), both ends inclusive. */
+  createdFrom?: string;
+  createdTo?: string;
+  /** Only read by `getPaged`. */
+  page?: number;
+  pageSize?: number;
 }
 
+const locomotiveListQuery = (filters: LocomotiveListFilters): string => {
+  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);
+  if (filters.search?.trim()) params.set('search', filters.search.trim());
+  if (filters.createdFrom) params.set('createdFrom', filters.createdFrom);
+  if (filters.createdTo) params.set('createdTo', filters.createdTo);
+  if (filters.page) params.set('page', String(filters.page));
+  if (filters.pageSize) params.set('pageSize', String(filters.pageSize));
+  const qs = params.toString();
+  return qs ? `?${qs}` : '';
+};
+
 export interface Locomotive {
   id: string;
   code: string;
@@ -45,17 +70,15 @@ export type SaveLocomotivePayload = Omit<
 >;
 
 export const locomotivesService = {
-  getAll: (filters: LocomotiveListFilters = {}) => {
-    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}` : ''}`,
-    );
-  },
+  getAll: (filters: LocomotiveListFilters = {}) =>
+    apiClient.get<Locomotive[]>(
+      `${URL_CONSTANTS.LOCOMOTIVES.BASE}${locomotiveListQuery(filters)}`,
+    ),
+  /** Same filters as `getAll` plus search, server-paginated ({items, meta}). */
+  getPaged: (filters: LocomotiveListFilters = {}) =>
+    apiClient.get<PaginatedResponse<Locomotive>>(
+      `${URL_CONSTANTS.LOCOMOTIVES.BASE}/paged${locomotiveListQuery(filters)}`,
+    ),
   getById: (id: string) => apiClient.get<Locomotive>(URL_CONSTANTS.LOCOMOTIVES.BY_ID(id)),
   create: (data: Partial<SaveLocomotivePayload>) =>
     apiClient.post(URL_CONSTANTS.LOCOMOTIVES.BASE, data),
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 f279f3f1e..d3795d83f 100644
--- a/apps/edr-freight-web/backoffice/src/services/routes.service.ts
+++ b/apps/edr-freight-web/backoffice/src/services/routes.service.ts
@@ -1,3 +1,5 @@
+import type { PaginatedResponse } from '@edr/types';
+
 import { api as apiClient } from '../auth/http';
 
 import { URL_CONSTANTS } from '@/constants/URLS';
@@ -78,9 +80,22 @@ export const ROUTE_STATUS_OPTIONS: Array<{ value: RouteStatus; label: string }>
   { value: 'STOP_WORKING', label: 'Stop working' },
 ];
 
+export interface RouteListFilters {
+  status?: RouteStatus;
+  search?: string;
+  page?: number;
+  pageSize?: number;
+}
+
 export const routesService = {
   getAll: (params?: { status?: RouteStatus; search?: string }) =>
     apiClient.get<RouteRecord[]>(URL_CONSTANTS.ROUTES.BASE, { params }),
+  /** Same filters as `getAll`, server-paginated ({items, meta}). */
+  getPaged: (params: RouteListFilters = {}) =>
+    apiClient.get<PaginatedResponse<RouteRecord>>(
+      `${URL_CONSTANTS.ROUTES.BASE}/paged`,
+      { params },
+    ),
   getById: (id: string) => apiClient.get<RouteRecord>(URL_CONSTANTS.ROUTES.BY_ID(id)),
   create: (data: SaveRoutePayload) => apiClient.post(URL_CONSTANTS.ROUTES.BASE, data),
   update: (id: string, data: Partial<SaveRoutePayload>) =>
diff --git a/apps/edr-freight-web/backoffice/src/services/wagon.service.ts b/apps/edr-freight-web/backoffice/src/services/wagon.service.ts
index d562625a9..9a5127f2b 100644
--- a/apps/edr-freight-web/backoffice/src/services/wagon.service.ts
+++ b/apps/edr-freight-web/backoffice/src/services/wagon.service.ts
@@ -41,10 +41,35 @@ export interface WagonListFilters {
   currentYardId?: string;
   wagonTypeId?: string;
   trainId?: string;
+  /** Drop wagons already coupled to a built train — only loose ones can be taken. */
+  unassigned?: boolean;
   /** Run number — matches a wagon whose export OR import run equals it. */
   trainNumber?: string;
+  /** Registration day range (YYYY-MM-DD), both ends inclusive. */
+  createdFrom?: string;
+  createdTo?: string;
+  /** Only read by `getPaged`. */
+  page?: number;
+  pageSize?: number;
 }
 
+const wagonListQuery = (filters: WagonListFilters): string => {
+  const params = new URLSearchParams();
+  if (filters.search?.trim()) params.set('search', filters.search.trim());
+  if (filters.status) params.set('status', filters.status);
+  if (filters.currentYardId) params.set('currentYardId', filters.currentYardId);
+  if (filters.wagonTypeId) params.set('wagonTypeId', filters.wagonTypeId);
+  if (filters.trainId) params.set('trainId', filters.trainId);
+  if (filters.unassigned) params.set('unassigned', 'true');
+  if (filters.trainNumber) params.set('trainNumber', filters.trainNumber);
+  if (filters.createdFrom) params.set('createdFrom', filters.createdFrom);
+  if (filters.createdTo) params.set('createdTo', filters.createdTo);
+  if (filters.page) params.set('page', String(filters.page));
+  if (filters.pageSize) params.set('pageSize', String(filters.pageSize));
+  const qs = params.toString();
+  return qs ? `?${qs}` : '';
+};
+
 /**
  * One row of the wagon_movements ledger: every physical relocation between
  * yards — a booking's loaded leg, an empty reposition ride, or a manual staff
@@ -70,21 +95,28 @@ export interface WagonMovementRecord {
 }
 
 export const wagonService = {
-  getAll: (filters: WagonListFilters = {}) => {
-    const params = new URLSearchParams();
-    if (filters.search?.trim()) params.set('search', filters.search.trim());
-    if (filters.status) params.set('status', filters.status);
-    if (filters.currentYardId) params.set('currentYardId', filters.currentYardId);
-    if (filters.wagonTypeId) params.set('wagonTypeId', filters.wagonTypeId);
-    if (filters.trainId) params.set('trainId', filters.trainId);
-    if (filters.trainNumber) params.set('trainNumber', filters.trainNumber);
-    const qs = params.toString();
-    return apiClient.get<Wagon[]>(`/wagons${qs ? `?${qs}` : ''}`);
+  /** One page ({items, meta}); 10 rows unless `pageSize` says otherwise. */
+  getAll: (filters: WagonListFilters = {}) =>
+    apiClient.get<PaginatedResponse<Wagon>>(`/wagons${wagonListQuery(filters)}`),
+  /**
+   * Every matching wagon, page-walked at the API's 100-row cap. For the pickers
+   * and yard views that filter the whole fleet in the browser — a list page
+   * should use `getAll` and show the real page controls instead.
+   */
+  listAll: async (filters: WagonListFilters = {}): Promise<Wagon[]> => {
+    const pageSize = 100;
+    const first = await wagonService.getAll({ ...filters, page: 1, pageSize });
+    const items = [...first.data.items];
+    for (let page = 2; page <= (first.data.meta.totalPages ?? 1); page += 1) {
+      const next = await wagonService.getAll({ ...filters, page, pageSize });
+      items.push(...next.data.items);
+    }
+    return items;
   },
   getById: (id: string) => apiClient.get<Wagon>(`/wagons/${id}`),
   getMovements: (id: string) =>
     apiClient.get<WagonMovementRecord[]>(`/wagons/${id}/movements`),
-  getByTrain: (trainId: string) => apiClient.get<Wagon[]>(`/wagons?trainId=${trainId}`),
+  getByTrain: (trainId: string) => wagonService.listAll({ trainId }),
   assignToTrain: (wagonId: string, trainId: string, sequenceNumber?: number) =>
     apiClient.post(`/wagons/${wagonId}/assign-train`, { trainId, sequenceNumber }),
   unassign: (wagonId: string) => apiClient.post(`/wagons/${wagonId}/unassign-train`),
diff --git a/apps/edr-freight-web/backoffice/src/shared/services/axiosInstance.ts b/apps/edr-freight-web/backoffice/src/shared/services/axiosInstance.ts
index d0e7f5866..a14c6b87f 100644
--- a/apps/edr-freight-web/backoffice/src/shared/services/axiosInstance.ts
+++ b/apps/edr-freight-web/backoffice/src/shared/services/axiosInstance.ts
@@ -25,6 +25,9 @@ axiosInstance.interceptors.request.use((config) => {
   }
   // X-Requested-With prevents CSRF via browser-native form/fetch without custom headers
   config.headers["X-Requested-With"] = "XMLHttpRequest";
+  // Tells the backend which app is asking, so /auth/login can reject
+  // cross-audience credentials (EDRFREIGHT-415).
+  config.headers["X-Client-App"] = "backoffice";
   return config;
 });
 
diff --git a/apps/edr-freight-web/portal/src/App.tsx b/apps/edr-freight-web/portal/src/App.tsx
index 72674363c..a115e1363 100644
--- a/apps/edr-freight-web/portal/src/App.tsx
+++ b/apps/edr-freight-web/portal/src/App.tsx
@@ -46,7 +46,6 @@ import BookingContractPage from "./pages/bookings/BookingContractPage";
 import BookingDetailPage from "./pages/bookings/BookingDetailPage";
 import BookingsListPage from "./pages/bookings/BookingsListPage";
 import EditBookingPage from "./pages/bookings/EditBookingPage";
-import ContractClearanceFlow from "./pages/contracts/ContractClearanceFlow";
 import ContractDetailPage from "./pages/contracts/ContractDetailPage";
 import ContractViewPage from "./pages/contracts/ContractViewPage";
 import ContractsList from "./pages/contracts/ContractsList";
@@ -336,10 +335,6 @@ const App = () => {
               path="/contracts/:id/bookings/:bookingId/complete"
               element={<NewShipmentPage />}
             />
-            <Route
-              path="/contracts/:id/clearance"
-              element={<ContractClearanceFlow />}
-            />
             <Route
               path="/contracts/:id/view"
               element={<ContractViewPage />}
diff --git a/apps/edr-freight-web/portal/src/components/contracts/StampUpload.tsx b/apps/edr-freight-web/portal/src/components/contracts/StampUpload.tsx
index 1c1e4d87c..bdf47c5fd 100644
--- a/apps/edr-freight-web/portal/src/components/contracts/StampUpload.tsx
+++ b/apps/edr-freight-web/portal/src/components/contracts/StampUpload.tsx
@@ -2,7 +2,7 @@ import { useRef, useState } from "react";
 import { Box, Button, Group, Image, Paper, Stack, Text } from "@mantine/core";
 import { RefreshCw, Stamp, X } from "lucide-react";
 
-const MAX_STAMP_MB = 5;
+const MAX_STAMP_MB = 10;
 
 export interface StampUploadProps {
   /** Stamp image as a data URL, or null when none is attached yet. */
diff --git a/apps/edr-freight-web/portal/src/components/customer-actions/ContractClearanceAction.tsx b/apps/edr-freight-web/portal/src/components/customer-actions/ContractClearanceAction.tsx
deleted file mode 100644
index fbb8f97c2..000000000
--- a/apps/edr-freight-web/portal/src/components/customer-actions/ContractClearanceAction.tsx
+++ /dev/null
@@ -1,90 +0,0 @@
-import { useMemo } from "react";
-import { useQuery } from "@tanstack/react-query";
-import { Button, Modal, Text, type ButtonProps } from "@mantine/core";
-import { AlertCircle, Upload, type LucideIcon } from "lucide-react";
-
-import { api } from "@/services/api";
-import { ContractClearancePanel } from "@/pages/contracts/ContractClearancePanel";
-import { ModalSafeWrapper } from "./ModalSafeWrapper";
-import { useDisclosure } from "@mantine/hooks";
-
-interface ContractClearanceActionProps {
-  contractId: string;
-  label?: string;
-  size?: ButtonProps["size"];
-  urgent?: boolean;
-  /** GL's turn — render as a calm status button, not a call to action. */
-  waiting?: boolean;
-  /** Icon override from the phase-aware action derivation. */
-  icon?: LucideIcon;
-}
-
-export function ContractClearanceAction({
-  contractId,
-  label: labelProp,
-  size = "xs",
-  urgent = false,
-  waiting = false,
-  icon: iconProp,
-}: ContractClearanceActionProps) {
-  const [opened, { open, close }] = useDisclosure(false);
-
-  const { data: clearance } = useQuery({
-    ...api.contracts.getClearance.queryOptions({ input: { id: contractId } }),
-    enabled: opened,
-  });
-
-  const label = useMemo(() => {
-    if (labelProp) return labelProp;
-    const docs = clearance?.documents ?? [];
-    const queried = docs.filter(
-      (d) => d.uploadedBy === "customer" && d.reviewStatus === "QUERIED",
-    ).length;
-    if (queried > 0) return "Update clearance";
-    return urgent ? "Upload clearance" : "Manage clearance";
-  }, [labelProp, clearance, urgent]);
-
-  const Icon =
-    iconProp ?? (urgent || label.includes("Update") ? AlertCircle : Upload);
-
-  // Urgent (customer's turn) = filled orange so it stands out among the green
-  // actions; waiting (GL's turn) = calm subtle gray; default = brand green.
-  const color = urgent ? "orange" : waiting ? "gray" : "edr-green";
-  const variant = waiting ? "light" : "filled";
-
-  return (
-    <ModalSafeWrapper>
-      <Button
-        size={size}
-        radius="md"
-        fw={700}
-        fz={13}
-        color={color}
-        variant={variant}
-        leftSection={<Icon size={14} />}
-        onClick={(e) => {
-          e.stopPropagation();
-          open();
-        }}
-      >
-        {label}
-      </Button>
-
-      <Modal
-        opened={opened}
-        onClose={close}
-        title={
-          <Text fw={700} fz={16}>
-            Clearance documents
-          </Text>
-        }
-        size="xl"
-        radius="md"
-        centered
-        overlayProps={{ blur: 2, backgroundOpacity: 0.55 }}
-      >
-        <ContractClearancePanel contractId={contractId} bare onSubmitted={close} />
-      </Modal>
-    </ModalSafeWrapper>
-  );
-}
diff --git a/apps/edr-freight-web/portal/src/components/customer-actions/ContractCustomerAction.tsx b/apps/edr-freight-web/portal/src/components/customer-actions/ContractCustomerAction.tsx
index 86c37585c..4555a5db8 100644
--- a/apps/edr-freight-web/portal/src/components/customer-actions/ContractCustomerAction.tsx
+++ b/apps/edr-freight-web/portal/src/components/customer-actions/ContractCustomerAction.tsx
@@ -16,7 +16,7 @@ import type { Freight } from "@edr/types";
 
 import { PayNowButton } from "@/pages/bookings/payments/PayNowButton";
 import { api } from "@/services/api";
-import { ContractClearanceAction } from "./ContractClearanceAction";
+import { bookingDocNoun } from "@/pages/bookings/clearance/bookingNextAction";
 import { deriveContractCustomerAction } from "./deriveContractCustomerAction";
 
 interface ContractCustomerActionProps {
@@ -50,19 +50,6 @@ export function ContractCustomerAction({
       }
     : undefined;
 
-  if (action.type === "clearance") {
-    return (
-      <ContractClearanceAction
-        contractId={action.contractId}
-        label={action.label}
-        size={size}
-        urgent={action.urgent}
-        waiting={action.waiting}
-        icon={action.icon}
-      />
-    );
-  }
-
   if (action.type === "pay") {
     return (
       <PayNowButton booking={action.booking} label={action.label} size={size} />
@@ -106,9 +93,9 @@ export function ContractCustomerAction({
 }
 
 /**
- * One-click bare booking instance under a GENERAL non-customs contract. No
- * form, no date, no window gate — the new instance lands in per-booking
- * clearance (AWAITING_DOCUMENTS) and the customer is taken straight to it.
+ * One-click bare booking instance under a self-clearance import/export contract
+ * — ONE_TIME or GENERAL. No form, no date, no window gate: the new instance
+ * lands in per-booking clearance (AWAITING_DOCUMENTS) with the customer on it.
  */
 export function InitiateBookingButton({
   contract,
@@ -145,7 +132,7 @@ export function InitiateBookingButton({
         queryKey: api.contracts.get.queryKey({ id: contract.id }),
       });
       toast.success(
-        "Booking initiated — upload your clearance documents to start the review.",
+        `Booking initiated — upload your ${bookingDocNoun(contract)} to start the review.`,
       );
       setConfirmOpen(false);
       navigate(`/bookings/${booking.id}`);
@@ -181,7 +168,7 @@ export function InitiateBookingButton({
           <Text span fw={700} c="#10202F">
             {contract.reference}
           </Text>
-          . You&apos;ll upload the clearance documents next, and the shipment
+          . You&apos;ll upload the {bookingDocNoun(contract)} next, and the shipment
           quantity is drawn down from your contract&apos;s reserved capacity.
         </Text>
         <Group justify="flex-end" gap="sm" mt="lg">
diff --git a/apps/edr-freight-web/portal/src/components/customer-actions/deriveContractCustomerAction.ts b/apps/edr-freight-web/portal/src/components/customer-actions/deriveContractCustomerAction.ts
index ddd64d3e8..445c1ab6a 100644
--- a/apps/edr-freight-web/portal/src/components/customer-actions/deriveContractCustomerAction.ts
+++ b/apps/edr-freight-web/portal/src/components/customer-actions/deriveContractCustomerAction.ts
@@ -4,43 +4,13 @@ import {
   CreditCard,
   Eye,
   FileSignature,
-  Hourglass,
   PackagePlus,
   PencilLine,
-  Receipt,
   RotateCcw,
-  Upload,
 } from "lucide-react";
 
 import { getContractBookingAction } from "@/pages/contracts/contract-booking-action";
 
-const CLEARANCE_IN_PROGRESS_STATUSES = [
-  "AWAITING_CLEARANCE_DOCUMENTS",
-  "CLEARANCE_UNDER_REVIEW",
-];
-
-export function contractNeedsClearanceAction(c: Freight.IContract): {
-  show: boolean;
-  urgent: boolean;
-} {
-  const clearance = (c as { clearanceStatus?: string }).clearanceStatus;
-  const ready =
-    clearance === "CLEARANCE_READY_FOR_BOOKING" ||
-    clearance === "SELF_CLEARED" ||
-    clearance === "ACTIVE_SHIPMENT_IN_PROGRESS";
-  if (ready) return { show: false, urgent: false };
-
-  const awaiting =
-    c.status === "AWAITING_CLEARANCE_DOCUMENTS" ||
-    clearance === "AWAITING_DOCUMENTS";
-  const inProgress =
-    CLEARANCE_IN_PROGRESS_STATUSES.includes(c.status) ||
-    clearance === "AWAITING_DOCUMENTS" ||
-    clearance === "DOCUMENTS_UNDER_REVIEW";
-
-  return { show: inProgress, urgent: awaiting };
-}
-
 export type ContractCustomerAction =
   | {
       type: "sign";
@@ -56,16 +26,6 @@ export type ContractCustomerAction =
       primary: boolean;
       icon: LucideIcon;
     }
-  | {
-      type: "clearance";
-      contractId: string;
-      label: string;
-      primary: boolean;
-      icon: LucideIcon;
-      urgent: boolean;
-      /** True when it's GL's turn — render calm/informational, not a call to action. */
-      waiting?: boolean;
-    }
   | {
       type: "pay";
       booking: Freight.IBooking;
@@ -148,60 +108,6 @@ export function deriveContractCustomerAction(
     };
   }
 
-  const clr = contractNeedsClearanceAction(contract);
-  if (clr.show) {
-    // Refine the generic clearance action by the persisted clearance phase so
-    // the button says what the customer actually has to do right now (e.g.
-    // "Pay duty & upload slip" during CUSTOMER_DUTY, not "Update clearance").
-    const phase = contract.clearancePhase ?? null;
-    switch (phase) {
-      case "CUSTOMER_INTAKE":
-        return {
-          type: "clearance",
-          contractId: id,
-          label: "Upload clearance documents",
-          primary: true,
-          icon: Upload,
-          urgent: true,
-        };
-      case "CUSTOMER_DUTY":
-        return {
-          type: "clearance",
-          contractId: id,
-          label: "Pay duty & upload slip",
-          primary: true,
-          icon: Receipt,
-          urgent: true,
-        };
-      case "GL_ET_REVIEW":
-      case "GL_DJ_COLLECTION":
-      case "GL_ET_OUTPUT":
-      case "GL_ET_POST_CLEARANCE":
-      case "GL_DJ_LOADING":
-      case "POST_TRANSIT":
-        // GL's turn — nothing for the customer to do; show a calm status.
-        return {
-          type: "clearance",
-          contractId: id,
-          label: "Clearance in progress",
-          primary: false,
-          icon: Hourglass,
-          urgent: false,
-          waiting: true,
-        };
-      default:
-        // No persisted phase (legacy / early cycles) — keep the status-derived label.
-        return {
-          type: "clearance",
-          contractId: id,
-          label: clr.urgent ? "Upload clearance" : "Update clearance",
-          primary: true,
-          icon: Upload,
-          urgent: clr.urgent,
-        };
-    }
-  }
-
   if (
     contract.customsClearingEnabled &&
     ["CLEARANCE_READY_FOR_BOOKING", "ACTIVE_SHIPMENT_IN_PROGRESS"].includes(
diff --git a/apps/edr-freight-web/portal/src/constants/URLS.ts b/apps/edr-freight-web/portal/src/constants/URLS.ts
index 7db110aba..3e0ad34cb 100644
--- a/apps/edr-freight-web/portal/src/constants/URLS.ts
+++ b/apps/edr-freight-web/portal/src/constants/URLS.ts
@@ -149,6 +149,7 @@ export const URL_CONSTANTS = {
     CONTRACT_SEND_SIGNING_OTP: (id: string) =>
       `/api/contracts/${id}/contract/send-signing-otp`,
     RENEW: (id: string) => `/api/contracts/${id}/renew`,
+    CANCEL: (id: string) => `/api/contracts/${id}/cancel`,
     CLEARANCE: (id: string) => `/api/contracts/${id}/clearance`,
     CLEARANCE_DOCUMENTS: (id: string) =>
       `/api/contracts/${id}/clearance/documents`,
diff --git a/apps/edr-freight-web/portal/src/pages/MyPortalPage/actions.ts b/apps/edr-freight-web/portal/src/pages/MyPortalPage/actions.ts
index de4b387b1..962b59bcc 100644
--- a/apps/edr-freight-web/portal/src/pages/MyPortalPage/actions.ts
+++ b/apps/edr-freight-web/portal/src/pages/MyPortalPage/actions.ts
@@ -1,27 +1,24 @@
 import type { Freight } from "@edr/types";
 
-import { contractNeedsClearanceAction } from "@/components/customer-actions/deriveContractCustomerAction";
-
 /** A pending customer action surfaced on the home "needs attention" card. */
 export interface ActionItem {
   id: string;
   /** What the customer must do — drives the icon, label and modal. */
-  kind: "clearance" | "duty" | "sign" | "book" | "pay";
+  kind: "sign" | "book" | "pay";
   /** The contract/booking reference for display. */
   reference: string;
   /** Short human description of the action. */
   description: string;
-  /** Contract id (clearance/sign/book) or booking id (pay). */
+  /** Contract id (sign/book) or booking id (pay). */
   targetId: string;
-  /** True for queried clearance (a document was sent back for correction). */
+  /** Highlighted as action-required in the home card. */
   urgent?: boolean;
 }
 
 /**
  * Derive the list of pending customer actions from the customer's contracts and
- * bookings. A contract in AWAITING_CLEARANCE_DOCUMENTS (initial upload or a
- * re-upload after a query) is flagged urgent so the home card shows an upload
- * button. See {@link contractNeedsClearanceAction}.
+ * bookings. Clearance never appears here any more: documents live on the
+ * shipment booking, so a pending upload surfaces as a booking action.
  */
 export function deriveActionItems(
   contracts: Freight.IContract[],
@@ -40,20 +37,6 @@ export function deriveActionItems(
       });
       continue;
     }
-    const clr = contractNeedsClearanceAction(c);
-    if (clr.show) {
-      items.push({
-        id: `clearance-${c.id}`,
-        kind: "clearance",
-        reference: c.reference,
-        description: clr.urgent
-          ? "Clearance documents need your action"
-          : "Clearance under review",
-        targetId: c.id,
-        urgent: clr.urgent,
-      });
-      continue;
-    }
     // Path A transport-only: customer may create the shipment booking.
     if (
       !c.customsClearingEnabled &&
diff --git a/apps/edr-freight-web/portal/src/pages/MyPortalPage/components/ActionNeededSection.tsx b/apps/edr-freight-web/portal/src/pages/MyPortalPage/components/ActionNeededSection.tsx
index 9e3fd13ec..ecd3d7df2 100644
--- a/apps/edr-freight-web/portal/src/pages/MyPortalPage/components/ActionNeededSection.tsx
+++ b/apps/edr-freight-web/portal/src/pages/MyPortalPage/components/ActionNeededSection.tsx
@@ -1,140 +1,53 @@
-import { useMemo, useState } from "react";
+import { useState } from "react";
 import { useNavigate } from "react-router-dom";
-import { useMutation, useQueries, useQuery } from "@tanstack/react-query";
-import { Badge, Box, Button, Group, Modal, Stack, Text } from "@mantine/core";
+import { useMutation, useQuery } from "@tanstack/react-query";
+import { Badge, Box, Button, Group, Stack, Text } from "@mantine/core";
 import {
   AlertTriangle,
   CreditCard,
   FilePlus2,
   FileSignature,
   PackagePlus,
-  Receipt,
-  Upload,
 } from "lucide-react";
-import type { Freight } from "@edr/types";
 
 import { api } from "@/services/api";
 import { ModalSafeWrapper } from "@/components/customer-actions/ModalSafeWrapper";
 import { paymentsService, type PaymentMethod } from "@/services/payments.service";
 import { invoicesService } from "@/services/invoices.service";
 import { isPayable } from "@/pages/billing/invoice-ui";
-import { ContractClearancePanel } from "@/pages/contracts/ContractClearancePanel";
 import { PaymentMethodModal } from "@/pages/bookings/BookingDetailPage/components/PaymentMethodModal";
 import { Card } from "./Card";
 import type { ActionItem } from "../actions";
 
-// Contracts whose clearance is still in progress — candidates for a real
-// per-document query check (small set; only contracts awaiting/under review).
-const CLEARANCE_CANDIDATE_STATUSES = [
-  "AWAITING_CLEARANCE_DOCUMENTS",
-  "CLEARANCE_UNDER_REVIEW",
-];
-
 const KIND_META: Record<
   ActionItem["kind"],
-  { icon: typeof Upload; label: string; color: string }
+  { icon: typeof CreditCard; label: string; color: string }
 > = {
-  clearance: { icon: Upload, label: "Clearance", color: "edr-green" },
-  duty: { icon: Receipt, label: "Duty / tax", color: "orange" },
   sign: { icon: FileSignature, label: "Sign", color: "blue" },
   book: { icon: PackagePlus, label: "Book", color: "violet" },
   pay: { icon: CreditCard, label: "Payment", color: "orange" },
 };
 
 export interface ActionNeededSectionProps {
-  /** Non-clearance actions (sign / book / pay) derived from status. */
+  /** Pending actions (sign / book / pay) derived from status. */
   items: ActionItem[];
-  /** All of the customer's contracts — used to detect real clearance queries. */
-  contracts: Freight.IContract[];
 }
 
 /**
  * Home "needs your attention" card. Lists pending customer actions across
- * contracts and bookings. Clearance items are derived from the ACTUAL clearance
- * documents (so an open query always surfaces an upload button), payment + the
- * clearance upload open in a modal right here; sign and book navigate.
+ * contracts and bookings: payment opens a modal right here; sign and book
+ * navigate. Clearance is a per-booking action and lives on the booking page.
  */
-export function ActionNeededSection({
-  items: baseItems,
-  contracts,
-}: ActionNeededSectionProps) {
+export function ActionNeededSection({ items: base }: ActionNeededSectionProps) {
   const navigate = useNavigate();
-  const [clearanceId, setClearanceId] = useState<string | null>(null);
   const [payItem, setPayItem] = useState<ActionItem | null>(null);
 
-  // Fetch the clearance view for every contract still in a clearance phase, so we
-  // can detect a queried document precisely (status alone can be ambiguous).
-  const candidates = useMemo(
-    () =>
-      contracts.filter((c) =>
-        CLEARANCE_CANDIDATE_STATUSES.includes(c.status),
-      ),
-    [contracts],
+  // Urgent first; clearance never appears here — those documents live on the
+  // shipment booking, and its own detail page drives that upload.
+  const items = [...base].sort(
+    (a, b) => Number(b.urgent ?? 0) - Number(a.urgent ?? 0),
   );
 
-  const clearanceQueries = useQueries({
-    queries: candidates.map((c) =>
-      api.contracts.getClearance.queryOptions({ input: { id: c.id } }),
-    ),
-  });
-
-  // Build clearance action items from the fetched views: show whenever the
-  // customer can still upload (not yet ready for booking), flag urgent + show the
-  // query count when any document was sent back for correction.
-  const clearanceItems = useMemo<ActionItem[]>(() => {
-    const out: ActionItem[] = [];
-    candidates.forEach((c, i) => {
-      const view = clearanceQueries[i]?.data;
-      const docs = view?.documents ?? [];
-      const customerDocs = docs.filter((d) => d.uploadedBy === "customer");
-      const queried = customerDocs.filter(
-        (d) => d.reviewStatus === "QUERIED",
-      ).length;
-      const ready =
-        view?.clearanceStatus === "CLEARANCE_READY_FOR_BOOKING" ||
-        view?.clearanceStatus === "SELF_CLEARED" ||
-        view?.clearanceStatus === "ACTIVE_SHIPMENT_IN_PROGRESS";
-      if (ready) return;
-      const awaiting =
-        c.status === "AWAITING_CLEARANCE_DOCUMENTS" ||
-        view?.clearanceStatus === "AWAITING_DOCUMENTS";
-      // Duty phase: the customer's task is paying duty/tax and uploading the
-      // slip — a distinct, money action, not a generic document upload.
-      if (view?.phase === "CUSTOMER_DUTY") {
-        out.push({
-          id: `duty-${c.id}`,
-          kind: "duty",
-          reference: c.reference,
-          description: "Duty / tax payment due — pay and upload the slip",
-          targetId: c.id,
-          urgent: true,
-        });
-        return;
-      }
-      // Only surface when there's something the customer can do: a query, or the
-      // contract is awaiting their (re)upload.
-      if (queried === 0 && !awaiting) return;
-      out.push({
-        id: `clearance-${c.id}`,
-        kind: "clearance",
-        reference: c.reference,
-        description:
-          queried > 0
-            ? `${queried} document${queried > 1 ? "s" : ""} need correction`
-            : "Clearance documents needed",
-        targetId: c.id,
-        urgent: queried > 0 || awaiting,
-      });
-    });
-    return out;
-  }, [candidates, clearanceQueries]);
-
-  // Merge: clearance items (from real docs) + the status-derived sign/book/pay.
-  const items = useMemo(
-    () => [...clearanceItems, ...baseItems.filter((i) => i.kind !== "clearance")],
-    [clearanceItems, baseItems],
-  ).sort((a, b) => Number(b.urgent ?? 0) - Number(a.urgent ?? 0));
-
   // Billing is invoice-centric — resolve the booking's currently payable
   // invoice before paying it (mirrors ReadonlyBookingView).
   const { data: payItemInvoices = [] } = useQuery({
@@ -175,13 +88,6 @@ export function ActionNeededSection({
 
   const handleClick = (item: ActionItem) => {
     switch (item.kind) {
-      case "clearance":
-        setClearanceId(item.targetId);
-        break;
-      case "duty":
-        // Duty advice + payment-slip upload live on the contract detail page.
-        navigate(`/contracts/${item.targetId}`);
-        break;
       case "pay":
         setPayItem(item);
         break;
@@ -266,27 +172,13 @@ export function ActionNeededSection({
                 variant={item.urgent ? "filled" : "light"}
                 color={meta.color}
                 radius="md"
-                leftSection={
-                  item.kind === "clearance" ? (
-                    <Upload size={14} />
-                  ) : item.kind === "duty" ? (
-                    <Receipt size={14} />
-                  ) : (
-                    <FilePlus2 size={14} />
-                  )
-                }
+                leftSection={<FilePlus2 size={14} />}
               >
                 {item.kind === "pay"
                   ? "Pay now"
-                  : item.kind === "duty"
-                    ? "Pay duty & upload slip"
-                    : item.kind === "sign"
-                      ? "Sign"
-                      : item.kind === "book"
-                        ? "Book"
-                        : item.urgent
-                          ? "Upload documents"
-                          : "Upload"}
+                  : item.kind === "sign"
+                    ? "Sign"
+                    : "Book"}
               </Button>
             </Group>
           );
@@ -294,24 +186,6 @@ export function ActionNeededSection({
       </Stack>
 
       <ModalSafeWrapper>
-        <Modal
-          opened={clearanceId !== null}
-          onClose={() => setClearanceId(null)}
-          title={
-            <Text fw={700} fz={16}>
-              Clearance documents
-            </Text>
-          }
-          size="xl"
-          radius="md"
-          centered
-          overlayProps={{ blur: 2, backgroundOpacity: 0.55 }}
-        >
-          {clearanceId && (
-            <ContractClearancePanel contractId={clearanceId} bare />
-          )}
-        </Modal>
-
         <PaymentMethodModal
           opened={payItem !== null}
           onClose={() => {
diff --git a/apps/edr-freight-web/portal/src/pages/MyPortalPage/constants.ts b/apps/edr-freight-web/portal/src/pages/MyPortalPage/constants.ts
index 7be5a0aed..7515befb9 100644
--- a/apps/edr-freight-web/portal/src/pages/MyPortalPage/constants.ts
+++ b/apps/edr-freight-web/portal/src/pages/MyPortalPage/constants.ts
@@ -170,7 +170,9 @@ export const STATUS_CONFIG: Record<string, StageConfig> = {
     icon: FileUp,
     iconColor: "edr-amber-text",
     tile: "edr-amber-soft",
-    hint: "Clearance documents needed",
+    // Direction-neutral: a self-clearance shipment collects the customer's own
+    // import/export papers, a customs one collects the clearance set.
+    hint: "Documents needed",
     step: "edr-accent",
     badgeLabel: "Upload documents",
     badgeBg: "edr-amber-soft",
@@ -521,9 +523,9 @@ export const STATUS_CONFIG: Record<string, StageConfig> = {
     icon: CheckCircle2,
     iconColor: "edr-slate",
     tile: "edr-slate-soft2",
-    hint: "Contract closed · quantity used or window elapsed",
+    hint: "Contract completed · shipment delivered, quantity used or window elapsed",
     step: "edr-step",
-    badgeLabel: "Closed",
+    badgeLabel: "Completed",
     badgeBg: "edr-slate-soft2",
     badgeText: "edr-slate",
     badgeDot: "edr-step",
diff --git a/apps/edr-freight-web/portal/src/pages/bookings/BookingClearanceWorkflowBanner.tsx b/apps/edr-freight-web/portal/src/pages/bookings/BookingClearanceWorkflowBanner.tsx
index c8b133a24..1589d250b 100644
--- a/apps/edr-freight-web/portal/src/pages/bookings/BookingClearanceWorkflowBanner.tsx
+++ b/apps/edr-freight-web/portal/src/pages/bookings/BookingClearanceWorkflowBanner.tsx
@@ -1,29 +1,73 @@
 import { useState } from "react";
-import { Alert, Anchor, Button, FileInput, Group, Paper, Stack, Text } from "@mantine/core";
-import { AlertTriangle, Download, Receipt, Upload } from "lucide-react";
+import {
+  Alert,
+  Anchor,
+  Badge,
+  Box,
+  Button,
+  FileInput,
+  Group,
+  Paper,
+  Stack,
+  Text,
+  Textarea,
+} from "@mantine/core";
+import {
+  AlertTriangle,
+  Download,
+  Eye,
+  FileBadge,
+  MessageSquareWarning,
+  Receipt,
+  Upload,
+} from "lucide-react";
 import { useQuery } from "@tanstack/react-query";
 import toast from "react-hot-toast";
 import type { Freight } from "@edr/types";
 
 import { bookingsService } from "@/services/bookings.service";
+import { contractsService } from "@/services/contracts.service";
 import { downloadStoredFile } from "@/services/files.service";
 import { ClearancePhaseStepper } from "../contracts/ClearancePhaseStepper";
 import { ClearanceUploadedDocumentsPanel } from "@/components/contracts/ClearanceUploadedDocumentsPanel";
 import { useFileViewer } from "@/hooks/useFileViewer";
+import { GREEN, INK } from "../contracts/contract-ui";
 
 const BORDER = "#E6ECF2";
 
+// Customer-facing labels for an invoice status (Freight.InvoiceStatus).
+const INVOICE_STATUS_LABELS: Record<string, string> = {
+  DRAFT: "Draft",
+  ISSUED: "Issued",
+  PENDING: "Due",
+  PARTIALLY_PAID: "Partially paid",
+  PAID: "Paid",
+  OVERDUE: "Overdue",
+  CANCELLED: "Cancelled",
+  REFUNDED: "Refunded",
+  EXPIRED: "Expired",
+};
+
+function invoiceStatusLabel(status: string): string {
+  return (
+    INVOICE_STATUS_LABELS[status] ??
+    status
+      .replace(/_/g, " ")
+      .toLowerCase()
+      .replace(/\b\w/g, (m) => m.toUpperCase())
+  );
+}
+
+
+
 export function BookingClearanceWorkflowBanner({
   booking,
 }: {
   booking: Freight.IBooking;
 }) {
-  // Drawdown bookings under a GENERAL contract keep bookingType = ONE_TIME —
-  // the denormalized contractKind is what marks them as phased (Path B).
-  const isPhased =
-    booking.customsClearingEnabled &&
-    (booking.bookingType === "GENERAL_CONTRACT" ||
-      booking.contractKind === "GENERAL");
+  // Every contract booking whose service bundles customs runs the phased GL
+  // workflow now — ONE_TIME and GENERAL alike.
+  const isPhased = Boolean(booking.customsClearingEnabled && booking.contractId);
 
   const { view, viewer } = useFileViewer();
 
@@ -42,6 +86,9 @@ export function BookingClearanceWorkflowBanner({
     clearance.dutyRequired &&
     clearance.dutyAdvice &&
     !dutyPaid;
+  // A dispute clears the advice while it's open — show the "waiting on GL"
+  // state instead of the pay panel until GL re-advises.
+  const dutyDisputePending = Boolean(clearance.dutyDispute);
 
   return (
     <Paper withBorder radius="lg" p="lg" style={{ borderColor: BORDER }}>
@@ -67,11 +114,52 @@ export function BookingClearanceWorkflowBanner({
           </Alert>
         ) : null}
 
-        {dutyPending && clearance.dutyAdvice ? (
+        {dutyDisputePending && clearance.dutyDispute ? (
+          <DutyDisputePendingCard dispute={clearance.dutyDispute} />
+        ) : dutyPending && clearance.dutyAdvice ? (
           <DutyAdvicePanel
             dutyAdvice={clearance.dutyAdvice}
             bookingId={booking.id}
-            onUploaded={() => void refetch()}
+            onChanged={() => void refetch()}
+          />
+        ) : null}
+
+        {clearance.riskLevel ? (
+          <Group gap={10} align="center">
+            <Text fw={700} fz={14} c={INK}>
+              Customs risk level
+            </Text>
+            <Badge
+              color={CUSTOMS_RISK_COLOR[clearance.riskLevel] ?? "gray"}
+              variant="filled"
+              radius="sm"
+            >
+              {clearance.riskLevel.charAt(0) +
+                clearance.riskLevel.slice(1).toLowerCase()}
+            </Badge>
+            {clearance.riskAssignedAt ? (
+              <Text fz={12} c="dimmed">
+                assigned {new Date(clearance.riskAssignedAt).toLocaleString()}
+              </Text>
+            ) : null}
+          </Group>
+        ) : null}
+
+        {clearance.secondDuty?.advised ? (
+          <SecondDutyDueCard
+            duty={clearance.secondDuty}
+            bookingId={booking.id}
+            onView={(f) => view(f)}
+            onChanged={() => void refetch()}
+          />
+        ) : null}
+
+        {clearance.finalInvoice ? (
+          <FinalInvoiceDueCard
+            invoice={clearance.finalInvoice}
+            bookingId={booking.id}
+            onView={(f) => view(f)}
+            onChanged={() => void refetch()}
           />
         ) : null}
 
@@ -97,14 +185,17 @@ export function BookingClearanceWorkflowBanner({
 function DutyAdvicePanel({
   dutyAdvice,
   bookingId,
-  onUploaded,
+  onChanged,
 }: {
   dutyAdvice: NonNullable<Freight.ClearanceView["dutyAdvice"]>;
   bookingId: string;
-  onUploaded: () => void;
+  onChanged: () => void;
 }) {
   const [file, setFile] = useState<File | null>(null);
   const [loading, setLoading] = useState(false);
+  const [disputing, setDisputing] = useState(false);
+  const [note, setNote] = useState("");
+  const [submittingDispute, setSubmittingDispute] = useState(false);
   const noticeFile = dutyAdvice.noticeFile;
 
   return (
@@ -148,7 +239,7 @@ function DutyAdvicePanel({
             try {
               await bookingsService.uploadBookingClearanceDutySlip(bookingId, file);
               toast.success("Payment slip uploaded");
-              onUploaded();
+              onChanged();
             } catch (e) {
               toast.error(e instanceof Error ? e.message : "Upload failed");
             } finally {
@@ -158,11 +249,101 @@ function DutyAdvicePanel({
         >
           Submit payment slip
         </Button>
+
+        {disputing ? (
+          <Stack gap={6}>
+            <Textarea
+              label="What's wrong with this amount?"
+              placeholder="Explain why you're disputing the advised duty/tax…"
+              minRows={2}
+              autosize
+              value={note}
+              onChange={(e) => setNote(e.currentTarget.value)}
+            />
+            <Group gap="xs">
+              <Button
+                variant="default"
+                size="xs"
+                onClick={() => {
+                  setDisputing(false);
+                  setNote("");
+                }}
+              >
+                Cancel
+              </Button>
+              <Button
+                color="red"
+                size="xs"
+                loading={submittingDispute}
+                disabled={!note.trim()}
+                onClick={async () => {
+                  setSubmittingDispute(true);
+                  try {
+                    await bookingsService.disputeBookingClearanceDuty(
+                      bookingId,
+                      note.trim(),
+                    );
+                    toast.success("Sent to GL Ethiopia for review");
+                    setDisputing(false);
+                    setNote("");
+                    onChanged();
+                  } catch (e) {
+                    toast.error(e instanceof Error ? e.message : "Failed to send");
+                  } finally {
+                    setSubmittingDispute(false);
+                  }
+                }}
+              >
+                Submit request
+              </Button>
+            </Group>
+          </Stack>
+        ) : (
+          <Anchor
+            component="button"
+            type="button"
+            size="sm"
+            c="dimmed"
+            onClick={() => setDisputing(true)}
+          >
+            Not right? Request a change
+          </Anchor>
+        )}
       </Stack>
     </Paper>
   );
 }
 
+/** The customer's dispute is open — GL Ethiopia owes a corrected advice. */
+function DutyDisputePendingCard({
+  dispute,
+}: {
+  dispute: NonNullable<Freight.ClearanceView["dutyDispute"]>;
+}) {
+  return (
+    <Alert
+      color="orange"
+      radius="md"
+      icon={<MessageSquareWarning size={16} />}
+      title={
+        dispute.rounds > 1
+          ? `Waiting on GL Ethiopia (round ${dispute.rounds})`
+          : "Waiting on GL Ethiopia"
+      }
+    >
+      <Stack gap={4}>
+        <Text size="sm" style={{ whiteSpace: "pre-wrap" }}>
+          {dispute.note}
+        </Text>
+        <Text size="xs" c="dimmed">
+          Sent {new Date(dispute.raisedAt).toLocaleString()} — you'll see the
+          corrected amount here once GL Ethiopia re-advises.
+        </Text>
+      </Stack>
+    </Alert>
+  );
+}
+
 function GroupLabel({ icon: Icon, text }: { icon: typeof Receipt; text: string }) {
   return (
     <div style={{ display: "flex", alignItems: "center", gap: 8 }}>
@@ -173,3 +354,295 @@ function GroupLabel({ icon: Icon, text }: { icon: typeof Receipt; text: string }
     </div>
   );
 }
+
+/**
+ * Post-offload final invoice from GL Djibouti (export): shows the due amount +
+ * invoice document; the customer pays offline and attaches the payment slip
+ * here, then GL confirms and the badge flips to PAID.
+ */
+function FinalInvoiceDueCard({
+  invoice,
+  bookingId,
+  onView,
+  onChanged,
+}: {
+  invoice: NonNullable<Freight.ClearanceView["finalInvoice"]>;
+  bookingId: string;
+  onView: (file: { name: string; url: string }) => void;
+  onChanged: () => void;
+}) {
+  const [slip, setSlip] = useState<File | null>(null);
+  const [uploading, setUploading] = useState(false);
+  const paid = invoice.status === "PAID";
+
+  return (
+    <Paper
+      withBorder
+      radius="lg"
+      p="lg"
+      style={{
+        borderColor: paid ? "#CDEBDD" : "#F2D9A6",
+        background: paid ? "#F6FBF8" : "#FFFBF2",
+        position: "relative",
+        overflow: "hidden",
+      }}
+    >
+      <Box
+        style={{
+          position: "absolute",
+          left: 0,
+          top: 0,
+          bottom: 0,
+          width: 3,
+          background: paid ? GREEN : "#E3A93C",
+        }}
+      />
+      <Group justify="space-between" align="flex-start" wrap="wrap" gap="md">
+        <div>
+          <Group gap={8} align="center">
+            <FileBadge size={16} color={paid ? GREEN : "#B07C1F"} />
+            <Text fw={700} fz={15} c={INK}>
+              {paid ? "Final invoice paid" : "Final invoice due"} —{" "}
+              {invoice.invoiceNumber}
+            </Text>
+            <Badge color={paid ? "edr-green" : "yellow"} variant="light" radius="sm">
+              {invoiceStatusLabel(invoice.status)}
+            </Badge>
+          </Group>
+          <Text fz={20} fw={800} mt={6} c={INK}>
+            {invoice.totalAmount.toLocaleString()} {invoice.currency}
+          </Text>
+          {invoice.description ? (
+            <Text fz={13} c="dimmed" mt={2}>
+              {invoice.description}
+            </Text>
+          ) : null}
+          {!paid ? (
+            <Text fz={13} c="#9A6B1F" mt={6}>
+              Pay the amount above and attach your payment slip — Global
+              Logistics will confirm the payment.
+            </Text>
+          ) : null}
+        </div>
+
+        <Stack gap="xs" miw={260}>
+          {invoice.invoiceFile ? (
+            <Button
+              variant="default"
+              radius="md"
+              size="sm"
+              leftSection={<Eye size={15} />}
+              onClick={() =>
+                onView({
+                  name: invoice.invoiceFile!.name,
+                  url: invoice.invoiceFile!.url,
+                })
+              }
+            >
+              View invoice
+            </Button>
+          ) : null}
+          {invoice.slipFile ? (
+            <Button
+              variant="default"
+              radius="md"
+              size="sm"
+              leftSection={<Eye size={15} />}
+              onClick={() =>
+                onView({
+                  name: invoice.slipFile!.name,
+                  url: invoice.slipFile!.url,
+                })
+              }
+            >
+              View payment slip
+            </Button>
+          ) : null}
+          {!paid ? (
+            <>
+              <FileInput
+                placeholder={
+                  invoice.slipFile ? "Replace payment slip" : "Attach payment slip"
+                }
+                value={slip}
+                onChange={setSlip}
+                size="sm"
+                radius="md"
+              />
+              <Button
+                color="edr-green"
+                radius="md"
+                size="sm"
+                loading={uploading}
+                disabled={!slip}
+                leftSection={<Upload size={15} />}
+                onClick={async () => {
+                  if (!slip) return;
+                  setUploading(true);
+                  try {
+                    await contractsService.uploadFinalInvoiceSlip(bookingId, slip);
+                    setSlip(null);
+                    toast.success("Payment slip attached");
+                    onChanged();
+                  } catch (e) {
+                    toast.error(
+                      e instanceof Error ? e.message : "Upload failed",
+                    );
+                  } finally {
+                    setUploading(false);
+                  }
+                }}
+              >
+                {invoice.slipFile ? "Replace slip" : "Submit payment slip"}
+              </Button>
+            </>
+          ) : null}
+        </Stack>
+      </Group>
+    </Paper>
+  );
+}
+
+
+const CUSTOMS_RISK_COLOR: Record<string, string> = {
+  GREEN: "green",
+  YELLOW: "yellow",
+  RED: "red",
+};
+
+
+/**
+ * Post-arrival additional duty/tax round (import): GL advises an extra amount
+ * with a notice; the customer pays offline and attaches another slip here.
+ */
+function SecondDutyDueCard({
+  duty,
+  bookingId,
+  onView,
+  onChanged,
+}: {
+  duty: NonNullable<Freight.ClearanceView["secondDuty"]>;
+  bookingId: string;
+  onView: (file: { name: string; url: string }) => void;
+  onChanged: () => void;
+}) {
+  const [slip, setSlip] = useState<File | null>(null);
+  const [uploading, setUploading] = useState(false);
+  const paid = duty.paid;
+
+  return (
+    <Paper
+      withBorder
+      radius="lg"
+      p="lg"
+      style={{
+        borderColor: paid ? "#CDEBDD" : "#F2D9A6",
+        background: paid ? "#F6FBF8" : "#FFFBF2",
+        position: "relative",
+        overflow: "hidden",
+      }}
+    >
+      <Box
+        style={{
+          position: "absolute",
+          left: 0,
+          top: 0,
+          bottom: 0,
+          width: 3,
+          background: paid ? GREEN : "#E3A93C",
+        }}
+      />
+      <Group justify="space-between" align="flex-start" wrap="wrap" gap="md">
+        <div>
+          <Group gap={8} align="center">
+            <FileBadge size={16} color={paid ? GREEN : "#B07C1F"} />
+            <Text fw={700} fz={15} c={INK}>
+              {paid ? "Additional duty & tax paid" : "Additional duty & tax due"}
+            </Text>
+            <Badge color={paid ? "edr-green" : "yellow"} variant="light" radius="sm">
+              {paid ? "PAID" : "DUE"}
+            </Badge>
+          </Group>
+          <Text fz={20} fw={800} mt={6} c={INK}>
+            {(duty.amount ?? 0).toLocaleString()} {duty.currency ?? ""}
+          </Text>
+          {duty.declarationSerial ? (
+            <Text fz={13} c="dimmed" mt={2}>
+              Payment code: {duty.declarationSerial}
+            </Text>
+          ) : null}
+          {!paid ? (
+            <Text fz={13} c="#9A6B1F" mt={6}>
+              Customs advised additional duty/tax after arrival. Pay the amount
+              above and attach your payment slip.
+            </Text>
+          ) : null}
+        </div>
+
+        <Stack gap="xs" miw={260}>
+          {duty.noticeFile ? (
+            <Button
+              variant="default"
+              radius="md"
+              size="sm"
+              leftSection={<Eye size={15} />}
+              onClick={() =>
+                onView({ name: duty.noticeFile!.name, url: duty.noticeFile!.url })
+              }
+            >
+              View duty notice
+            </Button>
+          ) : null}
+          {duty.slipFile ? (
+            <Button
+              variant="default"
+              radius="md"
+              size="sm"
+              leftSection={<Eye size={15} />}
+              onClick={() =>
+                onView({ name: duty.slipFile!.name, url: duty.slipFile!.url })
+              }
+            >
+              View payment slip
+            </Button>
+          ) : null}
+          {!paid ? (
+            <>
+              <FileInput
+                placeholder={duty.slipFile ? "Replace payment slip" : "Attach payment slip"}
+                value={slip}
+                onChange={setSlip}
+                size="sm"
+                radius="md"
+              />
+              <Button
+                color="edr-green"
+                radius="md"
+                size="sm"
+                loading={uploading}
+                disabled={!slip}
+                leftSection={<Upload size={15} />}
+                onClick={async () => {
+                  if (!slip) return;
+                  setUploading(true);
+                  try {
+                    await contractsService.uploadSecondDutySlip(bookingId, slip);
+                    setSlip(null);
+                    toast.success("Payment slip attached");
+                    onChanged();
+                  } catch (e) {
+                    toast.error(e instanceof Error ? e.message : "Upload failed");
+                  } finally {
+                    setUploading(false);
+                  }
+                }}
+              >
+                {duty.slipFile ? "Replace slip" : "Submit payment slip"}
+              </Button>
+            </>
+          ) : null}
+        </Stack>
+      </Group>
+    </Paper>
+  );
+}
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 ce4a2dbea..9d9116bab 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
@@ -14,6 +14,7 @@ import type { Freight } from "@edr/types";
 import { ApproveDeliveryButton } from "../delivery/ApproveDeliveryButton";
 import { ActivityCard } from "./components/ActivityCard";
 import { ClearanceCard } from "./components/ClearanceCard";
+import { BookingClearanceWorkflowBanner } from "@/pages/bookings/BookingClearanceWorkflowBanner";
 import { DocumentsTab } from "./components/DocumentsTab";
 import { CompanyInfoCard } from "./components/CompanyInfoCard";
 import { ContainersCard } from "./components/ContainersCard";
@@ -242,6 +243,10 @@ export function ReadonlyBookingView({
 
             {isClearance && <ClearanceCard booking={booking} />}
 
+            {/* Customs (Path B) shipments: GL's phased progress, the duty /
+                additional-duty payments and the final invoice — all per booking. */}
+            <BookingClearanceWorkflowBanner booking={booking} />
+
             <BodyGrid
               left={
                 <>
diff --git a/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/components/ClearanceCard.tsx b/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/components/ClearanceCard.tsx
index a8cc43e14..e5ea8d3a9 100644
--- a/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/components/ClearanceCard.tsx
+++ b/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/components/ClearanceCard.tsx
@@ -12,7 +12,11 @@ import { useNavigate } from "react-router-dom";
 import type { Freight } from "@edr/types";
 
 import { BookingActionModal } from "@/pages/bookings/clearance/BookingActionModal";
-import { getBookingNextAction } from "@/pages/bookings/clearance/bookingNextAction";
+import {
+  bookingDocNoun,
+  bookingDocNounCapitalized,
+  getBookingNextAction,
+} from "@/pages/bookings/clearance/bookingNextAction";
 
 import { CardTitle, SectionCard } from "./layout";
 
@@ -28,6 +32,9 @@ export function ClearanceCard({ booking }: { booking: Freight.IBooking }) {
   const navigate = useNavigate();
   const status = booking.status as string;
   const action = getBookingNextAction(booking);
+  // Self-clearance services collect the customer's own import/export paperwork,
+  // so the copy is named after the direction rather than "clearance".
+  const docNoun = bookingDocNoun(booking);
   // BOOK: clearance finished on a bare instance — go straight to the booking
   // form (cargo + shipment day + window check) instead of opening the modal.
   const isBookAction = action?.kind === "BOOK" && Boolean(action.to);
@@ -46,9 +53,15 @@ export function ClearanceCard({ booking }: { booking: Freight.IBooking }) {
   const summary =
     status === "CLEARANCE_READY" ? (
       <Alert color="teal" radius="md" icon={<CheckCircle2 size={18} />}>
-        {isBookAction
-          ? "Clearance is complete. Book your shipment — enter the cargo details and pick a shipment day inside an open booking window."
-          : "Clearance is complete. Pick a shipment day and proceed to operation."}
+        {`${
+          booking.customsClearingEnabled
+            ? "Clearance is complete."
+            : "Your documents are approved."
+        } ${
+          isBookAction
+            ? "Book your shipment — enter the cargo details and pick a shipment day inside an open booking window."
+            : "Pick a shipment day and proceed to operation."
+        }`}
       </Alert>
     ) : status === "DOCUMENTS_UNDER_REVIEW" ? (
       <Alert color="blue" radius="md" icon={<Clock size={18} />}>
@@ -57,8 +70,7 @@ export function ClearanceCard({ booking }: { booking: Freight.IBooking }) {
       </Alert>
     ) : (
       <Alert color="yellow" radius="md" icon={<Upload size={18} />}>
-        Upload the required clearance documents so your shipment can be
-        reviewed.
+        Upload the required {docNoun} so your shipment can be reviewed.
       </Alert>
     );
 
@@ -67,7 +79,7 @@ export function ClearanceCard({ booking }: { booking: Freight.IBooking }) {
       {/* The "Clearance progress" stepper moved into the unified journey
           wizard at the top of the page — this card keeps only the actions. */}
       <Group justify="space-between" align="center" mb="md">
-        <CardTitle>Clearance documents</CardTitle>
+        <CardTitle>{bookingDocNounCapitalized(booking)}</CardTitle>
         {action && (
           <Button
             color="edr-green"
@@ -93,7 +105,7 @@ export function ClearanceCard({ booking }: { booking: Freight.IBooking }) {
       <Text fz="12.5px" c="dimmed" mt="sm">
         {isBookAction
           ? "Use “Book” to enter the cargo details and schedule your shipment."
-          : `Use “${action?.label ?? "the action button"}” to manage your clearance documents.`}
+          : `Use “${action?.label ?? "the action button"}” to manage your ${docNoun}.`}
       </Text>
 
       {!isBookAction && (
diff --git a/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/components/DocumentsTab.tsx b/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/components/DocumentsTab.tsx
index e43bb43b9..fb328f4b7 100644
--- a/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/components/DocumentsTab.tsx
+++ b/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/components/DocumentsTab.tsx
@@ -18,7 +18,11 @@ import { fetchViewableFile, downloadStoredFile } from "@/services/files.service"
 import { warehouseService } from "@/services/warehouse.service";
 import { useFileViewer } from "@/hooks/useFileViewer";
 import { BookingActionModal } from "@/pages/bookings/clearance/BookingActionModal";
-import { getBookingNextAction } from "@/pages/bookings/clearance/bookingNextAction";
+import {
+  bookingDocNoun,
+  bookingDocNounCapitalized,
+  getBookingNextAction,
+} from "@/pages/bookings/clearance/bookingNextAction";
 import { ClearanceUploadedDocumentsPanel } from "@/components/contracts/ClearanceUploadedDocumentsPanel";
 
 import toast from "react-hot-toast";
@@ -322,7 +326,7 @@ export function DocumentsTab({ booking }: { booking: Freight.IBooking }) {
       {hasContract && clearance && (
         <SectionCard>
           <Group justify="space-between" align="center" mb={4}>
-            <CardTitle>Clearance documents</CardTitle>
+            <CardTitle>{bookingDocNounCapitalized(booking)}</CardTitle>
             {showManage && (
               <Button
                 color="edr-green"
@@ -366,7 +370,7 @@ export function DocumentsTab({ booking }: { booking: Freight.IBooking }) {
             </Stack>
           ) : (
             <Alert color="gray" radius="md" icon={<Info size={16} />}>
-              No clearance documents are required for this booking.
+              No {bookingDocNoun(booking)} are required for this booking.
             </Alert>
           )}
         </SectionCard>
diff --git a/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/components/StatusHero.tsx b/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/components/StatusHero.tsx
index c702329d1..de6d2c755 100644
--- a/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/components/StatusHero.tsx
+++ b/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/components/StatusHero.tsx
@@ -5,6 +5,10 @@ import { MoveRight } from "lucide-react";
 import type { Freight } from "@edr/types";
 
 import { contractsService } from "@/services/contracts.service";
+import {
+  bookingDocNoun,
+  bookingDocNounCapitalized,
+} from "@/pages/bookings/clearance/bookingNextAction";
 
 import {
   ARRIVAL_STAGE,
@@ -110,12 +114,29 @@ export function StatusHero({
         }
       : isInitiatedInstance
         ? {
-            title: "Upload clearance documents",
-            description:
-              "Upload the required clearance documents to start the review. Once the review is finalized you can book your shipment.",
+            title: `Upload ${bookingDocNoun(booking)}`,
+            description: `Upload the required ${bookingDocNoun(
+              booking,
+            )} to start the review. Once the review is finalized you can book your shipment.`,
             stage,
           }
-        : isContractDrawdown && status === "FULLY_EXECUTED"
+        : status === "AWAITING_DOCUMENTS"
+          ? {
+              title: `Upload ${bookingDocNoun(booking)}`,
+              description: `Upload the required ${bookingDocNoun(
+                booking,
+              )} so your shipment can be reviewed.`,
+              stage,
+            }
+          : status === "DOCUMENTS_UNDER_REVIEW"
+            ? {
+                title: `${bookingDocNounCapitalized(booking)} under review`,
+                description: `Your ${bookingDocNoun(
+                  booking,
+                )} are being reviewed. Re-upload any queried documents to proceed.`,
+                stage,
+              }
+            : isContractDrawdown && status === "FULLY_EXECUTED"
           ? {
               title: "Accepted by operations",
               description:
diff --git a/apps/edr-freight-web/portal/src/pages/bookings/clearance/BookingActionModal.tsx b/apps/edr-freight-web/portal/src/pages/bookings/clearance/BookingActionModal.tsx
index 8f93e040c..c8b324d47 100644
--- a/apps/edr-freight-web/portal/src/pages/bookings/clearance/BookingActionModal.tsx
+++ b/apps/edr-freight-web/portal/src/pages/bookings/clearance/BookingActionModal.tsx
@@ -5,7 +5,10 @@ import { useNavigate } from "react-router-dom";
 import type { Freight } from "@edr/types";
 
 import { ClearanceFlow } from "./ClearanceFlow";
-import { getBookingNextAction } from "./bookingNextAction";
+import {
+  bookingDocNounCapitalized,
+  getBookingNextAction,
+} from "./bookingNextAction";
 import { useClearanceFlow } from "./useClearanceFlow";
 
 interface BookingActionModalProps {
@@ -59,7 +62,7 @@ function BookingActionModalBody({
       title={
         <Box>
           <Text fw={700} fz={16}>
-            {action?.title ?? "Clearance documents"}
+            {action?.title ?? bookingDocNounCapitalized(booking)}
           </Text>
           <Text fz={12} c="dimmed" ff="monospace">
             {reference}
diff --git a/apps/edr-freight-web/portal/src/pages/bookings/clearance/ClearanceFlow.tsx b/apps/edr-freight-web/portal/src/pages/bookings/clearance/ClearanceFlow.tsx
index 1997c99d4..196646185 100644
--- a/apps/edr-freight-web/portal/src/pages/bookings/clearance/ClearanceFlow.tsx
+++ b/apps/edr-freight-web/portal/src/pages/bookings/clearance/ClearanceFlow.tsx
@@ -24,6 +24,7 @@ import {
 import { ClearanceDocumentUploadCard } from "@/components/contracts/ClearanceDocumentUploadCard";
 import { fetchViewableFile, downloadStoredFile } from "@/services/files.service";
 import { useFileViewer } from "@/hooks/useFileViewer";
+import { bookingDocNoun } from "./bookingNextAction";
 import { OperationDatePicker } from "./OperationDatePicker";
 import { DayAvailabilityHint } from "./DayAvailabilityHint";
 import type { ClearanceFlowController } from "./useClearanceFlow";
@@ -87,7 +88,7 @@ export function ClearanceFlow({ booking, flow, footer }: ClearanceFlowProps) {
               ? "Customs clearance is complete. Global Logistics is completing your booking (cargo details and shipment day) — you will be notified when payment is due."
               : clearance.includesCustoms
                 ? "Customs clearance is complete and your cleared documents are available below. You can now proceed to operation."
-                : "Clearance is ready. You can now proceed to operation."}
+                : "Your documents are approved. You can now proceed to operation."}
         </Alert>
       ) : status === "DOCUMENTS_UNDER_REVIEW" ? (
         <Alert color="blue" radius="md" icon={<Clock size={18} />} mb="md">
@@ -99,7 +100,7 @@ export function ClearanceFlow({ booking, flow, footer }: ClearanceFlowProps) {
         <Alert color="yellow" radius="md" icon={<AlertCircle size={18} />} mb="md">
           {clearance.includesCustoms
             ? "Upload every required document customs needs (marked *) to start the review. Global Logistics will clear your shipment and return the cleared documents here."
-            : "Upload every required clearance document (marked *) below to start the review."}
+            : `Upload every required ${bookingDocNoun(booking, { singular: true })} (marked *) below to start the review.`}
         </Alert>
       )}
 
@@ -115,7 +116,7 @@ export function ClearanceFlow({ booking, flow, footer }: ClearanceFlowProps) {
       <Stack gap="md">
         <Box>
           <Text fz={13} fw={700} c="#10202F">
-            Your clearance documents
+            Your {bookingDocNoun(booking)}
           </Text>
           <Text fz={12} c="dimmed" mt={4}>
             Upload each required document below. Items marked * are mandatory.
diff --git a/apps/edr-freight-web/portal/src/pages/bookings/clearance/bookingNextAction.ts b/apps/edr-freight-web/portal/src/pages/bookings/clearance/bookingNextAction.ts
index 1ebb047a6..d0256510a 100644
--- a/apps/edr-freight-web/portal/src/pages/bookings/clearance/bookingNextAction.ts
+++ b/apps/edr-freight-web/portal/src/pages/bookings/clearance/bookingNextAction.ts
@@ -22,29 +22,78 @@ export interface BookingNextAction {
   to?: string;
 }
 
-const ACTION_BY_STATUS: Record<string, BookingNextAction> = {
-  AWAITING_DOCUMENTS: {
-    kind: "UPLOAD_DOCUMENTS",
-    label: "Upload documents",
-    title: "Upload clearance documents",
-  },
-  DOCUMENTS_UNDER_REVIEW: {
-    kind: "FIX_DOCUMENTS",
-    label: "Review documents",
-    title: "Clearance documents",
-  },
-  CLEARANCE_READY: {
-    kind: "SCHEDULE_OPERATION",
-    label: "Schedule & proceed",
-    title: "Schedule your shipment",
-  },
-};
-
 type ActionBooking = Pick<
   Freight.IBooking,
-  "id" | "status" | "contractId" | "totalAmount" | "customsClearingEnabled"
+  | "id"
+  | "status"
+  | "contractId"
+  | "totalAmount"
+  | "customsClearingEnabled"
+  | "tradeDirection"
 >;
 
+/** Anything carrying a service + a lane: a booking or the contract behind it. */
+type DocNounSource = {
+  customsClearingEnabled?: boolean | null;
+  tradeDirection?: string | null;
+};
+
+/**
+ * What this booking's document set is CALLED to the customer.
+ *
+ * Only a customs (Path B) service collects EDR's clearance set. On a
+ * self-clearance service the customer clears the cargo himself and simply hands
+ * over his own import or export paperwork — calling that "clearance documents"
+ * reads as if EDR were clearing for him, so it is named after the direction.
+ */
+export function bookingDocNoun(
+  booking: DocNounSource,
+  { singular = false }: { singular?: boolean } = {},
+): string {
+  const kind = booking.customsClearingEnabled
+    ? "clearance"
+    : booking.tradeDirection === "IMPORT"
+      ? "import"
+      : booking.tradeDirection === "EXPORT"
+        ? "export"
+        : "intercity";
+  return `${kind} ${singular ? "document" : "documents"}`;
+}
+
+/** {@link bookingDocNoun} for the start of a sentence or a card title. */
+export function bookingDocNounCapitalized(
+  booking: Pick<ActionBooking, "customsClearingEnabled" | "tradeDirection">,
+): string {
+  const noun = bookingDocNoun(booking);
+  return noun.charAt(0).toUpperCase() + noun.slice(1);
+}
+
+function actionByStatus(booking: ActionBooking): BookingNextAction | null {
+  const noun = bookingDocNoun(booking);
+  switch (booking.status) {
+    case "AWAITING_DOCUMENTS":
+      return {
+        kind: "UPLOAD_DOCUMENTS",
+        label: "Upload documents",
+        title: `Upload ${noun}`,
+      };
+    case "DOCUMENTS_UNDER_REVIEW":
+      return {
+        kind: "FIX_DOCUMENTS",
+        label: "Review documents",
+        title: bookingDocNounCapitalized(booking),
+      };
+    case "CLEARANCE_READY":
+      return {
+        kind: "SCHEDULE_OPERATION",
+        label: "Schedule & proceed",
+        title: "Schedule your shipment",
+      };
+    default:
+      return null;
+  }
+}
+
 /** Initiated instance still carrying no cargo/price (clearance-first flow). */
 function isBareInstance(booking: ActionBooking): boolean {
   return (
@@ -83,7 +132,7 @@ export function getBookingNextAction(
       to: `/contracts/${booking.contractId}/bookings/${booking.id}/complete`,
     };
   }
-  return ACTION_BY_STATUS[booking.status as string] ?? null;
+  return actionByStatus(booking);
 }
 
 /**
diff --git a/apps/edr-freight-web/portal/src/pages/contracts/ContractClearanceFlow.tsx b/apps/edr-freight-web/portal/src/pages/contracts/ContractClearanceFlow.tsx
deleted file mode 100644
index b0bee36d2..000000000
--- a/apps/edr-freight-web/portal/src/pages/contracts/ContractClearanceFlow.tsx
+++ /dev/null
@@ -1,81 +0,0 @@
-import { useNavigate, useParams } from "react-router-dom";
-import { useQuery } from "@tanstack/react-query";
-import {
-  Box,
-  Button,
-  Group,
-  Stack,
-  Text,
-  ThemeIcon,
-  Title,
-} from "@mantine/core";
-import { ArrowLeft, Upload } from "lucide-react";
-
-import { api } from "@/services/api";
-import { ContractStatusBadge, INK } from "./contract-ui";
-import { ContractClearancePanel } from "./ContractClearancePanel";
-
-/**
- * Customer clearance upload page for a CONTRACT (doc §8.3). The document grid +
- * upload logic live in {@link ContractClearancePanel} so the same workspace can
- * render here (full page) or inside the contract action modal.
- */
-export default function ContractClearanceFlow() {
-  const { id } = useParams<{ id: string }>();
-  const navigate = useNavigate();
-
-  const { data: contract } = useQuery(
-    api.contracts.get.queryOptions({ input: { id: id! }, enabled: !!id }),
-  );
-
-  const { data: clearance } = useQuery(
-    api.contracts.getClearance.queryOptions({
-      input: { id: id! },
-      enabled: !!id,
-    }),
-  );
-
-  return (
-    <Box style={{ padding: "28px 32px 40px" }}>
-      <Stack gap="lg">
-        <Group justify="space-between" align="flex-start" wrap="wrap" gap="md">
-          <Group gap="md" align="center" wrap="nowrap">
-            <Button
-              variant="subtle"
-              color="gray"
-              radius="md"
-              px={8}
-              onClick={() => navigate(`/contracts/${id}`)}
-            >
-              <ArrowLeft size={18} />
-            </Button>
-            <Group gap={12} wrap="nowrap" align="center">
-              <ThemeIcon size={48} radius="lg" variant="light" color="edr-green">
-                <Upload size={23} />
-              </ThemeIcon>
-              <div>
-                <Group gap={10} align="center">
-                  <Title order={2} fw={800} fz={22} style={{ color: INK }}>
-                    Clearance documents
-                  </Title>
-                  {contract && <ContractStatusBadge status={contract.status} />}
-                </Group>
-                <Text size="sm" c="dimmed" mt={2}>
-                  {contract?.reference ?? ""} · Cycle{" "}
-                  {clearance?.cycleNumber ?? 1}
-                </Text>
-              </div>
-            </Group>
-          </Group>
-        </Group>
-
-        {id && (
-          <ContractClearancePanel
-            contractId={id}
-            tradeDirection={contract?.tradeDirection ?? "IMPORT"}
-          />
-        )}
-      </Stack>
-    </Box>
-  );
-}
diff --git a/apps/edr-freight-web/portal/src/pages/contracts/ContractClearancePanel.tsx b/apps/edr-freight-web/portal/src/pages/contracts/ContractClearancePanel.tsx
deleted file mode 100644
index 1516d0b71..000000000
--- a/apps/edr-freight-web/portal/src/pages/contracts/ContractClearancePanel.tsx
+++ /dev/null
@@ -1,355 +0,0 @@
-import { useMemo, useState } from "react";
-import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
-import {
-  Alert,
-  Box,
-  Button,
-  Center,
-  Group,
-  Loader,
-  Paper,
-  Stack,
-  Text,
-} from "@mantine/core";
-import {
-  AlertCircle,
-  CheckCircle2,
-  Clock,
-  Download,
-  Eye,
-  Upload,
-} from "lucide-react";
-
-import { isViewable } from "@edr/ui-common";
-import { api } from "@/services/api";
-import { fetchViewableFile, downloadStoredFile } from "@/services/files.service";
-import {
-  ClearanceAdHocUploadSection,
-  type AdHocDoc,
-} from "@/components/contracts/ClearanceAdHocUploadSection";
-import { ClearanceDocumentUploadCard } from "@/components/contracts/ClearanceDocumentUploadCard";
-import { ClearanceUploadedDocumentsPanel } from "@/components/contracts/ClearanceUploadedDocumentsPanel";
-import { useFileViewer } from "@/hooks/useFileViewer";
-import { IconSquare } from "@/pages/bookings/BookingDetailPage/components/Documents";
-
-const BORDER = "#E6ECF2";
-
-export interface ContractClearancePanelProps {
-  contractId: string;
-  tradeDirection?: string;
-  /** Show the loading state without the surrounding Paper (e.g. inside a modal). */
-  bare?: boolean;
-  /** Called after a successful document submission (e.g. to close the host modal). */
-  onSubmitted?: () => void;
-}
-
-/**
- * The clearance document workspace for a contract: shows the customer-input doc
- * grid + GL output docs, lets the customer upload / re-upload (only queried docs
- * after first submission), and surfaces query notes. Rendered both on the
- * standalone clearance page and inside the contract action modal. See
- * docs/new-doc.md §8.3.
- */
-export function ContractClearancePanel({
-  contractId,
-  tradeDirection = "IMPORT",
-  bare,
-  onSubmitted,
-}: ContractClearancePanelProps) {
-  const queryClient = useQueryClient();
-  const [pending, setPending] = useState<Record<string, File>>({});
-  const [adHoc, setAdHoc] = useState<AdHocDoc[]>([]);
-  const { view, viewer } = useFileViewer();
-
-  const clearanceQuery = useQuery(
-    api.contracts.getClearance.queryOptions({
-      input: { id: contractId },
-      enabled: !!contractId,
-    }),
-  );
-  const clearance = clearanceQuery.data;
-
-  const uploadMutation = useMutation({
-    ...api.contracts.uploadClearanceDocuments.mutationOptions(),
-    onSuccess: () => {
-      setPending({});
-      setAdHoc([]);
-      queryClient.invalidateQueries({
-        queryKey: api.contracts.getClearance.queryKey({ id: contractId }),
-      });
-      queryClient.invalidateQueries({
-        queryKey: api.contracts.get.queryKey({ id: contractId }),
-      });
-      // Submitting moves the contract to CLEARANCE_UNDER_REVIEW — refresh every
-      // contracts-list query (prefix key) so the /contracts table row and its
-      // action button update without a page reload.
-      queryClient.invalidateQueries({
-        queryKey: api.contracts.list.queryKey(),
-      });
-      onSubmitted?.();
-    },
-  });
-
-  const customerDocs = useMemo(() => {
-    const docs = (clearance?.documents ?? []).filter(
-      (d) => d.uploadedBy === "customer",
-    );
-    // Surface queried documents (the ones needing correction) first.
-    const rank = (s: string | null) =>
-      s === "QUERIED" ? 0 : s === "APPROVED" ? 2 : 1;
-    return [...docs].sort(
-      (a, b) => rank(a.reviewStatus) - rank(b.reviewStatus),
-    );
-  }, [clearance]);
-
-  const queriedCount = useMemo(
-    () => customerDocs.filter((d) => d.reviewStatus === "QUERIED").length,
-    [customerDocs],
-  );
-  const glDocs = useMemo(
-    () => (clearance?.documents ?? []).filter((d) => d.uploadedBy !== "customer"),
-    [clearance],
-  );
-
-  const status = clearance?.clearanceStatus ?? "AWAITING_DOCUMENTS";
-  const isUnderReview = status === "DOCUMENTS_UNDER_REVIEW";
-  const isReady =
-    status === "CLEARANCE_READY_FOR_BOOKING" ||
-    status === "SELF_CLEARED" ||
-    status === "ACTIVE_SHIPMENT_IN_PROGRESS";
-  const canUpload = status === "AWAITING_DOCUMENTS" || isUnderReview;
-  const isInitialUpload = status === "AWAITING_DOCUMENTS";
-
-  const customsPath = clearance?.includesCustoms ?? true;
-  const reviewer = customsPath ? "Global Logistics" : "the Operations team";
-
-  const missingRequired = useMemo(
-    () => customerDocs.filter((d) => d.required && !d.file && !pending[d.fileKey]),
-    [customerDocs, pending],
-  );
-
-  const hasStagedFiles =
-    Object.keys(pending).length > 0 || adHoc.some((r) => r.file);
-
-  const canSubmit = isInitialUpload
-    ? hasStagedFiles && missingRequired.length === 0
-    : hasStagedFiles;
-
-  const stagePending = (fileKey: string, file: File | null) =>
-    setPending((p) => {
-      if (file) return { ...p, [fileKey]: file };
-      const next = { ...p };
-      delete next[fileKey];
-      return next;
-    });
-
-  const submitDocuments = () => {
-    const files: Record<string, File | null> = { ...pending };
-    adHoc.forEach((row, i) => {
-      if (row.file) files[`custom_${Date.now()}_${i}`] = row.file;
-    });
-    if (Object.keys(files).length === 0) return;
-    uploadMutation.mutate({ id: contractId, files });
-  };
-
-  if (clearanceQuery.isLoading) {
-    return (
-      <Center mih={bare ? 200 : 400} p="xl">
-        <Loader color="edr-green" />
-      </Center>
-    );
-  }
-
-  const body = (
-    <Stack gap={0}>
-      {queriedCount > 0 && (
-        <Alert
-          color="red"
-          radius="md"
-          icon={<AlertCircle size={18} />}
-          mb="md"
-          title={`${queriedCount} document${queriedCount > 1 ? "s" : ""} need correction`}
-        >
-          Re-upload the highlighted document{queriedCount > 1 ? "s" : ""} below to
-          continue. The reviewer's note explains what to fix.
-        </Alert>
-      )}
-      {isReady ? (
-        <Alert color="teal" radius="md" icon={<CheckCircle2 size={18} />} mb="md">
-          {customsPath
-            ? "Your clearance documents are approved. Global Logistics will create your booking on your behalf — you will be notified when payment is due."
-            : "Your clearance documents are approved. You can now create a shipment booking under this contract."}
-        </Alert>
-      ) : isUnderReview ? (
-        <Alert color="blue" radius="md" icon={<Clock size={18} />} mb="md">
-          {reviewer.charAt(0).toUpperCase() + reviewer.slice(1)} is reviewing
-          your documents. Only re-upload the documents flagged with a query
-          below — approved documents stay as they are.
-        </Alert>
-      ) : (
-        <Alert color="yellow" radius="md" icon={<AlertCircle size={18} />} mb="md">
-          {customsPath
-            ? "Upload every required clearance document (marked *) below to start the review. Global Logistics will clear your shipment and create the booking for you."
-            : "This service does not include EDR customs clearance — clear the cargo yourself and upload every required clearance document (marked *) below. The Operations team will review them before you can book a shipment."}
-        </Alert>
-      )}
-
-      {isInitialUpload && missingRequired.length > 0 && (
-        <Alert color="yellow" variant="light" radius="md" mb="md" p="xs">
-          <Text fz="12px" c="#9A5B00">
-            Still required: {missingRequired.map((d) => d.label).join(", ")}
-          </Text>
-        </Alert>
-      )}
-
-      {/* Required customer documents */}
-      <Stack gap="md">
-        <Box>
-          <Text fz={13} fw={700} c="#10202F">
-            Your clearance documents
-          </Text>
-          <Text fz={12} c="dimmed" mt={4}>
-            Upload each required document below. Items marked * are mandatory.
-          </Text>
-        </Box>
-        {customerDocs.map((doc) => (
-          <ClearanceDocumentUploadCard
-            key={doc.fileKey}
-            label={doc.label}
-            required={doc.required}
-            reviewStatus={doc.reviewStatus}
-            note={doc.note}
-            uploadedFile={doc.file}
-            stagedFile={pending[doc.fileKey] ?? null}
-            canUpload={canUpload}
-            onStageFile={
-              canUpload && doc.reviewStatus !== "APPROVED"
-                ? (file) => stagePending(doc.fileKey, file)
-                : undefined
-            }
-            onPreview={view}
-          />
-        ))}
-        {customerDocs.length === 0 && (
-          <Text fz="sm" c="dimmed">
-            No clearance documents are configured for this contract yet.
-          </Text>
-        )}
-      </Stack>
-
-      {/* GL output documents (read-only). */}
-      {glDocs.length > 0 && (
-        <>
-          <Text fz="12.5px" fw={700} c="#10202F" mt="lg" mb={8}>
-            Customs output documents
-          </Text>
-          <Stack gap={8}>
-            {glDocs.map((doc) => (
-              <Group
-                key={doc.fileKey}
-                justify="space-between"
-                wrap="nowrap"
-                className="rounded-xl"
-                style={{ border: `1px solid ${BORDER}`, padding: 10 }}
-              >
-                <Text fz="13px" c="#10202F" truncate>
-                  {doc.label}
-                </Text>
-                {doc.file ? (
-                  <Group gap={8} wrap="nowrap">
-                    {isViewable({
-                      name: doc.file.name,
-                      url: "",
-                    }) && (
-                      <IconSquare
-                        icon={<Eye size={15} />}
-                        onClick={() =>
-                          void fetchViewableFile(
-                            doc.file!.id,
-                            doc.file!.name,
-                          ).then(view)
-                        }
-                      />
-                    )}
-                    <IconSquare
-                      icon={<Download size={15} />}
-                      onClick={() =>
-                        void downloadStoredFile(doc.file!.id, doc.file!.name)
-                      }
-                    />
-                  </Group>
-                ) : (
-                  <Text fz="12px" c="#9AA8B5">
-                    Pending
-                  </Text>
-                )}
-              </Group>
-            ))}
-          </Stack>
-        </>
-      )}
-
-      <Box mt="lg">
-        <ClearanceUploadedDocumentsPanel
-          embedded
-          tradeDirection={tradeDirection}
-          files={clearance?.workflowFiles ?? []}
-          title="Customs workflow documents"
-          onView={(f) => view(f)}
-          onDownload={({ id, name }) => void downloadStoredFile(id, name)}
-        />
-      </Box>
-
-      {canUpload ? (
-        <ClearanceAdHocUploadSection
-          rows={adHoc}
-          onAdd={() => setAdHoc((r) => [...r, { name: "", file: null }])}
-          onRemove={(i) => setAdHoc((rows) => rows.filter((_, j) => j !== i))}
-          onNameChange={(i, name) =>
-            setAdHoc((rows) => rows.map((r, j) => (j === i ? { ...r, name } : r)))
-          }
-          onFileChange={(i, file) =>
-            setAdHoc((rows) => rows.map((r, j) => (j === i ? { ...r, file } : r)))
-          }
-          onPreview={view}
-        />
-      ) : null}
-
-      {uploadMutation.isError && (
-        <Alert color="red" radius="md" icon={<AlertCircle size={16} />} mt="md">
-          {uploadMutation.error instanceof Error
-            ? uploadMutation.error.message
-            : "Upload failed. Please try again."}
-        </Alert>
-      )}
-
-      {canUpload && (
-        <Group justify="flex-end" mt="xl">
-          <Button
-            color="edr-green"
-            radius="md"
-            size="md"
-            leftSection={<Upload size={16} />}
-            disabled={!canSubmit}
-            loading={uploadMutation.isPending}
-            onClick={submitDocuments}
-          >
-            {isInitialUpload ? "Submit documents" : "Re-upload documents"}
-          </Button>
-        </Group>
-      )}
-
-      {viewer}
-    </Stack>
-  );
-
-  if (bare) return body;
-
-  return (
-    <Paper withBorder radius={20} p="lg" style={{ borderColor: BORDER }}>
-      {body}
-    </Paper>
-  );
-}
-
-export default ContractClearancePanel;
diff --git a/apps/edr-freight-web/portal/src/pages/contracts/ContractClearanceWorkflowBanner.tsx b/apps/edr-freight-web/portal/src/pages/contracts/ContractClearanceWorkflowBanner.tsx
deleted file mode 100644
index 1049aa4a2..000000000
--- a/apps/edr-freight-web/portal/src/pages/contracts/ContractClearanceWorkflowBanner.tsx
+++ /dev/null
@@ -1,347 +0,0 @@
-import { useState } from "react";
-import { Alert, Box, Button, Group, Paper, Stack, Text, Textarea } from "@mantine/core";
-import { AlertTriangle, ArrowRight, Download, MessageSquareWarning, PackageCheck, Receipt, Upload } from "lucide-react";
-import { useQuery } from "@tanstack/react-query";
-import toast from "react-hot-toast";
-import type { Freight } from "@edr/types";
-
-import { bookingStatusLabel } from "@/pages/bookings/booking-display";
-import { ClearanceUploadedDocumentsPanel } from "@/components/contracts/ClearanceUploadedDocumentsPanel";
-import { PortalFileDropzone } from "@/components/contracts/PortalFileDropzone";
-import { contractsService } from "@/services/contracts.service";
-import { fetchViewableFile, downloadStoredFile } from "@/services/files.service";
-import { useFileViewer } from "@/hooks/useFileViewer";
-import { BORDER, INK } from "./contract-ui";
-import { ClearancePhaseStepper } from "./ClearancePhaseStepper";
-
-function downloadWorkflowFile({ id, name }: { id: string; name: string }) {
-  void downloadStoredFile(id, name);
-}
-
-export function ContractClearanceWorkflowBanner({
-  contract,
-}: {
-  contract: Freight.IContract;
-}) {
-  const { view, viewer } = useFileViewer();
-  const isPhased =
-    contract.customsClearingEnabled && contract.contractKind === "ONE_TIME";
-
-  const { data: clearance, refetch } = useQuery({
-    queryKey: ["contract-clearance", contract.id],
-    queryFn: () => contractsService.getClearance(contract.id),
-    enabled: isPhased,
-  });
-
-  if (!isPhased || !clearance) return null;
-
-  const dutyPaid = clearance.milestones?.some(
-    (m) => m.milestoneCode === "DUTY_TAX_PAID" && m.status === "COMPLETED",
-  );
-  const dutyPending =
-    clearance.dutyRequired &&
-    clearance.dutyAdvice &&
-    !dutyPaid;
-
-  return (
-    <>
-      <Paper withBorder radius="lg" p="lg" style={{ borderColor: BORDER }}>
-        <Stack gap="md">
-          <Text fw={700} size="sm" style={{ color: INK }}>
-            Clearance progress
-          </Text>
-          <ClearancePhaseStepper
-            clearance={clearance}
-            tradeDirection={contract.tradeDirection}
-            compact
-          />
-
-          {clearance.roHold && clearance.roHoldReason ? (
-            <Alert color="orange" icon={<AlertTriangle size={16} />} title="Release Order on hold">
-              {clearance.roHoldReason}
-            </Alert>
-          ) : null}
-
-          {clearance.nextAction?.actor === "CUSTOMER" ? (
-            <Alert color="blue" variant="light">
-              {clearance.nextAction.action}
-            </Alert>
-          ) : null}
-
-          {/* Duty is disputed: GL owes a corrected advice, so the pay/upload
-              panel is replaced by the waiting state until they re-send it. */}
-          {clearance.dutyDispute ? (
-            <Alert
-              color="orange"
-              variant="light"
-              icon={<MessageSquareWarning size={16} />}
-              title="Waiting for a corrected duty amount"
-            >
-              <Stack gap={4}>
-                <Text fz={13}>
-                  You asked GL Ethiopia to review the advised duty & tax. They
-                  will send a corrected notice — you will be notified.
-                </Text>
-                <Text fz={12} c="dimmed" style={{ whiteSpace: "pre-wrap" }}>
-                  Your message: {clearance.dutyDispute.note}
-                </Text>
-              </Stack>
-            </Alert>
-          ) : dutyPending && clearance.dutyAdvice ? (
-            <DutyAdvicePanel
-              dutyAdvice={clearance.dutyAdvice}
-              contractId={contract.id}
-              onUploaded={() => void refetch()}
-              onPreview={view}
-            />
-          ) : null}
-
-          <ClearanceUploadedDocumentsPanel
-            embedded
-            tradeDirection={contract.tradeDirection ?? "IMPORT"}
-            files={clearance.workflowFiles ?? []}
-            onView={view}
-            onDownload={downloadWorkflowFile}
-          />
-
-          {clearance.linkedBookingId ? (
-            <Alert color="green" variant="light" icon={<PackageCheck size={16} />}>
-              <Stack gap={6}>
-                <Text fz={13} fw={600} style={{ color: INK }}>
-                  Shipment booking created
-                  {clearance.linkedBookingReference
-                    ? ` · ${clearance.linkedBookingReference}`
-                    : ""}
-                </Text>
-                <Text fz={12} c="dimmed">
-                  Global Logistics has created your shipment booking
-                  {clearance.linkedBookingStatus
-                    ? ` (${bookingStatusLabel(clearance.linkedBookingStatus).toLowerCase()})`
-                    : ""}
-                  . Track its progress from the booking.
-                </Text>
-                <Button
-                  size="compact-sm"
-                  variant="light"
-                  color="green"
-                  leftSection={<ArrowRight size={14} />}
-                  component="a"
-                  href={`/bookings/${clearance.linkedBookingId}`}
-                  style={{ alignSelf: "flex-start" }}
-                >
-                  View shipment booking
-                </Button>
-              </Stack>
-            </Alert>
-          ) : clearance.bookingReady ? (
-            <Alert color="green" variant="light">
-              Clearance is complete. Global Logistics will create your shipment booking shortly.
-            </Alert>
-          ) : null}
-        </Stack>
-      </Paper>
-      {viewer}
-    </>
-  );
-}
-
-function DutyAdvicePanel({
-  dutyAdvice,
-  contractId,
-  onUploaded,
-  onPreview,
-}: {
-  dutyAdvice: NonNullable<Freight.ContractClearanceView["dutyAdvice"]>;
-  contractId: string;
-  onUploaded: () => void;
-  onPreview: (file: { name: string; url: string; mimeType?: string | null }) => void;
-}) {
-  const [file, setFile] = useState<File | null>(null);
-  const [loading, setLoading] = useState(false);
-  // Accept → pay and upload the slip. Query → say what is wrong and send it
-  // back to GL Ethiopia for a corrected notice.
-  const [disputing, setDisputing] = useState(false);
-  const [disputeNote, setDisputeNote] = useState("");
-  const [sendingDispute, setSendingDispute] = useState(false);
-
-  return (
-    <Paper
-      withBorder
-      radius="lg"
-      p="md"
-      style={{
-        borderColor: "#F5D9A8",
-        background: "linear-gradient(160deg, #FFFBF0 0%, #FFFFFF 70%)",
-      }}
-    >
-      <Stack gap="md">
-        <Group gap={8} wrap="nowrap">
-          <Box
-            style={{
-              width: 32,
-              height: 32,
-              borderRadius: 8,
-              display: "flex",
-              alignItems: "center",
-              justifyContent: "center",
-              background: "#FFF3D6",
-              color: "#C77F09",
-            }}
-          >
-            <Receipt size={16} />
-          </Box>
-          <Text fw={700} fz={14} style={{ color: INK }}>
-            Duty / tax payment
-          </Text>
-        </Group>
-
-        <Paper withBorder radius="md" p="sm" bg="#fff">
-          <Text fz={13} style={{ color: INK }}>
-            Amount due:{" "}
-            <strong>
-              {dutyAdvice.amount.toLocaleString()} {dutyAdvice.currency}
-            </strong>
-            {dutyAdvice.declarationSerial
-              ? ` · Payment code: ${dutyAdvice.declarationSerial}`
-              : null}
-          </Text>
-          {dutyAdvice.noticeFile ? (
-            <Group gap={8} mt={8}>
-              <Button
-                size="compact-xs"
-                variant="light"
-                color="orange"
-                leftSection={<Download size={14} />}
-                component="button"
-                type="button"
-                onClick={() =>
-                  void downloadStoredFile(
-                    dutyAdvice.noticeFile!.id,
-                    dutyAdvice.noticeFile!.name,
-                  )
-                }
-              >
-                Download duty notice
-              </Button>
-              <Button
-                size="compact-xs"
-                variant="subtle"
-                color="gray"
-                onClick={() =>
-                  void fetchViewableFile(
-                    dutyAdvice.noticeFile!.id,
-                    dutyAdvice.noticeFile!.name,
-                  ).then(onPreview)
-                }
-              >
-                Preview notice
-              </Button>
-            </Group>
-          ) : null}
-        </Paper>
-
-        {disputing ? (
-          <Stack gap="sm">
-            <Text fz={13} c="dimmed">
-              Tell GL Ethiopia what is wrong with this amount. They will review
-              and send a corrected notice.
-            </Text>
-            <Textarea
-              label="What needs correcting?"
-              placeholder="e.g. the declared value is wrong — the invoice total is 412,000 ETB"
-              value={disputeNote}
-              onChange={(e) => setDisputeNote(e.currentTarget.value)}
-              autosize
-              minRows={3}
-            />
-            <Group gap="sm" grow>
-              <Button
-                variant="default"
-                onClick={() => {
-                  setDisputing(false);
-                  setDisputeNote("");
-                }}
-              >
-                Back
-              </Button>
-              <Button
-                color="orange"
-                loading={sendingDispute}
-                disabled={!disputeNote.trim()}
-                onClick={async () => {
-                  setSendingDispute(true);
-                  try {
-                    await contractsService.disputeContractDuty(
-                      contractId,
-                      disputeNote.trim(),
-                    );
-                    toast.success("Sent back to GL Ethiopia for correction");
-                    setDisputing(false);
-                    setDisputeNote("");
-                    onUploaded();
-                  } catch (e) {
-                    toast.error(e instanceof Error ? e.message : "Could not send");
-                  } finally {
-                    setSendingDispute(false);
-                  }
-                }}
-              >
-                Send for correction
-              </Button>
-            </Group>
-          </Stack>
-        ) : (
-          <>
-            <Text fz={13} c="dimmed">
-              Pay the amount above, then upload your payment slip so clearance can
-              continue. If the amount looks wrong, ask GL Ethiopia to correct it
-              before paying.
-            </Text>
-
-            <PortalFileDropzone
-              label="Payment slip"
-              description="Upload proof of duty/tax payment (PDF or image)."
-              value={file}
-              onChange={setFile}
-              onPreview={onPreview}
-            />
-
-            <Button
-              color="orange"
-              loading={loading}
-              disabled={!file}
-              leftSection={<Upload size={16} />}
-              fullWidth
-              onClick={async () => {
-                if (!file) return;
-                setLoading(true);
-                try {
-                  await contractsService.uploadContractDutySlip(contractId, file);
-                  toast.success("Payment slip uploaded");
-                  setFile(null);
-                  onUploaded();
-                } catch (e) {
-                  toast.error(e instanceof Error ? e.message : "Upload failed");
-                } finally {
-                  setLoading(false);
-                }
-              }}
-            >
-              Accept & submit payment slip
-            </Button>
-
-            <Button
-              variant="subtle"
-              color="orange"
-              leftSection={<MessageSquareWarning size={15} />}
-              fullWidth
-              onClick={() => setDisputing(true)}
-            >
-              Request a change to this amount
-            </Button>
-          </>
-        )}
-      </Stack>
-    </Paper>
-  );
-}
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 4288117ec..659b5161d 100644
--- a/apps/edr-freight-web/portal/src/pages/contracts/ContractDetailPage.tsx
+++ b/apps/edr-freight-web/portal/src/pages/contracts/ContractDetailPage.tsx
@@ -1,11 +1,6 @@
-import { useEffect, useMemo, useState } from "react";
-import {
-  Navigate,
-  useNavigate,
-  useParams,
-  useSearchParams,
-} from "react-router-dom";
-import { useQuery } from "@tanstack/react-query";
+import { useMemo, useState } from "react";
+import { Navigate, useNavigate, useParams } from "react-router-dom";
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
 import {
   Alert,
   Badge,
@@ -13,9 +8,9 @@ import {
   Button,
   Card,
   Center,
-  FileInput,
   Group,
   Loader,
+  Modal,
   Paper,
   Progress,
   RingProgress,
@@ -24,10 +19,10 @@ import {
   Table,
   Tabs,
   Text,
+  Textarea,
   Title,
 } from "@mantine/core";
 import {
-  AlertTriangle,
   ArrowLeft,
   CalendarClock,
   CheckCircle2,
@@ -49,9 +44,8 @@ import {
   Split,
   Upload,
   Weight,
+  XCircle,
 } from "lucide-react";
-import { Modal } from "@mantine/core";
-import { useDisclosure } from "@mantine/hooks";
 import { isViewable, type ViewableFile } from "@edr/ui-common";
 import type { Freight } from "@edr/types";
 import { clearanceWorkflowFileLabel } from "@edr/types";
@@ -68,11 +62,9 @@ import {
   PaymentBadge,
   SchedulingCell,
 } from "@/pages/bookings/booking-display";
-import { ContractClearancePanel } from "./ContractClearancePanel";
-import { ContractClearanceWorkflowBanner } from "./ContractClearanceWorkflowBanner";
-import { ClearanceUploadedDocumentsPanel } from "@/components/contracts/ClearanceUploadedDocumentsPanel";
 import { InitiateBookingButton } from "@/components/customer-actions/ContractCustomerAction";
 import { formatRateUnit } from "./new-contract-form/unit-rates";
+import { bookingDocNoun } from "@/pages/bookings/clearance/bookingNextAction";
 import { getContractBookingAction } from "./contract-booking-action";
 import { closedWindowMessage, hasOpenWindow } from "./booking-window";
 import { ContractBookingWindowsSection } from "./ContractBookingWindowsSection";
@@ -85,15 +77,6 @@ import {
   MUTED,
 } from "./contract-ui";
 
-// Statuses where the customer uploads clearance documents on the contract. Used
-// by both paths: Path B (customs, GL-reviewed) and Path A self-clearance
-// (non-customs IMPORT/EXPORT, Operations-reviewed).
-const CLEARANCE_UPLOAD_STATUSES = [
-  "AWAITING_CLEARANCE_DOCUMENTS",
-  "CLEARANCE_UNDER_REVIEW",
-  "CLEARANCE_READY_FOR_BOOKING",
-];
-
 type ContractFile = NonNullable<Freight.IContract["files"]>[number];
 
 // Customer-facing labels for a shipment-request status (BOOKING_REQUEST_STATUSES).
@@ -104,29 +87,6 @@ const BOOKING_REQUEST_STATUS_LABELS: Record<string, string> = {
   CANCELLED: "Cancelled",
 };
 
-// Customer-facing labels for an invoice status (Freight.InvoiceStatus).
-const INVOICE_STATUS_LABELS: Record<string, string> = {
-  DRAFT: "Draft",
-  ISSUED: "Issued",
-  PENDING: "Due",
-  PARTIALLY_PAID: "Partially paid",
-  PAID: "Paid",
-  OVERDUE: "Overdue",
-  CANCELLED: "Cancelled",
-  REFUNDED: "Refunded",
-  EXPIRED: "Expired",
-};
-
-function invoiceStatusLabel(status: string): string {
-  return (
-    INVOICE_STATUS_LABELS[status] ??
-    status
-      .replace(/_/g, " ")
-      .toLowerCase()
-      .replace(/\b\w/g, (m) => m.toUpperCase())
-  );
-}
-
 // Business-license document codes — surfaced as their own section so they stand
 // out from the rest of the onboarding/profile set.
 const BUSINESS_LICENSE_DOC_CODES = new Set([
@@ -215,24 +175,45 @@ function groupContractDocuments(
   ].filter((g) => g.files.length > 0);
 }
 
+/**
+ * Statuses where the customer's own cancel is pointless or not theirs to make:
+ * already over, or frozen by EDR (only staff can lift that).
+ */
+const CANCEL_BLOCKED_STATUSES = [
+  "REJECTED",
+  "CANCELLED",
+  "CONTRACT_CLOSED",
+  "ARCHIVED",
+  "EXPIRED",
+  "SUSPENDED",
+];
+
 export default function ContractDetailPage() {
   const { id } = useParams<{ id: string }>();
   const navigate = useNavigate();
   const [tab, setTab] = useState<string>("details");
+  const [cancelOpen, setCancelOpen] = useState(false);
+  const [cancelReason, setCancelReason] = useState("");
+  const queryClient = useQueryClient();
   const { view, viewer } = useFileViewer();
-  const [clearanceOpen, clearanceModal] = useDisclosure(false);
-  const [searchParams, setSearchParams] = useSearchParams();
-
-  // Deep link from the home "needs attention" card: /contracts/:id?action=clearance
-  // opens the clearance step modal directly.
-  useEffect(() => {
-    if (searchParams.get("action") === "clearance") {
-      clearanceModal.open();
-      searchParams.delete("action");
-      setSearchParams(searchParams, { replace: true });
-    }
-  }, [searchParams, clearanceModal, setSearchParams]);
-
+  // Declared up here with the other hooks — the page early-returns further down
+  // (loading / error / redirect-to-edit), so a hook below those would be
+  // conditional.
+  const cancelContract = useMutation({
+    mutationFn: (reason: string | undefined) =>
+      contractsService.cancel(id!, reason),
+    onSuccess: () => {
+      toast.success("Contract cancelled");
+      void queryClient.invalidateQueries({ queryKey: ["contracts"] });
+      navigate("/contracts");
+    },
+    onError: (error: unknown) => {
+      const message =
+        (error as { response?: { data?: { message?: string } } })?.response?.data
+          ?.message ?? "Could not cancel this contract.";
+      toast.error(message);
+    },
+  });
   const {
     data: contract,
     isLoading,
@@ -249,22 +230,6 @@ export default function ContractDetailPage() {
     enabled: !!id,
   });
 
-  // Clearance view — drives queries alert, workflow documents, and duty panels.
-  const inClearance =
-    !!contract && CLEARANCE_UPLOAD_STATUSES.includes(contract.status);
-  const isPhasedCustomsClearance =
-    !!contract &&
-    contract.customsClearingEnabled &&
-    contract.contractKind === "ONE_TIME";
-  const { data: clearanceView, refetch: refetchClearance } = useQuery({
-    ...api.contracts.getClearance.queryOptions({ input: { id: id! } }),
-    enabled: !!id && (inClearance || isPhasedCustomsClearance),
-  });
-  const workflowFiles = clearanceView?.workflowFiles ?? [];
-  const workflowFileCount = workflowFiles.filter((f) => f.file).length;
-  const queriedCount = (clearanceView?.documents ?? []).filter(
-    (d) => d.uploadedBy === "customer" && d.reviewStatus === "QUERIED",
-  ).length;
 
   const showShipmentRequests =
     !!contract &&
@@ -375,16 +340,9 @@ export default function ContractDetailPage() {
   const routes = contract.routes ?? [];
   const pricing = contract.pricingBreakdown;
   const files = contract.files ?? [];
-  // GENERAL contracts clear per booking — clearance documents live on each
-  // booking's detail page, so this tab keeps only profile/licence documents.
-  // Clearance upload field keys (when the clearance view is loaded) let the
-  // grouping tell real clearance docs apart from other attachments.
-  const docGroups = groupContractDocuments(files, {
-    includeClearance: contract.contractKind !== "GENERAL",
-    clearanceKeys: new Set(
-      (clearanceView?.documents ?? []).map((d) => d.fileKey),
-    ),
-  });
+  // Clearance documents live on each booking now, so the contract's Documents
+  // tab keeps only its own attachments (profile, licence, signed contract).
+  const docGroups = groupContractDocuments(files, { includeClearance: false });
   const docCount = docGroups.reduce((sum, g) => sum + g.files.length, 0);
   // The generated contract PDF — surfaced via a dedicated "View contract" button
   // in the header (it's excluded from the Documents tab groups).
@@ -407,18 +365,19 @@ export default function ContractDetailPage() {
   };
 
   const canSign = contract.status === "CONTRACT_READY";
+
+  // The customer may drop their own contract at any live stage so they can
+  // request a different one on the same lane — but not while a shipment under
+  // it is still running, and not while EDR has it suspended. The API enforces
+  // both; this only decides whether the button is offered.
+  const activeShipments = contract.activeBookingCount ?? 0;
+  const cancelStatusOk = !CANCEL_BLOCKED_STATUSES.includes(contract.status);
+  const cancellable = cancelStatusOk && activeShipments === 0;
+
   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
-  // button on a customs contract.
-  const clearanceFinalized =
-    contract.clearanceStatus === "CLEARANCE_READY_FOR_BOOKING" ||
-    contract.status === "CLEARANCE_READY_FOR_BOOKING";
+  // A ONE_TIME contract's shipment instance is opened by the customer on both
+  // paths; on customs (Path B) GL then clears it and completes it with cargo and
+  // price. GENERAL customs stays request-driven, so no booking button there.
   const bookingAction = getContractBookingAction(contract, contractBookings);
   // Whether the customer may open a new self-service booking. Derived from the
   // shared booking-action helper so it honours the ONE_TIME single-slot rule:
@@ -427,16 +386,9 @@ export default function ContractDetailPage() {
   const canBookShipment =
     bookingAction.kind === "book" || bookingAction.kind === "rebook";
   const canRequestShipment = bookingAction.kind === "request";
-  // GENERAL non-customs import/export: one-click bare booking instance — the
-  // per-booking clearance runs first, so no window gate applies here.
+  // Self-clearance import/export (ONE_TIME or GENERAL): one-click bare booking
+  // instance — the per-booking clearance runs first, so no window gate here.
   const canInitiateBooking = bookingAction.kind === "initiate";
-  // Customs + clearance finalized: GL is preparing the booking — surface a
-  // status notice instead of any action.
-  const glPreparingBooking = customsPath && clearanceFinalized;
-  // The customer uploads clearance documents while in a clearance status, until
-  // clearance is finalized.
-  const canUploadClearance =
-    CLEARANCE_UPLOAD_STATUSES.includes(contract.status) && !clearanceFinalized;
 
   return (
     <Box style={{ padding: "28px 32px 40px" }}>
@@ -559,33 +511,37 @@ export default function ContractDetailPage() {
                   </Group>
                 </Paper>
               ))}
-            {glPreparingBooking && (
-              <Badge
-                size="lg"
-                radius="md"
-                variant="light"
-                color="teal"
-                leftSection={<CheckCircle2 size={14} />}
-              >
-                Global Logistics is creating your booking
-              </Badge>
-            )}
-            {canUploadClearance && (
+            {cancelStatusOk && (
               <Button
-                color="edr-green"
+                variant="light"
+                color="red"
                 radius="md"
                 size="md"
-                leftSection={<Upload size={16} />}
-                onClick={clearanceModal.open}
+                leftSection={<XCircle size={16} />}
+                disabled={!cancellable}
+                title={
+                  cancellable
+                    ? undefined
+                    : `${activeShipments} shipment(s) still running on this contract`
+                }
+                onClick={() => setCancelOpen(true)}
               >
-                {contract.status === "CLEARANCE_UNDER_REVIEW"
-                  ? `Manage ${docNoun}`
-                  : `Upload ${docNoun}`}
+                Cancel contract
               </Button>
             )}
           </Group>
         </Group>
 
+        {contract.status === "SUSPENDED" && (
+          <Alert color="orange" radius="md" title="Contract suspended by EDR">
+            {contract.latestSuspensionNote
+              ? `Reason: ${contract.latestSuspensionNote}`
+              : "This contract is on hold."}{" "}
+            No new shipments can be booked and shipments already under it are
+            paused until EDR lifts the suspension.
+          </Alert>
+        )}
+
         {/* Key facts — one premium gradient card */}
         <Paper
           radius={18}
@@ -680,7 +636,7 @@ export default function ContractDetailPage() {
               active={tab === "documents"}
               icon={<Download size={16} />}
               label="Documents"
-              count={docCount + (isPhasedCustomsClearance ? workflowFileCount : 0)}
+              count={docCount}
             />
             <DetailTab
               value="bookings"
@@ -717,174 +673,6 @@ export default function ContractDetailPage() {
         </Paper>
 
 
-        {/* Clearance notice (both paths) */}
-        {queriedCount > 0 && (
-          <Paper
-            withBorder
-            radius="lg"
-            p="lg"
-            style={{
-              borderColor: "#F0B4B4",
-              background: "#FDF4F4",
-              position: "relative",
-              overflow: "hidden",
-            }}
-          >
-            <Box
-              style={{
-                position: "absolute",
-                left: 0,
-                top: 0,
-                bottom: 0,
-                width: 3,
-                background: "#D64545",
-              }}
-            />
-            <Group justify="space-between" align="center" wrap="wrap" gap="sm">
-              <Group gap={10} align="flex-start" wrap="nowrap">
-                <AlertTriangle size={18} color="#D64545" style={{ marginTop: 2 }} />
-                <div>
-                  <Text fw={700} fz={15} c="#7A1F1F">
-                    {queriedCount} document{queriedCount > 1 ? "s" : ""} need
-                    correction
-                  </Text>
-                  <Text fz={13} c="#9A4A4A" mt={2}>
-                    A reviewer sent back document
-                    {queriedCount > 1 ? "s" : ""} with a query. Re-upload the
-                    corrected file{queriedCount > 1 ? "s" : ""} to continue.
-                  </Text>
-                </div>
-              </Group>
-              <Button
-                color="red"
-                radius="md"
-                size="sm"
-                leftSection={<Upload size={15} />}
-                onClick={clearanceModal.open}
-              >
-                Upload corrected documents
-              </Button>
-            </Group>
-          </Paper>
-        )}
-
-        {customsPath && contract.contractKind === "ONE_TIME" ? (
-          <ContractClearanceWorkflowBanner contract={contract} />
-        ) : null}
-
-        {clearanceView?.riskLevel ? (
-          <Paper
-            withBorder
-            radius="lg"
-            p="md"
-            style={{ borderColor: BORDER, background: "#FBFDFC" }}
-          >
-            <Group gap={10} align="center">
-              <Text fw={700} fz={14} c={INK}>
-                Customs risk level
-              </Text>
-              <Badge
-                color={CUSTOMS_RISK_COLOR[clearanceView.riskLevel] ?? "gray"}
-                variant="filled"
-                radius="sm"
-              >
-                {clearanceView.riskLevel.charAt(0) +
-                  clearanceView.riskLevel.slice(1).toLowerCase()}
-              </Badge>
-              {clearanceView.riskAssignedAt ? (
-                <Text fz={12} c="dimmed">
-                  assigned {new Date(clearanceView.riskAssignedAt).toLocaleString()}
-                </Text>
-              ) : null}
-            </Group>
-          </Paper>
-        ) : null}
-
-        {clearanceView?.secondDuty?.advised && clearanceView?.linkedBookingId ? (
-          <SecondDutyDueCard
-            duty={clearanceView.secondDuty}
-            bookingId={clearanceView.linkedBookingId}
-            onView={view}
-            onChanged={() => void refetchClearance()}
-          />
-        ) : null}
-
-        {clearanceView?.finalInvoice && clearanceView?.linkedBookingId ? (
-          <FinalInvoiceDueCard
-            invoice={clearanceView.finalInvoice}
-            bookingId={clearanceView.linkedBookingId}
-            onView={view}
-            onChanged={() => void refetchClearance()}
-          />
-        ) : null}
-
-        {canUploadClearance && (
-          <Paper
-            withBorder
-            radius="lg"
-            p="lg"
-            style={{
-              borderColor: "#CDEBDD",
-              background: "#F6FBF8",
-              position: "relative",
-              overflow: "hidden",
-            }}
-          >
-            <Box
-              style={{
-                position: "absolute",
-                left: 0,
-                top: 0,
-                bottom: 0,
-                width: 3,
-                background: GREEN,
-              }}
-            />
-            <Group gap={10} align="center" mb={6}>
-              <Upload size={16} color={GREEN} />
-              <Text fw={700} fz={15} c={INK}>
-                {customsPath
-                  ? "Customs clearance shipment"
-                  : isIntercity
-                    ? "Intercity documents required"
-                    : "Customs clearance required"}
-              </Text>
-            </Group>
-            <Text fz={13} c="dimmed">
-              {customsPath
-                ? contract.status === "AWAITING_CLEARANCE_DOCUMENTS"
-                  ? "Upload your clearance documents so Global Logistics can review them. Once they finalize the clearance you can create your shipment booking."
-                  : 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."
-                : 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
-                mt="md"
-                color="edr-green"
-                radius="md"
-                size="sm"
-                leftSection={<Upload size={15} />}
-                onClick={clearanceModal.open}
-              >
-                {contract.status === "AWAITING_CLEARANCE_DOCUMENTS"
-                  ? "Upload documents"
-                  : "Manage documents"}
-              </Button>
-            )}
-          </Paper>
-        )}
 
         {/* Unit-rate schedule */}
         <Card
@@ -1213,21 +1001,6 @@ export default function ContractDetailPage() {
           {/* ── Documents tab ─────────────────────────────────────────── */}
           <Tabs.Panel value="documents">
             <Stack gap="lg">
-              {isPhasedCustomsClearance ? (
-                <ClearanceUploadedDocumentsPanel
-                  files={workflowFiles}
-                  tradeDirection={contract.tradeDirection ?? "IMPORT"}
-                  onView={view}
-                  onDownload={async (f) => {
-                    try {
-                      await downloadStoredFile(f.id, f.name);
-                    } catch {
-                      toast.error("Could not download file.");
-                    }
-                  }}
-                />
-              ) : null}
-
             {docGroups.length === 0 ? (
               <Card
                 withBorder
@@ -1255,7 +1028,7 @@ export default function ContractDetailPage() {
                   <Text fz={13} c="dimmed" ta="center" maw={420}>
                     {isGeneral
                       ? "Your company profile documents (TIN certificate, business licence, ID) appear here. Clearance documents are managed on each booking."
-                      : "The signed contract and any uploaded clearance documents will appear here."}
+                      : "The signed contract and your company documents appear here. Clearance documents are managed on each booking."}
                   </Text>
                 </Stack>
               </Card>
@@ -1455,10 +1228,10 @@ export default function ContractDetailPage() {
                   <Text fz={13} c="dimmed" ta="center" maw={380}>
                     {canBookShipment
                       ? "No bookings yet. Use “New booking” to ship against this contract."
-                      : customsPath
-                        ? "No bookings yet. After your clearance documents are approved, Global Logistics creates the booking on your behalf."
-                        : canUploadClearance
-                          ? "No bookings yet. After the Operations team approves your clearance documents, you can create a booking here."
+                      : canInitiateBooking
+                        ? `No shipments yet. Start one with “Initiate booking” — you upload the ${bookingDocNoun(contract)} on that shipment.`
+                        : customsPath
+                          ? "No bookings yet. Global Logistics opens the shipment on your behalf — you upload the clearance documents on it."
                           : "Bookings appear here once the contract is fully executed."}
                   </Text>
                 </Stack>
@@ -1578,23 +1351,42 @@ export default function ContractDetailPage() {
       {viewer}
 
       <Modal
-        opened={clearanceOpen}
-        onClose={clearanceModal.close}
-        title={
-          <Text fw={700} fz={16}>
-            {isIntercity ? "Intercity documents" : "Clearance documents"}
-          </Text>
-        }
-        size="xl"
-        radius="md"
+        opened={cancelOpen}
+        onClose={() => setCancelOpen(false)}
+        title="Cancel this contract?"
         centered
-        overlayProps={{ blur: 2, backgroundOpacity: 0.55 }}
       >
-        <ContractClearancePanel
-          contractId={contract.id}
-          tradeDirection={contract.tradeDirection ?? "IMPORT"}
-          bare
-        />
+        <Stack gap="md">
+          <Text size="sm">
+            Contract <b>{contract.reference}</b> will be cancelled. This cannot
+            be undone — but the lane is freed, so you can request a new contract
+            for the same route right away.
+          </Text>
+          <Textarea
+            label="Reason (optional)"
+            placeholder="Why are you cancelling this contract?"
+            autosize
+            minRows={2}
+            value={cancelReason}
+            onChange={(e) => setCancelReason(e.currentTarget.value)}
+          />
+          <Group justify="flex-end" gap="sm">
+            <Button variant="default" onClick={() => setCancelOpen(false)}>
+              Keep contract
+            </Button>
+            <Button
+              color="red"
+              loading={cancelContract.isPending}
+              onClick={() =>
+                cancelContract.mutate(cancelReason.trim() || undefined, {
+                  onSuccess: () => setCancelOpen(false),
+                })
+              }
+            >
+              Cancel contract
+            </Button>
+          </Group>
+        </Stack>
       </Modal>
     </Box>
   );
@@ -1931,292 +1723,3 @@ function FactCell({
   );
 }
 
-/**
- * Post-offload final invoice from GL Djibouti (export): shows the due amount +
- * invoice document; the customer pays offline and attaches the payment slip
- * here, then GL confirms and the badge flips to PAID.
- */
-function FinalInvoiceDueCard({
-  invoice,
-  bookingId,
-  onView,
-  onChanged,
-}: {
-  invoice: NonNullable<Freight.ContractClearanceView["finalInvoice"]>;
-  bookingId: string;
-  onView: (file: { name: string; url: string }) => void;
-  onChanged: () => void;
-}) {
-  const [slip, setSlip] = useState<File | null>(null);
-  const [uploading, setUploading] = useState(false);
-  const paid = invoice.status === "PAID";
-
-  return (
-    <Paper
-      withBorder
-      radius="lg"
-      p="lg"
-      style={{
-        borderColor: paid ? "#CDEBDD" : "#F2D9A6",
-        background: paid ? "#F6FBF8" : "#FFFBF2",
-        position: "relative",
-        overflow: "hidden",
-      }}
-    >
-      <Box
-        style={{
-          position: "absolute",
-          left: 0,
-          top: 0,
-          bottom: 0,
-          width: 3,
-          background: paid ? GREEN : "#E3A93C",
-        }}
-      />
-      <Group justify="space-between" align="flex-start" wrap="wrap" gap="md">
-        <div>
-          <Group gap={8} align="center">
-            <FileBadge size={16} color={paid ? GREEN : "#B07C1F"} />
-            <Text fw={700} fz={15} c={INK}>
-              {paid ? "Final invoice paid" : "Final invoice due"} —{" "}
-              {invoice.invoiceNumber}
-            </Text>
-            <Badge color={paid ? "edr-green" : "yellow"} variant="light" radius="sm">
-              {invoiceStatusLabel(invoice.status)}
-            </Badge>
-          </Group>
-          <Text fz={20} fw={800} mt={6} c={INK}>
-            {invoice.totalAmount.toLocaleString()} {invoice.currency}
-          </Text>
-          {invoice.description ? (
-            <Text fz={13} c="dimmed" mt={2}>
-              {invoice.description}
-            </Text>
-          ) : null}
-          {!paid ? (
-            <Text fz={13} c="#9A6B1F" mt={6}>
-              Pay the amount above and attach your payment slip — Global
-              Logistics will confirm the payment.
-            </Text>
-          ) : null}
-        </div>
-
-        <Stack gap="xs" miw={260}>
-          {invoice.invoiceFile ? (
-            <Button
-              variant="default"
-              radius="md"
-              size="sm"
-              leftSection={<Eye size={15} />}
-              onClick={() =>
-                onView({
-                  name: invoice.invoiceFile!.name,
-                  url: invoice.invoiceFile!.url,
-                })
-              }
-            >
-              View invoice
-            </Button>
-          ) : null}
-          {invoice.slipFile ? (
-            <Button
-              variant="default"
-              radius="md"
-              size="sm"
-              leftSection={<Eye size={15} />}
-              onClick={() =>
-                onView({
-                  name: invoice.slipFile!.name,
-                  url: invoice.slipFile!.url,
-                })
-              }
-            >
-              View payment slip
-            </Button>
-          ) : null}
-          {!paid ? (
-            <>
-              <FileInput
-                placeholder={
-                  invoice.slipFile ? "Replace payment slip" : "Attach payment slip"
-                }
-                value={slip}
-                onChange={setSlip}
-                size="sm"
-                radius="md"
-              />
-              <Button
-                color="edr-green"
-                radius="md"
-                size="sm"
-                loading={uploading}
-                disabled={!slip}
-                leftSection={<Upload size={15} />}
-                onClick={async () => {
-                  if (!slip) return;
-                  setUploading(true);
-                  try {
-                    await contractsService.uploadFinalInvoiceSlip(bookingId, slip);
-                    setSlip(null);
-                    toast.success("Payment slip attached");
-                    onChanged();
-                  } catch (e) {
-                    toast.error(
-                      e instanceof Error ? e.message : "Upload failed",
-                    );
-                  } finally {
-                    setUploading(false);
-                  }
-                }}
-              >
-                {invoice.slipFile ? "Replace slip" : "Submit payment slip"}
-              </Button>
-            </>
-          ) : null}
-        </Stack>
-      </Group>
-    </Paper>
-  );
-}
-
-const CUSTOMS_RISK_COLOR: Record<string, string> = {
-  GREEN: "green",
-  YELLOW: "yellow",
-  RED: "red",
-};
-
-/**
- * Post-arrival additional duty/tax round (import): GL advises an extra amount
- * with a notice; the customer pays offline and attaches another slip here.
- */
-function SecondDutyDueCard({
-  duty,
-  bookingId,
-  onView,
-  onChanged,
-}: {
-  duty: NonNullable<Freight.ContractClearanceView["secondDuty"]>;
-  bookingId: string;
-  onView: (file: { name: string; url: string }) => void;
-  onChanged: () => void;
-}) {
-  const [slip, setSlip] = useState<File | null>(null);
-  const [uploading, setUploading] = useState(false);
-  const paid = duty.paid;
-
-  return (
-    <Paper
-      withBorder
-      radius="lg"
-      p="lg"
-      style={{
-        borderColor: paid ? "#CDEBDD" : "#F2D9A6",
-        background: paid ? "#F6FBF8" : "#FFFBF2",
-        position: "relative",
-        overflow: "hidden",
-      }}
-    >
-      <Box
-        style={{
-          position: "absolute",
-          left: 0,
-          top: 0,
-          bottom: 0,
-          width: 3,
-          background: paid ? GREEN : "#E3A93C",
-        }}
-      />
-      <Group justify="space-between" align="flex-start" wrap="wrap" gap="md">
-        <div>
-          <Group gap={8} align="center">
-            <FileBadge size={16} color={paid ? GREEN : "#B07C1F"} />
-            <Text fw={700} fz={15} c={INK}>
-              {paid ? "Additional duty & tax paid" : "Additional duty & tax due"}
-            </Text>
-            <Badge color={paid ? "edr-green" : "yellow"} variant="light" radius="sm">
-              {paid ? "PAID" : "DUE"}
-            </Badge>
-          </Group>
-          <Text fz={20} fw={800} mt={6} c={INK}>
-            {(duty.amount ?? 0).toLocaleString()} {duty.currency ?? ""}
-          </Text>
-          {duty.declarationSerial ? (
-            <Text fz={13} c="dimmed" mt={2}>
-              Payment code: {duty.declarationSerial}
-            </Text>
-          ) : null}
-          {!paid ? (
-            <Text fz={13} c="#9A6B1F" mt={6}>
-              Customs advised additional duty/tax after arrival. Pay the amount
-              above and attach your payment slip.
-            </Text>
-          ) : null}
-        </div>
-
-        <Stack gap="xs" miw={260}>
-          {duty.noticeFile ? (
-            <Button
-              variant="default"
-              radius="md"
-              size="sm"
-              leftSection={<Eye size={15} />}
-              onClick={() =>
-                onView({ name: duty.noticeFile!.name, url: duty.noticeFile!.url })
-              }
-            >
-              View duty notice
-            </Button>
-          ) : null}
-          {duty.slipFile ? (
-            <Button
-              variant="default"
-              radius="md"
-              size="sm"
-              leftSection={<Eye size={15} />}
-              onClick={() =>
-                onView({ name: duty.slipFile!.name, url: duty.slipFile!.url })
-              }
-            >
-              View payment slip
-            </Button>
-          ) : null}
-          {!paid ? (
-            <>
-              <FileInput
-                placeholder={duty.slipFile ? "Replace payment slip" : "Attach payment slip"}
-                value={slip}
-                onChange={setSlip}
-                size="sm"
-                radius="md"
-              />
-              <Button
-                color="edr-green"
-                radius="md"
-                size="sm"
-                loading={uploading}
-                disabled={!slip}
-                leftSection={<Upload size={15} />}
-                onClick={async () => {
-                  if (!slip) return;
-                  setUploading(true);
-                  try {
-                    await contractsService.uploadSecondDutySlip(bookingId, slip);
-                    setSlip(null);
-                    toast.success("Payment slip attached");
-                    onChanged();
-                  } catch (e) {
-                    toast.error(e instanceof Error ? e.message : "Upload failed");
-                  } finally {
-                    setUploading(false);
-                  }
-                }}
-              >
-                {duty.slipFile ? "Replace slip" : "Submit payment slip"}
-              </Button>
-            </>
-          ) : null}
-        </Stack>
-      </Group>
-    </Paper>
-  );
-}
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 bc7d55691..012ec0d52 100644
--- a/apps/edr-freight-web/portal/src/pages/contracts/ContractStepBanner.tsx
+++ b/apps/edr-freight-web/portal/src/pages/contracts/ContractStepBanner.tsx
@@ -124,7 +124,11 @@ function resolveStep(status: string): StepState {
       return { activeIdx: at("active"), terminal: "EXPIRED", next: "This contract's validity has expired." };
     case "CONTRACT_CLOSED":
     case "ARCHIVED":
-      return { activeIdx: STAGES.length - 1, terminal: "CLOSED", next: "This contract is closed." };
+      return {
+        activeIdx: STAGES.length - 1,
+        terminal: "CLOSED",
+        next: "This contract is completed — its shipment was delivered.",
+      };
 
     default:
       return { activeIdx: at("draft"), terminal: null, next: "" };
diff --git a/apps/edr-freight-web/portal/src/pages/contracts/contract-booking-action.ts b/apps/edr-freight-web/portal/src/pages/contracts/contract-booking-action.ts
index c7374d510..225374f6f 100644
--- a/apps/edr-freight-web/portal/src/pages/contracts/contract-booking-action.ts
+++ b/apps/edr-freight-web/portal/src/pages/contracts/contract-booking-action.ts
@@ -40,8 +40,9 @@ export interface ContractBookingAction {
  * The single source of truth for whether a contract row should show a
  * Book / Re-book shipment button, and where it should navigate.
  *
- * - ONE_TIME: book only while there is no active booking. If the previous
- *   booking expired, offer Re-book. Once a live booking exists, no button.
+ * - ONE_TIME: one shipment instance at a time. Import/export initiates a bare
+ *   instance (clearance first) whether it self-clears or goes through customs;
+ *   intercity books directly.
  * - GENERAL: bookable while CONTRACT_ACTIVE (CONTRACT_CLOSED / EXPIRED are
  *   already excluded by the PATH_A_BOOKABLE gate).
  */
@@ -61,8 +62,18 @@ export function getContractBookingAction(
     };
   }
 
-  // Other customs (ONE_TIME): booked by GL — no customer action.
-  if (contract.customsClearingEnabled) return { kind: "none", to: "" };
+  // Customs: only a ONE_TIME import/export contract is opened by the customer —
+  // he initiates the bare instance and uploads the customs documents on it, GL
+  // clears it and completes it with cargo and price. GENERAL customs went
+  // through the shipment-request branch above; intercity customs is booked by GL
+  // directly with its cargo.
+  if (
+    contract.customsClearingEnabled &&
+    (contract.contractKind !== "ONE_TIME" ||
+      contract.tradeDirection === "DOMESTIC")
+  ) {
+    return { kind: "none", to: "" };
+  }
   if (!PATH_A_BOOKABLE.includes(contract.status)) return { kind: "none", to: "" };
 
   const to = `/contracts/${contract.id}/bookings/new`;
@@ -76,13 +87,24 @@ export function getContractBookingAction(
     const hasLiveSplit = mine.some(
       (b) => b.isSplit && !RELEASING_BOOKING_STATUSES.includes(b.status),
     );
-    if (hasLiveSplit) return { kind: "book", to, remainderOnly: true };
-    const hasActive = mine.some(
-      (b) => !TERMINAL_BOOKING_STATUSES.includes(b.status),
-    );
+    const hasActive =
+      !hasLiveSplit &&
+      mine.some((b) => !TERMINAL_BOOKING_STATUSES.includes(b.status));
     if (hasActive) return { kind: "none", to: "" };
-    const hasExpired = mine.some((b) => b.status === "EXPIRED");
-    return { kind: hasExpired ? "rebook" : "book", to };
+    // Intercity is booked directly with its cargo (no shipment day to defer to);
+    // its documents still live on that booking.
+    if (contract.tradeDirection === "DOMESTIC") {
+      const hasExpired = mine.some((b) => b.status === "EXPIRED");
+      return { kind: hasExpired ? "rebook" : "book", to };
+    }
+    // Import/export self-clearance: one-click bare instance, exactly like a
+    // GENERAL contract — clearance documents are uploaded on it, and cargo +
+    // shipment day come at completion.
+    return {
+      kind: "initiate",
+      to: `/contracts/${contract.id}`,
+      ...(hasLiveSplit ? { remainderOnly: true } : {}),
+    };
   }
 
   // GENERAL non-customs import/export: one-click bare booking instance — the
diff --git a/apps/edr-freight-web/portal/src/pages/contracts/contract-ui.tsx b/apps/edr-freight-web/portal/src/pages/contracts/contract-ui.tsx
index 4043fc71d..0ab4ba776 100644
--- a/apps/edr-freight-web/portal/src/pages/contracts/contract-ui.tsx
+++ b/apps/edr-freight-web/portal/src/pages/contracts/contract-ui.tsx
@@ -132,8 +132,9 @@ export const CONTRACT_STATUS_CONFIG: Record<
   CLEARANCE_UNDER_REVIEW: { label: "Clearance Under Review", ...TONE.info },
   CLEARANCE_READY_FOR_BOOKING: { label: "Cleared — Awaiting Booking", ...TONE.success },
   ACTIVE_SHIPMENT_IN_PROGRESS: { label: "Shipment In Progress", ...TONE.info },
+  SUSPENDED: { label: "Suspended", ...TONE.warning },
   // ── Terminal ──
-  CONTRACT_CLOSED: { label: "Closed", ...TONE.neutral },
+  CONTRACT_CLOSED: { label: "Completed", ...TONE.neutral },
   EXPIRED: { label: "Expired", ...TONE.danger },
   REJECTED: { label: "Rejected", ...TONE.danger },
   CANCELLED: { label: "Cancelled", ...TONE.danger },
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 79328a5dd..bb5f7f534 100644
--- a/apps/edr-freight-web/portal/src/services/bookings.service.ts
+++ b/apps/edr-freight-web/portal/src/services/bookings.service.ts
@@ -398,6 +398,16 @@ export const bookingsService = {
     return data.data ?? data;
   },
 
+  disputeBookingClearanceDuty: async (
+    id: string,
+    note: string,
+  ): Promise<Freight.IBooking> => {
+    const { data } = await client.post(`/api/bookings/${id}/clearance/duty/dispute`, {
+      note,
+    });
+    return data.data ?? data;
+  },
+
   getContractView: async (id: string): Promise<ContractView> => {
     const { data } = await client.get(B.CONTRACT_VIEW(id));
     return data.data ?? data;
diff --git a/apps/edr-freight-web/portal/src/services/contracts.service.ts b/apps/edr-freight-web/portal/src/services/contracts.service.ts
index 6f6d48e11..0afe84317 100644
--- a/apps/edr-freight-web/portal/src/services/contracts.service.ts
+++ b/apps/edr-freight-web/portal/src/services/contracts.service.ts
@@ -285,6 +285,15 @@ export const contractsService = {
     return data.data ?? data;
   },
 
+  /**
+   * Cancel own contract so a fresh one can be requested on the same lane. The
+   * API rejects it while any shipment on the contract is still live.
+   */
+  cancel: async (id: string, reason?: string): Promise<Freight.IContract> => {
+    const { data } = await client.post(C.CANCEL(id), { reason });
+    return data.data ?? data;
+  },
+
   // ── Pre-booking clearance (Path B) ──
   getClearance: async (id: string): Promise<Freight.ContractClearanceView> => {
     const { data } = await client.get(C.CLEARANCE(id));
diff --git a/apps/edr-freight-web/portal/src/utils/api.ts b/apps/edr-freight-web/portal/src/utils/api.ts
index a316d9520..1ba9ec8db 100644
--- a/apps/edr-freight-web/portal/src/utils/api.ts
+++ b/apps/edr-freight-web/portal/src/utils/api.ts
@@ -39,6 +39,9 @@ client.interceptors.request.use((config) => {
   if (token) {
     config.headers.Authorization = `Bearer ${token}`;
   }
+  // Tells the backend which app is asking, so /auth/login can reject
+  // cross-audience credentials (EDRFREIGHT-415).
+  config.headers["X-Client-App"] = "portal";
   return config;
 });
 
diff --git a/apps/edr-passenger-api/src/common/passenger-guards.ts b/apps/edr-passenger-api/src/common/passenger-guards.ts
index cadd56889..936ee73ef 100644
--- a/apps/edr-passenger-api/src/common/passenger-guards.ts
+++ b/apps/edr-passenger-api/src/common/passenger-guards.ts
@@ -11,4 +11,18 @@ export const PassengerStaff = (permission: string | string[]) =>
     ),
   );
 
+/**
+ * Like {@link PassengerStaff} but the permission must be explicitly granted —
+ * super admins / org admins get no automatic bypass.
+ */
+export const PassengerStaffStrict = (permission: string | string[]) =>
+  applyDecorators(
+    UseGuards(
+      JwtGuard,
+      PassengerPermissionGuard(Array.isArray(permission) ? permission : [permission], {
+        strict: true,
+      }),
+    ),
+  );
+
 export const PassengerAdmin = () => PassengerStaff(PASSENGER_PERMS.admin);
diff --git a/apps/edr-passenger-api/src/common/passenger-permission.guard.ts b/apps/edr-passenger-api/src/common/passenger-permission.guard.ts
index a93b2060b..d101fb63b 100644
--- a/apps/edr-passenger-api/src/common/passenger-permission.guard.ts
+++ b/apps/edr-passenger-api/src/common/passenger-permission.guard.ts
@@ -6,9 +6,25 @@ import {
   Type,
   UnauthorizedException,
 } from '@nestjs/common';
-import { hasPassengerPermission } from './passenger-permission.util';
+import {
+  hasPassengerPermission,
+  hasPassengerPermissionStrict,
+} from './passenger-permission.util';
+
+export type PassengerPermissionGuardOptions = {
+  /**
+   * When true, super admins and org admins do NOT bypass the check — the
+   * permission key must be explicitly granted to them like anyone else.
+   */
+  strict?: boolean;
+};
+
+export function PassengerPermissionGuard(
+  permissions: string[],
+  options: PassengerPermissionGuardOptions = {},
+): Type<CanActivate> {
+  const check = options.strict ? hasPassengerPermissionStrict : hasPassengerPermission;
 
-export function PassengerPermissionGuard(permissions: string[]): Type<CanActivate> {
   @Injectable()
   class PassengerPermissionsGuard implements CanActivate {
     canActivate(context: ExecutionContext): boolean {
@@ -18,10 +34,11 @@ export function PassengerPermissionGuard(permissions: string[]): Type<CanActivat
       if (!permissions?.length) return true;
       if (!user) throw new UnauthorizedException('Authentication required');
 
-      if (permissions.some((p) => hasPassengerPermission(user, p))) return true;
+      if (permissions.some((p) => check(user, p))) return true;
 
       throw new ForbiddenException(
-        `Missing permission. Required one of: ${permissions.join(', ')}`,
+        `Missing permission. Required one of: ${permissions.join(', ')}` +
+          (options.strict ? ' (granted explicitly — admin role does not bypass)' : ''),
       );
     }
   }
diff --git a/apps/edr-passenger-api/src/common/passenger-permission.util.ts b/apps/edr-passenger-api/src/common/passenger-permission.util.ts
index 62df74603..d915ef86e 100644
--- a/apps/edr-passenger-api/src/common/passenger-permission.util.ts
+++ b/apps/edr-passenger-api/src/common/passenger-permission.util.ts
@@ -65,6 +65,20 @@ export function hasPassengerPermission(
   return collectPermissionKeys(user).includes(permissionKey);
 }
 
+/**
+ * Same check as {@link hasPassengerPermission} but WITHOUT the super-admin /
+ * org-admin bypass — the permission key must be explicitly granted, whether via
+ * a role or an employee position. Use for actions that must stay auditable to a
+ * deliberate grant (e.g. ticket generation, which can waive a fare).
+ */
+export function hasPassengerPermissionStrict(
+  user: MeLikeUser | null | undefined,
+  permissionKey: string,
+): boolean {
+  if (!user) return false;
+  return collectPermissionKeys(user).includes(permissionKey);
+}
+
 export function assertPassengerPermission(
   user: MeLikeUser | null | undefined,
   permissionKey: string,
diff --git a/apps/edr-passenger-api/src/common/utils/checkin-cutoff.utils.ts b/apps/edr-passenger-api/src/common/utils/checkin-cutoff.utils.ts
index 36c0f872c..5a0fb50b1 100644
--- a/apps/edr-passenger-api/src/common/utils/checkin-cutoff.utils.ts
+++ b/apps/edr-passenger-api/src/common/utils/checkin-cutoff.utils.ts
@@ -1,19 +1,21 @@
 /**
- * Resolves the booking/check-in cutoff for one boarding stop.
+ * Resolves the booking/check-in cutoff for one boarding stop: stop-level
+ * `RouteStop.checkinMinutesBefore` override wins, else the route-level default
+ * (`Route.checkinMinutesBefore`), else a bare 30-minute fallback for routes/stops with
+ * neither configured. The basis is the stop's own estimated ARRIVAL time (the train reaching
+ * that stop), not its departure or the schedule's overall origin departure — a downstream
+ * stop's cutoff must be independent of how long ago the train left its origin. The first stop
+ * of a route has no arrival (nothing to arrive at), so it falls back to its own departure.
  *
- * Priority for checkinMinutes: RouteStop.checkinMinutesBefore → Route.checkinMinutesBefore → 30.
- *
- * Anchor (segmentTime): plannedDepartureAt ?? plannedArrivalAt ?? schedule.departureAt.
- *   - For the origin stop: plannedDepartureAt = schedule.departureAt (no arrival).
- *   - For intermediate stops: plannedDepartureAt = plannedArrivalAt + dwell (checkinMinutesBefore).
- *     cutoffAt = departureAt − checkinMinutesBefore = arrivalAt, so booking closes the
- *     moment the train reaches the stop — independent of how long ago it left the origin.
- *
- * Single source of truth — SeatsService.holdSeats and SearchService.buildScheduleResult both
- * apply it; GuestBookingService.createGuestBooking also applies it per boarding stop.
+ * Single source of truth for this computation — SeatsService.holdSeats and
+ * SearchService.buildScheduleResult already applied it (search results only ever showed a
+ * segment as bookable if this same cutoff hadn't passed); GuestBookingService.createGuestBooking
+ * used to independently hardcode a flat, non-configurable 30 minutes off the schedule's origin
+ * departure, which could reject a booking the search/hold steps had just accepted under the
+ * route's actual configured cutoff.
  */
 export interface CheckinCutoff {
-  /** The stop's planned departure time (or arrival / schedule departure as fallback). */
+  /** The stop's own estimated arrival time (or departure, for the first stop / missing data). */
   segmentTime: Date;
   /** Minutes before segmentTime that booking/holding closes. */
   checkinMinutes: number;
@@ -32,7 +34,7 @@ export function resolveCheckinCutoff(
   stopTime: { plannedArrivalAt?: Date | null; plannedDepartureAt?: Date | null } | null | undefined,
   stationId: string | null | undefined,
 ): CheckinCutoff {
-  const segmentTime = stopTime?.plannedDepartureAt ?? stopTime?.plannedArrivalAt ?? schedule.departureAt;
+  const segmentTime = stopTime?.plannedArrivalAt ?? stopTime?.plannedDepartureAt ?? schedule.departureAt;
   const routeStop = stationId ? schedule.route?.stops?.find((s) => s.stationId === stationId) : undefined;
   const checkinMinutes = routeStop?.checkinMinutesBefore ?? schedule.route?.checkinMinutesBefore ?? 30;
   return {
diff --git a/apps/edr-passenger-api/src/modules/bookings/bookings.controller.ts b/apps/edr-passenger-api/src/modules/bookings/bookings.controller.ts
index bd04ed34f..2c9010270 100644
--- a/apps/edr-passenger-api/src/modules/bookings/bookings.controller.ts
+++ b/apps/edr-passenger-api/src/modules/bookings/bookings.controller.ts
@@ -35,7 +35,7 @@ import {
   IssueReservationBookingDto,
 } from "./guest-booking.dto";
 import { JwtGuard } from "../../common/jwt.guard";
-import { PassengerAdmin, PassengerStaff } from "../../common/passenger-guards";
+import { PassengerAdmin, PassengerStaff, PassengerStaffStrict } from "../../common/passenger-guards";
 import { PASSENGER_PERMS } from "../../seed/passenger-permissions.registry";
 
 @ApiTags("Booking")
@@ -352,12 +352,12 @@ export class BookingsController {
   }
 
   @Post("reservations/:seatId/issue")
-  @PassengerStaff([PASSENGER_PERMS.seats.manage, PASSENGER_PERMS.bookings.manage, PASSENGER_PERMS.admin])
+  @PassengerStaffStrict(PASSENGER_PERMS.tickets.generate)
   @ApiBearerAuth("IAM-auth")
   @ApiOperation({
-    summary: "Issue a booking from a reserved (blocked) seat",
+    summary: "Issue a booking from a reserved (blocked) seat — requires tickets:generate",
     description:
-      "Converts an admin-reserved seat into a real booking for one traveler. bookingKind STAFF waives the fee and issues the ticket immediately; bookingKind PASSENGER creates the booking as PENDING_PAYMENT and texts a payment link to the traveler's phone.",
+      "Converts an admin-reserved seat into a real booking for one traveler. bookingKind STAFF waives the fee and issues the ticket immediately; bookingKind PASSENGER creates the booking as PENDING_PAYMENT and texts a payment link to the traveler's phone. Because STAFF issuance waives the fare, this requires edr_passenger_app:tickets:generate to be explicitly granted — super admins and org admins do NOT bypass it.",
   })
   @ApiBody({ type: IssueReservationBookingDto })
   issueBookingFromReservation(
@@ -369,6 +369,24 @@ export class BookingsController {
     return this.guestService.issueBookingFromReservation(seatId, dto, actingUserId);
   }
 
+  @Delete("reservations/:seatId")
+  @PassengerStaff([PASSENGER_PERMS.seats.manage, PASSENGER_PERMS.bookings.manage, PASSENGER_PERMS.admin])
+  @ApiBearerAuth("IAM-auth")
+  @ApiOperation({
+    summary: "Cancel a seat's pending-payment reservation and release the seat",
+    description:
+      "For a seat with an active PASSENGER-kind reservation (payment link sent, not yet paid): cancels that booking and releases the seat's hold, so it's genuinely free for someone else. The old payment link stops working immediately (the booking is no longer PENDING_PAYMENT).",
+  })
+  @ApiQuery({ name: "scheduleId", required: true, description: "TrainSchedule UUID the reservation was issued on" })
+  cancelReservationForSeat(
+    @Param("seatId") seatId: string,
+    @Query("scheduleId") scheduleId: string,
+    @Req() req: any,
+  ) {
+    const actingUserId = req.user?.id ?? req.user?.sub ?? null;
+    return this.service.cancelReservationForSeat(seatId, scheduleId, actingUserId);
+  }
+
   @Get("pay/:token")
   @SetMetadata("isPublic", true)
   @ApiOperation({
diff --git a/apps/edr-passenger-api/src/modules/bookings/bookings.service.ts b/apps/edr-passenger-api/src/modules/bookings/bookings.service.ts
index b5825ddc5..26ab854d3 100644
--- a/apps/edr-passenger-api/src/modules/bookings/bookings.service.ts
+++ b/apps/edr-passenger-api/src/modules/bookings/bookings.service.ts
@@ -2138,6 +2138,39 @@ export class BookingsService {
     return { cancelled: true, refundAmount: refundAmount / 100, currency: booking.displayCurrency};
   }
 
+  /**
+   * Staff releasing a seat that already has an in-flight backoffice reservation must not
+   * leave that booking dangling as PENDING_PAYMENT with a still-payable link — the traveler
+   * could pay for a seat that's since been given away. Finds the active reservation covering
+   * this exact seat+schedule and cancels it via the normal cancel() path (refund=0, since it's
+   * still unpaid), then separately releases the SeatHold issueBookingFromReservation created —
+   * cancel()'s releaseSeats() only deletes Journey/JourneySegment rows, which don't exist yet
+   * for an unpaid reservation, so without this the seat would stay held until the hold's own
+   * expiry. Once status flips to CANCELLED, getByPayToken's existing status check already
+   * rejects the old payToken with "This booking is no longer awaiting payment" — no separate
+   * payToken invalidation needed.
+   */
+  async cancelReservationForSeat(seatId: string, scheduleId: string, actingUserId: string | null) {
+    const bookingSeat = await this.prisma.bookingSeat.findFirst({
+      where: {
+        seatId,
+        scheduleId,
+        booking: { source: 'BACKOFFICE_RESERVATION', status: 'PENDING_PAYMENT' },
+      },
+      include: { booking: true },
+    });
+    if (!bookingSeat) throw new NotFoundException('No pending reservation found for this seat');
+
+    const { bookingRef } = bookingSeat.booking;
+    const result = await this.cancel(bookingRef, 'Seat released by staff before payment', actingUserId ?? undefined);
+
+    await this.prisma.seatHold.deleteMany({
+      where: { scheduleId, seatIds: { hasSome: [seatId] } },
+    });
+
+    return { ...result, bookingRef };
+  }
+
   async update(id: string, dto: any) {
     const booking = await this.prisma.booking.findUnique({ where: { id } });
     if (!booking) throw new NotFoundException('Booking not found');
diff --git a/apps/edr-passenger-api/src/modules/bookings/guest-booking.service.ts b/apps/edr-passenger-api/src/modules/bookings/guest-booking.service.ts
index 238d58d82..c8061184f 100644
--- a/apps/edr-passenger-api/src/modules/bookings/guest-booking.service.ts
+++ b/apps/edr-passenger-api/src/modules/bookings/guest-booking.service.ts
@@ -294,8 +294,12 @@ export class GuestBookingService {
 
     let displayTotalMinor: number;
     let resolvedTotalMinor: number;
+    // True when the total came from a client-summed subtotal (per-seat sum or reviewedTotalMinor),
+    // which the portal computes UNDISCOUNTED — the promo must still be applied to it (H-13).
+    let usedClientSubtotal = false;
     if (allFaresProvided && !isPackageOneway) {
       displayTotalMinor = passengersWithFares.reduce((sum, p) => sum + p.fareMinor, 0);
+      usedClientSubtotal = true;
     } else if (isPackageOneway && dto.reviewedTotalMinor != null) {
       displayTotalMinor = dto.reviewedTotalMinor;
       if (seatedPassengers.length > 0) {
@@ -306,6 +310,7 @@ export class GuestBookingService {
       }
     } else if (dto.reviewedTotalMinor != null && dto.reviewedTotalMinor > 0) {
       displayTotalMinor = dto.reviewedTotalMinor;
+      usedClientSubtotal = true;
     } else {
       // fare engine returns ETB — convert forward to display currency
       const etbTotal = Math.max(0, totalBaseFareMinor - discountMinor);
@@ -313,6 +318,18 @@ export class GuestBookingService {
         ? await this.currencyService.convertAmount(etbTotal, Currency.ETB, displayCurrency)
         : etbTotal;
     }
+
+    // H-13: the portal sums UNDISCOUNTED per-passenger fares into a client subtotal, silently
+    // dropping the promo the fare engine recognized. Apply the authoritative discount now so the
+    // customer is charged the discounted price. The non-client-subtotal branch above already
+    // nets the discount out of etbTotal, so it's excluded here to avoid double-subtracting.
+    if (usedClientSubtotal && discountMinor > 0) {
+      const discountDisplayMinor = displayCurrency !== Currency.ETB
+        ? await this.currencyService.convertAmount(discountMinor, Currency.ETB, displayCurrency)
+        : discountMinor;
+      displayTotalMinor = Math.max(0, displayTotalMinor - discountDisplayMinor);
+    }
+
     resolvedTotalMinor = displayCurrency !== Currency.ETB
       ? await this.currencyService.convertAmount(displayTotalMinor, displayCurrency, Currency.ETB)
       : displayTotalMinor;
@@ -834,17 +851,16 @@ export class GuestBookingService {
     const allRTFaresProvided = rtSeatedPassengers.length > 0 &&
       rtSeatedPassengers.every(p => p.seatFareMinor != null && p.returnSeatFareMinor != null);
 
+    // True when the total came from a client-summed subtotal (per-seat sum or reviewedTotalMinor),
+    // which the portal computes UNDISCOUNTED — the promo must still be applied to it (H-13).
+    let usedClientSubtotal = false;
+
     if (allRTFaresProvided && !isPackageRoundTrip) {
       // Server-computed sum is authoritative — prevents race-condition under-count.
       displayTotalMinor = passengersWithFares.reduce((sum, p) => sum + p.outboundFareMinor + p.returnFareMinor, 0);
-      totalMinor = displayCurrency !== Currency.ETB
-        ? await this.currencyService.convertAmount(displayTotalMinor, displayCurrency, Currency.ETB)
-        : displayTotalMinor;
+      usedClientSubtotal = true;
     } else if (isPackageRoundTrip && dto.reviewedTotalMinor != null) {
       displayTotalMinor = dto.reviewedTotalMinor;
-      totalMinor = displayCurrency !== Currency.ETB
-        ? await this.currencyService.convertAmount(displayTotalMinor, displayCurrency, Currency.ETB)
-        : displayTotalMinor;
       const seatedCount = passengersData.filter(p => p.seatId).length;
       if (seatedCount > 0) {
         const perSeatPerLeg = Math.round(dto.reviewedTotalMinor / (seatedCount * 2));
@@ -855,11 +871,24 @@ export class GuestBookingService {
       }
     } else if (dto.reviewedTotalMinor != null && dto.reviewedTotalMinor > 0) {
       displayTotalMinor = dto.reviewedTotalMinor;
-      totalMinor = displayCurrency !== Currency.ETB
-        ? await this.currencyService.convertAmount(displayTotalMinor, displayCurrency, Currency.ETB)
-        : displayTotalMinor;
+      usedClientSubtotal = true;
     }
 
+    // H-13: the portal sums UNDISCOUNTED per-passenger fares into a client subtotal, silently
+    // dropping the promo the fare engine recognized. Apply the authoritative discount now so the
+    // customer is charged the discounted price. The no-override case above already starts from a
+    // discounted displayTotalMinor, so it's excluded here to avoid double-subtracting.
+    if (usedClientSubtotal && discountMinor > 0) {
+      const discountDisplayMinor = displayCurrency !== Currency.ETB
+        ? await this.currencyService.convertAmount(discountMinor, Currency.ETB, displayCurrency)
+        : discountMinor;
+      displayTotalMinor = Math.max(0, displayTotalMinor - discountDisplayMinor);
+    }
+
+    totalMinor = displayCurrency !== Currency.ETB
+      ? await this.currencyService.convertAmount(displayTotalMinor, displayCurrency, Currency.ETB)
+      : displayTotalMinor;
+
     // C-1 guard: never charge less than the server-recomputed authoritative round-trip fare.
     this.assertTotalNotUnderAuthoritative(totalMinor, authoritativeTotalMinor, 'createGuestRoundTripBooking');
 
diff --git a/apps/edr-passenger-api/src/modules/live/live.module.ts b/apps/edr-passenger-api/src/modules/live/live.module.ts
index 268ba2385..aa46c7d57 100644
--- a/apps/edr-passenger-api/src/modules/live/live.module.ts
+++ b/apps/edr-passenger-api/src/modules/live/live.module.ts
@@ -2,5 +2,5 @@ import { Module } from '@nestjs/common';
 import { LiveController } from './live.controller';
 import { LiveService } from './live.service';
 
-@Module({ controllers: [LiveController], providers: [LiveService] })
+@Module({ controllers: [LiveController], providers: [LiveService], exports: [LiveService] })
 export class LiveModule {}
diff --git a/apps/edr-passenger-api/src/modules/notifications/notifications.service.ts b/apps/edr-passenger-api/src/modules/notifications/notifications.service.ts
index 12f549e9f..9ef922bb3 100644
--- a/apps/edr-passenger-api/src/modules/notifications/notifications.service.ts
+++ b/apps/edr-passenger-api/src/modules/notifications/notifications.service.ts
@@ -312,6 +312,18 @@ export class NotificationsService {
     const ref = booking?.bookingRef ?? payload.booking.bookingRef;
     const passengerId = booking?.passengerId ?? payload.booking.passengerId;
 
+    // A backoffice-issued reservation already sends its own purpose-built message —
+    // GuestBookingService.issueBookingFromReservation texts /reserve/pay/<payToken> for a
+    // PASSENGER-kind booking (the traveler has no portal session, so this generic template's
+    // /booking/detail?ref= link doesn't work), and for STAFF kind the booking is finalized
+    // immediately after this event fires, so onPaymentSucceeded's "ticket ready" message is
+    // the correct one to send, not a redundant/contradictory "awaiting payment" notice.
+    const source = (booking as any)?.source ?? payload.booking?.source;
+    if (source === 'BACKOFFICE_RESERVATION') {
+      this.logger.log(`Skipping generic booking.created notification for ${ref} — reservation flow sends its own`);
+      return;
+    }
+
     const template = await this.prisma.notificationTemplate.findUnique({
       where: { code: 'booking.created' },
     });
diff --git a/apps/edr-passenger-api/src/modules/payments/payments.controller.ts b/apps/edr-passenger-api/src/modules/payments/payments.controller.ts
index 88510f1a5..7da37df33 100644
--- a/apps/edr-passenger-api/src/modules/payments/payments.controller.ts
+++ b/apps/edr-passenger-api/src/modules/payments/payments.controller.ts
@@ -415,8 +415,18 @@ export class PaymentsController {
   paySupplementaryCharge(
     @Param('token') token: string,
     @Body() dto: PaySupplementaryChargeDto,
+    @Headers('origin') origin?: string,
+    @Headers('referer') referer?: string,
+    @Headers('x-frontend-base-url') frontendBaseUrl?: string,
   ) {
-    return this.supplementaryService.pay(token, dto.method, dto.platform);
+    // Same domain-follows-the-user rule as /initiate — the self-pay page can be
+    // opened on either portal domain.
+    return this.supplementaryService.pay(
+      token,
+      dto.method,
+      dto.platform,
+      resolveAllowedOrigin(origin, referer, frontendBaseUrl),
+    );
   }
 
   @Post('supplementary/:id/mark-paid')
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 a0f516628..8f3aabbab 100644
--- a/apps/edr-passenger-api/src/modules/payments/payments.service.ts
+++ b/apps/edr-passenger-api/src/modules/payments/payments.service.ts
@@ -48,12 +48,14 @@ const NON_TERMINAL_STATUSES: PaymentIntentStatus[] = [
 ];
 
 // Methods whose return/failure URLs are browser-facing pages on the passenger
-// portal, so they should follow whichever domain the user came in on. DMONEY is
-// deliberately excluded — its return URL is a server-to-server webhook host, not
-// a page the browser lands on.
+// portal, so they should follow whichever domain the user came in on. For DMONEY
+// this is the preOrder `redirect_url` (the page the browser lands on after
+// checkout) — NOT `notify_url`, which is the server-to-server webhook and is
+// configured provider-side, never rebased.
 const DOMAIN_AWARE_METHODS = new Set<PaymentMethodType>([
   PaymentMethodType.TELEBIRR,
   PaymentMethodType.WAAFI,
+  PaymentMethodType.DMONEY,
 ]);
 
 @Injectable()
@@ -279,22 +281,35 @@ export class PaymentsService {
         return this.formatIntentResponse(intent);
       }
 
+      // A web↔mobile switch needs a different clientAction (Telebirr: REDIRECT for web
+      // vs LAUNCH_APP for the native app). Detect the open session's platform from its
+      // clientAction shape so a platform change is NOT blocked below: it must flow
+      // through to re-initiate, where the payment service retires the stale session and
+      // opens a fresh one with the correct launch method for the requested platform.
+      const requestedMobile = (dto.platform ?? "web") === "mobile";
+      const storedAction = (snapshot?.clientAction ??
+        existingIntent.clientAction) as unknown as ClientAction | null;
+      const platformChanged =
+        (storedAction?.type === "LAUNCH_APP") !== requestedMobile;
+
       // Still pending at the provider (REQUIRES_ACTION/PROCESSING) — or the payment
       // service was unreachable and the local status is non-terminal. Block the switch:
       // return the existing intent so the payer completes or waits out the open attempt
-      // rather than opening a second concurrent charge.
+      // rather than opening a second concurrent charge. A platform switch is exempt — it
+      // falls through so a session with the correct clientAction is opened for it.
       if (
-        !snapshot ||
-        snapshot.status === ProviderPaymentStatus.REQUIRES_ACTION ||
-        snapshot.status === ProviderPaymentStatus.PROCESSING
+        !platformChanged &&
+        (!snapshot ||
+          snapshot.status === ProviderPaymentStatus.REQUIRES_ACTION ||
+          snapshot.status === ProviderPaymentStatus.PROCESSING)
       ) {
         const intent = snapshot
           ? await this.syncIntentProjection(booking.id, snapshot)
           : existingIntent;
         return this.formatIntentResponse(intent);
       }
-      // Otherwise the provider reports FAILED/CANCELLED — fall through and initiate
-      // the newly selected method below.
+      // Otherwise the provider reports FAILED/CANCELLED, or the payer switched platform —
+      // fall through and initiate the newly selected method below.
     }
 
     const { returnUrl, failureUrl } = this.resolveReturnUrls(
diff --git a/apps/edr-passenger-api/src/modules/payments/supplementary-charges.service.ts b/apps/edr-passenger-api/src/modules/payments/supplementary-charges.service.ts
index 9b62d433c..f8c316d87 100644
--- a/apps/edr-passenger-api/src/modules/payments/supplementary-charges.service.ts
+++ b/apps/edr-passenger-api/src/modules/payments/supplementary-charges.service.ts
@@ -116,11 +116,21 @@ export class SupplementaryChargesService {
     return updated;
   }
 
-  async pay(token: string, method: string, platform?: 'web' | 'mobile') {
+  async pay(
+    token: string,
+    method: string,
+    platform?: 'web' | 'mobile',
+    requestOrigin?: string | null,
+  ) {
     const charge = await this.getByToken(token); // validates status/expiry
 
     const paymentMethod = method as ProviderMethod;
-    const portalUrl = process.env.PORTAL_URL ?? 'http://localhost:5174';
+    // Self-pay links are opened on whichever portal domain the recipient used
+    // (bookingedr.et vs passenger.edrsc.com), so the return pages must live on
+    // that same domain. `requestOrigin` is already allowlist-validated by the
+    // controller; PORTAL_URL is the fallback for non-browser callers.
+    const portalUrl =
+      requestOrigin ?? process.env.PORTAL_URL ?? 'http://localhost:5174';
     const returnUrl = `${portalUrl}/pay-balance/${token}/success`;
     const failureUrl = `${portalUrl}/pay-balance/${token}/failed`;
 
diff --git a/apps/edr-passenger-api/src/modules/schedules/schedules.controller.ts b/apps/edr-passenger-api/src/modules/schedules/schedules.controller.ts
index 8cee1e94f..3f6228bf3 100644
--- a/apps/edr-passenger-api/src/modules/schedules/schedules.controller.ts
+++ b/apps/edr-passenger-api/src/modules/schedules/schedules.controller.ts
@@ -2,7 +2,7 @@ import { Body, Controller, Delete, Get, Param, Patch, Post, Put, Query, ParseInt
 import { ApiTags, ApiOperation, ApiBearerAuth, ApiParam, ApiQuery, ApiResponse } from '@nestjs/swagger';
 import { IsPublic } from '@tria-plc/api-common/modules/auth/decorators/public.decorator';
 import { SchedulesService } from './schedules.service';
-import { CreateScheduleDto, UpdateScheduleDto, CreateFareRuleDto, UpdateScheduleStatusDto, UpdateStopTimeDto, ListSchedulesDto, BulkCreateSchedulesDto, BulkSchedulesResponseDto, TripStatus } from './schedules.dto';
+import { CreateScheduleDto, UpdateScheduleDto, CreateFareRuleDto, UpdateScheduleStatusDto, UpdateStopTimeDto, ListSchedulesDto, BulkCreateSchedulesDto, BulkSchedulesResponseDto, TripStatus, ApplyDelayDto } from './schedules.dto';
 import { PassengerAdmin, PassengerStaff } from '../../common/passenger-guards';
 import { PASSENGER_PERMS } from '../../seed/passenger-permissions.registry';
 
@@ -177,6 +177,22 @@ export class SchedulesController {
     @Body() dto: UpdateStopTimeDto,
   ) { return this.service.updateStop(id, sequence, dto); }
 
+  @Post(':id/delay')
+  @PassengerStaff([PASSENGER_PERMS.schedules.manage, PASSENGER_PERMS.admin]) @ApiBearerAuth('IAM-auth')
+  @ApiOperation({
+    summary: 'Report a delay — pushes every downstream stop\'s planned times (and check-in cutoffs) back by the same amount',
+    description: `Shifts plannedArrivalAt/plannedDepartureAt on every stop not yet BOARDED/COMPLETED (or from fromSequence
+onward, if given) by delayMinutes. Since check-in cutoffs are derived directly from these planned
+times, this is the only action needed for booking closure to reflect the delay — no separate cutoff
+update. Also shifts the schedule's own departureAt/arrivalAt when the origin stop is included, and
+records the accumulated delay on the schedule's live status. Does not change schedule/stop status.`,
+  })
+  @ApiParam({ name: 'id', description: 'TrainSchedule UUID' })
+  @ApiResponse({ status: 200, description: 'Schedule with shifted stop times' })
+  applyDelay(@Param('id') id: string, @Body() dto: ApplyDelayDto) {
+    return this.service.applyDelay(id, dto);
+  }
+
   @Put(':scheduleId/fares/:seatClassId')
   @PassengerStaff([PASSENGER_PERMS.schedules.manage, PASSENGER_PERMS.admin]) @ApiBearerAuth('IAM-auth')
   @ApiOperation({
diff --git a/apps/edr-passenger-api/src/modules/schedules/schedules.dto.ts b/apps/edr-passenger-api/src/modules/schedules/schedules.dto.ts
index 49dec1d96..333eb7d26 100644
--- a/apps/edr-passenger-api/src/modules/schedules/schedules.dto.ts
+++ b/apps/edr-passenger-api/src/modules/schedules/schedules.dto.ts
@@ -113,6 +113,14 @@ export class UpdateScheduleStatusDto {
   @ApiProperty({ enum: TripStatus, example: TripStatus.EN_ROUTE }) @IsEnum(TripStatus) status: TripStatus;
 }
 
+export class ApplyDelayDto {
+  @ApiProperty({ example: 60, description: 'Minutes to shift downstream stop times by. Negative to correct an over-reported delay.' })
+  @IsInt() delayMinutes: number;
+
+  @ApiPropertyOptional({ example: 3, description: 'Only shift stops from this sequence onward. Omit to default to every stop not yet BOARDED/COMPLETED.' })
+  @IsOptional() @IsInt() @Min(1) fromSequence?: number;
+}
+
 export class BulkCreateSchedulesDto {
   @ApiProperty({ example: 'train-uuid', description: 'Train UUID' }) @IsString() trainId: string;
   @ApiProperty({ example: 'route-uuid', description: 'Route UUID' }) @IsString() routeId: string;
diff --git a/apps/edr-passenger-api/src/modules/schedules/schedules.module.ts b/apps/edr-passenger-api/src/modules/schedules/schedules.module.ts
index 18d88d631..e01dc616b 100644
--- a/apps/edr-passenger-api/src/modules/schedules/schedules.module.ts
+++ b/apps/edr-passenger-api/src/modules/schedules/schedules.module.ts
@@ -5,9 +5,10 @@ import { RoutesController } from './routes.controller';
 import { RoutesService } from './routes.service';
 import { FareEngineModule } from '../fare-engine/fare-engine.module';
 import { AuditModule } from '../../common/audit.module';
+import { LiveModule } from '../live/live.module';
 
 @Module({
-  imports: [FareEngineModule, AuditModule],
+  imports: [FareEngineModule, AuditModule, LiveModule],
   controllers: [RoutesController, SchedulesController],
   providers: [RoutesService, SchedulesService],
   exports: [RoutesService, SchedulesService],
diff --git a/apps/edr-passenger-api/src/modules/schedules/schedules.service.ts b/apps/edr-passenger-api/src/modules/schedules/schedules.service.ts
index d6dfda6ec..7680d8f9c 100644
--- a/apps/edr-passenger-api/src/modules/schedules/schedules.service.ts
+++ b/apps/edr-passenger-api/src/modules/schedules/schedules.service.ts
@@ -2,10 +2,11 @@ import { Injectable, Logger, NotFoundException, BadRequestException } from '@nes
 import { PrismaService } from '../../common/prisma.service';
 import { RoutesService } from './routes.service';
 import { FareEngineService } from '../fare-engine/fare-engine.service';
-import { CreateScheduleDto, UpdateScheduleDto, CreateFareRuleDto, UpdateScheduleStatusDto, UpdateStopTimeDto, ListSchedulesDto, BulkCreateSchedulesDto } from './schedules.dto';
+import { CreateScheduleDto, UpdateScheduleDto, CreateFareRuleDto, UpdateScheduleStatusDto, UpdateStopTimeDto, ListSchedulesDto, BulkCreateSchedulesDto, ApplyDelayDto } from './schedules.dto';
 import { DeleteOperationException } from '../../common/exceptions/delete-operation.exception';
 import { parseEthiopianTime, startOfDayEAT, startOfNextDayEAT } from '../../common/utils/timezone.utils';
 import { AuditService } from '../../common/audit.service';
+import { LiveService } from '../live/live.service';
 import { computePlannedStopTimes } from '../../common/utils/schedule-times.utils';
 
 @Injectable()
@@ -17,8 +18,47 @@ export class SchedulesService {
     private routesService: RoutesService,
     private fareEngine: FareEngineService,
     private auditService: AuditService,
+    private liveService: LiveService,
   ) { }
 
+  /**
+   * Computes each stop's planned arrival/departure time by walking the route in sequence
+   * order and accumulating `RouteStop.travelMinutesToStop` (minutes of travel from the
+   * previous stop). Falls back to distance-proportional interpolation over `distanceKm` for
+   * any stop missing `travelMinutesToStop`. The last stop is always locked to the confirmed
+   * overall `arr` regardless of the accumulated cursor, so schedule.arrivalAt stays
+   * authoritative even if per-stop estimates drift.
+   */
+  private computePlannedTimes(
+    route: { id: string; stops: { sequence: number; distanceKm: number | null; travelMinutesToStop: number | null }[] },
+    dep: Date,
+    arr: Date,
+  ) {
+    const totalDuration = arr.getTime() - dep.getTime();
+    const totalDistance = route.stops[route.stops.length - 1].distanceKm || 0;
+
+    let cursor = dep;
+    return route.stops.map((stop, index) => {
+      if (index === 0) {
+        cursor = dep;
+      } else if (index === route.stops.length - 1) {
+        cursor = arr;
+      } else if (stop.travelMinutesToStop != null) {
+        cursor = new Date(cursor.getTime() + stop.travelMinutesToStop * 60_000);
+      } else {
+        const stopDistance = stop.distanceKm || 0;
+        const progress = totalDistance > 0 ? stopDistance / totalDistance : index / (route.stops.length - 1);
+        cursor = new Date(dep.getTime() + totalDuration * progress);
+        this.logger.warn(`Route ${route.id} stop seq ${stop.sequence} missing travelMinutesToStop; falling back to distance interpolation`);
+      }
+      return {
+        sequence: stop.sequence,
+        plannedArrivalAt: index === 0 ? undefined : cursor.toISOString(),
+        plannedDepartureAt: index === route.stops.length - 1 ? undefined : cursor.toISOString(),
+      };
+    });
+  }
+
   async bulkGenerateSchedules(dto: BulkCreateSchedulesDto) {
     const startDate = parseEthiopianTime(dto.startDateTime);
     const endDate = new Date(startDate.getTime() + dto.forNextDays * 24 * 60 * 60 * 1000);
@@ -89,6 +129,7 @@ export class SchedulesService {
           include: { coach: true },
           orderBy: { positionNumber: 'asc' },
         },
+        liveStatus: { select: { delayMinutes: true } },
         _count: { select: { coachAssignments: true, bookings: true } },
       },
       orderBy: { departureAt: 'asc' },
@@ -132,7 +173,7 @@ export class SchedulesService {
 
     let plannedTimes = dto.plannedTimes;
     if (!plannedTimes || plannedTimes.length === 0) {
-      plannedTimes = computePlannedStopTimes(route, dep, arr);
+      plannedTimes = this.computePlannedTimes(route, dep, arr);
     }
 
     const providedSeqs = new Set((plannedTimes ?? []).map(t => t.sequence));
@@ -209,6 +250,7 @@ export class SchedulesService {
           orderBy: { positionNumber: 'asc' },
         },
         stopTimes: { include: { station: true }, orderBy: { sequence: 'asc' } },
+        liveStatus: { select: { delayMinutes: true } },
       },
     });
     if (!schedule) throw new NotFoundException('Schedule not found');
@@ -303,7 +345,7 @@ export class SchedulesService {
 
     let plannedTimes = dto.plannedTimes;
     if (!plannedTimes || plannedTimes.length === 0) {
-      plannedTimes = computePlannedStopTimes(route, dep, arr);
+      plannedTimes = this.computePlannedTimes(route, dep, arr);
     }
 
     const plannedTimesMap = Object.fromEntries(plannedTimes.map(t => [t.sequence, t]));
@@ -425,6 +467,70 @@ export class SchedulesService {
     });
   }
 
+  /**
+   * Shifts stored planned times additively rather than reusing updateSchedulePartial's
+   * recompute-from-route-interpolation path — that path also guards `departureAt must be in the
+   * future`, which a delay report for an already-departed/EN_ROUTE train would legitimately
+   * fail. Check-in cutoffs (resolveCheckinCutoff, SeatsService.holdSeats) are both derived
+   * directly from TripStopTime.plannedArrivalAt/plannedDepartureAt at read time, so shifting the
+   * stored values here is the entire fix — neither of those needs to change.
+   */
+  async applyDelay(scheduleId: string, dto: ApplyDelayDto) {
+    const schedule = await this.prisma.trainSchedule.findUnique({ where: { id: scheduleId } });
+    if (!schedule) throw new NotFoundException('Schedule not found');
+
+    const stopWhere: any = { scheduleId };
+    if (dto.fromSequence != null) {
+      stopWhere.sequence = { gte: dto.fromSequence };
+    } else {
+      // Default: only stops the train hasn't reached yet — a delay report must not retroactively
+      // move a stop that's already BOARDED/COMPLETED.
+      stopWhere.status = { notIn: ['BOARDED', 'COMPLETED'] };
+    }
+
+    const stopsToShift = await this.prisma.tripStopTime.findMany({ where: stopWhere });
+    const shiftMs = dto.delayMinutes * 60_000;
+    const includesOrigin = stopsToShift.some((s) => s.sequence === 1);
+
+    await this.prisma.$transaction(async (tx) => {
+      for (const stop of stopsToShift) {
+        await tx.tripStopTime.update({
+          where: { id: stop.id },
+          data: {
+            plannedArrivalAt: stop.plannedArrivalAt ? new Date(stop.plannedArrivalAt.getTime() + shiftMs) : undefined,
+            plannedDepartureAt: stop.plannedDepartureAt ? new Date(stop.plannedDepartureAt.getTime() + shiftMs) : undefined,
+          },
+        });
+      }
+
+      // Origin stop shifted → the schedule's own departureAt/arrivalAt drive search's day-window
+      // queries and the displayed departure time, so they must move too (both together, so
+      // durationMinutes stays correct).
+      if (includesOrigin) {
+        await tx.trainSchedule.update({
+          where: { id: scheduleId },
+          data: {
+            departureAt: new Date(schedule.departureAt.getTime() + shiftMs),
+            arrivalAt: new Date(schedule.arrivalAt.getTime() + shiftMs),
+          },
+        });
+      }
+    });
+
+    const currentLive = await this.prisma.tripLiveStatus.findUnique({ where: { scheduleId } });
+    const accumulatedDelayMinutes = Math.max(0, (currentLive?.delayMinutes ?? 0) + dto.delayMinutes);
+    await this.liveService.updateLiveStatus(scheduleId, { delayMinutes: accumulatedDelayMinutes });
+
+    await this.auditService.log({
+      action: 'UPDATE',
+      entityType: 'Schedule',
+      entityId: scheduleId,
+      newData: { delayMinutes: dto.delayMinutes, fromSequence: dto.fromSequence, accumulatedDelayMinutes },
+    });
+
+    return this.getSchedule(scheduleId);
+  }
+
   async upsertScheduleFare(
     scheduleId: string,
     seatClassId: string,
@@ -681,7 +787,7 @@ export class SchedulesService {
         include: { stops: { orderBy: { sequence: 'asc' } } },
       });
       if (route && route.stops.length >= 2) {
-        const plannedTimes = computePlannedStopTimes(route, dep, arr);
+        const plannedTimes = this.computePlannedTimes(route, dep, arr);
         const plannedTimesMap = Object.fromEntries(plannedTimes.map(t => [t.sequence, t]));
         await this.routesService.applyRouteToSchedule(schedule.routeId, id, plannedTimesMap);
       }
diff --git a/apps/edr-passenger-api/src/modules/search/search.controller.ts b/apps/edr-passenger-api/src/modules/search/search.controller.ts
index 384592dc9..92aff000a 100644
--- a/apps/edr-passenger-api/src/modules/search/search.controller.ts
+++ b/apps/edr-passenger-api/src/modules/search/search.controller.ts
@@ -2,7 +2,7 @@ import { Body, Controller, Post, Get, Query } from '@nestjs/common';
 import { ApiTags, ApiOperation, ApiResponse, ApiQuery } from '@nestjs/swagger';
 import { IsPublic } from '@tria-plc/api-common/modules/auth/decorators/public.decorator';
 import { SearchService } from './search.service';
-import { SearchTripsDto, FareQuoteDto, FareBreakdownRequestDto } from './search.dto';
+import { SearchTripsDto, FareQuoteDto, FareBreakdownRequestDto, AvailableDatesQueryDto } from './search.dto';
 
 @ApiTags('Search')
 @Controller('search')
@@ -67,6 +67,21 @@ Nationality-Based:
     return this.service.getFareQuote(dto);
   }
 
+  @Get('available-dates')
+  @ApiOperation({
+    summary: 'Which dates in a range have a bookable schedule for an origin/destination pair',
+    description: `Used to disable schedule-less dates on the search date picker before the user submits a search.
+
+For each date in the (server-clamped, max 90-day) range, a date is "available" if at least one
+schedule exists for the origin→destination pair whose status/package/coach state is bookable and
+whose check-in cutoff has not yet passed. This does not check seat-level availability — a date
+can be marked available and still turn out fully booked when actually searched.`,
+  })
+  @ApiResponse({ status: 200, description: 'routeExists flag plus a per-date availability list' })
+  getAvailableDates(@Query() dto: AvailableDatesQueryDto) {
+    return this.service.getAvailableDates(dto);
+  }
+
   @Get('fare-breakdown')
   @ApiOperation({
     summary: 'Per-passenger fare breakdown for booking review page',
diff --git a/apps/edr-passenger-api/src/modules/search/search.dto.ts b/apps/edr-passenger-api/src/modules/search/search.dto.ts
index cfb1075ca..1c99ce418 100644
--- a/apps/edr-passenger-api/src/modules/search/search.dto.ts
+++ b/apps/edr-passenger-api/src/modules/search/search.dto.ts
@@ -29,6 +29,20 @@ export class SearchTripsDto {
   @IsOptional() @IsDateString() returnDate?: string;
 }
 
+export class AvailableDatesQueryDto {
+  @ApiProperty({ example: 'station-uuid', description: 'Origin station UUID' })
+  @IsString() originStationId: string;
+
+  @ApiProperty({ example: 'station-uuid', description: 'Destination station UUID' })
+  @IsString() destinationStationId: string;
+
+  @ApiProperty({ example: '2026-06-15', description: 'Start of the date range (YYYY-MM-DD)' })
+  @IsDateString() from: string;
+
+  @ApiProperty({ example: '2026-09-13', description: 'End of the date range (YYYY-MM-DD), inclusive — server clamps to a max 90-day span' })
+  @IsDateString() to: string;
+}
+
 export class FareQuoteDto {
   @ApiProperty({ example: 'schedule-uuid', description: 'TrainSchedule UUID from search results' })
   @IsString() scheduleId: string;
diff --git a/apps/edr-passenger-api/src/modules/search/search.service.ts b/apps/edr-passenger-api/src/modules/search/search.service.ts
index 9c368a976..8820619d8 100644
--- a/apps/edr-passenger-api/src/modules/search/search.service.ts
+++ b/apps/edr-passenger-api/src/modules/search/search.service.ts
@@ -5,6 +5,7 @@ import {
   FareQuoteDto,
   FareBreakdownRequestDto,
   FareBreakdownPassengerDto,
+  AvailableDatesQueryDto,
 } from "./search.dto";
 import { CurrencyService } from "../currency/currency.service";
 import { FareEngineService } from "../fare-engine/fare-engine.service";
@@ -223,13 +224,10 @@ export class SearchService {
     childCount?: number,
     nationality?: string,
   ) {
-    const [y, m, d] = dateStr.split("-").map(Number);
-    const requestedDate = new Date(
-      `${String(y)}-${String(m).padStart(2, "0")}-${String(d).padStart(2, "0")}T00:00:00+03:00`,
-    );
-    const requestedNextDay = new Date(
-      `${String(y)}-${String(m).padStart(2, "0")}-${String(d + 1).padStart(2, "0")}T00:00:00+03:00`,
-    );
+    // Real millisecond arithmetic, not string-padded day-of-month increment — the latter
+    // produces an invalid date (e.g. "2026-07-32") for any search on the last day of a month.
+    const requestedDate = new Date(`${dateStr}T00:00:00+03:00`);
+    const requestedNextDay = new Date(requestedDate.getTime() + 24 * 60 * 60 * 1000);
     const now = new Date();
     const totalPassengers = adultCount + (childCount ?? 0);
     const NEEDED = 3;
@@ -313,13 +311,10 @@ export class SearchService {
     childCount?: number,
     nationality?: string,
   ) {
-    const [y, m, d] = dateStr.split("-").map(Number);
-    const date = new Date(
-      `${String(y)}-${String(m).padStart(2, "0")}-${String(d).padStart(2, "0")}T00:00:00+03:00`,
-    );
-    const nextDay = new Date(
-      `${String(y)}-${String(m).padStart(2, "0")}-${String(d + 1).padStart(2, "0")}T00:00:00+03:00`,
-    );
+    // Real millisecond arithmetic, not string-padded day-of-month increment — the latter
+    // produces an invalid date (e.g. "2026-07-32") for any search on the last day of a month.
+    const date = new Date(`${dateStr}T00:00:00+03:00`);
+    const nextDay = new Date(date.getTime() + 24 * 60 * 60 * 1000);
     const totalPassengers = adultCount + (childCount ?? 0);
 
     // Match on the schedule's own departure DATE only — do NOT use `now` as a lower bound here.
@@ -383,26 +378,16 @@ export class SearchService {
 
     // 1. Does any active route connect these two stations, in this direction, at all —
     // ignoring date entirely?
-    const candidateRoutes = await this.prisma.route.findMany({
-      where: { active: true, stops: { some: { stationId: originStationId } } },
-      select: { stops: { select: { stationId: true, sequence: true } } },
-    });
-    const routeExists = candidateRoutes.some((r) => {
-      const o = r.stops.find((s) => s.stationId === originStationId);
-      const d = r.stops.find((s) => s.stationId === destinationStationId);
-      return !!o && !!d && o.sequence < d.sequence;
-    });
-    if (!routeExists) return withCode(Passenger.SearchEmptyReasonCode.NoRoute);
+    if (!(await this.routeExistsForPair(originStationId, destinationStationId))) {
+      return withCode(Passenger.SearchEmptyReasonCode.NoRoute);
+    }
 
     // 2. A route exists — is there any schedule at all on the requested date for this pair
     // (regardless of status/package/coach/cutoff — those are checked next)?
-    const [y, m, d] = dateStr.split("-").map(Number);
-    const date = new Date(
-      `${String(y)}-${String(m).padStart(2, "0")}-${String(d).padStart(2, "0")}T00:00:00+03:00`,
-    );
-    const nextDay = new Date(
-      `${String(y)}-${String(m).padStart(2, "0")}-${String(d + 1).padStart(2, "0")}T00:00:00+03:00`,
-    );
+    // Real millisecond arithmetic, not string-padded day-of-month increment — the latter
+    // produces an invalid date (e.g. "2026-07-32") for any search on the last day of a month.
+    const date = new Date(`${dateStr}T00:00:00+03:00`);
+    const nextDay = new Date(date.getTime() + 24 * 60 * 60 * 1000);
     const dayCandidates = await this.prisma.trainSchedule.findMany({
       where: { departureAt: { gte: date, lt: nextDay }, stopTimes: { some: { stationId: originStationId } } },
       select: {
@@ -425,12 +410,7 @@ export class SearchService {
 
     // 3. Schedules exist that date — narrow to ones that would otherwise be bookable
     // (right status, not package-only, has at least one coach assigned).
-    const bookable = sameDayForPair.filter(
-      (s) =>
-        (["SCHEDULED", "BOARDING", "EN_ROUTE"] as string[]).includes(s.status) &&
-        !s.isPackageOnly &&
-        s.coachAssignments.length > 0,
-    );
+    const bookable = sameDayForPair.filter((s) => this.isBookableSchedule(s));
     if (bookable.length === 0) {
       if (sameDayForPair.every((s) => s.status === "CANCELLED"))
         return withCode(Passenger.SearchEmptyReasonCode.Cancelled);
@@ -452,6 +432,110 @@ export class SearchService {
     return withCode(Passenger.SearchEmptyReasonCode.FullyBooked);
   }
 
+  /**
+   * Whether any active route connects originStationId → destinationStationId in this
+   * direction, ignoring date/schedule state entirely. Shared by classifyEmptySearch and
+   * getAvailableDates.
+   */
+  private async routeExistsForPair(originStationId: string, destinationStationId: string): Promise<boolean> {
+    const candidateRoutes = await this.prisma.route.findMany({
+      where: { active: true, stops: { some: { stationId: originStationId } } },
+      select: { stops: { select: { stationId: true, sequence: true } } },
+    });
+    return candidateRoutes.some((r) => {
+      const o = r.stops.find((s) => s.stationId === originStationId);
+      const d = r.stops.find((s) => s.stationId === destinationStationId);
+      return !!o && !!d && o.sequence < d.sequence;
+    });
+  }
+
+  /** Status/package/coach bookability only — ignores date, cutoff, and seat-level availability. */
+  private isBookableSchedule(s: { status: string; isPackageOnly: boolean; coachAssignments: { id: string }[] }): boolean {
+    return (
+      (["SCHEDULED", "BOARDING", "EN_ROUTE"] as string[]).includes(s.status) &&
+      !s.isPackageOnly &&
+      s.coachAssignments.length > 0
+    );
+  }
+
+  private readonly MAX_AVAILABLE_DATES_SPAN_DAYS = 90;
+  private readonly ADDIS_OFFSET_MS = 3 * 60 * 60 * 1000;
+  private readonly ONE_DAY_MS = 24 * 60 * 60 * 1000;
+
+  /** Converts an absolute instant to its calendar date string in Africa/Addis_Ababa (fixed UTC+3, no DST). */
+  private toAddisDateStr(d: Date): string {
+    return new Date(d.getTime() + this.ADDIS_OFFSET_MS).toISOString().slice(0, 10);
+  }
+
+  /**
+   * For each date in the (server-clamped) range, whether at least one bookable schedule exists
+   * for originStationId → destinationStationId — used to disable schedule-less dates on the
+   * search date picker before the user submits a search. Reuses the same route-existence and
+   * bookability checks as classifyEmptySearch, plus the same check-in cutoff resolution used
+   * throughout this service, but does not compute seat-level availability (see buildScheduleResult)
+   * — a date can be marked available and still turn out fully booked when actually searched.
+   */
+  async getAvailableDates(dto: AvailableDatesQueryDto) {
+    const { originStationId, destinationStationId } = dto;
+
+    const todayStr = this.toAddisDateStr(new Date());
+    const from = dto.from > todayStr ? dto.from : todayStr;
+    const fromDate = new Date(`${from}T00:00:00+03:00`);
+
+    const maxToDate = new Date(fromDate.getTime() + this.MAX_AVAILABLE_DATES_SPAN_DAYS * this.ONE_DAY_MS);
+    const requestedToDate = new Date(`${dto.to}T00:00:00+03:00`);
+    const toDate = requestedToDate < maxToDate ? requestedToDate : maxToDate;
+    const to = this.toAddisDateStr(toDate);
+
+    if (!(await this.routeExistsForPair(originStationId, destinationStationId))) {
+      return {
+        originStationId,
+        destinationStationId,
+        from,
+        to,
+        routeExists: false,
+        dates: [] as { date: string; available: boolean }[],
+      };
+    }
+
+    const rangeEnd = new Date(toDate.getTime() + this.ONE_DAY_MS);
+    const schedules = await this.prisma.trainSchedule.findMany({
+      where: {
+        departureAt: { gte: fromDate, lt: rangeEnd },
+        stopTimes: { some: { stationId: originStationId } },
+      },
+      select: {
+        departureAt: true,
+        status: true,
+        isPackageOnly: true,
+        route: {
+          select: { checkinMinutesBefore: true, stops: { select: { stationId: true, checkinMinutesBefore: true } } },
+        },
+        stopTimes: { select: { stationId: true, sequence: true, plannedArrivalAt: true, plannedDepartureAt: true } },
+        coachAssignments: { select: { id: true } },
+      },
+    });
+
+    const now = Date.now();
+    const availableDays = new Set<string>();
+    for (const s of schedules) {
+      const originStop = s.stopTimes.find((st) => st.stationId === originStationId);
+      const destinationStop = s.stopTimes.find((st) => st.stationId === destinationStationId);
+      if (!originStop || !destinationStop || originStop.sequence >= destinationStop.sequence) continue;
+      if (!this.isBookableSchedule(s)) continue;
+      if (now >= resolveCheckinCutoff(s, originStop, originStationId).cutoffAt.getTime()) continue;
+      availableDays.add(this.toAddisDateStr(s.departureAt));
+    }
+
+    const dates: { date: string; available: boolean }[] = [];
+    for (let cursor = fromDate; cursor <= toDate; cursor = new Date(cursor.getTime() + this.ONE_DAY_MS)) {
+      const dateStr = this.toAddisDateStr(cursor);
+      dates.push({ date: dateStr, available: availableDays.has(dateStr) });
+    }
+
+    return { originStationId, destinationStationId, from, to, routeExists: true, dates };
+  }
+
   // ── Transit search ─────────────────────────────────────────────────────────
   private readonly MIN_CONNECTION_MINUTES = 30;
   private readonly MAX_CONNECTION_MINUTES = 360;
@@ -464,13 +548,10 @@ export class SearchService {
     childCount?: number,
     nationality?: string,
   ) {
-    const [y, m, d] = dateStr.split("-").map(Number);
-    const dayStart = new Date(
-      `${String(y)}-${String(m).padStart(2, "0")}-${String(d).padStart(2, "0")}T00:00:00+03:00`,
-    );
-    const dayEnd = new Date(
-      `${String(y)}-${String(m).padStart(2, "0")}-${String(d + 1).padStart(2, "0")}T00:00:00+03:00`,
-    );
+    // Real millisecond arithmetic, not string-padded day-of-month increment — the latter
+    // produces an invalid date (e.g. "2026-07-32") for any search on the last day of a month.
+    const dayStart = new Date(`${dateStr}T00:00:00+03:00`);
+    const dayEnd = new Date(dayStart.getTime() + 24 * 60 * 60 * 1000);
     const leg2WindowEnd = new Date(
       dayEnd.getTime() + this.MAX_CONNECTION_MINUTES * 60_000,
     );
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 79773a712..77e13740a 100644
--- a/apps/edr-passenger-api/src/modules/seats/seats.service.ts
+++ b/apps/edr-passenger-api/src/modules/seats/seats.service.ts
@@ -45,13 +45,16 @@ export class SeatsService {
     });
 
     const allSeatIds = assignments.flatMap((a: any) => a.coach.seats.map((s: any) => s.id));
-    const effectiveStatuses = await this.resolveEffectiveStatuses(
-      scheduleId, 
-      allSeatIds, 
-      originStationId ?? schedule.originStationId, 
-      destinationStationId ?? schedule.destinationStationId,
-      journeyDirection
-    );
+    const [effectiveStatuses, reservations] = await Promise.all([
+      this.resolveEffectiveStatuses(
+        scheduleId,
+        allSeatIds,
+        originStationId ?? schedule.originStationId,
+        destinationStationId ?? schedule.destinationStationId,
+        journeyDirection
+      ),
+      this.resolveActiveReservations(allSeatIds, scheduleId),
+    ]);
 
     return {
       coaches: assignments.map((a) => {
@@ -70,6 +73,7 @@ export class SeatsService {
             ? this.resolveBedPosition(s.col, s.bedPosition)
             : s.bedPosition;
           const effectiveStatus = effectiveStatuses.get(s.id) ?? (s.status === 'BLOCKED' || s.status === 'BOOKED' ? s.status : 'AVAILABLE');
+          const reservation = reservations.get(s.id);
           return {
             id:          s.id,
             seatNumber:  s.seatNumber,
@@ -88,6 +92,15 @@ export class SeatsService {
               position: this.colToPosition(s.col, a.coach.arrangement),
               bed_type: this.bedPositionToType(resolvedBedPosition),
             } : {}),
+            // Backoffice-issued reservation covering this seat, if any — lets staff see who's
+            // paying/ticketed for a HELD (awaiting payment) or BLOCKED (ticketed) seat without
+            // leaving the seat map. See resolveActiveReservations.
+            ...(reservation ? {
+              bookingRef:              reservation.bookingRef,
+              reservationStatus:       reservation.status,
+              reservationPassengerName: reservation.passengerName,
+              reservationContactPhone: reservation.contactPhone,
+            } : {}),
           };
         });
 
@@ -259,6 +272,46 @@ export class SeatsService {
     return statusMap;
   }
 
+  /**
+   * Batch-resolves the backoffice-issued reservation (if any) covering each of these seats on
+   * this schedule — a booking created via GuestBookingService.issueBookingFromReservation
+   * (`source: 'BACKOFFICE_RESERVATION'`), still PENDING_PAYMENT (payment link sent, not yet
+   * paid) or already CONFIRMED (ticketed). Used to surface the booking reference on the
+   * backoffice seat map so staff can see who's paying/ticketed for a given seat without
+   * looking it up separately.
+   */
+  private async resolveActiveReservations(
+    seatIds: string[],
+    scheduleId: string,
+  ): Promise<Map<string, { bookingRef: string; status: string; passengerName: string | null; contactPhone: string | null }>> {
+    const map = new Map<string, { bookingRef: string; status: string; passengerName: string | null; contactPhone: string | null }>();
+    if (seatIds.length === 0) return map;
+
+    const bookingSeats = await this.prisma.bookingSeat.findMany({
+      where: {
+        seatId: { in: seatIds },
+        scheduleId,
+        booking: { source: 'BACKOFFICE_RESERVATION', status: { in: ['PENDING_PAYMENT', 'CONFIRMED'] } },
+      },
+      select: {
+        seatId: true,
+        passengerName: true,
+        booking: { select: { bookingRef: true, status: true, contactPhone: true } },
+      },
+    });
+
+    for (const bs of bookingSeats) {
+      if (!bs.seatId) continue;
+      map.set(bs.seatId, {
+        bookingRef: bs.booking.bookingRef,
+        status: bs.booking.status,
+        passengerName: bs.passengerName,
+        contactPhone: bs.booking.contactPhone,
+      });
+    }
+    return map;
+  }
+
   async holdSeats(dto: HoldSeatsDto) {
     const passengerIds = dto.passengers.map(p => p.passengerId);
     const seatIds      = dto.passengers.map(p => p.seatId);
@@ -295,10 +348,9 @@ export class SeatsService {
 
     // Stop-level override wins; falls back to route-level; then to 30 min.
     const checkinMinutes = originRouteStop?.checkinMinutesBefore ?? schedule.route?.checkinMinutesBefore ?? 30;
-    // Departure basis: plannedDepartureAt = arrival + dwell. For the origin there is no
-    // arrival so plannedDepartureAt = schedule.departureAt. cutoffAt = departure - dwell = arrival,
-    // so holding closes the moment the train reaches the boarding stop.
-    const segmentDepartureAt = originStopTime?.plannedDepartureAt ?? originStopTime?.plannedArrivalAt ?? schedule.departureAt;
+    // Arrival basis: the origin stop's own estimated arrival, not its departure. The first
+    // stop of a route has no arrival (nothing to arrive at), so it falls back to its departure.
+    const segmentDepartureAt = originStopTime?.plannedArrivalAt ?? originStopTime?.plannedDepartureAt ?? schedule.departureAt;
     const msUntilDeparture = segmentDepartureAt.getTime() - Date.now();
     if (msUntilDeparture <= checkinMinutes * 60 * 1000) {
       throw new BadRequestException(
diff --git a/apps/edr-passenger-api/test/reserve-seat-issue-booking.e2e-spec.ts b/apps/edr-passenger-api/test/reserve-seat-issue-booking.e2e-spec.ts
index 75f822289..5d63d7a06 100644
--- a/apps/edr-passenger-api/test/reserve-seat-issue-booking.e2e-spec.ts
+++ b/apps/edr-passenger-api/test/reserve-seat-issue-booking.e2e-spec.ts
@@ -26,6 +26,7 @@ import { validateSync } from "class-validator";
 import { plainToInstance } from "class-transformer";
 import { SchedulesService } from "../src/modules/schedules/schedules.service";
 import { SeatsService } from "../src/modules/seats/seats.service";
+import { SegmentsService } from "../src/modules/segments/segments.service";
 import { TicketsService } from "../src/modules/tickets/tickets.service";
 import { PaymentsService } from "../src/modules/payments/payments.service";
 import { CurrencyService } from "../src/modules/currency/currency.service";
@@ -34,6 +35,7 @@ import { SystemConfigService } from "../src/modules/system-config/system-config.
 import { BookingsService } from "../src/modules/bookings/bookings.service";
 import { GuestBookingService } from "../src/modules/bookings/guest-booking.service";
 import { ReservationBookingKind, IssueReservationBookingDto } from "../src/modules/bookings/guest-booking.dto";
+import { NotificationsService } from "../src/modules/notifications/notifications.service";
 import { createServiceHarness, ServiceHarness } from "./setup/slim-app";
 import { IDS, resetAndSeedCore } from "./fixtures/seed-core";
 
@@ -48,7 +50,9 @@ describe("Reserve seat — issue booking (STAFF / PASSENGER)", () => {
   let seatsService: SeatsService;
   let guestBookingService: GuestBookingService;
   let bookingsService: BookingsService;
+  let notificationsService: NotificationsService;
   let smsClient: { sendSms: jest.Mock };
+  let emailClient: { sendEmail: jest.Mock };
 
   beforeAll(async () => {
     harness = await createServiceHarness();
@@ -57,7 +61,11 @@ describe("Reserve seat — issue booking (STAFF / PASSENGER)", () => {
     const fareEngine = harness.moduleRef.get(FareEngineService);
     const systemConfig = new SystemConfigService(harness.prisma as any);
 
-    seatsService = new SeatsService(harness.prisma as any, asyncStub(), systemConfig, asyncStub(), asyncStub());
+    // Real SegmentsService (not asyncStub) — the getSeatMap test below exercises
+    // resolveEffectiveStatuses, which calls segmentsService.getSeatAvailabilityMap and needs
+    // an actual Map back, not asyncStub's `async () => undefined`.
+    const segmentsService = new SegmentsService(harness.prisma as any);
+    seatsService = new SeatsService(harness.prisma as any, segmentsService, systemConfig, asyncStub(), asyncStub());
     const ticketsService = new TicketsService(harness.prisma as any, asyncStub(), systemConfig, asyncStub(), asyncStub());
     const paymentsService = new PaymentsService(
       harness.prisma as any,
@@ -85,12 +93,26 @@ describe("Reserve seat — issue booking (STAFF / PASSENGER)", () => {
       harness.prisma as any,
       asyncStub(), // dataSource
       seatsService,
-      { emit: () => true } as any,
+      ticketsService,
+      { emit: () => true } as any, // eventEmitter
       asyncStub(), // verifaydaService
       currencyService,
       fareEngine,
       asyncStub(), // auditService
     );
+
+    emailClient = { sendEmail: jest.fn().mockResolvedValue({ queued: true }) };
+    // Same smsClient instance guestBookingService uses — lets the notification-suppression
+    // test assert on ONE shared call count across both services, proving the reservation
+    // flow's own SMS is the only message sent for a BACKOFFICE_RESERVATION booking.
+    notificationsService = new NotificationsService(
+      harness.prisma as any,
+      asyncStub(), // dataSource (TypeORM) — only reached for non-UUID recipients / IAM lookups,
+                   // never hit by these guest-passenger-id-keyed test bookings
+      emailClient as any,
+      smsClient as any,
+      asyncStub(), // pushAdapter
+    );
   });
 
   afterAll(async () => {
@@ -99,6 +121,7 @@ describe("Reserve seat — issue booking (STAFF / PASSENGER)", () => {
 
   beforeEach(() => {
     smsClient.sendSms.mockClear();
+    emailClient.sendEmail.mockClear();
   });
 
   /** Creates a fresh Train + TrainSchedule on the seed-core route, coach assigned at creation. */
@@ -294,6 +317,53 @@ describe("Reserve seat — issue booking (STAFF / PASSENGER)", () => {
     expect(byToken.schedule.origin.id).toBe(IDS.stationA);
   });
 
+  it("NotificationsService.onBookingCreated skips its own message for a BACKOFFICE_RESERVATION booking (issueBookingFromReservation already sent one), but still fires for a normal booking", async () => {
+    // Regression for: the customer got TWO conflicting messages for one reservation —
+    // the reservation-specific /reserve/pay/<payToken> SMS from issueBookingFromReservation,
+    // AND a second, generic booking.created notification pointing at /booking/detail?ref=,
+    // a page that doesn't work for a traveler with no portal session.
+    await resetAndSeedCore(harness.prisma);
+    await harness.prisma.notificationTemplate.upsert({
+      where: { code: "booking.created" },
+      update: { active: true },
+      create: { code: "booking.created", channel: "SMS,EMAIL", bodyTemplate: "Booking {{bookingRef}} created. Pay: {{payLink}}", active: true },
+    });
+    const dep = new Date(Date.now() + 3 * 60 * 60_000);
+    const arr = new Date(dep.getTime() + 100 * 60_000);
+    const { schedule, seats } = await createTestSchedule({ trainNumber: `RES-NOTIFY-${Date.now()}`, departureAt: dep, arrivalAt: arr });
+
+    await seatsService.blockSeat(seats[0].id, "Reserved pending payment", schedule.id);
+    const result: any = await guestBookingService.issueBookingFromReservation(
+      seats[0].id,
+      baseDto({ scheduleId: schedule.id, bookingKind: ReservationBookingKind.PASSENGER, phone: "+253771234567" }) as any,
+      "staff-user-5",
+    );
+    expect(smsClient.sendSms).toHaveBeenCalledTimes(1); // the reservation flow's own SMS
+
+    // Directly invoke the event handler (the test harness's eventEmitter is a stub, so the
+    // real 'booking.created' emit from issueBookingFromReservation never reaches it) — this
+    // is what NotificationsService would have done had it received that event.
+    await notificationsService.onBookingCreated({ booking: { id: result.booking.id, bookingRef: result.booking.bookingRef } });
+    expect(smsClient.sendSms).toHaveBeenCalledTimes(1); // still 1 — onBookingCreated no-oped
+    expect(emailClient.sendEmail).not.toHaveBeenCalled();
+
+    // Control: a normal (non-reservation) booking must still get the generic notification.
+    const passenger = await harness.prisma.passenger.create({ data: {} });
+    const normalBooking = await harness.prisma.booking.create({
+      data: {
+        bookingRef: `WEB-CTRL-${Date.now()}`,
+        passengerId: passenger.id,
+        scheduleId: schedule.id,
+        status: "PENDING_PAYMENT",
+        totalMinor: 10_000,
+        contactPhone: "+251911234567",
+        source: "WEB",
+      },
+    });
+    await notificationsService.onBookingCreated({ booking: { id: normalBooking.id, bookingRef: normalBooking.bookingRef } });
+    expect(smsClient.sendSms).toHaveBeenCalledTimes(2); // suppression didn't leak to non-reservation bookings
+  });
+
   it("PASSENGER path: the seat stays reserved (not publicly available) after the payment link is sent", async () => {
     // Regression for: unblockSeat() released the reservation's SeatBlock and confirmSeats()
     // was a no-op with no SeatHold to extend, so the seat had no SeatBlock, no SeatHold, and
@@ -325,6 +395,87 @@ describe("Reserve seat — issue booking (STAFF / PASSENGER)", () => {
     ).rejects.toThrow(/already (held|booked)/i);
   });
 
+  it("cancelReservationForSeat: cancels the pending booking, frees the seat, and kills the old pay link", async () => {
+    await resetAndSeedCore(harness.prisma);
+    const dep = new Date(Date.now() + 3 * 60 * 60_000);
+    const arr = new Date(dep.getTime() + 100 * 60_000);
+    const { schedule, seats } = await createTestSchedule({ trainNumber: `RES-CANCEL-${Date.now()}`, departureAt: dep, arrivalAt: arr });
+
+    await seatsService.blockSeat(seats[0].id, "Reserved pending payment", schedule.id);
+    const result: any = await guestBookingService.issueBookingFromReservation(
+      seats[0].id,
+      baseDto({ scheduleId: schedule.id, bookingKind: ReservationBookingKind.PASSENGER, phone: "+253771234567" }) as any,
+      "staff-user-7",
+    );
+    const payToken = result.booking.payToken;
+
+    const cancelResult: any = await bookingsService.cancelReservationForSeat(seats[0].id, schedule.id, "staff-user-7");
+    expect(cancelResult.cancelled).toBe(true);
+    expect(cancelResult.bookingRef).toBe(result.booking.bookingRef);
+
+    const cancelledBooking = await harness.prisma.booking.findUnique({ where: { id: result.booking.id } });
+    expect(cancelledBooking?.status).toBe("CANCELLED");
+
+    // The seat is genuinely free — a member of the public can now hold it.
+    await expect(
+      seatsService.holdSeats({
+        scheduleId: schedule.id,
+        originStationId: IDS.stationA,
+        destinationStationId: IDS.stationB,
+        passengers: [{ passengerId: "someone-else", seatId: seats[0].id }],
+      } as any),
+    ).resolves.toBeTruthy();
+
+    // The old payment link no longer works.
+    await expect(bookingsService.getByPayToken(payToken)).rejects.toThrow(/no longer awaiting payment/i);
+  });
+
+  it("cancelReservationForSeat 404s when there's no pending reservation for this seat", async () => {
+    await resetAndSeedCore(harness.prisma);
+    const dep = new Date(Date.now() + 3 * 60 * 60_000);
+    const arr = new Date(dep.getTime() + 100 * 60_000);
+    const { schedule, seats } = await createTestSchedule({ trainNumber: `RES-CANCEL-404-${Date.now()}`, departureAt: dep, arrivalAt: arr });
+
+    await expect(
+      bookingsService.cancelReservationForSeat(seats[0].id, schedule.id, "staff-user-8"),
+    ).rejects.toThrow(/no pending reservation/i);
+  });
+
+  it("getSeatMap surfaces the bookingRef (PNR) for a seat with an active reservation — pending payment AND ticketed", async () => {
+    await resetAndSeedCore(harness.prisma);
+    const dep = new Date(Date.now() + 3 * 60 * 60_000);
+    const arr = new Date(dep.getTime() + 100 * 60_000);
+    const { schedule, seats } = await createTestSchedule({ trainNumber: `RES-SEATMAP-${Date.now()}`, departureAt: dep, arrivalAt: arr });
+
+    // Seat 0: PASSENGER reservation — still PENDING_PAYMENT.
+    await seatsService.blockSeat(seats[0].id, "Reserved pending payment", schedule.id);
+    const pending: any = await guestBookingService.issueBookingFromReservation(
+      seats[0].id,
+      baseDto({ scheduleId: schedule.id, bookingKind: ReservationBookingKind.PASSENGER, phone: "+253771234567" }) as any,
+      "staff-user-6",
+    );
+
+    // Seat 1: STAFF reservation — fee-waived, ticketed, CONFIRMED immediately.
+    await seatsService.blockSeat(seats[1].id, "Reserved for staff issue", schedule.id);
+    const staffResult: any = await guestBookingService.issueBookingFromReservation(
+      seats[1].id,
+      baseDto({ scheduleId: schedule.id, bookingKind: ReservationBookingKind.STAFF }) as any,
+      "staff-user-6",
+    );
+
+    const seatMap: any = await seatsService.getSeatMap(schedule.id);
+    const flatSeats = seatMap.coaches.flatMap((c: any) => c.seats ?? []);
+    const pendingSeat = flatSeats.find((s: any) => s.id === seats[0].id);
+    const ticketedSeat = flatSeats.find((s: any) => s.id === seats[1].id);
+
+    expect(pendingSeat.bookingRef).toBe(pending.booking.bookingRef);
+    expect(pendingSeat.reservationStatus).toBe("PENDING_PAYMENT");
+    expect(pendingSeat.status).toBe("HELD"); // covered by the SeatHold, not a SeatBlock
+
+    expect(ticketedSeat.bookingRef).toBe(staffResult.booking.bookingRef);
+    expect(ticketedSeat.reservationStatus).toBe("CONFIRMED");
+  });
+
   it("requires a phone number for a PASSENGER booking", async () => {
     await resetAndSeedCore(harness.prisma);
     const dep = new Date(Date.now() + 3 * 60 * 60_000);
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 17a31832a..35d0290ea 100644
--- a/apps/edr-passenger-web/backoffice/src/app/schedules/page.tsx
+++ b/apps/edr-passenger-web/backoffice/src/app/schedules/page.tsx
@@ -2,7 +2,7 @@
 
 import { useState, useEffect, useRef } from 'react';
 import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
-import { Plus, Loader2, Zap, Trash2, Edit, Search, X, GripVertical, RefreshCw } from 'lucide-react';
+import { Plus, Loader2, Zap, Trash2, Edit, Search, X, GripVertical, Clock, RefreshCw } from 'lucide-react';
 import DataTable from '@/components/ui/DataTable';
 import ActionButton from '@/components/ui/ActionButton';
 import Modal from '@/components/ui/Modal';
@@ -28,6 +28,7 @@ interface Schedule {
   destinationStation?: { id: string; name: string };
   coachAssignments?: Array<{ coachId: string; positionNumber: number; coach?: { id: string; number: string } }>;
   isPackageOnly?: boolean;
+  liveStatus?: { delayMinutes: number } | null;
 }
 
 interface Train {
@@ -461,6 +462,16 @@ export default function SchedulesPage() {
         <span className="font-mono text-sm">{formatDateTime(schedule.arrivalAt)}</span>
       ),
     },
+    {
+      key: 'liveStatus.delayMinutes',
+      label: 'Delay',
+      sortable: true,
+      render: (schedule: Schedule) => {
+        const delay = schedule.liveStatus?.delayMinutes ?? 0;
+        if (delay <= 0) return <span className="text-sm text-muted-foreground">On time</span>;
+        return <span className="edr-badge edr-badge-warning">+{delay} min</span>;
+      },
+    },
     {
       key: 'coachAssignments',
       label: 'Coaches',
@@ -493,6 +504,15 @@ export default function SchedulesPage() {
 
   const [cancelConfirm, setCancelConfirm] = useState<{ isOpen: boolean; item: Schedule | null }>({ isOpen: false, item: null });
 
+  const applyDelayMutation = useMutation({
+    mutationFn: ({ id, minutes }: { id: string; minutes: number }) =>
+      apiClient.post(`/schedules/${id}/delay`, { delayMinutes: minutes }),
+    onSuccess: () => queryClient.invalidateQueries({ queryKey: ['schedules'] }),
+  });
+  const [delayPrompt, setDelayPrompt] = useState<{ isOpen: boolean; item: Schedule | null }>({ isOpen: false, item: null });
+  const [delayMinutesInput, setDelayMinutesInput] = useState('');
+  const [delayError, setDelayError] = useState<string | null>(null);
+
   const scheduleActions = [
     {
       label: 'Edit',
@@ -500,6 +520,17 @@ export default function SchedulesPage() {
       variant: 'secondary' as const,
       icon: Edit,
     },
+    {
+      label: 'Report Delay',
+      onClick: (schedule: Schedule) => {
+        setDelayMinutesInput('');
+        setDelayError(null);
+        setDelayPrompt({ isOpen: true, item: schedule });
+      },
+      variant: 'secondary' as const,
+      icon: Clock,
+      hidden: (schedule: Schedule) => schedule.status === 'CANCELLED',
+    },
     {
       label: 'Cancel',
       onClick: (schedule: Schedule) => setCancelConfirm({ isOpen: true, item: schedule }),
@@ -660,6 +691,67 @@ export default function SchedulesPage() {
         isLoading={cancelScheduleMutation.isPending}
       />
 
+      <Modal
+        isOpen={delayPrompt.isOpen}
+        onClose={() => setDelayPrompt({ isOpen: false, item: null })}
+        title={`Report Delay${delayPrompt.item ? `: ${delayPrompt.item.originStation?.name ?? ''} → ${delayPrompt.item.destinationStation?.name ?? ''}` : ''}`}
+        size="sm"
+      >
+        {delayPrompt.item && (
+          <form
+            onSubmit={async (e) => {
+              e.preventDefault();
+              const minutes = parseInt(delayMinutesInput, 10);
+              if (Number.isNaN(minutes)) { setDelayError('Enter a whole number of minutes.'); return; }
+              try {
+                await applyDelayMutation.mutateAsync({ id: delayPrompt.item!.id, minutes });
+                setDelayPrompt({ isOpen: false, item: null });
+              } catch (err: any) {
+                setDelayError(err?.response?.data?.message || 'Failed to apply delay.');
+              }
+            }}
+            className="space-y-4"
+          >
+            {delayError && (
+              <div className="bg-red-50 p-3 rounded-lg text-sm text-red-800">{delayError}</div>
+            )}
+            <div className="flex items-center justify-between px-3 py-2 rounded-lg border border-border bg-muted/30">
+              <span className="text-sm text-muted-foreground">Current reported delay</span>
+              {(delayPrompt.item.liveStatus?.delayMinutes ?? 0) > 0 ? (
+                <span className="edr-badge edr-badge-warning">+{delayPrompt.item.liveStatus?.delayMinutes} min</span>
+              ) : (
+                <span className="text-sm font-medium">On time</span>
+              )}
+            </div>
+            <div>
+              <label className="label">Delay (minutes)</label>
+              <input
+                type="number"
+                value={delayMinutesInput}
+                onChange={(e) => setDelayMinutesInput(e.target.value)}
+                placeholder="e.g. 60"
+                className="input"
+                required
+                autoFocus
+              />
+              <p className="text-xs text-muted-foreground mt-1">
+                Adds to the current reported delay above and pushes every downstream station&apos;s
+                check-in cutoff back by this many minutes. Use a negative number to correct an
+                over-reported delay.
+              </p>
+            </div>
+            <div className="flex justify-end gap-2">
+              <ActionButton type="button" variant="secondary" onClick={() => setDelayPrompt({ isOpen: false, item: null })}>
+                Cancel
+              </ActionButton>
+              <ActionButton type="submit" loading={applyDelayMutation.isPending}>
+                Apply Delay
+              </ActionButton>
+            </div>
+          </form>
+        )}
+      </Modal>
+
       <ConfirmDialog
         isOpen={deleteConfirm.isOpen}
         onClose={() => setDeleteConfirm({ isOpen: false, item: null })}
diff --git a/apps/edr-passenger-web/backoffice/src/app/seats/page.tsx b/apps/edr-passenger-web/backoffice/src/app/seats/page.tsx
index 3ce651ac8..f1289d24a 100644
--- a/apps/edr-passenger-web/backoffice/src/app/seats/page.tsx
+++ b/apps/edr-passenger-web/backoffice/src/app/seats/page.tsx
@@ -4,6 +4,8 @@ import { useState } from 'react';
 import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query'
 import { seatsApi, schedulesApi, fleetApi, routeCoachTemplatesApi, bookingsApi } from '@/lib/api';
 import { routesApi } from '@/lib/api/routes';
+import { usePermissionStrict } from '@/lib/use-permission';
+import { PERMS } from '@/lib/permissions';
 import Modal from '@/components/ui/Modal';
 import ActionButton from '@/components/ui/ActionButton'
 import { Armchair, Lock, Unlock, Bed, X, RotateCcw, ChevronDown, Train, Wrench, Ticket as TicketIcon } from 'lucide-react';
@@ -39,9 +41,14 @@ export default function SeatsPage() {
     phone: '',
     email: '',
   });
-  const [issueBookingResult, setIssueBookingResult] = useState<{ payUrl?: string } | null>(null);
+  const [issueBookingResult, setIssueBookingResult] = useState<{ payUrl?: string; bookingRef?: string } | null>(null);
   const queryClient = useQueryClient();
 
+  // Issuing a booking off a reserved seat needs edr_passenger_app:tickets:generate
+  // (POST /bookings/reservations/:seatId/issue is guarded by @PassengerStaffStrict).
+  // Strict: being an admin is not enough, the permission has to be granted.
+  const canIssueBooking = usePermissionStrict(PERMS.tickets.generate);
+
   const { data: schedulesData } = useQuery({
     queryKey: ['schedules'],
     queryFn: () => schedulesApi.getAll(),
@@ -126,13 +133,19 @@ export default function SeatsPage() {
       bookingsApi.issueFromReservation(seatId, data),
     onSuccess: (result: any) => {
       invalidateSeatData();
-      setIssueBookingResult({ payUrl: result?.payUrl });
-      if (!result?.payUrl) {
-        // STAFF booking — nothing further to show the admin, close immediately.
-        setShowIssueBookingModal(false);
-        setSelectedSeat(null);
-        setIssueBookingCoach(null);
-      }
+      // Always show the reference — the PASSENGER path also needs the PNR alongside the
+      // pay link (staff need to know which booking a seat belongs to, whether it's
+      // awaiting payment or already ticketed), so no longer auto-closing for STAFF.
+      setIssueBookingResult({ payUrl: result?.payUrl, bookingRef: result?.booking?.bookingRef });
+    },
+  });
+
+  // Cancels a seat's still-unpaid reservation (payment link sent) and releases the seat —
+  // distinct from unblockMutation, which only handles a plain SeatBlock (no booking involved).
+  const cancelReservationMutation = useMutation({
+    mutationFn: (seatId: string) => bookingsApi.cancelReservation(seatId, selectedSchedule),
+    onSuccess: () => {
+      invalidateSeatData();
     },
   });
 
@@ -222,6 +235,16 @@ export default function SeatsPage() {
     }
   };
 
+  // Distinct from handleUnblock — this seat has no SeatBlock (issuing the reservation already
+  // released it), it's HELD by the SeatHold behind an unpaid booking. Cancelling that booking
+  // invalidates its payment link immediately, so warn staff explicitly about that.
+  const handleCancelReservation = async (seat: any) => {
+    if (!selectedSchedule) return;
+    if (confirm(`Cancel the reservation for seat ${seat.seatNumber} (PNR ${seat.bookingRef})? The payment link already sent to the traveler will stop working.`)) {
+      await cancelReservationMutation.mutateAsync(seat.id);
+    }
+  };
+
   const handleIssueBooking = (seat: any, coach: any) => {
     if (activeTab !== 'schedule' || !selectedSchedule) {
       alert('Select a specific schedule (Schedule tab) to issue a booking for a reserved seat.');
@@ -433,10 +456,12 @@ export default function SeatsPage() {
                       handleBlock={handleBlock}
                       handleRemoveSeat={handleRemoveSeat}
                       handleUnblock={handleUnblock}
+                      handleCancelReservation={handleCancelReservation}
                       handleUndoRemove={handleUndoRemove}
                       handleSetMaintenance={handleSetMaintenance}
                       handleClearMaintenance={handleClearMaintenance}
                       handleIssueBooking={handleIssueBooking}
+                      canIssueBooking={canIssueBooking}
                       hideNumber={true}
                     />
                   ))}
@@ -529,10 +554,12 @@ export default function SeatsPage() {
                       handleBlock={handleBlock}
                       handleRemoveSeat={handleRemoveSeat}
                       handleUnblock={handleUnblock}
+                      handleCancelReservation={handleCancelReservation}
                       handleUndoRemove={handleUndoRemove}
                       handleSetMaintenance={handleSetMaintenance}
                       handleClearMaintenance={handleClearMaintenance}
                       handleIssueBooking={handleIssueBooking}
+                      canIssueBooking={canIssueBooking}
                       hideNumber={true}
                     />
                   ))}
@@ -552,10 +579,12 @@ export default function SeatsPage() {
                         handleBlock={handleBlock}
                         handleRemoveSeat={handleRemoveSeat}
                         handleUnblock={handleUnblock}
+                      handleCancelReservation={handleCancelReservation}
                         handleUndoRemove={handleUndoRemove}
                         handleSetMaintenance={handleSetMaintenance}
                         handleClearMaintenance={handleClearMaintenance}
                       handleIssueBooking={handleIssueBooking}
+                      canIssueBooking={canIssueBooking}
                         hideNumber={true}
                       />
                     ))}
@@ -888,12 +917,25 @@ export default function SeatsPage() {
         title="Issue Booking"
         size="md"
       >
-        {issueBookingResult?.payUrl ? (
+        {issueBookingResult ? (
           <div className="space-y-4">
             <p className="text-sm text-muted-foreground">
-              Booking created. A payment link has been sent via SMS to the traveler.
+              {issueBookingResult.payUrl
+                ? 'Booking created. A payment link has been sent via SMS to the traveler.'
+                : 'Booking confirmed and ticketed.'}
             </p>
-            <div className="input break-all text-xs">{issueBookingResult.payUrl}</div>
+            {issueBookingResult.bookingRef && (
+              <div>
+                <label className="label">Booking Reference (PNR)</label>
+                <div className="input font-mono font-semibold text-sm">{issueBookingResult.bookingRef}</div>
+              </div>
+            )}
+            {issueBookingResult.payUrl && (
+              <div>
+                <label className="label">Payment Link</label>
+                <div className="input break-all text-xs">{issueBookingResult.payUrl}</div>
+              </div>
+            )}
             <div className="flex justify-end">
               <ActionButton
                 onClick={() => {
@@ -1231,10 +1273,12 @@ interface SeatIconProps {
   handleBlock: (seat: any) => void;
   handleRemoveSeat: (seat: any) => void;
   handleUnblock: (seat: any) => void;
+  handleCancelReservation: (seat: any) => void;
   handleUndoRemove: (seat: any) => void;
   handleSetMaintenance: (seat: any) => void;
   handleClearMaintenance: (seat: any) => void;
   handleIssueBooking: (seat: any, coach: any) => void;
+  canIssueBooking?: boolean;
 }
 
 function SeatIcon({
@@ -1248,10 +1292,12 @@ function SeatIcon({
   handleBlock,
   handleRemoveSeat,
   handleUnblock,
+  handleCancelReservation,
   handleUndoRemove,
   handleSetMaintenance,
   handleClearMaintenance,
   handleIssueBooking,
+  canIssueBooking = false,
 }: SeatIconProps) {
   const isRemoved = seat.seatNumber && seat.seatNumber.startsWith('-');
   const seatClassStr = typeof coach?.seatClass === 'string' ? coach.seatClass : (coach?.seatClass?.name || coach?.coachClass || '');
@@ -1285,6 +1331,10 @@ function SeatIcon({
   const color = getSeatColor(status);
   const canBlock = status === 'AVAILABLE';
   const canUnblock = status === 'BLOCKED';
+  // A HELD seat with a bookingRef + PENDING_PAYMENT is a backoffice reservation awaiting
+  // payment (see resolveActiveReservations) — issuing it already released the SeatBlock, so
+  // it's not reachable via canUnblock anymore; this is the seat's own release path.
+  const canCancelReservation = status === 'HELD' && !!seat.bookingRef && seat.reservationStatus === 'PENDING_PAYMENT';
   const canMaintenance = false;
   const canClearMaintenance = status === 'UNDER_MAINTENANCE';
 
@@ -1299,7 +1349,7 @@ function SeatIcon({
       {isBedCoach ? (
         <div
           className={`${width} h-11 rounded flex items-center justify-center cursor-pointer hover:opacity-80 transition-opacity ${color}`}
-          title={`${seat.seatNumber} - ${seat.bedPosition} - ${status}`}
+          title={`${seat.seatNumber} - ${seat.bedPosition} - ${status}${seat.bookingRef ? ` - PNR ${seat.bookingRef} (${seat.reservationStatus})` : ''}`}
           style={!shouldFlipIcon ? { transform: 'scaleY(-1)' } : undefined}
         >
           <Bed className="w-7 h-7 text-white" />
@@ -1307,14 +1357,23 @@ function SeatIcon({
       ) : (
         <div
           className={`w-11 h-11 rounded flex items-center justify-center cursor-pointer hover:opacity-80 transition-opacity ${color}`}
-          title={`${seat.seatNumber} - ${status}`}
+          title={`${seat.seatNumber} - ${status}${seat.bookingRef ? ` - PNR ${seat.bookingRef} (${seat.reservationStatus})` : ''}`}
           style={seat.row % 2 === 0 ? { transform: 'scaleY(-1)' } : undefined}
         >
           <Armchair className="w-7 h-7 text-white" />
         </div>
       )}
 
-      {(canBlock || canUnblock || canMaintenance || canClearMaintenance) && (
+      {seat.bookingRef && (
+        <span
+          className="text-[9px] leading-3 font-semibold text-foreground/80 mt-0.5 max-w-[3.5rem] truncate"
+          title={`PNR ${seat.bookingRef} — ${seat.reservationStatus}${seat.reservationPassengerName ? ` — ${seat.reservationPassengerName}` : ''}`}
+        >
+          {seat.bookingRef}
+        </span>
+      )}
+
+      {(canBlock || canUnblock || canCancelReservation || canMaintenance || canClearMaintenance) && (
         <div className="absolute top-full mt-1 bg-black/80 rounded shadow-lg flex items-center gap-1 p-1 z-20 opacity-0 group-hover:opacity-100 transition-opacity pointer-events-none group-hover:pointer-events-auto">
           {canBlock && (
             <>
@@ -1334,6 +1393,15 @@ function SeatIcon({
               </button>
             </>
           )}
+          {canCancelReservation && (
+            <button
+              onClick={() => handleCancelReservation(seat)}
+              className="p-1 bg-white rounded hover:bg-gray-100 pointer-events-auto"
+              title={`Cancel reservation (PNR ${seat.bookingRef}) — invalidates the payment link`}
+            >
+              <Unlock className="h-3 w-3 text-gray-700" />
+            </button>
+          )}
           {canUnblock && (
             <>
               <button
@@ -1343,13 +1411,15 @@ function SeatIcon({
               >
                 <Unlock className="h-3 w-3 text-gray-700" />
               </button>
-              <button
-                onClick={() => handleIssueBooking(seat, coach)}
-                className="p-1 bg-white rounded hover:bg-gray-100 pointer-events-auto"
-                title="Issue booking"
-              >
-                <TicketIcon className="h-3 w-3 text-gray-700" />
-              </button>
+              {canIssueBooking && (
+                <button
+                  onClick={() => handleIssueBooking(seat, coach)}
+                  className="p-1 bg-white rounded hover:bg-gray-100 pointer-events-auto"
+                  title="Issue booking"
+                >
+                  <TicketIcon className="h-3 w-3 text-gray-700" />
+                </button>
+              )}
             </>
           )}
           {canMaintenance && (
diff --git a/apps/edr-passenger-web/backoffice/src/lib/api/index.ts b/apps/edr-passenger-web/backoffice/src/lib/api/index.ts
index 1cd5fe4c7..f528f9dff 100644
--- a/apps/edr-passenger-web/backoffice/src/lib/api/index.ts
+++ b/apps/edr-passenger-web/backoffice/src/lib/api/index.ts
@@ -52,6 +52,10 @@ export const bookingsApi = {
   // issued immediately) or PASSENGER (payment link texted to the traveler's phone).
   issueFromReservation: (seatId: string, data: any) =>
     apiClient.post<any>(`/bookings/reservations/${seatId}/issue`, data),
+  // Cancels a seat's still-PENDING_PAYMENT reservation (payment link sent, not yet paid) and
+  // releases the seat — the old payment link stops working immediately.
+  cancelReservation: (seatId: string, scheduleId: string) =>
+    apiClient.delete<any>(`/bookings/reservations/${seatId}?scheduleId=${scheduleId}`),
 };
 
 // Passengers API
@@ -141,6 +145,8 @@ export const schedulesApi = {
   update: (id: string, data: any) => apiClient.patch<any>(`/schedules/${id}`, data),
   delete: (id: string) => apiClient.delete(`/schedules/${id}`),
   updateStatus: (id: string, status: string) => apiClient.patch<any>(`/schedules/${id}/status`, { status }),
+  applyDelay: (id: string, delayMinutes: number, fromSequence?: number) =>
+    apiClient.post<any>(`/schedules/${id}/delay`, { delayMinutes, fromSequence }),
   assignCoaches: (scheduleId: string, coaches: Array<{ coachId: string; positionNumber: number }>) =>
     apiClient.post<any>(`/schedules/${scheduleId}/coaches`, { coaches }),
   getAssignedCoaches: (scheduleId: string) => apiClient.get<any>(`/schedules/${scheduleId}/coaches`),
diff --git a/apps/edr-passenger-web/backoffice/src/lib/auth-store.ts b/apps/edr-passenger-web/backoffice/src/lib/auth-store.ts
index 4048e6d0e..05e47039d 100644
--- a/apps/edr-passenger-web/backoffice/src/lib/auth-store.ts
+++ b/apps/edr-passenger-web/backoffice/src/lib/auth-store.ts
@@ -23,6 +23,7 @@ interface AuthState {
   setUser: (user: AdminUser, token: string) => void;
   initialize: () => void;
   hasPermission: (key: string) => boolean;
+  hasPermissionStrict: (key: string) => boolean;
 }
 
 export const useAuthStore = create<AuthState>((set, get) => ({
@@ -123,4 +124,12 @@ export const useAuthStore = create<AuthState>((set, get) => ({
     if (user.isSuperAdmin || user.isOrgAdmin) return true;
     return user.permissions.includes(key);
   },
+
+  // No super-admin / org-admin bypass — mirrors PassengerStaffStrict on the API,
+  // so we don't render actions that would 403.
+  hasPermissionStrict: (key: string) => {
+    const { user } = get();
+    if (!user) return false;
+    return user.permissions.includes(key);
+  },
 }));
diff --git a/apps/edr-passenger-web/backoffice/src/lib/use-permission.ts b/apps/edr-passenger-web/backoffice/src/lib/use-permission.ts
index 0991a360e..d064c78f2 100644
--- a/apps/edr-passenger-web/backoffice/src/lib/use-permission.ts
+++ b/apps/edr-passenger-web/backoffice/src/lib/use-permission.ts
@@ -13,3 +13,15 @@ import { useAuthStore } from './auth-store';
 export function usePermission(key: string): boolean {
   return useAuthStore((s) => s.hasPermission(key));
 }
+
+/**
+ * Same as usePermission but WITHOUT the super-admin / org-admin bypass — the
+ * permission must be explicitly granted. Use it wherever the API endpoint is
+ * guarded with PassengerStaffStrict, so the UI matches what the API allows.
+ *
+ * Usage:
+ *   const canIssue = usePermissionStrict(PERMS.tickets.generate);
+ */
+export function usePermissionStrict(key: string): boolean {
+  return useAuthStore((s) => s.hasPermissionStrict(key));
+}
diff --git a/apps/edr-passenger-web/portal/src/app/booking/detail/page.tsx b/apps/edr-passenger-web/portal/src/app/booking/detail/page.tsx
index 67df46686..d42ab0dc3 100644
--- a/apps/edr-passenger-web/portal/src/app/booking/detail/page.tsx
+++ b/apps/edr-passenger-web/portal/src/app/booking/detail/page.tsx
@@ -4,6 +4,7 @@ import { Suspense } from "react";
 import { useSearchParams, useRouter } from "next/navigation";
 import { useQuery, useMutation } from "@tanstack/react-query";
 import { apiClient } from "@/lib/api-client";
+import { resolvePaymentRedirectUrl } from "@/lib/payment-redirect";
 import { useEffect, useState } from "react";
 import {
   Clock,
@@ -205,11 +206,10 @@ function BookingDetailContent() {
     onSuccess: async (data: any) => {
       setPaymentError(null);
 
-      if (
-        (selectedMethod === "TELEBIRR" || selectedMethod === "WAAFI") &&
-        data?.clientAction?.type === "REDIRECT"
-      ) {
-        window.location.href = data.clientAction.url;
+      // Any provider that hands back a REDIRECT (Telebirr, Waafi, D-Money) —
+      // the action type is the signal, not the method name.
+      if (data?.clientAction?.type === "REDIRECT" && data.clientAction.url) {
+        window.location.href = resolvePaymentRedirectUrl(data.clientAction.url);
         return;
       }
 
diff --git a/apps/edr-passenger-web/portal/src/app/booking/payment/page.tsx b/apps/edr-passenger-web/portal/src/app/booking/payment/page.tsx
index c03397fee..d27a505fa 100644
--- a/apps/edr-passenger-web/portal/src/app/booking/payment/page.tsx
+++ b/apps/edr-passenger-web/portal/src/app/booking/payment/page.tsx
@@ -5,6 +5,7 @@ import { useBookingStore } from "@/lib/booking-store";
 import { usePaymentStore } from "@/lib/payment-store";
 import { useMutation, useQuery } from "@tanstack/react-query";
 import { apiClient } from "@/lib/api-client";
+import { resolvePaymentRedirectUrl } from "@/lib/payment-redirect";
 import { useState, useEffect } from "react";
 import { PaymentMethod } from "@/types";
 import { format } from "date-fns";
@@ -146,7 +147,7 @@ export default function PaymentPage() {
       if ((selectedMethod === 'TELEBIRR' || selectedMethod === 'WAAFI' || selectedMethod === 'DMONEY') && data?.clientAction?.type === 'REDIRECT') {
         setPaymentIntent(data.intentId);
         updateStatus("REQUIRES_ACTION");
-        window.location.href = data.clientAction.url;
+        window.location.href = resolvePaymentRedirectUrl(data.clientAction.url);
         return;
       }
 
diff --git a/apps/edr-passenger-web/portal/src/app/booking/search/page.tsx b/apps/edr-passenger-web/portal/src/app/booking/search/page.tsx
index 371905e11..eab4d182b 100644
--- a/apps/edr-passenger-web/portal/src/app/booking/search/page.tsx
+++ b/apps/edr-passenger-web/portal/src/app/booking/search/page.tsx
@@ -21,9 +21,19 @@ import {
   ChevronLeft,
   Clock,
 } from "lucide-react";
-import { useEffect, useRef, useState, useCallback } from "react";
+import { useEffect, useRef, useState, useCallback, useMemo } from "react";
 import ModernDatePicker from "@/components/ModernDatePicker";
 
+const AVAILABLE_DATES_RANGE_DAYS = 90;
+
+const toDateStr = (date: Date) =>
+  `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, "0")}-${String(date.getDate()).padStart(2, "0")}`;
+
+interface AvailableDatesResponse {
+  routeExists: boolean;
+  dates: { date: string; available: boolean }[];
+}
+
 function useDarkMode() {
   const [dark, setDark] = useState(
     () =>
@@ -610,6 +620,7 @@ export default function SearchPage() {
     handleSubmit,
     watch,
     setValue,
+    setError,
     trigger,
     clearErrors,
     formState: { errors },
@@ -691,6 +702,62 @@ export default function SearchPage() {
   const tripType = watch("tripType");
   const totalPassengers = (adultCount || 1) + (childCount || 0);
 
+  // Which dates have no bookable schedule for the selected From/To — disables them on the
+  // departure date picker before the user submits a doomed search. Only fetched once both
+  // stations are picked; while loading or unselected, no extra dates are disabled (pickers
+  // keep their existing minDate-only behavior).
+  const { data: availableDates } = useQuery<AvailableDatesResponse>({
+    queryKey: ["available-dates", originId, destId],
+    queryFn: async () => {
+      const from = new Date();
+      const to = new Date();
+      to.setDate(to.getDate() + AVAILABLE_DATES_RANGE_DAYS);
+      return (await apiClient.get("/search/available-dates", {
+        params: {
+          originStationId: originId,
+          destinationStationId: destId,
+          from: toDateStr(from),
+          to: toDateStr(to),
+        },
+      })) as AvailableDatesResponse;
+    },
+    enabled: !!originId && !!destId,
+    staleTime: 5 * 60 * 1000,
+  });
+
+  const disabledDates = useMemo(() => {
+    const set = new Set<string>();
+    if (!availableDates?.routeExists) return set;
+    for (const d of availableDates.dates) if (!d.available) set.add(d.date);
+    return set;
+  }, [availableDates]);
+
+  // /search/available-dates only ever reports on a bounded window (server-clamped to 90 days —
+  // see AVAILABLE_DATES_RANGE_DAYS). disabledDates alone can't gray out anything past that
+  // window (it was simply never fetched, not confirmed available), so once a route is picked
+  // the picker's own maxDate has to match the same horizon or unchecked future months render
+  // as pickable again.
+  const maxSearchDate = useMemo(() => {
+    const d = new Date();
+    d.setDate(d.getDate() + AVAILABLE_DATES_RANGE_DAYS);
+    return d;
+  }, []);
+  const departureMaxDate = originId && destId ? maxSearchDate : undefined;
+
+  // If the currently selected departure date becomes unavailable (From/To changed, or the
+  // availability query just resolved), clear it and surface an inline error rather than
+  // letting the user submit a search that's already known to be empty.
+  useEffect(() => {
+    if (departureDate && disabledDates.has(departureDate)) {
+      setValue("departureDate", "");
+      setError("departureDate", {
+        type: "manual",
+        message:
+          "No trains run this route on the selected date — please pick another date.",
+      });
+    }
+  }, [departureDate, disabledDates, setValue, setError]);
+
   const saveRecent = useCallback((id: string) => {
     setRecentStationIds((prev) => {
       const next = [id, ...prev.filter((x) => x !== id)].slice(0, 5);
@@ -1126,6 +1193,8 @@ export default function SearchPage() {
                                   trigger("departureDate");
                                 }}
                                 minDate={new Date()}
+                                maxDate={departureMaxDate}
+                                disabledDates={disabledDates}
                                 placeholder="Departure date"
                                 error={!!errors.departureDate}
                               />
@@ -1316,6 +1385,8 @@ export default function SearchPage() {
                                 trigger("departureDate");
                               }}
                               minDate={new Date()}
+                              maxDate={departureMaxDate}
+                              disabledDates={disabledDates}
                               placeholder="Departure"
                               error={!!errors.departureDate}
                             />
@@ -1470,6 +1541,8 @@ export default function SearchPage() {
                               trigger("returnDate");
                             }}
                             minDate={new Date()}
+                            maxDate={departureMaxDate}
+                            disabledDates={disabledDates}
                             placeholder="Departure date"
                           />
                           {errors.departureDate && (
diff --git a/apps/edr-passenger-web/portal/src/app/go/page.tsx b/apps/edr-passenger-web/portal/src/app/go/page.tsx
index 7d2063022..b8fc8769f 100644
--- a/apps/edr-passenger-web/portal/src/app/go/page.tsx
+++ b/apps/edr-passenger-web/portal/src/app/go/page.tsx
@@ -3,6 +3,8 @@
 import { Suspense, useEffect, useMemo } from "react";
 import { useSearchParams } from "next/navigation";
 
+import { isDMoneyCheckoutUrl } from "@/lib/payment-redirect";
+
 /**
  * /go — payment redirect bounce page for D-Money web checkout.
  *
@@ -22,36 +24,10 @@ import { useSearchParams } from "next/navigation";
  * See scripts/test-go-redirect.mjs.
  */
 
-const ALLOWED_HOSTS = (
-  // Default allows both D-Money environments:
-  //   test/sandbox → pgtest.d-money.dj        (base domain d-money.dj)
-  //   production   → pg.d-moneyservice.dj      (base domain d-moneyservice.dj)
-  process.env.NEXT_PUBLIC_DMONEY_ALLOWED_HOSTS ?? "d-money.dj,d-moneyservice.dj"
-)
-  .split(",")
-  .map((h) => h.trim().toLowerCase())
-  .filter(Boolean);
-
-/** True only for https URLs whose host is (or is a subdomain of) an allowlisted host. */
-function isTrustedDMoneyUrl(raw: string | null): raw is string {
-  if (!raw) return false;
-  let parsed: URL;
-  try {
-    parsed = new URL(raw);
-  } catch {
-    return false;
-  }
-  if (parsed.protocol !== "https:") return false;
-  const host = parsed.hostname.toLowerCase();
-  return ALLOWED_HOSTS.some(
-    (allowed) => host === allowed || host.endsWith(`.${allowed}`),
-  );
-}
-
 function RedirectView() {
   const searchParams = useSearchParams();
   const raw = searchParams.get("url");
-  const target = useMemo(() => (isTrustedDMoneyUrl(raw) ? raw : null), [raw]);
+  const target = useMemo(() => (isDMoneyCheckoutUrl(raw) ? raw : null), [raw]);
 
   useEffect(() => {
     if (!target) return;
diff --git a/apps/edr-passenger-web/portal/src/app/pay-balance/[token]/page.tsx b/apps/edr-passenger-web/portal/src/app/pay-balance/[token]/page.tsx
index 2b2e69549..fb2135cd3 100644
--- a/apps/edr-passenger-web/portal/src/app/pay-balance/[token]/page.tsx
+++ b/apps/edr-passenger-web/portal/src/app/pay-balance/[token]/page.tsx
@@ -4,6 +4,7 @@ import { useState } from "react";
 import { useParams, useRouter } from "next/navigation";
 import { useQuery, useMutation } from "@tanstack/react-query";
 import { apiClient } from "@/lib/api-client";
+import { resolvePaymentRedirectUrl } from "@/lib/payment-redirect";
 import { PaymentMethod } from "@/types";
 import {
   Loader2,
@@ -52,7 +53,7 @@ export default function PayBalancePage() {
       }),
     onSuccess: (data: any) => {
       if (data?.clientAction?.type === "REDIRECT") {
-        window.location.href = data.clientAction.url;
+        window.location.href = resolvePaymentRedirectUrl(data.clientAction.url);
         return;
       }
       // Immediate success (e.g. wallet)
diff --git a/apps/edr-passenger-web/portal/src/app/reserve/pay/[token]/page.tsx b/apps/edr-passenger-web/portal/src/app/reserve/pay/[token]/page.tsx
index 8999ad939..8a8d9aa2e 100644
--- a/apps/edr-passenger-web/portal/src/app/reserve/pay/[token]/page.tsx
+++ b/apps/edr-passenger-web/portal/src/app/reserve/pay/[token]/page.tsx
@@ -4,6 +4,7 @@ import { useState } from "react";
 import { useParams, useRouter } from "next/navigation";
 import { useQuery, useMutation } from "@tanstack/react-query";
 import { apiClient } from "@/lib/api-client";
+import { resolvePaymentRedirectUrl } from "@/lib/payment-redirect";
 import { PaymentMethod } from "@/types";
 import {
   Loader2,
@@ -63,7 +64,7 @@ export default function ReservationPayPage() {
       }),
     onSuccess: (data: any) => {
       if (data?.clientAction?.type === "REDIRECT") {
-        window.location.href = data.clientAction.url;
+        window.location.href = resolvePaymentRedirectUrl(data.clientAction.url);
         return;
       }
       router.push(`/reserve/pay/${token}/success`);
diff --git a/apps/edr-passenger-web/portal/src/components/ModernDatePicker.tsx b/apps/edr-passenger-web/portal/src/components/ModernDatePicker.tsx
index 20923278c..0d81bba3b 100644
--- a/apps/edr-passenger-web/portal/src/components/ModernDatePicker.tsx
+++ b/apps/edr-passenger-web/portal/src/components/ModernDatePicker.tsx
@@ -18,15 +18,26 @@ interface ModernDatePickerProps {
   onChange: (date: Date) => void;
   minDate?: Date;
   maxDate?: Date;
+  // Dates with no bookable schedule for the selected route (YYYY-MM-DD keys) — disabled
+  // alongside the minDate/maxDate range, not just clamping it.
+  disabledDates?: Set<string>;
   placeholder?: string;
   error?: boolean;
 }
 
+const toDateKey = (date: Date) => {
+  const y = date.getFullYear();
+  const m = String(date.getMonth() + 1).padStart(2, '0');
+  const d = String(date.getDate()).padStart(2, '0');
+  return `${y}-${m}-${d}`;
+};
+
 export default function ModernDatePicker({
   value,
   onChange,
   minDate,
   maxDate,
+  disabledDates,
   placeholder = 'Select date',
   error = false,
 }: ModernDatePickerProps) {
@@ -120,7 +131,7 @@ export default function ModernDatePicker({
             const date = new Date(viewYear, viewMonth, day);
             const isSelected = value && date.getDate() === value.getDate() && date.getMonth() === value.getMonth() && date.getFullYear() === value.getFullYear();
             const isToday = date.toDateString() === new Date().toDateString();
-            const isDisabled = (minDate && date < new Date(minDate.getFullYear(), minDate.getMonth(), minDate.getDate())) || (maxDate && date > new Date(maxDate.getFullYear(), maxDate.getMonth(), maxDate.getDate()));
+            const isDisabled = (minDate && date < new Date(minDate.getFullYear(), minDate.getMonth(), minDate.getDate())) || (maxDate && date > new Date(maxDate.getFullYear(), maxDate.getMonth(), maxDate.getDate())) || !!disabledDates?.has(toDateKey(date));
             return (
               <button key={day} type="button" onClick={() => !isDisabled && handleDateSelect(date)} disabled={!!isDisabled}
                 className={`aspect-square flex items-center justify-center text-sm rounded-lg transition-all
@@ -180,6 +191,7 @@ export default function ModernDatePicker({
               const [gY, gM, gD] = [gregDate.getFullYear(), gregDate.getMonth(), gregDate.getDate()];
               if (gY > mY || (gY === mY && gM > mM) || (gY === mY && gM === mM && gD > mD)) isDisabled = true;
             }
+            if (!isDisabled && disabledDates?.has(toDateKey(gregDate))) isDisabled = true;
             return (
               <button key={day} type="button" onClick={() => !isDisabled && handleEthiopianDateSelect(ethDate)} disabled={isDisabled}
                 className={`aspect-square flex items-center justify-center text-sm rounded-lg transition-all
diff --git a/apps/edr-passenger-web/portal/src/components/SearchWidget.tsx b/apps/edr-passenger-web/portal/src/components/SearchWidget.tsx
index eb8a12f86..33fea2bee 100644
--- a/apps/edr-passenger-web/portal/src/components/SearchWidget.tsx
+++ b/apps/edr-passenger-web/portal/src/components/SearchWidget.tsx
@@ -9,9 +9,23 @@ import { apiClient } from '@/lib/api-client';
 import { useBookingStore } from '@/lib/booking-store';
 import { Station } from '@/types';
 import { MapPin, Users, Search, Plus, Minus, ChevronDown, Globe } from 'lucide-react';
-import { useState, useRef, useEffect } from 'react';
+import { useState, useRef, useEffect, useMemo } from 'react';
 import ModernDatePicker from '@/components/ModernDatePicker';
 
+const AVAILABLE_DATES_RANGE_DAYS = 90;
+
+const toDateStr = (date: Date) => {
+  const y = date.getFullYear();
+  const m = String(date.getMonth() + 1).padStart(2, '0');
+  const d = String(date.getDate()).padStart(2, '0');
+  return `${y}-${m}-${d}`;
+};
+
+interface AvailableDatesResponse {
+  routeExists: boolean;
+  dates: { date: string; available: boolean }[];
+}
+
 const searchSchema = z.object({
   tripType: z.enum(['ONE_WAY', 'ROUND_TRIP']),
   originStationId: z.string().min(1, 'Please select a departure station'),
@@ -129,7 +143,7 @@ export function SearchWidget({ fullWidth = false, onSearch }: SearchWidgetProps)
     queryFn: async () => await apiClient.get('/stations') as Station[],
   });
 
-  const { handleSubmit, watch, setValue, clearErrors, formState: { errors } } = useForm<SearchForm>({
+  const { handleSubmit, watch, setValue, clearErrors, setError, formState: { errors } } = useForm<SearchForm>({
     // @ts-ignore
     resolver: zodResolver(searchSchema),
     mode: 'onSubmit',
@@ -147,6 +161,7 @@ export function SearchWidget({ fullWidth = false, onSearch }: SearchWidgetProps)
 
   const originId = watch('originStationId');
   const destinationId = watch('destinationStationId');
+  const departureDate = watch('departureDate');
   const nationality = watch('nationality');
   const adultCount = watch('adultCount');
   const childCount = watch('childCount');
@@ -154,6 +169,62 @@ export function SearchWidget({ fullWidth = false, onSearch }: SearchWidgetProps)
   const stationOptions = (stations ?? []).map((s) => ({ value: s.id, label: s.name }));
   const destinationOptions = stationOptions.map((s) => ({ ...s, disabled: s.value === originId }));
 
+  // Which dates have no bookable schedule for the selected route — disables them on the date
+  // picker before the user submits a doomed search. Only fetched once both stations are picked;
+  // while loading or unselected, no extra dates are disabled (picker keeps today's minDate-only
+  // behavior).
+  const { data: availableDates } = useQuery<AvailableDatesResponse>({
+    queryKey: ['available-dates', originId, destinationId],
+    queryFn: async () => {
+      const from = new Date();
+      const to = new Date();
+      to.setDate(to.getDate() + AVAILABLE_DATES_RANGE_DAYS);
+      return await apiClient.get('/search/available-dates', {
+        params: {
+          originStationId: originId,
+          destinationStationId: destinationId,
+          from: toDateStr(from),
+          to: toDateStr(to),
+        },
+      }) as AvailableDatesResponse;
+    },
+    enabled: !!originId && !!destinationId,
+    staleTime: 5 * 60 * 1000,
+  });
+
+  const disabledDates = useMemo(() => {
+    const set = new Set<string>();
+    if (!availableDates) return set;
+    if (!availableDates.routeExists) return set; // no route → don't blanket-disable every date, the submit-time error already covers this
+    for (const d of availableDates.dates) if (!d.available) set.add(d.date);
+    return set;
+  }, [availableDates]);
+
+  // /search/available-dates only ever reports on a bounded window (server-clamped to 90 days —
+  // see AVAILABLE_DATES_RANGE_DAYS). disabledDates alone can't gray out anything past that
+  // window (it was simply never fetched, not confirmed available), so once a route is picked
+  // the picker's own maxDate has to match the same horizon or unchecked future months render
+  // as pickable again.
+  const maxSearchDate = useMemo(() => {
+    const d = new Date();
+    d.setDate(d.getDate() + AVAILABLE_DATES_RANGE_DAYS);
+    return d;
+  }, []);
+  const departureMaxDate = originId && destinationId ? maxSearchDate : undefined;
+
+  // If the currently selected date becomes unavailable (route changed, or the availability
+  // query just resolved), clear it and surface an inline error rather than letting the user
+  // submit a search that's already known to be empty.
+  useEffect(() => {
+    if (departureDate && disabledDates.has(departureDate)) {
+      setValue('departureDate', '');
+      setError('departureDate', {
+        type: 'manual',
+        message: 'No trains run this route on the selected date — please pick another date.',
+      });
+    }
+  }, [departureDate, disabledDates, setValue, setError]);
+
   const onSubmit = (data: SearchForm) => {
     setSearchCriteria({ ...data });
     const params = new URLSearchParams({
@@ -213,15 +284,14 @@ export function SearchWidget({ fullWidth = false, onSearch }: SearchWidgetProps)
             <div className="space-y-2">
               <label className="block text-sm font-medium text-gray-700 dark:text-gray-300">Date</label>
               <ModernDatePicker
-                value={watch('departureDate') ? new Date(watch('departureDate') + 'T00:00:00') : undefined}
+                value={departureDate ? new Date(departureDate + 'T00:00:00') : undefined}
                 onChange={(date) => {
-                  const y = date.getFullYear();
-                  const m = String(date.getMonth() + 1).padStart(2, '0');
-                  const d = String(date.getDate()).padStart(2, '0');
-                  setValue('departureDate', `${y}-${m}-${d}`);
+                  setValue('departureDate', toDateStr(date));
                   clearErrors('departureDate');
                 }}
                 minDate={new Date()}
+                maxDate={departureMaxDate}
+                disabledDates={disabledDates}
                 placeholder="Select date"
               />
               {errors.departureDate && (
diff --git a/apps/edr-passenger-web/portal/src/lib/payment-redirect.ts b/apps/edr-passenger-web/portal/src/lib/payment-redirect.ts
new file mode 100644
index 000000000..b235401d1
--- /dev/null
+++ b/apps/edr-passenger-web/portal/src/lib/payment-redirect.ts
@@ -0,0 +1,59 @@
+/**
+ * D-Money web checkout only opens when the request carries a whitelisted
+ * `Referer`. The paygate URL therefore must never be opened directly from an
+ * arbitrary page/origin — it has to bounce through `/go?url=<encoded>` on the
+ * portal origin, which navigates from its own document so D-Money sees
+ * `Referer: <portal origin>`.
+ *
+ * Every place that follows a `clientAction.url` from `/payments/initiate` runs
+ * it through `resolvePaymentRedirectUrl()`; non-D-Money providers (Telebirr,
+ * Waafi, card) pass through untouched.
+ */
+
+const ALLOWED_HOSTS = (
+  // Default allows both D-Money environments:
+  //   test/sandbox → pgtest.d-money.dj        (base domain d-money.dj)
+  //   production   → pg.d-moneyservice.dj      (base domain d-moneyservice.dj)
+  process.env.NEXT_PUBLIC_DMONEY_ALLOWED_HOSTS ?? "d-money.dj,d-moneyservice.dj"
+)
+  .split(",")
+  .map((h) => h.trim().toLowerCase())
+  .filter(Boolean);
+
+/**
+ * Origin the `/go` bounce page is served from — must be the exact origin D-Money
+ * whitelists as `Referer`. Deliberately NOT NEXT_PUBLIC_SITE_URL: that one is the
+ * SEO canonical (layout/sitemap/robots) and may legitimately point at another
+ * portal domain (e.g. bookingedr.et), which D-Money would reject. Users on other
+ * domains bounce through here on purpose; `redirect_url` still returns them to
+ * the domain they started on.
+ */
+const BOUNCE_ORIGIN = (
+  process.env.NEXT_PUBLIC_DMONEY_BOUNCE_ORIGIN ?? "https://passenger.edrsc.com"
+).replace(/\/+$/, "");
+
+/** True only for https URLs whose host is (or is a subdomain of) an allowlisted D-Money host. */
+export function isDMoneyCheckoutUrl(raw: string | null | undefined): raw is string {
+  if (!raw) return false;
+  let parsed: URL;
+  try {
+    parsed = new URL(raw);
+  } catch {
+    return false;
+  }
+  if (parsed.protocol !== "https:") return false;
+  const host = parsed.hostname.toLowerCase();
+  return ALLOWED_HOSTS.some(
+    (allowed) => host === allowed || host.endsWith(`.${allowed}`),
+  );
+}
+
+/**
+ * Wraps a D-Money checkout URL in the `/go` bounce page; returns any other
+ * provider URL unchanged. The URL is percent-encoded — without it the query
+ * parser truncates the D-Money URL at its first `&` and merch_code/sign are lost.
+ */
+export function resolvePaymentRedirectUrl(url: string): string {
+  if (!isDMoneyCheckoutUrl(url)) return url;
+  return `${BOUNCE_ORIGIN}/go?url=${encodeURIComponent(url)}`;
+}
diff --git a/e2e-ui-report/index.html b/e2e-ui-report/index.html
index 8428f4890..297afe29b 100644
--- a/e2e-ui-report/index.html
+++ b/e2e-ui-report/index.html
@@ -87,4 +87,4 @@ Error generating stack: `+l.message+`
     <div id='root'></div>
   </body>
 </html>
-<template id="playwrightReportBase64">data:application/zip;base64,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</template>
\ No newline at end of file
+<template id="playwrightReportBase64">data:application/zip;base64,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</template>
\ No newline at end of file
diff --git a/e2e/freight/cypress/e2e/api/health-and-auth.cy.ts b/e2e/freight/cypress/e2e/api/health-and-auth.cy.ts
index c183a11df..462ab8a73 100644
--- a/e2e/freight/cypress/e2e/api/health-and-auth.cy.ts
+++ b/e2e/freight/cypress/e2e/api/health-and-auth.cy.ts
@@ -15,6 +15,7 @@ describe("freight-api: health + auth contract", () => {
       method: "POST",
       url: `${api()}/api/auth/login`,
       body: { email: "nobody@edr.local", password: "wrong-password" },
+      headers: { "x-client-app": "backoffice" },
       failOnStatusCode: false,
     })
       .its("status")
@@ -50,8 +51,8 @@ describe("freight-api: health + auth contract", () => {
 
   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"));
+    cy.apiLogin("user@gmail.com", Cypress.env("demoPassword"), "portal");
+    cy.apiLogin("user2@gmail.com", Cypress.env("demoPassword"), "portal");
   });
 });
 
diff --git a/e2e/freight/cypress/e2e/flows/cross-app.cy.ts b/e2e/freight/cypress/e2e/flows/cross-app.cy.ts
index fe60170ba..225fbe11c 100644
--- a/e2e/freight/cypress/e2e/flows/cross-app.cy.ts
+++ b/e2e/freight/cypress/e2e/flows/cross-app.cy.ts
@@ -42,7 +42,7 @@ describe("flow: customer and staff see the same world", () => {
         .its("status")
         .should("eq", 200);
     });
-    cy.apiLogin("user@gmail.com", Cypress.env("demoPassword")).then(({ token }) => {
+    cy.apiLogin("user@gmail.com", Cypress.env("demoPassword"), "portal").then(({ token }) => {
       cy.request({
         url: `${api()}/api/me`,
         headers: { Authorization: `Bearer ${token}` },
diff --git a/e2e/freight/cypress/e2e/flows/import-utils.ts b/e2e/freight/cypress/e2e/flows/import-utils.ts
index 0ab5af12a..9f9b53688 100644
--- a/e2e/freight/cypress/e2e/flows/import-utils.ts
+++ b/e2e/freight/cypress/e2e/flows/import-utils.ts
@@ -45,9 +45,11 @@ export function db<T = Row>(sql: string, params: unknown[] = []) {
 
 /** Bearer token for a staff/customer account (portal users use the demo pwd). */
 export function tokenFor(email: string): Cypress.Chainable<string> {
-  const pass =
-    email.endsWith("@gmail.com") ? (Cypress.env("demoPassword") as string) : undefined;
-  return cy.apiLogin(email, pass).then(({ token }) => cy.wrap(token, { log: false }));
+  const isPortalUser = email.endsWith("@gmail.com");
+  const pass = isPortalUser ? (Cypress.env("demoPassword") as string) : undefined;
+  return cy
+    .apiLogin(email, pass, isPortalUser ? "portal" : "backoffice")
+    .then(({ token }) => cy.wrap(token, { log: false }));
 }
 
 export function apiPost(
diff --git a/e2e/freight/cypress/fixtures/seed-users.sql b/e2e/freight/cypress/fixtures/seed-users.sql
index 6f68040c0..6c097ddcc 100644
--- a/e2e/freight/cypress/fixtures/seed-users.sql
+++ b/e2e/freight/cypress/fixtures/seed-users.sql
@@ -55,26 +55,29 @@ where not exists (
 );
 
 -- ── Users ────────────────────────────────────────────────────────────────────
+-- user_type matters now: EDRFREIGHT-415's /auth/login audience gate rejects an
+-- employee-typed account on the portal client and vice versa, so the two demo
+-- "customer" accounts must actually be typed 'individual', not 'employee'.
 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'
+       'accepted', true, true, v.user_type
 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'),
+  ('linestaff@edr.local', 'linestaff', 'linestaff', 'employee'),
+  ('chief@edr.local',     'chief',     'chief',     'employee'),
+  ('director@edr.local',  'director',  'director',  'employee'),
+  ('ceo@edr.local',       'ceo',       'ceo',       'employee'),
+  ('marketer@edr.local',  'marketer',  'marketer',  'employee'),
+  ('operation@edr.local', 'operation', 'operation', 'employee'),
+  ('gl-et@edr.local',     'gl_et',     'gl_et',     'employee'),
+  ('gl-dj@edr.local',     'gl_dj',     'gl_dj',     'employee'),
+  ('user@gmail.com',      'user',      'Demo User 1', 'individual'),
+  ('user2@gmail.com',     'user2',     'Demo User 2', 'individual'),
   -- Full-authority operator the corridor specs drive the customs/GL steps with
   -- (t1-close, risk, gate pass, second duty, import release). Nothing in the
   -- repo seeded it before — the suite silently relied on a hand-made row that
   -- only existed in a long-lived dev database, so a fresh stack failed 7 specs.
-  ('superadmin@tria.com', 'superadmin', 'Super Admin')
-) v(email, username, display)
+  ('superadmin@tria.com', 'superadmin', 'Super Admin', 'employee')
+) v(email, username, display, user_type)
 where not exists (select 1 from iam.users u where u.email = v.email);
 
 -- ── Credentials ──────────────────────────────────────────────────────────────
diff --git a/e2e/freight/cypress/support/commands.ts b/e2e/freight/cypress/support/commands.ts
index 47eacfc7a..43566075b 100644
--- a/e2e/freight/cypress/support/commands.ts
+++ b/e2e/freight/cypress/support/commands.ts
@@ -21,11 +21,17 @@ export interface LoginBody {
 const apiUrl = () => Cypress.env("apiUrl") as string;
 const password = () => Cypress.env("defaultPassword") as string;
 
-function apiLogin(email: string, pass?: string): Cypress.Chainable<LoginBody> {
+function apiLogin(
+  email: string,
+  pass?: string,
+  app: "backoffice" | "portal" = "backoffice",
+): Cypress.Chainable<LoginBody> {
   return cy
-    .request<LoginBody>("POST", `${apiUrl()}/api/auth/login`, {
-      email,
-      password: pass ?? password(),
+    .request<LoginBody>({
+      method: "POST",
+      url: `${apiUrl()}/api/auth/login`,
+      body: { email, password: pass ?? password() },
+      headers: { "x-client-app": app },
     })
     .then((response) => {
       expect(response.status).to.eq(201);
@@ -38,7 +44,7 @@ function sessionFor(app: "backoffice" | "portal", email: string, pass?: string)
   cy.session(
     [app, email],
     () => {
-      apiLogin(email, pass).then(({ token, refreshToken }) => {
+      apiLogin(email, pass, app).then(({ token, refreshToken }) => {
         cy.setCookie("auth-token", token);
         cy.setCookie("refresh-token", refreshToken);
       });
@@ -60,7 +66,11 @@ function sessionFor(app: "backoffice" | "portal", email: string, pass?: string)
   );
 }
 
-Cypress.Commands.add("apiLogin", (email: string, pass?: string) => apiLogin(email, pass));
+Cypress.Commands.add(
+  "apiLogin",
+  (email: string, pass?: string, app: "backoffice" | "portal" = "backoffice") =>
+    apiLogin(email, pass, app),
+);
 
 Cypress.Commands.add("loginBackoffice", (email = "ceo@edr.local", pass?: string) => {
   sessionFor("backoffice", email, pass);
@@ -260,7 +270,11 @@ declare global {
   namespace Cypress {
     interface Chainable {
       /** POST /api/auth/login, returns the flattened token body. */
-      apiLogin(email: string, pass?: string): Chainable<LoginBody>;
+      apiLogin(
+        email: string,
+        pass?: string,
+        app?: "backoffice" | "portal",
+      ): 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). */
diff --git a/packages/types/src/freight/contracts.ts b/packages/types/src/freight/contracts.ts
index b5a9b6bdb..10359761e 100644
--- a/packages/types/src/freight/contracts.ts
+++ b/packages/types/src/freight/contracts.ts
@@ -78,6 +78,9 @@ export const CONTRACT_STATUSES = [
   "CLEARANCE_UNDER_REVIEW",
   "CLEARANCE_READY_FOR_BOOKING",
   "ACTIVE_SHIPMENT_IN_PROGRESS",
+  // Backoffice froze the contract post-signature. Reversible: the pre-suspension
+  // status is kept in statusBeforeSuspension and restored on resume.
+  "SUSPENDED",
   // terminal
   "CONTRACT_CLOSED",
   "EXPIRED",
@@ -749,6 +752,9 @@ export interface IContract extends BaseEntity {
   contractValidUntil?: string | null;
   expiresAt?: string | null;
 
+  /** When the customer last submitted this contract for review. */
+  submittedAt?: string | null;
+
   status: ContractStatus;
   /**
    * Body of the latest staff CHANGES_REQUESTED review note (detail response
@@ -768,6 +774,18 @@ export interface IContract extends BaseEntity {
    * Tells the returned-to approver why the chain came back to them.
    */
   latestSendBackNote?: string | null;
+  /** Status the contract returns to when a suspension is lifted. */
+  statusBeforeSuspension?: ContractStatus | null;
+  /**
+   * Body of the latest SUSPENSION review note (detail response only, while
+   * SUSPENDED). Shown to both staff and customer.
+   */
+  latestSuspensionNote?: string | null;
+  /**
+   * Bookings on this contract that are not in a terminal state (detail response
+   * only). The portal's cancel action is blocked while this is > 0.
+   */
+  activeBookingCount?: number;
   clearanceStatus: ContractClearanceStatus;
   clearanceCycleNumber: number;
   /**
diff --git a/packages/types/src/freight/index.ts b/packages/types/src/freight/index.ts
index addaee965..bd31769d1 100644
--- a/packages/types/src/freight/index.ts
+++ b/packages/types/src/freight/index.ts
@@ -326,6 +326,8 @@ export enum WagonMovementKind {
   EmptyReposition = "EMPTY_REPOSITION",
   /** Staff manually corrected/updated the wagon's yard. */
   Manual = "MANUAL",
+  /** Detached from a train and put out of service for maintenance. */
+  Maintenance = "MAINTENANCE",
 }
 
 export interface IWagonMovement extends BaseEntity {
@@ -781,12 +783,32 @@ export interface ClearanceView {
   /** Boundary milestone complete — customer may proceed to operations. */
   operationReady?: boolean;
   preClearanceFinalized?: boolean;
+  /**
+   * Pre-declaration handshake with GL Djibouti: who handles this shipment in
+   * transit. `name` stays null until Djibouti answers, and GL Ethiopia cannot
+   * file the import customs declaration before it is set.
+   */
+  transitAssignee?: {
+    requestedAt: string | null;
+    requestNote: string | null;
+    name: string | null;
+    assignedAt: string | null;
+  } | null;
   dutyAdvice?: {
     amount: number;
     currency: string;
     declarationSerial?: string | null;
     noticeFile?: { id: string; name: string; url: string } | null;
   } | null;
+  /**
+   * The customer's open objection to the advised duty. Present only until GL
+   * re-advises; `rounds` counts how many times it has been sent back.
+   */
+  dutyDispute?: {
+    note: string;
+    raisedAt: string;
+    rounds: number;
+  } | null;
   /** Phased customs uploads (IM4, DO, transit permit, etc.) with friendly labels. */
   workflowFiles?: import("./clearance-files.catalog").ClearanceWorkflowFile[];
   /** Import post-allocation T1 transit document state (null until wagon allocation). */
diff --git a/reset-bookings-trains.sql b/reset-bookings-trains.sql
new file mode 100644
index 000000000..4efb0483d
--- /dev/null
+++ b/reset-bookings-trains.sql
@@ -0,0 +1,76 @@
+-- edr_dev reset: drop every contract booking, every schedule/built train,
+-- and hand the whole fleet back as AVAILABLE.
+-- Deliberately KEPT: contracts, companies, rates, yards, routes, the 5 wagons
+-- and 7 locomotives parked in MAINTENANCE / OUT_OF_SERVICE, and the single
+-- contract-less draft booking BK-2026-000011.
+BEGIN;
+
+-- 1. Detach the fleet FIRST — wagons point at trains, consists and schedules.
+UPDATE freight.wagons
+   SET train_id = NULL,
+       current_train_schedule_id = NULL,
+       train_set_wagon_id = NULL,
+       sequence_number = NULL,
+       import_train_number = NULL,
+       export_train_number = NULL,
+       status = 'AVAILABLE',
+       updated_at = now()
+ WHERE deleted_at IS NULL
+   AND status <> 'MAINTENANCE';
+
+UPDATE freight.locomotives
+   SET status = 'AVAILABLE',
+       updated_at = now()
+ WHERE deleted_at IS NULL
+   AND status NOT IN ('MAINTENANCE', 'OUT_OF_SERVICE');
+
+-- 2. Booking-scoped rows (allocations, batch offers, movements, documents).
+DELETE FROM freight.train_schedule_bookings;
+DELETE FROM freight.booking_batch_offers;
+DELETE FROM freight.wagon_booking_allocations;
+DELETE FROM freight.wagon_allocation_bulk_loads;
+DELETE FROM freight.booking_container_allocations;
+DELETE FROM freight.wagon_movements;
+DELETE FROM freight.customer_truck_containers;
+DELETE FROM freight.customer_truck_assignments;
+DELETE FROM freight.interchange_document_items;
+DELETE FROM freight.facility_handling_events;
+DELETE FROM freight.booking_handovers;
+DELETE FROM freight.clearance_incidents;
+DELETE FROM freight.clearance_milestones WHERE booking_id IS NOT NULL;
+DELETE FROM freight.booking_document_review;
+DELETE FROM freight.booking_contract_signatures;
+DELETE FROM freight.booking_review_note;
+DELETE FROM freight.booking_cargo_modifier;
+DELETE FROM freight.booking_rate_snapshot;
+DELETE FROM freight.containers WHERE booking_id IS NOT NULL;
+DELETE FROM freight.booking_container;
+DELETE FROM freight.cargoes WHERE booking_id IS NOT NULL;
+DELETE FROM freight.first_mile;
+DELETE FROM freight.last_mile;
+DELETE FROM freight.booking_requests;
+
+-- 3. Billing raised for those bookings.
+DELETE FROM freight.invoice_lines
+ WHERE invoice_id IN (SELECT id FROM freight.invoices WHERE source = 'booking');
+UPDATE freight.invoices SET payment_id = NULL WHERE source = 'booking';
+DELETE FROM freight.payment_refunds;
+DELETE FROM freight.invoices WHERE source = 'booking';
+DELETE FROM freight.payments;
+
+-- 4. The bookings themselves (self-FK cleared first).
+UPDATE freight.bookings SET consolidation_partner_id = NULL WHERE contract_id IS NOT NULL;
+DELETE FROM freight.bookings WHERE contract_id IS NOT NULL;
+
+-- 5. Schedules, built trains and consists.
+DELETE FROM freight.train_checkpoint_events;
+DELETE FROM freight.djibouti_import_incidents;
+DELETE FROM freight.import_djibouti_operations;
+DELETE FROM freight.train_schedules;
+DELETE FROM freight.train_set_wagons;
+DELETE FROM freight.train_set_locomotives;
+DELETE FROM freight.train_sets;
+DELETE FROM freight.train_locomotives;
+DELETE FROM freight.trains;
+
+COMMIT;